/**
* @brief EXTI line detection callbacks.
* @param GPIO_Pin: Specifies the pins connected EXTI line
* @retval None
*/
void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{
__IO JOYState_TypeDef JoyState = JOY_NONE;
if(GPIO_Pin == MFX_IRQOUT_PIN)
{
/* The different functionalities of MFX (TS, Joystick, SD detection, etc. )
can be configured in exti mode to generate an IRQ on given events.
The MFX IRQ_OUT pin is unique and common to all functionalities, so if several
functionalities are configured in exit mode, the MCU has to enquire MFX about
the IRQ source (see BSP_IO_ITGetStatus). Communication with Mfx is done by I2C.
Often the sw requires ISRs (irq service routines) to be quick while communication
with I2C can be considered relatively long (hundreds of usec depending on I2C clk).
In order to avoid to use "blocking I2C communication" on interrupt service routines
it's suggested (as alternative to this implementation) to use dedicated semaphore*/
/* Get the Joystick State */
JoyState = BSP_JOY_GetState();
HID_DEMO_ProbeKey(JoyState);
switch(JoyState)
{
case JOY_LEFT:
LCD_LOG_ScrollBack();
break;
case JOY_RIGHT:
LCD_LOG_ScrollForward();
break;
default:
break;
}
/* Clear joystick interrupt pending bits */
BSP_IO_ITClear();
osSemaphoreRelease(MenuEvent);
}
}
/**
* @brief Demo state machine.
* @param None
* @retval None
*/
void Menu_Init(void)
{
/* Create Menu Semaphore */
osSemaphoreDef(osSem);
MenuEvent = osSemaphoreCreate(osSemaphore(osSem), 1);
/* Force menu to show Item 0 by default */
osSemaphoreRelease(MenuEvent);
/* Menu task */
#if defined(__GNUC__)
osThreadDef(Menu_Thread, MSC_MenuThread, osPriorityHigh, 0, 8 * configMINIMAL_STACK_SIZE);
#else
osThreadDef(Menu_Thread, MSC_MenuThread, osPriorityHigh, 0, 4 * configMINIMAL_STACK_SIZE);
#endif
osThreadCreate(osThread(Menu_Thread), NULL);
BSP_LCD_SetTextColor(LCD_COLOR_GREEN);
BSP_LCD_DisplayStringAtLine(15, (uint8_t *)"Use [Joystick Left/Right] to scroll up/down");
BSP_LCD_DisplayStringAtLine(16, (uint8_t *)"Use [Joystick Up/Down] to scroll MSC menu");
}
void Thread_Semaphore (void const *argument) {
int32_t val;
while (1) {
; // Insert thread code here...
val = osSemaphoreWait (sid_Thread_Semaphore, 10); // wait 10 mSec
switch (val) {
case osOK:
; // Use protected code here...
osSemaphoreRelease (sid_Thread_Semaphore); // Return a token back to a semaphore
break;
case osErrorResource:
break;
case osErrorParameter:
break;
default:
break;
}
osThreadYield (); // suspend thread
}
}
void threadBaseCode (void const *argument)
{
uint32_t LED_data;
LED_data = (uint32_t) argument;
while(1)
{
//---------------------------------------------------------------------------------
osSemaphoreWait(Mutex,0xffff); //Allow one task at a time to access the first turnstile
count = count+1; // Increment count
if( count == 5) //When last section of code reaches this point run his code
{
osSemaphoreWait (Turnstile2,0xffff); //Lock the second turnstile
osSemaphoreRelease(Turnstile); //Unlock the first turnstile
}
osSemaphoreRelease(Mutex); //Allow other tasks to access the turnstile
osSemaphoreWait(Turnstile,0xFFFF); //Turnstile Gate
osSemaphoreRelease(Turnstile);
//----------------------------------- GATE -----------------------------------
LED_On(LED_data);
osDelay(100); //Critical instructions
LED_Off(LED_data);
osDelay((LED_data*100));
//---------------------------------- GATE ------------------------------------
osSemaphoreWait(Mutex,0xffff); //Allow one task at a time to access the turnstile
count = count - 1;
if(count ==0) //When last section of code reaches this point run his code
{
osSemaphoreWait(Turnstile,0xffff); //Lock the second turnstile
osSemaphoreRelease(Turnstile2); //Unlock the first turnstile
}
osSemaphoreRelease(Mutex); //Allow other tasks to access the turnstile
osSemaphoreWait(Turnstile2,0xffff); //Turnstile Gate
osSemaphoreRelease(Turnstile2);
//------------------------------------------------------------------------------
}
}
void SPI_DMA_xfer(uint8_t* write_buff, uint8_t* read_buff, GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin, int numByte){
// sema will be released in interrupt
osSemaphoreWait(dmaSema_ID, osWaitForever);
//set chip select low
GPIO_ResetBits(GPIOx, GPIO_Pin);
// wait for slave
//while(GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_6) != Bit_RESET);
DMA2_Stream0->M0AR = (uint32_t)(&read_buff[0]);
DMA2_Stream3->M0AR = (uint32_t)(&write_buff[0]);
DMA2_Stream0->NDTR = numByte;
DMA2_Stream3->NDTR = numByte;
osDelay(10);
DMA2_Stream0->CR |= DMA_SxCR_EN;
DMA2_Stream3->CR |= DMA_SxCR_EN;
osSemaphoreWait(dmaComplete_ID, osWaitForever);
GPIO_SetBits(GPIOx, GPIO_Pin);
osSemaphoreRelease(dmaSema_ID);
}
/**
* @brief Semaphore Thread 1 function
* @param argument: shared semaphore
* @retval None
*/
static void SemaphoreThread1(void const *argument)
{
uint32_t count = 0;
osSemaphoreId semaphore = (osSemaphoreId) argument;
for (;;)
{
if (semaphore != NULL)
{
/* Try to obtain the semaphore */
if (osSemaphoreWait(semaphore , 100) == osOK)
{
count = osKernelSysTick() + 5000;
/* Toggle LED2 every 200 ms for 5 seconds */
while (count >= osKernelSysTick())
{
/* Toggle LED3 */
BSP_LED_Toggle(LED3);
/* Delay 200 ms */
osDelay(200);
}
/* Turn off LED3*/
BSP_LED_Off(LED3);
/* Release the semaphore */
osSemaphoreRelease(semaphore);
/* Suspend ourseleves to execute thread 2 (lower priority) */
osThreadSuspend(NULL);
}
}
}
}
/**
* @brief Demo state machine.
* @param None
* @retval None
*/
void Menu_Init(void)
{
/* Create Menu Semaphore */
osSemaphoreDef(osSem);
MenuEvent = osSemaphoreCreate(osSemaphore(osSem), 1);
/* Force menu to show Item 0 by default */
osSemaphoreRelease(MenuEvent);
/* Menu task */
osThreadDef(Menu_Thread, MSC_MenuThread, osPriorityHigh, 0, 8 * configMINIMAL_STACK_SIZE);
osThreadCreate(osThread(Menu_Thread), NULL);
/* Define used semaphore fot Joystick*/
osSemaphoreDef(JOY_SEM);
/* Create the semaphore used by the two threads. */
osJoySemaphore = osSemaphoreCreate(osSemaphore(JOY_SEM) , 1);
BSP_LCD_SetTextColor(LCD_COLOR_GREEN);
BSP_LCD_DisplayStringAtLine(15, (uint8_t *)"Use [Joystick Left/Right] to scroll up/down");
BSP_LCD_DisplayStringAtLine(16, (uint8_t *)"Use [Joystick Up/Down] to scroll MSC menu");
}
/**
* @brief User task
* @param pvParameters not used
* @retval None
*/
void HID_MenuThread(void const *argument)
{
for(;;)
{
if(osSemaphoreWait(MenuEvent , osWaitForever) == osOK)
{
switch(hid_demo.state)
{
case HID_DEMO_IDLE:
HID_SelectItem(DEMO_HID_menu, 0);
hid_demo.state = HID_DEMO_WAIT;
hid_demo.select = 0;
osSemaphoreRelease(MenuEvent);
break;
case HID_DEMO_WAIT:
if(hid_demo.select != prev_select)
{
prev_select = hid_demo.select;
HID_SelectItem(DEMO_HID_menu, hid_demo.select & 0x7F);
/* Handle select item */
if(hid_demo.select & 0x80)
{
switch(hid_demo.select & 0x7F)
{
case 0:
hid_demo.state = HID_DEMO_START;
osSemaphoreRelease(MenuEvent);
break;
case 1:
hid_demo.state = HID_DEMO_REENUMERATE;
osSemaphoreRelease(MenuEvent);
break;
default:
break;
}
}
}
break;
case HID_DEMO_START:
if(Appli_state == APPLICATION_READY)
{
if(USBH_HID_GetDeviceType(&hUSBHost) == HID_KEYBOARD)
{
hid_demo.keyboard_state = HID_KEYBOARD_IDLE;
hid_demo.state = HID_DEMO_KEYBOARD;
}
else if(USBH_HID_GetDeviceType(&hUSBHost) == HID_MOUSE)
{
hid_demo.mouse_state = HID_MOUSE_IDLE;
hid_demo.state = HID_DEMO_MOUSE;
}
}
else
{
LCD_ErrLog("No supported HID device!\n");
hid_demo.state = HID_DEMO_WAIT;
}
osSemaphoreRelease(MenuEvent);
break;
case HID_DEMO_REENUMERATE:
/* Force MSC Device to re-enumerate */
USBH_ReEnumerate(&hUSBHost);
hid_demo.state = HID_DEMO_WAIT;
osSemaphoreRelease(MenuEvent);
break;
case HID_DEMO_MOUSE:
if(Appli_state == APPLICATION_READY)
{
HID_MouseMenuProcess();
USBH_MouseDemo(&hUSBHost);
}
break;
case HID_DEMO_KEYBOARD:
if(Appli_state == APPLICATION_READY)
{
HID_KeyboardMenuProcess();
USBH_KeybdDemo(&hUSBHost);
}
break;
default:
break;
}
if(Appli_state == APPLICATION_DISCONNECT)
{
Appli_state = APPLICATION_IDLE;
LCD_LOG_ClearTextZone();
LCD_ErrLog("HID device disconnected!\n");
hid_demo.state = HID_DEMO_IDLE;
hid_demo.select = 0;
}
hid_demo.select &= 0x7F;
}
}
}
void EventHandlerCAN0()
{
/*
if(CAN001_GetMOFlagStatus(&CAN001_Handle0,1,TRANSMIT_PENDING) == CAN_SET)
{
CAN001_ClearMOFlagStatus(&CAN001_Handle0,1,TRANSMIT_PENDING);
}
if(CAN001_GetMOFlagStatus(&CAN001_Handle0,2,TRANSMIT_PENDING) == CAN_SET)
{
CAN001_ClearMOFlagStatus(&CAN001_Handle0,2,TRANSMIT_PENDING);
}
if(CAN001_GetMOFlagStatus(&CAN001_Handle0,3,TRANSMIT_PENDING) == CAN_SET)
{
CAN001_ClearMOFlagStatus(&CAN001_Handle0,3,TRANSMIT_PENDING);
}
if(CAN001_GetMOFlagStatus(&CAN001_Handle0,4,TRANSMIT_PENDING) == CAN_SET)
{
CAN001_ClearMOFlagStatus(&CAN001_Handle0,4,TRANSMIT_PENDING);
}
*/
if(CAN001_GetMOFlagStatus(&CAN001_Handle0,5,RECEIVE_PENDING) == CAN_SET)
{
CAN001_ClearMOFlagStatus(&CAN001_Handle0,5,RECEIVE_PENDING);
CAN001_ReadMsgObj(&CAN001_Handle0,&can0rx.buf[can0rx.WritePos],5);
can0rx.WritePos++;
can0rx.WritePos&=(MAXLINE-1);
osSemaphoreRelease(can0rx_semaphore_id);
}
if(CAN001_GetMOFlagStatus(&CAN001_Handle0,6,RECEIVE_PENDING) == CAN_SET)
{
CAN001_ClearMOFlagStatus(&CAN001_Handle0,6,RECEIVE_PENDING);
CAN001_ReadMsgObj(&CAN001_Handle0,&can0rx.buf[can0rx.WritePos],6);
can0rx.WritePos++;
can0rx.WritePos&=(MAXLINE-1);
osSemaphoreRelease(can0rx_semaphore_id);
}
if(CAN001_GetMOFlagStatus(&CAN001_Handle0,7,RECEIVE_PENDING) == CAN_SET)
{
CAN001_ClearMOFlagStatus(&CAN001_Handle0,7,RECEIVE_PENDING);
CAN001_ReadMsgObj(&CAN001_Handle0,&can0rx.buf[can0rx.WritePos],7);
can0rx.WritePos++;
can0rx.WritePos&=(MAXLINE-1);
osSemaphoreRelease(can0rx_semaphore_id);
}
if(CAN001_GetMOFlagStatus(&CAN001_Handle0,8,RECEIVE_PENDING) == CAN_SET)
{
CAN001_ClearMOFlagStatus(&CAN001_Handle0,8,RECEIVE_PENDING);
CAN001_ReadMsgObj(&CAN001_Handle0,&can0rx.buf[can0rx.WritePos],8);
can0rx.WritePos++;
can0rx.WritePos&=(MAXLINE-1);
osSemaphoreRelease(can0rx_semaphore_id);
}
if(CAN001_GetNodeFlagStatus(&CAN001_Handle0,CAN001_ALERT_STATUS) == CAN_SET)
{
CAN001_ClearNodeFlagStatus(&CAN001_Handle0,CAN001_ALERT_STATUS);
}
}
/**
* @brief EXTI line detection callbacks
* @param GPIO_Pin: Specifies the pins connected EXTI line
* @retval None
*/
void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{
osSemaphoreRelease(osSemaphore);
}
/*!
\brief Thread definition for thread 2.
\param argument A pointer to the list of arguments.
*/
void thread2 (void const *argument)
{
if (addTraceProtected("thread2 start run") != TRACE_OK)
{
stop_cpu;
}
while (1)
{
if (addTraceProtected("thread2 take sem0 attempt") != TRACE_OK)
{
stop_cpu;
}
if ( osSemaphoreWait (sid_Semaphore0, osWaitForever) != -1 ) // wait forever
{
if (addTraceProtected("thread2 take sem0 success") != TRACE_OK)
{
stop_cpu;
}
task2(); // thread code
count1Sec();
task2();
if (addTraceProtected("thread2 release sem0 attempt") != TRACE_OK)
{
stop_cpu;
}
if (osSemaphoreRelease (sid_Semaphore0) != osOK)
{
if (addTraceProtected("thread2 release sem0 fail") != TRACE_OK)
{
stop_cpu;
}
}
}
else
{
if (addTraceProtected("thread2 take sem0 fail") != TRACE_OK)
{
stop_cpu;
}
}
if (addTraceProtected("thread2 set priority to osPriorityBelowNormal") != TRACE_OK)
{
stop_cpu;
}
osThreadSetPriority(osThreadGetId(), osPriorityBelowNormal);
if (addTraceProtected("thread2 yields") != TRACE_OK)
{
stop_cpu;
}
osThreadYield(); // suspend thread
if (addTraceProtected("thread2 back from yield") != TRACE_OK)
{
stop_cpu;
}
// This should terminate the current thread2 thread
if (Terminate_thread2() != 0)
{
stop_cpu;
}
}
}
osStatus Semaphore::release(void)
{
return osSemaphoreRelease(_id);
}
/**
* @brief User task
* @param pvParameters not used
* @retval None
*/
void HID_MenuThread(void const *argument)
{
for(;;)
{
if(osSemaphoreWait(MenuEvent , osWaitForever) == osOK)
{
switch(hid_demo.state)
{
case HID_DEMO_IDLE:
hid_demo.state = HID_DEMO_START;
osSemaphoreRelease(MenuEvent);
break;
case HID_DEMO_START:
if(Appli_state == APPLICATION_READY)
{
/* Wait for User Input */
if(ButtonPressed == 1)
{
ButtonPressed = 0;
if(USBH_HID_GetDeviceType(&hUSBHost) == HID_KEYBOARD)
{
hid_demo.keyboard_state = HID_KEYBOARD_START;
hid_demo.state = HID_DEMO_KEYBOARD;
HID_KeyboardMenuProcess();
}
else if(USBH_HID_GetDeviceType(&hUSBHost) == HID_MOUSE)
{
hid_demo.mouse_state = HID_MOUSE_START;
hid_demo.state = HID_DEMO_MOUSE;
HID_MouseMenuProcess();
}
else
{
LCD_ErrLog("No supported HID device!\n");
hid_demo.state = HID_DEMO_IDLE;
}
}
osSemaphoreRelease(MenuEvent);
}
break;
case HID_DEMO_MOUSE:
if(Appli_state == APPLICATION_READY)
{
USBH_MouseDemo(&hUSBHost);
}
break;
case HID_DEMO_KEYBOARD:
if(Appli_state == APPLICATION_READY)
{
USBH_KeybdDemo(&hUSBHost);
}
break;
default:
break;
}
if(Appli_state == APPLICATION_DISCONNECT)
{
Appli_state = APPLICATION_IDLE;
LCD_LOG_ClearTextZone();
BSP_LCD_ClearStringLine(19);
LCD_ErrLog("HID device disconnected!\n");
hid_demo.state = HID_DEMO_IDLE;
}
}
}
}
void vMBM_EventPut_Post( void )
{ // 设置发送完成标志
osSemaphoreRelease( semaphore_TX );
}
/**
* @brief The function is a callback about HID Data events
* @param phost: Selected device
* @retval None
*/
void USBH_HID_EventCallback(USBH_HandleTypeDef *phost)
{
osSemaphoreRelease(MenuEvent);
}
void osSetEvent(OsEvent *event)
{
//Set the specified event to the signaled state
osSemaphoreRelease(event->id);
}
void ff_rel_grant (
_SYNC_t sobj /* Sync object to be signaled */
)
{
osSemaphoreRelease(sobj);
}
osStatus release_mySemaphore(struct mySemaphore *sem) {
return osSemaphoreRelease(sem->_osSemaphoreId);
}
/*-----------------------------------------------------------------------------
Routine to Move the Objects
*----------------------------------------------------------------------------*/
void S_MoveObjects (void){
int8_t i = 0;
uint32_t randNum;
osMutexWait(objectVar_mutex_id, osWaitForever);
srand(randSeed);
randSeed++;
randNum = rand();
if (objectNumb < maxNumberObjects){
if (randNum % 17 == 0) {
objectArray[objectNumb][0] = 100;
objectArray[objectNumb][1] = 80;
} else if (randNum % 11 == 0) {
objectArray[objectNumb][0] = 40;
objectArray[objectNumb][1] = 90;
} else if (randNum % 7 == 0) {
objectArray[objectNumb][0] = 200;
objectArray[objectNumb][1] = 220;
} else if (randNum % 5 == 0) {
objectArray[objectNumb][0] = 60;
objectArray[objectNumb][1] = 180;
} else if (randNum % 3 == 0) {
objectArray[objectNumb][0] = 150;
objectArray[objectNumb][1] = 120;
} else if (randNum % 2 == 0) {
objectArray[objectNumb][0] = 80;
objectArray[objectNumb][1] = 130;
} else {
objectArray[objectNumb][0] = 90;
objectArray[objectNumb][1] = 80;
}
objSenseArray[objectNumb][0] = -10;
objSenseArray[objectNumb][1] = 10;
objectNumb++;
}
osMutexRelease(objectVar_mutex_id);
for (i = 0; i < objectNumb; i++){
// Delete the object at its last position
osSemaphoreWait (glcd_semaph_id, osWaitForever);
GLCD_SetForegroundColor (GLCD_COLOR_BLACK);
S_DrawStar (objectArray[i][0], objectArray[i][1]);
osSemaphoreRelease(glcd_semaph_id);
osMutexWait(objectVar_mutex_id, osWaitForever);
if(!i)
{
if (randNum % 5 == 0)
{
objSenseArray[i][0] = 20;
objSenseArray[i][1] = 20;
}
else
{
objSenseArray[i][0] = 3;
objSenseArray[i][1] = 3;
}
//Homing behaviour for ball 0
if( objectArray[i][0] < plane_x ){
objSenseArray[i][0] = abs(objSenseArray[i][0]);
}
else
{
objSenseArray[i][0] = -abs(objSenseArray[i][0]);
}
if( objectArray[i][1] < plane_y ){
objSenseArray[i][1] = abs(objSenseArray[i][1]);
}
else
{
objSenseArray[i][1] = -abs(objSenseArray[i][1]);
}
}
// Reverse X sense if the object reach the limits
if( objectArray[i][0] < 1 | objectArray[i][0] > GLCD_WIDTH - 11){
objSenseArray[i][0] = -objSenseArray[i][0];
}
// Reverse Y sense if the object reach the limits
if( objectArray[i][1] < 29 | objectArray[i][1] > GLCD_HEIGHT - 11){
objSenseArray[i][1] = -objSenseArray[i][1];
}
// Move position of object
objectArray[i][0]+=objSenseArray[i][0];
objectArray[i][1]+=objSenseArray[i][1];
// Draw the object at its new position
osSemaphoreWait (glcd_semaph_id, osWaitForever);
switch(i)
{
case 0:
if(abs(objSenseArray[i][0]) == 20)
{
objectColor = GLCD_COLOR_RED;
}
else
{
objectColor = GLCD_COLOR_BLUE;
}
break;
case 1:
objectColor = GLCD_COLOR_YELLOW;
break;
default:
objectColor = GLCD_COLOR_WHITE;
break;
}
GLCD_SetForegroundColor (objectColor);
S_DrawStar (objectArray[i][0],objectArray[i][1]);
osSemaphoreRelease(glcd_semaph_id);
osMutexRelease(objectVar_mutex_id);
}
}
/*! \fn void thread0 (void const *argument)
\brief Thread definition for thread 0.
\param argument A pointer to the list of arguments.
*/
void thread0 (void const *argument)
{
if (addTraceProtected("thread0 start run") != TRACE_OK)
{
stop_cpu;
}
while (1)
{
if (addTraceProtected("thread0 take sem0 attempt") != TRACE_OK)
{
stop_cpu;
}
if ( osSemaphoreWait (sid_Semaphore0, 0) != -1 ) // no wait
{
if (addTraceProtected("thread0 take sem0 success") != TRACE_OK)
{
stop_cpu;
}
task0(); // thread code
count1Sec();
task0();
if (addTraceProtected("thread0 set priority to osPriorityLow") != TRACE_OK)
{
stop_cpu;
}
osThreadSetPriority(osThreadGetId(), osPriorityLow);
if (addTraceProtected("thread0 yields") != TRACE_OK)
{
stop_cpu;
}
osThreadYield(); // suspend thread
if (addTraceProtected("thread0 release sem0 attempt") != TRACE_OK)
{
stop_cpu;
}
if (osSemaphoreRelease (sid_Semaphore0) != osOK)
{
if (addTraceProtected("thread0 release sem0 fail") != TRACE_OK)
{
stop_cpu;
}
}
else
{
if (addTraceProtected("thread0 release sem0 success") != TRACE_OK)
{
stop_cpu;
}
}
}
else
{
if (addTraceProtected("thread0 take sem0 fail") != TRACE_OK)
{
stop_cpu;
}
}
if (addTraceProtected("thread0 set priority to osPriorityLow") != TRACE_OK)
{
stop_cpu;
}
osThreadSetPriority(osThreadGetId(), osPriorityLow);
if (addTraceProtected("thread0 yields") != TRACE_OK)
{
stop_cpu;
}
osThreadYield(); // suspend thread
if (addTraceProtected("thread0 back from yield") != TRACE_OK)
{
stop_cpu;
}
if (addTraceProtected("thread0 delete sem0") != TRACE_OK)
{
stop_cpu;
}
if (Delete_Semaphore0() != 0)
{
stop_cpu;
}
// This should terminate the current thread0 thread
if (Terminate_thread0() != 0)
{
stop_cpu;
}
}
}
/*---------------------------------------------------------------------------*
* Routine: sys_sem_signal
*---------------------------------------------------------------------------*
* Description:
* Signals (releases) a semaphore
* Inputs:
* sys_sem_t sem -- Semaphore to signal
*---------------------------------------------------------------------------*/
void sys_sem_signal(sys_sem_t *data) {
if (osSemaphoreRelease(data->id) != osOK)
mbed_die(); /* Can be called by ISR do not use printf */
}
/**
* @brief Updates the Menu.
* @param None
* @retval None
*/
void HID_UpdateMenu(void)
{
/* Force menu to show Item 0 by default */
hid_demo.state = HID_DEMO_IDLE;
osSemaphoreRelease(MenuEvent);
}
/**
* @brief User task
* @param pvParameters not used
* @retval None
*/
static void MSC_MenuThread(void const *argument)
{
for(;;)
{
if(osSemaphoreWait(MenuEvent, osWaitForever) == osOK)
{
switch(msc_demo.state)
{
case MSC_DEMO_IDLE:
MSC_SelectItem(MSC_main_menu, 0);
msc_demo.state = MSC_DEMO_WAIT;
msc_demo.select = 0;
osSemaphoreRelease(MenuEvent);
break;
case MSC_DEMO_WAIT:
MSC_SelectItem(MSC_main_menu, msc_demo.select & 0x7F);
/* Handle select item */
if(msc_demo.select & 0x80)
{
switch(msc_demo.select & 0x7F)
{
case 0:
msc_demo.state = MSC_DEMO_FILE_OPERATIONS;
osSemaphoreRelease(MenuEvent);
break;
case 1:
msc_demo.state = MSC_DEMO_EXPLORER;
osSemaphoreRelease(MenuEvent);
break;
case 2:
msc_demo.state = MSC_REENUMERATE;
osSemaphoreRelease(MenuEvent);
break;
default:
break;
}
}
break;
case MSC_DEMO_FILE_OPERATIONS:
/* Read and Write File Here */
if(Appli_state == APPLICATION_READY)
{
MSC_File_Operations();
}
msc_demo.state = MSC_DEMO_WAIT;
break;
case MSC_DEMO_EXPLORER:
/* Display disk content */
if(Appli_state == APPLICATION_READY)
{
Explore_Disk("0:/", 1);
}
msc_demo.state = MSC_DEMO_WAIT;
break;
case MSC_REENUMERATE:
/* Force MSC Device to re-enumerate */
USBH_ReEnumerate(&hUSBHost);
msc_demo.state = MSC_DEMO_WAIT;
break;
default:
break;
}
msc_demo.select &= 0x7F;
}
}
}
void osReleaseSemaphore(OsSemaphore *semaphore)
{
//Release the semaphore
osSemaphoreRelease(semaphore->id);
}
/**
* @brief Ethernet Rx Transfer completed callback
* @param heth: ETH handle
* @retval None
*/
void HAL_ETH_RxCpltCallback(ETH_HandleTypeDef *heth)
{
osSemaphoreRelease(s_xSemaphore);
}
/**
* @brief User task
* @param pvParameters not used
* @retval None
*/
static void MSC_MenuThread(void const *argument)
{
uint32_t ITstatus = 0;
for(;;)
{
if(osSemaphoreWait(MenuEvent, 100) == osOK)
{
switch(msc_demo.state)
{
case MSC_DEMO_IDLE:
MSC_SelectItem(MSC_main_menu, 0);
msc_demo.state = MSC_DEMO_WAIT;
msc_demo.select = 0;
osSemaphoreRelease(MenuEvent);
break;
case MSC_DEMO_WAIT:
MSC_SelectItem(MSC_main_menu, msc_demo.select & 0x7F);
/* Handle select item */
if(msc_demo.select & 0x80)
{
switch(msc_demo.select & 0x7F)
{
case 0:
msc_demo.state = MSC_DEMO_FILE_OPERATIONS;
osSemaphoreRelease(MenuEvent);
break;
case 1:
msc_demo.state = MSC_DEMO_EXPLORER;
osSemaphoreRelease(MenuEvent);
break;
case 2:
msc_demo.state = MSC_REENUMERATE;
osSemaphoreRelease(MenuEvent);
break;
default:
break;
}
}
break;
case MSC_DEMO_FILE_OPERATIONS:
/* Read and Write File Here */
if(Appli_state == APPLICATION_READY)
{
MSC_File_Operations();
}
msc_demo.state = MSC_DEMO_WAIT;
break;
case MSC_DEMO_EXPLORER:
/* Display disk content */
if(Appli_state == APPLICATION_READY)
{
Explore_Disk("0:/", 1);
}
msc_demo.state = MSC_DEMO_WAIT;
break;
case MSC_REENUMERATE:
/* Force MSC Device to re-enumerate */
USBH_ReEnumerate(&hUSBHost);
msc_demo.state = MSC_DEMO_WAIT;
break;
default:
break;
}
msc_demo.select &= 0x7F;
}
if (osJoySemaphore != NULL)
{
if(osSemaphoreWait(osJoySemaphore , 0) == osOK)
{
ITstatus = BSP_IO_ITGetStatus(JOY_ALL_PINS);
if (ITstatus)
{
Joystick_MscMenu();
/* Clear joystick interrupt pending bits */
BSP_IO_ITClear();
}
}
}
}
}
void on_popped_item(ipc_queue_item_t item)
{
osStatus_t os_status = osSemaphoreRelease((osSemaphoreId_t)(item.b));
MBED_ASSERT(osOK == os_status);
PSA_UNUSED(os_status);
}
void vMBM_EventGet_Post( void )
{ // 设置接收完成标志
osSemaphoreRelease( semaphore_RX );
}
void delayThread(void const *argument) {
while(1) {
osDelay(500);
osSemaphoreRelease(semid);
}
}
