void vApplicationIdleHook( void )
{
volatile size_t xFreeHeapSpace, xMinimumEverFreeHeapSpace;
/* This is just a trivial example of an idle hook. It is called on each
cycle of the idle task. It must *NOT* attempt to block. In this case the
idle task just queries the amount of FreeRTOS heap that remains. See the
memory management section on the http://www.FreeRTOS.org web site for memory
management options. If there is a lot of heap memory free then the
configTOTAL_HEAP_SIZE value in FreeRTOSConfig.h can be reduced to free up
RAM. */
xFreeHeapSpace = xPortGetFreeHeapSize();
xMinimumEverFreeHeapSpace = xPortGetMinimumEverFreeHeapSize();
/* Remove compiler warning about xFreeHeapSpace being set but never used. */
( void ) xFreeHeapSpace;
( void ) xMinimumEverFreeHeapSpace;
}
static BaseType_t prvQueryHeapCommand( char *pcWriteBuffer, size_t xWriteBufferLen, const char *pcCommandString )
{
/* 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 );
sprintf( pcWriteBuffer, "Current free heap %d bytes, minimum ever free heap %d bytes\r\n", ( int ) xPortGetFreeHeapSize(), ( int ) xPortGetMinimumEverFreeHeapSize() );
/* There is no more data to return after this single string, so return
pdFALSE. */
return pdFALSE;
}
static void prvCheckTask( void *pvParameters )
{
TickType_t xNextWakeTime;
const TickType_t xCycleFrequency = pdMS_TO_TICKS( 2500UL );
/* Just to remove compiler warning. */
( void ) pvParameters;
/* Initialise xNextWakeTime - this only needs to be done once. */
xNextWakeTime = xTaskGetTickCount();
for( ;; )
{
/* Place this task in the blocked state until it is time to run again. */
vTaskDelayUntil( &xNextWakeTime, xCycleFrequency );
/* Check the standard demo tasks are running without error. */
#if( configUSE_PREEMPTION != 0 )
{
/* These tasks are only created when preemption is used. */
if( xAreTimerDemoTasksStillRunning( xCycleFrequency ) != pdTRUE )
{
pcStatusMessage = "Error: TimerDemo";
}
}
#endif
if( xAreTaskNotificationTasksStillRunning() != pdTRUE )
{
pcStatusMessage = "Error: Notification";
}
if( xAreInterruptSemaphoreTasksStillRunning() != pdTRUE )
{
pcStatusMessage = "Error: IntSem";
}
else if( xAreEventGroupTasksStillRunning() != pdTRUE )
{
pcStatusMessage = "Error: EventGroup";
}
else if( xAreIntegerMathsTaskStillRunning() != pdTRUE )
{
pcStatusMessage = "Error: IntMath";
}
else if( xAreGenericQueueTasksStillRunning() != pdTRUE )
{
pcStatusMessage = "Error: GenQueue";
}
else if( xAreQueuePeekTasksStillRunning() != pdTRUE )
{
pcStatusMessage = "Error: QueuePeek";
}
else if( xAreBlockingQueuesStillRunning() != pdTRUE )
{
pcStatusMessage = "Error: BlockQueue";
}
else if( xAreSemaphoreTasksStillRunning() != pdTRUE )
{
pcStatusMessage = "Error: SemTest";
}
else if( xArePollingQueuesStillRunning() != pdTRUE )
{
pcStatusMessage = "Error: PollQueue";
}
else if( xAreMathsTaskStillRunning() != pdPASS )
{
pcStatusMessage = "Error: Flop";
}
else if( xAreRecursiveMutexTasksStillRunning() != pdTRUE )
{
pcStatusMessage = "Error: RecMutex";
}
else if( xAreCountingSemaphoreTasksStillRunning() != pdTRUE )
{
pcStatusMessage = "Error: CountSem";
}
else if( xIsCreateTaskStillRunning() != pdTRUE )
{
pcStatusMessage = "Error: Death";
}
else if( xAreDynamicPriorityTasksStillRunning() != pdPASS )
{
pcStatusMessage = "Error: Dynamic";
}
else if( xAreQueueSetTasksStillRunning() != pdPASS )
{
pcStatusMessage = "Error: Queue set";
}
else if( xIsQueueOverwriteTaskStillRunning() != pdPASS )
{
pcStatusMessage = "Error: Queue overwrite";
}
else if( xAreQueueSetPollTasksStillRunning() != pdPASS )
{
pcStatusMessage = "Error: Queue set polling";
}
else if( xAreBlockTimeTestTasksStillRunning() != pdPASS )
{
pcStatusMessage = "Error: Block time";
}
else if( xAreAbortDelayTestTasksStillRunning() != pdPASS )
{
pcStatusMessage = "Error: Abort delay";
}
#if( configSUPPORT_STATIC_ALLOCATION == 1 )
else if( xAreStaticAllocationTasksStillRunning() != pdPASS )
{
pcStatusMessage = "Error: Static allocation";
}
#endif /* configSUPPORT_STATIC_ALLOCATION */
/* This is the only task that uses stdout so its ok to call printf()
directly. */
printf( "%s - tick count %d - free heap %d - min free heap %d\r\n", pcStatusMessage,
xTaskGetTickCount(),
xPortGetFreeHeapSize(),
xPortGetMinimumEverFreeHeapSize() );
}
}
//void main(int argc, char ** argv) {
void TaskKermit(void *pvParameters) // Operate the Kermit Server
{
(void) pvParameters;
int status, rx_len, i, x;
char c;
UCHAR *inbuf;
short r_slot;
parity = P_PARITY; /* Set this to desired parity */
status = X_OK; /* Initial kermit status */
xargc = argc;
xargv = argv;
xname = argv[0];
while (--xargc > 0) { /* Loop through command-line words */
xargv++;
if (**xargv == '-') { /* Have dash */
c = *(*xargv+1); /* Get the option letter */
x = doarg(c); /* Go handle the option */
if (x < 0) doexit(FAILURE);
} else { /* No dash where expected */
fatal("Malformed command-line option: '",*xargv,"'");
}
}
if (!action) /* Nothing to do, give usage message */
usage();
#ifdef DEBUG
debug(DB_LOG,"SIMULATED ERROR RATE:",0,errorrate);
if (errorrate) srand(seed); /* Init random error generator */
#endif /* DEBUG */
/* THE REAL STUFF IS FROM HERE DOWN */
xSerialPrintf_P(PSTR("\r\nFree Heap Size: %u"),xPortGetMinimumEverFreeHeapSize() ); // needs heap_1.c, heap_2.c or heap_4.c
xSerialPrintf_P(PSTR("\r\nKermit HighWater: %u\r\n"), uxTaskGetStackHighWaterMark(NULL));
spiBegin(SDCard); // initialise the SPI bus for Kermit Server SD Card use.
spiSelect (SDCard);
if (!devopen("dummy")) /* Open the communication device */
doexit(FAILURE);
if (!devsettings("dummy")) /* Perform any needed settings */
doexit(FAILURE);
if (db) /* Open debug log if requested */
debug(DB_OPN,"debug.log",0,0);
debug(DB_MSG,"Initializing...",0,0);
/* Fill in parameters for this run */
k.xfermode = xmode; /* Text/binary automatic/manual */
k.remote = remote; /* Remote vs local */
k.binary = ftype; /* 0 = text, 1 = binary */
k.parity = parity; /* Communications parity */
k.bct = (check == 5) ? 3 : check; /* Block check type */
k.ikeep = keep; /* Keep incompletely received files */
k.filelist = cmlist; /* List of files to send (if any) */
k.cancel = 0; /* Not cancelled yet */
/* Fill in the i/o pointers */
k.zinbuf = i_buf; /* File input buffer */
k.zinlen = IBUFLEN; /* File input buffer length */
k.zincnt = 0; /* File input buffer position */
k.obuf = o_buf; /* File output buffer */
k.obuflen = OBUFLEN; /* File output buffer length */
k.obufpos = 0; /* File output buffer position */
/* Fill in function pointers */
k.rxd = readpkt; /* for reading packets */
k.txd = tx_data; /* for sending packets */
k.ixd = inchk; /* for checking connection */
k.openf = openfile; /* for opening files */
k.finfo = fileinfo; /* for getting file info */
k.readf = readfile; /* for reading files */
k.writef = writefile; /* for writing to output file */
k.closef = closefile; /* for closing files */
#ifdef DEBUG
k.dbf = db ? dodebug : 0; /* for debugging */
#else
k.dbf = 0;
#endif /* DEBUG */
/* Force Type 3 Block Check (16-bit CRC) on all packets, or not */
k.bctf = (check == 5) ? 1 : 0;
/* Initialize Kermit protocol */
status = kermit(K_INIT, &k, 0, 0, "", &r);
#ifdef DEBUG
debug(DB_LOG,"init status:",0,status);
debug(DB_LOG,"version:",k.version,0);
#endif /* DEBUG */
if (status == X_ERROR)
doexit(FAILURE);
if (action == A_SEND)
status = kermit(K_SEND, &k, 0, 0, "", &r);
/*
Now we read a packet ourselves and call Kermit with it. Normally, Kermit
would read its own packets, but in the embedded context, the device must be
free to do other things while waiting for a packet to arrive. So the real
control program might dispatch to other types of tasks, of which Kermit is
only one. But in order to read a packet into Kermit's internal buffer, we
have to ask for a buffer address and slot number.
To interrupt a transfer in progress, set k.cancel to I_FILE to interrupt
only the current file, or to I_GROUP to cancel the current file and all
remaining files. To cancel the whole operation in such a way that the
both Kermits return an error status, call Kermit with K_ERROR.
*/
while (status != X_DONE) {
/*
Here we block waiting for a packet to come in (unless readpkt times out).
Another possibility would be to call inchk() to see if any bytes are waiting
to be read, and if not, go do something else for a while, then come back
here and check again.
*/
inbuf = getrslot(&k,&r_slot); /* Allocate a window slot */
rx_len = k.rxd(&k,inbuf,P_PKTLEN); /* Try to read a packet */
debug(DB_PKT,"main packet",&(k.ipktbuf[0][r_slot]),rx_len);
/*
For simplicity, kermit() ACKs the packet immediately after verifying it was
received correctly. If, afterwards, the control program fails to handle the
data correctly (e.g. can't open file, can't write data, can't close file),
then it tells Kermit to send an Error packet next time through the loop.
*/
if (rx_len < 1) { /* No data was read */
freerslot(&k,r_slot); /* So free the window slot */
if (rx_len < 0) /* If there was a fatal error */
doexit(FAILURE); /* give up */
/* This would be another place to dispatch to another task */
/* while waiting for a Kermit packet to show up. */
}
/* Handle the input */
switch (status = kermit(K_RUN, &k, r_slot, rx_len, "", &r)) {
case X_OK:
#ifdef DEBUG
/*
This shows how, after each packet, you get the protocol state, file name,
date, size, and bytes transferred so far. These can be used in a
file-transfer progress display, log, etc.
*/
debug(DB_LOG,"NAME",r.filename ? (char *)r.filename : "(NULL)",0);
debug(DB_LOG,"DATE",r.filedate ? (char *)r.filedate : "(NULL)",0);
debug(DB_LOG,"SIZE",0,r.filesize);
debug(DB_LOG,"STATE",0,r.status);
debug(DB_LOG,"SOFAR",0,r.sofar);
#endif /* DEBUG */
/* Maybe do other brief tasks here... */
continue; /* Keep looping */
case X_DONE:
break; /* Finished */
case X_ERROR:
doexit(FAILURE); /* Failed */
break;
}
}
doexit(SUCCESS);
}
