void Sender
(
uint_32 parameter
)
{
_mqx_uint msg[MSG_SIZE];
_task_id created_task;
created_task = _task_create(0, RESPONDER, 0);
if (created_task == MQX_NULL_TASK_ID) {
/* task creation failed */
}
/*
* Service the message queue - Sender_Queue
*/
_lwmsgq_receive((pointer)sender_queue, msg, LWMSGQ_RECEIVE_BLOCK_ON_EMPTY, 0, 0);
_lwmsgq_send((pointer)responder_queue, msg, LWMSGQ_SEND_BLOCK_ON_FULL);
/*
** LOOP -
*/
while ( TRUE ) {
/*
* Service the message queue - Sender_Queue
*/
_lwmsgq_receive((pointer)sender_queue, msg, LWMSGQ_RECEIVE_BLOCK_ON_EMPTY, 0, 0);
_time_delay_ticks(3);
_lwmsgq_send((pointer)responder_queue, msg, LWMSGQ_SEND_BLOCK_ON_FULL);
putchar('.');
} /* endwhile */
} /*end of task*/
void remote_com_RI_processing(pointer rcom_msg_queue,
pointer controller_msg_queue,
sync_buffer_t *ri_to_controller_sync_buffer) {
char phone_number_or_sms_index[16];
SWM_msg_t msg;
switch (sim900_process_RI_task(phone_number_or_sms_index)) {
case INCOMING_VOICE_CALL:
msg.cmd = RCOM_HAVE_VOICE_CALL_CMD;
sim900_normalize_phone_number(phone_number_or_sms_index, VN_phone_code);
sync_buffer_write(ri_to_controller_sync_buffer,
(uint8_t*) phone_number_or_sms_index,
strlen(phone_number_or_sms_index) + 1);
sync_buffer_allow_read(ri_to_controller_sync_buffer);
msg.content.ptr = (void*) ri_to_controller_sync_buffer;
_lwmsgq_send(controller_msg_queue, (_mqx_max_type_ptr) &msg, 0);
break;
case RECEIVED_SMS_MSG:
msg.cmd = RCOM_HAVE_SMS_MSG_CMD;
msg.content.value = (uint8_t) *phone_number_or_sms_index;
_lwmsgq_send(rcom_msg_queue, (_mqx_max_type_ptr) &msg, 0);
break;
default:
DEBUG("RI_UNKNOWN\n");
break;
}
}
void usb_host_mass_device_event
(
/* [IN] pointer to device instance */
_usb_device_instance_handle dev_handle,
/* [IN] pointer to interface descriptor */
_usb_interface_descriptor_handle intf_handle,
/* [IN] code number for event causing callback */
uint_32 event_code
)
{
DEVICE_STRUCT_PTR device;
usb_msg_t msg;
switch (event_code) {
case USB_CONFIG_EVENT:
/* Drop through into attach, same processing */
case USB_ATTACH_EVENT:
/* Here, the device starts its lifetime */
device = (DEVICE_STRUCT_PTR) _mem_alloc_zero(sizeof(DEVICE_STRUCT));
if (device == NULL)
break;
if (USB_OK != _usb_hostdev_select_interface(dev_handle, intf_handle, &device->ccs))
break;
msg.ccs = &device->ccs;
msg.body = USB_EVENT_ATTACH;
if (LWMSGQ_FULL == _lwmsgq_send(usb_taskq, (uint_32 *) &msg, 0)) {
printf("Could not inform USB task about device attached\n");
}
break;
case USB_INTF_EVENT:
if (USB_OK != usb_class_mass_get_app(dev_handle, intf_handle, (CLASS_CALL_STRUCT_PTR *) &device))
break;
msg.ccs = &device->ccs;
msg.body = USB_EVENT_INTF;
if (LWMSGQ_FULL == _lwmsgq_send(usb_taskq, (uint_32 *) &msg, 0)) {
printf("Could not inform USB task about device interfaced\n");
}
break;
case USB_DETACH_EVENT:
if (USB_OK != usb_class_mass_get_app(dev_handle, intf_handle, (CLASS_CALL_STRUCT_PTR *) &device))
break;
msg.ccs = &device->ccs;
msg.body = USB_EVENT_DETACH;
if (LWMSGQ_FULL == _lwmsgq_send(usb_taskq, (uint_32 *) &msg, 0)) {
printf("Could not inform USB task about device detached\n");
}
_mem_free(device);
break;
default:
break;
}
}
void button_callback_timer_isr(button_t *button_table, uint8_t num_of_btns,
void *dest_queue) {
sampling_time_count = sampling_time_count + 1;
if (sampling_time_count == BTN_SAMPLING_PERIOD) {
sampling_time_count = 0;
uint8_t i = 0;
for (i = 0; i < num_of_btns; i++) {
button_processing(&button_table[i]);
if (is_changed_status(&button_table[i])) {
if (!dest_queue || !(&button_table[i].enable_btn_evt)
|| !enable_all_btn_evts) {
return;
}
_mqx_uint msg =
(_mqx_uint) (((uint32_t) button_table[i].dev_id
<< BTN_NUM_BITS_IN_VALUE)| (uint16_t) get_button_status(&button_table[i]));
_lwmsgq_send((pointer) dest_queue, &msg, 0);
} else {
if (button_table[i].current_status == btn_on_hold) {
button_hold_processing(&button_table[i], dest_queue);
}
}
} //end for()
} //end if()
}
uint32_t OS_MsgQ_send(os_msgq_handle msgq, void* msg, uint32_t flag)
{
if (MQX_OK != _lwmsgq_send(msgq, (uint32_t *) msg, flag))
{
return (uint32_t)OS_MSGQ_ERROR;
}
return (uint32_t)OS_MSGQ_OK;
}
void command_send(uint32_t msg_type, uint16_t code, void * dataPtr, uint32_t len)
{
msg_t msg;
msg.type = msg_type;
msg.cmd_opc = code & 0x00ff; /* code == cmd_cls | cmd_opc*/
msg.cmd_cls = (code & 0xff00)>>8;
msg.data = dataPtr;
msg.len = len;
if(LWMSGQ_FULL == _lwmsgq_send(uart_tx_taskq, (_mqx_max_type_ptr) &msg, 0)){
printf("Could not inform to uart_tx_task 2\n");
}
}
static void button_hold_processing(button_t *a_button, void *dest_queue) {
button_hold_time_count++;
if (button_hold_time_count == BTN_HOLD_PERIOD) {
button_hold_time_count = 0;
a_button->old_status = btn_no_pressed;
if (!dest_queue || !(a_button->enable_btn_evt)
|| !enable_all_btn_evts) {
return;
}
_mqx_uint msg = (_mqx_uint) (((uint32_t) a_button->dev_id
<< BTN_NUM_BITS_IN_VALUE)
| (uint16_t) get_button_status(a_button));
_lwmsgq_send((pointer) dest_queue, &msg, 0);
}
}
void client_task
(
uint_32 index
)
{
_mqx_uint msg[MSG_SIZE];
while (TRUE) {
msg[0] = ('A'+ index);
printf("Client Task %ld\n", index);
_lwmsgq_send((pointer)server_queue, msg, LWMSGQ_SEND_BLOCK_ON_FULL);
_time_delay_ticks(1);
/* wait for a return message */
_lwmsgq_receive((pointer)client_queue, msg, LWMSGQ_RECEIVE_BLOCK_ON_EMPTY, 0, 0);
}
}
void Responder
(
uint32_t parameter
)
{
uint32_t msg[MSG_SIZE];
/*
** LOOP -
*/
while ( TRUE ) {
/*
* Service the message queue - Responder_Queue
*/
_lwmsgq_receive((void *)responder_queue, msg, LWMSGQ_RECEIVE_BLOCK_ON_EMPTY, 0, 0);
_lwmsgq_send((void *)sender_queue, msg, LWMSGQ_SEND_BLOCK_ON_FULL);
putchar('.');
} /* endwhile */
} /*end of task*/
/*!
* \brief MQX API handler for usermode - part of wrapper around standard MQX API
* which require privilege mode.
*
* \param[in] api_no API number - number of wrapped function
* \param[in] params generic parameter - direct use with called MQX API fn
*
* \return uint32_t return of called function
*/
uint32_t _mqx_api_call_handler
(
// [IN] API number - number of wrapped function
MQX_API_NUMBER_ENUM api_no,
// [IN] generic parameter - direct use with called MQX API fn
MQX_API_CALL_PARAMS_PTR params
)
{
int32_t res = -1;
uint32_t param0 = params->param0;
uint32_t param1 = params->param1;
uint32_t param2 = params->param2;
uint32_t param3 = params->param3;
uint32_t param4 = params->param4;
switch (api_no) {
// _lwsem
case MQX_API_LWSEM_POLL:
if (MQX_OK == (res = _lwsem_usr_check((LWSEM_STRUCT_PTR)param0)))
res = (uint32_t)_lwsem_poll((LWSEM_STRUCT_PTR)param0);
break;
case MQX_API_LWSEM_POST:
if (MQX_OK == (res = _lwsem_usr_check((LWSEM_STRUCT_PTR)param0)))
res = _lwsem_post((LWSEM_STRUCT_PTR)param0);
break;
case MQX_API_LWSEM_WAIT:
if (MQX_OK == (res = _lwsem_usr_check((LWSEM_STRUCT_PTR)param0)))
res = _lwsem_wait((LWSEM_STRUCT_PTR)param0);
break;
case MQX_API_LWSEM_CREATE:
res = _lwsem_create_internal((LWSEM_STRUCT_PTR)param0, (_mqx_int)param1, (bool)param2, TRUE);
break;
#if MQX_HAS_TICK
case MQX_API_LWSEM_WAIT_FOR:
if (MQX_OK == (res = _lwsem_usr_check((LWSEM_STRUCT_PTR)param0)) && (!param1 || _psp_mem_check_access(param1, sizeof(MQX_TICK_STRUCT), MPU_UM_RW)))
res = _lwsem_wait_for((LWSEM_STRUCT_PTR)param0, (MQX_TICK_STRUCT_PTR)param1);
break;
case MQX_API_LWSEM_WAIT_TICKS:
if (MQX_OK == (res = _lwsem_usr_check((LWSEM_STRUCT_PTR)param0)))
res = _lwsem_wait_ticks((LWSEM_STRUCT_PTR)param0, (_mqx_uint)param1);
break;
case MQX_API_LWSEM_WAIT_UNTIL:
if (MQX_OK == (res = _lwsem_usr_check((LWSEM_STRUCT_PTR)param0)) && (!param1 || _psp_mem_check_access(param1, sizeof(MQX_TICK_STRUCT), MPU_UM_RW)))
res = _lwsem_wait_until((LWSEM_STRUCT_PTR)param0, (MQX_TICK_STRUCT_PTR)param1);
break;
case MQX_API_LWSEM_DESTROY:
if (MQX_OK == (res = _lwsem_usr_check((LWSEM_STRUCT_PTR)param0))) {
res = _lwsem_destroy_internal((LWSEM_STRUCT_PTR)param0, TRUE);
}
break;
#endif // MQX_HAS_TICK
// _lwevent
#if MQX_USE_LWEVENTS
case MQX_API_LWEVENT_CLEAR:
if (MQX_OK == (res = _lwevent_usr_check((LWEVENT_STRUCT_PTR)param0)))
res = _lwevent_clear((LWEVENT_STRUCT_PTR)param0, (_mqx_uint)param1);
break;
case MQX_API_LWEVENT_SET:
if (MQX_OK == (res = _lwevent_usr_check((LWEVENT_STRUCT_PTR)param0)))
res = _lwevent_set((LWEVENT_STRUCT_PTR)param0, (_mqx_uint)param1);
break;
case MQX_API_LWEVENT_SET_AUTO_CLEAR:
if (MQX_OK == (res = _lwevent_usr_check((LWEVENT_STRUCT_PTR)param0)))
res = _lwevent_set_auto_clear((LWEVENT_STRUCT_PTR)param0, (_mqx_uint)param1);
break;
case MQX_API_LWEVENT_WAIT_FOR:
if (MQX_OK == (res = _lwevent_usr_check((LWEVENT_STRUCT_PTR)param0)) && \
(!param3 || _psp_mem_check_access(param3, sizeof(MQX_TICK_STRUCT), MPU_UM_RW))) {
res = _lwevent_wait_for((LWEVENT_STRUCT_PTR)param0, (_mqx_uint)param1, (bool)param2, (MQX_TICK_STRUCT_PTR)param3);
}
break;
case MQX_API_LWEVENT_WAIT_FOR_TICKS:
if (MQX_OK == (res = _lwevent_usr_check((LWEVENT_STRUCT_PTR)param0))) {
res = _lwevent_wait_ticks((LWEVENT_STRUCT_PTR)param0, (_mqx_uint)param1, (bool)param2, (_mqx_uint)param3);
}
break;
case MQX_API_LWEVENT_WAIT_UNTIL:
if (MQX_OK == (res = _lwevent_usr_check((LWEVENT_STRUCT_PTR)param0)) && \
(!param3 || _psp_mem_check_access(param3, sizeof(MQX_TICK_STRUCT), MPU_UM_RW))) {
res = _lwevent_wait_until((LWEVENT_STRUCT_PTR)param0, (_mqx_uint)param1, (bool)param2, (MQX_TICK_STRUCT_PTR)param3);
}
break;
case MQX_API_LWEVENT_GET_SIGNALLED:
res = _lwevent_get_signalled();
break;
case MQX_API_LWEVENT_CREATE:
res = _lwevent_create_internal((LWEVENT_STRUCT_PTR)param0, (_mqx_uint)param1, TRUE);
break;
case MQX_API_LWEVENT_DESTROY:
if (MQX_OK == (res = _lwevent_usr_check((LWEVENT_STRUCT_PTR)param0))) {
res = _lwevent_destroy_internal((LWEVENT_STRUCT_PTR)param0, TRUE);
}
break;
#endif
#if MQX_USE_LWMSGQ
case MQX_API_LWMSGQ_INIT:
res = _lwmsgq_init_internal((void *)param0, (_mqx_uint)param1, (_mqx_uint)param2, TRUE);
break;
case MQX_API_LWMSGQ_RECEIVE:
if (MQX_OK == (res = _lwmsgq_usr_check((LWMSGQ_STRUCT_PTR)param0)) && \
_psp_mem_check_access(param1, ((LWMSGQ_STRUCT_PTR)param0)->MSG_SIZE, MPU_UM_RW) && \
(!param4 || _psp_mem_check_access(param4, sizeof(MQX_TICK_STRUCT), MPU_UM_RW)))
res = _lwmsgq_receive((void *)param0, (_mqx_max_type_ptr)param1, (_mqx_uint)param2, (_mqx_uint)param3, (MQX_TICK_STRUCT_PTR)param4);
break;
case MQX_API_LWMSGQ_SEND:
if (MQX_OK == (res = _lwmsgq_usr_check((LWMSGQ_STRUCT_PTR)param0)) && \
_psp_mem_check_access(param1, ((LWMSGQ_STRUCT_PTR)param0)->MSG_SIZE, MPU_UM_RW))
res = _lwmsgq_send((void *)param0, (_mqx_max_type_ptr)param1, (_mqx_uint)param2);
break;
#endif // MQX_USE_LWMSGQ
case MQX_API_TASK_CREATE:
res = _task_create_internal((_processor_number)param0, (_mqx_uint)param1, (uint32_t)param2, TRUE);
break;
case MQX_API_TASK_DESTROY:
res = _task_destroy_internal((_task_id)param0, TRUE);
break;
case MQX_API_TASK_ABORT:
res = _task_abort_internal((_task_id)param0, TRUE);
break;
case MQX_API_TASK_READY:
_task_ready((void *)param0);
res = MQX_OK; // irelevant, function is without return value
break;
case MQX_API_TASK_SET_ERROR:
res = _task_set_error((_mqx_uint)param0);
break;
case MQX_API_TASK_GET_TD:
res = (uint32_t)_task_get_td((_task_id)param0);
break;
#if MQX_USE_LWMEM
case MQX_API_LWMEM_ALLOC:
res = (uint32_t)_usr_lwmem_alloc_internal((_mem_size)param0);
break;
case MQX_API_LWMEM_ALLOC_FROM:
if (_psp_mem_check_access(param0, sizeof(LWMEM_POOL_STRUCT), MPU_UM_RW) && \
_psp_mem_check_access((uint32_t)(((LWMEM_POOL_STRUCT_PTR)param0)->POOL_ALLOC_START_PTR), (char*)(((LWMEM_POOL_STRUCT_PTR)param0)->POOL_ALLOC_END_PTR) - (char*)(((LWMEM_POOL_STRUCT_PTR)param0)->POOL_ALLOC_START_PTR), MPU_UM_RW))
res = (uint32_t)_lwmem_alloc_from((_lwmem_pool_id)param0, (_mem_size)param1);
else
res = 0; // NULL, allocation failed
break;
case MQX_API_LWMEM_FREE:
if (_psp_mem_check_access(param0, 4, MPU_UM_RW))
res = _lwmem_free((void *)param0);
break;
case MQX_API_LWMEM_CREATE_POOL:\
if (_psp_mem_check_access(param0, sizeof(LWMEM_POOL_STRUCT), MPU_UM_RW) && \
_psp_mem_check_access(param1, param2, MPU_UM_RW))
res = (uint32_t)_lwmem_create_pool((LWMEM_POOL_STRUCT_PTR)param0, (void *)param1, (_mem_size)param2);
break;
case MQX_API_LWMEM_REALLOC:
if (_psp_mem_check_access(param0, 4, MPU_UM_RW))
res = (uint32_t)_lwmem_realloc((void *)param0,(_mem_size)param1);
break;
#endif // MQX_USE_LWMEM
// _time
case MQX_API_TIME_DELAY:
_time_delay(param0);
res = MQX_OK; // irelevant, function is without return value
break;
#if MQX_HAS_TICK
case MQX_API_TIME_DELAY_TICKS:
_time_delay_ticks(param0);
res = MQX_OK; // irelevant, function is without return value
break;
case MQX_API_TIME_GET_ELAPSED_TICKS:
if (_psp_mem_check_access(param0, sizeof(MQX_TICK_STRUCT), MPU_UM_RW)) {
_time_get_elapsed_ticks((MQX_TICK_STRUCT_PTR)param0);
res = MQX_OK; // irelevant, function is without return value
}
else {
_task_set_error(MQX_ACCESS_ERROR);
}
break;
#endif // MQX_HAS_TICK
default:
while (1);
}
return res;
}
void remote_com_app(pointer rcom_msg_queue, pointer controller_msg_queue,
sync_buffer_t *rcom_to_controller_sync_buffer) {
SWM_msg_t msg;
if (_lwmsgq_receive(rcom_msg_queue, (_mqx_max_type_ptr) &msg,
LWMSGQ_RECEIVE_BLOCK_ON_EMPTY, 0, NULL ) != MQX_OK) {
DEBUG("ERR: receive msg failed\n");
}
char *result = NULL;
char *rcom_to_controller_buffer = NULL;
switch (msg.cmd) {
case RCOM_START_CMD:
DEBUG("RCOM starting...\n");
if (!sim900_start()) {
DEBUG("\tERR: SIM start failed\n");
msg.result_type = FAIL;
_lwmsgq_send(controller_msg_queue, (_mqx_max_type_ptr) &msg, 0);
return;
}
msg.result_type = SUCCESS;
_lwmsgq_send(controller_msg_queue, (_mqx_max_type_ptr) &msg, 0);
break;
case RCOM_STOP_CMD:
DEBUG("RCOM stoping...\n");
sim900_stop();
break;
case RCOM_CONFIGURE_CMD:
DEBUG("RCOM configuring...\n");
if (!sim900_default_config()) {
DEBUG("\tERR: SIM configuration failed\n");
msg.result_type = FAIL;
_lwmsgq_send(controller_msg_queue, (_mqx_max_type_ptr) &msg, 0);
return;
}
DEBUG("RCOM checking SIM inserted...\n");
if (!sim900_check_SIM_inserted()) {
DEBUG("\tERR: SIM removed\n");
msg.result_type = FAIL;
_lwmsgq_send(controller_msg_queue, (_mqx_max_type_ptr) &msg, 0);
return;
}
DEBUG("RCOM setting APN auto-ly...\n");
if (!set_APN_auto()) {
DEBUG("\tERR: Can't set APN\n");
msg.result_type = FAIL;
_lwmsgq_send(controller_msg_queue, (_mqx_max_type_ptr) &msg, 0);
return;
}
msg.result_type = SUCCESS;
_lwmsgq_send(controller_msg_queue, (_mqx_max_type_ptr) &msg, 0);
break;
case RCOM_CONNECT_INTERNET_CMD:
DEBUG("RCOM connecting internet...\n");
if (!sim900_connect_internet()) {
DEBUG("\tERR: Can't connect internet\n");
msg.result_type = FAIL;
_lwmsgq_send(controller_msg_queue, (_mqx_max_type_ptr) &msg, 0);
return;
}
msg.result_type = SUCCESS;
_lwmsgq_send(controller_msg_queue, (_mqx_max_type_ptr) &msg, 0);
break;
case RCOM_SEND_SMS_MSG_CMD:
DEBUG("RCOM sending SMS msg...\n");
// sim900_send_sms("0947380243", "nvhien");
break;
case RCOM_HAVE_SMS_MSG_CMD:
DEBUG("RCOM reading SMS msg...\n");
result = sim900_read_SMS_msg(msg.content.value);
rcom_to_controller_buffer = (char*) sync_buffer_get_resource_to_write(
rcom_to_controller_sync_buffer);
SIM900_SMS_msg_t sms_msg;
sms_msg.phone_number = rcom_to_controller_buffer
+ sizeof(SIM900_SMS_msg_t);
sim900_get_phone_number_from_SMS_msg(result, sms_msg.phone_number);
sim900_normalize_phone_number(sms_msg.phone_number, VN_phone_code);
sms_msg.content = sms_msg.phone_number + strlen(sms_msg.phone_number)
+ 1;
sim900_get_content_from_SMS_msg(result, sms_msg.content);
memcpy(rcom_to_controller_buffer, (void*) &sms_msg,
sizeof(SIM900_SMS_msg_t));
sync_buffer_allow_read(rcom_to_controller_sync_buffer);
msg.result_type = SUCCESS;
msg.content.ptr = (void*) rcom_to_controller_sync_buffer;
_lwmsgq_send(controller_msg_queue, (_mqx_max_type_ptr) &msg, 0);
break;
case RCOM_MAKE_MISSED_CALL_CMD:
DEBUG("RCOM making missed voice call...\n");
// sim900_make_missed_voice_call(buffer);
break;
case RCOM_REPORT_DATA_CMD:
break;
case RCOM_UPDATE_DATA_CMD:
break;
case RCOM_POLL_COMMAND_CMD:
break;
case RCOM_GET_TIMESTAMP_CMD:
DEBUG("RCOM getting timestamp...\n");
result = sim900_HTTP_GET(URL_time_stamp);
if (!result) {
msg.result_type = FAIL;
_lwmsgq_send(controller_msg_queue, (_mqx_max_type_ptr) &msg, 0);
return;
}
sync_buffer_write(rcom_to_controller_sync_buffer, (uint8_t*) result,
strlen(result) + 1);
sync_buffer_allow_read(rcom_to_controller_sync_buffer);
msg.result_type = SUCCESS;
msg.content.ptr = (void*) rcom_to_controller_sync_buffer;
_lwmsgq_send(controller_msg_queue, (_mqx_max_type_ptr) &msg, 0);
break;
default:
break;
}
return;
}
/*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");
}
}
}
