void frs_user_top(void *parameters)
{
char buf[256];
vTaskGetRunTimeStats(buf);
printf("Task\t Abs Time \t Time\n");
printf(buf);
/* kill task */
frs_task_kill_name(NULL);
}
void MPU_vTaskGetRunTimeStats( char *pcWriteBuffer )
{
BaseType_t xRunningPrivileged = prvRaisePrivilege();
vTaskGetRunTimeStats( pcWriteBuffer );
portRESET_PRIVILEGE( xRunningPrivileged );
}
void MPU_vTaskGetRunTimeStats( char *pcWriteBuffer )
{
BaseType_t xRunningPrivileged = xPortRaisePrivilege();
vTaskGetRunTimeStats( pcWriteBuffer );
vPortResetPrivilege( xRunningPrivileged );
}
static unsigned short uslwIPAppsSSIHandler( int iIndex, char *pcBuffer, int iBufferLength )
{
static unsigned int uiUpdateCount = 0;
static char cUpdateString[ 200 ];
extern char *pcMainGetTaskStatusMessage( void );
/* Unused parameter. */
( void ) iBufferLength;
/* The SSI handler function that generates text depending on the index of
the SSI tag encountered. */
switch( iIndex )
{
case ssiTASK_STATS_INDEX :
vTaskList( ( signed char * ) pcBuffer );
break;
case ssiRUN_TIME_STATS_INDEX :
vTaskGetRunTimeStats( ( signed char * ) pcBuffer );
break;
}
/* Include a count of the number of times an SSI function has been executed
in the returned string. */
uiUpdateCount++;
sprintf( cUpdateString, "\r\n\r\n%u\r\nStatus - %s", uiUpdateCount, pcMainGetTaskStatusMessage() );
strcat( pcBuffer, cUpdateString );
return strlen( pcBuffer );
}
portBASE_TYPE prvRunTimeStatsCommand(int8_t *pcWriteBuffer,
size_t xWriteBufferLen,
const int8_t *pcCommandString)
{
sprintf(pcWriteBuffer, runStatsHdr );
pcWriteBuffer += strlen(runStatsHdr);
vTaskGetRunTimeStats(pcWriteBuffer);
return pdFALSE;
}
static unsigned short generate_runtime_stats( void *arg )
{
( void ) arg;
lRefreshCount++;
sprintf( cCountBuf, "<p><br>Refresh count = %d", ( int ) lRefreshCount );
vTaskGetRunTimeStats( uip_appdata );
strcat( uip_appdata, cCountBuf );
return strlen( uip_appdata );
}
static retval_t cmd_dump_runtime_stats(const subsystem_t *self, frame_t *iframe, frame_t *oframe) {
#if ( configGENERATE_RUN_TIME_STATS == 1 )
#define FREERTOS_STAT_BUFSIZE_PER_TASK 40
#define CANOPUS_CMOCKERY_ESTIMATED_TASKS_COUNT 42
signed char buf[CANOPUS_CMOCKERY_ESTIMATED_TASKS_COUNT * FREERTOS_STAT_BUFSIZE_PER_TASK];
vTaskGetRunTimeStats(buf);
log_report(LOG_SS_PLATFORM, (const char *)buf);
FUTURE_HOOK_4(cmd_dump_runtime_stats, buf, sizeof(buf), iframe, oframe);
return RV_SUCCESS;
#else
return RV_NOTIMPLEMENTED;
#endif
}
static portBASE_TYPE prvRunTimeStatsCommand( int8_t *pcWriteBuffer, size_t xWriteBufferLen, const int8_t *pcCommandString )
{
const int8_t * const pcHeader = ( int8_t * ) "Task Abs Time % Time\r\n****************************************\r\n";
( void ) pcCommandString;
configASSERT( pcWriteBuffer );
/* This function assumes the buffer length is adequate. */
( void ) xWriteBufferLen;
/* Generate a table of task stats. */
strcpy( ( char * ) pcWriteBuffer, ( char * ) pcHeader );
vTaskGetRunTimeStats( pcWriteBuffer + strlen( ( char * ) pcHeader ) );
/* There is no more data to return after this single string, so return
pdFALSE. */
return pdFALSE;
}
static BaseType_t prvRunTimeStatsCommand( char *pcWriteBuffer, size_t xWriteBufferLen, const char *pcCommandString )
{
const char * const pcHeader = "Task Abs Time % Time\r\n****************************************\r\n";
/* Remove compile time warnings about unused parameters, and check the
write buffer is not NULL. NOTE - for simplicity, this example assumes the
write buffer length is adequate, so does not check for buffer overflows. */
( void ) pcCommandString;
( void ) xWriteBufferLen;
configASSERT( pcWriteBuffer );
/* Generate a table of task stats. */
strcpy( pcWriteBuffer, pcHeader );
vTaskGetRunTimeStats( pcWriteBuffer + strlen( pcHeader ) );
/* There is no more data to return after this single string, so return
pdFALSE. */
return pdFALSE;
}
static portBASE_TYPE prvRunTimeStatsCommand( signed char *pcWriteBuffer, size_t xWriteBufferLen, const signed char * pcCommandString )
{
const char * const pcHeader = "Task Abs Time % Time\r\n****************************************\r\n";
configASSERT( pcWriteBuffer );
/* This function assumes the buffer length is adequate and does not look
for parameters. */
( void ) xWriteBufferLen;
( void ) pcCommandString;
/* Generate a table of task stats. */
strcpy( pcWriteBuffer, pcHeader );
vTaskGetRunTimeStats( pcWriteBuffer + strlen( pcHeader ) );
/* There is no more data to return after this single string, so return
pdFALSE. */
return pdFALSE;
}
void runtimestats_print(void)
{
char *buf;
/* Allocate memory */
vTaskSuspendAll();
buf = (char *) calloc(uxTaskGetNumberOfTasks() * 40, sizeof(char));
xTaskResumeAll();
if (buf != NULL)
{
/* Get a runtime stats report and write it on the UART */
vTaskGetRunTimeStats((signed char*) buf);
uart_write((INT8U *) buf, strlen((char *) buf), portMAX_DELAY);
/* Free the memory again */
vTaskSuspendAll();
free(buf);
xTaskResumeAll();
}
}
static unsigned short generate_runtime_stats( void *arg )
{
( void ) arg;
lRefreshCount++;
sprintf( cCountBuf, "<p><br>Refresh count = %d", ( int ) lRefreshCount );
#ifdef INCLUDE_HIGH_FREQUENCY_TIMER_TEST
{
sprintf( cJitterBuffer, "<p><br>Max high frequency timer jitter = %d peripheral clock periods.<p><br>", ( int ) usMaxJitter );
vTaskGetRunTimeStats( uip_appdata );
strcat( uip_appdata, cJitterBuffer );
}
#else
{
( void ) cJitterBuffer;
strcpy( uip_appdata, "<p>Run time stats are only available in the debug_with_optimisation build configuration.<p>" );
}
#endif
strcat( uip_appdata, cCountBuf );
return strlen( uip_appdata );
}
static BaseType_t prvRunTimeStatsCommand( char *pcWriteBuffer, size_t xWriteBufferLen, const char *pcCommandString )
{
const char * const pcHeader = " Abs Time % Time\r\n****************************************\r\n";
BaseType_t xSpacePadding;
/* Remove compile time warnings about unused parameters, and check the
write buffer is not NULL. NOTE - for simplicity, this example assumes the
write buffer length is adequate, so does not check for buffer overflows. */
( void ) pcCommandString;
( void ) xWriteBufferLen;
configASSERT( pcWriteBuffer );
/* Generate a table of task stats. */
strcpy( pcWriteBuffer, "Task" );
pcWriteBuffer += strlen( pcWriteBuffer );
/* Pad the string "task" with however many bytes necessary to make it the
length of a task name. Minus three for the null terminator and half the
number of characters in "Task" so the column lines up with the centre of
the heading. */
for( xSpacePadding = strlen( "Task" ); xSpacePadding < ( configMAX_TASK_NAME_LEN - 3 ); xSpacePadding++ )
{
/* Add a space to align columns after the task's name. */
*pcWriteBuffer = ' ';
pcWriteBuffer++;
/* Ensure always terminated. */
*pcWriteBuffer = 0x00;
}
strcpy( pcWriteBuffer, pcHeader );
vTaskGetRunTimeStats( pcWriteBuffer + strlen( pcHeader ) );
/* There is no more data to return after this single string, so return
pdFALSE. */
return pdFALSE;
}
extern "C" void vApplicationTickHook()
{
static unsigned portLONG ulTicksSinceLastDisplay = 0;
// Called from every tick interrupt. Have enough ticks passed to make it
// time to perform our health status check again?
ulTicksSinceLastDisplay++;
if( ulTicksSinceLastDisplay >= mainCHECK_DELAY )
{
ulTicksSinceLastDisplay = 0;
WDT_Feed();
#if configGENERATE_RUN_TIME_STATS == 1
unsigned long long uptime_usec = ullTaskGetSchedulerUptime();
#if 1
struct timeval tp;
int t = gettimeofday(&tp, NULL);
printf("timeofday = %ld seconds %ld microseconds (code %d)\n", (long)tp.tv_sec, (long)tp.tv_usec, t);
#endif
printf("Uptime: %u.%06u seconds\n", (unsigned int)(uptime_usec / 1000000), (unsigned int)(uptime_usec % 1000000));
int8_t *taskListBuffer = (int8_t *)malloc(40 * uxTaskGetNumberOfTasks());
if (taskListBuffer != NULL)
{
vTaskGetRunTimeStats((int8_t *)taskListBuffer);
puts((const char *)taskListBuffer);
free(taskListBuffer);
}
#endif
// Has an error been found in any task?
int allGood = 1;
#if 0
if( xAreBlockingQueuesStillRunning() != pdTRUE )
{
printf("ERROR - BLOCKQ\n");
allGood = 0;
}
if( xAreBlockTimeTestTasksStillRunning() != pdTRUE )
{
printf("ERROR - BLOCKTIM\n");
allGood = 0;
}
if( xAreGenericQueueTasksStillRunning() != pdTRUE )
{
printf("ERROR - GENQ\n");
allGood = 0;
}
if( xAreQueuePeekTasksStillRunning() != pdTRUE )
{
printf("ERROR - PEEKQ\n");
allGood = 0;
}
if( xAreDynamicPriorityTasksStillRunning() != pdTRUE )
{
printf("ERROR - DYNAMIC\n");
allGood = 0;
}
#endif
if (allGood == 1)
{
printf("All Good.\n");
}
fflush(stdout);
}
}
static void prvLCDTask( void *pvParameters )
{
xQueueMessage xReceivedMessage;
long lLine = Line1;
const long lFontHeight = (((sFONT *)LCD_GetFont())->Height);
/* Buffer into which strings are formatted and placed ready for display on the
LCD. Note this is a static variable to prevent it being allocated on the task
stack, which is too small to hold such a variable. The stack size is configured
when the task is created. */
static char cBuffer[ 512 ];
/* This function is the only function that uses printf(). If printf() is
used from any other function then some sort of mutual exclusion on stdout
will be necessary.
This is also the only function that is permitted to access the LCD.
First print out the number of bytes that remain in the FreeRTOS heap. This
can be viewed in the terminal IO window within the IAR Embedded Workbench. */
printf( "%d bytes of heap space remain unallocated\n", xPortGetFreeHeapSize() );
for( ;; ) {
/* Wait for a message to be received. Using portMAX_DELAY as the block
time will result in an indefinite wait provided INCLUDE_vTaskSuspend is
set to 1 in FreeRTOSConfig.h, therefore there is no need to check the
function return value and the function will only return when a value
has been received. */
xQueueReceive( xLCDQueue, &xReceivedMessage, portMAX_DELAY );
/* Clear the LCD if no room remains for any more text output. */
if( lLine > Line9 ) {
LCD_Clear( Blue );
lLine = 0;
}
/* What is this message? What does it contain? */
switch( xReceivedMessage.cMessageID ) {
case mainMESSAGE_BUTTON_UP : /* The button poll task has just
informed this task that the up
button on the joystick input has
been pressed or released. */
sprintf( cBuffer, "Button up = %d", xReceivedMessage.lMessageValue );
break;
case mainMESSAGE_BUTTON_SEL : /* The select button interrupt
just informed this task that the
select button was pressed.
Generate a table of task run time
statistics and output this to
the terminal IO window in the IAR
embedded workbench. */
printf( "\nTask\t Abs Time\t %%Time\n*****************************************" );
vTaskGetRunTimeStats( cBuffer );
printf( cBuffer );
/* Also print out a message to
the LCD - in this case the
pointer to the string to print
is sent directly in the
lMessageValue member of the
message. This just demonstrates
a different communication
technique. */
sprintf( cBuffer, "%s", ( char * ) xReceivedMessage.lMessageValue );
break;
case mainMESSAGE_STATUS : /* The tick interrupt hook
function has just informed this
task of the system status.
Generate a string in accordance
with the status value. */
prvGenerateStatusMessage( cBuffer, xReceivedMessage.lMessageValue );
break;
default :
sprintf( cBuffer, "Unknown message" );
break;
}
/* Output the message that was placed into the cBuffer array within the
switch statement above. */
LCD_DisplayStringLine( lLine, ( uint8_t * ) cBuffer );
/* Move onto the next LCD line, ready for the next iteration of this
loop. */
lLine += lFontHeight;
}
}
static void prvLCDTask( void *pvParameters )
{
xQueueMessage xReceivedMessage;
/* Buffer into which strings are formatted and placed ready for display on the
LCD. Note this is a static variable to prevent it being allocated on the task
stack, which is too small to hold such a variable. The stack size is configured
when the task is created. */
static char cBuffer[ 512 ];
unsigned char ucLine = 1;
/* This function is the only function that uses printf(). If printf() is
used from any other function then some sort of mutual exclusion on stdout
will be necessary.
This is also the only function that is permitted to access the LCD.
First print out the number of bytes that remain in the FreeRTOS heap. This
can be viewed in the terminal IO window within the IAR Embedded Workbench. */
printf( "%d bytes of heap space remain unallocated\n", ( int ) xPortGetFreeHeapSize() );
/* Just as a test of the port, and for no functional reason, check the task
parameter contains its expected value. */
if( pvParameters != mainTASK_PARAMETER_CHECK_VALUE )
{
halLcdPrintLine( "Invalid parameter", ucLine, OVERWRITE_TEXT );
ucLine++;
}
for( ;; )
{
/* Wait for a message to be received. Using portMAX_DELAY as the block
time will result in an indefinite wait provided INCLUDE_vTaskSuspend is
set to 1 in FreeRTOSConfig.h, therefore there is no need to check the
function return value and the function will only return when a value
has been received. */
xQueueReceive( xLCDQueue, &xReceivedMessage, portMAX_DELAY );
/* Clear the LCD if no room remains for any more text output. */
if( ucLine > mainMAX_LCD_LINES )
{
halLcdClearScreen();
ucLine = 0;
}
/* What is this message? What does it contain? */
switch( xReceivedMessage.cMessageID )
{
case mainMESSAGE_BUTTON_UP : /* The button poll task has just
informed this task that the up
button on the joystick input has
been pressed or released. */
sprintf( cBuffer, "Button up = %d", ( int ) xReceivedMessage.ulMessageValue );
break;
case mainMESSAGE_BUTTON_SEL : /* The select button interrupt
just informed this task that the
select button was pressed.
Generate a table of task run time
statistics and output this to
the terminal IO window in the IAR
embedded workbench. */
printf( "\nTask\t Abs Time\t %%Time\n*****************************************" );
vTaskGetRunTimeStats( ( signed char * ) cBuffer );
printf( cBuffer );
/* Also print out a message to
the LCD - in this case the
pointer to the string to print
is sent directly in the
ulMessageValue member of the
message. This just demonstrates
a different communication
technique. */
sprintf( cBuffer, "%s", ( char * ) xReceivedMessage.ulMessageValue );
break;
case mainMESSAGE_STATUS : /* The tick interrupt hook
function has just informed this
task of the system status.
Generate a string in accordance
with the status value. */
prvGenerateStatusMessage( cBuffer, xReceivedMessage.ulMessageValue );
break;
default :
sprintf( cBuffer, "Unknown message" );
break;
}
/* Output the message that was placed into the cBuffer array within the
switch statement above, then move onto the next line ready for the next
message to arrive on the queue. */
halLcdPrintLine( cBuffer, ucLine, OVERWRITE_TEXT );
ucLine++;
}
}
/**
* \brief Send a JSON string representing the board status.
*
* \param name Not used.
* \param recv_buf Receive buffer.
* \param recv_len Receive buffer length.
*
* \return 0.
*/
static int cgi_status(struct netconn *client, const char *name, char *recv_buf, size_t recv_len)
{
(void)recv_buf;
(void)recv_len;
(void)name;
uint32_t length = 0;
uint32_t nb = 11;
uint32_t i, count, new_entry;
#if LWIP_STATS
extern uint32_t lwip_tx_rate;
extern uint32_t lwip_rx_rate;
#else
volatile uint32_t lwip_tx_rate = 0;
volatile uint32_t lwip_rx_rate = 0;
#endif
/* Protect tx_buf buffer from concurrent access. */
sys_arch_sem_wait(&cgi_sem, 0);
status.tot_req++;
status.up_time = xTaskGetTickCount() / 1000;
/* Update board status. */
sprintf(status.last_connected_ip, "%d.%d.%d.%d", IP_ADDR_TO_INT_TUPLE(client->pcb.ip->remote_ip.addr));
sprintf(status.local_ip, "%d.%d.%d.%d", IP_ADDR_TO_INT_TUPLE(client->pcb.ip->local_ip.addr));
length += sprintf((char *)tx_buf, "{\"board_ip\":\"%s\",\"remote_ip\":\"%s\",\"download\":%u,\"upload\":%u",
status.local_ip, status.last_connected_ip,
lwip_rx_rate, lwip_tx_rate);
/* Turn FreeRTOS stats into JSON. */
vTaskGetRunTimeStats(freertos_stats);
length += sprintf((char *)tx_buf + length, ",\"rtos\":{\"10");
// i = 2 to skip first 13 10 sequence.
for (i = 2, count = 0, new_entry = 0; i < FREERTOS_STATS_BUFLEN && freertos_stats[i]; ++i) {
if (freertos_stats[i] == 13) {
tx_buf[length++] = '\"';
new_entry = 1;
continue;
}
if (freertos_stats[i] == 10)
continue;
if (freertos_stats[i] == 9) {
count += 1;
if (count == 4) {
tx_buf[length++] = '\"';
tx_buf[length++] = ':';
tx_buf[length++] = '\"';
count = 0;
continue;
}
}
if (count != 0)
continue;
if (new_entry == 1) {
new_entry = 0;
tx_buf[length++] = ',';
tx_buf[length++] = '\"';
/* Append ID to task name since JSON id must be unique. */
tx_buf[length++] = '0' + nb / 10;
tx_buf[length++] = '0' + nb % 10;
nb++;
}
tx_buf[length++] = freertos_stats[i];
}
tx_buf[length++] = '}';
char * memp_names[] = {
#define LWIP_MEMPOOL(name,num,size,desc) desc,
#include "lwip/memp_std.h"
};
length += sprintf((char *)tx_buf + length, ",\"lwip\":{");
#if MEM_STATS || MEMP_STATS
length += sprintf((char *)tx_buf + length, "\"HEAP\":{\"Cur\":%d,\"Size\":%d,\"Max\":%d,\"Err\":%u}", lwip_stats.mem.used, lwip_stats.mem.avail, lwip_stats.mem.max, lwip_stats.mem.err);
if (MEMP_MAX > 0)
tx_buf[length++] = ',';
#endif
for (uint32_t z= 0; z < MEMP_MAX; ++z) {
length += sprintf((char *)tx_buf + length, "\"%s\":{\"Cur\":%d,\"Size\":%d,\"Max\":%d,\"Err\":%u}", memp_names[z], lwip_stats.memp[z].used, lwip_stats.memp[z].avail, lwip_stats.memp[z].max, lwip_stats.memp[z].err);
if (z + 1 < MEMP_MAX)
tx_buf[length++] = ',';
}
tx_buf[length++] = '}';
/* Remaining board status. */
length += sprintf((char *)tx_buf + length, ",\"up_time\":%u,\"tot_req\":%u}", status.up_time, status.tot_req);
/* Send answer. */
http_sendOk(client, HTTP_CONTENT_JSON);
/* Use NETCONN_COPY to avoid corrupting the buffer after releasing the semaphore. */
netconn_write(client, tx_buf, strlen((char *)tx_buf), NETCONN_COPY);
/* Release semaphore to allow further use of tx_buf. */
sys_sem_signal(&cgi_sem);
return 0;
}
//==================================================================================
void vKeyHandlerTask( void *pvParameters )
{ // Key handling is a continuous process and as such the task
// is implemented using an infinite loop (as most real time
// tasks are).
static uint16_t RegKn = 0, RegKnOld = 0;
char stat_buff[150];
u8 i=0, j=0;
for( ;; )
{
#if(( configGENERATE_RUN_TIME_STATS == 1 ) && (DEBUG_ON == 1 ))
if( one_sec )
{
i=0;
j=0;
one_sec = false;
for( i=0; i<150; i++ )
stat_buff[i] = 0;
//vTaskList(stat_buff);
vTaskGetRunTimeStats( stat_buff );
i = 99;
while( !stat_buff[i] )
i--;
printf("%c[1;1f%c[J", 27, 27); //ClearScreen
while( j<i )
{
putchar(stat_buff[j]);
++j;
}
}
#endif
if(!(MDR_PORTC -> RXTX & 0x10))
RegKn |= 1;
else
RegKn &= 0xfffe;
if(!(MDR_PORTC -> RXTX & 0x20))
RegKn |= 2;
else
RegKn &=0xfffd;
if(!(MDR_PORTC -> RXTX & 0x40))
RegKn |= 4;
else
RegKn &= 0xfffb;
if(!(MDR_PORTC -> RXTX & 0x80))
RegKn |= 8;
else
RegKn &= 0xfff7;
if(!(MDR_PORTC -> RXTX & 0x100))
RegKn |= 0x10;
else
RegKn &= 0xffef;
if(!(MDR_PORTC->RXTX & 0x200))
RegKn |= 0x20;
else
RegKn &= 0xffdf;
if(!(MDR_PORTC -> RXTX & 0x400))
RegKn |= 0x40;
else
RegKn &= 0xffbf;
if(!(MDR_PORTC -> RXTX & 0x800))
RegKn |= 0x80;
else
RegKn &= 0xff7f;
if(!(MDR_PORTC -> RXTX & 0x8))
RegKn |= 0x100;
else
RegKn &= 0xfeff;
if(!(MDR_PORTC -> RXTX & 0x1000))
RegKn |= 0x200;
else
RegKn &= 0xfdff;
if(!(MDR_PORTC -> RXTX & 0x2000))
RegKn |= 0x400;
else
RegKn &= 0xfbff;
if(!(MDR_PORTC -> RXTX & 0x4000))
RegKn |= 0x800;
else
RegKn &= 0xf7ff;
if(!(MDR_PORTC -> RXTX & 0x8000))
RegKn |= 0x1000;
else
RegKn &= 0xefff;
if(RegKnOld == RegKn)
{
//RegS = RegKn;
//PKDU_Status.Ctrl_BTN = RegS;
}
else
RegKnOld = RegKn;
vTaskDelay( 50 );
}
}
