+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
77#include "SEGGER_RTT.h"
+
+
+
+
+
+
+
+
+
+
+
88#if SEGGER_RTT_CPU_CACHE_LINE_SIZE
+
89 #ifdef SEGGER_RTT_CB_ALIGN
+
90 #error "Custom SEGGER_RTT_CB_ALIGN() is not supported for SEGGER_RTT_CPU_CACHE_LINE_SIZE != 0"
+
+
92 #ifdef SEGGER_RTT_BUFFER_ALIGN
+
93 #error "Custom SEGGER_RTT_BUFFER_ALIGN() is not supported for SEGGER_RTT_CPU_CACHE_LINE_SIZE != 0"
+
+
95 #ifdef SEGGER_RTT_PUT_CB_SECTION
+
96 #error "Custom SEGGER_RTT_PUT_CB_SECTION() is not supported for SEGGER_RTT_CPU_CACHE_LINE_SIZE != 0"
+
+
98 #ifdef SEGGER_RTT_PUT_BUFFER_SECTION
+
99 #error "Custom SEGGER_RTT_PUT_BUFFER_SECTION() is not supported for SEGGER_RTT_CPU_CACHE_LINE_SIZE != 0"
+
+
101 #ifdef SEGGER_RTT_BUFFER_ALIGNMENT
+
102 #error "Custom SEGGER_RTT_BUFFER_ALIGNMENT is not supported for SEGGER_RTT_CPU_CACHE_LINE_SIZE != 0"
+
+
104 #ifdef SEGGER_RTT_ALIGNMENT
+
105 #error "Custom SEGGER_RTT_ALIGNMENT is not supported for SEGGER_RTT_CPU_CACHE_LINE_SIZE != 0"
+
+
+
+
109#ifndef BUFFER_SIZE_UP
+
110 #define BUFFER_SIZE_UP 1024
+
+
+
113#ifndef BUFFER_SIZE_DOWN
+
114 #define BUFFER_SIZE_DOWN 16
+
+
+
117#ifndef SEGGER_RTT_MAX_NUM_UP_BUFFERS
+
118 #define SEGGER_RTT_MAX_NUM_UP_BUFFERS 2
+
+
+
121#ifndef SEGGER_RTT_MAX_NUM_DOWN_BUFFERS
+
122 #define SEGGER_RTT_MAX_NUM_DOWN_BUFFERS 2
+
+
+
125#ifndef SEGGER_RTT_BUFFER_SECTION
+
126 #if defined(SEGGER_RTT_SECTION)
+
127 #define SEGGER_RTT_BUFFER_SECTION SEGGER_RTT_SECTION
+
+
+
+
131#ifndef SEGGER_RTT_ALIGNMENT
+
132 #define SEGGER_RTT_ALIGNMENT SEGGER_RTT_CPU_CACHE_LINE_SIZE
+
+
+
135#ifndef SEGGER_RTT_BUFFER_ALIGNMENT
+
136 #define SEGGER_RTT_BUFFER_ALIGNMENT SEGGER_RTT_CPU_CACHE_LINE_SIZE
+
+
+
139#ifndef SEGGER_RTT_MODE_DEFAULT
+
140 #define SEGGER_RTT_MODE_DEFAULT SEGGER_RTT_MODE_NO_BLOCK_SKIP
+
+
+
143#ifndef SEGGER_RTT_LOCK
+
144 #define SEGGER_RTT_LOCK()
+
+
+
147#ifndef SEGGER_RTT_UNLOCK
+
148 #define SEGGER_RTT_UNLOCK()
+
+
+
+
152 #define STRLEN(a) strlen((a))
+
+
+
+
156 #define STRCPY(pDest, pSrc) strcpy((pDest), (pSrc))
+
+
+
159#ifndef SEGGER_RTT_MEMCPY_USE_BYTELOOP
+
160 #define SEGGER_RTT_MEMCPY_USE_BYTELOOP 0
+
+
+
163#ifndef SEGGER_RTT_MEMCPY
+
+
165 #define SEGGER_RTT_MEMCPY(pDest, pSrc, NumBytes) MEMCPY((pDest), (pSrc), (NumBytes))
+
+
167 #define SEGGER_RTT_MEMCPY(pDest, pSrc, NumBytes) memcpy((pDest), (pSrc), (NumBytes))
+
+
+
+
+
172 #define MIN(a, b) (((a) < (b)) ? (a) : (b))
+
+
+
+
176 #define MAX(a, b) (((a) > (b)) ? (a) : (b))
+
+
+
+
+
+
+
+
+
185#if (defined __ICCARM__) || (defined __ICCRX__)
+
186 #define RTT_PRAGMA(P) _Pragma(#P)
+
+
+
189#if SEGGER_RTT_ALIGNMENT || SEGGER_RTT_BUFFER_ALIGNMENT
+
190 #if ((defined __GNUC__) || (defined __clang__))
+
191 #define SEGGER_RTT_ALIGN(Var, Alignment) Var __attribute__ ((aligned (Alignment)))
+
192 #elif (defined __ICCARM__) || (defined __ICCRX__)
+
193 #define PRAGMA(A) _Pragma(#A)
+
194#define SEGGER_RTT_ALIGN(Var, Alignment) RTT_PRAGMA(data_alignment=Alignment) \
+
+
196 #elif (defined __CC_ARM)
+
197 #define SEGGER_RTT_ALIGN(Var, Alignment) Var __attribute__ ((aligned (Alignment)))
+
+
199 #error "Alignment not supported for this compiler."
+
+
+
202 #define SEGGER_RTT_ALIGN(Var, Alignment) Var
+
+
+
205#if defined(SEGGER_RTT_SECTION) || defined (SEGGER_RTT_BUFFER_SECTION)
+
206 #if ((defined __GNUC__) || (defined __clang__))
+
207 #define SEGGER_RTT_PUT_SECTION(Var, Section) __attribute__ ((section (Section))) Var
+
208 #elif (defined __ICCARM__) || (defined __ICCRX__)
+
209#define SEGGER_RTT_PUT_SECTION(Var, Section) RTT_PRAGMA(location=Section) \
+
+
211 #elif (defined __CC_ARM)
+
212 #define SEGGER_RTT_PUT_SECTION(Var, Section) __attribute__ ((section (Section), zero_init)) Var
+
+
214 #error "Section placement not supported for this compiler."
+
+
+
217 #define SEGGER_RTT_PUT_SECTION(Var, Section) Var
+
+
+
220#if SEGGER_RTT_ALIGNMENT
+
221 #define SEGGER_RTT_CB_ALIGN(Var) SEGGER_RTT_ALIGN(Var, SEGGER_RTT_ALIGNMENT)
+
+
223 #define SEGGER_RTT_CB_ALIGN(Var) Var
+
+
+
226#if SEGGER_RTT_BUFFER_ALIGNMENT
+
227 #define SEGGER_RTT_BUFFER_ALIGN(Var) SEGGER_RTT_ALIGN(Var, SEGGER_RTT_BUFFER_ALIGNMENT)
+
+
229 #define SEGGER_RTT_BUFFER_ALIGN(Var) Var
+
+
+
+
233#if defined(SEGGER_RTT_SECTION)
+
234 #define SEGGER_RTT_PUT_CB_SECTION(Var) SEGGER_RTT_PUT_SECTION(Var, SEGGER_RTT_SECTION)
+
+
236 #define SEGGER_RTT_PUT_CB_SECTION(Var) Var
+
+
+
239#if defined(SEGGER_RTT_BUFFER_SECTION)
+
240 #define SEGGER_RTT_PUT_BUFFER_SECTION(Var) SEGGER_RTT_PUT_SECTION(Var, SEGGER_RTT_BUFFER_SECTION)
+
+
242 #define SEGGER_RTT_PUT_BUFFER_SECTION(Var) Var
+
+
+
+
+
+
+
+
+
+
252static const unsigned char _aTerminalId[16] = {
'0',
'1',
'2',
'3',
'4',
'5',
'6',
'7',
'8',
'9',
'A',
'B',
'C',
'D',
'E',
'F' };
+
+
+
+
+
+
+
+
+
+
+
+
264#if SEGGER_RTT_CPU_CACHE_LINE_SIZE
+
265 #if ((defined __GNUC__) || (defined __clang__))
+
266 SEGGER_RTT_CB _SEGGER_RTT __attribute__ ((aligned (SEGGER_RTT_CPU_CACHE_LINE_SIZE)));
+
267 static char _acUpBuffer [SEGGER_RTT__ROUND_UP_2_CACHE_LINE_SIZE(BUFFER_SIZE_UP)] __attribute__ ((aligned (SEGGER_RTT_CPU_CACHE_LINE_SIZE)));
+
268 static char _acDownBuffer[SEGGER_RTT__ROUND_UP_2_CACHE_LINE_SIZE(BUFFER_SIZE_DOWN)] __attribute__ ((aligned (SEGGER_RTT_CPU_CACHE_LINE_SIZE)));
+
269 #elif (defined __ICCARM__)
+
270 #pragma data_alignment=SEGGER_RTT_CPU_CACHE_LINE_SIZE
+
+
272 #pragma data_alignment=SEGGER_RTT_CPU_CACHE_LINE_SIZE
+
273 static char _acUpBuffer [SEGGER_RTT__ROUND_UP_2_CACHE_LINE_SIZE(BUFFER_SIZE_UP)];
+
274 #pragma data_alignment=SEGGER_RTT_CPU_CACHE_LINE_SIZE
+
275 static char _acDownBuffer[SEGGER_RTT__ROUND_UP_2_CACHE_LINE_SIZE(BUFFER_SIZE_DOWN)];
+
+
277 #error "Don't know how to place _SEGGER_RTT, _acUpBuffer, _acDownBuffer cache-line aligned"
+
+
+
280 SEGGER_RTT_PUT_CB_SECTION(SEGGER_RTT_CB_ALIGN(
SEGGER_RTT_CB _SEGGER_RTT));
+
281 SEGGER_RTT_PUT_BUFFER_SECTION(SEGGER_RTT_BUFFER_ALIGN(
static char _acUpBuffer [BUFFER_SIZE_UP]));
+
282 SEGGER_RTT_PUT_BUFFER_SECTION(SEGGER_RTT_BUFFER_ALIGN(
static char _acDownBuffer[BUFFER_SIZE_DOWN]));
+
+
+
285static unsigned char _ActiveTerminal;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
307 volatile SEGGER_RTT_CB* pRTTCBInit; \
+
308 pRTTCBInit = (volatile SEGGER_RTT_CB*)((uintptr_t)&_SEGGER_RTT + SEGGER_RTT_UNCACHED_OFF); \
+
309 if (pRTTCBInit->acID[0] != 'S') { \
+
+
+
+
+
314static void _DoInit(
void) {
+
+
316 static const char _aInitStr[] =
"\0\0\0\0\0\0TTR REGGES";
+
+
+
+
+
321 p = (
volatile SEGGER_RTT_CB*)((uintptr_t)&_SEGGER_RTT + SEGGER_RTT_UNCACHED_OFF);
+
+
323 p->MaxNumUpBuffers = SEGGER_RTT_MAX_NUM_UP_BUFFERS;
+
324 p->MaxNumDownBuffers = SEGGER_RTT_MAX_NUM_DOWN_BUFFERS;
+
+
+
+
328 p->aUp[0].sName =
"Terminal";
+
329 p->aUp[0].pBuffer = _acUpBuffer;
+
330 p->aUp[0].SizeOfBuffer = BUFFER_SIZE_UP;
+
331 p->aUp[0].RdOff = 0u;
+
332 p->aUp[0].WrOff = 0u;
+
333 p->aUp[0].Flags = SEGGER_RTT_MODE_DEFAULT;
+
+
+
+
337 p->aDown[0].sName =
"Terminal";
+
338 p->aDown[0].pBuffer = _acDownBuffer;
+
339 p->aDown[0].SizeOfBuffer = BUFFER_SIZE_DOWN;
+
340 p->aDown[0].RdOff = 0u;
+
341 p->aDown[0].WrOff = 0u;
+
342 p->aDown[0].Flags = SEGGER_RTT_MODE_DEFAULT;
+
+
+
+
+
+
+
349 for (i = 0; i <
sizeof(_aInitStr) - 1; ++i) {
+
350 p->acID[i] = _aInitStr[
sizeof(_aInitStr) - 2 - i];
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
374static unsigned _WriteBlocking(
SEGGER_RTT_BUFFER_UP* pRing,
const char* pBuffer,
unsigned NumBytes) {
+
375 unsigned NumBytesToWrite;
+
376 unsigned NumBytesWritten;
+
+
+
+
+
+
+
383 NumBytesWritten = 0u;
+
384 WrOff = pRing->WrOff;
+
+
386 RdOff = pRing->RdOff;
+
+
388 NumBytesToWrite = RdOff - WrOff - 1u;
+
+
390 NumBytesToWrite = pRing->SizeOfBuffer - (WrOff - RdOff + 1u);
+
+
392 NumBytesToWrite = MIN(NumBytesToWrite, (pRing->SizeOfBuffer - WrOff));
+
393 NumBytesToWrite = MIN(NumBytesToWrite, NumBytes);
+
394 pDst = (pRing->pBuffer + WrOff) + SEGGER_RTT_UNCACHED_OFF;
+
395#if SEGGER_RTT_MEMCPY_USE_BYTELOOP
+
396 NumBytesWritten += NumBytesToWrite;
+
397 NumBytes -= NumBytesToWrite;
+
398 WrOff += NumBytesToWrite;
+
399 while (NumBytesToWrite--) {
+
400 *pDst++ = *pBuffer++;
+
+
+
403 SEGGER_RTT_MEMCPY((
void*)pDst, pBuffer, NumBytesToWrite);
+
404 NumBytesWritten += NumBytesToWrite;
+
405 pBuffer += NumBytesToWrite;
+
406 NumBytes -= NumBytesToWrite;
+
407 WrOff += NumBytesToWrite;
+
+
409 if (WrOff == pRing->SizeOfBuffer) {
+
+
+
+
413 pRing->WrOff = WrOff;
+
+
415 return NumBytesWritten;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
437 unsigned NumBytesAtOnce;
+
+
+
+
+
442 WrOff = pRing->WrOff;
+
443 Rem = pRing->SizeOfBuffer - WrOff;
+
444 if (Rem > NumBytes) {
+
+
+
+
448 pDst = (pRing->pBuffer + WrOff) + SEGGER_RTT_UNCACHED_OFF;
+
449#if SEGGER_RTT_MEMCPY_USE_BYTELOOP
+
+
+
+
+
+
455 pRing->WrOff = WrOff;
+
+
457 SEGGER_RTT_MEMCPY((
void*)pDst, pData, NumBytes);
+
+
459 pRing->WrOff = WrOff + NumBytes;
+
+
+
+
+
+
465#if SEGGER_RTT_MEMCPY_USE_BYTELOOP
+
466 pDst = (pRing->pBuffer + WrOff) + SEGGER_RTT_UNCACHED_OFF;
+
467 NumBytesAtOnce = Rem;
+
468 while (NumBytesAtOnce--) {
+
+
+
471 pDst = pRing->pBuffer + SEGGER_RTT_UNCACHED_OFF;
+
472 NumBytesAtOnce = NumBytes - Rem;
+
473 while (NumBytesAtOnce--) {
+
+
+
+
477 pRing->WrOff = NumBytes - Rem;
+
+
479 NumBytesAtOnce = Rem;
+
480 pDst = (pRing->pBuffer + WrOff) + SEGGER_RTT_UNCACHED_OFF;
+
481 SEGGER_RTT_MEMCPY((
void*)pDst, pData, NumBytesAtOnce);
+
482 NumBytesAtOnce = NumBytes - Rem;
+
483 pDst = pRing->pBuffer + SEGGER_RTT_UNCACHED_OFF;
+
484 SEGGER_RTT_MEMCPY((
void*)pDst, pData + Rem, NumBytesAtOnce);
+
+
486 pRing->WrOff = NumBytesAtOnce;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
508 ac[1] = _aTerminalId[TerminalId];
+
509 _WriteBlocking(pRing, (
const char*)ac, 2u);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
534 RdOff = pRing->RdOff;
+
535 WrOff = pRing->WrOff;
+
536 if (RdOff <= WrOff) {
+
537 r = pRing->SizeOfBuffer - 1u - WrOff + RdOff;
+
+
539 r = RdOff - WrOff - 1u;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
573unsigned SEGGER_RTT_ReadUpBufferNoLock(
unsigned BufferIndex,
void* pData,
unsigned BufferSize) {
+
574 unsigned NumBytesRem;
+
575 unsigned NumBytesRead;
+
+
+
578 unsigned char* pBuffer;
+
+
+
+
+
583 pRing = (
SEGGER_RTT_BUFFER_UP*)((uintptr_t)&_SEGGER_RTT.aUp[BufferIndex] + SEGGER_RTT_UNCACHED_OFF);
+
584 pBuffer = (
unsigned char*)pData;
+
585 RdOff = pRing->RdOff;
+
586 WrOff = pRing->WrOff;
+
+
+
+
+
+
592 NumBytesRem = pRing->SizeOfBuffer - RdOff;
+
593 NumBytesRem = MIN(NumBytesRem, BufferSize);
+
594 pSrc = (pRing->pBuffer + RdOff) + SEGGER_RTT_UNCACHED_OFF;
+
595#if SEGGER_RTT_MEMCPY_USE_BYTELOOP
+
596 NumBytesRead += NumBytesRem;
+
597 BufferSize -= NumBytesRem;
+
598 RdOff += NumBytesRem;
+
599 while (NumBytesRem--) {
+
600 *pBuffer++ = *pSrc++;
+
+
+
603 SEGGER_RTT_MEMCPY(pBuffer, (
void*)pSrc, NumBytesRem);
+
604 NumBytesRead += NumBytesRem;
+
605 pBuffer += NumBytesRem;
+
606 BufferSize -= NumBytesRem;
+
607 RdOff += NumBytesRem;
+
+
+
+
+
612 if (RdOff == pRing->SizeOfBuffer) {
+
+
+
+
+
+
+
619 NumBytesRem = WrOff - RdOff;
+
620 NumBytesRem = MIN(NumBytesRem, BufferSize);
+
621 if (NumBytesRem > 0u) {
+
622 pSrc = (pRing->pBuffer + RdOff) + SEGGER_RTT_UNCACHED_OFF;
+
623#if SEGGER_RTT_MEMCPY_USE_BYTELOOP
+
624 NumBytesRead += NumBytesRem;
+
625 BufferSize -= NumBytesRem;
+
626 RdOff += NumBytesRem;
+
627 while (NumBytesRem--) {
+
628 *pBuffer++ = *pSrc++;
+
+
+
631 SEGGER_RTT_MEMCPY(pBuffer, (
void*)pSrc, NumBytesRem);
+
632 NumBytesRead += NumBytesRem;
+
633 pBuffer += NumBytesRem;
+
634 BufferSize -= NumBytesRem;
+
635 RdOff += NumBytesRem;
+
+
+
+
+
+
+
642 pRing->RdOff = RdOff;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
665unsigned SEGGER_RTT_ReadNoLock(
unsigned BufferIndex,
void* pData,
unsigned BufferSize) {
+
666 unsigned NumBytesRem;
+
667 unsigned NumBytesRead;
+
+
+
670 unsigned char* pBuffer;
+
+
+
+
+
+
676 pBuffer = (
unsigned char*)pData;
+
677 RdOff = pRing->RdOff;
+
678 WrOff = pRing->WrOff;
+
+
+
+
+
+
684 NumBytesRem = pRing->SizeOfBuffer - RdOff;
+
685 NumBytesRem = MIN(NumBytesRem, BufferSize);
+
686 pSrc = (pRing->pBuffer + RdOff) + SEGGER_RTT_UNCACHED_OFF;
+
687#if SEGGER_RTT_MEMCPY_USE_BYTELOOP
+
688 NumBytesRead += NumBytesRem;
+
689 BufferSize -= NumBytesRem;
+
690 RdOff += NumBytesRem;
+
691 while (NumBytesRem--) {
+
692 *pBuffer++ = *pSrc++;
+
+
+
695 SEGGER_RTT_MEMCPY(pBuffer, (
void*)pSrc, NumBytesRem);
+
696 NumBytesRead += NumBytesRem;
+
697 pBuffer += NumBytesRem;
+
698 BufferSize -= NumBytesRem;
+
699 RdOff += NumBytesRem;
+
+
+
+
+
704 if (RdOff == pRing->SizeOfBuffer) {
+
+
+
+
+
+
+
711 NumBytesRem = WrOff - RdOff;
+
712 NumBytesRem = MIN(NumBytesRem, BufferSize);
+
713 if (NumBytesRem > 0u) {
+
714 pSrc = (pRing->pBuffer + RdOff) + SEGGER_RTT_UNCACHED_OFF;
+
715#if SEGGER_RTT_MEMCPY_USE_BYTELOOP
+
716 NumBytesRead += NumBytesRem;
+
717 BufferSize -= NumBytesRem;
+
718 RdOff += NumBytesRem;
+
719 while (NumBytesRem--) {
+
720 *pBuffer++ = *pSrc++;
+
+
+
723 SEGGER_RTT_MEMCPY(pBuffer, (
void*)pSrc, NumBytesRem);
+
724 NumBytesRead += NumBytesRem;
+
725 pBuffer += NumBytesRem;
+
726 BufferSize -= NumBytesRem;
+
727 RdOff += NumBytesRem;
+
+
+
+
731 pRing->RdOff = RdOff;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
762unsigned SEGGER_RTT_ReadUpBuffer(
unsigned BufferIndex,
void* pBuffer,
unsigned BufferSize) {
+
763 unsigned NumBytesRead;
+
+
+
+
+
+
769 NumBytesRead = SEGGER_RTT_ReadUpBufferNoLock(BufferIndex, pBuffer, BufferSize);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
794unsigned SEGGER_RTT_Read(
unsigned BufferIndex,
void* pBuffer,
unsigned BufferSize) {
+
795 unsigned NumBytesRead;
+
+
+
+
+
+
801 NumBytesRead = SEGGER_RTT_ReadNoLock(BufferIndex, pBuffer, BufferSize);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
833void SEGGER_RTT_WriteWithOverwriteNoLock(
unsigned BufferIndex,
const void* pBuffer,
unsigned NumBytes) {
+
+
+
+
+
+
+
+
841 pData = (
const char *)pBuffer;
+
842 pRing = (
SEGGER_RTT_BUFFER_UP*)((uintptr_t)&_SEGGER_RTT.aUp[BufferIndex] + SEGGER_RTT_UNCACHED_OFF);
+
+
+
+
846 if (pRing->WrOff == pRing->RdOff) {
+
847 Avail = pRing->SizeOfBuffer - 1u;
+
848 }
else if ( pRing->WrOff < pRing->RdOff) {
+
849 Avail = pRing->RdOff - pRing->WrOff - 1u;
+
+
851 Avail = pRing->RdOff - pRing->WrOff - 1u + pRing->SizeOfBuffer;
+
+
853 if (NumBytes > Avail) {
+
854 pRing->RdOff += (NumBytes - Avail);
+
855 while (pRing->RdOff >= pRing->SizeOfBuffer) {
+
856 pRing->RdOff -= pRing->SizeOfBuffer;
+
+
+
+
+
+
862 Avail = pRing->SizeOfBuffer - pRing->WrOff;
+
+
864 if (Avail > NumBytes) {
+
+
+
+
868 pDst = (pRing->pBuffer + pRing->WrOff) + SEGGER_RTT_UNCACHED_OFF;
+
869#if SEGGER_RTT_MEMCPY_USE_BYTELOOP
+
+
+
+
+
+
875 pRing->WrOff += Avail;
+
+
877 SEGGER_RTT_MEMCPY((
void*)pDst, pData, NumBytes);
+
+
879 pRing->WrOff += NumBytes;
+
+
+
+
+
+
+
886 pDst = (pRing->pBuffer + pRing->WrOff) + SEGGER_RTT_UNCACHED_OFF;
+
887#if SEGGER_RTT_MEMCPY_USE_BYTELOOP
+
+
+
+
+
+
+
+
895 SEGGER_RTT_MEMCPY((
void*)pDst, pData, Avail);
+
+
+
+
+
+
901 Avail = (pRing->SizeOfBuffer - 1);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
933#if (RTT_USE_ASM == 0)
+
934unsigned SEGGER_RTT_WriteSkipNoLock(
unsigned BufferIndex,
const void* pBuffer,
unsigned NumBytes) {
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
952 pData = (
const char *)pBuffer;
+
953 pRing = (
SEGGER_RTT_BUFFER_UP*)((uintptr_t)&_SEGGER_RTT.aUp[BufferIndex] + SEGGER_RTT_UNCACHED_OFF);
+
954 RdOff = pRing->RdOff;
+
955 WrOff = pRing->WrOff;
+
956 pDst = (pRing->pBuffer + WrOff) + SEGGER_RTT_UNCACHED_OFF;
+
957 if (RdOff <= WrOff) {
+
958 Avail = pRing->SizeOfBuffer - WrOff - 1u;
+
959 if (Avail >= NumBytes) {
+
960 memcpy((
void*)pDst, pData, NumBytes);
+
+
962 pRing->WrOff = WrOff + NumBytes;
+
+
+
+
966 if (Avail >= NumBytes) {
+
967 Rem = pRing->SizeOfBuffer - WrOff;
+
968 memcpy((
void*)pDst, pData, Rem);
+
+
+
+
+
+
+
+
+
977 pDst = pRing->pBuffer + SEGGER_RTT_UNCACHED_OFF;
+
978 memcpy((
void*)pDst, pData + Rem, NumBytes);
+
+
+
981 pRing->WrOff = NumBytes;
+
+
+
+
985 Avail = RdOff - WrOff - 1u;
+
986 if (Avail >= NumBytes) {
+
987 memcpy((
void*)pDst, pData, NumBytes);
+
+
989 pRing->WrOff = WrOff + NumBytes;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
1025unsigned SEGGER_RTT_WriteDownBufferNoLock(
unsigned BufferIndex,
const void* pBuffer,
unsigned NumBytes) {
+
+
+
+
+
+
+
+
+
1034 pData = (
const char *)pBuffer;
+
1035 pRing = (
SEGGER_RTT_BUFFER_UP*)((uintptr_t)&_SEGGER_RTT.aDown[BufferIndex] + SEGGER_RTT_UNCACHED_OFF);
+
+
+
+
1039 switch (pRing->Flags) {
+
1040 case SEGGER_RTT_MODE_NO_BLOCK_SKIP:
+
+
+
+
+
1045 Avail = _GetAvailWriteSpace(pRing);
+
1046 if (Avail < NumBytes) {
+
+
+
+
1050 _WriteNoCheck(pRing, pData, NumBytes);
+
+
+
1053 case SEGGER_RTT_MODE_NO_BLOCK_TRIM:
+
+
+
+
1057 Avail = _GetAvailWriteSpace(pRing);
+
1058 Status = Avail < NumBytes ? Avail : NumBytes;
+
1059 _WriteNoCheck(pRing, pData, Status);
+
+
1061 case SEGGER_RTT_MODE_BLOCK_IF_FIFO_FULL:
+
+
+
+
1065 Status = _WriteBlocking(pRing, pData, NumBytes);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
1100unsigned SEGGER_RTT_WriteNoLock(
unsigned BufferIndex,
const void* pBuffer,
unsigned NumBytes) {
+
+
+
+
+
+
+
+
1108 pData = (
const char *)pBuffer;
+
1109 pRing = (
SEGGER_RTT_BUFFER_UP*)((uintptr_t)&_SEGGER_RTT.aUp[BufferIndex] + SEGGER_RTT_UNCACHED_OFF);
+
+
+
+
1113 switch (pRing->Flags) {
+
1114 case SEGGER_RTT_MODE_NO_BLOCK_SKIP:
+
+
+
+
+
1119 Avail = _GetAvailWriteSpace(pRing);
+
1120 if (Avail < NumBytes) {
+
+
+
+
1124 _WriteNoCheck(pRing, pData, NumBytes);
+
+
+
1127 case SEGGER_RTT_MODE_NO_BLOCK_TRIM:
+
+
+
+
1131 Avail = _GetAvailWriteSpace(pRing);
+
1132 Status = Avail < NumBytes ? Avail : NumBytes;
+
1133 _WriteNoCheck(pRing, pData, Status);
+
+
1135 case SEGGER_RTT_MODE_BLOCK_IF_FIFO_FULL:
+
+
+
+
1139 Status = _WriteBlocking(pRing, pData, NumBytes);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
1176unsigned SEGGER_RTT_WriteDownBuffer(
unsigned BufferIndex,
const void* pBuffer,
unsigned NumBytes) {
+
+
+
+
+
1181 Status = SEGGER_RTT_WriteDownBufferNoLock(BufferIndex, pBuffer, NumBytes);
+
1182 SEGGER_RTT_UNLOCK();
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
1205unsigned SEGGER_RTT_Write(
unsigned BufferIndex,
const void* pBuffer,
unsigned NumBytes) {
+
+
+
+
+
1210 Status = SEGGER_RTT_WriteNoLock(BufferIndex, pBuffer, NumBytes);
+
1211 SEGGER_RTT_UNLOCK();
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
1235unsigned SEGGER_RTT_WriteString(
unsigned BufferIndex,
const char* s) {
+
+
+
+
1239 return SEGGER_RTT_Write(BufferIndex, s, Len);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
1265unsigned SEGGER_RTT_PutCharSkipNoLock(
unsigned BufferIndex,
char c) {
+
+
+
+
1269 volatile char* pDst;
+
+
+
+
1273 pRing = (
SEGGER_RTT_BUFFER_UP*)((uintptr_t)&_SEGGER_RTT.aUp[BufferIndex] + SEGGER_RTT_UNCACHED_OFF);
+
+
+
+
1277 WrOff = pRing->WrOff + 1;
+
1278 if (WrOff == pRing->SizeOfBuffer) {
+
+
+
+
+
+
1284 if (WrOff != pRing->RdOff) {
+
1285 pDst = (pRing->pBuffer + pRing->WrOff) + SEGGER_RTT_UNCACHED_OFF;
+
+
+
1288 pRing->WrOff = WrOff;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
1315unsigned SEGGER_RTT_PutCharSkip(
unsigned BufferIndex,
char c) {
+
+
+
+
1319 volatile char* pDst;
+
+
+
+
+
+
+
+
+
1328 pRing = (
SEGGER_RTT_BUFFER_UP*)((uintptr_t)&_SEGGER_RTT.aUp[BufferIndex] + SEGGER_RTT_UNCACHED_OFF);
+
+
+
+
1332 WrOff = pRing->WrOff + 1;
+
1333 if (WrOff == pRing->SizeOfBuffer) {
+
+
+
+
+
+
1339 if (WrOff != pRing->RdOff) {
+
1340 pDst = (pRing->pBuffer + pRing->WrOff) + SEGGER_RTT_UNCACHED_OFF;
+
+
+
1343 pRing->WrOff = WrOff;
+
+
+
+
+
+
+
+
1351 SEGGER_RTT_UNLOCK();
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
1374unsigned SEGGER_RTT_PutChar(
unsigned BufferIndex,
char c) {
+
+
+
+
1378 volatile char* pDst;
+
+
+
+
+
+
+
+
+
1387 pRing = (
SEGGER_RTT_BUFFER_UP*)((uintptr_t)&_SEGGER_RTT.aUp[BufferIndex] + SEGGER_RTT_UNCACHED_OFF);
+
+
+
+
1391 WrOff = pRing->WrOff + 1;
+
1392 if (WrOff == pRing->SizeOfBuffer) {
+
+
+
+
+
+
1398 if (pRing->Flags == SEGGER_RTT_MODE_BLOCK_IF_FIFO_FULL) {
+
1399 while (WrOff == pRing->RdOff) {
+
+
+
+
+
+
+
1406 if (WrOff != pRing->RdOff) {
+
1407 pDst = (pRing->pBuffer + pRing->WrOff) + SEGGER_RTT_UNCACHED_OFF;
+
+
+
1410 pRing->WrOff = WrOff;
+
+
+
+
+
+
+
+
1418 SEGGER_RTT_UNLOCK();
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
1437int SEGGER_RTT_GetKey(
void) {
+
+
+
+
1441 r = (int)SEGGER_RTT_Read(0u, &c, 1u);
+
+
1443 r = (int)(
unsigned char)c;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
1465int SEGGER_RTT_WaitKey(
void) {
+
+
+
+
1469 r = SEGGER_RTT_GetKey();
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
1488int SEGGER_RTT_HasKey(
void) {
+
+
+
+
+
+
+
1495 RdOff = pRing->RdOff;
+
1496 if (RdOff != pRing->WrOff) {
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
1516unsigned SEGGER_RTT_HasData(
unsigned BufferIndex) {
+
+
+
+
+
+
1522 return v - pRing->RdOff;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
1537unsigned SEGGER_RTT_HasDataUp(
unsigned BufferIndex) {
+
+
+
+
1541 pRing = (
SEGGER_RTT_BUFFER_UP*)((uintptr_t)&_SEGGER_RTT.aUp[BufferIndex] + SEGGER_RTT_UNCACHED_OFF);
+
+
1543 return pRing->WrOff - v;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
1566int SEGGER_RTT_AllocDownBuffer(
const char* sName,
void* pBuffer,
unsigned BufferSize,
unsigned Flags) {
+
+
+
+
+
+
1572 pRTTCB = (
volatile SEGGER_RTT_CB*)((uintptr_t)&_SEGGER_RTT + SEGGER_RTT_UNCACHED_OFF);
+
+
+
1575 if (pRTTCB->aDown[BufferIndex].pBuffer == NULL) {
+
+
+
+
1579 }
while (BufferIndex < pRTTCB->MaxNumDownBuffers);
+
1580 if (BufferIndex < pRTTCB->MaxNumDownBuffers) {
+
1581 pRTTCB->aDown[BufferIndex].sName = sName;
+
1582 pRTTCB->aDown[BufferIndex].pBuffer = (
char*)pBuffer;
+
1583 pRTTCB->aDown[BufferIndex].SizeOfBuffer = BufferSize;
+
1584 pRTTCB->aDown[BufferIndex].RdOff = 0u;
+
1585 pRTTCB->aDown[BufferIndex].WrOff = 0u;
+
1586 pRTTCB->aDown[BufferIndex].Flags = Flags;
+
+
+
+
+
1591 SEGGER_RTT_UNLOCK();
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
1615int SEGGER_RTT_AllocUpBuffer(
const char* sName,
void* pBuffer,
unsigned BufferSize,
unsigned Flags) {
+
+
+
+
+
+
1621 pRTTCB = (
volatile SEGGER_RTT_CB*)((uintptr_t)&_SEGGER_RTT + SEGGER_RTT_UNCACHED_OFF);
+
+
+
1624 if (pRTTCB->aUp[BufferIndex].pBuffer == NULL) {
+
+
+
+
1628 }
while (BufferIndex < pRTTCB->MaxNumUpBuffers);
+
1629 if (BufferIndex < pRTTCB->MaxNumUpBuffers) {
+
1630 pRTTCB->aUp[BufferIndex].sName = sName;
+
1631 pRTTCB->aUp[BufferIndex].pBuffer = (
char*)pBuffer;
+
1632 pRTTCB->aUp[BufferIndex].SizeOfBuffer = BufferSize;
+
1633 pRTTCB->aUp[BufferIndex].RdOff = 0u;
+
1634 pRTTCB->aUp[BufferIndex].WrOff = 0u;
+
1635 pRTTCB->aUp[BufferIndex].Flags = Flags;
+
+
+
+
+
1640 SEGGER_RTT_UNLOCK();
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
1670int SEGGER_RTT_ConfigUpBuffer(
unsigned BufferIndex,
const char* sName,
void* pBuffer,
unsigned BufferSize,
unsigned Flags) {
+
+
+
+
+
+
1676 pRTTCB = (
volatile SEGGER_RTT_CB*)((uintptr_t)&_SEGGER_RTT + SEGGER_RTT_UNCACHED_OFF);
+
1677 if (BufferIndex < SEGGER_RTT_MAX_NUM_UP_BUFFERS) {
+
+
1679 pUp = &pRTTCB->aUp[BufferIndex];
+
+
+
1682 pUp->pBuffer = (
char*)pBuffer;
+
1683 pUp->SizeOfBuffer = BufferSize;
+
+
+
+
+
1688 SEGGER_RTT_UNLOCK();
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
1722int SEGGER_RTT_ConfigDownBuffer(
unsigned BufferIndex,
const char* sName,
void* pBuffer,
unsigned BufferSize,
unsigned Flags) {
+
+
+
+
+
+
1728 pRTTCB = (
volatile SEGGER_RTT_CB*)((uintptr_t)&_SEGGER_RTT + SEGGER_RTT_UNCACHED_OFF);
+
1729 if (BufferIndex < SEGGER_RTT_MAX_NUM_DOWN_BUFFERS) {
+
+
1731 pDown = &pRTTCB->aDown[BufferIndex];
+
+
1733 pDown->sName = sName;
+
1734 pDown->pBuffer = (
char*)pBuffer;
+
1735 pDown->SizeOfBuffer = BufferSize;
+
+
+
+
1739 pDown->Flags = Flags;
+
+
1741 SEGGER_RTT_UNLOCK();
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
1765int SEGGER_RTT_SetNameUpBuffer(
unsigned BufferIndex,
const char* sName) {
+
+
+
+
+
+
1771 pRTTCB = (
volatile SEGGER_RTT_CB*)((uintptr_t)&_SEGGER_RTT + SEGGER_RTT_UNCACHED_OFF);
+
1772 if (BufferIndex < SEGGER_RTT_MAX_NUM_UP_BUFFERS) {
+
+
1774 pUp = &pRTTCB->aUp[BufferIndex];
+
+
1776 SEGGER_RTT_UNLOCK();
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
1800int SEGGER_RTT_SetNameDownBuffer(
unsigned BufferIndex,
const char* sName) {
+
+
+
+
+
+
1806 pRTTCB = (
volatile SEGGER_RTT_CB*)((uintptr_t)&_SEGGER_RTT + SEGGER_RTT_UNCACHED_OFF);
+
1807 if (BufferIndex < SEGGER_RTT_MAX_NUM_DOWN_BUFFERS) {
+
+
1809 pDown = &pRTTCB->aDown[BufferIndex];
+
1810 pDown->sName = sName;
+
1811 SEGGER_RTT_UNLOCK();
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
1836int SEGGER_RTT_SetFlagsUpBuffer(
unsigned BufferIndex,
unsigned Flags) {
+
+
+
+
+
+
1842 pRTTCB = (
volatile SEGGER_RTT_CB*)((uintptr_t)&_SEGGER_RTT + SEGGER_RTT_UNCACHED_OFF);
+
1843 if (BufferIndex < SEGGER_RTT_MAX_NUM_UP_BUFFERS) {
+
+
1845 pUp = &pRTTCB->aUp[BufferIndex];
+
+
1847 SEGGER_RTT_UNLOCK();
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
1872int SEGGER_RTT_SetFlagsDownBuffer(
unsigned BufferIndex,
unsigned Flags) {
+
+
+
+
+
+
1878 pRTTCB = (
volatile SEGGER_RTT_CB*)((uintptr_t)&_SEGGER_RTT + SEGGER_RTT_UNCACHED_OFF);
+
1879 if (BufferIndex < SEGGER_RTT_MAX_NUM_DOWN_BUFFERS) {
+
+
1881 pDown = &pRTTCB->aDown[BufferIndex];
+
1882 pDown->Flags = Flags;
+
1883 SEGGER_RTT_UNLOCK();
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
1900void SEGGER_RTT_Init (
void) {
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
1921int SEGGER_RTT_SetTerminal (
unsigned char TerminalId) {
+
1922 unsigned char ac[2];
+
+
+
+
+
+
+
+
1930 if (TerminalId <
sizeof(_aTerminalId)) {
+
1931 ac[1] = _aTerminalId[TerminalId];
+
+
+
1934 if ((pRing->Flags & SEGGER_RTT_MODE_MASK) == SEGGER_RTT_MODE_BLOCK_IF_FIFO_FULL) {
+
1935 _ActiveTerminal = TerminalId;
+
1936 _WriteBlocking(pRing, (
const char*)ac, 2u);
+
+
1938 Avail = _GetAvailWriteSpace(pRing);
+
+
1940 _ActiveTerminal = TerminalId;
+
1941 _WriteNoCheck(pRing, (
const char*)ac, 2u);
+
+
+
+
+
1946 SEGGER_RTT_UNLOCK();
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
1970int SEGGER_RTT_TerminalOut (
unsigned char TerminalId,
const char* s) {
+
+
+
+
+
+
+
+
+
+
1980 if (TerminalId < (
char)
sizeof(_aTerminalId)) {
+
+
+
+
+
+
+
+
+
1989 FragLen = STRLEN(s);
+
+
+
+
+
1994 Avail = _GetAvailWriteSpace(pRing);
+
1995 switch (pRing->Flags & SEGGER_RTT_MODE_MASK) {
+
1996 case SEGGER_RTT_MODE_NO_BLOCK_SKIP:
+
+
+
+
+
2001 if (Avail < (FragLen + 4u)) {
+
+
+
2004 _PostTerminalSwitch(pRing, TerminalId);
+
2005 Status = (int)_WriteBlocking(pRing, s, FragLen);
+
2006 _PostTerminalSwitch(pRing, _ActiveTerminal);
+
+
+
2009 case SEGGER_RTT_MODE_NO_BLOCK_TRIM:
+
+
+
+
+
+
+
+
+
2018 _PostTerminalSwitch(pRing, TerminalId);
+
2019 Status = (int)_WriteBlocking(pRing, s, (FragLen < (Avail - 4u)) ? FragLen : (Avail - 4u));
+
2020 _PostTerminalSwitch(pRing, _ActiveTerminal);
+
+
+
2023 case SEGGER_RTT_MODE_BLOCK_IF_FIFO_FULL:
+
+
+
+
2027 _PostTerminalSwitch(pRing, TerminalId);
+
2028 Status = (int)_WriteBlocking(pRing, s, FragLen);
+
2029 _PostTerminalSwitch(pRing, _ActiveTerminal);
+
+
+
+
+
+
+
+
+
2038 SEGGER_RTT_UNLOCK();
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
2058unsigned SEGGER_RTT_GetAvailWriteSpace (
unsigned BufferIndex) {
+
+
+
2061 pRing = (
SEGGER_RTT_BUFFER_UP*)((uintptr_t)&_SEGGER_RTT.aUp[BufferIndex] + SEGGER_RTT_UNCACHED_OFF);
+
2062 return _GetAvailWriteSpace(pRing);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
2079unsigned SEGGER_RTT_GetBytesInBuffer(
unsigned BufferIndex) {
+
+
+
+
+
+
+
+
+
2088 pRTTCB = (
volatile SEGGER_RTT_CB*)((uintptr_t)&_SEGGER_RTT + SEGGER_RTT_UNCACHED_OFF);
+
2089 RdOff = pRTTCB->aUp[BufferIndex].RdOff;
+
2090 WrOff = pRTTCB->aUp[BufferIndex].WrOff;
+
2091 if (RdOff <= WrOff) {
+
+
+
2094 r = pRTTCB->aUp[BufferIndex].SizeOfBuffer - (WrOff - RdOff);
+
+
+
+
+
+
+
+
+
1.14.0
+ 
