Mirrors_Framework/FreeRTOS
1
0
Fork 0
mirror of https://github.com/FreeRTOS/FreeRTOS.git synced 2026-09-21 10:33:55 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

Update trace recorder source to fix some compile time warnings.

Browse Source
This commit is contained in:
Richard Barry
2017-06-01 14:16:16 +00:00
parent 2307bc9dfa
commit b6f2402f3f
21 changed files with 3 additions and 5935 deletions
Download Patch File Download Diff File Expand all files Collapse all files
FreeRTOS-Plus/Source/FreeRTOS-Plus-Trace(streaming)/Demo.c
-566
View File
File diff suppressed because it is too large Load Diff
FreeRTOS-Plus/Source/FreeRTOS-Plus-Trace(streaming)/Release notes.txt
-45
View File
@@ -1,45 +0,0 @@
Release notes, Trace Recorder Library for Tracealyzer v3.0.2
September 29, 2015. Percepio AB.
Changes:
v3.0.2
- Fixed bug in tracing of nested interrupts.
- Made locally used variables and functions static.
v3.0.1
- Added vTraceOnTraceBegin()/vTraceOnTraceEnd() in trcKernelPort.c to allow custom cleanup via macros TRC_STREAM_PORT_ON_TRACE_BEGIN()/TRC_STREAM_PORT_ON_TRACE_END().
v3.0.0
- Modified trcTCPIP functions to take bytes written/read as parameters and instead return potential errors.
- Added vTraceOnTraceBegin()/vTraceOnTraceEnd() in trcKernelPort that in turn uses macros from trcStreamPort.h to allow transfer method defined (as well as user defined) actions where appropriate. Currently only used by TCP/IP to re-initialize the paged event buffer so no old data is sent on trace start.
v2.8.6
- Changed void* to uint32_t to ensure 32bit for vTraceStoreEvent1(), vTraceStoreEvent2() and vTraceStoreEvent3().
- Added prefix TRC to most macros to avoid conflicts.
- Moved all trace stream macros to trcStreamPort.h.
- Now allows users to define their own trace stream macros. First specify TRC_RECORDER_TRANSFER_METHOD_CUSTOM and then modify the TRC_STREAM_CUSTOM_XXXXXXXXX macros.
- Added trcPagedEventBuffer that can be used to avoid endless recursion for trace stream methods that use kernel objects (semaphores, mutexes) when sending data.
- Added trcTCPIP/trcTCPIPConfig for easy trace stream integration with custom TCP/IP stacks.
v2.8.5
- Added internal OS tick counter that can be used by certain kernel ports to keep track of the actual OS tick, in case it can be delayed.
- Updated generic macro names.
- Removed usage of strlen().
- Added support for width and padding formats for %d, %u, %x and %X.
- Reduced RAM usage for certain cases by redefining unused buffers.
- Fixed traceTAKE_MUTEX_RECURSIVE_FAILED being called traceTAKE_MUTEX_RECURSIVE resulting in duplicate defines.
- Implemented fix for missing parameter "xCopyPosition" when using "xSemaphoreGiveFromISR()" in FreeRTOS v8.
- Added prefix to internal defines to avoid conflicts.
- Fixed possible memory alignment issue which could cause hard fault.
- Made sure TzCtrl runs every 100ms instead of every 100 OS ticks.
- Moved project specific includes to trcConfig.h.
- Added a few backwards compatibility macros.
v2.8.2
- Improved vTracePrintF() parsing.
- Added vTracePrint() that performs no formatting.
- Removed need for passing parameter to vTraceStoreISREnd() on embOS port. This parameter is detected automatically.
- Added vTraceStoreISREndManual(param) that can be used on kernel ports that doesn't automatically detect pending task switches after interrupts.
v2.8.1
- New J-Link drivers fixes the RTT Buffer Index != 0 issue.
- trcRecorder.c hotfixed to handle missing defines in embOS that haven't made it to release yet.
v2.8.0
- Initial release. Only RTT Buffer Index 0 works in this version.
For questions, contact support@percepio.com or sales@percepio.com
FreeRTOS-Plus/Source/FreeRTOS-Plus-Trace(streaming)/SEGGER_RTT.c
-591
View File
File diff suppressed because it is too large Load Diff
FreeRTOS-Plus/Source/FreeRTOS-Plus-Trace(streaming)/SEGGER_RTT.h
-110
View File
@@ -1,110 +0,0 @@
/*********************************************************************
* SEGGER MICROCONTROLLER SYSTEME GmbH *
* Solutions for real time microcontroller applications *
**********************************************************************
* *
* (c) 1996-2014 SEGGER Microcontroller Systeme GmbH *
* *
* Internet: www.segger.com Support: support@segger.com *
* *
**********************************************************************
----------------------------------------------------------------------
File : SEGGER_RTT.h
Date : 17 Dec 2014
Purpose : Implementation of SEGGER real-time terminal which allows
real-time terminal communication on targets which support
debugger memory accesses while the CPU is running.
---------------------------END-OF-HEADER------------------------------
*/
/*********************************************************************
*
* Defines
*
**********************************************************************
*/
#define SEGGER_RTT_MODE_MASK (3 << 0)
#define SEGGER_RTT_MODE_NO_BLOCK_SKIP (0)
#define SEGGER_RTT_MODE_NO_BLOCK_TRIM (1 << 0)
#define SEGGER_RTT_MODE_BLOCK_IF_FIFO_FULL (1 << 1)
#define RTT_CTRL_RESET ""
#define RTT_CTRL_CLEAR ""
#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 ""
/*********************************************************************
*
* RTT API functions
*
**********************************************************************
*/
int SEGGER_RTT_Read (unsigned BufferIndex, char* pBuffer, unsigned BufferSize);
int SEGGER_RTT_Write (unsigned BufferIndex, const char* pBuffer, unsigned NumBytes);
int SEGGER_RTT_WriteString (unsigned BufferIndex, const char* s);
int SEGGER_RTT_GetKey (void);
int SEGGER_RTT_WaitKey (void);
int SEGGER_RTT_HasKey (void);
int SEGGER_RTT_ConfigUpBuffer (unsigned BufferIndex, const char* sName, char* pBuffer, int BufferSize, int Flags);
int SEGGER_RTT_ConfigDownBuffer (unsigned BufferIndex, const char* sName, char* pBuffer, int BufferSize, int Flags);
void SEGGER_RTT_Init (void);
/*********************************************************************
*
* RTT "Terminal" API functions
*
**********************************************************************
*/
void 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, ...);
/*************************** End of file ****************************/
FreeRTOS-Plus/Source/FreeRTOS-Plus-Trace(streaming)/SEGGER_RTT_Conf.h
-57
View File
@@ -1,57 +0,0 @@
/*********************************************************************
* SEGGER MICROCONTROLLER SYSTEME GmbH *
* Solutions for real time microcontroller applications *
**********************************************************************
* *
* (c) 1996-2014 SEGGER Microcontroller Systeme GmbH *
* *
* Internet: www.segger.com Support: support@segger.com *
* *
**********************************************************************
----------------------------------------------------------------------
File : SEGGER_RTT_Conf.h
Date : 17 Dec 2014
Purpose : Implementation of SEGGER real-time terminal which allows
real-time terminal communication on targets which support
debugger memory accesses while the CPU is running.
---------------------------END-OF-HEADER------------------------------
*/
/*********************************************************************
*
* Defines, configurable
*
**********************************************************************
*/
#define SEGGER_RTT_MAX_NUM_UP_BUFFERS (2) // Max. number of up-buffers (T->H) available on this target (Default: 2)
#define SEGGER_RTT_MAX_NUM_DOWN_BUFFERS (2) // Max. number of down-buffers (H->T) available on this target (Default: 2)
#define BUFFER_SIZE_UP (10 * 1024) // Size of the buffer for terminal output of target, up to host (Default: 1k)
#define BUFFER_SIZE_DOWN (32) // Size of the buffer for terminal input to target from host (Usually keyboard input) (Default: 16)
#define SEGGER_RTT_PRINTF_BUFFER_SIZE (64) // Size of buffer for RTT printf to bulk-send chars via RTT (Default: 64)
//
// 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.
//
#define SEGGER_RTT_LOCK()
#define SEGGER_RTT_UNLOCK()
//
// Define SEGGER_RTT_IN_RAM as 1
// when using RTT in RAM targets (init and data section both in RAM).
// This prevents the host to falsly identify the RTT Callback Structure
// in the init segment as the used Callback Structure.
//
// When defined as 1,
// the first call to an RTT function will modify the ID of the RTT Callback Structure.
// To speed up identifying on the host,
// especially when RTT functions are not called at the beginning of execution,
// SEGGER_RTT_Init() should be called at the start of the application.
//
#define SEGGER_RTT_IN_RAM (0)
/*************************** End of file ****************************/
FreeRTOS-Plus/Source/FreeRTOS-Plus-Trace(streaming)/SEGGER_RTT_Printf.c
-443
View File
@@ -1,443 +0,0 @@
/*********************************************************************
* SEGGER MICROCONTROLLER GmbH & Co. KG *
* Solutions for real time microcontroller applications *
**********************************************************************
* *
* (c) 2014-2014 SEGGER Microcontroller GmbH & Co. KG *
* *
* Internet: www.segger.com Support: support@segger.com *
* *
**********************************************************************
----------------------------------------------------------------------
File : SEGGER_RTT_printf.c
Date : 17 Dec 2014
Purpose : Replacement for printf to write formatted data via RTT
---------------------------END-OF-HEADER------------------------------
*/
#include "SEGGER_RTT.h"
#include "SEGGER_RTT_Conf.h"
/*********************************************************************
*
* Defines, configurable
*
**********************************************************************
*/
#ifndef SEGGER_RTT_PRINTF_BUFFER_SIZE
#define SEGGER_RTT_PRINTF_BUFFER_SIZE (64)
#endif
#include <stdlib.h>
#include <stdarg.h>
#define FORMAT_FLAG_LEFT_JUSTIFY (1 << 0)
#define FORMAT_FLAG_PAD_ZERO (1 << 1)
#define FORMAT_FLAG_PRINT_SIGN (1 << 2)
#define FORMAT_FLAG_ALTERNATE (1 << 3)
/*********************************************************************
*
* Types
*
**********************************************************************
*/
typedef struct {
char* pBuffer;
int BufferSize;
int Cnt;
int ReturnValue;
unsigned RTTBufferIndex;
} SEGGER_RTT_PRINTF_DESC;
/*********************************************************************
*
* Function prototypes
*
**********************************************************************
*/
int SEGGER_RTT_vprintf(unsigned BufferIndex, const char * sFormat, va_list * pParamList);
/*********************************************************************
*
* Static code
*
**********************************************************************
*/
/*********************************************************************
*
* _StoreChar
*/
static void _StoreChar(SEGGER_RTT_PRINTF_DESC * p, char c) {
int Cnt;
Cnt = p->Cnt;
if ((Cnt + 1) <= p->BufferSize) {
*(p->pBuffer + Cnt) = c;
p->Cnt = Cnt + 1;
p->ReturnValue++;
}
//
// Write part of string, when the buffer is full
//
if (p->Cnt == p->BufferSize) {
if (SEGGER_RTT_Write(p->RTTBufferIndex, p->pBuffer, p->Cnt) != p->Cnt) {
p->ReturnValue = -1;
} else {
p->Cnt = 0;
}
}
}
/*********************************************************************
*
* _PrintUnsigned
*/
static void _PrintUnsigned(SEGGER_RTT_PRINTF_DESC * pBufferDesc, unsigned v, unsigned Base, int NumDigits, unsigned FieldWidth, unsigned FormatFlags) {
static const char _aV2C[16] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
unsigned Div;
unsigned Digit = 1;
unsigned Number;
unsigned Width;
char c;
Number = v;
//
// Get actual field width
//
Width = 1;
while (Number >= Base) {
Number = (Number / Base);
Width++;
}
if ((unsigned)NumDigits > Width) {
Width = NumDigits;
}
//
// Print leading chars if necessary
//
if ((FormatFlags & FORMAT_FLAG_LEFT_JUSTIFY) == 0) {
if (FieldWidth != 0) {
if (((FormatFlags & FORMAT_FLAG_PAD_ZERO) == FORMAT_FLAG_PAD_ZERO) && (NumDigits == 0)) {
c = '0';
} else {
c = ' ';
}
while ((FieldWidth != 0) && (Width < FieldWidth--)) {
_StoreChar(pBufferDesc, c);
if (pBufferDesc->ReturnValue < 0) {
return;
}
}
}
}
//
// Count how many digits are required by precision
//
while (((v / Digit) >= Base) | (NumDigits-- > 1)) {
Digit *= Base;
}
//
// Output digits
//
do {
Div = v / Digit;
v -= Div * Digit;
_StoreChar(pBufferDesc, _aV2C[Div]);
if (pBufferDesc->ReturnValue < 0) {
break;
}
Digit /= Base;
} while (Digit);
//
// Print trailing spaces if necessary
//
if ((FormatFlags & FORMAT_FLAG_LEFT_JUSTIFY) == FORMAT_FLAG_LEFT_JUSTIFY) {
if (FieldWidth != 0) {
while ((FieldWidth != 0) && (Width < FieldWidth--)) {
_StoreChar(pBufferDesc, ' ');
if (pBufferDesc->ReturnValue < 0) {
return;
}
}
}
}
}
/*********************************************************************
*
* _PrintInt
*/
static void _PrintInt(SEGGER_RTT_PRINTF_DESC * pBufferDesc, int v, unsigned Base, unsigned NumDigits, unsigned FieldWidth, unsigned FormatFlags) {
unsigned Width;
unsigned Number;
Number = (v < 0) ? -v : v;
//
// Get actual field width
//
Width = 1;
while (Number >= Base) {
Number = (Number / Base);
Width++;
}
if (NumDigits > Width) {
Width = NumDigits;
}
if ((FieldWidth > 0) && ((v < 0) || ((FormatFlags & FORMAT_FLAG_PRINT_SIGN) == FORMAT_FLAG_PRINT_SIGN))) {
FieldWidth--;
}
//
// Print leading spaces if necessary
//
if ((((FormatFlags & FORMAT_FLAG_PAD_ZERO) == 0) || (NumDigits != 0)) && ((FormatFlags & FORMAT_FLAG_LEFT_JUSTIFY) == 0)) {
if (FieldWidth != 0) {
while ((FieldWidth != 0) && (Width < FieldWidth--)) {
_StoreChar(pBufferDesc, ' ');
if (pBufferDesc->ReturnValue < 0) {
return;
}
}
}
}
//
// Print sign if necessary
//
if (v < 0) {
v = -v;
_StoreChar(pBufferDesc, '-');
if (pBufferDesc->ReturnValue < 0) {
return;
}
} else if ((FormatFlags & FORMAT_FLAG_PRINT_SIGN) == FORMAT_FLAG_PRINT_SIGN) {
_StoreChar(pBufferDesc, '+');
if (pBufferDesc->ReturnValue < 0) {
return;
}
}
//
// Print leading zeros if necessary
//
if (((FormatFlags & FORMAT_FLAG_PAD_ZERO) == FORMAT_FLAG_PAD_ZERO) && ((FormatFlags & FORMAT_FLAG_LEFT_JUSTIFY) == 0) && (NumDigits == 0)) {
if (FieldWidth != 0) {
while ((FieldWidth != 0) && (Width < FieldWidth--)) {
_StoreChar(pBufferDesc, '0');
if (pBufferDesc->ReturnValue < 0) {
return;
}
}
}
}
//
// Print number without sign
//
_PrintUnsigned(pBufferDesc, v, Base, NumDigits, FieldWidth, FormatFlags);
}
/*********************************************************************
*
* Public code
*
**********************************************************************
*/
/*********************************************************************
*
* SEGGER_RTT_vprintf
*
* Function description
* Stores a formatted string in SEGGER RTT control block.
* This data is read by the host.
*
* Parameters
* BufferIndex Index of "Up"-buffer to be used. (e.g. 0 for "Terminal")
* sFormat Pointer to format string
* pParamList Pointer to the list of arguments for the format string
*
* Return values
* >= 0: Number of bytes which have been stored in the "Up"-buffer.
* < 0: Error
*/
int SEGGER_RTT_vprintf(unsigned BufferIndex, const char * sFormat, va_list * pParamList) {
char c;
SEGGER_RTT_PRINTF_DESC BufferDesc;
int v;
unsigned NumDigits;
unsigned FormatFlags;
unsigned FieldWidth;
char acBuffer[SEGGER_RTT_PRINTF_BUFFER_SIZE];
BufferDesc.pBuffer = acBuffer;
BufferDesc.BufferSize = SEGGER_RTT_PRINTF_BUFFER_SIZE;
BufferDesc.Cnt = 0;
BufferDesc.RTTBufferIndex = BufferIndex;
BufferDesc.ReturnValue = 0;
do {
c = *sFormat++;
if (c == 0) {
break;
}
if (c == '%') {
//
// Filter out flags
//
FormatFlags = 0;
do {
c = *sFormat;
switch (c) {
case '-': FormatFlags |= FORMAT_FLAG_LEFT_JUSTIFY; sFormat++; break;
case '0': FormatFlags |= FORMAT_FLAG_PAD_ZERO; sFormat++; break;
case '+': FormatFlags |= FORMAT_FLAG_PRINT_SIGN; sFormat++; break;
case '#': FormatFlags |= FORMAT_FLAG_ALTERNATE; sFormat++; break;
default: goto FilterFieldWidth; break;
}
} while (1);
//
// filter out field with
//
FilterFieldWidth:
FieldWidth = 0;
do {
c = *sFormat;
if (c < '0' || c > '9') {
break;
}
sFormat++;
FieldWidth = FieldWidth * 10 + (c - '0');
} while (1);
//
// Filter out precision (number of digits to display)
//
NumDigits = 0;
c = *sFormat;
if (c == '.') {
sFormat++;
do {
c = *sFormat;
if (c < '0' || c > '9') {
break;
}
sFormat++;
NumDigits = NumDigits * 10 + (c - '0');
} while (1);
}
//
// Filter out length modifier
//
c = *sFormat;
do {
if (c == 'l' || c == 'h') {
c = *sFormat++;
continue;
}
break;
} while (1);
//
// Handle specifiers
//
switch (c) {
case 'c': {
char c0;
v = va_arg(*pParamList, int);
c0 = (char)v;
_StoreChar(&BufferDesc, c0);
break;
}
case 'd':
v = va_arg(*pParamList, int);
_PrintInt(&BufferDesc, v, 10, NumDigits, FieldWidth, FormatFlags);
break;
case 'u':
v = va_arg(*pParamList, int);
_PrintUnsigned(&BufferDesc, v, 10, NumDigits, FieldWidth, FormatFlags);
break;
case 'x':
case 'X':
v = va_arg(*pParamList, int);
_PrintUnsigned(&BufferDesc, v, 16, NumDigits, FieldWidth, FormatFlags);
break;
case 's':
{
const char * s = va_arg(*pParamList, const char *);
do {
c = *s++;
if (c == 0) {
break;
}
_StoreChar(&BufferDesc, c);
} while (BufferDesc.ReturnValue >= 0);
}
break;
case 'p':
v = va_arg(*pParamList, int);
_PrintUnsigned(&BufferDesc, v, 16, 8, 8, 0);
break;
case '%':
_StoreChar(&BufferDesc, '%');
break;
}
sFormat++;
} else {
_StoreChar(&BufferDesc, c);
}
} while (BufferDesc.ReturnValue >= 0);
if (BufferDesc.ReturnValue > 0) {
//
// Write remaining data, if any
//
if (BufferDesc.Cnt != 0) {
SEGGER_RTT_Write(BufferIndex, acBuffer, BufferDesc.Cnt);
}
BufferDesc.ReturnValue += BufferDesc.Cnt;
}
return BufferDesc.ReturnValue;
}
/*********************************************************************
*
* SEGGER_RTT_printf
*
* Function description
* Stores a formatted string in SEGGER RTT control block.
* This data is read by the host.
*
* Parameters
* BufferIndex Index of "Up"-buffer to be used. (e.g. 0 for "Terminal")
* sFormat Pointer to format string, followed by the arguments for conversion
*
* Return values
* >= 0: Number of bytes which have been stored in the "Up"-buffer.
* < 0: Error
*
* Notes
* (1) Conversion specifications have following syntax:
* %[flags][FieldWidth][.Precision]ConversionSpecifier
* (2) Supported flags:
* -: Left justify within the field width
* +: Always print sign extension for signed conversions
* 0: Pad with 0 instead of spaces. Ignored when using '-'-flag or precision
* Supported conversion specifiers:
* c: Print the argument as one char
* d: Print the argument as a signed integer
* u: Print the argument as an unsigned integer
* x: Print the argument as an hexadecimal integer
* s: Print the string pointed to by the argument
* p: Print the argument as an 8-digit hexadecimal integer. (Argument shall be a pointer to void.)
*/
int SEGGER_RTT_printf(unsigned BufferIndex, const char * sFormat, ...) {
va_list ParamList;
va_start(ParamList, sFormat);
return SEGGER_RTT_vprintf(BufferIndex, sFormat, &ParamList);
}
/*************************** End of file ****************************/
FreeRTOS-Plus/Source/FreeRTOS-Plus-Trace(streaming)/trcConfig.h
-326
View File
@@ -1,326 +0,0 @@
/*******************************************************************************
* Trace Recorder Library for Tracealyzer v3.0.2
* Percepio AB, www.percepio.com
*
* trcConfig.h
*
* Configuration parameters for the streaming version trace recorder library.
* Before using the trace recorder library, please check that the default
* settings are appropriate for your system, and if necessary adjust these.
*
* Terms of Use
* This software (the "Tracealyzer Recorder Library") is the intellectual
* property of Percepio AB and may not be sold or in other ways commercially
* redistributed without explicit written permission by Percepio AB.
*
* Separate conditions applies for the SEGGER branded source code included.
*
* The recorder library is free for use together with Percepio products.
* You may distribute the recorder library in its original form, but public
* distribution of modified versions require approval by Percepio AB.
*
* Disclaimer
* The trace tool and recorder library is being delivered to you AS IS and
* Percepio AB makes no warranty as to its use or performance. Percepio AB does
* not and cannot warrant the performance or results you may obtain by using the
* software or documentation. Percepio AB make no warranties, express or
* implied, as to noninfringement of third party rights, merchantability, or
* fitness for any particular purpose. In no event will Percepio AB, its
* technology partners, or distributors be liable to you for any consequential,
* incidental or special damages, including any lost profits or lost savings,
* even if a representative of Percepio AB has been advised of the possibility
* of such damages, or for any claim by any third party. Some jurisdictions do
* not allow the exclusion or limitation of incidental, consequential or special
* damages, or the exclusion of implied warranties or limitations on how long an
* implied warranty may last, so the above limitations may not apply to you.
*
* Tabs are used for indent in this file (1 tab = 4 spaces)
*
* Copyright Percepio AB, 2015.
* www.percepio.com
******************************************************************************/
#ifndef TRC_CONFIG_H
#define TRC_CONFIG_H
#ifdef __cplusplus
extern “C” {
#endif
/*******************************************************************************
* Configuration Macro: TRC_RECORDER_HARDWARE_PORT
*
* Specify what hardware is used.
*
* See trcHardwarePort.h for available ports, or to define your own.
******************************************************************************/
#define TRC_RECORDER_HARDWARE_PORT TRC_PORT_ARM_Cortex_M
/******************************************************************************
* BSP and other project specific includes
*
* Include the necessary header files.
*****************************************************************************/
#include "board.h"
/******************************************************************************
* TRC_FREERTOS_VERSION
*
* Specify what version of FreeRTOS that is used. This is necessary compensate
* for renamed symbols in the FreeRTOS kernel (does not build if incorrect).
*
* TRC_FREERTOS_VERSION_7_3_OR_7_4 (= 1) If using FreeRTOS v7.3.0 - v7.4.2
* TRC_FREERTOS_VERSION_7_5_OR_7_6 (= 2) If using FreeRTOS v7.5.0 - v7.6.0
* TRC_FREERTOS_VERSION_8_0_OR_LATER (= 3) If using FreeRTOS v8.0.0 or later
*****************************************************************************/
#define TRC_FREERTOS_VERSION_NOT_SET 0
#define TRC_FREERTOS_VERSION_7_3_OR_7_4 1
#define TRC_FREERTOS_VERSION_7_5_OR_7_6 2
#define TRC_FREERTOS_VERSION_8_0_OR_LATER 3
#define TRC_FREERTOS_VERSION TRC_FREERTOS_VERSION_8_0_OR_LATER
/*******************************************************************************
* Configuration Macro: TRC_SYMBOL_TABLE_SLOTS
*
* The maximum number of symbols names that can be stored. This includes:
* - Task names
* - Named ISRs (vTraceSetISRProperties)
* - Named kernel objects (vTraceStoreKernelObjectName)
* - User event channels (vTraceStoreUserEventChannelName)
*
* If this value is too small, not all symbol names will be stored and the
* trace display will be affected. In that case, there will be warnings
* (as User Events) from TzCtrl task, that monitors this.
******************************************************************************/
#define TRC_SYMBOL_TABLE_SLOTS 30
/*******************************************************************************
* Configuration Macro: TRC_SYMBOL_MAX_LENGTH
*
* The maximum length of symbol names, including:
* - Task names
* - Named ISRs (vTraceSetISRProperties)
* - Named kernel objects (vTraceStoreKernelObjectName)
* - User event channel names (vTraceStoreUserEventChannelName)
*
* If longer symbol names are used, they will be truncated by the recorder,
* which will affect the trace display. In that case, there will be warnings
* (as User Events) from TzCtrl task, that monitors this.
******************************************************************************/
#define TRC_SYMBOL_MAX_LENGTH 25
/*******************************************************************************
* Configuration Macro: TRC_OBJECT_DATA_SLOTS
*
* The maximum number of object data entries (used for task priorities) that can
* be stored at the same time. Must be sufficient for all tasks, otherwise there
* will be warnings (as User Events) from TzCtrl task, that monitors this.
******************************************************************************/
#define TRC_OBJECT_DATA_SLOTS 20
/*******************************************************************************
* Configuration Macro: TRC_RTT_UP_BUFFER_INDEX
*
* Defines the RTT buffer to use for writing the trace data. Make sure that
* the PC application has the same setting (File->Settings).
*
******************************************************************************/
#define TRC_RTT_UP_BUFFER_INDEX 0
/*******************************************************************************
* Configuration Macro: TRC_RTT_DOWN_BUFFER_INDEX
*
* Defines the RTT buffer to use for reading the trace data. Make sure that
* the PC application has the same setting (File->Settings).
*
******************************************************************************/
#define TRC_RTT_DOWN_BUFFER_INDEX 0
/*******************************************************************************
* Configuration Macro: TRC_CTRL_TASK_STACK_SIZE
*
* The stack size of the TzCtrl task, that receive commands.
* We are aiming to remove this extra task in future versions.
******************************************************************************/
#define TRC_CTRL_TASK_STACK_SIZE (configMINIMAL_STACK_SIZE * 2)
/*******************************************************************************
* Configuration Macro: TRC_CTRL_TASK_PRIORITY
*
* The priority of the TzCtrl task, that receive commands from.
* We are aiming to remove this extra task in future versions.
******************************************************************************/
#define TRC_CTRL_TASK_PRIORITY 1
/*******************************************************************************
* Configuration Macro: TRC_CTRL_TASK_DELAY
*
* The delay between every loop of the TzCtrl task. A high delay will reduce the
* CPU load, but may cause missed events if the TzCtrl task is performing the
* trace transfer.
******************************************************************************/
#define TRC_CTRL_TASK_DELAY ((10 * configTICK_RATE_HZ) / 1000)
/*******************************************************************************
* Configuration Macro: TRC_MEASURE_BLOCKING_TIME
*
* If using SEGGER_RTT_MODE_BLOCK_IF_FIFO_FULL, this activates detection and
* warnings in case of blocking in SEGGER_RTT_Write (if too small buffer).
*
* If enabling this option (set to 1) warnings are given as User Events if
* blocking occurs, including the longest blocking time. These warnings are
* given on the channel "Blocking on trace buffer".
*
* Note: If you get such warnings, you can study the blocking time in the User
* Event Signal Plot to get an overview of the magnitude of the blocking and
* decide if acceptable.
*
* To eliminate or at least reduce occurrences of blocking:
*
* - Verify the J-Link Speed in the Settings dialog of the PC application.
* Default is 4 MHz, but can be increased a lot depending on your J-Link.
*
* Note: If you set the speed higher than your J-Link can manage, the J-Link
* driver will instead use the fastest supported speed. The actual speed used
* is shown in the title of the trace receiver window.
*
* - Increase the buffer size (BUFFER_SIZE_UP in SEGGER_RTT_Conf.h).
*
* - Reduce the amount of data produced, e.g., by removing frequent User Events.
******************************************************************************/
#define TRC_MEASURE_BLOCKING_TIME 0
/*******************************************************************************
* Configuration Macro: TRC_BLOCKING_MIN_CYCLES
*
* Threshold value for deciding if SEGGER_RTT_Write has blocked. Most events
* take 200-300 cycles on ARM Cortex-M MCUs, so anything above 500 cycles should
* be due to blocking on a full buffer (i.e., waiting for the debugger to read
* the RTT buffer data and make room for more...).
******************************************************************************/
#define TRC_BLOCKING_MIN_CYCLES 500
/*******************************************************************************
* Configuration Macro: TRC_RECORDER_BUFFER_ALLOCATION
*
* Specifies how the recorder buffer is allocated.
*
* Values:
* TRC_RECORDER_BUFFER_ALLOCATION_STATIC
* TRC_RECORDER_BUFFER_ALLOCATION_DYNAMIC
******************************************************************************/
#define TRC_RECORDER_BUFFER_ALLOCATION TRC_RECORDER_BUFFER_ALLOCATION_STATIC
/*******************************************************************************
* Configuration Macro: TRC_RECORDER_TRANSFER_METHOD
*
* Specifies what type of transfer method is used.
*
* Values:
* TRC_RECORDER_TRANSFER_METHOD_JLINK_RTT_BLOCK
* TRC_RECORDER_TRANSFER_METHOD_JLINK_RTT_NOBLOCK
* TRC_RECORDER_TRANSFER_METHOD_TCPIP
* TRC_RECORDER_TRANSFER_METHOD_CUSTOM
******************************************************************************/
#define TRC_RECORDER_TRANSFER_METHOD TRC_RECORDER_TRANSFER_METHOD_JLINK_RTT_BLOCK
/*******************************************************************************
* Configuration Macro: TRC_STREAM_CUSTOM_BLOCKING_TRANSFER
*
* Note: Only active if TRC_RECORDER_TRANSFER_METHOD_CUSTOM is used.
*
* Specifies how the custom transfer method handles full buffers.
*
* Values:
* 0 - The custom transfer method skips sending the data if the buffer is full.
* 1 - The custom transfer method blocks on send if the buffer is full.
******************************************************************************/
#define TRC_STREAM_CUSTOM_BLOCKING_TRANSFER
/*******************************************************************************
* Configuration Macro: TRC_STREAM_CUSTOM_ALLOCATE_FIELDS
*
* Note: Only active if TRC_RECORDER_TRANSFER_METHOD_CUSTOM is used.
*
* Macro that should allocate any buffers needed for the transfer method.
* See trcStreamPort.h for examples.
******************************************************************************/
#define TRC_STREAM_CUSTOM_ALLOCATE_FIELDS()
/*******************************************************************************
* Configuration Macro: TRC_STREAM_CUSTOM_INIT
*
* Note: Only active if TRC_RECORDER_TRANSFER_METHOD_CUSTOM is used.
*
* Used to initialize and set up the transfer method.
* See trcStreamPort.h for examples.
******************************************************************************/
#define TRC_STREAM_CUSTOM_INIT()
/*******************************************************************************
* Configuration Macro: TRC_STREAM_CUSTOM_ALLOCATE_EVENT
*
* Note: Only active if TRC_RECORDER_TRANSFER_METHOD_CUSTOM is used.
*
* Specifies how the trace events that should be sent using the transfer method
* are allocated first.
* See trcStreamPort.h for examples.
******************************************************************************/
#define TRC_STREAM_CUSTOM_ALLOCATE_EVENT(_type, _ptr, _size)
/*******************************************************************************
* Configuration Macro: TRC_STREAM_CUSTOM_COMMIT_EVENT
*
* Note: Only active if TRC_RECORDER_TRANSFER_METHOD_CUSTOM is used.
*
* Specifies how trace events are sent/written.
* See trcStreamPort.h for examples.
******************************************************************************/
#define TRC_STREAM_CUSTOM_COMMIT_EVENT(_ptr, _size)
/*******************************************************************************
* Configuration Macro: TRC_STREAM_CUSTOM_READ_DATA
*
* Note: Only active if TRC_RECORDER_TRANSFER_METHOD_CUSTOM is used.
*
* Specifies how data is read using the transfer method.
* See trcStreamPort.h for examples.
******************************************************************************/
#define TRC_STREAM_CUSTOM_READ_DATA(_ptrData, _size, _ptrBytesRead)
/*******************************************************************************
* Configuration Macro: TRC_STREAM_CUSTOM_PERIODIC_SEND_DATA
*
* Note: Only active if TRC_RECORDER_TRANSFER_METHOD_CUSTOM is used.
*
* Specifies how data is sent periodically. Used by certain transfer methods.
* See trcStreamPort.h for examples.
******************************************************************************/
#define TRC_STREAM_CUSTOM_PERIODIC_SEND_DATA(_ptrBytesSent)
/*******************************************************************************
* Configuration Macro: TRC_STREAM_CUSTOM_ON_TRACE_BEGIN
*
* Note: Only active if TRC_RECORDER_TRANSFER_METHOD_CUSTOM is used.
*
* Called on tracing is started. Use this to perform any necessary steps to
* properly start the trace, such as clearing buffers.
******************************************************************************/
#define TRC_STREAM_CUSTOM_ON_TRACE_BEGIN()
/*******************************************************************************
* Configuration Macro: TRC_STREAM_CUSTOM_ON_TRACE_END
*
* Note: Only active if TRC_RECORDER_TRANSFER_METHOD_CUSTOM is used.
*
* Called when tracing is disabled. Use this to perform any necessary steps to
* properly shut down the tracing, such as clearing buffers.
******************************************************************************/
#define TRC_STREAM_CUSTOM_ON_TRACE_END()
#ifdef __cplusplus
}
#endif
#endif /* TRC_CONFIG_H */
FreeRTOS-Plus/Source/FreeRTOS-Plus-Trace(streaming)/trcHardwarePort.h
-194
View File
@@ -1,194 +0,0 @@
/*******************************************************************************
* Trace Recorder Library for Tracealyzer v3.0.2
* Percepio AB, www.percepio.com
*
* trcHardwarePort.h
*
* The hardware abstraction layer for the trace recorder library.
*
* Terms of Use
* This software (the "Tracealyzer Recorder Library") is the intellectual
* property of Percepio AB and may not be sold or in other ways commercially
* redistributed without explicit written permission by Percepio AB.
*
* Separate conditions applies for the SEGGER branded source code included.
*
* The recorder library is free for use together with Percepio products.
* You may distribute the recorder library in its original form, but public
* distribution of modified versions require approval by Percepio AB.
*
* Disclaimer
* The trace tool and recorder library is being delivered to you AS IS and
* Percepio AB makes no warranty as to its use or performance. Percepio AB does
* not and cannot warrant the performance or results you may obtain by using the
* software or documentation. Percepio AB make no warranties, express or
* implied, as to noninfringement of third party rights, merchantability, or
* fitness for any particular purpose. In no event will Percepio AB, its
* technology partners, or distributors be liable to you for any consequential,
* incidental or special damages, including any lost profits or lost savings,
* even if a representative of Percepio AB has been advised of the possibility
* of such damages, or for any claim by any third party. Some jurisdictions do
* not allow the exclusion or limitation of incidental, consequential or special
* damages, or the exclusion of implied warranties or limitations on how long an
* implied warranty may last, so the above limitations may not apply to you.
*
* Tabs are used for indent in this file (1 tab = 4 spaces)
*
* Copyright Percepio AB, 2015.
* www.percepio.com
******************************************************************************/
#ifndef TRC_HARDWARE_PORT_H
#define TRC_HARDWARE_PORT_H
#ifdef __cplusplus
extern “C” {
#endif
#include <stdint.h>
/******************************************************************************
* Hardware ports
* To get accurate timestamping, a hardware timer is necessary. Below are the
* available ports. Some of these are "unofficial", meaning that
* they have not yet been verified by Percepio but have been contributed by
* external developers. They should work, otherwise let us know by emailing
* support@percepio.com. Some work on any OS platform, while other are specific
* to a certain operating system.
*****************************************************************************/
/****** Port Name ***************************** Code */
#define TRC_PORT_APPLICATION_DEFINED -1
#define TRC_PORT_NOT_SET 0
#define TRC_PORT_ARM_Cortex_M 1
#define TRC_PORT_ARM_CORTEX_A9 2
#define TRC_PORT_Renesas_RX600 3
#define TRC_PORT_TEXAS_INSTRUMENTS_TMS570_RM48 4
#define TRC_PORT_MICROCHIP_PIC32_MX_MZ 5
/*******************************************************************************
*
* HWTC Macros - Hardware Timer/Counter Isolation Layer
*
* These two HWTC macros provides a hardware isolation layer representing a
* generic hardware timer/counter used for the timestamping.
*
* HWTC_COUNT: The current value of the counter. This is expected to be reset
* a each tick interrupt. Thus, when the tick handler starts, the counter has
* already wrapped.
*
* HWTC_TYPE: Defines the type of timer/counter used for HWTC_COUNT:
*
* - FREE_RUNNING_32BIT_INCR:
* Free-running 32-bit timer, counting upwards from 0 - > 0xFFFFFFFF
*
* - FREE_RUNNING_32BIT_DECR
* Free-running 32-bit counter, counting downwards from 0xFFFFFFFF -> 0
*
* - OS_TIMER_INCR
* Interrupt timer, counts upwards from 0 until HWTC_PERIOD-1
*
* - OS_TIMER_DECR
* Interrupt timer, counts downwards from HWTC_PERIOD-1 until 0
*
*******************************************************************************
*
* IRQ_PRIORITY_ORDER
*
* Macro which should be defined as an integer of 0 or 1.
*
* It is only used only to sort and colorize the interrupts in priority order,
* in case you record interrupts using the vTraceStoreISRBegin and
* vTraceStoreISREnd routines. 1 indicates higher value is more important.
*
******************************************************************************/
#define TRC_FREE_RUNNING_32BIT_INCR 1
#define TRC_FREE_RUNNING_32BIT_DECR 2
#define TRC_OS_TIMER_INCR 3
#define TRC_OS_TIMER_DECR 4
#if (TRC_RECORDER_HARDWARE_PORT == TRC_PORT_ARM_Cortex_M)
#define HWTC_TYPE TRC_OS_TIMER_DECR
#define HWTC_COUNT (*((uint32_t*)0xE000E018)) /* SysTick counter */
#define IRQ_PRIORITY_ORDER 0
#elif (TRC_RECORDER_HARDWARE_PORT == TRC_PORT_Renesas_RX600)
#include "iodefine.h"
#define HWTC_TYPE TRC_OS_TIMER_INCR
#define HWTC_COUNT (CMT0.CMCNT)
#define IRQ_PRIORITY_ORDER 1
#elif (TRC_RECORDER_HARDWARE_PORT == TRC_PORT_MICROCHIP_PIC32_MX_MZ)
#define HWTC_TYPE TRC_OS_TIMER_INCR
#define HWTC_COUNT (TMR1)
#define IRQ_PRIORITY_ORDER 0
#elif (TRC_RECORDER_HARDWARE_PORT == TRC_PORT_TEXAS_INSTRUMENTS_TMS570_RM48)
#define RTIFRC0 *((uint32_t *)0xFFFFFC10)
#define RTICOMP0 *((uint32_t *)0xFFFFFC50)
#define RTIUDCP0 *((uint32_t *)0xFFFFFC54)
#define HWTC_TYPE TRC_OS_TIMER_INCR
#define HWTC_COUNT (RTIFRC0 - (RTICOMP0 - RTIUDCP0))
#define IRQ_PRIORITY_ORDER 0
#elif (TRC_RECORDER_HARDWARE_PORT == TRC_PORT_ARM_CORTEX_A9)
/* INPUT YOUR PERIPHERAL BASE ADDRESS HERE */
#define CA9_MPCORE_PERIPHERAL_BASE_ADDRESS 0xSOMETHING
#define CA9_MPCORE_PRIVATE_MEMORY_OFFSET 0x0600
#define CA9_MPCORE_PRIVCTR_PERIOD_REG (*(volatile uint32_t*)(CA9_MPCORE_PERIPHERAL_BASE_ADDRESS + CA9_MPCORE_PRIVATE_MEMORY_OFFSET + 0x00))
#define CA9_MPCORE_PRIVCTR_COUNTER_REG (*(volatile uint32_t*)(CA9_MPCORE_PERIPHERAL_BASE_ADDRESS + CA9_MPCORE_PRIVATE_MEMORY_OFFSET + 0x04))
#define CA9_MPCORE_PRIVCTR_CONTROL_REG (*(volatile uint32_t*)(CA9_MPCORE_PERIPHERAL_BASE_ADDRESS + CA9_MPCORE_PRIVATE_MEMORY_OFFSET + 0x08))
#define CA9_MPCORE_PRIVCTR_CONTROL_PRESCALER_MASK 0x0000FF00
#define CA9_MPCORE_PRIVCTR_CONTROL_PRESCALER_SHIFT 8
#define CA9_MPCORE_PRIVCTR_PRESCALER (((CA9_MPCORE_PRIVCTR_CONTROL_REG & CA9_MPCORE_PRIVCTR_CONTROL_PRESCALER_MASK) >> CA9_MPCORE_PRIVCTR_CONTROL_PRESCALER_SHIFT) + 1)
#define HWTC_TYPE TRC_OS_TIMER_DECR
#define HWTC_COUNT CA9_MPCORE_PRIVCTR_COUNTER_REG
#define IRQ_PRIORITY_ORDER 0
#elif (TRC_RECORDER_HARDWARE_PORT == TRC_PORT_APPLICATION_DEFINED)
#if !( defined (HWTC_TYPE) && defined (HWTC_COUNT) && defined (IRQ_PRIORITY_ORDER))
#error RECORDER_HARDWARE_PORT is PORT_APPLICATION_DEFINED but not all of the necessary constants have been defined.
#endif
#elif (TRC_RECORDER_HARDWARE_PORT != TRC_PORT_NOT_SET)
#error "RECORDER_HARDWARE_PORT had unsupported value!"
#define TRC_RECORDER_HARDWARE_PORT PORT_NOT_SET
#endif
#if (TRC_RECORDER_HARDWARE_PORT != TRC_PORT_NOT_SET)
#ifndef HWTC_COUNT
#error "HWTC_COUNT is not set!"
#endif
#ifndef HWTC_TYPE
#error "HWTC_TYPE is not set!"
#endif
#ifndef IRQ_PRIORITY_ORDER
#error "IRQ_PRIORITY_ORDER is not set!"
#elif (IRQ_PRIORITY_ORDER != 0) && (IRQ_PRIORITY_ORDER != 1)
#error "IRQ_PRIORITY_ORDER has bad value!"
#endif
#endif
#ifdef __cplusplus
}
#endif
#endif /* TRC_HARDWARE_PORT_H */
FreeRTOS-Plus/Source/FreeRTOS-Plus-Trace(streaming)/trcKernelPort.c
-267
View File
@@ -1,267 +0,0 @@
/*******************************************************************************
* Trace Recorder Library for Tracealyzer v3.0.2
* Percepio AB, www.percepio.com
*
* trcKernelPort.c
*
* The kernel-specific code for integration with FreeRTOS.
*
* Terms of Use
* This software (the "Tracealyzer Recorder Library") is the intellectual
* property of Percepio AB and may not be sold or in other ways commercially
* redistributed without explicit written permission by Percepio AB.
*
* Separate conditions applies for the SEGGER branded source code included.
*
* The recorder library is free for use together with Percepio products.
* You may distribute the recorder library in its original form, but public
* distribution of modified versions require approval by Percepio AB.
*
* Disclaimer
* The trace tool and recorder library is being delivered to you AS IS and
* Percepio AB makes no warranty as to its use or performance. Percepio AB does
* not and cannot warrant the performance or results you may obtain by using the
* software or documentation. Percepio AB make no warranties, express or
* implied, as to noninfringement of third party rights, merchantability, or
* fitness for any particular purpose. In no event will Percepio AB, its
* technology partners, or distributors be liable to you for any consequential,
* incidental or special damages, including any lost profits or lost savings,
* even if a representative of Percepio AB has been advised of the possibility
* of such damages, or for any claim by any third party. Some jurisdictions do
* not allow the exclusion or limitation of incidental, consequential or special
* damages, or the exclusion of implied warranties or limitations on how long an
* implied warranty may last, so the above limitations may not apply to you.
*
* Tabs are used for indent in this file (1 tab = 4 spaces)
*
* Copyright Percepio AB, 2015.
* www.percepio.com
******************************************************************************/
#include "trcKernelPort.h"
#if (USE_TRACEALYZER_RECORDER == 1)
#include <stdint.h>
#include "trcRecorder.h"
#include "trcStreamPort.h"
#include "task.h"
/* TzCtrl task TCB */
static xTaskHandle HandleTzCtrl;
/* Called by TzCtrl task periodically (every 100 ms) */
static void CheckRecorderStatus(void);
/* The TzCtrl task - receives commands from Tracealyzer (start/stop) */
static portTASK_FUNCTION( TzCtrl, pvParameters );
/* Monitored by TzCtrl task, that give warnings as User Events */
extern volatile uint32_t NoRoomForSymbol;
extern volatile uint32_t NoRoomForObjectData;
extern volatile uint32_t LongestSymbolName;
extern volatile uint32_t MaxBytesTruncated;
#define TRC_PORT_MALLOC(size) pvPortMalloc(size)
#if ((TRC_STREAM_PORT_BLOCKING_TRANSFER == 1) && (TRC_MEASURE_BLOCKING_TIME == 1))
/*** Used in blocking transfer mode, if enabled TRC_MEASURE_BLOCKING_TIME **************/
/* The highest number of cycles used by SEGGER_RTT_Write. */
static volatile int32_t blockingCyclesMax;
/* The number of times SEGGER_RTT_Write has blocked due to a full buffer. */
static volatile uint32_t blockingCount;
/* User Event Channel for giving warnings regarding blocking */
static char* trcDiagnosticsChannel;
#endif /*((TRC_STREAM_PORT_BLOCKING_TRANSFER==1) && (TRC_MEASURE_BLOCKING_TIME))*/
TRC_STREAM_PORT_ALLOCATE_FIELDS()
/* User Event Channel for giving warnings regarding NoRoomForSymbol etc. */
char* trcWarningChannel;
/* Keeps track of previous values, to only react on changes. */
static uint32_t NoRoomForSymbol_last = 0;
static uint32_t NoRoomForObjectData_last = 0;
static uint32_t LongestSymbolName_last = 0;
static uint32_t MaxBytesTruncated_last = 0;
/*******************************************************************************
* prvTraceGetCurrentTaskHandle
*
* Function that returns the handle to the currently executing task.
*
******************************************************************************/
void* prvTraceGetCurrentTaskHandle(void)
{
return xTaskGetCurrentTaskHandle();
}
/*******************************************************************************
* prvIsNewTCB
*
* Function that returns the handle to the currently executing task.
*
******************************************************************************/
static void* pCurrentTCB = NULL;
uint32_t prvIsNewTCB(void* pNewTCB)
{
if (pCurrentTCB != pNewTCB)
{
pCurrentTCB = pNewTCB;
return 1;
}
return 0;
}
/*******************************************************************************
* CheckRecorderStatus
*
* Called by TzCtrl task periodically (every 100 ms - seems reasonable).
* Checks a number of diagnostic variables and give warnings as user events,
* in most cases including a suggested solution.
******************************************************************************/
static void CheckRecorderStatus(void)
{
if (NoRoomForSymbol > NoRoomForSymbol_last)
{
vTracePrintF(trcWarningChannel, "TRC_SYMBOL_TABLE_SLOTS too small. Add %d slots.",
NoRoomForSymbol);
NoRoomForSymbol_last = NoRoomForSymbol;
}
if (NoRoomForObjectData > NoRoomForObjectData_last)
{
vTracePrintF(trcWarningChannel, "TRC_OBJECT_DATA_SLOTS too small. Add %d slots.",
NoRoomForObjectData);
NoRoomForObjectData_last = NoRoomForObjectData;
}
if (LongestSymbolName > LongestSymbolName_last)
{
if (LongestSymbolName > TRC_SYMBOL_MAX_LENGTH)
{
vTracePrintF(trcWarningChannel, "TRC_SYMBOL_MAX_LENGTH too small. Add %d chars.",
LongestSymbolName);
}
LongestSymbolName_last = LongestSymbolName;
}
if (MaxBytesTruncated > MaxBytesTruncated_last)
{
/* Some string event generated a too long string that was truncated.
This may happen for the following functions:
- vTracePrintF
- vTracePrintF
- vTraceStoreKernelObjectName
- vTraceStoreUserEventChannelName
- vTraceSetISRProperties
A PSF event may store maximum 60 bytes payload, including data arguments
and string characters. For User Events, also the User Event Channel ptr
must be squeezed in, if a channel is specified. */
vTracePrintF(trcWarningChannel, "String event too long, up to %d bytes truncated.",
MaxBytesTruncated);
MaxBytesTruncated_last = MaxBytesTruncated;
}
#if ((TRC_STREAM_PORT_BLOCKING_TRANSFER==1) && (TRC_MEASURE_BLOCKING_TIME))
if (blockingCount > 0)
{
/* At least one case of blocking since the last check and this is
the longest case. */
vTracePrintF(trcDiagnosticsChannel, "Longest since last: %d us",
(uint32_t)blockingCyclesMax/(TRACE_CPU_CLOCK_HZ/1000000));
blockingCyclesMax = 0;
}
#endif
}
/*******************************************************************************
* vTraceOnTraceBegin
*
* Called on trace begin.
******************************************************************************/
void vTraceOnTraceBegin(void)
{
TRC_STREAM_PORT_ON_TRACE_BEGIN();
}
/*******************************************************************************
* vTraceOnTraceEnd
*
* Called on trace end.
******************************************************************************/
void vTraceOnTraceEnd(void)
{
TRC_STREAM_PORT_ON_TRACE_END();
}
/*******************************************************************************
* TzCtrl
*
* Task for receiving commands from Tracealyzer and for recorder diagnostics.
*
******************************************************************************/
static portTASK_FUNCTION( TzCtrl, pvParameters )
{
TracealyzerCommandType msg;
int bytes = 0;
while (1)
{
bytes = 0;
TRC_STREAM_PORT_READ_DATA(&msg, sizeof(TracealyzerCommandType), &bytes);
if (bytes != 0)
{
if (bytes == sizeof(TracealyzerCommandType))
{
if (isValidCommand(&msg))
{
processCommand(&msg); /* Start or Stop currently... */
}
}
}
do
{
bytes = 0;
TRC_STREAM_PORT_PERIODIC_SEND_DATA(&bytes);
}
while (bytes != 0);
CheckRecorderStatus();
vTaskDelay(TRC_CTRL_TASK_DELAY); /* 10ms */
}
}
/*******************************************************************************
* Trace_Init
*
* The main initialization routine for the trace recorder. Configures the stream
* and activates the TzCtrl task.
* Also sets up the diagnostic User Event channels used by TzCtrl task.
*
******************************************************************************/
void Trace_Init(void)
{
TRC_STREAM_PORT_INIT();
trcWarningChannel = vTraceStoreUserEventChannelName("Warnings from Recorder");
#if ((TRC_STREAM_PORT_BLOCKING_TRANSFER==1) && (TRC_MEASURE_BLOCKING_TIME))
trcDiagnosticsChannel = vTraceStoreUserEventChannelName("Blocking on trace buffer");
#endif
/* Creates the TzCtrl task - receives trace commands (start, stop, ...) */
xTaskCreate( TzCtrl, "TzCtrl", configMINIMAL_STACK_SIZE, NULL, TRC_CTRL_TASK_PRIORITY, &HandleTzCtrl );
}
#endif
FreeRTOS-Plus/Source/FreeRTOS-Plus-Trace(streaming)/trcKernelPort.h
-929
View File
File diff suppressed because it is too large Load Diff
FreeRTOS-Plus/Source/FreeRTOS-Plus-Trace(streaming)/trcPagedEventBuffer.c
-302
View File
@@ -1,302 +0,0 @@
/*******************************************************************************
* Trace Recorder Library for Tracealyzer v3.0.2
* Percepio AB, www.percepio.com
*
* trcPagedEventBuffer.c
*
* Implements a paged buffer that can be used by TCP/IP or custom transfer
* methods.
*
* Terms of Use
* This software (the "Tracealyzer Recorder Library") is the intellectual
* property of Percepio AB and may not be sold or in other ways commercially
* redistributed without explicit written permission by Percepio AB.
*
* Separate conditions applies for the SEGGER branded source code included.
*
* The recorder library is free for use together with Percepio products.
* You may distribute the recorder library in its original form, but public
* distribution of modified versions require approval by Percepio AB.
*
* Disclaimer
* The trace tool and recorder library is being delivered to you AS IS and
* Percepio AB makes no warranty as to its use or performance. Percepio AB does
* not and cannot warrant the performance or results you may obtain by using the
* software or documentation. Percepio AB make no warranties, express or
* implied, as to noninfringement of third party rights, merchantability, or
* fitness for any particular purpose. In no event will Percepio AB, its
* technology partners, or distributors be liable to you for any consequential,
* incidental or special damages, including any lost profits or lost savings,
* even if a representative of Percepio AB has been advised of the possibility
* of such damages, or for any claim by any third party. Some jurisdictions do
* not allow the exclusion or limitation of incidental, consequential or special
* damages, or the exclusion of implied warranties or limitations on how long an
* implied warranty may last, so the above limitations may not apply to you.
*
* Tabs are used for indent in this file (1 tab = 4 spaces)
*
* Copyright Percepio AB, 2015.
* www.percepio.com
******************************************************************************/
#include <stdio.h>
#include <stdint.h>
#include <string.h>
#include "trcConfig.h"
#include "trcPagedEventBuffer.h"
#include "trcPagedEventBufferConfig.h"
#include "trcKernelPort.h"
uint32_t DroppedEventCounter = 0; // Total number of dropped events (failed allocations)
uint32_t TotalBytesRemaining_LowWaterMark = TRC_PAGED_EVENT_BUFFER_PAGE_COUNT * TRC_PAGED_EVENT_BUFFER_PAGE_SIZE;
#if (USE_TRACEALYZER_RECORDER == 1)
#define PAGE_STATUS_FREE 0
#define PAGE_STATUS_WRITE 1
#define PAGE_STATUS_READ 2
uint32_t TotalBytesRemaining = TRC_PAGED_EVENT_BUFFER_PAGE_COUNT * TRC_PAGED_EVENT_BUFFER_PAGE_SIZE;
typedef struct{
uint8_t Status;
uint16_t BytesRemaining;
char* WritePointer;
} PageType;
PageType PageInfo[TRC_PAGED_EVENT_BUFFER_PAGE_COUNT];
char* EventBuffer = NULL;
static void prvPageReadComplete(int pageIndex);
static int prvAllocateBufferPage(int prevPage);
static int prvAllocateBufferPage(int prevPage)
{
int index;
int count = 0;
index = (prevPage + 1) % TRC_PAGED_EVENT_BUFFER_PAGE_COUNT;
while((PageInfo[index].Status != PAGE_STATUS_FREE) && (count ++ < TRC_PAGED_EVENT_BUFFER_PAGE_COUNT))
{
index = (index + 1) % TRC_PAGED_EVENT_BUFFER_PAGE_COUNT;
}
if (PageInfo[index].Status == PAGE_STATUS_FREE)
{
return index;
}
return -1;
}
static void prvPageReadComplete(int pageIndex)
{
TRACE_ALLOC_CRITICAL_SECTION();
TRACE_ENTER_CRITICAL_SECTION();
PageInfo[pageIndex].BytesRemaining = TRC_PAGED_EVENT_BUFFER_PAGE_SIZE;
PageInfo[pageIndex].WritePointer = &EventBuffer[pageIndex * TRC_PAGED_EVENT_BUFFER_PAGE_SIZE];
PageInfo[pageIndex].Status = PAGE_STATUS_FREE;
TotalBytesRemaining += TRC_PAGED_EVENT_BUFFER_PAGE_SIZE;
TRACE_EXIT_CRITICAL_SECTION();
}
static int prvGetBufferPage(int32_t* bytesUsed)
{
static int8_t lastPage = -1;
int count = 0;
int8_t index = (lastPage + 1) % TRC_PAGED_EVENT_BUFFER_PAGE_COUNT;
while((PageInfo[index].Status != PAGE_STATUS_READ) && (count++ < TRC_PAGED_EVENT_BUFFER_PAGE_COUNT))
{
index = (index + 1) % TRC_PAGED_EVENT_BUFFER_PAGE_COUNT;
}
if (PageInfo[index].Status == PAGE_STATUS_READ)
{
*bytesUsed = TRC_PAGED_EVENT_BUFFER_PAGE_SIZE - PageInfo[index].BytesRemaining;
lastPage = index;
return index;
}
*bytesUsed = 0;
return -1;
}
/*******************************************************************************
int32_t vPagedEventBufferTransfer(int32_t (*writeFunc)(void* data,
uint32_t size),
int32_t* nofBytes)
Transfers one block of trace data, if available for reading. Returns the number
of bytes transfered, or a negative error code. If data was transferred (return
value > 0), it can be good to call this function again until all data available
has been transfered.
This function is intended to be called by a periodic task with a suitable
delay (e.g. 10-100 ms).
Example:
TickType_t lastWakeTime = xTaskGetTickCount();
while(1)
{
do{
// Transfer all available data
status = vPagedEventBufferTransfer(MyWrite, ptrBytes);
}while(status > 0);
if (status < 0)
{
// A negative return value is an error code...
}
vTraceDelayUntil(lastWakeTime, 50); // 50 ms -> 20 times/sec
}
Return value: returnvalue of writeFunc (0 == OK)
Parameters:
- writeFunc
Function pointer (example: int32_t write(void* data, uint32_t size))
The function passed as writeFunc should write "size" bytes from "data" to the
socket/file/channel, and return a status code where 0 means OK,
and any other non-zero value means an error.
- int32_t* nofBytes
Pointer to an integer assigned the number of bytes that was transfered.
*******************************************************************************/
int32_t vPagedEventBufferTransfer(int32_t (*writeFunc)(void* data, uint32_t size, int32_t* ptrBytesWritten), int32_t* nofBytes)
{
static int firstTime = 1;
int8_t pageToTransfer = -1;
pageToTransfer = prvGetBufferPage(nofBytes);
if (firstTime)
{
firstTime = 0;
}
if (pageToTransfer > -1)
{
if (writeFunc(&EventBuffer[pageToTransfer * TRC_PAGED_EVENT_BUFFER_PAGE_SIZE], *nofBytes, nofBytes) == 0)
{
prvPageReadComplete(pageToTransfer);
return 0;
}
else
{
return 1;
}
}
return 0;
}
/*******************************************************************************
void* vPagedEventBufferGetWritePointer(int sizeOfEvent)
Returns a pointer to an available location in the buffer able to store the
requested size.
Return value: The pointer.
Parameters:
- sizeOfEvent
The size of the event that is to be placed in the buffer.
*******************************************************************************/
void* vPagedEventBufferGetWritePointer(int sizeOfEvent)
{
void* ret;
static int currentWritePage = -1;
if (currentWritePage == -1)
{
currentWritePage = prvAllocateBufferPage(currentWritePage);
if (currentWritePage == -1)
{
DroppedEventCounter++;
return NULL;
}
}
if (PageInfo[currentWritePage].BytesRemaining - sizeOfEvent < 0)
{
PageInfo[currentWritePage].Status = PAGE_STATUS_READ;
TotalBytesRemaining -= PageInfo[currentWritePage].BytesRemaining; // Last trailing bytes
if (TotalBytesRemaining < TotalBytesRemaining_LowWaterMark)
TotalBytesRemaining_LowWaterMark = TotalBytesRemaining;
currentWritePage = prvAllocateBufferPage(currentWritePage);
if (currentWritePage == -1)
{
DroppedEventCounter++;
return NULL;
}
}
ret = PageInfo[currentWritePage].WritePointer;
PageInfo[currentWritePage].WritePointer += sizeOfEvent;
PageInfo[currentWritePage].BytesRemaining -= sizeOfEvent;
TotalBytesRemaining -= sizeOfEvent;
if (TotalBytesRemaining < TotalBytesRemaining_LowWaterMark)
TotalBytesRemaining_LowWaterMark = TotalBytesRemaining;
return ret;
}
/*******************************************************************************
void vPagedEventBufferInit(char* buffer)
Assigns the buffer to use and initializes the PageInfo structure.
Return value: void
Parameters:
- buffer
Pointer to the buffer location that is dynamically or statically allocated by
the caller.
*******************************************************************************/
void vPagedEventBufferInit(char* buffer)
{
TRACE_ALLOC_CRITICAL_SECTION();
int i;
EventBuffer = buffer;
TRACE_ENTER_CRITICAL_SECTION();
for (i = 0; i < TRC_PAGED_EVENT_BUFFER_PAGE_COUNT; i++)
{
PageInfo[i].BytesRemaining = TRC_PAGED_EVENT_BUFFER_PAGE_SIZE;
PageInfo[i].WritePointer = &EventBuffer[i * TRC_PAGED_EVENT_BUFFER_PAGE_SIZE];
PageInfo[i].Status = PAGE_STATUS_FREE;
}
TRACE_EXIT_CRITICAL_SECTION();
}
#endif
FreeRTOS-Plus/Source/FreeRTOS-Plus-Trace(streaming)/trcPagedEventBuffer.h
-61
View File
@@ -1,61 +0,0 @@
/*******************************************************************************
* Trace Recorder Library for Tracealyzer v3.0.2
* Percepio AB, www.percepio.com
*
* trcPagedEventBuffer.h
*
* Implements a paged buffer that can be used by TCP/IP or custom transfer
* methods.
*
* Terms of Use
* This software (the "Tracealyzer Recorder Library") is the intellectual
* property of Percepio AB and may not be sold or in other ways commercially
* redistributed without explicit written permission by Percepio AB.
*
* Separate conditions applies for the SEGGER branded source code included.
*
* The recorder library is free for use together with Percepio products.
* You may distribute the recorder library in its original form, but public
* distribution of modified versions require approval by Percepio AB.
*
* Disclaimer
* The trace tool and recorder library is being delivered to you AS IS and
* Percepio AB makes no warranty as to its use or performance. Percepio AB does
* not and cannot warrant the performance or results you may obtain by using the
* software or documentation. Percepio AB make no warranties, express or
* implied, as to noninfringement of third party rights, merchantability, or
* fitness for any particular purpose. In no event will Percepio AB, its
* technology partners, or distributors be liable to you for any consequential,
* incidental or special damages, including any lost profits or lost savings,
* even if a representative of Percepio AB has been advised of the possibility
* of such damages, or for any claim by any third party. Some jurisdictions do
* not allow the exclusion or limitation of incidental, consequential or special
* damages, or the exclusion of implied warranties or limitations on how long an
* implied warranty may last, so the above limitations may not apply to you.
*
* Tabs are used for indent in this file (1 tab = 4 spaces)
*
* Copyright Percepio AB, 2015.
* www.percepio.com
******************************************************************************/
#ifndef TRC_PAGED_EVENT_BUFFER_H
#define TRC_PAGED_EVENT_BUFFER_H
#ifdef __cplusplus
extern “C” {
#endif
void vPagedEventBufferInit(char* buffer);
void* vPagedEventBufferGetWritePointer(int sizeOfEvent);
int32_t vPagedEventBufferTransfer(int32_t (*writeFunc)(void* data, uint32_t size, int32_t* ptrBytesWritten), int32_t* nofBytes);
void vPagedEventBufferReset(void);
#ifdef __cplusplus
}
#endif
#endif /*TRC_PAGED_EVENT_BUFFER_H*/
FreeRTOS-Plus/Source/FreeRTOS-Plus-Trace(streaming)/trcPagedEventBufferConfig.h
-56
View File
@@ -1,56 +0,0 @@
/*******************************************************************************
* Trace Recorder Library for Tracealyzer v3.0.2
* Percepio AB, www.percepio.com
*
* trcPagedEventBuffer.h
*
* Configuration for the paged event buffer that can be used by TCP/IP or
* custom transfer methods.
*
* Terms of Use
* This software (the "Tracealyzer Recorder Library") is the intellectual
* property of Percepio AB and may not be sold or in other ways commercially
* redistributed without explicit written permission by Percepio AB.
*
* Separate conditions applies for the SEGGER branded source code included.
*
* The recorder library is free for use together with Percepio products.
* You may distribute the recorder library in its original form, but public
* distribution of modified versions require approval by Percepio AB.
*
* Disclaimer
* The trace tool and recorder library is being delivered to you AS IS and
* Percepio AB makes no warranty as to its use or performance. Percepio AB does
* not and cannot warrant the performance or results you may obtain by using the
* software or documentation. Percepio AB make no warranties, express or
* implied, as to noninfringement of third party rights, merchantability, or
* fitness for any particular purpose. In no event will Percepio AB, its
* technology partners, or distributors be liable to you for any consequential,
* incidental or special damages, including any lost profits or lost savings,
* even if a representative of Percepio AB has been advised of the possibility
* of such damages, or for any claim by any third party. Some jurisdictions do
* not allow the exclusion or limitation of incidental, consequential or special
* damages, or the exclusion of implied warranties or limitations on how long an
* implied warranty may last, so the above limitations may not apply to you.
*
* Tabs are used for indent in this file (1 tab = 4 spaces)
*
* Copyright Percepio AB, 2015.
* www.percepio.com
******************************************************************************/
#ifndef TRC_PAGED_EVENT_BUFFER_CONFIG_H
#define TRC_PAGED_EVENT_BUFFER_CONFIG_H
#ifdef __cplusplus
extern “C” {
#endif
#define TRC_PAGED_EVENT_BUFFER_PAGE_COUNT 5
#define TRC_PAGED_EVENT_BUFFER_PAGE_SIZE 1440
#ifdef __cplusplus
}
#endif
#endif /*TRC_PAGED_EVENT_BUFFER_CONFIG_H*/
FreeRTOS-Plus/Source/FreeRTOS-Plus-Trace(streaming)/trcRecorder.c
-1126
View File
File diff suppressed because it is too large Load Diff
FreeRTOS-Plus/Source/FreeRTOS-Plus-Trace(streaming)/trcRecorder.h
-363
View File
@@ -1,363 +0,0 @@
/*******************************************************************************
* Trace Recorder Library for Tracealyzer v3.0.2
* Percepio AB, www.percepio.com
*
* trcRecorder.c
*
* Public interface and configurations for the trace recorder library.
*
* Terms of Use
* This software (the "Tracealyzer Recorder Library") is the intellectual
* property of Percepio AB and may not be sold or in other ways commercially
* redistributed without explicit written permission by Percepio AB.
*
* Separate conditions applies for the SEGGER branded source code included.
*
* The recorder library is free for use together with Percepio products.
* You may distribute the recorder library in its original form, but public
* distribution of modified versions require approval by Percepio AB.
*
* Disclaimer
* The trace tool and recorder library is being delivered to you AS IS and
* Percepio AB makes no warranty as to its use or performance. Percepio AB does
* not and cannot warrant the performance or results you may obtain by using the
* software or documentation. Percepio AB make no warranties, express or
* implied, as to noninfringement of third party rights, merchantability, or
* fitness for any particular purpose. In no event will Percepio AB, its
* technology partners, or distributors be liable to you for any consequential,
* incidental or special damages, including any lost profits or lost savings,
* even if a representative of Percepio AB has been advised of the possibility
* of such damages, or for any claim by any third party. Some jurisdictions do
* not allow the exclusion or limitation of incidental, consequential or special
* damages, or the exclusion of implied warranties or limitations on how long an
* implied warranty may last, so the above limitations may not apply to you.
*
* Tabs are used for indent in this file (1 tab = 4 spaces)
*
* Copyright Percepio AB, 2015.
* www.percepio.com
******************************************************************************/
#ifndef _TRC_RECORDER_H
#define _TRC_RECORDER_H
#ifdef __cplusplus
extern “C” {
#endif
#include "trcConfig.h"
#include "trcKernelPort.h"
#include "trcHardwarePort.h"
#if (USE_TRACEALYZER_RECORDER == 1)
/*** User API *****************************************************************/
/******************************************************************************
* vTracePrint
*
* Generates "User Events", with unformatted text.
*
* User Events can be used for very efficient application logging, and are shown
* as yellow labels in the main trace view.
*
* You may group User Events into User Event Channels. The yellow User Event
* labels shows the logged string, preceeded by the channel name within
* brackets. For example:
*
* "[MyChannel] Hello World!"
*
* The User Event Channels are shown in the View Filter, which makes it easy to
* select what User Events you wish to display. User Event Channels are created
* using vTraceStoreUserEventChannelName().
*
* Example:
*
* char* error_uechannel = vTraceStoreUserEventChannelName("Errors");
* ...
* vTracePrint(error_uechannel, "Shouldn't reach this code!");
*
******************************************************************************/
void vTracePrint(const char* chn, const char* str);
/******************************************************************************
* vTracePrintF
*
* Generates "User Events", with formatted text and data, similar to a "printf".
* It is very fast since the actual formatting is done on the host side when the
* trace is displayed.
*
* User Events can be used for very efficient application logging, and are shown
* as yellow labels in the main trace view.
* An advantage of User Events is that data can be plotted in the "User Event
* Signal Plot" view, visualizing any data you log as User Events, discrete
* states or control system signals (e.g. system inputs or outputs).
*
* You may group User Events into User Event Channels. The yellow User Event
* labels show the logged string, preceeded by the channel name within brackets.
*
* Example:
*
* "[MyChannel] Hello World!"
*
* The User Event Channels are shown in the View Filter, which makes it easy to
* select what User Events you wish to display. User Event Channels are created
* using vTraceStoreUserEventChannelName().
*
* Example:
*
* char* adc_uechannel = vTraceStoreUserEventChannelName("ADC User Events");
* ...
* vTracePrint(adc_uechannel,
* "ADC channel %d: %lf volts",
* ch, (double)adc_reading/(double)scale);
*
* All data arguments are assumed to be 32 bt wide. The following formats are
* supported in v2.8:
* %d - signed integer
* %u - unsigned integer
* %X - hexadecimal (uppercase)
* %x - hexadecimal (lowercase)
* %s - string (currently, this must be an earlier stored symbol name)
*
* Up to 15 data arguments are allowed, with a total size of maximum 60 byte
* including 8 byte for the base event fields and the format string. So with
* one data argument, the maximum string length is 48 chars. If this is exceeded
* the string is truncated (4 bytes at a time).
*
******************************************************************************/
void vTracePrintF(const char* chn, const char* fmt, ...);
/*******************************************************************************
* vTraceStoreUserEventChannelName(const char* name)
*
* Parameter name: the channel name to store (const string literal)
*
* Stores a name for a user event channel, returns the handle (just a pointer
* to the provided string). Typically assigned to a "channel" variable that
* keeps it for later calls to vTracePrintF();
******************************************************************************/
char* vTraceStoreUserEventChannelName(const char* name);
/*******************************************************************************
* vTraceStoreKernelObjectName(void* object, const char* name)
*
* Parameter object: pointer to the kernel object that shall be named
* Parameter name: the name to store (const string literal)
*
* Stores a name for kernel objects (Semaphore, Mailbox, etc.).
******************************************************************************/
void vTraceStoreKernelObjectName(void* object, const char* name);
/*******************************************************************************
* vTraceSetISRProperties(const char* name, char priority)
*
* Parameter name: the name to give the the ISR, also serves as handle.
* Parameter priority: the priority level of the ISR.
*
* Stores a name and priority level for an Interrupt Service Routine, to allow
* for better visualization. The string address is used as a unique handle.
*
* Example:
*
* vTraceSetISRProperties("ISRTimer1", ISRPriorityTimer1);
* ...
* void ISR_handler()
* {
* vTraceStoreISRBegin("ISRTimer1");
* ...
* vTraceStoreISREnd(0);
* }
******************************************************************************/
void vTraceSetISRProperties(const char* name, char priority);
/*******************************************************************************
* vTraceStoreISRBegin(void* handle);
*
* Parameter handle: ID of the ISR, which is "name" in vTraceSetISRProperties
*
* Registers the beginning of an Interrupt Service Routine (ISR), i.e., or an
* exception handler.
*
* Example:
*
* vTraceSetISRProperties("ISRTimer1", ISRPriorityTimer1);
* ...
* void ISR_handler()
* {
* vTraceStoreISRBegin("ISRTimer1");
* ...
* vTraceStoreISREnd(0);
* }
******************************************************************************/
void vTraceStoreISRBegin(void* handle);
/*******************************************************************************
* vTraceStoreISREnd
*
* Registers the end of an Interrupt Service Routine.
*
* This function attempts to automatically detect if a task switch will take
* place when interrupt ends. If this is possible depends on the kernel port.
*
* Example:
* #define PRIO_ISR_TIMER1 3 // the hardware priority of the interrupt
* ...
* vTraceSetISRProperties("ISRTimer1", PRIO_ISR_TIMER1);
* ...
* void ISR_handler()
* {
* vTraceStoreISRBegin("ISRTimer1");
* ...
* vTraceStoreISREnd();
* }
*
******************************************************************************/
void vTraceStoreISREnd(void);
/*******************************************************************************
* vTraceStoreISREndManual
*
* Registers the end of an Interrupt Service Routine.
*
* The parameter isTaskSwitchRequired indicates if the interrupt has requested a
* task-switch (= 1) or if the interrupt returns to the earlier context (= 0)
*
* Example:
* #define PRIO_ISR_TIMER1 3 // the hardware priority of the interrupt
* ...
* vTraceSetISRProperties("ISRTimer1", PRIO_ISR_TIMER1);
* ...
* void ISR_handler()
* {
* vTraceStoreISRBegin("ISRTimer1");
* ...
* vTraceStoreISREndManual(0);
* }
*
******************************************************************************/
void vTraceStoreISREndManual(int isTaskSwitchRequired);
/*******************************************************************************
* vTraceInstanceFinishNow
*
* Creates an event that ends the current task instance at this very instant.
* This makes the viewer to splits the current fragment at this point and begin
* a new actor instance, even if no task-switch has occurred.
*****************************************************************************/
void vTraceInstanceFinishedNow(void);
/*******************************************************************************
* vTraceInstanceFinishedNext
*
* Marks the current "task instance" as finished on the next kernel call.
*
* If that kernel call is blocking, the instance ends after the blocking event
* and the corresponding return event is then the start of the next instance.
* If the kernel call is not blocking, the viewer instead splits the current
* fragment right before the kernel call, which makes this call the first event
* of the next instance.
*****************************************************************************/
void vTraceInstanceFinishedNext(void);
/******************************************************************************/
/*** INTERNAL FUNCTIONS *******************************************************/
/******************************************************************************/
/* Saves a symbol name (task name etc.) in symbol table */
void vTraceSaveSymbol(void *address, const char *name);
/* Deletes a symbol name (task name etc.) from symbol table */
void vTraceDeleteSymbol(void *address);
/* Saves an object data entry (task base priority) in object data table */
void vTraceSaveObjectData(void *address, uint32_t data);
/* Removes an object data entry (task base priority) from object data table */
void vTraceDeleteObjectData(void *address);
/* Store an event with zero parameters (event ID only) */
void vTraceStoreEvent0(uint16_t eventID);
/* Store an event with one 32-bit parameter (pointer address or an int) */
void vTraceStoreEvent1(uint16_t eventID, uint32_t param1);
/* Store an event with two 32-bit parameters */
void vTraceStoreEvent2(uint16_t eventID, uint32_t param1, uint32_t param2);
/* Store an event with three 32-bit parameters */
void vTraceStoreEvent3( uint16_t eventID,
uint32_t param1,
uint32_t param2,
uint32_t param3);
/* Stores an event with <nParam> 32-bit integer parameters */
void vTraceStoreEvent(int nParam, uint16_t EventID, ...);
/* Stories an event with a string and <nParam> 32-bit integer parameters */
void vTraceStoreStringEvent(int nArgs, uint16_t eventID, const char* str, ...);
/* The data structure for commands (a bit overkill) */
typedef struct
{
unsigned char cmdCode;
unsigned char param1;
unsigned char param2;
unsigned char param3;
unsigned char param4;
unsigned char param5;
unsigned char checksumLSB;
unsigned char checksumMSB;
} TracealyzerCommandType;
/* Checks if the provided command is a valid command */
int isValidCommand(TracealyzerCommandType* cmd);
/* Executed the received command (Start or Stop) */
void processCommand(TracealyzerCommandType* cmd);
/* Backwards compatibility macros with old recorder */
#define vTraceInitTraceData() Trace_Init()
#define uiTraceStart() (1)
#define vTraceStart()
#define vTraceStop()
#else /*(USE_TRACEALYZER_RECORDER == 1)*/
#define vTraceStoreEvent0(e)
#define vTraceStoreEvent1(e, param1)
#define vTraceStoreEvent2(e, param1, param2)
#define vTraceStoreEvent3(e, param1, param2, param3)
#define vTraceStoreUserEventChannelName(x) 0
#define vTracePrint(chn, ...)
#define vTracePrintF(chn, ...)
#define vTraceInstanceFinishedNow()
#define vTraceInstanceFinishedNext()
#define vTraceStoreISRBegin(x)
#define vTraceStoreISREnd()
#define vTraceStoreISREndManual(x)
#define vTraceSetISRProperties(a, b)
#define vTraceStoreKernelObjectName(a, b)
/* Backwards compatibility macros with old recorder */
#define vTraceInitTraceData()
#define uiTraceStart() (1)
#define vTraceStart()
#define vTraceStop()
#endif /*(USE_TRACEALYZER_RECORDER == 1)*/
extern void psfError(int errCode);
#define PSF_ASSERT(_assert, _err) if (! (_assert)){ psfError(_err); return; }
#define PSF_ERROR_NONE 0
#define PSF_ERROR_EVENT_CODE_TOO_LARGE 1
#define PSF_ERROR_ISR_NESTING_OVERFLOW 2
#ifdef __cplusplus
}
#endif
#endif /* _TRC_RECORDER_H */
FreeRTOS-Plus/Source/FreeRTOS-Plus-Trace(streaming)/trcStreamPort.h
-219
View File
@@ -1,219 +0,0 @@
/*******************************************************************************
* Trace Recorder Library for Tracealyzer v3.0.2
* Percepio AB, www.percepio.com
*
* trcStreamPort.h
*
* This file defines the trace streaming interface used by the
* Trace Recorder Library. It comes preconfigured for use with SEGGER's RTT and
* a TCP/IP (needs additional configuration in trcTCPIPConfig.h).
*
* Terms of Use
* This software (the "Tracealyzer Recorder Library") is the intellectual
* property of Percepio AB and may not be sold or in other ways commercially
* redistributed without explicit written permission by Percepio AB.
*
* Separate conditions applies for the SEGGER branded source code included.
*
* The recorder library is free for use together with Percepio products.
* You may distribute the recorder library in its original form, but public
* distribution of modified versions require approval by Percepio AB.
*
* Disclaimer
* The trace tool and recorder library is being delivered to you AS IS and
* Percepio AB makes no warranty as to its use or performance. Percepio AB does
* not and cannot warrant the performance or results you may obtain by using the
* software or documentation. Percepio AB make no warranties, express or
* implied, as to noninfringement of third party rights, merchantability, or
* fitness for any particular purpose. In no event will Percepio AB, its
* technology partners, or distributors be liable to you for any consequential,
* incidental or special damages, including any lost profits or lost savings,
* even if a representative of Percepio AB has been advised of the possibility
* of such damages, or for any claim by any third party. Some jurisdictions do
* not allow the exclusion or limitation of incidental, consequential or special
* damages, or the exclusion of implied warranties or limitations on how long an
* implied warranty may last, so the above limitations may not apply to you.
*
* Tabs are used for indent in this file (1 tab = 4 spaces)
*
* Copyright Percepio AB, 2015.
* www.percepio.com
******************************************************************************/
#ifndef _TRC_STREAM_PORT_H
#define _TRC_STREAM_PORT_H
#ifdef __cplusplus
extern “C” {
#endif
#if (USE_TRACEALYZER_RECORDER == 1)
#define TRC_RECORDER_TRANSFER_METHOD_JLINK_RTT_BLOCK (0x01)
#define TRC_RECORDER_TRANSFER_METHOD_JLINK_RTT_NOBLOCK (0x02)
#define TRC_RECORDER_TRANSFER_METHOD_TCPIP (0x03)
#define TRC_RECORDER_TRANSFER_METHOD_CUSTOM (0xFF)
#define TRC_RECORDER_BUFFER_ALLOCATION_STATIC (0x00)
#define TRC_RECORDER_BUFFER_ALLOCATION_DYNAMIC (0x01)
/*******************************************************************************
* TRC_RECORDER_TRANSFER_METHOD_JLINK_RTT_BLOCK / NOBLOCK
******************************************************************************/
#if TRC_RECORDER_TRANSFER_METHOD == TRC_RECORDER_TRANSFER_METHOD_JLINK_RTT_BLOCK || TRC_RECORDER_TRANSFER_METHOD == TRC_RECORDER_TRANSFER_METHOD_JLINK_RTT_NOBLOCK
#if TRC_RECORDER_TRANSFER_METHOD == TRC_RECORDER_TRANSFER_METHOD_JLINK_RTT_BLOCK
#define TRC_STREAM_PORT_BLOCKING_TRANSFER 1
#define RTT_MODE SEGGER_RTT_MODE_BLOCK_IF_FIFO_FULL
#else
#define TRC_STREAM_PORT_BLOCKING_TRANSFER 0
#define RTT_MODE SEGGER_RTT_MODE_NO_BLOCK_SKIP
#endif
#include "SEGGER_RTT_Conf.h"
#include "SEGGER_RTT.h"
/* Up-buffer. If index is defined as 0, the internal RTT buffers will be used instead of this. */ \
#if TRC_RTT_UP_BUFFER_INDEX == 0
#define TRC_RTT_ALLOC_UP() static char* _TzTraceData = NULL; /* Not actually used. Ignore allocation method. */
#define TRC_STREAM_PORT_MALLOC() /* Static allocation. Not used. */
#else
#if TRC_RECORDER_BUFFER_ALLOCATION == TRC_RECORDER_BUFFER_ALLOCATION_STATIC
#define TRC_RTT_ALLOC_UP() static char _TzTraceData[BUFFER_SIZE_UP]; /* Static allocation */
#define TRC_STREAM_PORT_MALLOC() /* Static allocation. Not used. */
#else
#define TRC_RTT_ALLOC_UP() static char* _TzTraceData = NULL; /* Dynamic allocation */
#define TRC_STREAM_PORT_MALLOC() _TzTraceData = TRC_PORT_MALLOC(BUFFER_SIZE_UP);
#endif
#endif
/* Down-buffer. If index is defined as 0, the internal RTT buffers will be used instead of this. */ \
#if TRC_RTT_DOWN_BUFFER_INDEX == 0
#define TRC_RTT_ALLOC_DOWN() static char* _TzCtrlData = NULL; /* Not actually used. Ignore allocation method. */
#else
#define TRC_RTT_ALLOC_DOWN() static char _TzCtrlData[BUFFER_SIZE_DOWN]; /* This buffer should be ~32bytes. Ignore allocation method. */
#endif
#define TRC_STREAM_PORT_ALLOCATE_FIELDS() \
TRC_RTT_ALLOC_UP() /* Macro that will result in proper UP buffer allocation */ \
TRC_RTT_ALLOC_DOWN() /* Macro that will result in proper DOWN buffer allocation */
#define TRC_STREAM_PORT_INIT() \
TRC_STREAM_PORT_MALLOC(); /*Dynamic allocation or empty if static */ \
SEGGER_RTT_ConfigUpBuffer(TRC_RTT_UP_BUFFER_INDEX, "TzData", _TzTraceData, sizeof(_TzTraceData), RTT_MODE ); \
SEGGER_RTT_ConfigDownBuffer(TRC_RTT_DOWN_BUFFER_INDEX, "TzCtrl", _TzCtrlData, sizeof(_TzCtrlData), 0);
#define TRC_STREAM_PORT_ALLOCATE_EVENT(_type, _ptrData, _size) uint8_t tmpEvt[_size]; _type* _ptrData = (_type*)tmpEvt;
#define TRC_STREAM_PORT_COMMIT_EVENT(_ptrData, _size) SEGGER_RTT_Write(TRC_RTT_UP_BUFFER_INDEX, (const char*)_ptrData, _size);
#define TRC_STREAM_PORT_READ_DATA(_ptrData, _size, _ptrBytesRead) *_ptrBytesRead = SEGGER_RTT_Read(TRC_RTT_DOWN_BUFFER_INDEX, (char*)_ptrData, _size);
#define TRC_STREAM_PORT_PERIODIC_SEND_DATA(_ptrBytesSent)
#define TRC_STREAM_PORT_ON_TRACE_BEGIN() /* Do nothing */
#define TRC_STREAM_PORT_ON_TRACE_END() /* Do nothing */
#endif /*TRC_RECORDER_TRANSFER_METHOD == TRC_RECORDER_TRANSFER_METHOD_JLINK_RTT_BLOCK || TRC_RECORDER_TRANSFER_METHOD == TRC_RECORDER_TRANSFER_METHOD_JLINK_RTT_NOBLOCK*/
/*******************************************************************************
* TRC_RECORDER_TRANSFER_METHOD_TCPIP
*
* This TCP/IP implementation is using a secondary buffer consisting of multiple
* pages to avoid the endless recursive calls that occurr when "socket_send"
* uses kernel objects such as mutexes and semaphores, which in turn needs to be
* traced. To use your own TCP/IP stack, modify the functions declared in
* trcTCPIPConfig.h.
******************************************************************************/
#if TRC_RECORDER_TRANSFER_METHOD == TRC_RECORDER_TRANSFER_METHOD_TCPIP
#include "trcTCPIP.h"
#include "trcPagedEventBuffer.h"
#include "trcPagedEventBufferConfig.h"
#define TRC_STREAM_PORT_BLOCKING_TRANSFER 0
#if TRC_RECORDER_BUFFER_ALLOCATION == TRC_RECORDER_BUFFER_ALLOCATION_STATIC
#define TRC_STREAM_PORT_ALLOCATE_FIELDS() static char _TzTraceData[TRC_PAGED_EVENT_BUFFER_PAGE_COUNT * TRC_PAGED_EVENT_BUFFER_PAGE_SIZE]; /* Static allocation. */
#define TRC_STREAM_PORT_MALLOC() /* Static allocation. Not used. */
#else
#define TRC_STREAM_PORT_ALLOCATE_FIELDS() static char* _TzTraceData = NULL; /* Dynamic allocation. */
#define TRC_STREAM_PORT_MALLOC() _TzTraceData = TRC_PORT_MALLOC(TRC_PAGED_EVENT_BUFFER_PAGE_COUNT * TRC_PAGED_EVENT_BUFFER_PAGE_SIZE);
#endif
#define TRC_STREAM_PORT_INIT() \
TRC_STREAM_PORT_MALLOC(); /*Dynamic allocation or empty if static */ \
vPagedEventBufferInit(_TzTraceData);
#define TRC_STREAM_PORT_ALLOCATE_EVENT(_type, _ptrData, _size) _type* _ptrData; _ptrData = (_type*)vPagedEventBufferGetWritePointer(_size);
#define TRC_STREAM_PORT_COMMIT_EVENT(_ptrData, _size) /* Not needed since we write immediately into the buffer received above by TRC_STREAM_PORT_ALLOCATE_EVENT, and the TRC_STREAM_PORT_PERIODIC_SEND_DATA defined below will take care of the actual trace transfer. */
#define TRC_STREAM_PORT_READ_DATA(_ptrData, _size, _ptrBytesRead) trcTcpRead(_ptrData, _size, _ptrBytesRead);
#define TRC_STREAM_PORT_PERIODIC_SEND_DATA(_ptrBytesSent) vPagedEventBufferTransfer(trcTcpWrite, _ptrBytesSent);
#define TRC_STREAM_PORT_ON_TRACE_BEGIN() vPagedEventBufferInit(_TzTraceData);
#define TRC_STREAM_PORT_ON_TRACE_END() /* Do nothing */
#endif /*TRC_RECORDER_TRANSFER_METHOD == TRC_RECORDER_TRANSFER_METHOD_TCPIP*/
/*******************************************************************************
* TRC_RECORDER_TRANSFER_METHOD_CUSTOM
*
* Implement the following macros in trcConfig.h. If your transfer method uses
* kernel objects when sending data you will need to use a secondary buffer to
* store the trace data before sending it. For this reason we provide
* trcPagedEventBuffer. Look at the TCP/IP macros above to see how to use it.
******************************************************************************/
#if TRC_RECORDER_TRANSFER_METHOD == TRC_RECORDER_TRANSFER_METHOD_CUSTOM
/* When using the custom transfer method, define TRC_STREAM_CUSTOM_XXXXXXXXXXXXX in trcConfig.h */
#define TRC_STREAM_PORT_BLOCKING_TRANSFER TRC_STREAM_CUSTOM_BLOCKING_TRANSFER
#define TRC_STREAM_PORT_ALLOCATE_FIELDS() TRC_STREAM_CUSTOM_ALLOCATE_FIELDS()
#define TRC_STREAM_PORT_INIT() TRC_STREAM_CUSTOM_INIT()
#define TRC_STREAM_PORT_ALLOCATE_EVENT(_type, _ptr, _size) TRC_STREAM_CUSTOM_ALLOCATE_EVENT(_type, _ptr, _size)
#define TRC_STREAM_PORT_COMMIT_EVENT(_ptr, _size) TRC_STREAM_CUSTOM_COMMIT_EVENT(_ptr, _size)
#define TRC_STREAM_PORT_READ_DATA(_ptrData, _size, _ptrBytesRead) TRC_STREAM_CUSTOM_READ_DATA(_ptrData, _size, _ptrBytesRead)
#define TRC_STREAM_PORT_PERIODIC_SEND_DATA(_ptrBytesSent) TRC_STREAM_CUSTOM_PERIODIC_SEND_DATA(_ptrBytesSent)
#define TRC_STREAM_PORT_ON_TRACE_BEGIN() TRC_STREAM_CUSTOM_ON_TRACE_BEGIN()
#define TRC_STREAM_PORT_ON_TRACE_END() TRC_STREAM_CUSTOM_ON_TRACE_END()
#endif /*TRC_RECORDER_TRANSFER_METHOD == TRC_RECORDER_TRANSFER_METHOD_CUSTOM*/
#ifndef TRC_STREAM_PORT_ALLOCATE_FIELDS
#error "Selected TRC_RECORDER_TRANSFER_METHOD does not define TRC_STREAM_PORT_ALLOCATE_FIELDS!"
#endif
#ifndef TRC_STREAM_PORT_ALLOCATE_EVENT
#error "Selected TRC_RECORDER_TRANSFER_METHOD does not define TRC_STREAM_PORT_ALLOCATE_EVENT!"
#endif
#ifndef TRC_STREAM_PORT_COMMIT_EVENT
#error "Selected TRC_RECORDER_TRANSFER_METHOD does not define TRC_STREAM_PORT_COMMIT_EVENT!"
#endif
#ifndef TRC_STREAM_PORT_INIT
#error "Selected TRC_RECORDER_TRANSFER_METHOD does not define TRC_STREAM_PORT_INIT!"
#endif
#ifndef TRC_STREAM_PORT_BLOCKING_TRANSFER
#error "Selected TRC_RECORDER_TRANSFER_METHOD does not define TRC_STREAM_PORT_BLOCKING_TRANSFER!"
#endif
#ifndef TRC_STREAM_PORT_READ_DATA
#error "Selected TRC_RECORDER_TRANSFER_METHOD does not define TRC_STREAM_PORT_READ_DATA!"
#endif
#ifndef TRC_STREAM_PORT_PERIODIC_SEND_DATA
#error "Selected TRC_RECORDER_TRANSFER_METHOD does not define TRC_STREAM_PORT_PERIODIC_SEND_DATA!"
#endif
#ifndef TRC_STREAM_PORT_ON_TRACE_BEGIN
#error "Selected TRC_RECORDER_TRANSFER_METHOD does not define TRC_STREAM_PORT_ON_TRACE_BEGIN!"
#endif
#ifndef TRC_STREAM_PORT_ON_TRACE_END
#error "Selected TRC_RECORDER_TRANSFER_METHOD does not define TRC_STREAM_PORT_ON_TRACE_END!"
#endif
#endif /*(USE_TRACEALYZER_RECORDER == 1)*/
#ifdef __cplusplus
}
#endif
#endif /* _TRC_STREAM_PORT_H */
FreeRTOS-Plus/Source/FreeRTOS-Plus-Trace(streaming)/trcTCPIP.c
-58
View File
@@ -1,58 +0,0 @@
/*******************************************************************************
* Trace Recorder Library for Tracealyzer v3.0.2
* Percepio AB, www.percepio.com
*
* trcTCPIP.c
*
* Simple generic TCP/IP layer. Modify trcTCPIPConfig.h to adapt it to any
* custom stack.
*
* Terms of Use
* This software (the "Tracealyzer Recorder Library") is the intellectual
* property of Percepio AB and may not be sold or in other ways commercially
* redistributed without explicit written permission by Percepio AB.
*
* Separate conditions applies for the SEGGER branded source code included.
*
* The recorder library is free for use together with Percepio products.
* You may distribute the recorder library in its original form, but public
* distribution of modified versions require approval by Percepio AB.
*
* Disclaimer
* The trace tool and recorder library is being delivered to you AS IS and
* Percepio AB makes no warranty as to its use or performance. Percepio AB does
* not and cannot warrant the performance or results you may obtain by using the
* software or documentation. Percepio AB make no warranties, express or
* implied, as to noninfringement of third party rights, merchantability, or
* fitness for any particular purpose. In no event will Percepio AB, its
* technology partners, or distributors be liable to you for any consequential,
* incidental or special damages, including any lost profits or lost savings,
* even if a representative of Percepio AB has been advised of the possibility
* of such damages, or for any claim by any third party. Some jurisdictions do
* not allow the exclusion or limitation of incidental, consequential or special
* damages, or the exclusion of implied warranties or limitations on how long an
* implied warranty may last, so the above limitations may not apply to you.
*
* Tabs are used for indent in this file (1 tab = 4 spaces)
*
* Copyright Percepio AB, 2015.
* www.percepio.com
******************************************************************************/
#include <stdint.h>
#include "trcTCPIP.h"
#include "trcTCPIPConfig.h"
int32_t trcTcpWrite(void* data, uint32_t size, int32_t *ptrBytesWritten)
{
return trcSocketSend(data, size, ptrBytesWritten);
}
int32_t trcTcpRead(void* data, uint32_t size, int32_t *ptrBytesRead)
{
trcSocketInitializeListener();
trcSocketAccept();
return trcSocketReceive(data, size, ptrBytesRead);
}
FreeRTOS-Plus/Source/FreeRTOS-Plus-Trace(streaming)/trcTCPIP.h
-56
View File
@@ -1,56 +0,0 @@
/*******************************************************************************
* Trace Recorder Library for Tracealyzer v3.0.2
* Percepio AB, www.percepio.com
*
* trcTCPIP.h
*
* Simple generic TCP/IP layer. Modify trcTCPIPConfig.h to adapt it to any
* custom stack.
*
* Terms of Use
* This software (the "Tracealyzer Recorder Library") is the intellectual
* property of Percepio AB and may not be sold or in other ways commercially
* redistributed without explicit written permission by Percepio AB.
*
* Separate conditions applies for the SEGGER branded source code included.
*
* The recorder library is free for use together with Percepio products.
* You may distribute the recorder library in its original form, but public
* distribution of modified versions require approval by Percepio AB.
*
* Disclaimer
* The trace tool and recorder library is being delivered to you AS IS and
* Percepio AB makes no warranty as to its use or performance. Percepio AB does
* not and cannot warrant the performance or results you may obtain by using the
* software or documentation. Percepio AB make no warranties, express or
* implied, as to noninfringement of third party rights, merchantability, or
* fitness for any particular purpose. In no event will Percepio AB, its
* technology partners, or distributors be liable to you for any consequential,
* incidental or special damages, including any lost profits or lost savings,
* even if a representative of Percepio AB has been advised of the possibility
* of such damages, or for any claim by any third party. Some jurisdictions do
* not allow the exclusion or limitation of incidental, consequential or special
* damages, or the exclusion of implied warranties or limitations on how long an
* implied warranty may last, so the above limitations may not apply to you.
*
* Tabs are used for indent in this file (1 tab = 4 spaces)
*
* Copyright Percepio AB, 2015.
* www.percepio.com
******************************************************************************/
#ifndef TRC_TCPIP_H
#define TRC_TCPIP_H
#ifdef __cplusplus
extern “C” {
#endif
int32_t trcTcpWrite(void* data, uint32_t size, int32_t *ptrBytesWritten);
int32_t trcTcpRead(void* data, uint32_t size, int32_t *ptrBytesRead);
#ifdef __cplusplus
}
#endif
#endif /*TRC_TCPIP_H*/
FreeRTOS-Plus/Source/FreeRTOS-Plus-Trace(streaming)/trcTCPIPConfig.h
-163
View File
@@ -1,163 +0,0 @@
/*******************************************************************************
* Trace Recorder Library for Tracealyzer v3.0.2
* Percepio AB, www.percepio.com
*
* trcTCPIPConfig.h
*
* Trace TCP/IP configuration. Modify these includes and functions to perform
* the same functionality using your specific TCP/IP stack.
* Will only be included by trcTCPIP.c.
*
* Terms of Use
* This software (the "Tracealyzer Recorder Library") is the intellectual
* property of Percepio AB and may not be sold or in other ways commercially
* redistributed without explicit written permission by Percepio AB.
*
* Separate conditions applies for the SEGGER branded source code included.
*
* The recorder library is free for use together with Percepio products.
* You may distribute the recorder library in its original form, but public
* distribution of modified versions require approval by Percepio AB.
*
* Disclaimer
* The trace tool and recorder library is being delivered to you AS IS and
* Percepio AB makes no warranty as to its use or performance. Percepio AB does
* not and cannot warrant the performance or results you may obtain by using the
* software or documentation. Percepio AB make no warranties, express or
* implied, as to noninfringement of third party rights, merchantability, or
* fitness for any particular purpose. In no event will Percepio AB, its
* technology partners, or distributors be liable to you for any consequential,
* incidental or special damages, including any lost profits or lost savings,
* even if a representative of Percepio AB has been advised of the possibility
* of such damages, or for any claim by any third party. Some jurisdictions do
* not allow the exclusion or limitation of incidental, consequential or special
* damages, or the exclusion of implied warranties or limitations on how long an
* implied warranty may last, so the above limitations may not apply to you.
*
* Tabs are used for indent in this file (1 tab = 4 spaces)
*
* Copyright Percepio AB, 2015.
* www.percepio.com
******************************************************************************/
#ifndef TRC_TCPIP_CONFIG_H
#define TRC_TCPIP_CONFIG_H
#ifdef __cplusplus
extern “C” {
#endif
/* TCP/IP includes*/
#include "tcpip.h"
#define TRC_TCPIP_PORT 12000
socket* sock = NULL;
socket* listenerSocket = NULL;
int32_t trcSocketSend(void* data, int32_t size, int32_t* bytesWritten)
{
int32_t error;
if (sock == NULL)
return 1;
error = socket_send(sock, data, size, (size_t*)bytesWritten, 0);
if (error)
{
socket_close(sock);
sock = NULL;
}
return (int32_t)error;
}
int32_t trcSocketReceive(void* data, int32_t size, int32_t* bytesRead)
{
int32_t error;
if (sock == NULL)
return 1;
error = socket_receive(sock, data, size, (size_t*)bytesRead, SOCKET_WAIT_ALL);
if (error != ERROR_NONE && error != ERROR_TIMEOUT) /* Timeout may be expected when there is no data */
{
socket_close(sock);
sock = NULL;
return error;
}
return 0;
}
int32_t trcSocketInitializeListener()
{
int32_t error;
if (listenerSocket)
return 0;
//Start of exception handling block
do
{
listenerSocket = socket_open(SOCKET_STREAM, SOCKET_TCP);
if(listenerSocket == NULL)
{
error = 1;
break;
}
error = socket_set_timeout(listenerSocket, INFINITE);
if(error) break;
error = socket_set_tx_buffer_size(listenerSocket, 1440 * 2);
if(error) break;
error = socket_set_rx_buffer_size(listenerSocket, 128);
if(error) break;
error = socket_bind_to_interface(listenerSocket, pNetInterface);
if(error) break;
error = socket_bind(listenerSocket, ADDR_ANY, TRC_TCPIP_PORT);
if(error) break;
error = socket_listen(listenerSocket);
if(error) break;
} while(0);
if(error)
{
socket_close(listenerSocket);
listenerSocket = NULL;
}
return error;
}
int32_t trcSocketAccept()
{
ip_addr clientIpAddr;
uint16_t clientPort;
if (sock != NULL)
return 0;
if (listenerSocket == NULL)
return 1;
/* Wait for connection */
sock = socket_accept(listenerSocket, &clientIpAddr, &clientPort);
if(sock != NULL)
{
socket_set_timeout(sock, 20);
}
else
return 1;
return 0;
}
#ifdef __cplusplus
}
#endif
#endif /*TRC_TCPIP_CONFIG_H*/
FreeRTOS-Plus/Source/FreeRTOS-Plus-Trace/Include/trcKernelPort.h
+1 -1
View File
@@ -778,7 +778,7 @@ extern void vTraceStoreMemMangEvent(uint32_t ecode, uint32_t address, int32_t si
#define traceMALLOC( pvAddress, uiSize ) {if (pvAddress != 0) vTraceStoreMemMangEvent(MEM_MALLOC_SIZE, ( uint32_t ) pvAddress, (int32_t)uiSize); }
#undef traceFREE
#define traceFREE( pvAddress, uiSize ) {vTraceStoreMemMangEvent(MEM_FREE_SIZE, ( uint32_t ) pvAddress, (int32_t)(-uiSize)); }
#define traceFREE( pvAddress, uiSize ) {vTraceStoreMemMangEvent(MEM_FREE_SIZE, ( uint32_t ) pvAddress, -((int32_t)uiSize)); }
#endif /* (TRC_CFG_SCHEDULING_ONLY == 0) && (TRC_CFG_INCLUDE_MEMMANG_EVENTS == 1) */
FreeRTOS-Plus/Source/FreeRTOS-Plus-Trace/trcSnapshotRecorder.c
+2 -2
View File
@@ -1868,8 +1868,8 @@ static uint32_t prvTraceGetParam(uint32_t param_max, uint32_t param)
if (xps != NULL)
{
xps->type = DIV_XPS;
xps->xps_8 = (uint8_t)(param & (0xFF00 & ~param_max)) >> 8;
xps->xps_16 = (uint16_t)(param & (0xFFFF0000 & ~param_max)) >> 16;
xps->xps_8 = (uint8_t)((param & (0xFF00 & ~param_max)) >> 8);
xps->xps_16 = (uint16_t)((param & (0xFFFF0000 & ~param_max)) >> 16);
prvTraceUpdateCounters();
}