/**
* @brief USBH_HID_USR_OverCurrentDetected
* Device Overcurrent detection event
* @param None
* @retval None
*/
void USBH_HID_USR_OverCurrentDetected (void)
{
LCD_ErrLog (">Port1:Overcurrent detected.\n");
}
/**
* @brief USBH_MSC_InterfaceInit
* Interface initialization for MSC class.
* @param pdev: Selected device
* @param hdev: Selected device property
* @retval USBH_Status : Status of class request handled.
*/
static USBH_Status USBH_MSC_InterfaceInit ( USB_OTG_CORE_HANDLE *pdev,
void *phost)
{
USBH_HOST *pphost = phost;
if((pphost->device_prop.Itf_Desc[0].bInterfaceClass == MSC_CLASS) && \
(pphost->device_prop.Itf_Desc[0].bInterfaceProtocol == MSC_PROTOCOL))
{
if(pphost->device_prop.Ep_Desc[0][0].bEndpointAddress & 0x80)
{
MSC_Machine.MSBulkInEp = (pphost->device_prop.Ep_Desc[0][0].bEndpointAddress);
MSC_Machine.MSBulkInEpSize = pphost->device_prop.Ep_Desc[0][0].wMaxPacketSize;
}
else
{
MSC_Machine.MSBulkOutEp = (pphost->device_prop.Ep_Desc[0][0].bEndpointAddress);
MSC_Machine.MSBulkOutEpSize = pphost->device_prop.Ep_Desc[0] [0].wMaxPacketSize;
}
if(pphost->device_prop.Ep_Desc[0][1].bEndpointAddress & 0x80)
{
MSC_Machine.MSBulkInEp = (pphost->device_prop.Ep_Desc[0][1].bEndpointAddress);
MSC_Machine.MSBulkInEpSize = pphost->device_prop.Ep_Desc[0][1].wMaxPacketSize;
}
else
{
MSC_Machine.MSBulkOutEp = (pphost->device_prop.Ep_Desc[0][1].bEndpointAddress);
MSC_Machine.MSBulkOutEpSize = pphost->device_prop.Ep_Desc[0][1].wMaxPacketSize;
}
MSC_Machine.hc_num_out = USBH_Alloc_Channel(pdev,
MSC_Machine.MSBulkOutEp);
MSC_Machine.hc_num_in = USBH_Alloc_Channel(pdev,
MSC_Machine.MSBulkInEp);
/* Open the new channels */
USBH_Open_Channel (pdev,
MSC_Machine.hc_num_out,
pphost->device_prop.address,
pphost->device_prop.speed,
EP_TYPE_BULK,
MSC_Machine.MSBulkOutEpSize);
USBH_Open_Channel (pdev,
MSC_Machine.hc_num_in,
pphost->device_prop.address,
pphost->device_prop.speed,
EP_TYPE_BULK,
MSC_Machine.MSBulkInEpSize);
}
else
{
if (pphost->device_prop.Itf_Desc[0].bInterfaceClass == USB_HUB)
{
LCD_ErrLog("Hub is not supported.\n");
}
else if (pphost->device_prop.Itf_Desc[0].bInterfaceClass == USB_CDCC)
{
LCD_ErrLog("Communications and CDC Control device is not supported.\n");
}
else if (pphost->device_prop.Itf_Desc[0].bInterfaceClass == USB_HID)
{
LCD_ErrLog("HID device is not supported.\n");
}
else if (pphost->device_prop.Itf_Desc[0].bInterfaceClass == USB_PRINTER)
{
LCD_ErrLog("Printer device is not supported.\n");
}
else if (pphost->device_prop.Itf_Desc[0].bInterfaceClass == USB_SMARTCARD)
{
LCD_ErrLog("Smart Card device is not supported.\n");
}
else if (pphost->device_prop.Itf_Desc[0].bInterfaceClass == USB_VIDEO)
{
LCD_ErrLog("Video device is not supported.\n");
}
else if (pphost->device_prop.Itf_Desc[0].bInterfaceClass == USB_AVD)
{
LCD_ErrLog("Audio/Video Devices is not supported.\n");
}
else
{
LCD_ErrLog ("The attached device is not supported. \n");
}
pphost->usr_cb->DeviceNotSupported();
}
return USBH_OK ;
}
/**
* @brief USBH_DisconnectEvent
* Device disconnect event
* @param None
* @retval None
*/
void USBH_HID_USR_DeviceDisconnected (void)
{
LCD_ErrLog((void *)MSG_HID_DEV_DISCONNECTED);
USBFS_EnumDone= 0;
}
/**
* @brief Manages AUDIO Menu Process.
* @param None
* @retval None
*/
void AUDIO_MenuProcess(void)
{
AUDIO_ErrorTypeDef status;
TS_StateTypeDef TS_State;
Point PlaybackLogoPoints[] = {{TOUCH_PLAYBACK_XMIN, TOUCH_PLAYBACK_YMIN},
{TOUCH_PLAYBACK_XMAX, (TOUCH_PLAYBACK_YMIN+TOUCH_PLAYBACK_YMAX)/2},
{TOUCH_PLAYBACK_XMIN, TOUCH_PLAYBACK_YMAX}};
if(appli_state == APPLICATION_READY)
{
switch(AudioDemo.state)
{
case AUDIO_DEMO_IDLE:
if(AUDIO_ShowWavFiles() > 0)
{
LCD_ErrLog("There is no WAV file on the USB Key.\n");
AUDIO_ChangeSelectMode(AUDIO_SELECT_MENU);
AudioDemo.state = AUDIO_DEMO_IDLE;
}
else
{
AudioDemo.state = AUDIO_DEMO_WAIT;
}
BSP_LCD_SetFont(&LCD_LOG_HEADER_FONT);
BSP_LCD_ClearStringLine(13); /* Clear touch screen buttons dedicated zone */
BSP_LCD_ClearStringLine(14);
BSP_LCD_ClearStringLine(15);
BSP_LCD_SetTextColor(LCD_COLOR_CYAN);
BSP_LCD_FillPolygon(PlaybackLogoPoints, 3); /* Playback sign */
BSP_LCD_FillCircle((TOUCH_RECORD_XMAX+TOUCH_RECORD_XMIN)/2, /* Record circle */
(TOUCH_RECORD_YMAX+TOUCH_RECORD_YMIN)/2,
(TOUCH_RECORD_XMAX-TOUCH_RECORD_XMIN)/2);
BSP_LCD_SetTextColor(LCD_COLOR_GREEN);
BSP_LCD_SetFont(&LCD_LOG_TEXT_FONT);
BSP_LCD_DisplayStringAtLine(15, (uint8_t *)"Use touch screen to enter playback or record menu");
break;
case AUDIO_DEMO_WAIT:
BSP_TS_GetState(&TS_State);
if(TS_State.touchDetected == 1)
{
if ((TS_State.touchX[0] > TOUCH_RECORD_XMIN) && (TS_State.touchX[0] < TOUCH_RECORD_XMAX) &&
(TS_State.touchY[0] > TOUCH_RECORD_YMIN) && (TS_State.touchY[0] < TOUCH_RECORD_YMAX))
{
AudioDemo.state = AUDIO_DEMO_IN;
}
else if ((TS_State.touchX[0] > TOUCH_PLAYBACK_XMIN) && (TS_State.touchX[0] < TOUCH_PLAYBACK_XMAX) &&
(TS_State.touchY[0] > TOUCH_PLAYBACK_YMIN) && (TS_State.touchY[0] < TOUCH_PLAYBACK_YMAX))
{
AudioDemo.state = AUDIO_DEMO_PLAYBACK;
}
else
{
AudioDemo.state = AUDIO_DEMO_EXPLORE;
}
/* Wait for touch released */
do
{
BSP_TS_GetState(&TS_State);
}while(TS_State.touchDetected > 0);
}
break;
case AUDIO_DEMO_EXPLORE:
if(appli_state == APPLICATION_READY)
{
if(AUDIO_ShowWavFiles() > 0)
{
LCD_ErrLog("There is no WAV file on the USB Key.\n");
AUDIO_ChangeSelectMode(AUDIO_SELECT_MENU);
AudioDemo.state = AUDIO_DEMO_IDLE;
}
else
{
AudioDemo.state = AUDIO_DEMO_WAIT;
}
}
else
{
AudioDemo.state = AUDIO_DEMO_WAIT;
}
break;
case AUDIO_DEMO_PLAYBACK:
if(appli_state == APPLICATION_READY)
{
if(AudioState == AUDIO_STATE_IDLE)
{
/* Start Playing */
AudioState = AUDIO_STATE_INIT;
/* Clear the LCD */
LCD_ClearTextZone();
if(AUDIO_PLAYER_Start(0) == AUDIO_ERROR_IO)
{
AUDIO_ChangeSelectMode(AUDIO_SELECT_MENU);
AudioDemo.state = AUDIO_DEMO_IDLE;
}
}
else /* Not idle */
{
if(AUDIO_PLAYER_Process() == AUDIO_ERROR_IO)
{
/* Clear the LCD */
LCD_ClearTextZone();
AUDIO_ChangeSelectMode(AUDIO_SELECT_MENU);
AudioDemo.state = AUDIO_DEMO_IDLE;
}
}
}
else
{
AudioDemo.state = AUDIO_DEMO_WAIT;
}
break;
case AUDIO_DEMO_IN:
if(appli_state == APPLICATION_READY)
{
if(AudioState == AUDIO_STATE_IDLE)
{
/* Start Playing */
AudioState = AUDIO_STATE_INIT;
/* Clear the LCD */
LCD_ClearTextZone();
/* Configure the audio recorder: sampling frequency, bits-depth, number of channels */
if(AUDIO_REC_Start() == AUDIO_ERROR_IO)
{
AUDIO_ChangeSelectMode(AUDIO_SELECT_MENU);
AudioDemo.state = AUDIO_DEMO_IDLE;
}
}
else /* Not idle */
{
status = AUDIO_REC_Process();
if((status == AUDIO_ERROR_IO) || (status == AUDIO_ERROR_EOF))
{
/* Clear the LCD */
LCD_ClearTextZone();
AUDIO_ChangeSelectMode(AUDIO_SELECT_MENU);
AudioDemo.state = AUDIO_DEMO_IDLE;
}
}
}
else
{
AudioDemo.state = AUDIO_DEMO_WAIT;
}
break;
default:
break;
}
}
if(appli_state == APPLICATION_DISCONNECT)
{
appli_state = APPLICATION_IDLE;
AUDIO_ChangeSelectMode(AUDIO_SELECT_MENU);
BSP_AUDIO_OUT_Stop(CODEC_PDWN_SW);
}
}
/**
* @brief Manages DUAL Menu Process.
* @param None
* @retval None
*/
void DUAL_MenuProcess(void)
{
switch(demo.state)
{
case DEMO_IDLE:
Demo_SelectItem(DEMO_main_menu, 0);
LCD_UsrLog("Select an operation to continue.\n");
demo.state = DEMO_WAIT;
demo.select = 0;
break;
case DEMO_WAIT:
if(demo.select != prev_select)
{
prev_select = demo.select;
Demo_SelectItem(DEMO_main_menu, demo.select & 0x7F);
/* Handle select item */
if(demo.select & 0x80)
{
demo.select &= 0x7F;
switch(demo.select)
{
case 0:
demo.state = DEMO_MSC_START;
break;
case 1:
demo.state = DEMO_HID_START;
break;
case 2:
demo.state = DEMO_MSC_REENUMERATE;
break;
case 3:
demo.state = DEMO_HID_REENUMERATE;
break;
default:
break;
}
}
}
break;
case DEMO_MSC_START:
if(Appli_HS_state == APPLICATION_HS_READY)
{
/* If HS device connected*/
demo.state = DEMO_MSC;
demo.msc_state = APPLI_MSC_IDLE;
}
else
{
LCD_ErrLog("No Mass storage device connected.\n");
demo.state = DEMO_WAIT;
}
break;
case DEMO_HID_START:
if(Appli_FS_state == APPLICATION_FS_READY)
{
/*if FS device connected*/
demo.state = DEMO_HID;
demo.hid_state = APPLI_HID_IDLE;
}
else
{
LCD_ErrLog("No HID device connected.\n");
demo.state = DEMO_WAIT;
}
break;
case DEMO_MSC:
MSC_MenuProcess();
break;
case DEMO_HID:
HID_MenuProcess();
break;
case DEMO_MSC_REENUMERATE: /* Re-Enumeration MSC */
LCD_DbgLog("Starting Enumeration MSC....");
LCD_DbgLog("\n");
USBH_ReEnumerate(&hUSBHost_HS);
demo.state = DEMO_WAIT;
break;
case DEMO_HID_REENUMERATE: /* Re-Enumeration HID */
LCD_DbgLog("Starting Enumeration HID....");
LCD_DbgLog("\n");
USBH_ReEnumerate(&hUSBHost_FS);
demo.state = DEMO_WAIT;
break;
default:
break;
}
if(Appli_FS_state == APPLICATION_FS_DISCONNECT)
{
Appli_FS_state = APPLICATION_IDLE;
LCD_LOG_ClearTextZone();
LCD_ErrLog("device FS disconnected!\n");
demo.state = DEMO_IDLE;
demo.select = 0;
}
if(Appli_HS_state == APPLICATION_HS_DISCONNECT)
{
Appli_HS_state = APPLICATION_IDLE;
LCD_LOG_ClearTextZone();
LCD_ErrLog("device HS disconnected!\n");
demo.state = DEMO_IDLE;
demo.select = 0;
}
}
/**
* @brief Manages AUDIO Menu Process.
* @param None
* @retval None
*/
void AUDIO_MenuProcess(void)
{
uint32_t ITstatus = 0;
AUDIO_ErrorTypeDef status;
if(appli_state == APPLICATION_READY)
{
switch(AudioDemo.state)
{
case AUDIO_DEMO_IDLE:
AUDIO_SelectItem(AUDIO_main_menu, 0);
if((AUDIO_ShowWavFiles() > 0) && (state == 0))
{
LCD_ErrLog("There is no WAV file on the USB Key.\n");
AUDIO_ChangeSelectMode(AUDIO_SELECT_MENU);
AudioDemo.state = AUDIO_DEMO_IDLE;
state = 1;
}
else
{
AudioDemo.state = AUDIO_DEMO_WAIT;
}
AudioDemo.select = 0;
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 Audio Playback and Record menu");
break;
case AUDIO_DEMO_WAIT:
if(AudioDemo.select != PrevSelect)
{
PrevSelect = AudioDemo.select;
AUDIO_SelectItem(AUDIO_main_menu, AudioDemo.select & 0x7F);
/* Handle select item */
if(AudioDemo.select & 0x80)
{
switch(AudioDemo.select & 0x7F)
{
case 0:
AudioDemo.state = AUDIO_DEMO_EXPLORE;
break;
case 1:
/* Display HMI messages */
BSP_LCD_SetTextColor(LCD_COLOR_GREEN);
BSP_LCD_DisplayStringAtLine(14 ,(uint8_t *)" ");
BSP_LCD_DisplayStringAtLine(15 ,(uint8_t *)" ");
BSP_LCD_DisplayStringAtLine(16 ,(uint8_t *)"Use [User Key] To Stop and return from player/recorder ");
BSP_LCD_SetTextColor(LCD_COLOR_WHITE);
/* Set PLAYBACK state and start playing 1st file */
AudioState = AUDIO_STATE_IDLE;
AudioDemo.state = AUDIO_DEMO_PLAYBACK;
AUDIO_ChangeSelectMode(AUDIO_PLAYBACK_CONTROL);
break;
case 2:
/* Display HMI messages */
BSP_LCD_SetTextColor(LCD_COLOR_GREEN);
BSP_LCD_DisplayStringAtLine(14 ,(uint8_t *)" ");
BSP_LCD_DisplayStringAtLine(15 ,(uint8_t *)" ");
BSP_LCD_DisplayStringAtLine(16 ,(uint8_t *)"Use [User Key] To Stop and return from player/recorder ");
BSP_LCD_SetTextColor(LCD_COLOR_WHITE);
/* Set PLAYBACK state and start playing 1st file */
AudioState = AUDIO_STATE_IDLE;
AudioDemo.state = AUDIO_DEMO_IN;
AUDIO_ChangeSelectMode(AUDIO_PLAYBACK_CONTROL);
break;
default:
break;
}
}
}
break;
case AUDIO_DEMO_EXPLORE:
if(appli_state == APPLICATION_READY)
{
if(AUDIO_ShowWavFiles() > 0)
{
LCD_ErrLog("There is no WAV file on the USB Key.\n");
AUDIO_ChangeSelectMode(AUDIO_SELECT_MENU);
AudioDemo.state = AUDIO_DEMO_IDLE;
}
else
{
AudioDemo.state = AUDIO_DEMO_WAIT;
}
}
else
{
AudioDemo.state = AUDIO_DEMO_WAIT;
}
break;
case AUDIO_DEMO_PLAYBACK:
if(appli_state == APPLICATION_READY)
{
if(AudioState == AUDIO_STATE_IDLE)
{
/* Start Playing */
AudioState = AUDIO_STATE_INIT;
if(AUDIO_PLAYER_Start(0) == AUDIO_ERROR_IO)
{
AUDIO_ChangeSelectMode(AUDIO_SELECT_MENU);
AudioDemo.state = AUDIO_DEMO_IDLE;
}
else
{
BSP_LCD_SetTextColor(LCD_COLOR_YELLOW);
BSP_LCD_DisplayStringAtLine(10, (uint8_t *)"[ UP ] : Volume +");
BSP_LCD_DisplayStringAtLine(11, (uint8_t *)"[ DOWN ] : Volume -");
BSP_LCD_DisplayStringAtLine(12, (uint8_t *)"[ LEFT ] : Previous");
BSP_LCD_DisplayStringAtLine(13, (uint8_t *)"[ RIGHT ] : Next");
BSP_LCD_DisplayStringAtLine(14, (uint8_t *)"[ SEL ] : Pause/Resume");
BSP_LCD_SetTextColor(LCD_COLOR_WHITE);
}
}
else /* Not idle */
{
if(AUDIO_PLAYER_Process() == AUDIO_ERROR_IO)
{
AUDIO_ChangeSelectMode(AUDIO_SELECT_MENU);
AudioDemo.state = AUDIO_DEMO_IDLE;
}
}
}
else
{
AudioDemo.state = AUDIO_DEMO_WAIT;
}
break;
case AUDIO_DEMO_IN:
if(appli_state == APPLICATION_READY)
{
if(AudioState == AUDIO_STATE_IDLE)
{
/* Start Playing */
AudioState = AUDIO_STATE_INIT;
/* Configure the audio recorder: sampling frequency, bits-depth, number of channels */
if(AUDIO_REC_Start() == AUDIO_ERROR_IO)
{
AUDIO_ChangeSelectMode(AUDIO_SELECT_MENU);
AudioDemo.state = AUDIO_DEMO_IDLE;
}
else
{
BSP_LCD_SetTextColor(LCD_COLOR_YELLOW);
BSP_LCD_DisplayStringAtLine(11, (uint8_t *)"[ UP ] : Volume +");
BSP_LCD_DisplayStringAtLine(12, (uint8_t *)"[ DOWN ] : Volume -");
BSP_LCD_DisplayStringAtLine(13, (uint8_t *)"[ SEL ] : Pause/Resume");
BSP_LCD_SetTextColor(LCD_COLOR_WHITE);
}
}
else /* Not idle */
{
status = AUDIO_REC_Process();
if((status == AUDIO_ERROR_IO) || (status == AUDIO_ERROR_EOF))
{
AUDIO_ChangeSelectMode(AUDIO_SELECT_MENU);
AudioDemo.state = AUDIO_DEMO_IDLE;
}
}
}
else
{
AudioDemo.state = AUDIO_DEMO_WAIT;
}
break;
default:
break;
}
}
if(appli_state == APPLICATION_DISCONNECT)
{
appli_state = APPLICATION_IDLE;
AUDIO_ChangeSelectMode(AUDIO_SELECT_MENU);
BSP_AUDIO_OUT_Stop(CODEC_PDWN_SW);
}
AudioDemo.select &= 0x7F;
if (MfxExtiReceived == 1)
{
MfxExtiReceived = 0;
ITstatus = BSP_IO_ITGetStatus(JOY_ALL_PINS);
if (ITstatus)
{
Joystick_AudioMenu();
/* Clear joystick interrupt pending bits */
BSP_IO_ITClear();
}
}
}
/**
* @brief Configure the RTC peripheral by selecting the clock source.
* @param None
* @retval None
*/
static void RTC_Config(void)
{
/* Enable the PWR clock */
RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR, ENABLE);
/* Allow access to RTC */
PWR_BackupAccessCmd(ENABLE);
#if defined (RTC_CLOCK_SOURCE_LSI) /* LSI used as RTC source clock*/
/* The RTC Clock may varies due to LSI frequency dispersion. */
/* Enable the LSI OSC */
RCC_LSICmd(ENABLE);
/* Wait till LSI is ready */
while(RCC_GetFlagStatus(RCC_FLAG_LSIRDY) == RESET)
{
}
/* Select the RTC Clock Source */
RCC_RTCCLKConfig(RCC_RTCCLKSource_LSI);
/* ck_spre(1Hz) = RTCCLK(LSI) /(uwAsynchPrediv + 1)*(uwSynchPrediv + 1)*/
uwSynchPrediv = 0xFF;
uwAsynchPrediv = 0x7F;
#elif defined (RTC_CLOCK_SOURCE_LSE) /* LSE used as RTC source clock */
/* Enable the LSE OSC */
RCC_LSEConfig(RCC_LSE_ON);
/* Wait till LSE is ready */
while(RCC_GetFlagStatus(RCC_FLAG_LSERDY) == RESET)
{
}
/* Select the RTC Clock Source */
RCC_RTCCLKConfig(RCC_RTCCLKSource_LSE);
/* ck_spre(1Hz) = RTCCLK(LSE) /(uwAsynchPrediv + 1)*(uwSynchPrediv + 1)*/
uwSynchPrediv = 0xFF;
uwAsynchPrediv = 0x7F;
#else
#error Please select the RTC Clock source inside the main.c file
#endif /* RTC_CLOCK_SOURCE_LSI */
/* Enable the RTC Clock */
RCC_RTCCLKCmd(ENABLE);
/* Wait for RTC APB registers synchronisation */
RTC_WaitForSynchro();
/* Write to the first RTC Backup Data Register */
RTC_WriteBackupRegister(RTC_BKP_DR0, FIRST_DATA);
/* Display the new RCC BDCR and RTC TAFCR Registers */
LCD_UsrLog ("RTC Reconfig \n");
LCD_UsrLog ("RCC BDCR = 0x%x\n", RCC->BDCR);
LCD_UsrLog ("RTC TAFCR = 0x%x\n", RTC->TAFCR);
/* Set the Time */
RTC_TimeStructure.RTC_Hours = 0x08;
RTC_TimeStructure.RTC_Minutes = 0x00;
RTC_TimeStructure.RTC_Seconds = 0x00;
/* Set the Date */
RTC_DateStructure.RTC_Month = RTC_Month_January;
RTC_DateStructure.RTC_Date = 0x11;
RTC_DateStructure.RTC_Year = 0x13;
RTC_DateStructure.RTC_WeekDay = RTC_Weekday_Friday;
/* Calendar Configuration */
RTC_InitStructure.RTC_AsynchPrediv = uwAsynchPrediv;
RTC_InitStructure.RTC_SynchPrediv = uwSynchPrediv;
RTC_InitStructure.RTC_HourFormat = RTC_HourFormat_24;
RTC_Init(&RTC_InitStructure);
/* Set Current Time and Date */
RTC_SetTime(RTC_Format_BCD, &RTC_TimeStructure);
RTC_SetDate(RTC_Format_BCD, &RTC_DateStructure);
/* Configure the RTC Wakeup Clock source and Counter (Wakeup event each 1 second) */
RTC_WakeUpClockConfig(RTC_WakeUpClock_RTCCLK_Div16);
RTC_SetWakeUpCounter(0x7FF);
/* Enable the Wakeup Interrupt */
RTC_ITConfig(RTC_IT_WUT, ENABLE);
/* Enable Wakeup Counter */
RTC_WakeUpCmd(ENABLE);
/* Backup SRAM ***************************************************************/
/* Enable BKPRAM Clock */
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_BKPSRAM, ENABLE);
/* Write to Backup SRAM with 32-Bit Data */
for (uwIndex = 0x0; uwIndex < 0x1000; uwIndex += 4)
{
*(__IO uint32_t *) (BKPSRAM_BASE + uwIndex) = uwIndex;
}
/* Check the written Data */
for (uwIndex = 0x0; uwIndex < 0x1000; uwIndex += 4)
{
if ((*(__IO uint32_t *) (BKPSRAM_BASE + uwIndex)) != uwIndex)
{
uwErrorIndex++;
}
}
if(uwErrorIndex)
{
LCD_ErrLog ("BKP SRAM Number of errors = %d\n", uwErrorIndex);
}
else
{
LCD_UsrLog ("BKP SRAM write OK \n");
}
/* Enable the Backup SRAM low power Regulator to retain it's content in VBAT mode */
PWR_BackupRegulatorCmd(ENABLE);
/* Wait until the Backup SRAM low power Regulator is ready */
while(PWR_GetFlagStatus(PWR_FLAG_BRR) == RESET)
{
}
/* RTC Backup Data Registers **************************************************/
/* Write to RTC Backup Data Registers */
WriteToBackupReg(FIRST_DATA);
}
/**
* @brief USBH_USR_DeviceNotSupported
* Device is not supported
* @param None
* @retval None
*/
void USBH_USR_DeviceNotSupported(void)
{
LCD_ErrLog ("> Device not supported.");
}
/**
* @brief USBH_USR_MSC_Application
* Demo application for mass storage
* @param None
* @retval Staus
*/
int USBH_USR_MSC_Application(void)
{
FRESULT res;
uint8_t writeTextBuff[] = "BIG_MANTA FS/HS STM32 Connectivity line Host Demo application using FAT_FS ";
uint16_t bytesWritten, bytesToWrite;
/* Set LCD Layer size and pixel format */
LTDC_LayerPixelFormat(LTDC_Layer2, LTDC_Pixelformat_RGB565);
LTDC_LayerSize(LTDC_Layer2, 240, 320);
/* LTDC reload configuration */
LTDC_ReloadConfig(LTDC_IMReload);
switch(USBH_USR_ApplicationState)
{
case USH_USR_FS_INIT:
/* Initialises the File System*/
if ( f_mount( 0, &fatfs ) != FR_OK )
{
/* efs initialisation fails*/
LCD_ErrLog("> Cannot initialize File System.\n");
return(-1);
}
LCD_UsrLog("> File System initialized.\n");
LCD_UsrLog("> Disk capacity : %d Bytes\n", USBH_MSC_Param.MSCapacity * \
USBH_MSC_Param.MSPageLength);
if(USBH_MSC_Param.MSWriteProtect == DISK_WRITE_PROTECTED)
{
LCD_ErrLog((void *)MSG_WR_PROTECT);
}
USBH_USR_ApplicationState = USH_USR_FS_READLIST;
break;
case USH_USR_FS_READLIST:
LCD_UsrLog((void *)MSG_ROOT_CONT);
Explore_Disk("0:/", 1);
line_idx = 0;
USBH_USR_ApplicationState = USH_USR_FS_WRITEFILE;
break;
case USH_USR_FS_WRITEFILE:
/*Key B3 in polling*/
while((HCD_IsDeviceConnected(&USB_OTG_Core)) && \
(STM_EVAL_PBGetState (BUTTON_USER) != RESET))
{
Toggle_Leds();
}
/* Writes a text file, STM32.TXT in the disk*/
LCD_UsrLog("> Writing File to disk flash ...\n");
if(USBH_MSC_Param.MSWriteProtect == DISK_WRITE_PROTECTED)
{
LCD_ErrLog ( "> Disk flash is write protected \n");
USBH_USR_ApplicationState = USH_USR_FS_DRAW;
break;
}
/* Register work area for logical drives */
f_mount(0, &fatfs);
if(f_open(&file, "0:STM32.TXT",FA_CREATE_ALWAYS | FA_WRITE) == FR_OK)
{
/* Write buffer to file */
bytesToWrite = sizeof(writeTextBuff);
res= f_write (&file, writeTextBuff, bytesToWrite, (void *)&bytesWritten);
if((bytesWritten == 0) || (res != FR_OK)) /*EOF or Error*/
{
LCD_ErrLog("> STM32.TXT CANNOT be writen.\n");
}
else
{
LCD_UsrLog("> 'STM32.TXT' file created\n");
}
/*close file and filesystem*/
f_close(&file);
f_mount(0, NULL);
}
else
{
LCD_UsrLog ("> STM32.TXT created in the disk\n");
}
USBH_USR_ApplicationState = USH_USR_FS_DRAW;
LCD_SetTextColor(Green);
LCD_DisplayStringLine(LCD_LINE_15,"To start Image slide show ");
LCD_DisplayStringLine(LCD_LINE_16,"Press Key ");
LCD_SetTextColor(LCD_LOG_DEFAULT_COLOR);
while(STM_EVAL_PBGetState (BUTTON_USER) != SET)
{
Toggle_Leds();
}
break;
case USH_USR_FS_DRAW:
/*Key B3 in polling*/
while((HCD_IsDeviceConnected(&USB_OTG_Core)) && \
(STM_EVAL_PBGetState (BUTTON_USER) != RESET))
{
Toggle_Leds();
}
while(HCD_IsDeviceConnected(&USB_OTG_Core))
{
if ( f_mount( 0, &fatfs ) != FR_OK )
{
/* fat_fs initialisation fails*/
return(-1);
}
return Image_Browser("0:/");
}
break;
default: break;
}
return(0);
}
/**
* @brief Processes traffic received on UDP port 69
* @param args: pointer on tftp_connection arguments
* @param upcb: pointer on udp_pcb structure
* @param pbuf: pointer on packet buffer
* @param addr: pointer on the receive IP address
* @param port: receive port number
* @retval None
*/
static void IAP_tftp_recv_callback(void *arg, struct udp_pcb *upcb, struct pbuf *pkt_buf,
struct ip_addr *addr, u16_t port)
{
tftp_opcode op;
struct udp_pcb *upcb_tftp_data;
err_t err;
#ifdef USE_LCD
uint32_t i;
char filename[40],message[40], *ptr;
#endif
/* create new UDP PCB structure */
upcb_tftp_data = udp_new();
if (!upcb_tftp_data)
{
/* Error creating PCB. Out of Memory */
#ifdef USE_LCD
LCD_ErrLog("Can not create pcb \n");
#endif
return;
}
/* bind to port 0 to receive next available free port */
/* NOTE: This is how TFTP works. There is a UDP PCB for the standard port
* 69 which al transactions begin communication on, however, _all_ subsequent
* transactions for a given "stream" occur on another port */
err = udp_bind(upcb_tftp_data, IP_ADDR_ANY, 0);
if (err != ERR_OK)
{
/* Unable to bind to port */
#ifdef USE_LCD
LCD_ErrLog("Can not create pcb \n");
#endif
return;
}
op = IAP_tftp_decode_op(pkt_buf->payload);
if (op != TFTP_WRQ)
{
/* remove PCB */
#ifdef USE_LCD
LCD_ErrLog("Bad TFTP opcode \n");
#endif
udp_remove(upcb_tftp_data);
}
else
{
#ifdef USE_LCD
ptr = pkt_buf->payload;
ptr = ptr +2;
/*extract file name info */
i= 0;
while (*(ptr+i)!=0x0)
{
i++;
}
strncpy(filename, ptr, i+1);
LCD_UsrLog("IAP using TFTP \n");
sprintf(message, "File: %s",filename);
LCD_UsrLog("%s\n", message);
LCD_UsrLog(" State: Erasing...\n");
#endif
/* Start the TFTP write mode*/
IAP_tftp_process_write(upcb_tftp_data, addr, port);
}
pbuf_free(pkt_buf);
}
/**
* @brief USBH_USR_UnrecoveredError
* @param None
* @retval None
*/
void USBH_USR_UnrecoveredError (void)
{
/* Set default screen color*/
LCD_ErrLog((void *)MSG_UNREC_ERROR);
}
/**
* @brief Processes data transfers after a TFTP write request
* @param _args: used as pointer on TFTP connection args
* @param upcb: pointer on udp_pcb structure
* @param pkt_buf: pointer on a pbuf stucture
* @param ip_addr: pointer on the receive IP_address structure
* @param port: receive port address
* @retval None
*/
static void IAP_wrq_recv_callback(void *_args, struct udp_pcb *upcb, struct pbuf *pkt_buf, struct ip_addr *addr, u16_t port)
{
tftp_connection_args *args = (tftp_connection_args *)_args;
uint32_t data_buffer[128];
uint16_t count=0;
#ifdef USE_LCD
char message[40];
#endif
if (pkt_buf->len != pkt_buf->tot_len)
{
#ifdef USE_LCD
LCD_ErrLog("Invalid data length\n");
#endif
return;
}
/* Does this packet have any valid data to write? */
if ((pkt_buf->len > TFTP_DATA_PKT_HDR_LEN) &&
(IAP_tftp_extract_block(pkt_buf->payload) == (args->block + 1)))
{
/* copy packet payload to data_buffer */
pbuf_copy_partial(pkt_buf, data_buffer, pkt_buf->len - TFTP_DATA_PKT_HDR_LEN,
TFTP_DATA_PKT_HDR_LEN);
total_count += pkt_buf->len - TFTP_DATA_PKT_HDR_LEN;
count = (pkt_buf->len - TFTP_DATA_PKT_HDR_LEN)/4;
if (((pkt_buf->len - TFTP_DATA_PKT_HDR_LEN)%4)!=0)
count++;
/* Write received data in Flash */
FLASH_If_Write(&Flash_Write_Address, data_buffer ,count);
/* update our block number to match the block number just received */
args->block++;
/* update total bytes */
(args->tot_bytes) += (pkt_buf->len - TFTP_DATA_PKT_HDR_LEN);
/* This is a valid pkt but it has no data. This would occur if the file being
written is an exact multiple of 512 bytes. In this case, the args->block
value must still be updated, but we can skip everything else. */
}
else if (IAP_tftp_extract_block(pkt_buf->payload) == (args->block + 1))
{
/* update our block number to match the block number just received */
args->block++;
}
/* Send the appropriate ACK pkt*/
IAP_tftp_send_ack_packet(upcb, addr, port, args->block);
/* If the last write returned less than the maximum TFTP data pkt length,
* then we've received the whole file and so we can quit (this is how TFTP
* signals the EndTransferof a transfer!)
*/
if (pkt_buf->len < TFTP_DATA_PKT_LEN_MAX)
{
IAP_tftp_cleanup_wr(upcb, args);
pbuf_free(pkt_buf);
#ifdef USE_LCD
sprintf(message, "%d bytes ",(int)total_count);
LCD_UsrLog("Tot bytes Received:, %s\n", message);
LCD_UsrLog(" State: Prog Finished \n");
LCD_UsrLog("Reset the board \n");
#endif
}
else
{
pbuf_free(pkt_buf);
return;
}
}
/**
* @brief Manages HID Menu Process.
* @param None
* @retval None
*/
void HID_MenuProcess(void)
{
switch(hid_demo.state)
{
case HID_DEMO_IDLE:
BSP_LCD_SetTextColor(LCD_COLOR_GREEN);
BSP_LCD_DisplayStringAtLine(17, (uint8_t *)"Use [Buttons Left/Right] to scroll up/down ");
BSP_LCD_DisplayStringAtLine(18, (uint8_t *)"Use [Joystick Up/Down] to scroll HID menu ");
BSP_LCD_DisplayStringAtLine(19, (uint8_t *)" ");
BSP_LCD_SetTextColor(LCD_COLOR_WHITE);
HID_SelectItem(DEMO_HID_menu, 0);
hid_demo.state = HID_DEMO_WAIT;
hid_demo.select = 0;
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)
{
hid_demo.select &= 0x7F;
switch(hid_demo.select)
{
case 0:
hid_demo.state = HID_DEMO_START;
break;
case 1:
hid_demo.state = HID_DEMO_REENUMERATE;
break;
default:
break;
}
}
}
break;
case HID_DEMO_START:
if(Appli_state == APPLICATION_HID)
{
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;
}
break;
case HID_DEMO_REENUMERATE:
/* Force HID Device to re-enumerate */
USBH_ReEnumerate(&hUSBHost);
hid_demo.state = HID_DEMO_WAIT;
break;
case HID_DEMO_MOUSE:
if( Appli_state == APPLICATION_HID)
{
HID_MouseMenuProcess();
USBH_MouseDemo(&hUSBHost);
}
break;
case HID_DEMO_KEYBOARD:
if( Appli_state == APPLICATION_HID)
{
HID_KeyboardMenuProcess();
USBH_KeybdDemo(&hUSBHost);
}
break;
default:
break;
}
}
/**
* @brief Manages MSC Menu Process.
* @param None
* @retval None
*/
void MSC_MenuProcess(void)
{
switch(msc_demo.state)
{
case MSC_DEMO_START:
if(Appli_state == APPLICATION_READY)
{
BSP_LCD_SetTextColor(LCD_COLOR_GREEN);
BSP_LCD_DisplayStringAtLine(19, (uint8_t *)"Press User button to start read and write operations");
/* Wait for User Input */
while((BSP_PB_GetState(BUTTON_WAKEUP) != SET) && (Appli_state != APPLICATION_DISCONNECT))
{
}
msc_demo.state = MSC_DEMO_FILE_OPERATIONS;
/* Prevent debounce effect for user key */
HAL_Delay(400);
BSP_LCD_ClearStringLine(19);
}
break;
case MSC_DEMO_FILE_OPERATIONS:
/* Read and Write File Here */
if(Appli_state == APPLICATION_READY)
{
MSC_File_Operations();
BSP_LCD_SetTextColor(LCD_COLOR_GREEN);
BSP_LCD_DisplayStringAtLine(19, (uint8_t *)"Press User button to display disk content");
/* Wait for User Input */
while((BSP_PB_GetState(BUTTON_WAKEUP) != SET) && (Appli_state != APPLICATION_DISCONNECT))
{
}
msc_demo.state = MSC_DEMO_EXPLORER;
/* Prevent debounce effect for user key */
HAL_Delay(400);
BSP_LCD_ClearStringLine(19);
}
break;
case MSC_DEMO_EXPLORER:
/* Display disk content */
if(Appli_state == APPLICATION_READY)
{
Explore_Disk("0:/", 1);
msc_demo.state = MSC_DEMO_START;
/* Prevent debounce effect for user key */
HAL_Delay(400);
}
break;
default:
break;
}
if(Appli_state == APPLICATION_DISCONNECT)
{
Appli_state = APPLICATION_IDLE;
LCD_LOG_ClearTextZone();
LCD_ErrLog("MSC device disconnected!\n");
msc_demo.state = MSC_DEMO_START;
msc_demo.select = 0;
}
}
/**
* @brief Manages CDC Menu Process.
* @param None
* @retval None
*/
void CDC_MenuProcess(void)
{
switch(CdcDemo.state)
{
case CDC_DEMO_IDLE:
CDC_SelectItem(CDC_main_menu, 0);
CdcDemo.state = CDC_DEMO_WAIT;
CdcDemo.select = 0;
break;
case CDC_DEMO_WAIT:
if(CdcDemo.select != PrevSelect)
{
PrevSelect = CdcDemo.select;
CDC_SelectItem(CDC_main_menu, CdcDemo.select & 0x7F);
/* Handle select item */
if(CdcDemo.select & 0x80)
{
switch(CdcDemo.select & 0x7F)
{
case 0:
CdcDemo.state = CDC_DEMO_SEND;
CdcDemo.Send_state = CDC_SEND_IDLE;
break;
case 1:
CdcDemo.state = CDC_DEMO_RECEIVE;
CdcDemo.Receive_state = CDC_RECEIVE_IDLE;
break;
case 2:
CdcDemo.state = CDC_DEMO_CONFIGURATION;
CdcDemo.Configuration_state = CDC_CONFIGURATION_IDLE;
break;
case 3:
CdcDemo.state = CDC_DEMO_REENUMERATE;
break;
default:
break;
}
}
}
break;
case CDC_DEMO_SEND:
if(Appli_state == APPLICATION_READY)
{
CDC_Handle_Send_Menu();
}
else
{
CdcDemo.state = CDC_DEMO_WAIT;
}
break;
case CDC_DEMO_RECEIVE:
if(Appli_state == APPLICATION_READY)
{
CDC_Handle_Receive_Menu();
}
else
{
CdcDemo.state = CDC_DEMO_WAIT;
}
break;
case CDC_DEMO_CONFIGURATION:
if(Appli_state == APPLICATION_READY)
{
CDC_Handle_Configuration_Menu();
}
else
{
CdcDemo.state = CDC_DEMO_WAIT;
}
break;
case CDC_DEMO_REENUMERATE:
/* Force Device to re-enumerate */
USBH_ReEnumerate(&hUSBHost);
CdcDemo.state = CDC_DEMO_WAIT;
break;
default:
break;
}
CdcDemo.select &= 0x7F;
if(Appli_state == APPLICATION_DISCONNECT)
{
Appli_state = APPLICATION_IDLE;
LCD_LOG_ClearTextZone();
LCD_ErrLog("CDC device disconnected!\n");
CDC_ChangeSelectMode(CDC_SELECT_MENU);
CdcDemo.state = CDC_DEMO_IDLE;
CdcDemo.select = 0;
}
}
/**
* @brief Manages HID Menu Process.
* @param None
* @retval None
*/
void HID_MenuProcess(void)
{
switch(demo.hid_state)
{
case APPLI_HID_IDLE:
Demo_SelectItem(DEMO_HID_menu, 0);
demo.hid_state = APPLI_HID_WAIT;
demo.select = 0;
break;
case APPLI_HID_WAIT:
if(demo.select != prev_select)
{
prev_select = demo.select;
Demo_SelectItem(DEMO_HID_menu, demo.select & 0x7F);
/* Handle select item */
if(demo.select & 0x80)
{
demo.select &= 0x7F;
switch(demo.select)
{
case 0:
demo.hid_state = APPLI_HID_START;
break;
case 1:
demo.state = DEMO_IDLE;
demo.select = 0;
LCD_UsrLogY("> HID application closed.\n");
break;
default:
break;
}
}
}
break;
case APPLI_HID_START:
if(Appli_FS_state == APPLICATION_FS_READY)
{
if(USBH_HID_GetDeviceType(&hUSBHost_FS) == HID_KEYBOARD)
{
demo.keyboard_state = HID_KEYBOARD_IDLE;
demo.hid_state = APPLI_HID_KEYBOARD;
}
else if(USBH_HID_GetDeviceType(&hUSBHost_FS) == HID_MOUSE)
{
demo.mouse_state = HID_MOUSE_IDLE;
demo.hid_state = APPLI_HID_MOUSE;
}
}
else
{
LCD_ErrLog("No supported HID device!\n");
demo.hid_state = APPLI_HID_WAIT;
}
break;
case APPLI_HID_MOUSE:
if(Appli_FS_state == APPLICATION_FS_READY)
{
HID_MouseMenuProcess();
USBH_MouseDemo(&hUSBHost_FS);
}
break;
case APPLI_HID_KEYBOARD:
if(Appli_FS_state == APPLICATION_FS_READY)
{
HID_KeyboardMenuProcess();
USBH_KeybdDemo(&hUSBHost_FS);
}
break;
default:
break;
}
}
/**
* @brief Files operations: Read/Write and compare
* @param None
* @retval None
*/
void MSC_File_Operations(void)
{
uint16_t bytesread;
/* Register the file system object to the FatFs module */
if(f_mount(&USBH_fatfs, "", 0) != FR_OK)
{
LCD_ErrLog("Cannot Initialize FatFs! \n");
}
else
{
LCD_UsrLog("INFO : FatFs Initialized \n");
if(f_open(&MyFile, "0:USBHost.txt",FA_CREATE_ALWAYS | FA_WRITE) != FR_OK)
{
LCD_ErrLog("Cannot Open 'USBHost.txt' file \n");
}
else
{
LCD_UsrLog("INFO : 'USBHost.txt' opened for write \n");
res= f_write (&MyFile, wtext, sizeof(wtext), (void *)&bytesWritten);
f_close(&MyFile);
if((bytesWritten == 0) || (res != FR_OK)) /*EOF or Error*/
{
LCD_ErrLog("Cannot Write on the 'USBHost.txt' file \n");
}
else
{
if(f_open(&MyFile, "0:USBHost.txt", FA_READ) != FR_OK)
{
LCD_ErrLog("Cannot Open 'USBHost.txt' file for read.\n");
}
else
{
LCD_UsrLog("INFO : Text written on the 'USBHost.txt' file \n");
res = f_read(&MyFile, rtext, sizeof(rtext), (void *)&bytesread);
if((bytesread == 0) || (res != FR_OK)) /*EOF or Error*/
{
LCD_ErrLog("Cannot Read from the 'USBHost.txt' file \n");
}
else
{
LCD_UsrLog("Read Text : \n");
LCD_DbgLog((char *)rtext);
LCD_DbgLog("\n");
}
f_close(&MyFile);
}
/* Compare read data with the expected data */
if((bytesread == bytesWritten))
{
LCD_UsrLog("INFO : FatFs data compare SUCCES");
LCD_UsrLog("\n");
}
else
{
LCD_ErrLog("FatFs data compare ERROR");
LCD_ErrLog("\n");
}
}
}
}
}
/**
* @brief USBH_USR_OverCurrentDetected
* Device Overcurrent detection event
* @param None
* @retval None
*/
void USBH_USR_OverCurrentDetected (void)
{
LCD_ErrLog ("Overcurrent detected.\n");
}
/**
* @brief Manages MTP Menu Process.
* @param None
* @retval None
*/
void MTP_MenuProcess(void)
{
switch(mtp_demo.state)
{
case MTP_DEMO_IDLE:
MTP_SelectItem(MTP_main_menu, 0);
mtp_demo.state = MTP_DEMO_WAIT;
mtp_demo.select = 0;
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 MTP menu");
break;
case MTP_DEMO_WAIT:
if(mtp_demo.select != prev_select)
{
prev_select = mtp_demo.select;
MTP_SelectItem(MTP_main_menu, mtp_demo.select & 0x7F);
/* Handle select item */
if(mtp_demo.select & 0x80)
{
switch(mtp_demo.select & 0x7F)
{
case 0:
mtp_demo.state = MTP_DEMO_EXPLORE;
break;
case 1:
/* Display HMI messages */
BSP_LCD_SetTextColor(LCD_COLOR_GREEN);
BSP_LCD_DisplayStringAtLine(14, (uint8_t *)" ");
BSP_LCD_DisplayStringAtLine(15, (uint8_t *)" ");
BSP_LCD_DisplayStringAtLine(16, (uint8_t *)"Use [User Key] To Stop and return from player");
BSP_LCD_SetTextColor(LCD_COLOR_WHITE);
/* Set PLAYBACK state and start playing 1st file */
audio_state = AUDIO_STATE_IDLE;
mtp_demo.state = MTP_DEMO_PLAYBACK;
MTP_ChangeSelectMode(MTP_PLAYBACK_CONTROL);
break;
case 2:
mtp_demo.state = MTP_REENUMERATE;
break;
default:
break;
}
}
}
break;
case MTP_DEMO_EXPLORE:
if(Appli_state == APPLICATION_READY)
{
if(MTP_Init() == 0)
{
if(MTP_ExploreWavFile() > 0)
{
LCD_ErrLog("There is no WAV file on the microSD.\n" );
MTP_ChangeSelectMode(MTP_SELECT_MENU);
mtp_demo.state = MTP_DEMO_IDLE;
}
else
{
mtp_demo.state = MTP_DEMO_WAIT;
}
}
}
else
{
mtp_demo.state = MTP_DEMO_WAIT;
}
break;
case MTP_DEMO_PLAYBACK:
if(Appli_state == APPLICATION_READY)
{
if(MTP_Init() == 0)
{
if(audio_state == AUDIO_STATE_IDLE)
{
/* Start Playing */
audio_state = AUDIO_STATE_INIT;
if(AUDIO_Start(0) == AUDIO_ERROR_IO)
{
MTP_ChangeSelectMode(MTP_SELECT_MENU);
mtp_demo.state = MTP_DEMO_IDLE;
}
else
{
BSP_LCD_SetTextColor(LCD_COLOR_YELLOW);
BSP_LCD_DisplayStringAtLine(10, (uint8_t *)"[ UP ] : Volume +");
BSP_LCD_DisplayStringAtLine(11, (uint8_t *)"[ DOWN ] : Volume -");
BSP_LCD_DisplayStringAtLine(12, (uint8_t *)"[ LEFT ] : Previous");
BSP_LCD_DisplayStringAtLine(13, (uint8_t *)"[ RIGHT ] : Next");
BSP_LCD_DisplayStringAtLine(14, (uint8_t *)"[ SEL ] : Pause/Resume");
BSP_LCD_SetTextColor(LCD_COLOR_WHITE);
}
}
else /* Not idle */
{
if(AUDIO_Process() == AUDIO_ERROR_IO)
{
MTP_ChangeSelectMode(MTP_SELECT_MENU);
mtp_demo.state = MTP_DEMO_IDLE;
}
}
}
}
else
{
mtp_demo.state = MTP_DEMO_WAIT;
}
break;
case MTP_REENUMERATE:
/* Force MTP Device to re-enumerate */
USBH_ReEnumerate(&hUSBHost);
mtp_demo.state = MTP_DEMO_WAIT;
break;
default:
break;
}
if(Appli_state == APPLICATION_DISCONNECT)
{
Appli_state = APPLICATION_IDLE;
BSP_AUDIO_OUT_Stop(CODEC_PDWN_SW);
MTP_ChangeSelectMode(MTP_SELECT_MENU);
}
mtp_demo.select &= 0x7F;
}
/**
* @brief Manages HID Menu Process.
* @param None
* @retval None
*/
void HID_MenuProcess(void)
{
switch(hid_demo.state)
{
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;
BSP_LCD_SetTextColor(LCD_COLOR_GREEN);
BSP_LCD_DisplayStringAtLine(19, (uint8_t *)"Press User button to start");
/* Wait for User Input */
while((BSP_PB_GetState(BUTTON_WAKEUP) != SET) && (Appli_state != APPLICATION_DISCONNECT))
{
}
BSP_LCD_ClearStringLine(19);
HID_KeyboardMenuProcess();
}
else if(USBH_HID_GetDeviceType(&hUSBHost) == HID_MOUSE)
{
hid_demo.mouse_state = HID_MOUSE_IDLE;
hid_demo.state = HID_DEMO_MOUSE;
BSP_LCD_SetTextColor(LCD_COLOR_GREEN);
BSP_LCD_DisplayStringAtLine(19, (uint8_t *)"Press User button to start");
/* Wait for User Input */
while((BSP_PB_GetState(BUTTON_WAKEUP) != SET) && (Appli_state != APPLICATION_DISCONNECT))
{
}
BSP_LCD_ClearStringLine(19);
HID_MouseMenuProcess();
}
else
{
LCD_ErrLog("No supported HID device!\n");
hid_demo.state = HID_DEMO_START;
}
}
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();
LCD_ErrLog("HID device disconnected!\n");
hid_demo.state = HID_DEMO_START;
hid_demo.select = 0;
}
}
/**
* @brief Main program
* @param None
* @retval None
*/
int main(void)
{
NVIC_InitTypeDef NVIC_InitStructure;
EXTI_InitTypeDef EXTI_InitStructure;
/*!< At this stage the microcontroller clock setting is already configured,
this is done through SystemInit() function which is called from startup
files (startup_stm32f40_41xxx.s/startup_stm32f427_437xx.s)
before to branch to application main.
*/
/* Configure the external interrupt "WAKEUP" and "TAMPER" buttons */
STM_EVAL_PBInit(BUTTON_TAMPER , BUTTON_MODE_GPIO);
STM_EVAL_PBInit(BUTTON_WAKEUP , BUTTON_MODE_GPIO);
/* Initialize the LCD */
LCD_Init();
/* Configure the LCD Log Module */
LCD_LOG_Init();
LCD_LOG_SetHeader((uint8_t*)"RTC Backup Domain Example");
LCD_LOG_SetFooter ((uint8_t*)" Copyright (c) STMicroelectronics" );
/* Display the default RCC BDCR and RTC TAFCR Registers */
LCD_UsrLog ("Entry Point \n");
LCD_UsrLog ("RCC BDCR = 0x%x\n", RCC->BDCR);
LCD_UsrLog ("RTC TAFCR = 0x%x\n", RTC->TAFCR);
/* Enable the PWR APB1 Clock Interface */
RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR, ENABLE);
/* Allow access to BKP Domain */
PWR_BackupAccessCmd(ENABLE);
/* Configure one bit for preemption priority */
NVIC_PriorityGroupConfig(NVIC_PriorityGroup_1);
/* Enable the RTC Interrupt */
NVIC_InitStructure.NVIC_IRQChannel = RTC_WKUP_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
/* EXTI configuration */
EXTI_ClearITPendingBit(EXTI_Line22);
EXTI_InitStructure.EXTI_Line = EXTI_Line22;
EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;
EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising;
EXTI_InitStructure.EXTI_LineCmd = ENABLE;
EXTI_Init(&EXTI_InitStructure);
if(RTC_ReadBackupRegister(RTC_BKP_DR0) != FIRST_DATA)
{
LCD_UsrLog ("RTC Config PLZ Wait. \n");
/* RTC Configuration */
RTC_Config();
/* Adjust Current Time */
Time_Adjust();
/* Adjust Current Date */
Date_Adjust();
}
else
{
/* Wait for RTC APB registers synchronisation */
RTC_WaitForSynchro();
RTC_ClearITPendingBit(RTC_IT_WUT);
EXTI_ClearITPendingBit(EXTI_Line22);
/* Backup SRAM ***************************************************************/
/* Enable BKPSRAM Clock */
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_BKPSRAM, ENABLE);
/* Check the written Data */
for (uwIndex = 0x0; uwIndex < 0x1000; uwIndex += 4)
{
if ((*(__IO uint32_t *) (BKPSRAM_BASE + uwIndex)) != uwIndex)
{
uwErrorIndex++;
}
}
if(uwErrorIndex)
{
LCD_ErrLog ("BKP SRAM Number of errors = %d\n", uwErrorIndex);
}
else
{
LCD_UsrLog ("BKP SRAM Content OK \n");
}
/* RTC Backup Data Registers **************************************************/
/* Check if RTC Backup DRx registers data are correct */
if (CheckBackupReg(FIRST_DATA) == 0x00)
{
/* OK, RTC Backup DRx registers data are correct */
LCD_UsrLog ("OK, RTC Backup DRx registers data are correct. \n");
}
else
{
/* Error, RTC Backup DRx registers data are not correct */
LCD_ErrLog ("RTC Backup DRx registers data are not correct\n");
}
}
while (1)
{
/* Infinite loop */
Calendar_Show();
}
}
/**
* @brief Handles CDC Send Menu.
* @param None
* @retval None
*/
void CDC_Handle_Send_Menu(void)
{
if(CdcSelectMode == CDC_SELECT_MENU)
{
switch(CdcDemo.Send_state)
{
case CDC_SEND_IDLE:
CdcDemo.Send_state = CDC_SEND_WAIT;
CDC_SelectItem (DEMO_SEND_menu, 0);
CdcDemo.select = 0;
PrevPos = 0;
USBH_CDC_Stop(&hUSBHost);
break;
case CDC_SEND_WAIT:
if(CdcDemo.select != PrevSelect)
{
PrevSelect = CdcDemo.select;
CDC_SelectItem (DEMO_SEND_menu, CdcDemo.select & 0x7F);
/* Handle select item */
if(CdcDemo.select & 0x80)
{
switch(CdcDemo.select & 0x7F)
{
case 0:
memset(CDC_TX_Buffer, 0x5A, TX_BUFF_SIZE);
LCD_DbgLog("Sending data ...\n");
USBH_CDC_Transmit(&hUSBHost, CDC_TX_Buffer, TX_BUFF_SIZE);
use_file = 0;
break;
case 1:
if(FileList.ptr > 0)
{
SendFileMenu_Init();
if(FilePos >= 9)
{
CDC_ShowFiles(FileOffset, 9);
}
else
{
CDC_ShowFiles(FileOffset, FilePos);
}
CdcDemo.Send_state = CDC_SEND_SELECT_FILE;
}
else
{
LCD_ErrLog("No file on the microSD\n");
}
break;
case 2: /* Return */
ReturnFromSendMenu();
break;
default:
break;
}
}
}
break;
default:
break;
}
}
else if(CdcSelectMode == CDC_SELECT_FILE)
{
switch(CdcDemo.Send_state)
{
case CDC_SEND_SELECT_FILE:
if(CdcDemo.select & 0x80)
{
CdcDemo.select &= 0x7F;
CdcDemo.Send_state = CDC_SEND_TRANSMIT_FILE;
}
break;
case CDC_SEND_TRANSMIT_FILE:
LCD_DbgLog("Sending file ...\n");
use_file = 1;
CDC_SendFile(FilePos);
CDC_ChangeSelectMode(CDC_SELECT_MENU);
LCD_LOG_UpdateDisplay();
CdcDemo.Send_state = CDC_SEND_WAIT;
break;
default:
break;
}
if(FilePos != PrevPos)
{
if(((FilePos > 9)&&(FilePos > PrevPos)) ||
((FilePos >= 9)&&(FilePos < PrevPos)))
{
if(FilePos > PrevPos)
{
FileOffset++;
}
else
{
FileOffset--;
}
CDC_ShowFiles(FileOffset, 9);
}
else
{
CDC_ShowFiles(0, FilePos);
}
PrevPos = FilePos;
}
}
CdcDemo.select &= 0x7F;
}
/**
* @brief Manages Audio Menu Process.
* @param None
* @retval None
*/
void AUDIO_MenuProcess(void)
{
switch(audio_demo.state)
{
case AUDIO_DEMO_IDLE:
BSP_LCD_SetTextColor(LCD_COLOR_GREEN);
BSP_LCD_DisplayStringAtLine(16, (uint8_t *)" ");
BSP_LCD_DisplayStringAtLine(17, (uint8_t *)"Use [Buttons Left/Right] to scroll up/down ");
BSP_LCD_DisplayStringAtLine(18, (uint8_t *)"Use [Joystick Up/Down] to scroll audio menu ");
BSP_LCD_SetTextColor(LCD_COLOR_WHITE);
AUDIO_MenuSelectItem(AUDIO_main_menu, 0);
audio_demo.state = AUDIO_DEMO_WAIT;
audio_demo.select = 0;
break;
case AUDIO_DEMO_WAIT:
if(audio_demo.select != prev_select)
{
prev_select = audio_demo.select;
AUDIO_MenuSelectItem(AUDIO_main_menu, audio_demo.select & 0x7F);
/* Handle select item */
if(audio_demo.select & 0x80)
{
audio_demo.select &= 0x7F;
switch(audio_demo.select)
{
case 0:
audio_demo.state = AUDIO_DEMO_EXPLORE;
break;
case 1:
/* Display HMI messages */
BSP_LCD_SetTextColor(LCD_COLOR_GREEN);
BSP_LCD_DisplayStringAtLine(14, (uint8_t *)" ");
BSP_LCD_DisplayStringAtLine(15, (uint8_t *)" ");
BSP_LCD_DisplayStringAtLine(16, (uint8_t *)"Use [User Key] To Stop and return from player");
BSP_LCD_SetTextColor(LCD_COLOR_WHITE);
/* Set PLAYBACK state and start playing 1st file */
audio_state = AUDIO_STATE_IDLE;
audio_demo.state = AUDIO_DEMO_PLAYBACK;
Audio_ChangeSelectMode(AUDIO_PLAYBACK_CONTROL);
break;
case 2:
audio_demo.state = AUDIO_REENUMERATE;
break;
default:
break;
}
}
}
break;
case AUDIO_DEMO_EXPLORE:
if(Appli_state == APPLICATION_AUDIO)
{
if(Audio_ShowWavFiles() > 0)
{
LCD_ErrLog("There is no WAV file on the microSD.\n");
Audio_ChangeSelectMode(AUDIO_SELECT_MENU);
}
else
{
audio_demo.state = AUDIO_DEMO_WAIT;
}
}
break;
case AUDIO_DEMO_PLAYBACK:
if(Appli_state == APPLICATION_AUDIO)
{
if(audio_state == AUDIO_STATE_IDLE)
{
/* Start Playing...*/
audio_state = AUDIO_STATE_INIT;
if(AUDIO_Start(0) == AUDIO_ERROR_IO)
{
Audio_ChangeSelectMode(AUDIO_SELECT_MENU);
}
else
{
BSP_LCD_SetTextColor(LCD_COLOR_YELLOW);
BSP_LCD_DisplayStringAtLine(10, (uint8_t *)"[ UP ] : Volume +");
BSP_LCD_DisplayStringAtLine(11, (uint8_t *)"[ DOWN ] : Volume -");
BSP_LCD_DisplayStringAtLine(12, (uint8_t *)"[ LEFT ] : Previous");
BSP_LCD_DisplayStringAtLine(13, (uint8_t *)"[ RIGHT ] : Next");
BSP_LCD_DisplayStringAtLine(14, (uint8_t *)"[ SEL ] : Pause/Resume");
BSP_LCD_SetTextColor(LCD_COLOR_WHITE);
}
}
else /* Not idle */
{
if(AUDIO_Process() == AUDIO_ERROR_IO)
{
Audio_ChangeSelectMode(AUDIO_SELECT_MENU);
}
}
}
break;
case AUDIO_REENUMERATE:
/* Force Audio Device to re-enumerate */
USBH_ReEnumerate(&hUSBHost);
audio_demo.state = AUDIO_DEMO_WAIT;
break;
default:
break;
}
}
/**
* @brief USBH_HID_USR_UnrecoveredError
* @param None
* @retval None
*/
void USBH_HID_USR_UnrecoveredError (void)
{
LCD_ErrLog((void*)MSG_UNREC_ERROR);
}
/**
* @brief Manages HID Menu Process.
* @param None
* @retval None
*/
void HID_MenuProcess(void)
{
switch(hid_demo.state)
{
case HID_DEMO_IDLE:
HID_SelectItem(DEMO_HID_menu, 0);
hid_demo.state = HID_DEMO_WAIT;
hid_demo.select = 0;
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)
{
hid_demo.select &= 0x7F;
switch(hid_demo.select)
{
case 0:
hid_demo.state = HID_DEMO_START;
break;
case 1:
hid_demo.state = HID_DEMO_REENUMERATE;
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;
}
break;
case HID_DEMO_REENUMERATE:
/* Force HID Device to re-enumerate */
USBH_ReEnumerate(&hUSBHost);
hid_demo.state = HID_DEMO_WAIT;
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;
}
}
/**
* @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;
}
}
}
}