/********************************************************************* * * _sys_write * * Function description: * Writes the data to an open handle. * Currently this function only outputs data to the console * * Parameters: * hFile - Handle to a file opened via _sys_open * pBuffer - Pointer to the data that shall be written * NumBytes - Number of bytes to write * Mode - The Mode that shall be used * * Return value: * Number of bytes *not* written to the file/device * */ int _sys_write(FILEHANDLE hFile, const unsigned char * pBuffer, unsigned NumBytes, int Mode) { int r = 0; (void)Mode; if (hFile == STDOUT) { return NumBytes - SEGGER_RTT_Write(0, (const char*)pBuffer, NumBytes); } return r; }
/* ** =================================================================== ** Method : RTT1_SendChar (component SeggerRTT) ** Description : ** Sends a character to channel 0. ** Parameters : ** NAME - DESCRIPTION ** ch - Character to send ** Returns : ** --- - Error code. ERR_OK if character has been ** sent, ERR_TXFULL otherwise. ** =================================================================== */ uint8_t RTT1_SendChar(uint8_t ch) { int res; res = SEGGER_RTT_Write(0, (const char*)&ch, 1); if (res!=1) { return ERR_TXFULL; /* character not sent? */ } return ERR_OK; }
/********************************************************************* * * main */ void main(void) { SEGGER_RTT_WriteString(0, "SEGGER Real-Time-Terminal Sample\r\n"); SEGGER_RTT_ConfigUpBuffer(0, NULL, NULL, 0, SEGGER_RTT_MODE_NO_BLOCK_SKIP); do { r = SEGGER_RTT_WaitKey(); SEGGER_RTT_Write(0, &r, 1); r++; } while (1); }
//Overwrite _write so 'printf''s get pushed over the uart int _write(int fd, char *ptr, int len) { #ifdef FRAMEWORK_LOG_OUTPUT_ON_RTT SEGGER_RTT_Write(0, ptr, len); #else console_print_bytes((uint8_t*)ptr, len); #endif return len; }
/********************************************************************* * * SEGGER_RTT_TerminalOut * * Function description * Writes a string to the given terminal * without changing the terminal for channel 0. * */ int32_t SEGGER_RTT_TerminalOut (char TerminalId, const char* s) { char ac[2]; int32_t r; ac[0] = 0xFF; if (TerminalId < 10) { ac[1] = '0' + TerminalId; } else if (TerminalId < 16) { ac[1] = 'A' + (TerminalId - 0x0A); } else { return -1; // RTT only supports up to 16 virtual terminals. } SEGGER_RTT_Write(0, ac, 2); r = SEGGER_RTT_WriteString(0, s); if (TerminalId < 10) { ac[1] = '0' + _ActiveTerminal; } else if (TerminalId < 16) { ac[1] = 'A' + (_ActiveTerminal - 0x0A); } SEGGER_RTT_Write(0, ac, 2); return r; }
/********************************************************************* * * SEGGER_RTT_SetTerminal * * Function description * Sets the terminal to be used for output on channel 0. * */ void SEGGER_RTT_SetTerminal (char TerminalId) { char ac[2]; ac[0] = 0xFF; if (TerminalId < 10) { ac[1] = '0' + TerminalId; } else if (TerminalId < 16) { ac[1] = 'A' + (TerminalId - 0x0A); } else { return; // RTT only supports up to 16 virtual terminals. } _ActiveTerminal = TerminalId; SEGGER_RTT_Write(0, ac, 2); }
/********************************************************************* * * _StoreChar */ static void _StoreChar(SEGGER_RTT_PRINTF_DESC * p, char c) { unsigned Cnt; Cnt = p->Cnt; if ((Cnt + 1u) <= p->BufferSize) { *(p->pBuffer + Cnt) = c; p->Cnt = Cnt + 1u; p->ReturnValue++; } // // Write part of string, when the buffer is full // if (p->Cnt == p->BufferSize) { if (SEGGER_RTT_Write(p->RTTBufferIndex, p->pBuffer, p->Cnt) != p->Cnt) { p->ReturnValue = -1; } else { p->Cnt = 0u; } } }
/********************************************************************* * * 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) If there is not enough space in the "Up"-buffer, depending on configuration, * remaining characters may be dropped or RTT module waits until there is more space in the buffer. * (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); }
/********************************************************************* * * __write() * * Function description * Low-level write function. * libc subroutines will use this system routine for output to all files, * including stdout. * Write data via RTT. */ size_t __write(int handle, const unsigned char * buffer, size_t size) { (void) handle; /* Not used, avoid warning */ SEGGER_RTT_Write(0, buffer, size); return size; }
/********************************************************************* * * _write_r() * * Function description * Low-level reentrant write function. * libc subroutines will use this system routine for output to all files, * including stdout. * Write data via RTT. */ int _write_r(struct _reent *r, int file, char *ptr, int len) { (void) file; /* Not used, avoid warning */ (void) r; /* Not used, avoid warning */ SEGGER_RTT_Write(0, ptr, len); return len; }
/********************************************************************* * * _write() * * Function description * Low-level write function. * libc subroutines will use this system routine for output to all files, * including stdout. * Write data via RTT. */ int _write(int file, char *ptr, int len) { (void) file; /* Not used, avoid warning */ SEGGER_RTT_Write(0, ptr, len); return len; }
/********************************************************************* * * 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 values * Number of bytes which have been stored in the "Up"-buffer. * * Notes * (1) If there is not enough space in the "Up"-buffer, depending on configuration, * remaining characters may be dropped or RTT module waits until there is more space in the buffer. * (2) String passed to this function has to be \0 terminated * (3) \0 termination character is *not* stored in RTT buffer */ int32_t SEGGER_RTT_WriteString(unsigned BufferIndex, const char* s) { int32_t Len; Len = _strlen(s); return SEGGER_RTT_Write(BufferIndex, s, Len); }
uint32_t segger_send_byte(uint8_t byte){ return SEGGER_RTT_Write(0, &byte, 1); }