_mqx_int _io_pcb_mqxa_close
(
/* [IN] the file handle */
FILE_DEVICE_STRUCT_PTR fd_ptr
)
{ /* Body */
IO_PCB_MQXA_INFO_STRUCT_PTR info_ptr;
IO_PCB_STRUCT_PTR pcb_ptr;
#if MQX_CHECK_ERRORS
if (!(fd_ptr->FLAGS & IO_FLAG_IS_PCB_DEVICE)) {
fd_ptr->ERROR = IO_PCB_NOT_A_PCB_DEVICE;
return(IO_ERROR);
}/* Endif */
#endif
info_ptr = (IO_PCB_MQXA_INFO_STRUCT_PTR)fd_ptr->DEV_DATA_PTR;
if (info_ptr->FD) {
fclose(info_ptr->FD);
info_ptr->FD = NULL;
}/* Endif */
if (info_ptr->INPUT_TASK) {
#if MQX_TASK_DESTRUCTION
_task_destroy(info_ptr->INPUT_TASK);
#endif
info_ptr->INPUT_TASK = 0;
}/* Endif */
if (info_ptr->OUTPUT_TASK ) {
#if MQX_TASK_DESTRUCTION
_task_destroy(info_ptr->OUTPUT_TASK);
#endif
info_ptr->OUTPUT_TASK = 0;
}/* Endif */
_lwsem_destroy(&info_ptr->READ_LWSEM);
_lwsem_destroy(&info_ptr->WRITE_LWSEM);
while (_queue_get_size(&info_ptr->WRITE_QUEUE)) {
pcb_ptr = (IO_PCB_STRUCT_PTR)
((pointer)_queue_dequeue(&info_ptr->WRITE_QUEUE));
_io_pcb_free(pcb_ptr);
} /* Endwhile */
while (_queue_get_size(&info_ptr->READ_QUEUE)) {
pcb_ptr = (IO_PCB_STRUCT_PTR)
((pointer)_queue_dequeue(&info_ptr->READ_QUEUE));
_io_pcb_free(pcb_ptr);
} /* Endwhile */
return(MQX_OK);
} /* Endbody */
/** De-Initialise the Uart.
*
* BLEUART_Deinit()
* This function is called by the BLE stack (TRANSPORT layer) to de-initialise
* the UART layer. Eventual thread shall be terminated here.
* When this function succeed, the UART layer shall be fully de-initialised
*
* This function is called during the BLESTCK_Deinit() process, failure here
* will issue a failure in BLESTCK_Deinit()
*
* @todo implement this function
*
* @see BLESTCK_Deinit()
*
* @return The status of the operation:
* - BLESTATUS_SUCCESS indicates to the BLE stack that the UART have been
* successfully initialized
* - BLESTATUS_FAILED indicates to the BLE stack that the UART could not be
* initialized
*
* @author Alexandre GIMARD
*/
BleStatus BLEUART_Deinit(void){
// Add here specific code to execute during Stack De-Initialisation
// in order to de-initialise the transport drivers
//>
/*close spi interface*/
if(MQX_OK != fclose(spi_dev))
{
#ifdef LOCAL_LOG
SYSTEM_Log("Unable to close communication channel\n");
#endif
return BLESTATUS_FAILED;
}
/*power off em9301 from 74HC595*/
if(MQX_OK != mux_74hc595_clear_bit(BSP_74HC595_0, BSP_74HC595_VBLE_3V3))
{
return BLESTATUS_FAILED;
}
/*disable pin IRQ, destroy spi read task, semaphore*/
_bsp_int_disable(lwgpio_int_get_vector(&SPI_IRQ_PIN));
_int_install_isr(lwgpio_int_get_vector(&SPI_IRQ_PIN), _int_get_default_isr(), NULL);
if(MQX_OK != _task_destroy(_task_get_id_from_name("SPI_READ")))
{
return BLESTATUS_FAILED;
}
if(MQX_OK != _lwsem_destroy(&IRQ_SEM))
{
return BLESTATUS_FAILED;
}
//<
return BLESTATUS_SUCCESS;
}
uint32_t OS_Task_delete(uint32_t task_id)
{
uint32_t ret;
ret = _task_destroy((_task_id)task_id);
if (ret != MQX_OK)
return (uint32_t)OS_TASK_ERROR;
else
return (uint32_t)OS_TASK_OK;
}
// Main task
void Main_task(uint32_t task_init_data)
{
// switch the red LED on (line low sets LED on)
LED_RED_ClrVal(NULL);
LED_GREEN_SetVal(NULL);
LED_BLUE_SetVal(NULL);
// create the sensor sampling event (typically 200Hz)
_lwevent_create(&(mqxglobals.SamplingEventStruct), LWEVENT_AUTO_CLEAR);
// create the Kalman filter sensor fusion event (typically 25Hz)
_lwevent_create(&(mqxglobals.RunKFEventStruct), LWEVENT_AUTO_CLEAR);
// create the magnetic calibration event (typically once per minute)
_lwevent_create(&(mqxglobals.MagCalEventStruct), LWEVENT_AUTO_CLEAR);
// create the sensor read task (controlled by sensor sampling event SamplingEventStruct)
_task_create_at(0, RDSENSDATA_TASK, 0, RdSensData_task_stack, RDSENSDATA_TASK_STACK_SIZE);
// create the sensor fusion task (controlled by sensor fusion event RunKFEventStruct)
_task_create_at(0, FUSION_TASK, 0, Fusion_task_stack, FUSION_TASK_STACK_SIZE);
// create the magnetic calibration task (controlled by MagCalEventStruct)
_task_create_at(0, MAGCAL_TASK, 0, MagCal_task_stack, MAGCAL_TASK_STACK_SIZE);
// and this main task uses about 512 bytes stack for a grand total of 3K task stack space
// set the sensor sampling frequency (typically 200Hz)
// this is set to 200Hz by default in PE but we want to set it using value in proj_config.h
FTM_SetPeriodTicks(FTM_DeviceData, (uint16) (FTM_INCLK_HZ / SENSORFS));
// initialize globals
mqxglobals.FTMReload = (uint16)(FTM_INCLK_HZ / SENSORFS);
mqxglobals.FTMTimestamp = 0;
globals.iPacketNumber = 0;
globals.AngularVelocityPacketOn = true;
globals.DebugPacketOn = true;
globals.RPCPacketOn = true;
globals.AltPacketOn = true;
globals.iMPL3115Found = false;
globals.MagneticPacketID = 0;
// initialize the BlueRadios Bluetooth module and other user tasks
UserStartup();
// initialize the incoming command buffer to all '~' = 0x7E and trigger a callback
// when any single command character is received into the UART buffer
iCommand[0] = iCommand[1] = iCommand[2] = iCommand[3] = '~';
UART_ReceiveBlock(UART_DeviceData, sUARTInputBuf, 1);
// destroy this task (main task) now that the three new tasks are created
_task_destroy(MQX_NULL_TASK_ID);
return;
}
void main_task
(
uint_32 initial_data
)
{
_task_id test_task;
_lwsem_create(&shutdown_sem, 0);
test_task = _task_create(0, TEST_TASK,0);
_lwsem_wait(&shutdown_sem);
_task_destroy(test_task);
printf("\nWatchdog expired");
_task_block();
}
int32_t Shell_kill(int32_t argc, char *argv[] )
{
_task_id task_id;
uint32_t result;
bool print_usage, shorthelp = FALSE;
int32_t return_code = SHELL_EXIT_SUCCESS;
print_usage = Shell_check_help_request(argc, argv, &shorthelp );
if (!print_usage) {
if (argc == 2) {
task_id = _task_get_id_from_name( argv[1] );
if (task_id == MQX_NULL_TASK_ID) {
printf("No task named %s running.\n",argv[1]);
return_code = SHELL_EXIT_ERROR;
} else {
result = _task_destroy(task_id);
if (result == MQX_OK) {
printf("Task %s killed.\n",argv[1]);
} else {
printf("Unable to kill task %s.\n",argv[1]);
return_code = SHELL_EXIT_ERROR;
}
}
} else {
printf("Error, %s invoked with incorrect number of arguments\n", argv[0]);
print_usage = TRUE;
}
}
if (print_usage) {
if (shorthelp) {
printf("%s <taskid>\n", argv[0]);
} else {
printf("Usage: %s <taskname>\n", argv[0]);
printf(" <taskname> = MQX Task name\n");
}
}
return return_code;
} /* Endbody */
/*TASK*-----------------------------------------------------------------
*
* Function Name : Sdcard_task
* Returned Value : void
* Comments :
*
*END------------------------------------------------------------------*/
void Sdcard_task
(
uint_32 temp
)
{
boolean inserted = TRUE, last = FALSE;
_mqx_int error_code;
MQX_FILE_PTR com_handle;
//#if defined BSP_SDCARD_GPIO_DETECT
// LWGPIO_STRUCT sd_detect;
//#endif
#if defined BSP_SDCARD_GPIO_PROTECT
LWGPIO_STRUCT sd_protect;
#endif
#ifdef BSP_SDCARD_GPIO_CS
LWGPIO_STRUCT sd_cs;
SPI_CS_CALLBACK_STRUCT callback;
#endif
_task_id player_task_id, sd_walker_id;
_mqx_int sd_event_value;
_mqx_uint wait_state;
#ifdef USB_ACCESSORY_PLAY
connect_msg_t msg;
int delaySetp = 0;
#endif
if (MQX_OK !=_lwevent_create(&(sddetect_event), LWEVENT_AUTO_CLEAR)) {
printf("\n_lwevent_create sddetect_event failed\n");
_task_block();
}
/* Open low level communication device */
com_handle = fopen (SDCARD_COM_CHANNEL, NULL);
if (NULL == com_handle)
{
printf("Error installing communication handle.\n");
_task_block();
}
#ifdef BSP_SDCARD_GPIO_CS
/* Open GPIO file for SPI CS signal emulation */
error_code = lwgpio_init(&sd_cs, BSP_SDCARD_GPIO_CS, LWGPIO_DIR_OUTPUT, LWGPIO_VALUE_NOCHANGE);
if (!error_code)
{
printf("Initializing GPIO with associated pins failed.\n");
_task_block();
}
lwgpio_set_functionality(&sd_cs,BSP_SDCARD_CS_MUX_GPIO);
lwgpio_set_attribute(&sd_cs, LWGPIO_ATTR_PULL_UP, LWGPIO_AVAL_ENABLE);
/* Set CS callback */
callback.MASK = BSP_SDCARD_SPI_CS;
callback.CALLBACK = set_CS;
callback.USERDATA = &sd_cs;
if (SPI_OK != ioctl (com_handle, IO_IOCTL_SPI_SET_CS_CALLBACK, &callback))
{
printf ("Setting CS callback failed.\n");
_task_block();
}
#endif
#if defined BSP_SDCARD_GPIO_DETECT
/* Init GPIO pins for other SD card signals */
error_code = lwgpio_init(&sd_detect, BSP_SDCARD_GPIO_DETECT, LWGPIO_DIR_INPUT, LWGPIO_VALUE_NOCHANGE);
if (!error_code)
{
printf("Initializing GPIO with sdcard detect pin failed.\n");
_task_block();
}
/*Set detect and protect pins as GPIO Function */
lwgpio_set_functionality(&sd_detect,BSP_SDCARD_DETECT_MUX_GPIO);
lwgpio_set_attribute(&sd_detect, LWGPIO_ATTR_PULL_UP, LWGPIO_AVAL_ENABLE);
#ifndef SD_DETECT_POLLING // init sd detcet pin interrupt
lwgpio_int_init(&sd_detect,LWGPIO_INT_MODE_RISING | LWGPIO_INT_MODE_FALLING /* LWGPIO_INT_MODE_HIGH*/); /* falling,raising mode = 3 */
/* install gpio interrupt service routine */
_int_install_isr(lwgpio_int_get_vector(&sd_detect), EXT_SDDETECT_ISR, (void *) &sd_detect);
_bsp_int_init(lwgpio_int_get_vector(&sd_detect), 5, 0, TRUE);
lwgpio_int_enable(&sd_detect, TRUE);
#endif
#endif
#if defined BSP_SDCARD_GPIO_PROTECT
/* Init GPIO pins for other SD card signals */
error_code = lwgpio_init(&sd_protect, BSP_SDCARD_GPIO_PROTECT, LWGPIO_DIR_INPUT, LWGPIO_VALUE_NOCHANGE);
if (!error_code)
{
printf("Initializing GPIO with sdcard protect pin failed.\n");
_task_block();
}
/*Set detect and protect pins as GPIO Function */
lwgpio_set_functionality(&sd_protect,BSP_SDCARD_PROTECT_MUX_GPIO);
lwgpio_set_attribute(&sd_protect, LWGPIO_ATTR_PULL_UP, LWGPIO_AVAL_ENABLE);
#endif
/* Install SD card device */
error_code = _io_sdcard_install("sdcard:", (pointer)&_bsp_sdcard0_init, com_handle);
if ( error_code != MQX_OK )
{
printf("Error installing SD card device (0x%x)\n", error_code);
_task_block();
}
_lwevent_set(&sddetect_event,SD_ATTACHED_EVENT); // set attached event at mode manager
_time_delay(1000); /* wait otg main task ready */
printf("start sd card task\n");
// use sd detect interrupt
for (;;) {
#ifdef SD_DETECT_POLLING
wait_state = _lwevent_wait_ticks(&sddetect_event,SD_EVENT_MASK, FALSE, 4/* 0*/);
#else
wait_state = _lwevent_wait_ticks(&sddetect_event,SD_EVENT_MASK, FALSE, 0);
#endif
//if (wait_state == LWEVENT_WAIT_TIMEOUT/* MQX_OK*/) {
if (wait_state != MQX_OK ) {
#ifndef SD_DETECT_POLLING
printf("waiting sddetect_event fail\n");
// _task_block(); // _lwevent_destroy(&sddetect_event);
//-goto wait_timeout;
continue;
#else
_lwevent_set(&sddetect_event,SD_ATTACHED_EVENT);
#endif
}
//else
sd_event_value = _lwevent_get_signalled();
if (sd_event_value == SD_ATTACHED_EVENT ) {
_time_delay (200);
inserted = !lwgpio_get_value(&sd_detect);
if(!inserted) // mount sd fs ,must attached sd card !
continue;
// printf("mount sd card...\n");
// mount_sdcard();
#ifndef USB_ACCESSORY_PLAY
/* create player and sd_walker task*/
player_task_id = _task_create(0, PLAYER_TASK, 0);
printf("Creating sd player task................");
if (player_task_id == MQX_NULL_TASK_ID) {
printf("[FAIL]\n");
}
else {
printf("[OK]\n");
}
sd_walker_id = _task_create(0, SD_WALKER_TASK, 0);
printf("Creating sd walker task................");
if (sd_walker_id == MQX_NULL_TASK_ID) {
printf("[FAIL]\n");
}
else {
printf("[OK]\n");
}
#else
msg.conct_source = mp_for_TF;
msg.conct_action = mp_plugIn; /* post message, TFcard plug in*/
if (LWMSGQ_FULL == _lwmsgq_send(connect_taskq, (uint_32 *) &msg, 0)) {
printf("Could not inform about TFCard device attached\n");
}
//_time_delay (1); // give mode manager task some times to cancel play ,if sd task high than mode task
#endif
// _lwevent_set(&player_event, PLAYER_EVENT_MSK_SD_FS_MOUNTED); //auto play event
last = inserted;
} // SD_ATTACHED_EVENT
else if (sd_event_value == SD_DETTACHED_EVENT ) {
// _time_delay (100);
//inserted = !lwgpio_get_value(&sd_detect);
//if(inserted)
// continue;
#ifndef USB_ACCESSORY_PLAY
_lwevent_set(&player_event, PLAYER_EVENT_MSK_SD_FS_UNMOUNTED);
_lwevent_wait_ticks(&player_event,
PLAYER_EVENT_MSK_PLAYER_TASK_KILLED,
TRUE, 0);
_lwevent_clear(&player_event, PLAYER_EVENT_MSK_PLAYER_TASK_KILLED);
/* And the destroy play_task and sd_walker task */
_task_destroy(sd_walker_id);
_task_destroy(player_task_id);
#else
/* post message, TFcard plug out*/
msg.conct_source = mp_for_TF;
msg.conct_action = mp_plugOut; /* post message, TFcard plug out*/
if (LWMSGQ_FULL == _lwmsgq_send(connect_taskq, (uint_32 *) &msg, 0)) {
printf("Could not inform about TFCard device de-attached\n");
}
//_time_delay (1); // give mode manager task some times to cancel play ,if sd task high than mode task
#endif
// printf("unmount sd card...\n");
// unmount_sdcard();
// printf ("SD card uninstalled.\n");
}
}
}
_task_id _mmu_create_vtask
(
/* [IN] the task template number */
_mqx_uint template_number,
/* [IN] the task creation parameter */
_mqx_uint parameter,
/* [IN] the data address to copy initialization values from*/
pointer data_init_ptr,
/* [IN] the virtual address for the virtual memory */
pointer vaddr,
/* [IN] the size of the virtual memory */
_mem_size size,
/* [IN] the MMU flags to use */
_mqx_uint flags
)
{ /* Body */
KERNEL_DATA_STRUCT_PTR kernel_data;
TD_STRUCT_PTR td_ptr;
TD_STRUCT_PTR my_td_ptr;
uint_32 result;
_task_id task_id;
_GET_KERNEL_DATA(kernel_data);
my_td_ptr = kernel_data->ACTIVE_PTR;
if (my_td_ptr->FLAGS & TASK_MMU_CONTEXT_EXISTS) {
return(MQX_MMU_PARENT_TASK_CANNOT_BE_MMU);
} /* Endif */
task_id = _task_create_blocked(0, template_number, parameter);
if (task_id == MQX_NULL_TASK_ID) {
return(MQX_NULL_TASK_ID);
} /* Endif */
td_ptr = _task_get_td(task_id);
result = _mmu_create_vcontext(task_id);
if (result != MQX_OK) {
_task_destroy(task_id);
_task_set_error(result);
return(MQX_NULL_TASK_ID);
} /* Endif */
result = _mmu_add_vcontext(task_id, vaddr, size, flags);
if (result != MQX_OK) {
_task_destroy(task_id);
_task_set_error(result);
return(MQX_NULL_TASK_ID);
} /* Endif */
if (data_init_ptr != NULL) {
_int_disable();
my_td_ptr->MMU_VIRTUAL_CONTEXT_PTR =
td_ptr->MMU_VIRTUAL_CONTEXT_PTR;
my_td_ptr->FLAGS |= TASK_MMU_CONTEXT_EXISTS;
_mmu_set_vcontext_internal();
_int_enable();
_mem_copy(data_init_ptr, vaddr, size);
_int_disable();
_mmu_reset_vcontext_internal();
my_td_ptr->FLAGS &= ~TASK_MMU_CONTEXT_EXISTS;
my_td_ptr->MMU_VIRTUAL_CONTEXT_PTR = NULL;
_int_enable();
} /* Endif */
_task_ready(td_ptr);
return(task_id);
} /* Endbody */
