void usb_host_hid_mouse_recv_callback ( /* [IN] pointer to pipe */ _usb_pipe_handle pipe_handle, /* [IN] user-defined parameter */ void *user_parm, /* [IN] buffer address */ unsigned char *buffer, /* [IN] length of data transferred */ uint32_t buflen, /* [IN] status, hopefully USB_OK or USB_DONE */ USB_STATUS status ) { /* Body */ if (status == USB_OK) { /* notify application that data are available */ _lwevent_set(&USB_Mouse_Event, USB_EVENT_DATA); } else { /* notify application that data are available */ _lwevent_set(&USB_Mouse_Event, USB_EVENT_DATA_CORRUPTED); } }
void switch_poll(void) { /* Read pin status to switches list */ if (IO_OK != ioctl(file_switches, GPIO_IOCTL_READ, (char_ptr) &switches)) { _task_block(); } /* Test if SW1 was pressed */ if (((switches[SW1] & GPIO_PIN_STATUS) == 0)) { if ((switch_state & IO_SW1_MASK) == 0) { switch_state |= IO_SW1_MASK; _lwevent_set(&meter_shared_event, IO_SW1_MASK); } } else { switch_state &= ~IO_SW1_MASK; } /* Test if SW2 was pressed */ if (((switches[SW2] & GPIO_PIN_STATUS) == 0)) { if ((switch_state & IO_SW2_MASK) == 0) { switch_state |= IO_SW2_MASK; /* Set SW2 click mask */ _lwevent_set(&meter_shared_event, IO_SW2_MASK); } } else { switch_state &= ~IO_SW2_MASK; } /* Test if SW3 was pressed */ if (((switches[SW3] & GPIO_PIN_STATUS) == 0)) { if ((switch_state & IO_SW3_MASK) == 0) { switch_state |= IO_SW3_MASK; /* Set SW2 click mask */ _lwevent_set(&meter_shared_event, IO_SW3_MASK); } } else { switch_state &= ~IO_SW3_MASK; } /* Test if SW4 was pressed */ if (((switches[SW4] & GPIO_PIN_STATUS) == 0)) { if ((switch_state & IO_SW4_MASK) == 0) { switch_state |= IO_SW4_MASK; /* Set SW2 click mask */ _lwevent_set(&meter_shared_event, IO_SW4_MASK); } } else { switch_state &= ~IO_SW4_MASK; } }
static void my_interrupt (pointer rtc_registers_ptr) { state = _rtc_get_status (); if( state & RTC_RTCISR_SW) { _lwevent_set(&lwevent,LWE_STOPWATCH); } if( state & RTC_RTCISR_ALM) { _lwevent_set(&lwevent,LWE_ALARM); } _rtc_clear_requests (state); }
// sensor read task void RdSensData_task(uint32_t task_init_data) { // initialize the physical sensors over I2C and the sensor data structures RdSensData_Init(); // initialize the user high frequency (typically 200Hz) task UserHighFrequencyTaskInit(); // loop indefinitely (typically 200Hz) while(1) { // wait here for the sampling event (hardware clock, typically at 200Hz) // the Kalman filter and magnetic fusion tasks execute while this task is blocked here // FALSE means any bit (of the 1 bit enabled by the mask) unblocks // and NULL means timeout is infinite _lwevent_wait_for(&(mqxglobals.SamplingEventStruct), 1, FALSE, NULL); // reset the Kalman filter task flag mqxglobals.RunKF_Event_Flag = 0; // read the sensors RdSensData_Run(); // run the user high frequency task UserHighFrequencyTaskRun(); // use the Kalman filter flag set by the sensor read task (typically every 8 iterations) // with a mask of 1 (least significant bit set) to enable the Kalman filter task to run if (mqxglobals.RunKF_Event_Flag) _lwevent_set(&(mqxglobals.RunKFEventStruct), 1); } // end of infinite loop }
void usb_host_hid_mouse_ctrl_callback ( /* [IN] pointer to pipe */ _usb_pipe_handle pipe_handle, /* [IN] user-defined parameter */ void *user_parm, /* [IN] buffer address */ unsigned char *buffer, /* [IN] length of data transferred */ uint32_t buflen, /* [IN] status, hopefully USB_OK or USB_DONE */ uint32_t status ) { /* Body */ if (status == USBERR_ENDPOINT_STALLED) { printf("\nHID Set_Protocol Request BOOT is not supported!\n"); fflush(stdout); } else if (status) { printf("\nHID Set_Protocol Request BOOT failed!: 0x%x ... END!\n", status); fflush(stdout); } /* Endif */ if(mouse_hid_device.DEV_STATE == USB_DEVICE_SETTING_PROTOCOL) mouse_hid_device.DEV_STATE = USB_DEVICE_INUSE; /* notify application that status has changed */ _lwevent_set(&USB_Mouse_Event, USB_EVENT_CTRL); } /* Endbody */
void usb_host_hid_ctrl_callback( /* [IN] pointer to pipe */ _usb_pipe_handle pipe_handle, /* [IN] user-defined parameter */ pointer user_parm, /* [IN] buffer address */ uchar_ptr buffer, /* [IN] length of data transferred */ uint_32 buflen, /* [IN] status, hopefully USB_OK or USB_DONE */ USB_STATUS status ) { if(status == USBERR_ENDPOINT_STALLED) { printf("\nHID Set_Protocol Request BOOT is not supported!\n"); fflush(stdout); } else if(status) { printf("\nHID Set_Protocol Request BOOT failed!: 0x%x ... END!\n", status); fflush(stdout); _task_block(); } if(hid_device.DEV_STATE == USB_DEVICE_SETTING_PROTOCOL) hid_device.DEV_STATE = USB_DEVICE_INUSE; /* notify application that status has changed */ _lwevent_set(&USB_Event, USB_EVENT_CTRL); }
/****************************************************************************** * @name process_play_button * * @brief process play button * * @return None * * @comment * *******************************************************************************/ static void process_play_button(void) { if(USB_DEVICE_INTERFACED == audio_stream.DEV_STATE) { play = 1 - play; /* play */ if (TRUE == play) { printf("Playing ...\n"); _lwevent_set(&USB_Event, USB_EVENT_RECEIVED_DATA); #if (defined BSP_TWRMCF51JE) || (defined BSP_TWRMCF51MM)||(defined BSP_MCF51JMEVB) EnableCmtInterrupt(); #elif (defined BSP_TWRMCF51JF) EnableFTM0Interrupt(); #else _audio_timer_unmask_int(BSP_LAST_TIMER); #endif } /* stop */ else { printf("\nPaused.\n"); #if (defined BSP_TWRMCF51JE) || (defined BSP_TWRMCF51MM)||(defined BSP_MCF51JMEVB) DisableCmtInterrupt(); #elif (defined BSP_TWRMCF51JF) DisableFTM0Interrupt(); #else _audio_timer_mask_int(BSP_LAST_TIMER); #endif } } }
/* ===================================================================*/ void TU1_OnCounterRestart(LDD_TUserData *UserDataPtr) { /* Write your code here ... */ time_count++; if (time_count == TIME_TO_SEND) { time_count = 0; _lwevent_set(&an_event, EVT_BIT_MASK); } }
void EXT_SDDETECT_ISR(void *pin) { int sd_pin; boolean inserted; // if(sd_pin = lwgpio_int_get_flag((LWGPIO_STRUCT_PTR) pin)) { inserted = !lwgpio_get_value((LWGPIO_STRUCT_PTR) pin); // printf("sd detect pin changed %d,insert state %d,cur_musicPlayMS %d\n",sd_pin,inserted,cur_musicPlayMS); //if(cur_musicPlayMS != mp_sBT) { if(inserted) _lwevent_set(&sddetect_event,SD_ATTACHED_EVENT); else _lwevent_set(&sddetect_event,SD_DETTACHED_EVENT); //} lwgpio_int_clear_flag((LWGPIO_STRUCT_PTR) pin); // } }
void usb_host_hid_keyboard_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) { INTERFACE_DESCRIPTOR_PTR intf_ptr = (INTERFACE_DESCRIPTOR_PTR) intf_handle; fflush(stdout); switch (event_code) { case USB_ATTACH_EVENT: printf("----- Attach Event -----\n"); /* Drop through config event for the same processing */ case USB_CONFIG_EVENT: printf("State = %d", hid_device.DEV_STATE); printf(" Class = %d", intf_ptr->bInterfaceClass); printf(" SubClass = %d", intf_ptr->bInterfaceSubClass); printf(" Protocol = %d\n", intf_ptr->bInterfaceProtocol); fflush(stdout); if(hid_device.DEV_STATE == USB_DEVICE_IDLE) { hid_device.DEV_HANDLE = dev_handle; hid_device.INTF_HANDLE = intf_handle; hid_device.DEV_STATE = USB_DEVICE_ATTACHED; } else { printf("HID device already attached\n"); fflush(stdout); } break; case USB_INTF_EVENT: printf("----- Interfaced Event -----\n"); hid_device.DEV_STATE = USB_DEVICE_INTERFACED; break; case USB_DETACH_EVENT: /* Use only the interface with desired protocol */ printf("\n----- Detach Event -----\n"); printf("State = %d", hid_device.DEV_STATE); printf(" Class = %d", intf_ptr->bInterfaceClass); printf(" SubClass = %d", intf_ptr->bInterfaceSubClass); printf(" Protocol = %d\n", intf_ptr->bInterfaceProtocol); fflush(stdout); hid_device.DEV_HANDLE = NULL; hid_device.INTF_HANDLE = NULL; hid_device.DEV_STATE = USB_DEVICE_DETACHED; break; } /* notify application that status has changed */ _lwevent_set(&USB_Event, USB_EVENT_CTRL); }
static void button_isr ( void *pin ) { lwgpio_toggle_value (&led1); lwgpio_int_clear_flag (pin); _lwevent_set (&app_event, SW_EVENT_MASK); }
uint32_t OS_Event_set(os_event_handle handle, uint32_t bitmask) { LWEVENT_STRUCT *event = (LWEVENT_STRUCT*)handle; if (_lwevent_set(event, bitmask) != MQX_OK) { return (uint32_t)OS_EVENT_ERROR; } return (uint32_t)OS_EVENT_OK; }
void usb_class_audio_control_init ( /* [IN] structure with USB pipe information on the interface */ PIPE_BUNDLE_STRUCT_PTR pbs_ptr, /* [IN] audio call struct pointer */ CLASS_CALL_STRUCT_PTR ccs_ptr ) { /* Body */ AUDIO_CONTROL_INTERFACE_STRUCT_PTR if_ptr = ccs_ptr->class_intf_handle; USB_STATUS status; #ifdef _HOST_DEBUG_ DEBUG_LOG_TRACE("usb_class_audio_control_init"); #endif /* Make sure the device is still attached */ USB_lock(); status = usb_host_class_intf_init(pbs_ptr, if_ptr, &audio_control_anchor); if (status == USB_OK) { /* ** We generate a code_key based on the attached device. This is used to ** verify that the device has not been detached and replaced with another. */ ccs_ptr->code_key = 0; ccs_ptr->code_key = usb_host_class_intf_validate(ccs_ptr); if_ptr->AUDIO_G.IFNUM = ((INTERFACE_DESCRIPTOR_PTR)if_ptr->AUDIO_G.G.intf_handle)->bInterfaceNumber; if_ptr->interrupt_pipe = usb_hostdev_get_pipe_handle(pbs_ptr, USB_INTERRUPT_PIPE, 0); if (MQX_OK != (status = _lwevent_create(&if_ptr->control_event, 0))) { status = USBERR_INIT_FAILED; } else { /* prepare events to be auto or manual */ _lwevent_set_auto_clear(&if_ptr->control_event, USB_AUDIO_CTRL_PIPE_FREE | USB_AUDIO_CTRL_INT_PIPE_FREE); /* pre-set events */ _lwevent_set(&if_ptr->control_event, USB_AUDIO_CTRL_PIPE_FREE | USB_AUDIO_CTRL_INT_PIPE_FREE); } } /* Endif */ /* Signal that an error has occured by setting the "code_key" */ if (status) { ccs_ptr->code_key = 0; } /* Endif */ USB_unlock(); #ifdef _HOST_DEBUG_ if (status) DEBUG_LOG_TRACE("usb_class_audio_control_init, SUCCESSFUL"); else DEBUG_LOG_TRACE("usb_class_audio_control_init, FAILED"); #endif } /* Endbody */
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 ) { INTERFACE_DESCRIPTOR_PTR intf_ptr = (INTERFACE_DESCRIPTOR_PTR)intf_handle; switch (event_code) { case USB_CONFIG_EVENT: /* Drop through into attach, same processing */ case USB_ATTACH_EVENT: if (device.STATE == USB_DEVICE_IDLE || device.STATE == USB_DEVICE_DETACHED) { device.DEV_HANDLE = dev_handle; device.INTF_HANDLE = intf_handle; device.STATE = USB_DEVICE_ATTACHED; device.SUPPORTED = TRUE; _lwevent_set(&USB_Event,USB_EVENT); } break; case USB_INTF_EVENT: device.STATE = USB_DEVICE_INTERFACED; break; case USB_DETACH_EVENT: device.DEV_HANDLE = NULL; device.INTF_HANDLE = NULL; device.STATE = USB_DEVICE_DETACHED; _lwevent_set(&USB_Event,USB_EVENT); break; default: device.STATE = USB_DEVICE_IDLE; break; } }
// Kalman filter sensor fusion task void Fusion_task(uint32_t task_init_data) { uint16_t LedGreenCounter = 0; // initialize the sensor fusion algorithms Fusion_Init(); // initialize the user medium frequency (typically 25Hz) task UserMediumFrequencyTaskInit(); // infinite loop controlled by MQX-Lite events while(1) { // ensure the red LED (power up check) is off (line high) LED_RED_SetVal(NULL); // set the output test pin to zero (for timing measurements) TestPin_KF_Time_ClrVal(NULL); // wait for the sensor fusion event to occur // FALSE means any bit (of the 1 bit enabled by the mask) unblocks // and NULL means timeout is infinite _lwevent_wait_for(&(mqxglobals.RunKFEventStruct), 1, FALSE, NULL); // set the output test pin to high to denote sensor fusion running TestPin_KF_Time_SetVal(NULL); // flash the green LED to denote the sensor fusion is running if (++LedGreenCounter >= 5) { LED_GREEN_NegVal(NULL); LedGreenCounter = 0; } // reset the magnetic calibration flag (this is set by the fusion algorithm) mqxglobals.MagCal_Event_Flag = 0; // call the sensor fusion algorithms Fusion_Run(); // run the user medium frequency (typically 25Hz) user task UserMediumFrequencyTaskRun(); // enable the magnetic calibration event if the flag for a new magnetic calibration // with a mask of 1 (least significant bit set) // was set by the sensor fusion algorithms if (mqxglobals.MagCal_Event_Flag) { _lwevent_set(&(mqxglobals.MagCalEventStruct), 1); } } // end of infinite loop return; }
void button_task ( uint32_t initial_data ) { LWGPIO_STRUCT button; LWGPIO_VALUE button_state = LWGPIO_VALUE_HIGH; uint32_t button_integrator = BUTTON_INTEGRATOR_MAXIMUM; /* set the pin to input */ if (!lwgpio_init(&button, BSP_BUTTON2, LWGPIO_DIR_INPUT, LWGPIO_VALUE_NOCHANGE)) { /* Button initialization failed. */ _task_block(); } /* Set multiplexer to GPIO functionality */ lwgpio_set_functionality(&button, BSP_SW2_MUX_GPIO); /* Enable pull up */ lwgpio_set_attribute(&button, LWGPIO_ATTR_PULL_UP, LWGPIO_AVAL_ENABLE); while(1) { /* Update the integrator based on the input signal. */ if (LWGPIO_VALUE_LOW == lwgpio_get_value(&button)) { if (button_integrator > 0) { button_integrator--; } } else if (button_integrator < BUTTON_INTEGRATOR_MAXIMUM) { button_integrator++; } /* Defensive code if integrator got corrupted */ if (button_integrator > BUTTON_INTEGRATOR_MAXIMUM) button_integrator = BUTTON_INTEGRATOR_MAXIMUM; /* Post event if integrator reaches limit */ if ((button_integrator == 0) ) { if (button_state == LWGPIO_VALUE_LOW) { button_state = LWGPIO_VALUE_HIGH; _lwevent_set(&app_event, SW_EVENT_MASK); } } else { button_state = LWGPIO_VALUE_LOW; } _time_delay(BUTTON_SAMPLE_PERIOD_MS); } }
static int usb_host_aoa_in_tr_callback #else static void usb_host_aoa_in_tr_callback #endif ( /* device to host */ /* [IN] pointer to pipe */ _usb_pipe_handle pipe_handle, /* [IN] user-defined parameter */ void * user_parm, /* [IN] buffer address */ unsigned char * buffer, /* [IN] length of data transferred */ uint32_t buflen, /* [IN] status, hopefully USB_OK or USB_DONE */ uint32_t status ) { struct _usb_accessoy_host_info_ * acc_host_info = (struct _usb_accessoy_host_info_ *)user_parm; #ifdef ACCESSORY_PRINTF printf("receive status=%d, buff len %d\n",status,buflen); #endif if(status == USB_OK) { acc_host_info->received_size = buflen; _lwevent_set(&(acc_host_info->acc_event),USBH_AOA_RECV_COMP_EVENT); } else { acc_host_info->received_size = 0; _lwevent_set(&(acc_host_info->acc_event),USBH_AOA_RECV_FAIL_EVENT); } #ifdef TR_CALLBACK_COMPLETE return TR_CALLBACK_COMPLETE; #endif }
void simulated_ISR_task ( uint_32 initial_data ) { while (TRUE) { _time_delay_ticks(200); if (_lwevent_set(&lwevent,0x01) != MQX_OK) { printf("\nSet Event failed"); _task_block(); } } }
static void timer_wakeup_isr ( void *parameter ) { /* Stop the timer */ hwtimer_stop(&lpttimer); /* Do not return to sleep after isr again */ _lpm_wakeup_core (); /* Signal the timer event */ _lwevent_set (&app_event, TIMER_EVENT_MASK); }
void FTM_OnCounterRestart(LDD_TUserData *UserDataPtr) { // this function is called (typically at 200Hz) by the hardware clock interrupt and drives the sensor // read function and indirectly the fusion and magnetic calibration functions which // are software locked to the sensor read process // always enable the sensor read task // update time stamp counter mqxglobals.FTMTimestamp += (uint32)mqxglobals.FTMReload; // enable the (typically 200Hz) sensor read event FSL_SAMPLING_EVENT // with a mask of 1 (least significant bit set) _lwevent_set(&(mqxglobals.SamplingEventStruct), 1); return; }
void usb_host_hid_recv_callback( /* [IN] pointer to pipe */ _usb_pipe_handle pipe_handle, /* [IN] user-defined parameter */ pointer user_parm, /* [IN] buffer address */ uchar_ptr buffer, /* [IN] length of data transferred */ uint_32 buflen, /* [IN] status, hopefully USB_OK or USB_DONE */ USB_STATUS status ) { /* notify application that data are available */ _lwevent_set(&USB_Event, USB_EVENT_DATA); }
/*TASK--------------------------------------------------------------- * * Task Name : LWEventA * Comments : * *END*--------------------------------------------------------------*/ void LWEventA ( uint32_t parameter ) { _mqx_uint event_result; while ( TRUE ) { /* set lwevent bit */ event_result = _lwevent_set(&lwevent, 1); if (event_result != MQX_OK) { /* setting the event event.Event1 failed */ } /* endif */ _time_delay_ticks(1); } }
static void my_rtc_isr ( pointer rtc_registers_ptr ) { uint_32 state = _rtc_get_status (); if (state & RTC_RTCISR_ALM) { /* Do not return to sleep after isr again */ _lpm_wakeup_core (); _lwevent_set(&app_event, RTC_EVENT_MASK); } _rtc_clear_requests (state); }
void int_service_routine_btn_pause(void *pin) //SW1 { lwgpio_int_clear_flag((LWGPIO_STRUCT_PTR) pin); pause_trigger = !pause_trigger; if(TRUE == pause_trigger) //pause a song { if((mp_sMicroSDplay == cur_musicPlayMS)||(mp_sMSDplay == cur_musicPlayMS)) { _lwevent_clear(&player_event, PLAYER_EVENT_MSK_SONG_RESUME); } else if(mp_sAccessory == cur_musicPlayMS) { //AccessoryPausePlay(); AccessroyHidEvent |= ACCPAUSEPLAY; } else if(mp_sBT == cur_musicPlayMS) { BtAVRCPEvent |= ACCPAUSEPLAY; } printf("Paused\n"); } else //resume a song { if((mp_sMicroSDplay == cur_musicPlayMS)||(mp_sMSDplay == cur_musicPlayMS)) { _lwevent_set(&player_event, PLAYER_EVENT_MSK_SONG_RESUME); } else if(mp_sAccessory == cur_musicPlayMS) { //AccessoryResumePlay(); AccessroyHidEvent |= ACCRESUMEPLAY; } else if(mp_sBT == cur_musicPlayMS) { BtAVRCPEvent |= ACCRESUMEPLAY; } printf("Resume\n"); } //decoding = FALSE; //printf("SW1 pressed. %d \n", trigger); }
void LWEventA ( uint_32 parameter ) { _mqx_uint event_result; /* ** LOOP - */ while ( TRUE ) { /* set lwevent bit */ event_result = _lwevent_set(&lwevent, 1); if (event_result != MQX_OK) { /* setting the event event.Event1 failed */ } /* endif */ _time_delay_ticks(1); } /* endwhile */ } /*end of task*/
int usb_try_accessory_callback #else void usb_try_accessory_callback #endif ( /* [IN] pointer to pipe */ _usb_pipe_handle pipe_handle, /* [IN] user-defined parameter */ void * user_parm, /* [IN] buffer address */ unsigned char * buffer, /* [IN] length of data transferred */ uint32_t length_data_transfered, /* [IN] status, hopefully USB_OK or USB_DONE */ USB_STATUS status ) { /* Body */ struct _usb_accessoy_host_info_ * acc_host_info = (struct _usb_accessoy_host_info_ *)user_parm; if(status == USB_OK) { _lwevent_set(&(acc_host_info->acc_event), USBH_TRY_AOA_CALLBACK_EVENT); acc_host_info->try_acc_status++; // this function will be called by accessory hid . printf("try accessory callback ok\n"); } else printf("try accessory callback fail\n"); #if 1 if(acc_host_info->try_acc_status >= WAITING_ACCESSORY) { LWGPIO_STRUCT vbus; init_set_vbus_low(&vbus); delay_set_vbus_high(&vbus); } #endif #ifdef TR_CALLBACK_COMPLETE return TR_CALLBACK_COMPLETE; #endif }
void int_service_routine_btn_stop(void *pin) //SW2 { lwgpio_int_clear_flag((LWGPIO_STRUCT_PTR) pin); #if 0 //_lwevent_set(&player_event, PLAYER_EVENT_MSK_PREV_BTN_PRESSED); if(TRUE == trigger) _lwevent_set(&player_event, PLAYER_EVENT_MSK_SONG_RESUME); //if pause a song, resume firstly decoding = FALSE; #endif if ((ModeSwitchEvent & MODESWITCH) == 0) ModeSwitchEvent |= MODESWITCH; printf("Auto\n"); //printf("SW2 pressed.\n"); }
static void SAMPLE_TIMER_ISR(void * p) { VQPIT_REG_STRUCT_PTR qpit_ptr = sample_qpit_ptr; qpit_ptr->TIMERS[SAMPLE_PIT_CH].TFLG |= QPIT_TFLG_TIF; qpit_ptr->TIMERS[SAMPLE_PIT_CH].TCTRL &= (~ QPIT_TCTRL_TIE); // ~(QPIT_TCTRL_TIE|QPIT_TCTRL_TEN) // todo if(WAIT_START_SAMPLE_STATE == sample_state){ // set wait sample stop time sample_timer_set(0, 0,STOP_SAMPLE_TIME_US); sample_state = WAIT_STOP_SAMPLE_STATE; // set event ,could sample adc #ifdef ALWAYS_SAMPLING sample_value = adc_measure_pm2p5(); #else _lwevent_set(&sample_event, 1); #endif } else if (WAIT_STOP_SAMPLE_STATE == sample_state) { sample_timer_set(0, SAMPLE_PERIOD_TIME_MS,SAMPLE_PERIOD_TIME_US); sample_state = WAIT_NEXT_START_STATE; // set led low lwgpio_set_value(&pm2p5_ledgpio, SAMPLE_LED_LOW); sample_value = 0; } else if(WAIT_NEXT_START_STATE == sample_state) { sample_timer_set(0, 0 ,START_SAMPLE_TIME_US); sample_state = WAIT_START_SAMPLE_STATE; // set led high lwgpio_set_value(&pm2p5_ledgpio, SAMPLE_LED_HIGH); //_lwevent_set(&sample_event, 1); } else { printf("error sample state!\n"); } /* Enable PIT interrupt neeed due to errata on Kinetis PIT */ qpit_ptr->TIMERS[SAMPLE_PIT_CH].TCTRL |= QPIT_TCTRL_TIE; }
/*FUNCTION*---------------------------------------------------------------- * * Function Name : usb_class_audio_int_callback * Returned Value : None * Comments : * Called on interrupt endpoint data reception. * *END*--------------------------------------------------------------------*/ static void usb_class_audio_int_callback ( /* [IN] pointer to pipe */ _usb_pipe_handle pipe, /* [IN] user-defined parameter */ void *param, /* [IN] buffer address */ void *buffer, /* [IN] length of data transferred */ uint32_t len, /* [IN] status, hopefully USB_OK or USB_DONE */ uint32_t status ) { /* Body */ CLASS_CALL_STRUCT_PTR audio_instance = (CLASS_CALL_STRUCT_PTR) param; AUDIO_CONTROL_INTERFACE_STRUCT_PTR if_ptr; #ifdef _HOST_DEBUG_ DEBUG_LOG_TRACE("usb_class_audio_int_callback"); #endif if_ptr = (AUDIO_CONTROL_INTERFACE_STRUCT_PTR) audio_instance->class_intf_handle; #ifdef _HOST_DEBUG_ DEBUG_LOG_TRACE("usb_class_audio_int_callback, SUCCESSFUL"); #endif if (NULL!=pipe) { if_ptr->interrupt_callback(pipe,param,buffer,len,status); } usb_class_audio_init_ipipe(audio_instance,if_ptr->interrupt_callback,if_ptr->interrupt_callback_param); _lwevent_set(&USB_Event, USB_EVENT_DATA); } /*EndBody */
int_32 Shell_play(int_32 argc, char_ptr argv[]) { boolean print_usage, shorthelp = FALSE; int_32 return_code = SHELL_EXIT_ERROR; char_ptr c = NULL; print_usage = Shell_check_help_request(argc, argv, &shorthelp); /* Check if help should be printed out */ if (print_usage) { if (shorthelp) { printf("%s <device> <filename>\n", argv[0]); } else { printf("Usage: %s <device> <filename>\n", argv[0]); printf(" device = playback device (i.e. \"sai:\")\n"); printf(" filename = file(mp3/wma/wav) to play\n"); } return (SHELL_EXIT_SUCCESS); } /* Check if there is enough parameters */ if (argc < 3) { printf(" Error: Not enough parameters.\n"); return (SHELL_EXIT_ERROR); } strcpy(full_path, argv[2]); // get the short file name c = argv[2]; while(*c != '\0') c++; while((*c != '\\') && (*c !='/')) c--; c++; // update the current file name for file searching. set_cur_file(c); _lwevent_set(&player_event, PLAYER_EVENT_MSK_SHELL_COMMAND); return (return_code); }