int commandClearFlash(uint8_t *buffer)
{
uint8_t state = getProcessStatus();
if( (state == 1) || (state == 3) )
*buffer = 0x0E;
else
{
EventBits_t flags = xEventGroupGetBits(xEventGroup);
if( flags & FLAG_FLASH_CLEARING )
{
*buffer++ = 0x0d; //устройство занято
*buffer = 0x04; //устройство зянято стиранием памяти
return 7;
}
else
{
memset((void*)flashMap, 0xff, sizeof(flashMap));
memset((void*)headerList, 0xff, sizeof(headerList));
countProc = 0;
spiChipErase();
xEventGroupSetBits(xEventGroup, FLAG_FLASH_CLEARING);
//стартуем таймер на 22 сек, после которого state сменим с 4 на 2.
xTimerStart(timerClearFlash, 500);
}
}
return 6;
}
static void prvExerciseEventGroupAPI( void )
{
EventGroupHandle_t xEventGroup;
EventBits_t xBits;
const EventBits_t xBitsToWaitFor = ( EventBits_t ) 0xff, xBitToClear = ( EventBits_t ) 0x01;
/* Exercise some event group functions. */
xEventGroup = xEventGroupCreate();
configASSERT( xEventGroup );
/* No bits should be set. */
xBits = xEventGroupWaitBits( xEventGroup, xBitsToWaitFor, pdTRUE, pdFALSE, mainDONT_BLOCK );
configASSERT( xBits == ( EventBits_t ) 0 );
/* Set bits and read back to ensure the bits were set. */
xEventGroupSetBits( xEventGroup, xBitsToWaitFor );
xBits = xEventGroupGetBits( xEventGroup );
configASSERT( xBits == xBitsToWaitFor );
/* Clear a bit and read back again using a different API function. */
xEventGroupClearBits( xEventGroup, xBitToClear );
xBits = xEventGroupSync( xEventGroup, 0x00, xBitsToWaitFor, mainDONT_BLOCK );
configASSERT( xBits == ( xBitsToWaitFor & ~xBitToClear ) );
/* Finished with the event group. */
vEventGroupDelete( xEventGroup );
}
static void prvSanityCheckCreatedEventGroup( EventGroupHandle_t xEventGroup )
{
EventBits_t xEventBits;
const EventBits_t xFirstTestBits = ( EventBits_t ) 0xaa, xSecondTestBits = ( EventBits_t ) 0x55;
/* The event group should not have any bits set yet. */
xEventBits = xEventGroupGetBits( xEventGroup );
if( xEventBits != ( EventBits_t ) 0 )
{
xErrorOccurred = pdTRUE;
}
/* Some some bits, then read them back to check they are as expected. */
xEventGroupSetBits( xEventGroup, xFirstTestBits );
xEventBits = xEventGroupGetBits( xEventGroup );
if( xEventBits != xFirstTestBits )
{
xErrorOccurred = pdTRUE;
}
xEventGroupSetBits( xEventGroup, xSecondTestBits );
xEventBits = xEventGroupGetBits( xEventGroup );
if( xEventBits != ( xFirstTestBits | xSecondTestBits ) )
{
xErrorOccurred = pdTRUE;
}
/* Finally try clearing some bits too and check that operation proceeds as
expected. */
xEventGroupClearBits( xEventGroup, xFirstTestBits );
xEventBits = xEventGroupGetBits( xEventGroup );
if( xEventBits != xSecondTestBits )
{
xErrorOccurred = pdTRUE;
}
}
/*FUNCTION**********************************************************************
*
* Function Name : OSA_EventGetFlags
* Description : Get event flags status.
* Return current event flags.
*
*END**************************************************************************/
event_flags_t OSA_EventGetFlags(event_t *pEvent)
{
assert(pEvent);
if (__get_IPSR())
{
return xEventGroupGetBitsFromISR(pEvent->eventHandler);
}
else
{
return xEventGroupGetBits(pEvent->eventHandler);
}
}
int commandReadyCheck(uint8_t *buffer)
{
buffer[5] = 0x0d;
if( xSemaphoreTake(semaphAdc, 0) == pdTRUE )
{
EventBits_t uxBits = xEventGroupGetBits(xEventGroup);
if( (uxBits & FLAG_IS_READY_MES) == FLAG_IS_READY_MES )
buffer[6] = 3; //Устройство не занято, есть данные
else
buffer[6] = 2; //Устройство не занято, нет данных или нет процесса
xSemaphoreGive(semaphAdc);
}
else
{
buffer[6] = 1;
}
return 7;
}
/// Set the specified Signal Flags of an active thread.
/// \param[in] thread_id thread ID obtained by \ref osThreadCreate or \ref osThreadGetId.
/// \param[in] signals specifies the signal flags of the thread that should be set.
/// \return previous signal flags of the specified thread or 0x80000000 in case of incorrect parameters.
/// \note MUST REMAIN UNCHANGED: \b osSignalSet shall be consistent in every CMSIS-RTOS.
int32_t osSignalSet (osThreadId thread_id, int32_t signals)
{
EventGroupHandle_t event_handle;
portBASE_TYPE taskWoken = pdFALSE;
portBASE_TYPE xResult;
EventBits_t uxBits_ret=0x80000000;
#ifdef CHECK_VALUE_OF_EVENT_GROUP
EventBits_t uxBits;
#endif
if (signals & (0xFFFFFFFF << osFeature_Signals)) {
return 0x80000000;
}
event_handle = find_signal_by_thread(thread_id);
if (event_handle) {
if (inHandlerMode()) {
uxBits_ret = xEventGroupGetBitsFromISR(event_handle);
xResult = xEventGroupSetBitsFromISR(
event_handle, /* The event group being updated. */
signals, /* The bits being set. */
&taskWoken );
if( xResult != pdFAIL )
{
portYIELD_FROM_ISR(taskWoken);
}
}
else {
uxBits_ret = xEventGroupGetBits(event_handle);
#ifdef CHECK_VALUE_OF_EVENT_GROUP
uxBits =
#endif
xEventGroupSetBits(
event_handle, /* The event group being updated. */
signals );/* The bits being set. */
}
}
return uxBits_ret;
}
/// Clear the specified Signal Flags of an active thread.
/// \param[in] thread_id thread ID obtained by \ref osThreadCreate or \ref osThreadGetId.
/// \param[in] signals specifies the signal flags of the thread that shall be cleared.
/// \return previous signal flags of the specified thread or 0x80000000 in case of incorrect parameters.
/// \note MUST REMAIN UNCHANGED: \b osSignalClear shall be consistent in every CMSIS-RTOS.
int32_t osSignalClear (osThreadId thread_id, int32_t signals)
{
EventGroupHandle_t event_handle;
//portBASE_TYPE taskWoken = pdFALSE;
EventBits_t uxBits_ret=0x80000000;
#ifdef CHECK_VALUE_OF_EVENT_GROUP
EventBits_t uxBits;
#endif
if (signals & (0xFFFFFFFF << osFeature_Signals)) {
return 0x80000000;
}
event_handle = find_signal_by_thread(thread_id);
if (event_handle) {
if (inHandlerMode()) {
uxBits_ret = xEventGroupGetBitsFromISR(event_handle);
#ifdef CHECK_VALUE_OF_EVENT_GROUP
uxBits =
#endif
xEventGroupClearBitsFromISR(
event_handle, /* The event group being updated. */
signals);/* The bits being cleared. */
}
else {
uxBits_ret = xEventGroupGetBits(event_handle);
#ifdef CHECK_VALUE_OF_EVENT_GROUP
uxBits =
#endif
xEventGroupClearBits(
event_handle, /* The event group being updated. */
signals);/* The bits being cleared. */
}
}
return uxBits_ret;
}
static BaseType_t prvBitCombinationTestMasterFunction( BaseType_t xError, TaskHandle_t xTestSlaveTaskHandle )
{
EventBits_t uxBits;
/* Resume the other task. It will block, pending a single bit from
within ebCOMBINED_BITS. */
vTaskResume( xTestSlaveTaskHandle );
/* Ensure the other task is blocked on the task. */
if( eTaskGetState( xTestSlaveTaskHandle ) != eBlocked )
{
xError = pdTRUE;
}
/* Set all the bits in ebCOMBINED_BITS - the 'test slave' task is only
blocked waiting for one of them. */
xEventGroupSetBits( xEventGroup, ebCOMBINED_BITS );
/* The 'test slave' task should now have executed, clearing ebBIT_1 (the
bit it was blocked on), then re-entered the Blocked state to wait for
all the other bits in ebCOMBINED_BITS to be set again. First check
ebBIT_1 is clear. */
uxBits = xEventGroupWaitBits( xEventGroup, ebALL_BITS, pdFALSE, pdFALSE, ebDONT_BLOCK );
if( uxBits != ( ebCOMBINED_BITS & ~ebBIT_1 ) )
{
xError = pdTRUE;
}
/* Ensure the other task is still in the blocked state. */
if( eTaskGetState( xTestSlaveTaskHandle ) != eBlocked )
{
xError = pdTRUE;
}
/* Set all the bits other than ebBIT_1 - which is the bit that must be
set before the other task unblocks. */
xEventGroupSetBits( xEventGroup, ebALL_BITS & ~ebBIT_1 );
/* Ensure all the expected bits are still set. */
uxBits = xEventGroupWaitBits( xEventGroup, ebALL_BITS, pdFALSE, pdFALSE, ebDONT_BLOCK );
if( uxBits != ( ebALL_BITS & ~ebBIT_1 ) )
{
xError = pdTRUE;
}
/* Ensure the other task is still in the blocked state. */
if( eTaskGetState( xTestSlaveTaskHandle ) != eBlocked )
{
xError = pdTRUE;
}
/* Now also set ebBIT_1, which should unblock the other task, which will
then suspend itself. */
xEventGroupSetBits( xEventGroup, ebBIT_1 );
/* Ensure the other task is suspended. */
if( eTaskGetState( xTestSlaveTaskHandle ) != eSuspended )
{
xError = pdTRUE;
}
/* The other task should not have cleared the bits - so all the bits
should still be set. */
if( xEventGroupSetBits( xEventGroup, 0x00 ) != ebALL_BITS )
{
xError = pdTRUE;
}
/* Clear ebBIT_1 again. */
if( xEventGroupClearBits( xEventGroup, ebBIT_1 ) != ebALL_BITS )
{
xError = pdTRUE;
}
/* Resume the other task - which will wait on all the ebCOMBINED_BITS
again - this time clearing the bits when it is unblocked. */
vTaskResume( xTestSlaveTaskHandle );
/* Ensure the other task is blocked once again. */
if( eTaskGetState( xTestSlaveTaskHandle ) != eBlocked )
{
xError = pdTRUE;
}
/* Set the bit the other task is waiting for. */
xEventGroupSetBits( xEventGroup, ebBIT_1 );
/* Ensure the other task is suspended once again. */
if( eTaskGetState( xTestSlaveTaskHandle ) != eSuspended )
{
xError = pdTRUE;
}
/* The other task should have cleared the bits in ebCOMBINED_BITS.
Clear the remaining bits. */
uxBits = xEventGroupWaitBits( xEventGroup, ebALL_BITS, pdFALSE, pdFALSE, ebDONT_BLOCK );
if( uxBits != ( ebALL_BITS & ~ebCOMBINED_BITS ) )
{
xError = pdTRUE;
}
/* Clear all bits ready for the sync with the other three tasks. The
value returned is the value prior to the bits being cleared. */
if( xEventGroupClearBits( xEventGroup, ebALL_BITS ) != ( ebALL_BITS & ~ebCOMBINED_BITS ) )
{
xError = pdTRUE;
}
/* The bits should be clear now. */
if( xEventGroupGetBits( xEventGroup ) != 0x00 )
{
xError = pdTRUE;
}
return xError;
}
static BaseType_t prvPerformTaskSyncTests( BaseType_t xError, TaskHandle_t xTestSlaveTaskHandle )
{
EventBits_t uxBits;
/* The three tasks that take part in the synchronisation (rendezvous) are
expected to be in the suspended state at the start of the test. */
if( eTaskGetState( xTestSlaveTaskHandle ) != eSuspended )
{
xError = pdTRUE;
}
if( eTaskGetState( xSyncTask1 ) != eSuspended )
{
xError = pdTRUE;
}
if( eTaskGetState( xSyncTask2 ) != eSuspended )
{
xError = pdTRUE;
}
/* Try a synch with no other tasks involved. First set all the bits other
than this task's bit. */
xEventGroupSetBits( xEventGroup, ( ebALL_SYNC_BITS & ~ebSET_BIT_TASK_SYNC_BIT ) );
/* Then wait on just one bit - the bit that is being set. */
uxBits = xEventGroupSync( xEventGroup, /* The event group used for the synchronisation. */
ebSET_BIT_TASK_SYNC_BIT,/* The bit set by this task when it reaches the sync point. */
ebSET_BIT_TASK_SYNC_BIT,/* The bits to wait for - in this case it is just waiting for itself. */
portMAX_DELAY ); /* The maximum time to wait for the sync condition to be met. */
/* A sync with a max delay should only exit when all the synchronise
bits are set...check that is the case. In this case there is only one
sync bit anyway. */
if( ( uxBits & ebSET_BIT_TASK_SYNC_BIT ) != ebSET_BIT_TASK_SYNC_BIT )
{
xError = pdTRUE;
}
/* ...but now the sync bits should be clear again, leaving all the other
bits set (as only one bit was being waited for). */
if( xEventGroupGetBits( xEventGroup ) != ( ebALL_SYNC_BITS & ~ebSET_BIT_TASK_SYNC_BIT ) )
{
xError = pdTRUE;
}
/* Clear all the bits to zero again. */
xEventGroupClearBits( xEventGroup, ( ebALL_SYNC_BITS & ~ebSET_BIT_TASK_SYNC_BIT ) );
if( xEventGroupGetBits( xEventGroup ) != 0 )
{
xError = pdTRUE;
}
/* Unsuspend the other tasks then check they have executed up to the
synchronisation point. */
vTaskResume( xTestSlaveTaskHandle );
vTaskResume( xSyncTask1 );
vTaskResume( xSyncTask2 );
if( eTaskGetState( xTestSlaveTaskHandle ) != eBlocked )
{
xError = pdTRUE;
}
if( eTaskGetState( xSyncTask1 ) != eBlocked )
{
xError = pdTRUE;
}
if( eTaskGetState( xSyncTask2 ) != eBlocked )
{
xError = pdTRUE;
}
/* Set this task's sync bit. */
uxBits = xEventGroupSync( xEventGroup, /* The event group used for the synchronisation. */
ebSET_BIT_TASK_SYNC_BIT,/* The bit set by this task when it reaches the sync point. */
ebALL_SYNC_BITS, /* The bits to wait for - these bits are set by the other tasks that take part in the sync. */
portMAX_DELAY ); /* The maximum time to wait for the sync condition to be met. */
/* A sync with a max delay should only exit when all the synchronise
bits are set...check that is the case. */
if( ( uxBits & ebALL_SYNC_BITS ) != ebALL_SYNC_BITS )
{
xError = pdTRUE;
}
/* ...but now the sync bits should be clear again. */
if( xEventGroupGetBits( xEventGroup ) != 0 )
{
xError = pdTRUE;
}
/* The other tasks should now all be suspended again, ready for the next
synchronisation. */
if( eTaskGetState( xTestSlaveTaskHandle ) != eSuspended )
{
xError = pdTRUE;
}
if( eTaskGetState( xSyncTask1 ) != eSuspended )
{
xError = pdTRUE;
}
if( eTaskGetState( xSyncTask2 ) != eSuspended )
{
xError = pdTRUE;
}
/* Sync again - but this time set the last necessary bit as the
highest priority task, rather than the lowest priority task. Unsuspend
the other tasks then check they have executed up to the synchronisation
point. */
vTaskResume( xTestSlaveTaskHandle );
vTaskResume( xSyncTask1 );
vTaskResume( xSyncTask2 );
if( eTaskGetState( xTestSlaveTaskHandle ) != eBlocked )
{
xError = pdTRUE;
}
if( eTaskGetState( xSyncTask1 ) != eBlocked )
{
xError = pdTRUE;
}
if( eTaskGetState( xSyncTask2 ) != eBlocked )
{
xError = pdTRUE;
}
/* Raise the priority of this task above that of the other tasks. */
vTaskPrioritySet( NULL, ebWAIT_BIT_TASK_PRIORITY + 1 );
/* Set this task's sync bit. */
uxBits = xEventGroupSync( xEventGroup, ebSET_BIT_TASK_SYNC_BIT, ebALL_SYNC_BITS, portMAX_DELAY );
/* A sync with a max delay should only exit when all the synchronisation
bits are set... */
if( ( uxBits & ebALL_SYNC_BITS ) != ebALL_SYNC_BITS )
{
xError = pdTRUE;
}
/* ...but now the sync bits should be clear again. */
if( xEventGroupGetBits( xEventGroup ) != 0 )
{
xError = pdTRUE;
}
/* The other tasks should now all be in the ready state again, but not
executed yet as this task still has a higher relative priority. */
if( eTaskGetState( xTestSlaveTaskHandle ) != eReady )
{
xError = pdTRUE;
}
if( eTaskGetState( xSyncTask1 ) != eReady )
{
xError = pdTRUE;
}
if( eTaskGetState( xSyncTask2 ) != eReady )
{
xError = pdTRUE;
}
/* Reset the priority of this task back to its original value. */
vTaskPrioritySet( NULL, ebSET_BIT_TASK_PRIORITY );
/* Now all the other tasks should have reblocked on the event bits
to test the behaviour when the event bits are deleted. */
if( eTaskGetState( xTestSlaveTaskHandle ) != eBlocked )
{
xError = pdTRUE;
}
if( eTaskGetState( xSyncTask1 ) != eBlocked )
{
xError = pdTRUE;
}
if( eTaskGetState( xSyncTask2 ) != eBlocked )
{
xError = pdTRUE;
}
return xError;
}
static void prvTestSlaveTask( void *pvParameters )
{
EventBits_t uxReturned;
BaseType_t xError = pdFALSE;
/* Avoid compiler warnings. */
( void ) pvParameters;
for( ;; )
{
/**********************************************************************
* Part 1: This section is the counterpart to the
* prvBitCombinationTestMasterFunction() function which is called by the
* test master task.
***********************************************************************
This task is controller by the 'test master' task (which is
implemented by prvTestMasterTask()). Suspend until resumed by the
'test master' task. */
vTaskSuspend( NULL );
/* Wait indefinitely for one of the bits in ebCOMBINED_BITS to get
set. Clear the bit on exit. */
uxReturned = xEventGroupWaitBits( xEventGroup, /* The event group that contains the event bits being queried. */
ebBIT_1, /* The bit to wait for. */
pdTRUE, /* Clear the bit on exit. */
pdTRUE, /* Wait for all the bits (only one in this case anyway). */
portMAX_DELAY ); /* Block indefinitely to wait for the condition to be met. */
/* The 'test master' task set all the bits defined by ebCOMBINED_BITS,
only one of which was being waited for by this task. The return value
shows the state of the event bits when the task was unblocked, however
because the task was waiting for ebBIT_1 and 'clear on exit' was set to
the current state of the event bits will have ebBIT_1 clear. */
if( uxReturned != ebCOMBINED_BITS )
{
xError = pdTRUE;
}
/* Now call xEventGroupWaitBits() again, this time waiting for all the
bits in ebCOMBINED_BITS to be set. This call should block until the
'test master' task sets ebBIT_1 - which was the bit cleared in the call
to xEventGroupWaitBits() above. */
uxReturned = xEventGroupWaitBits( xEventGroup,
ebCOMBINED_BITS, /* The bits being waited on. */
pdFALSE, /* Don't clear the bits on exit. */
pdTRUE, /* All the bits must be set to unblock. */
portMAX_DELAY );
/* Were all the bits set? */
if( ( uxReturned & ebCOMBINED_BITS ) != ebCOMBINED_BITS )
{
xError = pdTRUE;
}
/* Suspend again to wait for the 'test master' task. */
vTaskSuspend( NULL );
/* Now call xEventGroupWaitBits() again, again waiting for all the bits
in ebCOMBINED_BITS to be set, but this time clearing the bits when the
task is unblocked. */
uxReturned = xEventGroupWaitBits( xEventGroup,
ebCOMBINED_BITS, /* The bits being waited on. */
pdTRUE, /* Clear the bits on exit. */
pdTRUE, /* All the bits must be set to unblock. */
portMAX_DELAY );
/* The 'test master' task set all the bits in the event group, so that
is the value that should have been returned. The bits defined by
ebCOMBINED_BITS will have been clear again in the current value though
as 'clear on exit' was set to pdTRUE. */
if( uxReturned != ebALL_BITS )
{
xError = pdTRUE;
}
/**********************************************************************
* Part 2: This section is the counterpart to the
* prvPerformTaskSyncTests() function which is called by the
* test master task.
***********************************************************************
Once again wait for the 'test master' task to unsuspend this task
when it is time for the next test. */
vTaskSuspend( NULL );
/* Now peform a synchronisation with all the other tasks. At this point
the 'test master' task has the lowest priority so will get to the sync
point after all the other synchronising tasks. */
uxReturned = xEventGroupSync( xEventGroup, /* The event group used for the sync. */
ebWAIT_BIT_TASK_SYNC_BIT, /* The bit in the event group used to indicate this task is at the sync point. */
ebALL_SYNC_BITS, /* The bits to wait for. These bits are set by the other tasks taking part in the sync. */
portMAX_DELAY ); /* The maximum time to wait for the sync condition to be met before giving up. */
/* A sync with a max delay should only exit when all the synchronisation
bits are set... */
if( ( uxReturned & ebALL_SYNC_BITS ) != ebALL_SYNC_BITS )
{
xError = pdTRUE;
}
/* ...but now the synchronisation bits should be clear again. Read back
the current value of the bits within the event group to check that is
the case. Setting the bits to zero will return the bits previous value
then leave all the bits clear. */
if( xEventGroupSetBits( xEventGroup, 0x00 ) != 0 )
{
xError = pdTRUE;
}
/* Check the bits are indeed 0 now by simply reading then. */
if( xEventGroupGetBits( xEventGroup ) != 0 )
{
xError = pdTRUE;
}
if( xError == pdFALSE )
{
/* This task is still cycling without finding an error. */
ulTestSlaveCycles++;
}
vTaskSuspend( NULL );
/* This time sync when the 'test master' task has the highest priority
at the point where it sets its sync bit - so this time the 'test master'
task will get to the sync point before this task. */
uxReturned = xEventGroupSync( xEventGroup, ebWAIT_BIT_TASK_SYNC_BIT, ebALL_SYNC_BITS, portMAX_DELAY );
/* A sync with a max delay should only exit when all the synchronisation
bits are set... */
if( ( uxReturned & ebALL_SYNC_BITS ) != ebALL_SYNC_BITS )
{
xError = pdTRUE;
}
/* ...but now the sync bits should be clear again. */
if( xEventGroupSetBits( xEventGroup, 0x00 ) != 0 )
{
xError = pdTRUE;
}
/* Block on the event group again. This time the event group is going
to be deleted while this task is blocked on it, so it is expected that 0
will be returned. */
uxReturned = xEventGroupWaitBits( xEventGroup, ebALL_SYNC_BITS, pdFALSE, pdTRUE, portMAX_DELAY );
if( uxReturned != 0 )
{
xError = pdTRUE;
}
if( xError == pdFALSE )
{
/* This task is still cycling without finding an error. */
ulTestSlaveCycles++;
}
configASSERT( xError == pdFALSE );
}
}
int WiFiGenericClass::getStatusBits(){
if(!_network_event_group){
return 0;
}
return xEventGroupGetBits(_network_event_group);
}
// Codigo para procesar los comandos recibidos a traves del canal USB
static portTASK_FUNCTION( CommandProcessingTask, pvParameters ){
unsigned char frame[MAX_FRAME_SIZE]; //Ojo, esto hace que esta tarea necesite bastante pila
int numdatos;
unsigned int errors=0;
unsigned char command;
EventBits_t bits;
/* The parameters are not used. */
( void ) pvParameters;
for(;;)
{
numdatos=receive_frame(frame,MAX_FRAME_SIZE);
if (numdatos>0)
{ //Si no hay error, proceso la trama que ha llegado.
numdatos=destuff_and_check_checksum(frame,numdatos);
if (numdatos<0)
{
//Error de checksum (PROT_ERROR_BAD_CHECKSUM), ignorar el paquete
errors++;
// Procesamiento del error (TODO)
}
else
{
//El paquete esta bien, luego procedo a tratarlo.
command=decode_command_type(frame,0);
bits=xEventGroupGetBits(xEventGroup);
switch(command)
{
case COMANDO_PING :
if(bits & TrazaBit == TrazaBit){
UARTprintf("Comando PING\n ");
}
//A un comando de ping se responde con el propio comando
numdatos=create_frame(frame,command,0,0,MAX_FRAME_SIZE);
if (numdatos>=0)
{
send_frame(frame,numdatos);
}else{
//Error de creacion de trama: determinar el error y abortar operacion
errors++;
logError(numdatos);
}
break;
case COMANDO_START: // Comando de ejemplo: eliminar en la aplicacion final
{
if(bits & TrazaBit == TrazaBit){
UARTprintf("Comando START\n ");
}
if(sensorTaskHandle == NULL){
inicializarVariables();
if((xTaskCreate(ConsumoTask, (signed portCHAR *)"Consumo", LED1TASKSTACKSIZE,NULL,tskIDLE_PRIORITY + 1, &consumoTaskHandle)!= pdTRUE))
{
while(1);
}
if((xTaskCreate(SensorTask, (signed portCHAR *)"Sensor", LED1TASKSTACKSIZE,NULL,tskIDLE_PRIORITY + 1, &sensorTaskHandle) != pdTRUE))
{
while(1);
}
if((xTaskCreate(HighTask, (signed portCHAR *)"Altitud", LED1TASKSTACKSIZE,NULL,tskIDLE_PRIORITY + 1, &altitudTaskHandle) != pdTRUE))
{
while(1);
}
if((xTaskCreate(turbulenciasTask, (signed portCHAR *)"Turbulencias", LED1TASKSTACKSIZE,NULL,tskIDLE_PRIORITY + 1, &turbulenciasTaskHandle) != pdTRUE))
{
while(1);
}
}
}
break;
case COMANDO_STOP:
{
if(bits & TrazaBit == TrazaBit){
UARTprintf("Comando STOP\n ");
}
if(combustible>0){ //Eliminamos las tareas en el STOP
vTaskDelete(sensorTaskHandle);
vTaskDelete( consumoTaskHandle );
vTaskDelete(altitudTaskHandle);
vTaskDelete( turbulenciasTaskHandle );
}
}
break;
case COMANDO_SPEED:
{
if(bits & TrazaBit == TrazaBit){
UARTprintf("Comando SPEED\n ");
}
float velocidad;
//Recibimos y enviamos por la cola la velocidad
extract_packet_command_param(frame,sizeof(velocidad),&velocidad);
xQueueSend( velocidadQueue,&velocidad,portMAX_DELAY);
}
break;
case COMANDO_TIME:
{
if(bits & TrazaBit == TrazaBit){
UARTprintf("Comando TIME\n ");
}
uint32_t hora;
extract_packet_command_param(frame,sizeof(hora),&hora);
//recibimos y actualizamos el valor de Hora
setHora(hora);
//Creamos la tarea Time
if(xTaskCreate(TimeTask, (portCHAR *)"Time",LED1TASKSTACKSIZE, NULL, tskIDLE_PRIORITY + 1, NULL) != pdTRUE)
{
while(1);
}
}
break;
default:
{
PARAM_COMANDO_NO_IMPLEMENTADO parametro;
parametro.command=command;
//El comando esta bien pero no esta implementado
numdatos=create_frame(frame,COMANDO_NO_IMPLEMENTADO,¶metro,sizeof(parametro),MAX_FRAME_SIZE);
if (numdatos>=0)
{
send_frame(frame,numdatos);
}
break;
}
}
}
}else{ // if (numdatos >0)
//Error de recepcion de trama(PROT_ERROR_RX_FRAME_TOO_LONG), ignorar el paquete
errors++;
}
}
}
static portTASK_FUNCTION(PilAuto,pvParameters)
{
unsigned char frame[MAX_FRAME_SIZE];
int num_datos;
//Desactivamos las lecturas del ADC
ADCSequenceDisable(ADC0_BASE,0);
bool pilotoAutomatico =true;
EventBits_t bits;
// Enviamos la trama para indicar a QT que estamos con el piloto Automatico
num_datos=create_frame(frame, COMANDO_AUTOMATICO, &pilotoAutomatico, sizeof(pilotoAutomatico), MAX_FRAME_SIZE);
if (num_datos>=0){
send_frame(frame, num_datos);
}else{
logError(num_datos);
}
while(1)
{
vTaskDelay(configTICK_RATE_HZ); // Esperamos 1 seg
bits=xEventGroupGetBits(xEventGroup); // Leemos los flags
if(bits == 0 || bits== 1){ //Si el flags de pilotoAutomatico esta a cero quitamos el pilotoAutomatico
pilotoAutomatico=false;
num_datos=create_frame(frame, COMANDO_AUTOMATICO, &pilotoAutomatico, sizeof(pilotoAutomatico), MAX_FRAME_SIZE);
if (num_datos>=0){
send_frame(frame, num_datos);
}else{
logError(num_datos);
}
ADCSequenceEnable(ADC0_BASE,0); // Habilitamos el ADC
vTaskDelete(NULL);
while(1){
//Por si falla
}
}
//Centramos el avion, ponemos la velocidad a 100 y lo mandamos a QT
setEjes(0,0,0);
setVelocidad(100.0f);
num_datos=create_frame(frame, COMANDO_EJES, &ejes, sizeof(ejes), MAX_FRAME_SIZE);
if (num_datos>=0){
send_frame(frame, num_datos);
}else{
logError(num_datos);
}
num_datos=create_frame(frame, COMANDO_SPEED, &velocidad, sizeof(velocidad), MAX_FRAME_SIZE);
if (num_datos>=0){
send_frame(frame, num_datos);
}else{
logError(num_datos);
}
}
}
