From 205a5df834a4485c0dba80448466850e13414317 Mon Sep 17 00:00:00 2001 From: fanoush Date: Thu, 8 Aug 2024 08:07:09 +0200 Subject: [PATCH 01/19] console over SWD uses customized SEGGER RTT --- Makefile | 6 + boards/BANGLEJS2.py | 1 + libs/swdcon/SEGGER_RTT_custom.c | 2142 +++++++++++++++++++++++++++++++ libs/swdcon/SEGGER_RTT_custom.h | 511 ++++++++ libs/swdcon/jswrap_swdcon.c | 183 +++ libs/swdcon/jswrap_swdcon.h | 28 + src/jsdevices.c | 13 + src/jsdevices.h | 3 + 8 files changed, 2887 insertions(+) create mode 100644 libs/swdcon/SEGGER_RTT_custom.c create mode 100644 libs/swdcon/SEGGER_RTT_custom.h create mode 100644 libs/swdcon/jswrap_swdcon.c create mode 100644 libs/swdcon/jswrap_swdcon.h diff --git a/Makefile b/Makefile index 8636ad16f5..24e6eaa6a3 100755 --- a/Makefile +++ b/Makefile @@ -456,6 +456,12 @@ ifeq ($(USE_TERMINAL),1) WRAPPERSOURCES += libs/graphics/jswrap_terminal.c endif +ifeq ($(USE_SWDCON),1) + DEFINES += -DUSE_SWDCON + WRAPPERSOURCES += libs/swdcon/jswrap_swdcon.c +# directly included so not needed SOURCES += libs/swdcon/SEGGER_RTT_custom.c +endif + endif ifeq ($(USE_USB_HID),1) diff --git a/boards/BANGLEJS2.py b/boards/BANGLEJS2.py index 14798eee00..48d29cb2f7 100644 --- a/boards/BANGLEJS2.py +++ b/boards/BANGLEJS2.py @@ -38,6 +38,7 @@ 'CRYPTO','SHA256','SHA512', 'LCD_MEMLCD', 'TENSORFLOW', +# 'SWDCON', RTT console over SWD 'JIT' # JIT compiler enabled ], 'makefile' : [ diff --git a/libs/swdcon/SEGGER_RTT_custom.c b/libs/swdcon/SEGGER_RTT_custom.c new file mode 100644 index 0000000000..120978185f --- /dev/null +++ b/libs/swdcon/SEGGER_RTT_custom.c @@ -0,0 +1,2142 @@ +/* + customized and cut down (=#ifdef-ed out) minimal version of SEGGER RTT + Version V7.94a (2023-12-06) + https://github.com/adfernandes/segger-rtt/tree/0022265202e4f6e7a44cf0e15e447d75b573c371 + + - no default allocation of channel 0 with name "Terminal" + - customizable "SEGGER RTT" header in memory (to possibly coexist with full version) + - removed some Terminal static deslarations + related Terminal methods + - INIT() macro used in most calls is empty, now needs SEGGER_RTT_Init() to work + - no extra _Conf.h header included +*/ +#define CUSTOM_RTT // used for ifdefs with changes +#ifndef CUSTOM_RTT_HEADER_BACKWARDS +#define CUSTOM_RTT_HEADER_BACKWARDS "TTR REGGES" +#endif +/********************************************************************* +* SEGGER Microcontroller GmbH * +* The Embedded Experts * +********************************************************************** +* * +* (c) 1995 - 2019 SEGGER Microcontroller GmbH * +* * +* www.segger.com Support: support@segger.com * +* * +********************************************************************** +* * +* SEGGER RTT * Real Time Transfer for embedded targets * +* * +********************************************************************** +* * +* All rights reserved. * +* * +* SEGGER strongly recommends to not make any changes * +* to or modify the source code of this software in order to stay * +* compatible with the RTT protocol and J-Link. * +* * +* Redistribution and use in source and binary forms, with or * +* without modification, are permitted provided that the following * +* condition is met: * +* * +* o Redistributions of source code must retain the above copyright * +* notice, this condition and the following disclaimer. * +* * +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND * +* CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, * +* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF * +* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE * +* DISCLAIMED. IN NO EVENT SHALL SEGGER Microcontroller BE LIABLE FOR * +* ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT * +* OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; * +* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * +* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * +* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE * +* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH * +* DAMAGE. * +* * +********************************************************************** +---------------------------END-OF-HEADER------------------------------ +File : SEGGER_RTT.c +Purpose : Implementation of SEGGER real-time transfer (RTT) which + allows real-time communication on targets which support + debugger memory accesses while the CPU is running. +Revision: $Rev: 29668 $ + +Additional information: + Type "int" is assumed to be 32-bits in size + H->T Host to target communication + T->H Target to host communication + + RTT channel 0 is always present and reserved for Terminal usage. + Name is fixed to "Terminal" + + Effective buffer size: SizeOfBuffer - 1 + + WrOff == RdOff: Buffer is empty + WrOff == (RdOff - 1): Buffer is full + WrOff > RdOff: Free space includes wrap-around + WrOff < RdOff: Used space includes wrap-around + (WrOff == (SizeOfBuffer - 1)) && (RdOff == 0): + Buffer full and wrap-around after next byte + + +---------------------------------------------------------------------- +*/ +#ifdef CUSTOM_RTT +#include "SEGGER_RTT_custom.h" +#else +#include "SEGGER_RTT.h" +#endif +#include // for memcpy + +/********************************************************************* +* +* Configuration, default values +* +********************************************************************** +*/ + +#if SEGGER_RTT_CPU_CACHE_LINE_SIZE + #ifdef SEGGER_RTT_CB_ALIGN + #error "Custom SEGGER_RTT_CB_ALIGN() is not supported for SEGGER_RTT_CPU_CACHE_LINE_SIZE != 0" + #endif + #ifdef SEGGER_RTT_BUFFER_ALIGN + #error "Custom SEGGER_RTT_BUFFER_ALIGN() is not supported for SEGGER_RTT_CPU_CACHE_LINE_SIZE != 0" + #endif + #ifdef SEGGER_RTT_PUT_CB_SECTION + #error "Custom SEGGER_RTT_PUT_CB_SECTION() is not supported for SEGGER_RTT_CPU_CACHE_LINE_SIZE != 0" + #endif + #ifdef SEGGER_RTT_PUT_BUFFER_SECTION + #error "Custom SEGGER_RTT_PUT_BUFFER_SECTION() is not supported for SEGGER_RTT_CPU_CACHE_LINE_SIZE != 0" + #endif + #ifdef SEGGER_RTT_BUFFER_ALIGNMENT + #error "Custom SEGGER_RTT_BUFFER_ALIGNMENT is not supported for SEGGER_RTT_CPU_CACHE_LINE_SIZE != 0" + #endif + #ifdef SEGGER_RTT_ALIGNMENT + #error "Custom SEGGER_RTT_ALIGNMENT is not supported for SEGGER_RTT_CPU_CACHE_LINE_SIZE != 0" + #endif +#endif + +#ifndef BUFFER_SIZE_UP + #define BUFFER_SIZE_UP 1024 // Size of the buffer for terminal output of target, up to host +#endif + +#ifndef BUFFER_SIZE_DOWN + #define BUFFER_SIZE_DOWN 16 // Size of the buffer for terminal input to target from host (Usually keyboard input) +#endif + +#ifndef SEGGER_RTT_MAX_NUM_UP_BUFFERS + #define SEGGER_RTT_MAX_NUM_UP_BUFFERS 2 // Number of up-buffers (T->H) available on this target +#endif + +#ifndef SEGGER_RTT_MAX_NUM_DOWN_BUFFERS + #define SEGGER_RTT_MAX_NUM_DOWN_BUFFERS 2 // Number of down-buffers (H->T) available on this target +#endif + +#ifndef SEGGER_RTT_BUFFER_SECTION + #if defined(SEGGER_RTT_SECTION) + #define SEGGER_RTT_BUFFER_SECTION SEGGER_RTT_SECTION + #endif +#endif + +#ifndef SEGGER_RTT_ALIGNMENT + #define SEGGER_RTT_ALIGNMENT SEGGER_RTT_CPU_CACHE_LINE_SIZE +#endif + +#ifndef SEGGER_RTT_BUFFER_ALIGNMENT + #define SEGGER_RTT_BUFFER_ALIGNMENT SEGGER_RTT_CPU_CACHE_LINE_SIZE +#endif + +#ifndef SEGGER_RTT_MODE_DEFAULT + #define SEGGER_RTT_MODE_DEFAULT SEGGER_RTT_MODE_NO_BLOCK_SKIP +#endif + +#ifndef SEGGER_RTT_LOCK + #define SEGGER_RTT_LOCK() +#endif + +#ifndef SEGGER_RTT_UNLOCK + #define SEGGER_RTT_UNLOCK() +#endif + +#ifndef STRLEN + #define STRLEN(a) strlen((a)) +#endif + +#ifndef STRCPY + #define STRCPY(pDest, pSrc) strcpy((pDest), (pSrc)) +#endif + +#ifndef SEGGER_RTT_MEMCPY_USE_BYTELOOP + #define SEGGER_RTT_MEMCPY_USE_BYTELOOP 0 +#endif + +#ifndef SEGGER_RTT_MEMCPY + #ifdef MEMCPY + #define SEGGER_RTT_MEMCPY(pDest, pSrc, NumBytes) MEMCPY((pDest), (pSrc), (NumBytes)) + #else + #define SEGGER_RTT_MEMCPY(pDest, pSrc, NumBytes) memcpy((pDest), (pSrc), (NumBytes)) + #endif +#endif + +#ifndef MIN + #define MIN(a, b) (((a) < (b)) ? (a) : (b)) +#endif + +#ifndef MAX + #define MAX(a, b) (((a) > (b)) ? (a) : (b)) +#endif + +/********************************************************************* +* +* Defines, fixed +* +********************************************************************** +*/ +#if (defined __ICCARM__) || (defined __ICCRX__) + #define RTT_PRAGMA(P) _Pragma(#P) +#endif + +#if SEGGER_RTT_ALIGNMENT || SEGGER_RTT_BUFFER_ALIGNMENT + #if ((defined __GNUC__) || (defined __clang__)) + #define SEGGER_RTT_ALIGN(Var, Alignment) Var __attribute__ ((aligned (Alignment))) + #elif (defined __ICCARM__) || (defined __ICCRX__) + #define PRAGMA(A) _Pragma(#A) +#define SEGGER_RTT_ALIGN(Var, Alignment) RTT_PRAGMA(data_alignment=Alignment) \ + Var + #elif (defined __CC_ARM) + #define SEGGER_RTT_ALIGN(Var, Alignment) Var __attribute__ ((aligned (Alignment))) + #else + #error "Alignment not supported for this compiler." + #endif +#else + #define SEGGER_RTT_ALIGN(Var, Alignment) Var +#endif + +#if defined(SEGGER_RTT_SECTION) || defined (SEGGER_RTT_BUFFER_SECTION) + #if ((defined __GNUC__) || (defined __clang__)) + #define SEGGER_RTT_PUT_SECTION(Var, Section) __attribute__ ((section (Section))) Var + #elif (defined __ICCARM__) || (defined __ICCRX__) +#define SEGGER_RTT_PUT_SECTION(Var, Section) RTT_PRAGMA(location=Section) \ + Var + #elif (defined __CC_ARM) + #define SEGGER_RTT_PUT_SECTION(Var, Section) __attribute__ ((section (Section), zero_init)) Var + #else + #error "Section placement not supported for this compiler." + #endif +#else + #define SEGGER_RTT_PUT_SECTION(Var, Section) Var +#endif + +#if SEGGER_RTT_ALIGNMENT + #define SEGGER_RTT_CB_ALIGN(Var) SEGGER_RTT_ALIGN(Var, SEGGER_RTT_ALIGNMENT) +#else + #define SEGGER_RTT_CB_ALIGN(Var) Var +#endif + +#if SEGGER_RTT_BUFFER_ALIGNMENT + #define SEGGER_RTT_BUFFER_ALIGN(Var) SEGGER_RTT_ALIGN(Var, SEGGER_RTT_BUFFER_ALIGNMENT) +#else + #define SEGGER_RTT_BUFFER_ALIGN(Var) Var +#endif + + +#if defined(SEGGER_RTT_SECTION) + #define SEGGER_RTT_PUT_CB_SECTION(Var) SEGGER_RTT_PUT_SECTION(Var, SEGGER_RTT_SECTION) +#else + #define SEGGER_RTT_PUT_CB_SECTION(Var) Var +#endif + +#if defined(SEGGER_RTT_BUFFER_SECTION) + #define SEGGER_RTT_PUT_BUFFER_SECTION(Var) SEGGER_RTT_PUT_SECTION(Var, SEGGER_RTT_BUFFER_SECTION) +#else + #define SEGGER_RTT_PUT_BUFFER_SECTION(Var) Var +#endif + +/********************************************************************* +* +* Static const data +* +********************************************************************** +*/ + +#ifndef CUSTOM_RTT +static const unsigned char _aTerminalId[16] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' }; +#endif + + +/********************************************************************* +* +* Static data +* +********************************************************************** +*/ + +// +// RTT Control Block and allocate buffers for channel 0 +// +#if SEGGER_RTT_CPU_CACHE_LINE_SIZE + #if ((defined __GNUC__) || (defined __clang__)) + SEGGER_RTT_CB _SEGGER_RTT __attribute__ ((aligned (SEGGER_RTT_CPU_CACHE_LINE_SIZE))); + #elif (defined __ICCARM__) + #pragma data_alignment=SEGGER_RTT_CPU_CACHE_LINE_SIZE + SEGGER_RTT_CB _SEGGER_RTT; + #else + #error "Don't know how to place _SEGGER_RTT, _acUpBuffer, _acDownBuffer cache-line aligned" + #endif +#else + SEGGER_RTT_PUT_CB_SECTION(SEGGER_RTT_CB_ALIGN(SEGGER_RTT_CB _SEGGER_RTT)); +#endif + +#ifndef CUSTOM_RTT +#if SEGGER_RTT_CPU_CACHE_LINE_SIZE + #if ((defined __GNUC__) || (defined __clang__)) + static char _acUpBuffer [SEGGER_RTT__ROUND_UP_2_CACHE_LINE_SIZE(BUFFER_SIZE_UP)] __attribute__ ((aligned (SEGGER_RTT_CPU_CACHE_LINE_SIZE))); + static char _acDownBuffer[SEGGER_RTT__ROUND_UP_2_CACHE_LINE_SIZE(BUFFER_SIZE_DOWN)] __attribute__ ((aligned (SEGGER_RTT_CPU_CACHE_LINE_SIZE))); + #elif (defined __ICCARM__) + #pragma data_alignment=SEGGER_RTT_CPU_CACHE_LINE_SIZE + static char _acUpBuffer [SEGGER_RTT__ROUND_UP_2_CACHE_LINE_SIZE(BUFFER_SIZE_UP)]; + #pragma data_alignment=SEGGER_RTT_CPU_CACHE_LINE_SIZE + static char _acDownBuffer[SEGGER_RTT__ROUND_UP_2_CACHE_LINE_SIZE(BUFFER_SIZE_DOWN)]; + #else + #error "Don't know how to place _SEGGER_RTT, _acUpBuffer, _acDownBuffer cache-line aligned" + #endif +#else + SEGGER_RTT_PUT_BUFFER_SECTION(SEGGER_RTT_BUFFER_ALIGN(static char _acUpBuffer [BUFFER_SIZE_UP])); + SEGGER_RTT_PUT_BUFFER_SECTION(SEGGER_RTT_BUFFER_ALIGN(static char _acDownBuffer[BUFFER_SIZE_DOWN])); +#endif + +static unsigned char _ActiveTerminal; +#endif +/********************************************************************* +* +* Static functions +* +********************************************************************** +*/ + +/********************************************************************* +* +* _DoInit() +* +* Function description +* Initializes the control block an buffers. +* +* Notes +* (1) May only be called via INIT() to avoid overriding settings. +* The only exception is SEGGER_RTT_Init(), to make an intentional override possible. +*/ +#ifdef CUSTOM_RTT +#define INIT() +#else + #define INIT() \ + do { \ + volatile SEGGER_RTT_CB* pRTTCBInit; \ + pRTTCBInit = (volatile SEGGER_RTT_CB*)((uintptr_t)&_SEGGER_RTT + SEGGER_RTT_UNCACHED_OFF); \ + if (pRTTCBInit->acID[0] != 'S') { \ + _DoInit(); \ + } \ + } while (0) +#endif + +static void _DoInit(void) { + volatile SEGGER_RTT_CB* p; // Volatile to make sure that compiler cannot change the order of accesses to the control block + static const char _aInitStr[] = "\0\0\0\0\0\0"CUSTOM_RTT_HEADER_BACKWARDS; // Init complete ID string to make sure that things also work if RTT is linked to a no-init memory area + unsigned i; + // + // Initialize control block + // + p = (volatile SEGGER_RTT_CB*)((uintptr_t)&_SEGGER_RTT + SEGGER_RTT_UNCACHED_OFF); // Access control block uncached so that nothing in the cache ever becomes dirty and all changes are visible in HW directly + memset((SEGGER_RTT_CB*)p, 0, sizeof(_SEGGER_RTT)); // Make sure that the RTT CB is always zero initialized. + p->MaxNumUpBuffers = SEGGER_RTT_MAX_NUM_UP_BUFFERS; + p->MaxNumDownBuffers = SEGGER_RTT_MAX_NUM_DOWN_BUFFERS; +#ifndef CUSTOM_RTT + // + // Initialize up buffer 0 + // + p->aUp[0].sName = "Terminal"; + p->aUp[0].pBuffer = _acUpBuffer; + p->aUp[0].SizeOfBuffer = BUFFER_SIZE_UP; + p->aUp[0].RdOff = 0u; + p->aUp[0].WrOff = 0u; + p->aUp[0].Flags = SEGGER_RTT_MODE_DEFAULT; + // + // Initialize down buffer 0 + // + p->aDown[0].sName = "Terminal"; + p->aDown[0].pBuffer = _acDownBuffer; + p->aDown[0].SizeOfBuffer = BUFFER_SIZE_DOWN; + p->aDown[0].RdOff = 0u; + p->aDown[0].WrOff = 0u; + p->aDown[0].Flags = SEGGER_RTT_MODE_DEFAULT; +#endif + // + // Finish initialization of the control block. + // Copy Id string backwards to make sure that "SEGGER RTT" is not found in initializer memory (usually flash), + // as this would cause J-Link to "find" the control block at a wrong address. + // + RTT__DMB(); // Force order of memory accesses for cores that may perform out-of-order memory accesses + for (i = 0; i < sizeof(_aInitStr) - 1; ++i) { + p->acID[i] = _aInitStr[sizeof(_aInitStr) - 2 - i]; // Skip terminating \0 at the end of the array + } + RTT__DMB(); // Force order of memory accesses for cores that may perform out-of-order memory accesses +} + +/********************************************************************* +* +* _WriteBlocking() +* +* Function description +* Stores a specified number of characters in SEGGER RTT ring buffer +* and updates the associated write pointer which is periodically +* read by the host. +* The caller is responsible for managing the write chunk sizes as +* _WriteBlocking() will block until all data has been posted successfully. +* +* Parameters +* pRing Ring buffer to post to. +* pBuffer Pointer to character array. Does not need to point to a \0 terminated string. +* NumBytes Number of bytes to be stored in the SEGGER RTT control block. +* +* Return value +* >= 0 - Number of bytes written into buffer. +*/ +static unsigned _WriteBlocking(SEGGER_RTT_BUFFER_UP* pRing, const char* pBuffer, unsigned NumBytes) { + unsigned NumBytesToWrite; + unsigned NumBytesWritten; + unsigned RdOff; + unsigned WrOff; + volatile char* pDst; + // + // Write data to buffer and handle wrap-around if necessary + // + NumBytesWritten = 0u; + WrOff = pRing->WrOff; + do { + RdOff = pRing->RdOff; // May be changed by host (debug probe) in the meantime + if (RdOff > WrOff) { + NumBytesToWrite = RdOff - WrOff - 1u; + } else { + NumBytesToWrite = pRing->SizeOfBuffer - (WrOff - RdOff + 1u); + } + NumBytesToWrite = MIN(NumBytesToWrite, (pRing->SizeOfBuffer - WrOff)); // Number of bytes that can be written until buffer wrap-around + NumBytesToWrite = MIN(NumBytesToWrite, NumBytes); + pDst = (pRing->pBuffer + WrOff) + SEGGER_RTT_UNCACHED_OFF; +#if SEGGER_RTT_MEMCPY_USE_BYTELOOP + NumBytesWritten += NumBytesToWrite; + NumBytes -= NumBytesToWrite; + WrOff += NumBytesToWrite; + while (NumBytesToWrite--) { + *pDst++ = *pBuffer++; + }; +#else + SEGGER_RTT_MEMCPY((void*)pDst, pBuffer, NumBytesToWrite); + NumBytesWritten += NumBytesToWrite; + pBuffer += NumBytesToWrite; + NumBytes -= NumBytesToWrite; + WrOff += NumBytesToWrite; +#endif + if (WrOff == pRing->SizeOfBuffer) { + WrOff = 0u; + } + RTT__DMB(); // Force data write to be complete before writing the , in case CPU is allowed to change the order of memory accesses + pRing->WrOff = WrOff; + } while (NumBytes); + return NumBytesWritten; +} + +/********************************************************************* +* +* _WriteNoCheck() +* +* Function description +* Stores a specified number of characters in SEGGER RTT ring buffer +* and updates the associated write pointer which is periodically +* read by the host. +* It is callers responsibility to make sure data actually fits in buffer. +* +* Parameters +* pRing Ring buffer to post to. +* pBuffer Pointer to character array. Does not need to point to a \0 terminated string. +* NumBytes Number of bytes to be stored in the SEGGER RTT control block. +* +* Notes +* (1) If there might not be enough space in the "Up"-buffer, call _WriteBlocking +*/ +static void _WriteNoCheck(SEGGER_RTT_BUFFER_UP* pRing, const char* pData, unsigned NumBytes) { + unsigned NumBytesAtOnce; + unsigned WrOff; + unsigned Rem; + volatile char* pDst; + + WrOff = pRing->WrOff; + Rem = pRing->SizeOfBuffer - WrOff; + if (Rem > NumBytes) { + // + // All data fits before wrap around + // + pDst = (pRing->pBuffer + WrOff) + SEGGER_RTT_UNCACHED_OFF; +#if SEGGER_RTT_MEMCPY_USE_BYTELOOP + WrOff += NumBytes; + while (NumBytes--) { + *pDst++ = *pData++; + }; + RTT__DMB(); // Force data write to be complete before writing the , in case CPU is allowed to change the order of memory accesses + pRing->WrOff = WrOff; +#else + SEGGER_RTT_MEMCPY((void*)pDst, pData, NumBytes); + RTT__DMB(); // Force data write to be complete before writing the , in case CPU is allowed to change the order of memory accesses + pRing->WrOff = WrOff + NumBytes; +#endif + } else { + // + // We reach the end of the buffer, so need to wrap around + // +#if SEGGER_RTT_MEMCPY_USE_BYTELOOP + pDst = (pRing->pBuffer + WrOff) + SEGGER_RTT_UNCACHED_OFF; + NumBytesAtOnce = Rem; + while (NumBytesAtOnce--) { + *pDst++ = *pData++; + }; + pDst = pRing->pBuffer + SEGGER_RTT_UNCACHED_OFF; + NumBytesAtOnce = NumBytes - Rem; + while (NumBytesAtOnce--) { + *pDst++ = *pData++; + }; + RTT__DMB(); // Force data write to be complete before writing the , in case CPU is allowed to change the order of memory accesses + pRing->WrOff = NumBytes - Rem; +#else + NumBytesAtOnce = Rem; + pDst = (pRing->pBuffer + WrOff) + SEGGER_RTT_UNCACHED_OFF; + SEGGER_RTT_MEMCPY((void*)pDst, pData, NumBytesAtOnce); + NumBytesAtOnce = NumBytes - Rem; + pDst = pRing->pBuffer + SEGGER_RTT_UNCACHED_OFF; + SEGGER_RTT_MEMCPY((void*)pDst, pData + Rem, NumBytesAtOnce); + RTT__DMB(); // Force data write to be complete before writing the , in case CPU is allowed to change the order of memory accesses + pRing->WrOff = NumBytesAtOnce; +#endif + } +} + +#ifndef CUSTOM_RTT +/********************************************************************* +* +* _PostTerminalSwitch() +* +* Function description +* Switch terminal to the given terminal ID. It is the caller's +* responsibility to ensure the terminal ID is correct and there is +* enough space in the buffer for this to complete successfully. +* +* Parameters +* pRing Ring buffer to post to. +* TerminalId Terminal ID to switch to. +*/ +static void _PostTerminalSwitch(SEGGER_RTT_BUFFER_UP* pRing, unsigned char TerminalId) { + unsigned char ac[2]; + + ac[0] = 0xFFu; + ac[1] = _aTerminalId[TerminalId]; // Caller made already sure that TerminalId does not exceed our terminal limit + _WriteBlocking(pRing, (const char*)ac, 2u); +} +#endif + +/********************************************************************* +* +* _GetAvailWriteSpace() +* +* Function description +* Returns the number of bytes that can be written to the ring +* buffer without blocking. +* +* Parameters +* pRing Ring buffer to check. +* +* Return value +* Number of bytes that are free in the buffer. +*/ +static unsigned _GetAvailWriteSpace(SEGGER_RTT_BUFFER_UP* pRing) { + unsigned RdOff; + unsigned WrOff; + unsigned r; + // + // Avoid warnings regarding volatile access order. It's not a problem + // in this case, but dampen compiler enthusiasm. + // + RdOff = pRing->RdOff; + WrOff = pRing->WrOff; + if (RdOff <= WrOff) { + r = pRing->SizeOfBuffer - 1u - WrOff + RdOff; + } else { + r = RdOff - WrOff - 1u; + } + return r; +} + +/********************************************************************* +* +* Public code +* +********************************************************************** +*/ + +/********************************************************************* +* +* SEGGER_RTT_ReadUpBufferNoLock() +* +* Function description +* Reads characters from SEGGER real-time-terminal control block +* which have been previously stored by the application. +* Do not lock against interrupts and multiple access. +* Used to do the same operation that J-Link does, to transfer +* RTT data via other channels, such as TCP/IP or UART. +* +* Parameters +* BufferIndex Index of Up-buffer to be used. +* pBuffer Pointer to buffer provided by target application, to copy characters from RTT-up-buffer to. +* BufferSize Size of the target application buffer. +* +* Return value +* Number of bytes that have been read. +* +* Additional information +* This function must not be called when J-Link might also do RTT. +*/ +unsigned SEGGER_RTT_ReadUpBufferNoLock(unsigned BufferIndex, void* pData, unsigned BufferSize) { + unsigned NumBytesRem; + unsigned NumBytesRead; + unsigned RdOff; + unsigned WrOff; + unsigned char* pBuffer; + SEGGER_RTT_BUFFER_UP* pRing; + volatile char* pSrc; + + INIT(); + pRing = (SEGGER_RTT_BUFFER_UP*)((uintptr_t)&_SEGGER_RTT.aUp[BufferIndex] + SEGGER_RTT_UNCACHED_OFF); // Access uncached to make sure we see changes made by the J-Link side and all of our changes go into HW directly + pBuffer = (unsigned char*)pData; + RdOff = pRing->RdOff; + WrOff = pRing->WrOff; + NumBytesRead = 0u; + // + // Read from current read position to wrap-around of buffer, first + // + if (RdOff > WrOff) { + NumBytesRem = pRing->SizeOfBuffer - RdOff; + NumBytesRem = MIN(NumBytesRem, BufferSize); + pSrc = (pRing->pBuffer + RdOff) + SEGGER_RTT_UNCACHED_OFF; +#if SEGGER_RTT_MEMCPY_USE_BYTELOOP + NumBytesRead += NumBytesRem; + BufferSize -= NumBytesRem; + RdOff += NumBytesRem; + while (NumBytesRem--) { + *pBuffer++ = *pSrc++; + }; +#else + SEGGER_RTT_MEMCPY(pBuffer, (void*)pSrc, NumBytesRem); + NumBytesRead += NumBytesRem; + pBuffer += NumBytesRem; + BufferSize -= NumBytesRem; + RdOff += NumBytesRem; +#endif + // + // Handle wrap-around of buffer + // + if (RdOff == pRing->SizeOfBuffer) { + RdOff = 0u; + } + } + // + // Read remaining items of buffer + // + NumBytesRem = WrOff - RdOff; + NumBytesRem = MIN(NumBytesRem, BufferSize); + if (NumBytesRem > 0u) { + pSrc = (pRing->pBuffer + RdOff) + SEGGER_RTT_UNCACHED_OFF; +#if SEGGER_RTT_MEMCPY_USE_BYTELOOP + NumBytesRead += NumBytesRem; + BufferSize -= NumBytesRem; + RdOff += NumBytesRem; + while (NumBytesRem--) { + *pBuffer++ = *pSrc++; + }; +#else + SEGGER_RTT_MEMCPY(pBuffer, (void*)pSrc, NumBytesRem); + NumBytesRead += NumBytesRem; + pBuffer += NumBytesRem; + BufferSize -= NumBytesRem; + RdOff += NumBytesRem; +#endif + } + // + // Update read offset of buffer + // + if (NumBytesRead) { + pRing->RdOff = RdOff; + } + // + return NumBytesRead; +} + +/********************************************************************* +* +* SEGGER_RTT_ReadNoLock() +* +* Function description +* Reads characters from SEGGER real-time-terminal control block +* which have been previously stored by the host. +* Do not lock against interrupts and multiple access. +* +* Parameters +* BufferIndex Index of Down-buffer to be used (e.g. 0 for "Terminal"). +* pBuffer Pointer to buffer provided by target application, to copy characters from RTT-down-buffer to. +* BufferSize Size of the target application buffer. +* +* Return value +* Number of bytes that have been read. +*/ +unsigned SEGGER_RTT_ReadNoLock(unsigned BufferIndex, void* pData, unsigned BufferSize) { + unsigned NumBytesRem; + unsigned NumBytesRead; + unsigned RdOff; + unsigned WrOff; + unsigned char* pBuffer; + SEGGER_RTT_BUFFER_DOWN* pRing; + volatile char* pSrc; + // + INIT(); + pRing = (SEGGER_RTT_BUFFER_DOWN*)((uintptr_t)&_SEGGER_RTT.aDown[BufferIndex] + SEGGER_RTT_UNCACHED_OFF); // Access uncached to make sure we see changes made by the J-Link side and all of our changes go into HW directly + pBuffer = (unsigned char*)pData; + RdOff = pRing->RdOff; + WrOff = pRing->WrOff; + NumBytesRead = 0u; + // + // Read from current read position to wrap-around of buffer, first + // + if (RdOff > WrOff) { + NumBytesRem = pRing->SizeOfBuffer - RdOff; + NumBytesRem = MIN(NumBytesRem, BufferSize); + pSrc = (pRing->pBuffer + RdOff) + SEGGER_RTT_UNCACHED_OFF; +#if SEGGER_RTT_MEMCPY_USE_BYTELOOP + NumBytesRead += NumBytesRem; + BufferSize -= NumBytesRem; + RdOff += NumBytesRem; + while (NumBytesRem--) { + *pBuffer++ = *pSrc++; + }; +#else + SEGGER_RTT_MEMCPY(pBuffer, (void*)pSrc, NumBytesRem); + NumBytesRead += NumBytesRem; + pBuffer += NumBytesRem; + BufferSize -= NumBytesRem; + RdOff += NumBytesRem; +#endif + // + // Handle wrap-around of buffer + // + if (RdOff == pRing->SizeOfBuffer) { + RdOff = 0u; + } + } + // + // Read remaining items of buffer + // + NumBytesRem = WrOff - RdOff; + NumBytesRem = MIN(NumBytesRem, BufferSize); + if (NumBytesRem > 0u) { + pSrc = (pRing->pBuffer + RdOff) + SEGGER_RTT_UNCACHED_OFF; +#if SEGGER_RTT_MEMCPY_USE_BYTELOOP + NumBytesRead += NumBytesRem; + BufferSize -= NumBytesRem; + RdOff += NumBytesRem; + while (NumBytesRem--) { + *pBuffer++ = *pSrc++; + }; +#else + SEGGER_RTT_MEMCPY(pBuffer, (void*)pSrc, NumBytesRem); + NumBytesRead += NumBytesRem; + pBuffer += NumBytesRem; + BufferSize -= NumBytesRem; + RdOff += NumBytesRem; +#endif + } + if (NumBytesRead) { + pRing->RdOff = RdOff; + } + // + return NumBytesRead; +} + +/********************************************************************* +* +* SEGGER_RTT_ReadUpBuffer +* +* Function description +* Reads characters from SEGGER real-time-terminal control block +* which have been previously stored by the application. +* Used to do the same operation that J-Link does, to transfer +* RTT data via other channels, such as TCP/IP or UART. +* +* Parameters +* BufferIndex Index of Up-buffer to be used. +* pBuffer Pointer to buffer provided by target application, to copy characters from RTT-up-buffer to. +* BufferSize Size of the target application buffer. +* +* Return value +* Number of bytes that have been read. +* +* Additional information +* This function must not be called when J-Link might also do RTT. +* This function locks against all other RTT operations. I.e. during +* the read operation, writing is also locked. +* If only one consumer reads from the up buffer, +* call sEGGER_RTT_ReadUpBufferNoLock() instead. +*/ +unsigned SEGGER_RTT_ReadUpBuffer(unsigned BufferIndex, void* pBuffer, unsigned BufferSize) { + unsigned NumBytesRead; + + SEGGER_RTT_LOCK(); + // + // Call the non-locking read function + // + NumBytesRead = SEGGER_RTT_ReadUpBufferNoLock(BufferIndex, pBuffer, BufferSize); + // + // Finish up. + // + SEGGER_RTT_UNLOCK(); + // + return NumBytesRead; +} + +/********************************************************************* +* +* SEGGER_RTT_Read +* +* Function description +* Reads characters from SEGGER real-time-terminal control block +* which have been previously stored by the host. +* +* Parameters +* BufferIndex Index of Down-buffer to be used (e.g. 0 for "Terminal"). +* pBuffer Pointer to buffer provided by target application, to copy characters from RTT-down-buffer to. +* BufferSize Size of the target application buffer. +* +* Return value +* Number of bytes that have been read. +*/ +unsigned SEGGER_RTT_Read(unsigned BufferIndex, void* pBuffer, unsigned BufferSize) { + unsigned NumBytesRead; + + SEGGER_RTT_LOCK(); + // + // Call the non-locking read function + // + NumBytesRead = SEGGER_RTT_ReadNoLock(BufferIndex, pBuffer, BufferSize); + // + // Finish up. + // + SEGGER_RTT_UNLOCK(); + // + return NumBytesRead; +} + +/********************************************************************* +* +* SEGGER_RTT_WriteWithOverwriteNoLock +* +* Function description +* Stores a specified number of characters in SEGGER RTT +* control block. +* SEGGER_RTT_WriteWithOverwriteNoLock does not lock the application +* and overwrites data if the data does not fit into the buffer. +* +* Parameters +* BufferIndex Index of "Up"-buffer to be used (e.g. 0 for "Terminal"). +* pBuffer Pointer to character array. Does not need to point to a \0 terminated string. +* NumBytes Number of bytes to be stored in the SEGGER RTT control block. +* +* Notes +* (1) If there is not enough space in the "Up"-buffer, data is overwritten. +* (2) For performance reasons this function does not call Init() +* and may only be called after RTT has been initialized. +* Either by calling SEGGER_RTT_Init() or calling another RTT API function first. +* (3) Do not use SEGGER_RTT_WriteWithOverwriteNoLock if a J-Link +* connection reads RTT data. +*/ +void SEGGER_RTT_WriteWithOverwriteNoLock(unsigned BufferIndex, const void* pBuffer, unsigned NumBytes) { + const char* pData; + SEGGER_RTT_BUFFER_UP* pRing; + unsigned Avail; + volatile char* pDst; + // + // Get "to-host" ring buffer and copy some elements into local variables. + // + pData = (const char *)pBuffer; + pRing = (SEGGER_RTT_BUFFER_UP*)((uintptr_t)&_SEGGER_RTT.aUp[BufferIndex] + SEGGER_RTT_UNCACHED_OFF); // Access uncached to make sure we see changes made by the J-Link side and all of our changes go into HW directly + // + // Check if we will overwrite data and need to adjust the RdOff. + // + if (pRing->WrOff == pRing->RdOff) { + Avail = pRing->SizeOfBuffer - 1u; + } else if ( pRing->WrOff < pRing->RdOff) { + Avail = pRing->RdOff - pRing->WrOff - 1u; + } else { + Avail = pRing->RdOff - pRing->WrOff - 1u + pRing->SizeOfBuffer; + } + if (NumBytes > Avail) { + pRing->RdOff += (NumBytes - Avail); + while (pRing->RdOff >= pRing->SizeOfBuffer) { + pRing->RdOff -= pRing->SizeOfBuffer; + } + } + // + // Write all data, no need to check the RdOff, but possibly handle multiple wrap-arounds + // + Avail = pRing->SizeOfBuffer - pRing->WrOff; + do { + if (Avail > NumBytes) { + // + // Last round + // + pDst = (pRing->pBuffer + pRing->WrOff) + SEGGER_RTT_UNCACHED_OFF; +#if SEGGER_RTT_MEMCPY_USE_BYTELOOP + Avail = NumBytes; + while (NumBytes--) { + *pDst++ = *pData++; + }; + RTT__DMB(); // Force data write to be complete before writing the , in case CPU is allowed to change the order of memory accesses + pRing->WrOff += Avail; +#else + SEGGER_RTT_MEMCPY((void*)pDst, pData, NumBytes); + RTT__DMB(); // Force data write to be complete before writing the , in case CPU is allowed to change the order of memory accesses + pRing->WrOff += NumBytes; +#endif + break; + } else { + // + // Wrap-around necessary, write until wrap-around and reset WrOff + // + pDst = (pRing->pBuffer + pRing->WrOff) + SEGGER_RTT_UNCACHED_OFF; +#if SEGGER_RTT_MEMCPY_USE_BYTELOOP + NumBytes -= Avail; + while (Avail--) { + *pDst++ = *pData++; + }; + RTT__DMB(); // Force data write to be complete before writing the , in case CPU is allowed to change the order of memory accesses + pRing->WrOff = 0; +#else + SEGGER_RTT_MEMCPY((void*)pDst, pData, Avail); + pData += Avail; + RTT__DMB(); // Force data write to be complete before writing the , in case CPU is allowed to change the order of memory accesses + pRing->WrOff = 0; + NumBytes -= Avail; +#endif + Avail = (pRing->SizeOfBuffer - 1); + } + } while (NumBytes); +} + +/********************************************************************* +* +* SEGGER_RTT_WriteSkipNoLock +* +* Function description +* Stores a specified number of characters in SEGGER RTT +* control block which is then read by the host. +* SEGGER_RTT_WriteSkipNoLock does not lock the application and +* skips all data, if the data does not fit into the buffer. +* +* Parameters +* BufferIndex Index of "Up"-buffer to be used (e.g. 0 for "Terminal"). +* pBuffer Pointer to character array. Does not need to point to a \0 terminated string. +* NumBytes Number of bytes to be stored in the SEGGER RTT control block. +* MUST be > 0!!! +* This is done for performance reasons, so no initial check has do be done. +* +* Return value +* 1: Data has been copied +* 0: No space, data has not been copied +* +* Notes +* (1) If there is not enough space in the "Up"-buffer, all data is dropped. +* (2) For performance reasons this function does not call Init() +* and may only be called after RTT has been initialized. +* Either by calling SEGGER_RTT_Init() or calling another RTT API function first. +*/ +#if (RTT_USE_ASM == 0) +unsigned SEGGER_RTT_WriteSkipNoLock(unsigned BufferIndex, const void* pBuffer, unsigned NumBytes) { + const char* pData; + SEGGER_RTT_BUFFER_UP* pRing; + unsigned Avail; + unsigned RdOff; + unsigned WrOff; + unsigned Rem; + volatile char* pDst; + // + // Cases: + // 1) RdOff <= WrOff => Space until wrap-around is sufficient + // 2) RdOff <= WrOff => Space after wrap-around needed (copy in 2 chunks) + // 3) RdOff < WrOff => No space in buf + // 4) RdOff > WrOff => Space is sufficient + // 5) RdOff > WrOff => No space in buf + // + // 1) is the most common case for large buffers and assuming that J-Link reads the data fast enough + // + pData = (const char *)pBuffer; + pRing = (SEGGER_RTT_BUFFER_UP*)((uintptr_t)&_SEGGER_RTT.aUp[BufferIndex] + SEGGER_RTT_UNCACHED_OFF); // Access uncached to make sure we see changes made by the J-Link side and all of our changes go into HW directly + RdOff = pRing->RdOff; + WrOff = pRing->WrOff; + pDst = (pRing->pBuffer + WrOff) + SEGGER_RTT_UNCACHED_OFF; + if (RdOff <= WrOff) { // Case 1), 2) or 3) + Avail = pRing->SizeOfBuffer - WrOff - 1u; // Space until wrap-around (assume 1 byte not usable for case that RdOff == 0) + if (Avail >= NumBytes) { // Case 1)? + memcpy((void*)pDst, pData, NumBytes); + RTT__DMB(); // Force data write to be complete before writing the , in case CPU is allowed to change the order of memory accesses + pRing->WrOff = WrOff + NumBytes; + return 1; + } + Avail += RdOff; // Space incl. wrap-around + if (Avail >= NumBytes) { // Case 2? => If not, we have case 3) (does not fit) + Rem = pRing->SizeOfBuffer - WrOff; // Space until end of buffer + memcpy((void*)pDst, pData, Rem); // Copy 1st chunk + NumBytes -= Rem; + // + // Special case: First check that assumed RdOff == 0 calculated that last element before wrap-around could not be used + // But 2nd check (considering space until wrap-around and until RdOff) revealed that RdOff is not 0, so we can use the last element + // In this case, we may use a copy straight until buffer end anyway without needing to copy 2 chunks + // Therefore, check if 2nd memcpy is necessary at all + // + if (NumBytes) { + pDst = pRing->pBuffer + SEGGER_RTT_UNCACHED_OFF; + memcpy((void*)pDst, pData + Rem, NumBytes); + } + RTT__DMB(); // Force data write to be complete before writing the , in case CPU is allowed to change the order of memory accesses + pRing->WrOff = NumBytes; + return 1; + } + } else { // Potential case 4) + Avail = RdOff - WrOff - 1u; + if (Avail >= NumBytes) { // Case 4)? => If not, we have case 5) (does not fit) + memcpy((void*)pDst, pData, NumBytes); + RTT__DMB(); // Force data write to be complete before writing the , in case CPU is allowed to change the order of memory accesses + pRing->WrOff = WrOff + NumBytes; + return 1; + } + } + return 0; // No space in buffer +} +#endif + +/********************************************************************* +* +* SEGGER_RTT_WriteDownBufferNoLock +* +* Function description +* Stores a specified number of characters in SEGGER RTT +* control block inside a buffer. +* SEGGER_RTT_WriteDownBufferNoLock does not lock the application. +* Used to do the same operation that J-Link does, to transfer +* RTT data from other channels, such as TCP/IP or UART. +* +* Parameters +* BufferIndex Index of "Down"-buffer to be used. +* pBuffer Pointer to character array. Does not need to point to a \0 terminated string. +* NumBytes Number of bytes to be stored in the SEGGER RTT control block. +* +* Return value +* Number of bytes which have been stored in the "Down"-buffer. +* +* Notes +* (1) Data is stored according to buffer flags. +* (2) For performance reasons this function does not call Init() +* and may only be called after RTT has been initialized. +* Either by calling SEGGER_RTT_Init() or calling another RTT API function first. +* +* Additional information +* This function must not be called when J-Link might also do RTT. +*/ +unsigned SEGGER_RTT_WriteDownBufferNoLock(unsigned BufferIndex, const void* pBuffer, unsigned NumBytes) { + unsigned Status; + unsigned Avail; + const char* pData; + SEGGER_RTT_BUFFER_UP* pRing; + // + // Get "to-target" ring buffer. + // It is save to cast that to a "to-host" buffer. Up and Down buffer differ in volatility of offsets that might be modified by J-Link. + // + pData = (const char *)pBuffer; + pRing = (SEGGER_RTT_BUFFER_UP*)((uintptr_t)&_SEGGER_RTT.aDown[BufferIndex] + SEGGER_RTT_UNCACHED_OFF); // Access uncached to make sure we see changes made by the J-Link side and all of our changes go into HW directly + // + // How we output depends upon the mode... + // + switch (pRing->Flags) { + case SEGGER_RTT_MODE_NO_BLOCK_SKIP: + // + // If we are in skip mode and there is no space for the whole + // of this output, don't bother. + // + Avail = _GetAvailWriteSpace(pRing); + if (Avail < NumBytes) { + Status = 0u; + } else { + Status = NumBytes; + _WriteNoCheck(pRing, pData, NumBytes); + } + break; + case SEGGER_RTT_MODE_NO_BLOCK_TRIM: + // + // If we are in trim mode, trim to what we can output without blocking. + // + Avail = _GetAvailWriteSpace(pRing); + Status = Avail < NumBytes ? Avail : NumBytes; + _WriteNoCheck(pRing, pData, Status); + break; + case SEGGER_RTT_MODE_BLOCK_IF_FIFO_FULL: + // + // If we are in blocking mode, output everything. + // + Status = _WriteBlocking(pRing, pData, NumBytes); + break; + default: + Status = 0u; + break; + } + // + // Finish up. + // + return Status; +} + +/********************************************************************* +* +* SEGGER_RTT_WriteNoLock +* +* Function description +* Stores a specified number of characters in SEGGER RTT +* control block which is then read by the host. +* SEGGER_RTT_WriteNoLock does not lock the application. +* +* Parameters +* BufferIndex Index of "Up"-buffer to be used (e.g. 0 for "Terminal"). +* pBuffer Pointer to character array. Does not need to point to a \0 terminated string. +* NumBytes Number of bytes to be stored in the SEGGER RTT control block. +* +* Return value +* Number of bytes which have been stored in the "Up"-buffer. +* +* Notes +* (1) Data is stored according to buffer flags. +* (2) For performance reasons this function does not call Init() +* and may only be called after RTT has been initialized. +* Either by calling SEGGER_RTT_Init() or calling another RTT API function first. +*/ +unsigned SEGGER_RTT_WriteNoLock(unsigned BufferIndex, const void* pBuffer, unsigned NumBytes) { + unsigned Status; + unsigned Avail; + const char* pData; + SEGGER_RTT_BUFFER_UP* pRing; + // + // Get "to-host" ring buffer. + // + pData = (const char *)pBuffer; + pRing = (SEGGER_RTT_BUFFER_UP*)((uintptr_t)&_SEGGER_RTT.aUp[BufferIndex] + SEGGER_RTT_UNCACHED_OFF); // Access uncached to make sure we see changes made by the J-Link side and all of our changes go into HW directly + // + // How we output depends upon the mode... + // + switch (pRing->Flags) { + case SEGGER_RTT_MODE_NO_BLOCK_SKIP: + // + // If we are in skip mode and there is no space for the whole + // of this output, don't bother. + // + Avail = _GetAvailWriteSpace(pRing); + if (Avail < NumBytes) { + Status = 0u; + } else { + Status = NumBytes; + _WriteNoCheck(pRing, pData, NumBytes); + } + break; + case SEGGER_RTT_MODE_NO_BLOCK_TRIM: + // + // If we are in trim mode, trim to what we can output without blocking. + // + Avail = _GetAvailWriteSpace(pRing); + Status = Avail < NumBytes ? Avail : NumBytes; + _WriteNoCheck(pRing, pData, Status); + break; + case SEGGER_RTT_MODE_BLOCK_IF_FIFO_FULL: + // + // If we are in blocking mode, output everything. + // + Status = _WriteBlocking(pRing, pData, NumBytes); + break; + default: + Status = 0u; + break; + } + // + // Finish up. + // + return Status; +} + +/********************************************************************* +* +* SEGGER_RTT_WriteDownBuffer +* +* Function description +* Stores a specified number of characters in SEGGER RTT control block in a buffer. +* +* Parameters +* BufferIndex Index of "Up"-buffer to be used (e.g. 0 for "Terminal"). +* pBuffer Pointer to character array. Does not need to point to a \0 terminated string. +* NumBytes Number of bytes to be stored in the SEGGER RTT control block. +* +* Return value +* Number of bytes which have been stored in the "Down"-buffer. +* +* Notes +* (1) Data is stored according to buffer flags. +* +* Additional information +* This function must not be called when J-Link might also do RTT. +* This function locks against all other RTT operations. I.e. during +* the write operation, writing from the application is also locked. +* If only one consumer writes to the down buffer, +* call SEGGER_RTT_WriteDownBufferNoLock() instead. +*/ +unsigned SEGGER_RTT_WriteDownBuffer(unsigned BufferIndex, const void* pBuffer, unsigned NumBytes) { + unsigned Status; + + INIT(); + SEGGER_RTT_LOCK(); + Status = SEGGER_RTT_WriteDownBufferNoLock(BufferIndex, pBuffer, NumBytes); // Call the non-locking write function + SEGGER_RTT_UNLOCK(); + return Status; +} + +/********************************************************************* +* +* SEGGER_RTT_Write +* +* Function description +* Stores a specified number of characters in SEGGER RTT +* control block which is then read by the host. +* +* Parameters +* BufferIndex Index of "Up"-buffer to be used (e.g. 0 for "Terminal"). +* pBuffer Pointer to character array. Does not need to point to a \0 terminated string. +* NumBytes Number of bytes to be stored in the SEGGER RTT control block. +* +* Return value +* Number of bytes which have been stored in the "Up"-buffer. +* +* Notes +* (1) Data is stored according to buffer flags. +*/ +unsigned SEGGER_RTT_Write(unsigned BufferIndex, const void* pBuffer, unsigned NumBytes) { + unsigned Status; + + INIT(); + SEGGER_RTT_LOCK(); + Status = SEGGER_RTT_WriteNoLock(BufferIndex, pBuffer, NumBytes); // Call the non-locking write function + SEGGER_RTT_UNLOCK(); + return Status; +} + +/********************************************************************* +* +* SEGGER_RTT_WriteString +* +* Function description +* Stores 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"). +* s Pointer to string. +* +* Return value +* Number of bytes which have been stored in the "Up"-buffer. +* +* Notes +* (1) Data is stored according to buffer flags. +* (2) String passed to this function has to be \0 terminated +* (3) \0 termination character is *not* stored in RTT buffer +*/ +unsigned SEGGER_RTT_WriteString(unsigned BufferIndex, const char* s) { + unsigned Len; + + Len = STRLEN(s); + return SEGGER_RTT_Write(BufferIndex, s, Len); +} + +/********************************************************************* +* +* SEGGER_RTT_PutCharSkipNoLock +* +* Function description +* Stores a single character/byte in SEGGER RTT buffer. +* SEGGER_RTT_PutCharSkipNoLock does not lock the application and +* skips the byte, if it does not fit into the buffer. +* +* Parameters +* BufferIndex Index of "Up"-buffer to be used (e.g. 0 for "Terminal"). +* c Byte to be stored. +* +* Return value +* Number of bytes which have been stored in the "Up"-buffer. +* +* Notes +* (1) If there is not enough space in the "Up"-buffer, the character is dropped. +* (2) For performance reasons this function does not call Init() +* and may only be called after RTT has been initialized. +* Either by calling SEGGER_RTT_Init() or calling another RTT API function first. +*/ + +unsigned SEGGER_RTT_PutCharSkipNoLock(unsigned BufferIndex, char c) { + SEGGER_RTT_BUFFER_UP* pRing; + unsigned WrOff; + unsigned Status; + volatile char* pDst; + // + // Get "to-host" ring buffer. + // + pRing = (SEGGER_RTT_BUFFER_UP*)((uintptr_t)&_SEGGER_RTT.aUp[BufferIndex] + SEGGER_RTT_UNCACHED_OFF); // Access uncached to make sure we see changes made by the J-Link side and all of our changes go into HW directly + // + // Get write position and handle wrap-around if necessary + // + WrOff = pRing->WrOff + 1; + if (WrOff == pRing->SizeOfBuffer) { + WrOff = 0; + } + // + // Output byte if free space is available + // + if (WrOff != pRing->RdOff) { + pDst = (pRing->pBuffer + pRing->WrOff) + SEGGER_RTT_UNCACHED_OFF; + *pDst = c; + RTT__DMB(); // Force data write to be complete before writing the , in case CPU is allowed to change the order of memory accesses + pRing->WrOff = WrOff; + Status = 1; + } else { + Status = 0; + } + // + return Status; +} + +/********************************************************************* +* +* SEGGER_RTT_PutCharSkip +* +* Function description +* Stores a single character/byte in SEGGER RTT buffer. +* +* Parameters +* BufferIndex Index of "Up"-buffer to be used (e.g. 0 for "Terminal"). +* c Byte to be stored. +* +* Return value +* Number of bytes which have been stored in the "Up"-buffer. +* +* Notes +* (1) If there is not enough space in the "Up"-buffer, the character is dropped. +*/ + +unsigned SEGGER_RTT_PutCharSkip(unsigned BufferIndex, char c) { + SEGGER_RTT_BUFFER_UP* pRing; + unsigned WrOff; + unsigned Status; + volatile char* pDst; + // + // Prepare + // + INIT(); + SEGGER_RTT_LOCK(); + // + // Get "to-host" ring buffer. + // + pRing = (SEGGER_RTT_BUFFER_UP*)((uintptr_t)&_SEGGER_RTT.aUp[BufferIndex] + SEGGER_RTT_UNCACHED_OFF); // Access uncached to make sure we see changes made by the J-Link side and all of our changes go into HW directly + // + // Get write position and handle wrap-around if necessary + // + WrOff = pRing->WrOff + 1; + if (WrOff == pRing->SizeOfBuffer) { + WrOff = 0; + } + // + // Output byte if free space is available + // + if (WrOff != pRing->RdOff) { + pDst = (pRing->pBuffer + pRing->WrOff) + SEGGER_RTT_UNCACHED_OFF; + *pDst = c; + RTT__DMB(); // Force data write to be complete before writing the , in case CPU is allowed to change the order of memory accesses + pRing->WrOff = WrOff; + Status = 1; + } else { + Status = 0; + } + // + // Finish up. + // + SEGGER_RTT_UNLOCK(); + // + return Status; +} + + /********************************************************************* +* +* SEGGER_RTT_PutChar +* +* Function description +* Stores a single character/byte in SEGGER RTT buffer. +* +* Parameters +* BufferIndex Index of "Up"-buffer to be used (e.g. 0 for "Terminal"). +* c Byte to be stored. +* +* Return value +* Number of bytes which have been stored in the "Up"-buffer. +* +* Notes +* (1) Data is stored according to buffer flags. +*/ + +unsigned SEGGER_RTT_PutChar(unsigned BufferIndex, char c) { + SEGGER_RTT_BUFFER_UP* pRing; + unsigned WrOff; + unsigned Status; + volatile char* pDst; + // + // Prepare + // + INIT(); + SEGGER_RTT_LOCK(); + // + // Get "to-host" ring buffer. + // + pRing = (SEGGER_RTT_BUFFER_UP*)((uintptr_t)&_SEGGER_RTT.aUp[BufferIndex] + SEGGER_RTT_UNCACHED_OFF); // Access uncached to make sure we see changes made by the J-Link side and all of our changes go into HW directly + // + // Get write position and handle wrap-around if necessary + // + WrOff = pRing->WrOff + 1; + if (WrOff == pRing->SizeOfBuffer) { + WrOff = 0; + } + // + // Wait for free space if mode is set to blocking + // + if (pRing->Flags == SEGGER_RTT_MODE_BLOCK_IF_FIFO_FULL) { + while (WrOff == pRing->RdOff) { + ; + } + } + // + // Output byte if free space is available + // + if (WrOff != pRing->RdOff) { + pDst = (pRing->pBuffer + pRing->WrOff) + SEGGER_RTT_UNCACHED_OFF; + *pDst = c; + RTT__DMB(); // Force data write to be complete before writing the , in case CPU is allowed to change the order of memory accesses + pRing->WrOff = WrOff; + Status = 1; + } else { + Status = 0; + } + // + // Finish up. + // + SEGGER_RTT_UNLOCK(); + return Status; +} + +/********************************************************************* +* +* SEGGER_RTT_GetKey +* +* Function description +* Reads one character from the SEGGER RTT buffer. +* Host has previously stored data there. +* +* Return value +* < 0 - No character available (buffer empty). +* >= 0 - Character which has been read. (Possible values: 0 - 255) +* +* Notes +* (1) This function is only specified for accesses to RTT buffer 0. +*/ +int SEGGER_RTT_GetKey(void) { + char c; + int r; + + r = (int)SEGGER_RTT_Read(0u, &c, 1u); + if (r == 1) { + r = (int)(unsigned char)c; + } else { + r = -1; + } + return r; +} + +/********************************************************************* +* +* SEGGER_RTT_WaitKey +* +* Function description +* Waits until at least one character is avaible in the SEGGER RTT buffer. +* Once a character is available, it is read and this function returns. +* +* Return value +* >=0 - Character which has been read. +* +* Notes +* (1) This function is only specified for accesses to RTT buffer 0 +* (2) This function is blocking if no character is present in RTT buffer +*/ +int SEGGER_RTT_WaitKey(void) { + int r; + + do { + r = SEGGER_RTT_GetKey(); + } while (r < 0); + return r; +} + +/********************************************************************* +* +* SEGGER_RTT_HasKey +* +* Function description +* Checks if at least one character for reading is available in the SEGGER RTT buffer. +* +* Return value +* == 0 - No characters are available to read. +* == 1 - At least one character is available. +* +* Notes +* (1) This function is only specified for accesses to RTT buffer 0 +*/ +int SEGGER_RTT_HasKey(void) { + SEGGER_RTT_BUFFER_DOWN* pRing; + unsigned RdOff; + int r; + + INIT(); + pRing = (SEGGER_RTT_BUFFER_DOWN*)((uintptr_t)&_SEGGER_RTT.aDown[0] + SEGGER_RTT_UNCACHED_OFF); // Access uncached to make sure we see changes made by the J-Link side and all of our changes go into HW directly + RdOff = pRing->RdOff; + if (RdOff != pRing->WrOff) { + r = 1; + } else { + r = 0; + } + return r; +} + +/********************************************************************* +* +* SEGGER_RTT_HasData +* +* Function description +* Check if there is data from the host in the given buffer. +* +* Return value: +* ==0: No data +* !=0: Data in buffer +* +*/ +unsigned SEGGER_RTT_HasData(unsigned BufferIndex) { + SEGGER_RTT_BUFFER_DOWN* pRing; + unsigned v; + + pRing = (SEGGER_RTT_BUFFER_DOWN*)((uintptr_t)&_SEGGER_RTT.aDown[BufferIndex] + SEGGER_RTT_UNCACHED_OFF); // Access uncached to make sure we see changes made by the J-Link side and all of our changes go into HW directly + v = pRing->WrOff; + return v - pRing->RdOff; +} + +/********************************************************************* +* +* SEGGER_RTT_HasDataUp +* +* Function description +* Check if there is data remaining to be sent in the given buffer. +* +* Return value: +* ==0: No data +* !=0: Data in buffer +* +*/ +unsigned SEGGER_RTT_HasDataUp(unsigned BufferIndex) { + SEGGER_RTT_BUFFER_UP* pRing; + unsigned v; + + pRing = (SEGGER_RTT_BUFFER_UP*)((uintptr_t)&_SEGGER_RTT.aUp[BufferIndex] + SEGGER_RTT_UNCACHED_OFF); // Access uncached to make sure we see changes made by the J-Link side and all of our changes go into HW directly + v = pRing->RdOff; + return pRing->WrOff - v; +} + +/********************************************************************* +* +* SEGGER_RTT_AllocDownBuffer +* +* Function description +* Run-time configuration of the next down-buffer (H->T). +* The next buffer, which is not used yet is configured. +* This includes: Buffer address, size, name, flags, ... +* +* Parameters +* sName Pointer to a constant name string. +* pBuffer Pointer to a buffer to be used. +* BufferSize Size of the buffer. +* Flags Operating modes. Define behavior if buffer is full (not enough space for entire message). +* Flags[31:24] are used for validity check and must be zero. Flags[23:2] are reserved for future use. Flags[1:0] = RTT operating mode. +* +* Return value +* >= 0 - O.K. Buffer Index +* < 0 - Error +*/ +int SEGGER_RTT_AllocDownBuffer(const char* sName, void* pBuffer, unsigned BufferSize, unsigned Flags) { + int BufferIndex; + volatile SEGGER_RTT_CB* pRTTCB; + + INIT(); + SEGGER_RTT_LOCK(); + pRTTCB = (volatile SEGGER_RTT_CB*)((uintptr_t)&_SEGGER_RTT + SEGGER_RTT_UNCACHED_OFF); // Access RTTCB uncached to make sure we see changes made by the J-Link side and all of our changes go into HW directly + BufferIndex = 0; + do { + if (pRTTCB->aDown[BufferIndex].pBuffer == NULL) { + break; + } + BufferIndex++; + } while (BufferIndex < pRTTCB->MaxNumDownBuffers); + if (BufferIndex < pRTTCB->MaxNumDownBuffers) { + pRTTCB->aDown[BufferIndex].sName = sName; + pRTTCB->aDown[BufferIndex].pBuffer = (char*)pBuffer; + pRTTCB->aDown[BufferIndex].SizeOfBuffer = BufferSize; + pRTTCB->aDown[BufferIndex].RdOff = 0u; + pRTTCB->aDown[BufferIndex].WrOff = 0u; + pRTTCB->aDown[BufferIndex].Flags = Flags; + RTT__DMB(); // Force data write to be complete before writing the , in case CPU is allowed to change the order of memory accesses + } else { + BufferIndex = -1; + } + SEGGER_RTT_UNLOCK(); + return BufferIndex; +} + +/********************************************************************* +* +* SEGGER_RTT_AllocUpBuffer +* +* Function description +* Run-time configuration of the next up-buffer (T->H). +* The next buffer, which is not used yet is configured. +* This includes: Buffer address, size, name, flags, ... +* +* Parameters +* sName Pointer to a constant name string. +* pBuffer Pointer to a buffer to be used. +* BufferSize Size of the buffer. +* Flags Operating modes. Define behavior if buffer is full (not enough space for entire message). +* Flags[31:24] are used for validity check and must be zero. Flags[23:2] are reserved for future use. Flags[1:0] = RTT operating mode. +* +* Return value +* >= 0 - O.K. Buffer Index +* < 0 - Error +*/ +int SEGGER_RTT_AllocUpBuffer(const char* sName, void* pBuffer, unsigned BufferSize, unsigned Flags) { + int BufferIndex; + volatile SEGGER_RTT_CB* pRTTCB; + + INIT(); + SEGGER_RTT_LOCK(); + pRTTCB = (volatile SEGGER_RTT_CB*)((uintptr_t)&_SEGGER_RTT + SEGGER_RTT_UNCACHED_OFF); // Access RTTCB uncached to make sure we see changes made by the J-Link side and all of our changes go into HW directly + BufferIndex = 0; + do { + if (pRTTCB->aUp[BufferIndex].pBuffer == NULL) { + break; + } + BufferIndex++; + } while (BufferIndex < pRTTCB->MaxNumUpBuffers); + if (BufferIndex < pRTTCB->MaxNumUpBuffers) { + pRTTCB->aUp[BufferIndex].sName = sName; + pRTTCB->aUp[BufferIndex].pBuffer = (char*)pBuffer; + pRTTCB->aUp[BufferIndex].SizeOfBuffer = BufferSize; + pRTTCB->aUp[BufferIndex].RdOff = 0u; + pRTTCB->aUp[BufferIndex].WrOff = 0u; + pRTTCB->aUp[BufferIndex].Flags = Flags; + RTT__DMB(); // Force data write to be complete before writing the , in case CPU is allowed to change the order of memory accesses + } else { + BufferIndex = -1; + } + SEGGER_RTT_UNLOCK(); + return BufferIndex; +} + +/********************************************************************* +* +* SEGGER_RTT_ConfigUpBuffer +* +* Function description +* Run-time configuration of a specific up-buffer (T->H). +* Buffer to be configured is specified by index. +* This includes: Buffer address, size, name, flags, ... +* +* Parameters +* BufferIndex Index of the buffer to configure. +* sName Pointer to a constant name string. +* pBuffer Pointer to a buffer to be used. +* BufferSize Size of the buffer. +* Flags Operating modes. Define behavior if buffer is full (not enough space for entire message). +* Flags[31:24] are used for validity check and must be zero. Flags[23:2] are reserved for future use. Flags[1:0] = RTT operating mode. +* +* Return value +* >= 0 - O.K. +* < 0 - Error +* +* Additional information +* Buffer 0 is configured on compile-time. +* May only be called once per buffer. +* Buffer name and flags can be reconfigured using the appropriate functions. +*/ +int SEGGER_RTT_ConfigUpBuffer(unsigned BufferIndex, const char* sName, void* pBuffer, unsigned BufferSize, unsigned Flags) { + int r; + volatile SEGGER_RTT_CB* pRTTCB; + volatile SEGGER_RTT_BUFFER_UP* pUp; + + INIT(); + pRTTCB = (volatile SEGGER_RTT_CB*)((uintptr_t)&_SEGGER_RTT + SEGGER_RTT_UNCACHED_OFF); // Access RTTCB uncached to make sure we see changes made by the J-Link side and all of our changes go into HW directly + if (BufferIndex < SEGGER_RTT_MAX_NUM_UP_BUFFERS) { + SEGGER_RTT_LOCK(); + pUp = &pRTTCB->aUp[BufferIndex]; +#ifdef CUSTOM_RTT + if (1) { +#else + if (BufferIndex) { +#endif + pUp->sName = sName; + pUp->pBuffer = (char*)pBuffer; + pUp->SizeOfBuffer = BufferSize; + pUp->RdOff = 0u; + pUp->WrOff = 0u; + } + pUp->Flags = Flags; + SEGGER_RTT_UNLOCK(); + r = 0; + } else { + r = -1; + } + return r; +} + +/********************************************************************* +* +* SEGGER_RTT_ConfigDownBuffer +* +* Function description +* Run-time configuration of a specific down-buffer (H->T). +* Buffer to be configured is specified by index. +* This includes: Buffer address, size, name, flags, ... +* +* Parameters +* BufferIndex Index of the buffer to configure. +* sName Pointer to a constant name string. +* pBuffer Pointer to a buffer to be used. +* BufferSize Size of the buffer. +* Flags Operating modes. Define behavior if buffer is full (not enough space for entire message). +* Flags[31:24] are used for validity check and must be zero. Flags[23:2] are reserved for future use. Flags[1:0] = RTT operating mode. +* +* Return value +* >= 0 O.K. +* < 0 Error +* +* Additional information +* Buffer 0 is configured on compile-time. +* May only be called once per buffer. +* Buffer name and flags can be reconfigured using the appropriate functions. +*/ +int SEGGER_RTT_ConfigDownBuffer(unsigned BufferIndex, const char* sName, void* pBuffer, unsigned BufferSize, unsigned Flags) { + int r; + volatile SEGGER_RTT_CB* pRTTCB; + volatile SEGGER_RTT_BUFFER_DOWN* pDown; + + INIT(); + pRTTCB = (volatile SEGGER_RTT_CB*)((uintptr_t)&_SEGGER_RTT + SEGGER_RTT_UNCACHED_OFF); // Access RTTCB uncached to make sure we see changes made by the J-Link side and all of our changes go into HW directly + if (BufferIndex < SEGGER_RTT_MAX_NUM_DOWN_BUFFERS) { + SEGGER_RTT_LOCK(); + pDown = &pRTTCB->aDown[BufferIndex]; +#ifdef CUSTOM_RTT + if (1) { +#else + if (BufferIndex) { +#endif + pDown->sName = sName; + pDown->pBuffer = (char*)pBuffer; + pDown->SizeOfBuffer = BufferSize; + pDown->RdOff = 0u; + pDown->WrOff = 0u; + } + pDown->Flags = Flags; + RTT__DMB(); // Force data write to be complete before writing the , in case CPU is allowed to change the order of memory accesses + SEGGER_RTT_UNLOCK(); + r = 0; + } else { + r = -1; + } + return r; +} + +/********************************************************************* +* +* SEGGER_RTT_SetNameUpBuffer +* +* Function description +* Run-time configuration of a specific up-buffer name (T->H). +* Buffer to be configured is specified by index. +* +* Parameters +* BufferIndex Index of the buffer to renamed. +* sName Pointer to a constant name string. +* +* Return value +* >= 0 O.K. +* < 0 Error +*/ +int SEGGER_RTT_SetNameUpBuffer(unsigned BufferIndex, const char* sName) { + int r; + volatile SEGGER_RTT_CB* pRTTCB; + volatile SEGGER_RTT_BUFFER_UP* pUp; + + INIT(); + pRTTCB = (volatile SEGGER_RTT_CB*)((uintptr_t)&_SEGGER_RTT + SEGGER_RTT_UNCACHED_OFF); // Access RTTCB uncached to make sure we see changes made by the J-Link side and all of our changes go into HW directly + if (BufferIndex < SEGGER_RTT_MAX_NUM_UP_BUFFERS) { + SEGGER_RTT_LOCK(); + pUp = &pRTTCB->aUp[BufferIndex]; + pUp->sName = sName; + SEGGER_RTT_UNLOCK(); + r = 0; + } else { + r = -1; + } + return r; +} + +/********************************************************************* +* +* SEGGER_RTT_SetNameDownBuffer +* +* Function description +* Run-time configuration of a specific Down-buffer name (T->H). +* Buffer to be configured is specified by index. +* +* Parameters +* BufferIndex Index of the buffer to renamed. +* sName Pointer to a constant name string. +* +* Return value +* >= 0 O.K. +* < 0 Error +*/ +int SEGGER_RTT_SetNameDownBuffer(unsigned BufferIndex, const char* sName) { + int r; + volatile SEGGER_RTT_CB* pRTTCB; + volatile SEGGER_RTT_BUFFER_DOWN* pDown; + + INIT(); + pRTTCB = (volatile SEGGER_RTT_CB*)((uintptr_t)&_SEGGER_RTT + SEGGER_RTT_UNCACHED_OFF); // Access RTTCB uncached to make sure we see changes made by the J-Link side and all of our changes go into HW directly + if (BufferIndex < SEGGER_RTT_MAX_NUM_DOWN_BUFFERS) { + SEGGER_RTT_LOCK(); + pDown = &pRTTCB->aDown[BufferIndex]; + pDown->sName = sName; + SEGGER_RTT_UNLOCK(); + r = 0; + } else { + r = -1; + } + return r; +} + +/********************************************************************* +* +* SEGGER_RTT_SetFlagsUpBuffer +* +* Function description +* Run-time configuration of specific up-buffer flags (T->H). +* Buffer to be configured is specified by index. +* +* Parameters +* BufferIndex Index of the buffer. +* Flags Flags to set for the buffer. +* Flags[31:24] are used for validity check and must be zero. Flags[23:2] are reserved for future use. Flags[1:0] = RTT operating mode. +* +* Return value +* >= 0 O.K. +* < 0 Error +*/ +int SEGGER_RTT_SetFlagsUpBuffer(unsigned BufferIndex, unsigned Flags) { + int r; + volatile SEGGER_RTT_CB* pRTTCB; + volatile SEGGER_RTT_BUFFER_UP* pUp; + + INIT(); + pRTTCB = (volatile SEGGER_RTT_CB*)((uintptr_t)&_SEGGER_RTT + SEGGER_RTT_UNCACHED_OFF); // Access RTTCB uncached to make sure we see changes made by the J-Link side and all of our changes go into HW directly + if (BufferIndex < SEGGER_RTT_MAX_NUM_UP_BUFFERS) { + SEGGER_RTT_LOCK(); + pUp = &pRTTCB->aUp[BufferIndex]; + pUp->Flags = Flags; + SEGGER_RTT_UNLOCK(); + r = 0; + } else { + r = -1; + } + return r; +} + +/********************************************************************* +* +* SEGGER_RTT_SetFlagsDownBuffer +* +* Function description +* Run-time configuration of specific Down-buffer flags (T->H). +* Buffer to be configured is specified by index. +* +* Parameters +* BufferIndex Index of the buffer to renamed. +* Flags Flags to set for the buffer. +* Flags[31:24] are used for validity check and must be zero. Flags[23:2] are reserved for future use. Flags[1:0] = RTT operating mode. +* +* Return value +* >= 0 O.K. +* < 0 Error +*/ +int SEGGER_RTT_SetFlagsDownBuffer(unsigned BufferIndex, unsigned Flags) { + int r; + volatile SEGGER_RTT_CB* pRTTCB; + volatile SEGGER_RTT_BUFFER_DOWN* pDown; + + INIT(); + pRTTCB = (volatile SEGGER_RTT_CB*)((uintptr_t)&_SEGGER_RTT + SEGGER_RTT_UNCACHED_OFF); // Access RTTCB uncached to make sure we see changes made by the J-Link side and all of our changes go into HW directly + if (BufferIndex < SEGGER_RTT_MAX_NUM_DOWN_BUFFERS) { + SEGGER_RTT_LOCK(); + pDown = &pRTTCB->aDown[BufferIndex]; + pDown->Flags = Flags; + SEGGER_RTT_UNLOCK(); + r = 0; + } else { + r = -1; + } + return r; +} + +/********************************************************************* +* +* SEGGER_RTT_Init +* +* Function description +* Initializes the RTT Control Block. +* Should be used in RAM targets, at start of the application. +* +*/ +void SEGGER_RTT_Init (void) { + _DoInit(); +} + +#ifndef CUSTOM_RTT +/********************************************************************* +* +* SEGGER_RTT_SetTerminal +* +* Function description +* Sets the terminal to be used for output on channel 0. +* +* Parameters +* TerminalId Index of the terminal. +* +* Return value +* >= 0 O.K. +* < 0 Error (e.g. if RTT is configured for non-blocking mode and there was no space in the buffer to set the new terminal Id) +* +* Notes +* (1) Buffer 0 is always reserved for terminal I/O, so we can use index 0 here, fixed +*/ +int SEGGER_RTT_SetTerminal (unsigned char TerminalId) { + unsigned char ac[2]; + SEGGER_RTT_BUFFER_UP* pRing; + unsigned Avail; + int r; + + INIT(); + r = 0; + ac[0] = 0xFFu; + if (TerminalId < sizeof(_aTerminalId)) { // We only support a certain number of channels + ac[1] = _aTerminalId[TerminalId]; + pRing = (SEGGER_RTT_BUFFER_UP*)((uintptr_t)&_SEGGER_RTT.aUp[0] + SEGGER_RTT_UNCACHED_OFF); // Access uncached to make sure we see changes made by the J-Link side and all of our changes go into HW directly + SEGGER_RTT_LOCK(); // Lock to make sure that no other task is writing into buffer, while we are and number of free bytes in buffer does not change downwards after checking and before writing + if ((pRing->Flags & SEGGER_RTT_MODE_MASK) == SEGGER_RTT_MODE_BLOCK_IF_FIFO_FULL) { + _ActiveTerminal = TerminalId; + _WriteBlocking(pRing, (const char*)ac, 2u); + } else { // Skipping mode or trim mode? => We cannot trim this command so handling is the same for both modes + Avail = _GetAvailWriteSpace(pRing); + if (Avail >= 2) { + _ActiveTerminal = TerminalId; // Only change active terminal in case of success + _WriteNoCheck(pRing, (const char*)ac, 2u); + } else { + r = -1; + } + } + SEGGER_RTT_UNLOCK(); + } else { + r = -1; + } + return r; +} + +/********************************************************************* +* +* SEGGER_RTT_TerminalOut +* +* Function description +* Writes a string to the given terminal +* without changing the terminal for channel 0. +* +* Parameters +* TerminalId Index of the terminal. +* s String to be printed on the terminal. +* +* Return value +* >= 0 - Number of bytes written. +* < 0 - Error. +* +*/ +int SEGGER_RTT_TerminalOut (unsigned char TerminalId, const char* s) { + int Status; + unsigned FragLen; + unsigned Avail; + SEGGER_RTT_BUFFER_UP* pRing; + // + INIT(); + // + // Validate terminal ID. + // + if (TerminalId < (char)sizeof(_aTerminalId)) { // We only support a certain number of channels + // + // Get "to-host" ring buffer. + // + pRing = (SEGGER_RTT_BUFFER_UP*)((uintptr_t)&_SEGGER_RTT.aUp[0] + SEGGER_RTT_UNCACHED_OFF); // Access uncached to make sure we see changes made by the J-Link side and all of our changes go into HW directly + // + // Need to be able to change terminal, write data, change back. + // Compute the fixed and variable sizes. + // + FragLen = STRLEN(s); + // + // How we output depends upon the mode... + // + SEGGER_RTT_LOCK(); + Avail = _GetAvailWriteSpace(pRing); + switch (pRing->Flags & SEGGER_RTT_MODE_MASK) { + case SEGGER_RTT_MODE_NO_BLOCK_SKIP: + // + // If we are in skip mode and there is no space for the whole + // of this output, don't bother switching terminals at all. + // + if (Avail < (FragLen + 4u)) { + Status = 0; + } else { + _PostTerminalSwitch(pRing, TerminalId); + Status = (int)_WriteBlocking(pRing, s, FragLen); + _PostTerminalSwitch(pRing, _ActiveTerminal); + } + break; + case SEGGER_RTT_MODE_NO_BLOCK_TRIM: + // + // If we are in trim mode and there is not enough space for everything, + // trim the output but always include the terminal switch. If no room + // for terminal switch, skip that totally. + // + if (Avail < 4u) { + Status = -1; + } else { + _PostTerminalSwitch(pRing, TerminalId); + Status = (int)_WriteBlocking(pRing, s, (FragLen < (Avail - 4u)) ? FragLen : (Avail - 4u)); + _PostTerminalSwitch(pRing, _ActiveTerminal); + } + break; + case SEGGER_RTT_MODE_BLOCK_IF_FIFO_FULL: + // + // If we are in blocking mode, output everything. + // + _PostTerminalSwitch(pRing, TerminalId); + Status = (int)_WriteBlocking(pRing, s, FragLen); + _PostTerminalSwitch(pRing, _ActiveTerminal); + break; + default: + Status = -1; + break; + } + // + // Finish up. + // + SEGGER_RTT_UNLOCK(); + } else { + Status = -1; + } + return Status; +} +#endif // CUSTOM_RTT + +/********************************************************************* +* +* SEGGER_RTT_GetAvailWriteSpace +* +* Function description +* Returns the number of bytes available in the ring buffer. +* +* Parameters +* BufferIndex Index of the up buffer. +* +* Return value +* Number of bytes that are free in the selected up buffer. +*/ +unsigned SEGGER_RTT_GetAvailWriteSpace (unsigned BufferIndex) { + SEGGER_RTT_BUFFER_UP* pRing; + + pRing = (SEGGER_RTT_BUFFER_UP*)((uintptr_t)&_SEGGER_RTT.aUp[BufferIndex] + SEGGER_RTT_UNCACHED_OFF); // Access uncached to make sure we see changes made by the J-Link side and all of our changes go into HW directly + return _GetAvailWriteSpace(pRing); +} + + +/********************************************************************* +* +* SEGGER_RTT_GetBytesInBuffer() +* +* Function description +* Returns the number of bytes currently used in the up buffer. +* +* Parameters +* BufferIndex Index of the up buffer. +* +* Return value +* Number of bytes that are used in the buffer. +*/ +unsigned SEGGER_RTT_GetBytesInBuffer(unsigned BufferIndex) { + unsigned RdOff; + unsigned WrOff; + unsigned r; + volatile SEGGER_RTT_CB* pRTTCB; + // + // Avoid warnings regarding volatile access order. It's not a problem + // in this case, but dampen compiler enthusiasm. + // + pRTTCB = (volatile SEGGER_RTT_CB*)((uintptr_t)&_SEGGER_RTT + SEGGER_RTT_UNCACHED_OFF); // Access RTTCB uncached to make sure we see changes made by the J-Link side and all of our changes go into HW directly + RdOff = pRTTCB->aUp[BufferIndex].RdOff; + WrOff = pRTTCB->aUp[BufferIndex].WrOff; + if (RdOff <= WrOff) { + r = WrOff - RdOff; + } else { + r = pRTTCB->aUp[BufferIndex].SizeOfBuffer - (WrOff - RdOff); + } + return r; +} + +/*************************** End of file ****************************/ diff --git a/libs/swdcon/SEGGER_RTT_custom.h b/libs/swdcon/SEGGER_RTT_custom.h new file mode 100644 index 0000000000..1b4a76d143 --- /dev/null +++ b/libs/swdcon/SEGGER_RTT_custom.h @@ -0,0 +1,511 @@ +/********************************************************************* +* SEGGER Microcontroller GmbH * +* The Embedded Experts * +********************************************************************** +* * +* (c) 1995 - 2019 SEGGER Microcontroller GmbH * +* * +* www.segger.com Support: support@segger.com * +* * +********************************************************************** +* * +* SEGGER RTT * Real Time Transfer for embedded targets * +* * +********************************************************************** +* * +* All rights reserved. * +* * +* SEGGER strongly recommends to not make any changes * +* to or modify the source code of this software in order to stay * +* compatible with the RTT protocol and J-Link. * +* * +* Redistribution and use in source and binary forms, with or * +* without modification, are permitted provided that the following * +* condition is met: * +* * +* o Redistributions of source code must retain the above copyright * +* notice, this condition and the following disclaimer. * +* * +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND * +* CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, * +* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF * +* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE * +* DISCLAIMED. IN NO EVENT SHALL SEGGER Microcontroller BE LIABLE FOR * +* ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT * +* OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; * +* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * +* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * +* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE * +* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH * +* DAMAGE. * +* * +********************************************************************** +---------------------------END-OF-HEADER------------------------------ +File : SEGGER_RTT.h +Purpose : Implementation of SEGGER real-time transfer which allows + real-time communication on targets which support debugger + memory accesses while the CPU is running. +Revision: $Rev: 25842 $ +---------------------------------------------------------------------- +*/ + +#ifndef SEGGER_RTT_H +#define SEGGER_RTT_H + +#ifndef CUSTOM_RTT +#include "SEGGER_RTT_Conf.h" +#endif + +/********************************************************************* +* +* Defines, defaults +* +********************************************************************** +*/ + +#ifndef RTT_USE_ASM + // + // Some cores support out-of-order memory accesses (reordering of memory accesses in the core) + // For such cores, we need to define a memory barrier to guarantee the order of certain accesses to the RTT ring buffers. + // Needed for: + // Cortex-M7 (ARMv7-M) + // Cortex-M23 (ARM-v8M) + // Cortex-M33 (ARM-v8M) + // Cortex-A/R (ARM-v7A/R) + // + // We do not explicitly check for "Embedded Studio" as the compiler in use determines what we support. + // You can use an external toolchain like IAR inside ES. So there is no point in checking for "Embedded Studio" + // + #if (defined __CROSSWORKS_ARM) // Rowley Crossworks + #define _CC_HAS_RTT_ASM_SUPPORT 1 + #if (defined __ARM_ARCH_7M__) // Cortex-M3 + #define _CORE_HAS_RTT_ASM_SUPPORT 1 + #elif (defined __ARM_ARCH_7EM__) // Cortex-M4/M7 + #define _CORE_HAS_RTT_ASM_SUPPORT 1 + #define _CORE_NEEDS_DMB 1 + #define RTT__DMB() __asm volatile ("dmb\n" : : :); + #elif (defined __ARM_ARCH_8M_BASE__) // Cortex-M23 + #define _CORE_HAS_RTT_ASM_SUPPORT 0 + #define _CORE_NEEDS_DMB 1 + #define RTT__DMB() __asm volatile ("dmb\n" : : :); + #elif (defined __ARM_ARCH_8M_MAIN__) // Cortex-M33 + #define _CORE_HAS_RTT_ASM_SUPPORT 1 + #define _CORE_NEEDS_DMB 1 + #define RTT__DMB() __asm volatile ("dmb\n" : : :); + #elif (defined(__ARM_ARCH_8_1M_MAIN__)) // Cortex-M85 + #define _CORE_HAS_RTT_ASM_SUPPORT 1 + #define _CORE_NEEDS_DMB 1 + #define RTT__DMB() __asm volatile ("dmb\n" : : :); + #else + #define _CORE_HAS_RTT_ASM_SUPPORT 0 + #endif + #elif (defined __ARMCC_VERSION) + // + // ARM compiler + // ARM compiler V6.0 and later is clang based. + // Our ASM part is compatible to clang. + // + #if (__ARMCC_VERSION >= 6000000) + #define _CC_HAS_RTT_ASM_SUPPORT 1 + #else + #define _CC_HAS_RTT_ASM_SUPPORT 0 + #endif + #if (defined __ARM_ARCH_6M__) // Cortex-M0 / M1 + #define _CORE_HAS_RTT_ASM_SUPPORT 0 // No ASM support for this architecture + #elif (defined __ARM_ARCH_7M__) // Cortex-M3 + #define _CORE_HAS_RTT_ASM_SUPPORT 1 + #elif (defined __ARM_ARCH_7EM__) // Cortex-M4/M7 + #define _CORE_HAS_RTT_ASM_SUPPORT 1 + #define _CORE_NEEDS_DMB 1 + #define RTT__DMB() __asm volatile ("dmb\n" : : :); + #elif (defined __ARM_ARCH_8M_BASE__) // Cortex-M23 + #define _CORE_HAS_RTT_ASM_SUPPORT 0 + #define _CORE_NEEDS_DMB 1 + #define RTT__DMB() __asm volatile ("dmb\n" : : :); + #elif (defined __ARM_ARCH_8M_MAIN__) // Cortex-M33 + #define _CORE_HAS_RTT_ASM_SUPPORT 1 + #define _CORE_NEEDS_DMB 1 + #define RTT__DMB() __asm volatile ("dmb\n" : : :); + #elif (defined __ARM_ARCH_8_1M_MAIN__) // Cortex-M85 + #define _CORE_HAS_RTT_ASM_SUPPORT 1 + #define _CORE_NEEDS_DMB 1 + #define RTT__DMB() __asm volatile ("dmb\n" : : :); + #elif ((defined __ARM_ARCH_7A__) || (defined __ARM_ARCH_7R__)) // Cortex-A/R 32-bit ARMv7-A/R + #define _CORE_NEEDS_DMB 1 + #define RTT__DMB() __asm volatile ("dmb\n" : : :); + #else + #define _CORE_HAS_RTT_ASM_SUPPORT 0 + #endif + #elif ((defined __GNUC__) || (defined __clang__)) + // + // GCC / Clang + // + #define _CC_HAS_RTT_ASM_SUPPORT 1 + // ARM 7/9: __ARM_ARCH_5__ / __ARM_ARCH_5E__ / __ARM_ARCH_5T__ / __ARM_ARCH_5T__ / __ARM_ARCH_5TE__ + #if (defined __ARM_ARCH_7M__) // Cortex-M3 + #define _CORE_HAS_RTT_ASM_SUPPORT 1 + #elif (defined __ARM_ARCH_7EM__) // Cortex-M4/M7 + #define _CORE_HAS_RTT_ASM_SUPPORT 1 + #define _CORE_NEEDS_DMB 1 // Only Cortex-M7 needs a DMB but we cannot distinguish M4 and M7 here... + #define RTT__DMB() __asm volatile ("dmb\n" : : :); + #elif (defined __ARM_ARCH_8M_BASE__) // Cortex-M23 + #define _CORE_HAS_RTT_ASM_SUPPORT 0 + #define _CORE_NEEDS_DMB 1 + #define RTT__DMB() __asm volatile ("dmb\n" : : :); + #elif (defined __ARM_ARCH_8M_MAIN__) // Cortex-M33 + #define _CORE_HAS_RTT_ASM_SUPPORT 1 + #define _CORE_NEEDS_DMB 1 + #define RTT__DMB() __asm volatile ("dmb\n" : : :); + #elif (defined __ARM_ARCH_8_1M_MAIN__) // Cortex-M85 + #define _CORE_HAS_RTT_ASM_SUPPORT 1 + #define _CORE_NEEDS_DMB 1 + #define RTT__DMB() __asm volatile ("dmb\n" : : :); + #elif ((defined __ARM_ARCH_7A__) || (defined __ARM_ARCH_7R__)) // Cortex-A/R 32-bit ARMv7-A/R + #define _CORE_NEEDS_DMB 1 + #define RTT__DMB() __asm volatile ("dmb\n" : : :); + #else + #define _CORE_HAS_RTT_ASM_SUPPORT 0 + #endif + #elif ((defined __IASMARM__) || (defined __ICCARM__)) + // + // IAR assembler/compiler + // + #define _CC_HAS_RTT_ASM_SUPPORT 1 + #if (__VER__ < 6300000) + #define VOLATILE + #else + #define VOLATILE volatile + #endif + #if (defined __ARM7M__) // Needed for old versions that do not know the define yet + #if (__CORE__ == __ARM7M__) // Cortex-M3 + #define _CORE_HAS_RTT_ASM_SUPPORT 1 + #endif + #endif + #if (defined __ARM7EM__) + #if (__CORE__ == __ARM7EM__) // Cortex-M4/M7 + #define _CORE_HAS_RTT_ASM_SUPPORT 1 + #define _CORE_NEEDS_DMB 1 + #define RTT__DMB() asm VOLATILE ("DMB"); + #endif + #endif + #if (defined __ARM8M_BASELINE__) + #if (__CORE__ == __ARM8M_BASELINE__) // Cortex-M23 + #define _CORE_HAS_RTT_ASM_SUPPORT 0 + #define _CORE_NEEDS_DMB 1 + #define RTT__DMB() asm VOLATILE ("DMB"); + #endif + #endif + #if (defined __ARM8M_MAINLINE__) + #if (__CORE__ == __ARM8M_MAINLINE__) // Cortex-M33 + #define _CORE_HAS_RTT_ASM_SUPPORT 1 + #define _CORE_NEEDS_DMB 1 + #define RTT__DMB() asm VOLATILE ("DMB"); + #endif + #endif + #if (defined __ARM8EM_MAINLINE__) + #if (__CORE__ == __ARM8EM_MAINLINE__) // Cortex-??? + #define _CORE_HAS_RTT_ASM_SUPPORT 1 + #define _CORE_NEEDS_DMB 1 + #define RTT__DMB() asm VOLATILE ("DMB"); + #endif + #endif + #if (defined __ARM7A__) + #if (__CORE__ == __ARM7A__) // Cortex-A 32-bit ARMv7-A + #define _CORE_NEEDS_DMB 1 + #define RTT__DMB() asm VOLATILE ("DMB"); + #endif + #endif + #if (defined __ARM7R__) + #if (__CORE__ == __ARM7R__) // Cortex-R 32-bit ARMv7-R + #define _CORE_NEEDS_DMB 1 + #define RTT__DMB() asm VOLATILE ("DMB"); + #endif + #endif +// TBD: __ARM8A__ => Cortex-A 64-bit ARMv8-A +// TBD: __ARM8R__ => Cortex-R 64-bit ARMv8-R + #else + // + // Other compilers + // + #define _CC_HAS_RTT_ASM_SUPPORT 0 + #define _CORE_HAS_RTT_ASM_SUPPORT 0 + #endif + // + // If IDE and core support the ASM version, enable ASM version by default + // + #ifndef _CORE_HAS_RTT_ASM_SUPPORT + #define _CORE_HAS_RTT_ASM_SUPPORT 0 // Default for unknown cores + #endif + #if (_CC_HAS_RTT_ASM_SUPPORT && _CORE_HAS_RTT_ASM_SUPPORT) + #define RTT_USE_ASM (1) + #else + #define RTT_USE_ASM (0) + #endif +#endif + +#ifndef _CORE_NEEDS_DMB + #define _CORE_NEEDS_DMB 0 +#endif + +#ifndef RTT__DMB + #if _CORE_NEEDS_DMB + #error "Don't know how to place inline assembly for DMB" + #else + #define RTT__DMB() + #endif +#endif + +#ifndef SEGGER_RTT_CPU_CACHE_LINE_SIZE + #define SEGGER_RTT_CPU_CACHE_LINE_SIZE (0) // On most target systems where RTT is used, we do not have a CPU cache, therefore 0 is a good default here +#endif + +#ifndef SEGGER_RTT_UNCACHED_OFF + #if SEGGER_RTT_CPU_CACHE_LINE_SIZE + #error "SEGGER_RTT_UNCACHED_OFF must be defined when setting SEGGER_RTT_CPU_CACHE_LINE_SIZE != 0" + #else + #define SEGGER_RTT_UNCACHED_OFF (0) + #endif +#endif +#if RTT_USE_ASM + #if SEGGER_RTT_CPU_CACHE_LINE_SIZE + #error "RTT_USE_ASM is not available if SEGGER_RTT_CPU_CACHE_LINE_SIZE != 0" + #endif +#endif + +#ifndef SEGGER_RTT_ASM // defined when SEGGER_RTT.h is included from assembly file +#include +#include +#include + +/********************************************************************* +* +* Defines, fixed +* +********************************************************************** +*/ + +// +// Determine how much we must pad the control block to make it a multiple of a cache line in size +// Assuming: U8 = 1B +// U16 = 2B +// U32 = 4B +// U8/U16/U32* = 4B +// +#if SEGGER_RTT_CPU_CACHE_LINE_SIZE // Avoid division by zero in case we do not have any cache + #define SEGGER_RTT__ROUND_UP_2_CACHE_LINE_SIZE(NumBytes) (((NumBytes + SEGGER_RTT_CPU_CACHE_LINE_SIZE - 1) / SEGGER_RTT_CPU_CACHE_LINE_SIZE) * SEGGER_RTT_CPU_CACHE_LINE_SIZE) +#else + #define SEGGER_RTT__ROUND_UP_2_CACHE_LINE_SIZE(NumBytes) (NumBytes) +#endif +#define SEGGER_RTT__CB_SIZE (16 + 4 + 4 + (SEGGER_RTT_MAX_NUM_UP_BUFFERS * 24) + (SEGGER_RTT_MAX_NUM_DOWN_BUFFERS * 24)) +#define SEGGER_RTT__CB_PADDING (SEGGER_RTT__ROUND_UP_2_CACHE_LINE_SIZE(SEGGER_RTT__CB_SIZE) - SEGGER_RTT__CB_SIZE) + +/********************************************************************* +* +* Types +* +********************************************************************** +*/ + +// +// Description for a circular buffer (also called "ring buffer") +// which is used as up-buffer (T->H) +// +typedef struct { + const char* sName; // Optional name. Standard names so far are: "Terminal", "SysView", "J-Scope_t4i4" + char* pBuffer; // Pointer to start of buffer + unsigned SizeOfBuffer; // Buffer size in bytes. Note that one byte is lost, as this implementation does not fill up the buffer in order to avoid the problem of being unable to distinguish between full and empty. + unsigned WrOff; // Position of next item to be written by either target. + volatile unsigned RdOff; // Position of next item to be read by host. Must be volatile since it may be modified by host. + unsigned Flags; // Contains configuration flags. Flags[31:24] are used for validity check and must be zero. Flags[23:2] are reserved for future use. Flags[1:0] = RTT operating mode. +} SEGGER_RTT_BUFFER_UP; + +// +// Description for a circular buffer (also called "ring buffer") +// which is used as down-buffer (H->T) +// +typedef struct { + const char* sName; // Optional name. Standard names so far are: "Terminal", "SysView", "J-Scope_t4i4" + char* pBuffer; // Pointer to start of buffer + unsigned SizeOfBuffer; // Buffer size in bytes. Note that one byte is lost, as this implementation does not fill up the buffer in order to avoid the problem of being unable to distinguish between full and empty. + volatile unsigned WrOff; // Position of next item to be written by host. Must be volatile since it may be modified by host. + unsigned RdOff; // Position of next item to be read by target (down-buffer). + unsigned Flags; // Contains configuration flags. Flags[31:24] are used for validity check and must be zero. Flags[23:2] are reserved for future use. Flags[1:0] = RTT operating mode. +} SEGGER_RTT_BUFFER_DOWN; + +// +// RTT control block which describes the number of buffers available +// as well as the configuration for each buffer +// +// +typedef struct { + char acID[16]; // Initialized to "SEGGER RTT" + int MaxNumUpBuffers; // Initialized to SEGGER_RTT_MAX_NUM_UP_BUFFERS (type. 2) + int MaxNumDownBuffers; // Initialized to SEGGER_RTT_MAX_NUM_DOWN_BUFFERS (type. 2) + SEGGER_RTT_BUFFER_UP aUp[SEGGER_RTT_MAX_NUM_UP_BUFFERS]; // Up buffers, transferring information up from target via debug probe to host + SEGGER_RTT_BUFFER_DOWN aDown[SEGGER_RTT_MAX_NUM_DOWN_BUFFERS]; // Down buffers, transferring information down from host via debug probe to target +#if SEGGER_RTT__CB_PADDING + unsigned char aDummy[SEGGER_RTT__CB_PADDING]; +#endif +} SEGGER_RTT_CB; + +/********************************************************************* +* +* Global data +* +********************************************************************** +*/ +extern SEGGER_RTT_CB _SEGGER_RTT; + +/********************************************************************* +* +* RTT API functions +* +********************************************************************** +*/ +#ifdef __cplusplus + extern "C" { +#endif +int SEGGER_RTT_AllocDownBuffer (const char* sName, void* pBuffer, unsigned BufferSize, unsigned Flags); +int SEGGER_RTT_AllocUpBuffer (const char* sName, void* pBuffer, unsigned BufferSize, unsigned Flags); +int SEGGER_RTT_ConfigUpBuffer (unsigned BufferIndex, const char* sName, void* pBuffer, unsigned BufferSize, unsigned Flags); +int SEGGER_RTT_ConfigDownBuffer (unsigned BufferIndex, const char* sName, void* pBuffer, unsigned BufferSize, unsigned Flags); +int SEGGER_RTT_GetKey (void); +unsigned SEGGER_RTT_HasData (unsigned BufferIndex); +int SEGGER_RTT_HasKey (void); +unsigned SEGGER_RTT_HasDataUp (unsigned BufferIndex); +void SEGGER_RTT_Init (void); +unsigned SEGGER_RTT_Read (unsigned BufferIndex, void* pBuffer, unsigned BufferSize); +unsigned SEGGER_RTT_ReadNoLock (unsigned BufferIndex, void* pData, unsigned BufferSize); +int SEGGER_RTT_SetNameDownBuffer (unsigned BufferIndex, const char* sName); +int SEGGER_RTT_SetNameUpBuffer (unsigned BufferIndex, const char* sName); +int SEGGER_RTT_SetFlagsDownBuffer (unsigned BufferIndex, unsigned Flags); +int SEGGER_RTT_SetFlagsUpBuffer (unsigned BufferIndex, unsigned Flags); +int SEGGER_RTT_WaitKey (void); +unsigned SEGGER_RTT_Write (unsigned BufferIndex, const void* pBuffer, unsigned NumBytes); +unsigned SEGGER_RTT_WriteNoLock (unsigned BufferIndex, const void* pBuffer, unsigned NumBytes); +unsigned SEGGER_RTT_WriteSkipNoLock (unsigned BufferIndex, const void* pBuffer, unsigned NumBytes); +unsigned SEGGER_RTT_ASM_WriteSkipNoLock (unsigned BufferIndex, const void* pBuffer, unsigned NumBytes); +unsigned SEGGER_RTT_WriteString (unsigned BufferIndex, const char* s); +void SEGGER_RTT_WriteWithOverwriteNoLock(unsigned BufferIndex, const void* pBuffer, unsigned NumBytes); +unsigned SEGGER_RTT_PutChar (unsigned BufferIndex, char c); +unsigned SEGGER_RTT_PutCharSkip (unsigned BufferIndex, char c); +unsigned SEGGER_RTT_PutCharSkipNoLock (unsigned BufferIndex, char c); +unsigned SEGGER_RTT_GetAvailWriteSpace (unsigned BufferIndex); +unsigned SEGGER_RTT_GetBytesInBuffer (unsigned BufferIndex); +// +// Function macro for performance optimization +// +#define SEGGER_RTT_HASDATA(n) (((SEGGER_RTT_BUFFER_DOWN*)((uintptr_t)&_SEGGER_RTT.aDown[n] + SEGGER_RTT_UNCACHED_OFF))->WrOff - ((SEGGER_RTT_BUFFER_DOWN*)((uintptr_t)&_SEGGER_RTT.aDown[n] + SEGGER_RTT_UNCACHED_OFF))->RdOff) + +#if RTT_USE_ASM + #define SEGGER_RTT_WriteSkipNoLock SEGGER_RTT_ASM_WriteSkipNoLock +#endif + +/********************************************************************* +* +* RTT transfer functions to send RTT data via other channels. +* +********************************************************************** +*/ +unsigned SEGGER_RTT_ReadUpBuffer (unsigned BufferIndex, void* pBuffer, unsigned BufferSize); +unsigned SEGGER_RTT_ReadUpBufferNoLock (unsigned BufferIndex, void* pData, unsigned BufferSize); +unsigned SEGGER_RTT_WriteDownBuffer (unsigned BufferIndex, const void* pBuffer, unsigned NumBytes); +unsigned SEGGER_RTT_WriteDownBufferNoLock (unsigned BufferIndex, const void* pBuffer, unsigned NumBytes); + +#define SEGGER_RTT_HASDATA_UP(n) (((SEGGER_RTT_BUFFER_UP*)((uintptr_t)&_SEGGER_RTT.aUp[n] + SEGGER_RTT_UNCACHED_OFF))->WrOff - ((SEGGER_RTT_BUFFER_UP*)((uintptr_t)&_SEGGER_RTT.aUp[n] + SEGGER_RTT_UNCACHED_OFF))->RdOff) // Access uncached to make sure we see changes made by the J-Link side and all of our changes go into HW directly + +#ifndef CUSTOM_RTT +/********************************************************************* +* +* RTT "Terminal" API functions +* +********************************************************************** +*/ +int SEGGER_RTT_SetTerminal (unsigned char TerminalId); +int SEGGER_RTT_TerminalOut (unsigned char TerminalId, const char* s); + +/********************************************************************* +* +* RTT printf functions (require SEGGER_RTT_printf.c) +* +********************************************************************** +*/ +int SEGGER_RTT_printf(unsigned BufferIndex, const char * sFormat, ...); +int SEGGER_RTT_vprintf(unsigned BufferIndex, const char * sFormat, va_list * pParamList); +#endif // CUSTOM_RTT +#ifdef __cplusplus + } +#endif + +#endif // ifndef(SEGGER_RTT_ASM) + +// +// For some environments, NULL may not be defined until certain headers are included +// +#ifndef NULL + #define NULL ((void*)0) +#endif + +/********************************************************************* +* +* Defines +* +********************************************************************** +*/ + +// +// Operating modes. Define behavior if buffer is full (not enough space for entire message) +// +#define SEGGER_RTT_MODE_NO_BLOCK_SKIP (0) // Skip. Do not block, output nothing. (Default) +#define SEGGER_RTT_MODE_NO_BLOCK_TRIM (1) // Trim: Do not block, output as much as fits. +#define SEGGER_RTT_MODE_BLOCK_IF_FIFO_FULL (2) // Block: Wait until there is space in the buffer. +#define SEGGER_RTT_MODE_MASK (3) + +// +// Control sequences, based on ANSI. +// Can be used to control color, and clear the screen +// +#define RTT_CTRL_RESET "\x1B[0m" // Reset to default colors +#define RTT_CTRL_CLEAR "\x1B[2J" // Clear screen, reposition cursor to top left + +#define RTT_CTRL_TEXT_BLACK "\x1B[2;30m" +#define RTT_CTRL_TEXT_RED "\x1B[2;31m" +#define RTT_CTRL_TEXT_GREEN "\x1B[2;32m" +#define RTT_CTRL_TEXT_YELLOW "\x1B[2;33m" +#define RTT_CTRL_TEXT_BLUE "\x1B[2;34m" +#define RTT_CTRL_TEXT_MAGENTA "\x1B[2;35m" +#define RTT_CTRL_TEXT_CYAN "\x1B[2;36m" +#define RTT_CTRL_TEXT_WHITE "\x1B[2;37m" + +#define RTT_CTRL_TEXT_BRIGHT_BLACK "\x1B[1;30m" +#define RTT_CTRL_TEXT_BRIGHT_RED "\x1B[1;31m" +#define RTT_CTRL_TEXT_BRIGHT_GREEN "\x1B[1;32m" +#define RTT_CTRL_TEXT_BRIGHT_YELLOW "\x1B[1;33m" +#define RTT_CTRL_TEXT_BRIGHT_BLUE "\x1B[1;34m" +#define RTT_CTRL_TEXT_BRIGHT_MAGENTA "\x1B[1;35m" +#define RTT_CTRL_TEXT_BRIGHT_CYAN "\x1B[1;36m" +#define RTT_CTRL_TEXT_BRIGHT_WHITE "\x1B[1;37m" + +#define RTT_CTRL_BG_BLACK "\x1B[24;40m" +#define RTT_CTRL_BG_RED "\x1B[24;41m" +#define RTT_CTRL_BG_GREEN "\x1B[24;42m" +#define RTT_CTRL_BG_YELLOW "\x1B[24;43m" +#define RTT_CTRL_BG_BLUE "\x1B[24;44m" +#define RTT_CTRL_BG_MAGENTA "\x1B[24;45m" +#define RTT_CTRL_BG_CYAN "\x1B[24;46m" +#define RTT_CTRL_BG_WHITE "\x1B[24;47m" + +#define RTT_CTRL_BG_BRIGHT_BLACK "\x1B[4;40m" +#define RTT_CTRL_BG_BRIGHT_RED "\x1B[4;41m" +#define RTT_CTRL_BG_BRIGHT_GREEN "\x1B[4;42m" +#define RTT_CTRL_BG_BRIGHT_YELLOW "\x1B[4;43m" +#define RTT_CTRL_BG_BRIGHT_BLUE "\x1B[4;44m" +#define RTT_CTRL_BG_BRIGHT_MAGENTA "\x1B[4;45m" +#define RTT_CTRL_BG_BRIGHT_CYAN "\x1B[4;46m" +#define RTT_CTRL_BG_BRIGHT_WHITE "\x1B[4;47m" + + +#endif + +/*************************** End of file ****************************/ diff --git a/libs/swdcon/jswrap_swdcon.c b/libs/swdcon/jswrap_swdcon.c new file mode 100644 index 0000000000..3cfd98ee0f --- /dev/null +++ b/libs/swdcon/jswrap_swdcon.c @@ -0,0 +1,183 @@ +/* + * This file is part of Espruino, a JavaScript interpreter for Microcontrollers + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * ---------------------------------------------------------------------------- + * This file is designed to be parsed during the build process + * + * Contains JavaScript SWD console + * ---------------------------------------------------------------------------- + */ +#include "jsvariterator.h" +#include "jsinteractive.h" + +#ifdef NRF5X +#include "app_util_platform.h" +#endif +#ifndef CRITICAL_REGION_ENTER +#define CRITICAL_REGION_ENTER jshInterruptOff +#endif +#ifndef CRITICAL_REGION_EXIT +#define CRITICAL_REGION_EXIT jshInterruptOn +#endif + +// "SWDCON RTT" header instead of default "SEGGER RTT" +// #define CUSTOM_RTT_HEADER_BACKWARDS "TTR NOCDWS" + +// stuff from removed SEGGER_RTT_Conf.h +#define SEGGER_RTT_MAX_NUM_UP_BUFFERS (1) +#define SEGGER_RTT_MAX_NUM_DOWN_BUFFERS (1) // Max. number of down-buffers (H->T) available on this target (Default: 3) +#define BUFFER_SIZE_UP (128) // 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_MODE_DEFAULT SEGGER_RTT_MODE_NO_BLOCK_SKIP // Mode for pre-initialized terminal channel (buffer 0) +#define SEGGER_RTT_LOCK() CRITICAL_REGION_ENTER() +#define SEGGER_RTT_UNLOCK() CRITICAL_REGION_EXIT() +//#include "SEGGER_RTT_Conf.h" +#include "SEGGER_RTT_custom.c" + +// possibly dynamically allocated from variables? +static char swdconUpBuffer[BUFFER_SIZE_UP]; +static char swdconDownBuffer[BUFFER_SIZE_DOWN]; +const char swdconBufferName[] ="SWDCON"; // visible in "rtt channels" openocd command, SEGGER default for channel 0 is "Terminal" +// Forward function declarations + + +// console data structures + +#define MODE_OFF 0 // console is off +#define MODE_ON 1 // console is on + +static uint8_t srvMode = MODE_OFF; ///< current mode + +/*JSON{ + "type" : "object", + "name" : "SWDCON", + "instanceof" : "Serial", + "ifdef" : "USE_SWDCON" +} +In memory serial I/O device accessible via SWD debugger. +uses SEGGER RTT so it can be used with openocd and other SEGGER compatible tools. +*/ + + +/*JSON{ + "type" : "init", + "generate" : "jswrap_swdcon_init" +} +*/ +void jswrap_swdcon_init(void) { + SEGGER_RTT_Init(); + SEGGER_RTT_ConfigDownBuffer(0, swdconBufferName, swdconDownBuffer, sizeof(swdconDownBuffer), SEGGER_RTT_MODE_DEFAULT); + SEGGER_RTT_ConfigUpBuffer(0, swdconBufferName, swdconUpBuffer, sizeof(swdconUpBuffer), SEGGER_RTT_MODE_DEFAULT); + srvMode = MODE_ON; // hardcoded for now +} + +/*JSON{ + "type" : "kill", + "generate" : "jswrap_swdcon_kill" +} +*/ +void jswrap_swdcon_kill(void) { + srvMode = MODE_OFF; +} + +/*JSON{ + "type" : "idle", + "generate" : "jswrap_swdcon_idle" +} +*/ +bool swdconActivate(); +bool swdconRecv(); + +bool jswrap_swdcon_idle(void) { + + if (srvMode == MODE_OFF) { + return false; + } + + if (SEGGER_RTT_HasKey()) swdconActivate(); + bool active = false; + active |= swdconRecv(); + // prevent sleep if SWD console is active, we probably have power attached anyway + // sleeping would work if SWD debugger would trigger interrupt after sending data (it does not) + // however it is possible to trigger interrupt in our own SWD RTT host in future + // e.g. triggering TIMER1 interrupt vie writing STIR register wakes nrf52 espruino device + active |= (jsiGetConsoleDevice() == EV_SWDCON); + return active; +} + +//===== Internal functions +bool wasForced=false; +IOEventFlags oldConsole = EV_NONE; +// on Bangle 2 looks like console is always forced to something (bluetooth or null) +// setting to non-programmable forces console to null in .boot0 +// allow to override this case +#define shouldOverride (console == EV_NONE) + +bool swdconActivate() { + // if the console is not already us, then change it + IOEventFlags console = jsiGetConsoleDevice(); + if (console != EV_SWDCON) { + if (!jsiIsConsoleDeviceForced()) { + jsiSetConsoleDevice(EV_SWDCON, false); + //jshHadEvent(); + wasForced=false; + } else { + if (shouldOverride){ + wasForced=true; + oldConsole=console; + jsiSetConsoleDevice(EV_SWDCON, true); + } + } + } + return true; +} + +// Close the connection and release the console device +void swdconRelease() { + IOEventFlags console = jsiGetConsoleDevice(); + // only switch away if the current console is us + if (console == EV_SWDCON){ + if (wasForced){ + jsiSetConsoleDevice(oldConsole, true); // restore previos forced one back + wasForced=false; + } else { + jsiSetConsoleDevice(jsiGetPreferredConsoleDevice(), false); + } + } +} + +void swdconSendChar(char ch) { + if (srvMode == MODE_OFF) return; + int timeout = WAIT_UNTIL_N_CYCLES; + while (SEGGER_RTT_GetAvailWriteSpace(0)==0){ + // same handling as in jshTransmit + if (jshIsInInterrupt()) { + // if we're printing from an IRQ, don't wait - it's unlikely TX will ever finish + jsErrorFlags |= JSERR_BUFFER_FULL; + return; + } + jshBusyIdle(); + if (--timeout == 0) { + // try to switch away if buffer is full and nobody is reading + jsiStatus |= JSIS_ECHO_OFF_FOR_LINE; // we are full, no space for "<-" when switching + swdconRelease(); + return; + } + } + SEGGER_RTT_PutChar(0,ch); +} + +bool swdconRecv() { + bool gotChar=false; + char c; + while(SEGGER_RTT_Read(0, &c, 1) > 0){ + jshPushIOCharEvent(EV_SWDCON, c); + gotChar=true; + } + if (gotChar) jshHadEvent(); + return gotChar; +} diff --git a/libs/swdcon/jswrap_swdcon.h b/libs/swdcon/jswrap_swdcon.h new file mode 100644 index 0000000000..dfb655506d --- /dev/null +++ b/libs/swdcon/jswrap_swdcon.h @@ -0,0 +1,28 @@ +/* + * This file is part of Espruino, a JavaScript interpreter for Microcontrollers + * + * Copyright (C) 2013 Thorsten von Eicken + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * ---------------------------------------------------------------------------- + * Contains JavaScript HTTP Functions + * ---------------------------------------------------------------------------- + */ +#ifndef LIBS_SWDCON_H_ +#define LIBS_SWDCON_H_ + +#include "jsvar.h" + +void jswrap_swdcon_setOptions(JsVar *options); + +void jswrap_swdcon_init(void); +void jswrap_swdcon_kill(void); + +// Listen, accept, send, and recv on telnet console connections. Returns true if something +// was done. +bool jswrap_swdcon_idle(void); + +#endif diff --git a/src/jsdevices.c b/src/jsdevices.c index 5767b63edb..0ac420cb49 100644 --- a/src/jsdevices.c +++ b/src/jsdevices.c @@ -202,6 +202,13 @@ void jshTransmit( return; } #endif +#ifdef USE_SWDCON + if (device==EV_SWDCON) { + extern void swdconSendChar(char c); + swdconSendChar((char)data); + return; + } +#endif #ifndef LINUX #ifdef USB if (device==EV_USBSERIAL && !jshIsUSBSERIALConnected()) { @@ -613,6 +620,9 @@ const char *jshGetDeviceString( #ifdef USE_TELNET case EV_TELNET: return "Telnet"; #endif +#ifdef USE_SWDCON + case EV_SWDCON: return "SWDCON"; +#endif #ifdef USE_TERMINAL case EV_TERMINAL: return "Terminal"; #endif @@ -686,6 +696,9 @@ IOEventFlags jshFromDeviceString( #endif } else if (device[0]=='S') { +#ifdef USE_SWDCON + if (strcmp(&device[1], "WDCON")==0) return EV_SWDCON; +#endif #if ESPR_USART_COUNT>0 if (device[1]=='e' && device[2]=='r' && device[3]=='i' && device[4]=='a' && device[5]=='l' && device[6]>='1' && (device[6]-'1') Date: Thu, 8 Aug 2024 10:02:00 +0200 Subject: [PATCH 02/19] enable SWDCON for Bangle 2 --- boards/BANGLEJS2.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/boards/BANGLEJS2.py b/boards/BANGLEJS2.py index 7f4515a1d4..96e0653d80 100644 --- a/boards/BANGLEJS2.py +++ b/boards/BANGLEJS2.py @@ -38,7 +38,7 @@ 'CRYPTO','SHA256','SHA512', 'LCD_MEMLCD', 'TENSORFLOW', -# 'SWDCON', RTT console over SWD + 'SWDCON', RTT console over SWD 'JIT' # JIT compiler enabled ], 'makefile' : [ From 8781ed601ea95894a4c21b31c018e488b36d4486 Mon Sep 17 00:00:00 2001 From: fanoush Date: Thu, 8 Aug 2024 10:04:05 +0200 Subject: [PATCH 03/19] SWDCON enable fix --- boards/BANGLEJS2.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/boards/BANGLEJS2.py b/boards/BANGLEJS2.py index 96e0653d80..edf4c48fe8 100644 --- a/boards/BANGLEJS2.py +++ b/boards/BANGLEJS2.py @@ -38,7 +38,7 @@ 'CRYPTO','SHA256','SHA512', 'LCD_MEMLCD', 'TENSORFLOW', - 'SWDCON', RTT console over SWD + 'SWDCON', # RTT console over SWD 'JIT' # JIT compiler enabled ], 'makefile' : [ From c60f49c1bb220f6644fffa76f9a16523fdf4751f Mon Sep 17 00:00:00 2001 From: fanoush Date: Fri, 9 Aug 2024 08:51:13 +0200 Subject: [PATCH 04/19] make console override code optional + enable for BANGLEJS fix typos/comments --- libs/swdcon/jswrap_swdcon.c | 27 ++++++++++++++++++--------- libs/swdcon/jswrap_swdcon.h | 9 ++------- 2 files changed, 20 insertions(+), 16 deletions(-) diff --git a/libs/swdcon/jswrap_swdcon.c b/libs/swdcon/jswrap_swdcon.c index 3cfd98ee0f..b64e796a1b 100644 --- a/libs/swdcon/jswrap_swdcon.c +++ b/libs/swdcon/jswrap_swdcon.c @@ -1,6 +1,8 @@ /* * This file is part of Espruino, a JavaScript interpreter for Microcontrollers * + * Copyright (C) 2013 Gordon Williams + * * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at http://mozilla.org/MPL/2.0/. @@ -59,7 +61,7 @@ static uint8_t srvMode = MODE_OFF; ///< current mode "ifdef" : "USE_SWDCON" } In memory serial I/O device accessible via SWD debugger. -uses SEGGER RTT so it can be used with openocd and other SEGGER compatible tools. +Uses SEGGER RTT so it can be used with openocd and other SEGGER compatible tools. */ @@ -102,35 +104,39 @@ bool jswrap_swdcon_idle(void) { bool active = false; active |= swdconRecv(); // prevent sleep if SWD console is active, we probably have power attached anyway + active |= (jsiGetConsoleDevice() == EV_SWDCON); // sleeping would work if SWD debugger would trigger interrupt after sending data (it does not) // however it is possible to trigger interrupt in our own SWD RTT host in future // e.g. triggering TIMER1 interrupt vie writing STIR register wakes nrf52 espruino device - active |= (jsiGetConsoleDevice() == EV_SWDCON); return active; } //===== Internal functions -bool wasForced=false; -IOEventFlags oldConsole = EV_NONE; +#ifdef BANGLEJS // on Bangle 2 looks like console is always forced to something (bluetooth or null) // setting to non-programmable forces console to null in .boot0 // allow to override this case -#define shouldOverride (console == EV_NONE) +#define OVERRIDE_CONDITION (console == EV_NONE) +bool wasForced=false; +IOEventFlags oldConsole = EV_NONE; +#endif bool swdconActivate() { - // if the console is not already us, then change it + // if current console is not already us, then change it IOEventFlags console = jsiGetConsoleDevice(); if (console != EV_SWDCON) { if (!jsiIsConsoleDeviceForced()) { jsiSetConsoleDevice(EV_SWDCON, false); //jshHadEvent(); +#ifdef OVERRIDE_CONDITION wasForced=false; } else { - if (shouldOverride){ + if (OVERRIDE_CONDITION){ wasForced=true; oldConsole=console; jsiSetConsoleDevice(EV_SWDCON, true); } +#endif } } return true; @@ -141,10 +147,13 @@ void swdconRelease() { IOEventFlags console = jsiGetConsoleDevice(); // only switch away if the current console is us if (console == EV_SWDCON){ +#ifdef OVERRIDE_CONDITION if (wasForced){ - jsiSetConsoleDevice(oldConsole, true); // restore previos forced one back + jsiSetConsoleDevice(oldConsole, true); // restore previous forced one back wasForced=false; - } else { + } else +#endif + { jsiSetConsoleDevice(jsiGetPreferredConsoleDevice(), false); } } diff --git a/libs/swdcon/jswrap_swdcon.h b/libs/swdcon/jswrap_swdcon.h index dfb655506d..98f700af13 100644 --- a/libs/swdcon/jswrap_swdcon.h +++ b/libs/swdcon/jswrap_swdcon.h @@ -1,14 +1,14 @@ /* * This file is part of Espruino, a JavaScript interpreter for Microcontrollers * - * Copyright (C) 2013 Thorsten von Eicken + * Copyright (C) 2013 Gordon Williams * * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at http://mozilla.org/MPL/2.0/. * * ---------------------------------------------------------------------------- - * Contains JavaScript HTTP Functions + * Contains JavaScript SWD console * ---------------------------------------------------------------------------- */ #ifndef LIBS_SWDCON_H_ @@ -16,13 +16,8 @@ #include "jsvar.h" -void jswrap_swdcon_setOptions(JsVar *options); - void jswrap_swdcon_init(void); void jswrap_swdcon_kill(void); - -// Listen, accept, send, and recv on telnet console connections. Returns true if something -// was done. bool jswrap_swdcon_idle(void); #endif From baf64ef054b34097441b39a9f47b72dbebb01c4f Mon Sep 17 00:00:00 2001 From: fanoush Date: Mon, 19 Aug 2024 01:53:48 +0200 Subject: [PATCH 05/19] use utility timer to poll RTT buffers --- libs/swdcon/jswrap_swdcon.c | 152 +++++++++++++++++++++++++++--------- src/jsdevices.c | 13 ++- 2 files changed, 122 insertions(+), 43 deletions(-) diff --git a/libs/swdcon/jswrap_swdcon.c b/libs/swdcon/jswrap_swdcon.c index 3cfd98ee0f..b0f873cc1a 100644 --- a/libs/swdcon/jswrap_swdcon.c +++ b/libs/swdcon/jswrap_swdcon.c @@ -13,7 +13,7 @@ */ #include "jsvariterator.h" #include "jsinteractive.h" - +#include "jstimer.h" #ifdef NRF5X #include "app_util_platform.h" #endif @@ -38,19 +38,32 @@ //#include "SEGGER_RTT_Conf.h" #include "SEGGER_RTT_custom.c" +// Forward function declarations +bool swdconActivate(); +void swdconRelease(); +bool swdconRecv(); +bool swdconSend(); +void swdconUtilTimerTask(JsSysTime time, void* userdata); +void swdconEnablePolling(int interval); +void swdconDisablePolling(); + +// console data structures + // possibly dynamically allocated from variables? static char swdconUpBuffer[BUFFER_SIZE_UP]; static char swdconDownBuffer[BUFFER_SIZE_DOWN]; const char swdconBufferName[] ="SWDCON"; // visible in "rtt channels" openocd command, SEGGER default for channel 0 is "Terminal" -// Forward function declarations - - -// console data structures #define MODE_OFF 0 // console is off #define MODE_ON 1 // console is on -static uint8_t srvMode = MODE_OFF; ///< current mode +static struct { + uint8_t srvMode:1; + bool timerRunning:1; + bool timerSlow:1; +} flags; + +uint32_t timerIdleCounter=0; /*JSON{ "type" : "object", @@ -70,9 +83,9 @@ uses SEGGER RTT so it can be used with openocd and other SEGGER compatible tools */ void jswrap_swdcon_init(void) { SEGGER_RTT_Init(); - SEGGER_RTT_ConfigDownBuffer(0, swdconBufferName, swdconDownBuffer, sizeof(swdconDownBuffer), SEGGER_RTT_MODE_DEFAULT); + SEGGER_RTT_ConfigDownBuffer(0, swdconBufferName, swdconDownBuffer, sizeof(swdconDownBuffer), SEGGER_RTT_MODE_BLOCK_IF_FIFO_FULL); SEGGER_RTT_ConfigUpBuffer(0, swdconBufferName, swdconUpBuffer, sizeof(swdconUpBuffer), SEGGER_RTT_MODE_DEFAULT); - srvMode = MODE_ON; // hardcoded for now + flags.srvMode = MODE_ON; // hardcoded for now } /*JSON{ @@ -81,7 +94,8 @@ void jswrap_swdcon_init(void) { } */ void jswrap_swdcon_kill(void) { - srvMode = MODE_OFF; + flags.srvMode = MODE_OFF; + swdconDisablePolling(); } /*JSON{ @@ -89,26 +103,82 @@ void jswrap_swdcon_kill(void) { "generate" : "jswrap_swdcon_idle" } */ -bool swdconActivate(); -bool swdconRecv(); bool jswrap_swdcon_idle(void) { - if (srvMode == MODE_OFF) { + if (flags.srvMode == MODE_OFF) { return false; } - if (SEGGER_RTT_HasKey()) swdconActivate(); + if (SEGGER_RTT_HasKey()){ + swdconActivate(); + if (!flags.timerRunning){ + swdconEnablePolling(50); + } + } else { + if (flags.timerRunning){ + if (timerIdleCounter < 10 && flags.timerSlow){ + // restart timer in fast mode + swdconDisablePolling(); + flags.timerSlow=false; + swdconEnablePolling(50); + timerIdleCounter = 0; + + } + if (timerIdleCounter > 200 && !flags.timerSlow){ + // slow down timer if idle for too long (>10 sec = 50*200ms) + swdconDisablePolling(); + swdconEnablePolling(500); + flags.timerSlow = true; + timerIdleCounter = 10; + } + // stop polling if idle for 10min=500*1200ms + if (timerIdleCounter > 1200 && flags.timerSlow){ + swdconDisablePolling(); + flags.timerSlow=false; + timerIdleCounter = 0; + } + } + } + bool active = false; - active |= swdconRecv(); - // prevent sleep if SWD console is active, we probably have power attached anyway - // sleeping would work if SWD debugger would trigger interrupt after sending data (it does not) - // however it is possible to trigger interrupt in our own SWD RTT host in future - // e.g. triggering TIMER1 interrupt vie writing STIR register wakes nrf52 espruino device - active |= (jsiGetConsoleDevice() == EV_SWDCON); + if (!flags.timerRunning){ + // no polling in timer, do it here instead + active |= swdconRecv(); + active |= swdconSend(); + // prevent sleep if SWD console is active, we probably have power attached anyway + // sleeping would work if SWD debugger would trigger interrupt after sending data (it does not) + // however it is possible to trigger interrupt in our own SWD RTT host in future + // e.g. triggering TIMER1 interrupt vie writing STIR register wakes nrf52 espruino device + active |= (jsiGetConsoleDevice() == EV_SWDCON); + } return active; } +void swdconUtilTimerTask(JsSysTime time, void* userdata){ +// if (jsiGetConsoleDevice() != EV_SWDCON) +// return; + bool active = false; + active |= swdconRecv(); + active |= swdconSend(); + if (active) + timerIdleCounter=0; + else + timerIdleCounter++; +} +void swdconEnablePolling(int interval){ + if (!flags.timerRunning){ + JsSysTime t = jshGetTimeFromMilliseconds(interval); + flags.timerRunning = jstExecuteFn(&swdconUtilTimerTask,NULL,t,t,NULL); + } +} + +void swdconDisablePolling(){ + if (flags.timerRunning){ + jstStopExecuteFn(&swdconUtilTimerTask,NULL); + flags.timerRunning = false; + } +} //===== Internal functions bool wasForced=false; IOEventFlags oldConsole = EV_NONE; @@ -135,7 +205,6 @@ bool swdconActivate() { } return true; } - // Close the connection and release the console device void swdconRelease() { IOEventFlags console = jsiGetConsoleDevice(); @@ -150,25 +219,36 @@ void swdconRelease() { } } -void swdconSendChar(char ch) { - if (srvMode == MODE_OFF) return; - int timeout = WAIT_UNTIL_N_CYCLES; - while (SEGGER_RTT_GetAvailWriteSpace(0)==0){ - // same handling as in jshTransmit - if (jshIsInInterrupt()) { - // if we're printing from an IRQ, don't wait - it's unlikely TX will ever finish - jsErrorFlags |= JSERR_BUFFER_FULL; - return; - } - jshBusyIdle(); - if (--timeout == 0) { - // try to switch away if buffer is full and nobody is reading +// handle full Espruino transmit buffer +void swdconBusyIdle(int loopCount){ + if (flags.srvMode == MODE_OFF) return; + if (flags.timerRunning || SEGGER_RTT_GetAvailWriteSpace(0)==0){ + // we can't send to host here + if (loopCount>10000){ + // if it takes too long and nobody is reading then give up and try to switch away + jshTransmitClearDevice(EV_SWDCON); jsiStatus |= JSIS_ECHO_OFF_FOR_LINE; // we are full, no space for "<-" when switching swdconRelease(); - return; + jsErrorFlags |= JSERR_BUFFER_FULL; } - } - SEGGER_RTT_PutChar(0,ch); + return; + } + // ok, we can try to send data to RTT host now + int ch = jshGetCharToTransmit(EV_SWDCON); + if (ch < 0) return; + SEGGER_RTT_PutChar(0,(char)ch); +} + +bool swdconSend(){ + bool gotChar=false; + while (SEGGER_RTT_GetAvailWriteSpace(0)>0){ + int ch = jshGetCharToTransmit(EV_SWDCON); + if (ch<0) + break; + SEGGER_RTT_PutChar(0,(char)ch); + gotChar=true; + } + return gotChar; } bool swdconRecv() { diff --git a/src/jsdevices.c b/src/jsdevices.c index 0ac420cb49..2d7f5ab993 100644 --- a/src/jsdevices.c +++ b/src/jsdevices.c @@ -202,13 +202,6 @@ void jshTransmit( return; } #endif -#ifdef USE_SWDCON - if (device==EV_SWDCON) { - extern void swdconSendChar(char c); - swdconSendChar((char)data); - return; - } -#endif #ifndef LINUX #ifdef USB if (device==EV_USBSERIAL && !jshIsUSBSERIALConnected()) { @@ -239,6 +232,7 @@ void jshTransmit( if (txHeadNext==txTail) { jsiSetBusy(BUSY_TRANSMIT, true); bool wasConsoleLimbo = device==EV_LIMBO && jsiGetConsoleDevice()==EV_LIMBO; + int loopCount=0; while (txHeadNext==txTail) { // wait for send to finish as buffer is about to overflow if (jshIsInInterrupt()) { @@ -247,6 +241,11 @@ void jshTransmit( return; } jshBusyIdle(); +#ifdef USE_SWDCON + loopCount++; + extern bool swdconBusyIdle(int); + if (device == EV_SWDCON) swdconBusyIdle(loopCount); +#endif #ifdef USB // just in case USB was unplugged while we were waiting! if (!jshIsUSBSERIALConnected()) jshTransmitClearDevice(EV_USBSERIAL); From f690af57d7de4600de3ce3d9bab5e7e8b41c65ee Mon Sep 17 00:00:00 2001 From: fanoush Date: Tue, 20 Aug 2024 08:48:37 +0200 Subject: [PATCH 06/19] start and don't stop polling if console active, cleanup code --- libs/swdcon/jswrap_swdcon.c | 89 ++++++++++++++++++++----------------- 1 file changed, 48 insertions(+), 41 deletions(-) diff --git a/libs/swdcon/jswrap_swdcon.c b/libs/swdcon/jswrap_swdcon.c index b0f873cc1a..cd87b0d579 100644 --- a/libs/swdcon/jswrap_swdcon.c +++ b/libs/swdcon/jswrap_swdcon.c @@ -103,54 +103,61 @@ void jswrap_swdcon_kill(void) { "generate" : "jswrap_swdcon_idle" } */ +#define SWDCON_IDLE_RESET_THRESHOLD 16 +#define SWDCON_POLL_FAST_MS 50 +#define SWDCON_POLL_SLOW_MS 500 +// slow down polling when idle +#define SWDCON_POLL_TIMEOUT_SLOW 200 // 10s = 50*200ms +// disable polling when it is slow and console is not active +#define SWDCON_POLL_TIMEOUT_OFF 40 // 20s = 500*40ms bool jswrap_swdcon_idle(void) { if (flags.srvMode == MODE_OFF) { return false; } - - if (SEGGER_RTT_HasKey()){ - swdconActivate(); - if (!flags.timerRunning){ - swdconEnablePolling(50); + bool active = false; + if (flags.timerRunning == false){ + if (SEGGER_RTT_HasKey()){ + // activate console on first key press received + swdconActivate(); + } + // start polling if console is active + if (jsiGetConsoleDevice() == EV_SWDCON){ + flags.timerSlow = false; + timerIdleCounter = 0; + swdconEnablePolling(SWDCON_POLL_FAST_MS); + } else { + // no polling in timer so do it here instead + active |= swdconRecv(); + active |= swdconSend(); } } else { - if (flags.timerRunning){ - if (timerIdleCounter < 10 && flags.timerSlow){ - // restart timer in fast mode - swdconDisablePolling(); - flags.timerSlow=false; - swdconEnablePolling(50); - timerIdleCounter = 0; - - } - if (timerIdleCounter > 200 && !flags.timerSlow){ - // slow down timer if idle for too long (>10 sec = 50*200ms) - swdconDisablePolling(); - swdconEnablePolling(500); - flags.timerSlow = true; - timerIdleCounter = 10; - } - // stop polling if idle for 10min=500*1200ms - if (timerIdleCounter > 1200 && flags.timerSlow){ - swdconDisablePolling(); - flags.timerSlow=false; - timerIdleCounter = 0; - } + // timer already running so check idle state + if (timerIdleCounter < SWDCON_IDLE_RESET_THRESHOLD && flags.timerSlow){ + // restart timer in fast mode if we are not idle + // threshold is there just to not miss it if timer is faster than idle loop + swdconDisablePolling(); + flags.timerSlow=false; + timerIdleCounter = 0; + swdconEnablePolling(SWDCON_POLL_FAST_MS); + } + if (timerIdleCounter > SWDCON_POLL_TIMEOUT_SLOW && !flags.timerSlow){ + // slow down timer if idle for too long + swdconDisablePolling(); + flags.timerSlow = true; + timerIdleCounter = SWDCON_IDLE_RESET_THRESHOLD; // set higher than test above + swdconEnablePolling(SWDCON_POLL_SLOW_MS); + } + if (timerIdleCounter > (SWDCON_POLL_TIMEOUT_OFF+SWDCON_IDLE_RESET_THRESHOLD) + && flags.timerSlow + && jsiGetConsoleDevice() != EV_SWDCON){ + // polling is needed for ctrl+c to break busy loops + // stop polling if idle and our console is not active + swdconDisablePolling(); + flags.timerSlow=false; + timerIdleCounter = 0; } - } - - bool active = false; - if (!flags.timerRunning){ - // no polling in timer, do it here instead - active |= swdconRecv(); - active |= swdconSend(); - // prevent sleep if SWD console is active, we probably have power attached anyway - // sleeping would work if SWD debugger would trigger interrupt after sending data (it does not) - // however it is possible to trigger interrupt in our own SWD RTT host in future - // e.g. triggering TIMER1 interrupt vie writing STIR register wakes nrf52 espruino device - active |= (jsiGetConsoleDevice() == EV_SWDCON); } return active; } @@ -219,12 +226,12 @@ void swdconRelease() { } } -// handle full Espruino transmit buffer +// handle Espruino transmit buffer being full void swdconBusyIdle(int loopCount){ if (flags.srvMode == MODE_OFF) return; if (flags.timerRunning || SEGGER_RTT_GetAvailWriteSpace(0)==0){ // we can't send to host here - if (loopCount>10000){ + if (loopCount > WAIT_UNTIL_N_CYCLES){ // if it takes too long and nobody is reading then give up and try to switch away jshTransmitClearDevice(EV_SWDCON); jsiStatus |= JSIS_ECHO_OFF_FOR_LINE; // we are full, no space for "<-" when switching From b46c6b5c00a957ef8bfe0d7976db64aab80dde12 Mon Sep 17 00:00:00 2001 From: fanoush Date: Wed, 28 Aug 2024 01:44:56 +0200 Subject: [PATCH 07/19] remove slow polling mode, cleanup --- libs/swdcon/jswrap_swdcon.c | 87 +++++++++++++------------------------ 1 file changed, 30 insertions(+), 57 deletions(-) diff --git a/libs/swdcon/jswrap_swdcon.c b/libs/swdcon/jswrap_swdcon.c index 5289d6a84b..3ba7bba640 100644 --- a/libs/swdcon/jswrap_swdcon.c +++ b/libs/swdcon/jswrap_swdcon.c @@ -13,6 +13,7 @@ * Contains JavaScript SWD console * ---------------------------------------------------------------------------- */ +#include "jswrap_swdcon.h" #include "jsvariterator.h" #include "jsinteractive.h" #include "jstimer.h" @@ -37,7 +38,7 @@ #define SEGGER_RTT_MODE_DEFAULT SEGGER_RTT_MODE_NO_BLOCK_SKIP // Mode for pre-initialized terminal channel (buffer 0) #define SEGGER_RTT_LOCK() CRITICAL_REGION_ENTER() #define SEGGER_RTT_UNLOCK() CRITICAL_REGION_EXIT() -//#include "SEGGER_RTT_Conf.h" + #include "SEGGER_RTT_custom.c" // Forward function declarations @@ -62,10 +63,12 @@ const char swdconBufferName[] ="SWDCON"; // visible in "rtt channels" openocd co static struct { uint8_t srvMode:1; bool timerRunning:1; - bool timerSlow:1; } flags; -uint32_t timerIdleCounter=0; +// utility timer interval for polling RTT buffers +#define SWDCON_POLL_MS 50 + +// uint32_t timerIdleCounter=0; /*JSON{ "type" : "object", @@ -105,13 +108,6 @@ void jswrap_swdcon_kill(void) { "generate" : "jswrap_swdcon_idle" } */ -#define SWDCON_IDLE_RESET_THRESHOLD 16 -#define SWDCON_POLL_FAST_MS 50 -#define SWDCON_POLL_SLOW_MS 500 -// slow down polling when idle -#define SWDCON_POLL_TIMEOUT_SLOW 200 // 10s = 50*200ms -// disable polling when it is slow and console is not active -#define SWDCON_POLL_TIMEOUT_OFF 40 // 20s = 500*40ms bool jswrap_swdcon_idle(void) { @@ -126,53 +122,32 @@ bool jswrap_swdcon_idle(void) { } // start polling if console is active if (jsiGetConsoleDevice() == EV_SWDCON){ - flags.timerSlow = false; - timerIdleCounter = 0; - swdconEnablePolling(SWDCON_POLL_FAST_MS); + swdconEnablePolling(SWDCON_POLL_MS); } else { // no polling in timer so do it here instead active |= swdconRecv(); active |= swdconSend(); } } else { - // timer already running so check idle state - if (timerIdleCounter < SWDCON_IDLE_RESET_THRESHOLD && flags.timerSlow){ - // restart timer in fast mode if we are not idle - // threshold is there just to not miss it if timer is faster than idle loop - swdconDisablePolling(); - flags.timerSlow=false; - timerIdleCounter = 0; - swdconEnablePolling(SWDCON_POLL_FAST_MS); - } - if (timerIdleCounter > SWDCON_POLL_TIMEOUT_SLOW && !flags.timerSlow){ - // slow down timer if idle for too long + // check if conole still active + if (jsiGetConsoleDevice() != EV_SWDCON){ + // stop polling timer if console is not active + // as polling is really needed for ctrl+c to break busy loops swdconDisablePolling(); - flags.timerSlow = true; - timerIdleCounter = SWDCON_IDLE_RESET_THRESHOLD; // set higher than test above - swdconEnablePolling(SWDCON_POLL_SLOW_MS); - } - if (timerIdleCounter > (SWDCON_POLL_TIMEOUT_OFF+SWDCON_IDLE_RESET_THRESHOLD) - && flags.timerSlow - && jsiGetConsoleDevice() != EV_SWDCON){ - // polling is needed for ctrl+c to break busy loops - // stop polling if idle and our console is not active - swdconDisablePolling(); - flags.timerSlow=false; - timerIdleCounter = 0; } } return active; } void swdconUtilTimerTask(JsSysTime time, void* userdata){ -// if (jsiGetConsoleDevice() != EV_SWDCON) -// return; bool active = false; active |= swdconRecv(); active |= swdconSend(); +/* idle counter not needed for now if (active) timerIdleCounter=0; else timerIdleCounter++; +*/ } void swdconEnablePolling(int interval){ @@ -218,41 +193,39 @@ bool swdconActivate() { } return true; } -// Close the connection and release the console device +// deactivate this console void swdconRelease() { - IOEventFlags console = jsiGetConsoleDevice(); - // only switch away if the current console is us - if (console == EV_SWDCON){ + // only try to switch away if the current console is us + if (jsiGetConsoleDevice() != EV_SWDCON) return; + IOEventFlags newConsole = jsiGetPreferredConsoleDevice(); + bool force = false; #ifdef OVERRIDE_CONDITION - if (wasForced){ - jsiSetConsoleDevice(oldConsole, true); // restore previous forced one back - wasForced=false; - } else -#endif - { - jsiSetConsoleDevice(jsiGetPreferredConsoleDevice(), false); - } + if (wasForced){ + force = true; + newConsole = oldConsole; } +#endif + if (newConsole != EV_SWDCON && SEGGER_RTT_GetAvailWriteSpace(0) == 0) + jsiStatus |= JSIS_ECHO_OFF_FOR_LINE; // we are full, no space for "<- " message when switching + jsiSetConsoleDevice(newConsole, force); } // handle Espruino transmit buffer being full void swdconBusyIdle(int loopCount){ if (flags.srvMode == MODE_OFF) return; if (flags.timerRunning || SEGGER_RTT_GetAvailWriteSpace(0)==0){ - // we can't send to host here + // we can't help with full buffer here if (loopCount > WAIT_UNTIL_N_CYCLES){ // if it takes too long and nobody is reading then give up and try to switch away jshTransmitClearDevice(EV_SWDCON); - jsiStatus |= JSIS_ECHO_OFF_FOR_LINE; // we are full, no space for "<-" when switching - swdconRelease(); jsErrorFlags |= JSERR_BUFFER_FULL; + swdconRelease(); } return; } - // ok, we can try to send data to RTT host now - int ch = jshGetCharToTransmit(EV_SWDCON); - if (ch < 0) return; - SEGGER_RTT_PutChar(0,(char)ch); + // ok, no timer running and there is space so we can try to send data to RTT host + if (swdconSend()) + jshHadEvent(); // prevent sleep, maybe there is more to send in next cycle } bool swdconSend(){ From cdfb4d399f0a24df0177cdf926e47ea302dab6ea Mon Sep 17 00:00:00 2001 From: fanoush Date: Wed, 28 Aug 2024 09:49:16 +0200 Subject: [PATCH 08/19] loopCount variable - ifdef+comment --- src/jsdevices.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/jsdevices.c b/src/jsdevices.c index 2d7f5ab993..fb459dfaa5 100644 --- a/src/jsdevices.c +++ b/src/jsdevices.c @@ -232,7 +232,9 @@ void jshTransmit( if (txHeadNext==txTail) { jsiSetBusy(BUSY_TRANSMIT, true); bool wasConsoleLimbo = device==EV_LIMBO && jsiGetConsoleDevice()==EV_LIMBO; - int loopCount=0; +#ifdef USE_SWDCON + int loopCount=0; // for recovery inside swdconBusyIdle +#endif while (txHeadNext==txTail) { // wait for send to finish as buffer is about to overflow if (jshIsInInterrupt()) { From 67eb166924702ded17d822c59b52fe49688e1887 Mon Sep 17 00:00:00 2001 From: fanoush Date: Wed, 28 Aug 2024 14:38:13 +0200 Subject: [PATCH 09/19] added README with OpenOCD RTT guide --- libs/swdcon/README.md | 50 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 50 insertions(+) create mode 100644 libs/swdcon/README.md diff --git a/libs/swdcon/README.md b/libs/swdcon/README.md new file mode 100644 index 0000000000..5a17e6ae77 --- /dev/null +++ b/libs/swdcon/README.md @@ -0,0 +1,50 @@ +# SWDCON - console over Segger RTT + +This is Espruino console over [Segger RTT](https://wiki.segger.com/RTT) technology. Can be used with [BANGLEJS2](https://www.espruino.com/Bangle.js2#hardware-swd) over charging cable or with any other device that has SWD pins available and no extra UART or USB. Also could work as initial console when porting to new devices before other drivers are working. + +The console can be used via Segger RTT Viewer (if you use J-Link debugger probe) or it can be also used with OpenOCD with any debugger probe like e.g. cheap CMSIS-DAP dongle. + +In future the console can be also used with any Espruino device with 2 free GPIOs acting as serial to SWD/RTT bridge. + +## OpenOCD start + +Attach openocd to device, for nrf52 and cmsis-dap probe it is something like `openocd -d2 -f interface/cmsis-dap.cfg -f target/nrf52.cfg`. Then connect +to openocd interactive console via `telnet localhost 4444` (Or you can use e.g. Putty for making Telnet connection) and continue with some OpenOCD commands below: + +`rtt setup 0x20000000 262144 "SEGGER RTT"` - with 256KB RAM size for nrf52840 like BANGLEJS2 + +`rtt setup 0x20000000 65535 "SEGGER RTT"` - with 64KB RAM size for nrf52832, newer OpenOCD may not need third "SEGGER RTT" parameter + +`rtt start` - should search and find the buffer + +`rtt server start 2222 0` - start telnet server on port 2222 for channel 0 = SWDCON, use any free port number you wish + +`rtt server start 2222 0 "\377\375\042\377\373\001"` - newer OpenOCD versions can send initial string to telnet client, this switches it to raw mode but adds some extra initial garbage also to espruino console as telnet client sends some stuff back, more info https://stackoverflow.com/questions/273261/force-telnet-client-into-character-mode + +To connect to console use anothe telnet connecion - `telnet localhost 2222` +By default telnet is in line mode if there is no rtt server inital string. For espruino console we need raw character mode, +type ctrl+],Enter and then type `mode char` to switch to raw mode +or you can use netcat https://unix.stackexchange.com/questions/767170/using-telnet-command-without-protocol-negotiation + +Now press ctrl+c to clear espruino console and/or press enter few times to see some initial errors from telnet garbage + +If the device is in deep sleep you need to wake it up to notice the input and switch console - e.g. press button on Bangle watch + +## OpenOCD stop + +`rtt stop` - stop polling data, do this also before flashing new version of espruino (server can stay running but rttt stop, setup and start is needed to run after firmware update) +`rtt server stop 2222` - optional +`nrf52.dap dpreg 4 0 ; shutdown` - with cmsis-dap this powers down nrf52 debug hardware (`dap dpreg 4 0`) and disconnects, if you would just close openocd and nrf5x stays in debug mode it drains battery and needs reboot to clear this state + +## Known issues + +- clipboard paste drops data when buffer is full, this is openocd issue - it only writes first part that fits into buffer and does not retry or wait for data to go out, quick fix in branch here https://github.com/fanoush/openocd/tree/f-rtt-server-write-retry with windows build here https://github.com/fanoush/openocd/releases/tag/latest + +- if device is in deep sleep it needs to be woken up to activate the console - press button, press enter in old console, for nrf52 also triggering TIMER1_IRQn interrupt via STIR register write in openocd works `mww 0xE000EF00 9` + +## TODO + +- disable/enable and allocate buffers for SDWCON dynamically at runtime + +- our own SWD RTT host code instead of openocd/telnet - espruino device can redirect its serial/usb/bluetooth console to another device via 2 GPIOs + From 9b7eb5bcba95973c4a82fb341831b64860eafea5 Mon Sep 17 00:00:00 2001 From: fanoush Date: Wed, 28 Aug 2024 15:35:56 +0200 Subject: [PATCH 10/19] README update - polling interval, typos --- libs/swdcon/README.md | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/libs/swdcon/README.md b/libs/swdcon/README.md index 5a17e6ae77..df1abc3448 100644 --- a/libs/swdcon/README.md +++ b/libs/swdcon/README.md @@ -17,11 +17,13 @@ to openocd interactive console via `telnet localhost 4444` (Or you can use e.g. `rtt start` - should search and find the buffer +`rtt polling_interval 50` - optional, make console I/O faster (try e.g. E.dumpVariables() with default value) + `rtt server start 2222 0` - start telnet server on port 2222 for channel 0 = SWDCON, use any free port number you wish `rtt server start 2222 0 "\377\375\042\377\373\001"` - newer OpenOCD versions can send initial string to telnet client, this switches it to raw mode but adds some extra initial garbage also to espruino console as telnet client sends some stuff back, more info https://stackoverflow.com/questions/273261/force-telnet-client-into-character-mode -To connect to console use anothe telnet connecion - `telnet localhost 2222` +To connect to console use another telnet connection - `telnet localhost 2222` By default telnet is in line mode if there is no rtt server inital string. For espruino console we need raw character mode, type ctrl+],Enter and then type `mode char` to switch to raw mode or you can use netcat https://unix.stackexchange.com/questions/767170/using-telnet-command-without-protocol-negotiation From f8592c9dd6364dc08169917089eea8abba2171f2 Mon Sep 17 00:00:00 2001 From: fanoush Date: Wed, 28 Aug 2024 15:47:27 +0200 Subject: [PATCH 11/19] diff to see customization of SEGGER_RTT.h|.c see top of SEGGER_RTT_custom.c for more info --- libs/swdcon/SEGGER_RTT.diff | 210 ++++++++++++++++++++++++++++++++++++ 1 file changed, 210 insertions(+) create mode 100644 libs/swdcon/SEGGER_RTT.diff diff --git a/libs/swdcon/SEGGER_RTT.diff b/libs/swdcon/SEGGER_RTT.diff new file mode 100644 index 0000000000..e2f559f527 --- /dev/null +++ b/libs/swdcon/SEGGER_RTT.diff @@ -0,0 +1,210 @@ +--- SEGGER_RTT.h 2024-08-28 15:41:15.273606346 +0200 ++++ SEGGER_RTT_custom.h 2024-08-08 17:02:06.286067463 +0200 +@@ -53,7 +53,9 @@ + #ifndef SEGGER_RTT_H + #define SEGGER_RTT_H + ++#ifndef CUSTOM_RTT + #include "SEGGER_RTT_Conf.h" ++#endif + + /********************************************************************* + * +@@ -413,6 +415,7 @@ + + #define SEGGER_RTT_HASDATA_UP(n) (((SEGGER_RTT_BUFFER_UP*)((uintptr_t)&_SEGGER_RTT.aUp[n] + SEGGER_RTT_UNCACHED_OFF))->WrOff - ((SEGGER_RTT_BUFFER_UP*)((uintptr_t)&_SEGGER_RTT.aUp[n] + SEGGER_RTT_UNCACHED_OFF))->RdOff) // Access uncached to make sure we see changes made by the J-Link side and all of our changes go into HW directly + ++#ifndef CUSTOM_RTT + /********************************************************************* + * + * RTT "Terminal" API functions +@@ -430,7 +433,7 @@ + */ + int SEGGER_RTT_printf(unsigned BufferIndex, const char * sFormat, ...); + int SEGGER_RTT_vprintf(unsigned BufferIndex, const char * sFormat, va_list * pParamList); +- ++#endif // CUSTOM_RTT + #ifdef __cplusplus + } + #endif +--- SEGGER_RTT.c 2024-08-28 15:41:12.163607554 +0200 ++++ SEGGER_RTT_custom.c 2024-08-08 17:02:06.286067463 +0200 +@@ -1,3 +1,18 @@ ++/* ++ customized and cut down (=#ifdef-ed out) minimal version of SEGGER RTT ++ Version V7.94a (2023-12-06) ++ https://github.com/adfernandes/segger-rtt/tree/0022265202e4f6e7a44cf0e15e447d75b573c371 ++ ++ - no default allocation of channel 0 with name "Terminal" ++ - customizable "SEGGER RTT" header in memory (to possibly coexist with full version) ++ - removed some Terminal static deslarations + related Terminal methods ++ - INIT() macro used in most calls is empty, now needs SEGGER_RTT_Init() to work ++ - no extra _Conf.h header included ++*/ ++#define CUSTOM_RTT // used for ifdefs with changes ++#ifndef CUSTOM_RTT_HEADER_BACKWARDS ++#define CUSTOM_RTT_HEADER_BACKWARDS "TTR REGGES" ++#endif + /********************************************************************* + * SEGGER Microcontroller GmbH * + * The Embedded Experts * +@@ -68,9 +83,11 @@ + + ---------------------------------------------------------------------- + */ +- ++#ifdef CUSTOM_RTT ++#include "SEGGER_RTT_custom.h" ++#else + #include "SEGGER_RTT.h" +- ++#endif + #include // for memcpy + + /********************************************************************* +@@ -244,7 +261,10 @@ + ********************************************************************** + */ + ++#ifndef CUSTOM_RTT + static const unsigned char _aTerminalId[16] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' }; ++#endif ++ + + /********************************************************************* + * +@@ -259,11 +279,22 @@ + #if SEGGER_RTT_CPU_CACHE_LINE_SIZE + #if ((defined __GNUC__) || (defined __clang__)) + SEGGER_RTT_CB _SEGGER_RTT __attribute__ ((aligned (SEGGER_RTT_CPU_CACHE_LINE_SIZE))); +- static char _acUpBuffer [SEGGER_RTT__ROUND_UP_2_CACHE_LINE_SIZE(BUFFER_SIZE_UP)] __attribute__ ((aligned (SEGGER_RTT_CPU_CACHE_LINE_SIZE))); +- static char _acDownBuffer[SEGGER_RTT__ROUND_UP_2_CACHE_LINE_SIZE(BUFFER_SIZE_DOWN)] __attribute__ ((aligned (SEGGER_RTT_CPU_CACHE_LINE_SIZE))); + #elif (defined __ICCARM__) + #pragma data_alignment=SEGGER_RTT_CPU_CACHE_LINE_SIZE + SEGGER_RTT_CB _SEGGER_RTT; ++ #else ++ #error "Don't know how to place _SEGGER_RTT, _acUpBuffer, _acDownBuffer cache-line aligned" ++ #endif ++#else ++ SEGGER_RTT_PUT_CB_SECTION(SEGGER_RTT_CB_ALIGN(SEGGER_RTT_CB _SEGGER_RTT)); ++#endif ++ ++#ifndef CUSTOM_RTT ++#if SEGGER_RTT_CPU_CACHE_LINE_SIZE ++ #if ((defined __GNUC__) || (defined __clang__)) ++ static char _acUpBuffer [SEGGER_RTT__ROUND_UP_2_CACHE_LINE_SIZE(BUFFER_SIZE_UP)] __attribute__ ((aligned (SEGGER_RTT_CPU_CACHE_LINE_SIZE))); ++ static char _acDownBuffer[SEGGER_RTT__ROUND_UP_2_CACHE_LINE_SIZE(BUFFER_SIZE_DOWN)] __attribute__ ((aligned (SEGGER_RTT_CPU_CACHE_LINE_SIZE))); ++ #elif (defined __ICCARM__) + #pragma data_alignment=SEGGER_RTT_CPU_CACHE_LINE_SIZE + static char _acUpBuffer [SEGGER_RTT__ROUND_UP_2_CACHE_LINE_SIZE(BUFFER_SIZE_UP)]; + #pragma data_alignment=SEGGER_RTT_CPU_CACHE_LINE_SIZE +@@ -272,13 +303,12 @@ + #error "Don't know how to place _SEGGER_RTT, _acUpBuffer, _acDownBuffer cache-line aligned" + #endif + #else +- SEGGER_RTT_PUT_CB_SECTION(SEGGER_RTT_CB_ALIGN(SEGGER_RTT_CB _SEGGER_RTT)); + SEGGER_RTT_PUT_BUFFER_SECTION(SEGGER_RTT_BUFFER_ALIGN(static char _acUpBuffer [BUFFER_SIZE_UP])); + SEGGER_RTT_PUT_BUFFER_SECTION(SEGGER_RTT_BUFFER_ALIGN(static char _acDownBuffer[BUFFER_SIZE_DOWN])); + #endif + + static unsigned char _ActiveTerminal; +- ++#endif + /********************************************************************* + * + * Static functions +@@ -297,6 +327,9 @@ + * (1) May only be called via INIT() to avoid overriding settings. + * The only exception is SEGGER_RTT_Init(), to make an intentional override possible. + */ ++#ifdef CUSTOM_RTT ++#define INIT() ++#else + #define INIT() \ + do { \ + volatile SEGGER_RTT_CB* pRTTCBInit; \ +@@ -305,10 +338,11 @@ + _DoInit(); \ + } \ + } while (0) ++#endif + + static void _DoInit(void) { + volatile SEGGER_RTT_CB* p; // Volatile to make sure that compiler cannot change the order of accesses to the control block +- static const char _aInitStr[] = "\0\0\0\0\0\0TTR REGGES"; // Init complete ID string to make sure that things also work if RTT is linked to a no-init memory area ++ static const char _aInitStr[] = "\0\0\0\0\0\0"CUSTOM_RTT_HEADER_BACKWARDS; // Init complete ID string to make sure that things also work if RTT is linked to a no-init memory area + unsigned i; + // + // Initialize control block +@@ -317,6 +351,7 @@ + memset((SEGGER_RTT_CB*)p, 0, sizeof(_SEGGER_RTT)); // Make sure that the RTT CB is always zero initialized. + p->MaxNumUpBuffers = SEGGER_RTT_MAX_NUM_UP_BUFFERS; + p->MaxNumDownBuffers = SEGGER_RTT_MAX_NUM_DOWN_BUFFERS; ++#ifndef CUSTOM_RTT + // + // Initialize up buffer 0 + // +@@ -335,6 +370,7 @@ + p->aDown[0].RdOff = 0u; + p->aDown[0].WrOff = 0u; + p->aDown[0].Flags = SEGGER_RTT_MODE_DEFAULT; ++#endif + // + // Finish initialization of the control block. + // Copy Id string backwards to make sure that "SEGGER RTT" is not found in initializer memory (usually flash), +@@ -483,6 +519,7 @@ + } + } + ++#ifndef CUSTOM_RTT + /********************************************************************* + * + * _PostTerminalSwitch() +@@ -503,6 +540,7 @@ + ac[1] = _aTerminalId[TerminalId]; // Caller made already sure that TerminalId does not exceed our terminal limit + _WriteBlocking(pRing, (const char*)ac, 2u); + } ++#endif + + /********************************************************************* + * +@@ -1672,7 +1710,11 @@ + if (BufferIndex < SEGGER_RTT_MAX_NUM_UP_BUFFERS) { + SEGGER_RTT_LOCK(); + pUp = &pRTTCB->aUp[BufferIndex]; ++#ifdef CUSTOM_RTT ++ if (1) { ++#else + if (BufferIndex) { ++#endif + pUp->sName = sName; + pUp->pBuffer = (char*)pBuffer; + pUp->SizeOfBuffer = BufferSize; +@@ -1724,7 +1766,11 @@ + if (BufferIndex < SEGGER_RTT_MAX_NUM_DOWN_BUFFERS) { + SEGGER_RTT_LOCK(); + pDown = &pRTTCB->aDown[BufferIndex]; ++#ifdef CUSTOM_RTT ++ if (1) { ++#else + if (BufferIndex) { ++#endif + pDown->sName = sName; + pDown->pBuffer = (char*)pBuffer; + pDown->SizeOfBuffer = BufferSize; +@@ -1896,6 +1942,7 @@ + _DoInit(); + } + ++#ifndef CUSTOM_RTT + /********************************************************************* + * + * SEGGER_RTT_SetTerminal +@@ -2036,6 +2083,7 @@ + } + return Status; + } ++#endif // CUSTOM_RTT + + /********************************************************************* + * From 6669062aebb207b195b5a3ef7e06b9a1deb12c36 Mon Sep 17 00:00:00 2001 From: fanoush Date: Thu, 29 Aug 2024 10:20:18 +0200 Subject: [PATCH 12/19] fix broken formatting + more info --- libs/swdcon/README.md | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/libs/swdcon/README.md b/libs/swdcon/README.md index df1abc3448..670076a352 100644 --- a/libs/swdcon/README.md +++ b/libs/swdcon/README.md @@ -35,12 +35,14 @@ If the device is in deep sleep you need to wake it up to notice the input and sw ## OpenOCD stop `rtt stop` - stop polling data, do this also before flashing new version of espruino (server can stay running but rttt stop, setup and start is needed to run after firmware update) + `rtt server stop 2222` - optional + `nrf52.dap dpreg 4 0 ; shutdown` - with cmsis-dap this powers down nrf52 debug hardware (`dap dpreg 4 0`) and disconnects, if you would just close openocd and nrf5x stays in debug mode it drains battery and needs reboot to clear this state ## Known issues -- clipboard paste drops data when buffer is full, this is openocd issue - it only writes first part that fits into buffer and does not retry or wait for data to go out, quick fix in branch here https://github.com/fanoush/openocd/tree/f-rtt-server-write-retry with windows build here https://github.com/fanoush/openocd/releases/tag/latest +- clipboard paste drops data when buffer is full, this is openocd issue - it only writes first part that fits into buffer and does not retry or wait for data to go out, quick fix in branch here https://github.com/fanoush/openocd/tree/f-rtt-server-write-retry with Windows build available here https://github.com/fanoush/openocd/releases/tag/latest - if device is in deep sleep it needs to be woken up to activate the console - press button, press enter in old console, for nrf52 also triggering TIMER1_IRQn interrupt via STIR register write in openocd works `mww 0xE000EF00 9` @@ -48,5 +50,5 @@ If the device is in deep sleep you need to wake it up to notice the input and sw - disable/enable and allocate buffers for SDWCON dynamically at runtime -- our own SWD RTT host code instead of openocd/telnet - espruino device can redirect its serial/usb/bluetooth console to another device via 2 GPIOs +- our own SWD RTT host code instead of openocd/telnet, then any Espruino device could redirect its serial/usb/bluetooth console to SWDCON of another device, which would allow WebIDE to be used easily with target device (so e.g. Bangle.js 2 with dead bluetooth could be used with App Loader over cable) From 793f23ad465a7009bd4c3630f21aaf811a5062fe Mon Sep 17 00:00:00 2001 From: fanoush Date: Thu, 29 Aug 2024 12:53:17 +0200 Subject: [PATCH 13/19] README - EspruinoTools working over TCP port --- libs/swdcon/README.md | 22 ++++++++++++++++++++-- 1 file changed, 20 insertions(+), 2 deletions(-) diff --git a/libs/swdcon/README.md b/libs/swdcon/README.md index 670076a352..60b78bf5e5 100644 --- a/libs/swdcon/README.md +++ b/libs/swdcon/README.md @@ -23,14 +23,32 @@ to openocd interactive console via `telnet localhost 4444` (Or you can use e.g. `rtt server start 2222 0 "\377\375\042\377\373\001"` - newer OpenOCD versions can send initial string to telnet client, this switches it to raw mode but adds some extra initial garbage also to espruino console as telnet client sends some stuff back, more info https://stackoverflow.com/questions/273261/force-telnet-client-into-character-mode -To connect to console use another telnet connection - `telnet localhost 2222` +To connect to console you may use another telnet connection - `telnet localhost 2222` By default telnet is in line mode if there is no rtt server inital string. For espruino console we need raw character mode, type ctrl+],Enter and then type `mode char` to switch to raw mode or you can use netcat https://unix.stackexchange.com/questions/767170/using-telnet-command-without-protocol-negotiation Now press ctrl+c to clear espruino console and/or press enter few times to see some initial errors from telnet garbage -If the device is in deep sleep you need to wake it up to notice the input and switch console - e.g. press button on Bangle watch +If the device is in deep sleep and nothing happens after text entry you need to wake it up to notice the input and switch console - see Known issues below. + +## EspruinoTools + +When the openocd rtt server is running on TCP port you can also use the `espruino` command line tool available from https://github.com/espruino/EspruinoTools like this: + +``` +espruino --ide 8080 --port tcp://127.0.0.1:2222 +``` +Then the interactive console is available and you can also use Web IDE from web browser on http://localhost:8080 +``` +Espruino Command-line Tool 0.1.47 +----------------------------------- + +Connecting to 'tcp://127.0.0.1:2222' +Connected +Web IDE is now available on http://localhost:8080 +> +``` ## OpenOCD stop From 8fbe2cb8485a4521316f57f71edcdf10c4dc5dc0 Mon Sep 17 00:00:00 2001 From: fanoush Date: Mon, 2 Sep 2024 00:53:55 +0200 Subject: [PATCH 14/19] avoid pushing too many characters, check how much is available --- libs/swdcon/jswrap_swdcon.c | 8 +++++--- src/jsdevices.c | 10 ++++++---- src/jsdevices.h | 2 ++ 3 files changed, 13 insertions(+), 7 deletions(-) diff --git a/libs/swdcon/jswrap_swdcon.c b/libs/swdcon/jswrap_swdcon.c index 3ba7bba640..fe1328c21d 100644 --- a/libs/swdcon/jswrap_swdcon.c +++ b/libs/swdcon/jswrap_swdcon.c @@ -242,9 +242,11 @@ bool swdconSend(){ bool swdconRecv() { bool gotChar=false; - char c; - while(SEGGER_RTT_Read(0, &c, 1) > 0){ - jshPushIOCharEvent(EV_SWDCON, c); + char buff[BUFFER_SIZE_DOWN]; + int len, limit=jshGetIOCharEventsFree(); + while(limit > 0 && (len = SEGGER_RTT_Read(0, buff, MIN(limit,sizeof(buff)))) > 0){ + jshPushIOCharEvents(EV_SWDCON, buff, len); + limit -= len; gotChar=true; } if (gotChar) jshHadEvent(); diff --git a/src/jsdevices.c b/src/jsdevices.c index fb459dfaa5..80bbf2ba1d 100644 --- a/src/jsdevices.c +++ b/src/jsdevices.c @@ -590,11 +590,13 @@ int jshGetEventsUsed() { return spaceUsed; } +int jshGetIOCharEventsFree() { + int spaceLeft = IOBUFFERMASK+1-jshGetEventsUsed(); + return spaceLeft*IOEVENT_MAXCHARS-4; // be sensible - leave a little spare +} + bool jshHasEventSpaceForChars(int n) { - int spacesNeeded = 4 + (n/IOEVENT_MAXCHARS); // be sensible - leave a little spare - int spaceUsed = jshGetEventsUsed(); - int spaceLeft = IOBUFFERMASK+1-spaceUsed; - return spaceLeft > spacesNeeded; + return jshGetIOCharEventsFree() > n; } // ---------------------------------------------------------------------------- diff --git a/src/jsdevices.h b/src/jsdevices.h index 61fb5b3e46..799c3a79e3 100644 --- a/src/jsdevices.h +++ b/src/jsdevices.h @@ -208,6 +208,8 @@ int jshGetEventsUsed(); /// Do we have enough space for N characters? bool jshHasEventSpaceForChars(int n); +/// How many characters can we write? +int jshGetIOCharEventsFree(); const char *jshGetDeviceString(IOEventFlags device); IOEventFlags jshFromDeviceString(const char *device); From 317e6429d95129bf2c7a2bee57244ae775eef781 Mon Sep 17 00:00:00 2001 From: fanoush Date: Mon, 2 Sep 2024 00:55:39 +0200 Subject: [PATCH 15/19] try to enable XON/XOFF --- src/jsdevices.c | 7 +++++++ src/jsdevices.h | 6 +++--- 2 files changed, 10 insertions(+), 3 deletions(-) diff --git a/src/jsdevices.c b/src/jsdevices.c index 80bbf2ba1d..bc698e92af 100644 --- a/src/jsdevices.c +++ b/src/jsdevices.c @@ -95,6 +95,10 @@ void jshInitDevices() { assert(EV_USBSERIAL>=EV_SERIAL_DEVICE_STATE_START); jshSerialDeviceStates[TO_SERIAL_DEVICE_STATE(EV_USBSERIAL)] = SDS_FLOW_CONTROL_XON_XOFF; #endif +#ifdef USE_SWDCON + assert(EV_SWDCON>=EV_SERIAL_DEVICE_STATE_START); + jshSerialDeviceStates[TO_SERIAL_DEVICE_STATE(EV_SWDCON)] = SDS_FLOW_CONTROL_XON_XOFF; +#endif #ifdef BLUETOOTH jshSerialDeviceStates[TO_SERIAL_DEVICE_STATE(EV_BLUETOOTH)] = SDS_FLOW_CONTROL_XON_XOFF; #endif @@ -113,6 +117,9 @@ void jshResetDevices() { #ifdef USB if (i==TO_SERIAL_DEVICE_STATE(EV_USBSERIAL)) break; // don't update USB status #endif +#ifdef USE_SWDCON + if (i==TO_SERIAL_DEVICE_STATE(EV_SWDCON)) break; // don't update SWDCON status +#endif #ifdef BLUETOOTH if (i==TO_SERIAL_DEVICE_STATE(EV_BLUETOOTH)) break; // don't update Bluetooth status #endif diff --git a/src/jsdevices.h b/src/jsdevices.h index 799c3a79e3..5cf4fc04dc 100644 --- a/src/jsdevices.h +++ b/src/jsdevices.h @@ -44,14 +44,14 @@ typedef enum { #ifdef USE_TELNET EV_TELNET, #endif -#ifdef USE_SWDCON - EV_SWDCON, /// console over in memory buffer accessible via SWD -#endif #ifdef USE_TERMINAL EV_TERMINAL, // Built-in VT100 terminal #endif EV_SERIAL_DEVICE_STATE_START, // The point at which we start storing device state (jshSerialDevice*) _EV_SERIAL_DEVICE_STATE_START_MINUS_ONE=EV_SERIAL_DEVICE_STATE_START-1, // means that the next enum should==EV_SERIAL_DEVICE_STATE_START +#ifdef USE_SWDCON + EV_SWDCON, /// console over in memory buffer accessible via SWD +#endif #ifdef USB EV_USBSERIAL, ///< USB CDC Serial Data #endif From dbc94a119c38d2993deffd3a6da88394f437e941 Mon Sep 17 00:00:00 2001 From: fanoush Date: Mon, 9 Sep 2024 09:33:00 +0200 Subject: [PATCH 16/19] README - add dapjs, port 9090 is used for RTT --- libs/swdcon/README.md | 57 +++++++++++++++++++++++++++++++------------ 1 file changed, 41 insertions(+), 16 deletions(-) diff --git a/libs/swdcon/README.md b/libs/swdcon/README.md index 60b78bf5e5..54ccbf4175 100644 --- a/libs/swdcon/README.md +++ b/libs/swdcon/README.md @@ -4,10 +4,23 @@ This is Espruino console over [Segger RTT](https://wiki.segger.com/RTT) technolo The console can be used via Segger RTT Viewer (if you use J-Link debugger probe) or it can be also used with OpenOCD with any debugger probe like e.g. cheap CMSIS-DAP dongle. +Another way istead of running OpenOCD is dapjs over WebUSB supported in Chrome browser. + In future the console can be also used with any Espruino device with 2 free GPIOs acting as serial to SWD/RTT bridge. -## OpenOCD start +## dapjs over WebUSB + +There is a project that allows using CMSIS-DAP debug probe directly from web browser https://armmbed.github.io/dapjs/docs/index.html + + You can try customized example here https://fanoush.github.io/dapjs/examples/rtt/web.html + + Best is to enable character mode, then connect to your probe via 'start RTT', then press enter and then click the 'trigger IRQ' button and you should get console output - see also Known issues below. + + Unfortunately only newer CMSIS-DAP probes that support V2 protocol work over WebUSB in browser, older v1 probes that work over HID protocol do not work. If you probe is not working the easiest is to get Raspberry Pico or any other RP2040 board and flash it with debugprobe firmware https://github.com/raspberrypi/debugprobe which does support V2 protocol + +## OpenOCD +OpenOCD gives best compatibility with many debug probes. Attach openocd to device, for nrf52 and cmsis-dap probe it is something like `openocd -d2 -f interface/cmsis-dap.cfg -f target/nrf52.cfg`. Then connect to openocd interactive console via `telnet localhost 4444` (Or you can use e.g. Putty for making Telnet connection) and continue with some OpenOCD commands below: @@ -17,50 +30,62 @@ to openocd interactive console via `telnet localhost 4444` (Or you can use e.g. `rtt start` - should search and find the buffer -`rtt polling_interval 50` - optional, make console I/O faster (try e.g. E.dumpVariables() with default value) +`rtt polling_interval 30` - optional, make console I/O faster (try e.g. E.dumpVariables() with default value) -`rtt server start 2222 0` - start telnet server on port 2222 for channel 0 = SWDCON, use any free port number you wish +`rtt server start 9090 0` - start telnet server on port 9090 for channel 0 = SWDCON, use any free port number you wish, 9090 is typical for RTT channel 0 -`rtt server start 2222 0 "\377\375\042\377\373\001"` - newer OpenOCD versions can send initial string to telnet client, this switches it to raw mode but adds some extra initial garbage also to espruino console as telnet client sends some stuff back, more info https://stackoverflow.com/questions/273261/force-telnet-client-into-character-mode +You can also run all commands directly when starting OpenOCD -To connect to console you may use another telnet connection - `telnet localhost 2222` -By default telnet is in line mode if there is no rtt server inital string. For espruino console we need raw character mode, -type ctrl+],Enter and then type `mode char` to switch to raw mode -or you can use netcat https://unix.stackexchange.com/questions/767170/using-telnet-command-without-protocol-negotiation +`openocd -d2 -f interface/cmsis-dap.cfg -f target/nrf52.cfg -c "adapter speed 8000000" -c "init" -c "rtt setup 0x20000000 262144" -c "rtt start ; rtt server start 9090 0" -c "rtt polling_interval 30"` -Now press ctrl+c to clear espruino console and/or press enter few times to see some initial errors from telnet garbage +Many good probes including RP2040 debugprobe support higher adapter speeds, for nrf52 chips maximum supported is 8MHz, if you have issues skip `-c "adapter speed 8000000"` or go lower to 4 or 2 MHz -If the device is in deep sleep and nothing happens after text entry you need to wake it up to notice the input and switch console - see Known issues below. ## EspruinoTools -When the openocd rtt server is running on TCP port you can also use the `espruino` command line tool available from https://github.com/espruino/EspruinoTools like this: +When the openocd rtt server is running on TCP port you can use the `espruino` command line tool available from https://github.com/espruino/EspruinoTools like this: ``` -espruino --ide 8080 --port tcp://127.0.0.1:2222 +espruino --ide 8080 --port tcp://127.0.0.1:9090 ``` Then the interactive console is available and you can also use Web IDE from web browser on http://localhost:8080 ``` Espruino Command-line Tool 0.1.47 ----------------------------------- -Connecting to 'tcp://127.0.0.1:2222' +Connecting to 'tcp://127.0.0.1:9090' Connected Web IDE is now available on http://localhost:8080 > ``` +Beware that by default device is in deep sleep and nothing happens after first text entry, you need to wake it up to notice the input and switch to RTT console - see Known issues below. + + +## telnet client + +While espruino command line tool is easier, you may also use telnet client directly via `telnet localhost 9090` + +By default telnet is in line mode if there is no rtt server inital string. For espruino console we need raw character mode, +type ctrl+],Enter and then type `mode char` to switch to raw mode +or you can use netcat https://unix.stackexchange.com/questions/767170/using-telnet-command-without-protocol-negotiation + +Now press ctrl+c to clear espruino console and/or press enter few times to see some initial errors from telnet garbage + +`rtt server start 9090 0 "\377\375\042\377\373\001"` - newer OpenOCD versions can send initial string to telnet client, this switches it to raw mode automatically but adds some extra initial garbage also to espruino console as telnet client sends some stuff back, more info https://stackoverflow.com/questions/273261/force-telnet-client-into-character-mode + + ## OpenOCD stop `rtt stop` - stop polling data, do this also before flashing new version of espruino (server can stay running but rttt stop, setup and start is needed to run after firmware update) -`rtt server stop 2222` - optional +`rtt server stop 9090` - optional -`nrf52.dap dpreg 4 0 ; shutdown` - with cmsis-dap this powers down nrf52 debug hardware (`dap dpreg 4 0`) and disconnects, if you would just close openocd and nrf5x stays in debug mode it drains battery and needs reboot to clear this state +`nrf52.dap dpreg 4 0 ; shutdown` - with cmsis-dap this powers down nrf52 debug hardware (`dap dpreg 4 0`) and disconnects, if you would just close/kill openocd and nrf5x stays in debug mode it drains battery and needs reboot to clear this state ## Known issues -- clipboard paste drops data when buffer is full, this is openocd issue - it only writes first part that fits into buffer and does not retry or wait for data to go out, quick fix in branch here https://github.com/fanoush/openocd/tree/f-rtt-server-write-retry with Windows build available here https://github.com/fanoush/openocd/releases/tag/latest +- clipboard paste drops data when buffer is full, this is [openocd issue](https://review.openocd.org/c/openocd/+/8360) - it only writes first part that fits into buffer and does not retry or wait for data to go out, quick fix in branch here https://github.com/fanoush/openocd/tree/f-rtt-server-write-retry with Windows build available here https://github.com/fanoush/openocd/releases - if device is in deep sleep it needs to be woken up to activate the console - press button, press enter in old console, for nrf52 also triggering TIMER1_IRQn interrupt via STIR register write in openocd works `mww 0xE000EF00 9` From 792328f18d85c2c7b1bc730dcc860ab342689490 Mon Sep 17 00:00:00 2001 From: fanoush Date: Tue, 10 Sep 2024 10:23:10 +0200 Subject: [PATCH 17/19] fix README typos --- libs/swdcon/README.md | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/libs/swdcon/README.md b/libs/swdcon/README.md index 54ccbf4175..357ad2f46f 100644 --- a/libs/swdcon/README.md +++ b/libs/swdcon/README.md @@ -4,7 +4,7 @@ This is Espruino console over [Segger RTT](https://wiki.segger.com/RTT) technolo The console can be used via Segger RTT Viewer (if you use J-Link debugger probe) or it can be also used with OpenOCD with any debugger probe like e.g. cheap CMSIS-DAP dongle. -Another way istead of running OpenOCD is dapjs over WebUSB supported in Chrome browser. +Another way instead of running OpenOCD is dapjs over WebUSB supported in Chrome browser. In future the console can be also used with any Espruino device with 2 free GPIOs acting as serial to SWD/RTT bridge. @@ -16,7 +16,7 @@ There is a project that allows using CMSIS-DAP debug probe directly from web bro Best is to enable character mode, then connect to your probe via 'start RTT', then press enter and then click the 'trigger IRQ' button and you should get console output - see also Known issues below. - Unfortunately only newer CMSIS-DAP probes that support V2 protocol work over WebUSB in browser, older v1 probes that work over HID protocol do not work. If you probe is not working the easiest is to get Raspberry Pico or any other RP2040 board and flash it with debugprobe firmware https://github.com/raspberrypi/debugprobe which does support V2 protocol + Unfortunately only newer CMSIS-DAP probes that support V2 protocol work over WebUSB in browser, older v1 probes that work over HID protocol do not work. If your probe is not working the easiest is to get Raspberry Pico or any other RP2040 board and flash it with debugprobe firmware https://github.com/raspberrypi/debugprobe which does support V2 protocol ## OpenOCD @@ -30,7 +30,7 @@ to openocd interactive console via `telnet localhost 4444` (Or you can use e.g. `rtt start` - should search and find the buffer -`rtt polling_interval 30` - optional, make console I/O faster (try e.g. E.dumpVariables() with default value) +`rtt polling_interval 30` - optional, make console I/O faster (try to run e.g. `E.dumpVariables()` with default value) `rtt server start 9090 0` - start telnet server on port 9090 for channel 0 = SWDCON, use any free port number you wish, 9090 is typical for RTT channel 0 @@ -72,7 +72,7 @@ or you can use netcat https://unix.stackexchange.com/questions/767170/using-teln Now press ctrl+c to clear espruino console and/or press enter few times to see some initial errors from telnet garbage -`rtt server start 9090 0 "\377\375\042\377\373\001"` - newer OpenOCD versions can send initial string to telnet client, this switches it to raw mode automatically but adds some extra initial garbage also to espruino console as telnet client sends some stuff back, more info https://stackoverflow.com/questions/273261/force-telnet-client-into-character-mode +`rtt server start 9090 0 "\377\375\042\377\373\001"` - newer OpenOCD versions can send initial string to telnet client, this switches it to raw mode automatically but adds some extra initial garbage also to Espruino console as telnet client sends some stuff back, more info https://stackoverflow.com/questions/273261/force-telnet-client-into-character-mode ## OpenOCD stop @@ -91,7 +91,7 @@ Now press ctrl+c to clear espruino console and/or press enter few times to see s ## TODO -- disable/enable and allocate buffers for SDWCON dynamically at runtime +- disable/enable and allocate buffers for SWDCON dynamically at runtime - our own SWD RTT host code instead of openocd/telnet, then any Espruino device could redirect its serial/usb/bluetooth console to SWDCON of another device, which would allow WebIDE to be used easily with target device (so e.g. Bangle.js 2 with dead bluetooth could be used with App Loader over cable) From 7d2312c4e4d5b72deaa3d34289e9cd1020c1020a Mon Sep 17 00:00:00 2001 From: fanoush Date: Mon, 30 Sep 2024 13:00:19 +0200 Subject: [PATCH 18/19] Update README.md - openocd adapter speed value is in kHz --- libs/swdcon/README.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/libs/swdcon/README.md b/libs/swdcon/README.md index 357ad2f46f..c88b138acd 100644 --- a/libs/swdcon/README.md +++ b/libs/swdcon/README.md @@ -36,9 +36,9 @@ to openocd interactive console via `telnet localhost 4444` (Or you can use e.g. You can also run all commands directly when starting OpenOCD -`openocd -d2 -f interface/cmsis-dap.cfg -f target/nrf52.cfg -c "adapter speed 8000000" -c "init" -c "rtt setup 0x20000000 262144" -c "rtt start ; rtt server start 9090 0" -c "rtt polling_interval 30"` +`openocd -d2 -f interface/cmsis-dap.cfg -f target/nrf52.cfg -c "adapter speed 8000" -c "init" -c "rtt setup 0x20000000 262144" -c "rtt start ; rtt server start 9090 0" -c "rtt polling_interval 30"` -Many good probes including RP2040 debugprobe support higher adapter speeds, for nrf52 chips maximum supported is 8MHz, if you have issues skip `-c "adapter speed 8000000"` or go lower to 4 or 2 MHz +Many good probes including RP2040 debugprobe support higher adapter speeds, for nrf52 chips maximum supported is 8MHz, if you have issues skip `-c "adapter speed 8000"` or go lower to 4 or 2 MHz ## EspruinoTools From b629fab77716faecd78122042dd4771dfc51ab36 Mon Sep 17 00:00:00 2001 From: Gordon Williams Date: Mon, 9 Dec 2024 10:21:16 +0000 Subject: [PATCH 19/19] Update jsdevices.h Move EV_SWDCON location so it doesn't break the Bangle.js emulators which have hard-coded IDs --- src/jsdevices.h | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/jsdevices.h b/src/jsdevices.h index 5cf4fc04dc..f19ad6ae24 100644 --- a/src/jsdevices.h +++ b/src/jsdevices.h @@ -49,15 +49,15 @@ typedef enum { #endif EV_SERIAL_DEVICE_STATE_START, // The point at which we start storing device state (jshSerialDevice*) _EV_SERIAL_DEVICE_STATE_START_MINUS_ONE=EV_SERIAL_DEVICE_STATE_START-1, // means that the next enum should==EV_SERIAL_DEVICE_STATE_START -#ifdef USE_SWDCON - EV_SWDCON, /// console over in memory buffer accessible via SWD -#endif #ifdef USB EV_USBSERIAL, ///< USB CDC Serial Data #endif #ifdef BLUETOOTH EV_BLUETOOTH, ///< Bluetooth LE #endif +#ifdef USE_SWDCON + EV_SWDCON, /// console over in memory buffer accessible via SWD +#endif #if ESPR_USART_COUNT>=1 EV_SERIAL1, // Used for IO for UARTS #endif