/**
* @brief Main program
* @param None
* @retval None
*/
int main(void)
{
uint32_t counter = 0, transparency = 0;
uint8_t str[30];
uwInternalBuffer = (uint8_t *)INTERNAL_BUFFER_START_ADDRESS;
/* STM32F4xx HAL library initialization:
- Configure the Flash prefetch, instruction and Data caches
- Configure the Systick to generate an interrupt each 1 msec
- Set NVIC Group Priority to 4
- Global MSP (MCU Support Package) initialization
*/
HAL_Init();
/* Configure the system clock to 200 MHz */
SystemClock_Config();
/* Configure LED3 */
BSP_LED_Init(LED3);
/*##-1- Configure LCD ######################################################*/
LCD_Config();
/*##-2- Link the SD Card disk I/O driver ###################################*/
if(FATFS_LinkDriver(&SD_Driver, SD_Path) == 0)
{
/*##-3- Initialize the Directory Files pointers (heap) ###################*/
for (counter = 0; counter < MAX_BMP_FILES; counter++)
{
pDirectoryFiles[counter] = malloc(MAX_BMP_FILE_NAME);
if(pDirectoryFiles[counter] == NULL)
{
/* Set the Text Color */
BSP_LCD_SetTextColor(LCD_COLOR_RED);
BSP_LCD_DisplayStringAtLine(8, (uint8_t*)" Cannot allocate memory ");
while(1) { ; }
}
}
/* Get the BMP file names on root directory */
ubNumberOfFiles = Storage_GetDirectoryBitmapFiles("/Media", pDirectoryFiles);
if (ubNumberOfFiles == 0)
{
for (counter = 0; counter < MAX_BMP_FILES; counter++)
{
free(pDirectoryFiles[counter]);
}
BSP_LCD_DisplayStringAtLine(8, (uint8_t*)" No Bitmap files... ");
while(1) { ; }
}
}
else
{
/* FatFs Initialization Error */
Error_Handler();
}
/* Main infinite loop */
while(1)
{
counter = 0;
while ((counter) < ubNumberOfFiles)
{
/* Step1 : Display on Foreground layer -------------------------------*/
/* Format the string */
sprintf ((char*)str, "Media/%-11.11s", pDirectoryFiles[counter]);
if (Storage_CheckBitmapFile((const char*)str, &uwBmplen) == 0)
{
/* Format the string */
sprintf ((char*)str, "Media/%-11.11s", pDirectoryFiles[counter]);
/* Set LCD foreground Layer */
BSP_LCD_SelectLayer(LTDC_ACTIVE_LAYER_FOREGROUND);
/* Open a file and copy its content to an internal buffer */
Storage_OpenReadFile(uwInternalBuffer, (const char*)str);
/* Write bmp file on LCD frame buffer */
BSP_LCD_DrawBitmap(0, 0, uwInternalBuffer);
/* Configure the transparency for background layer : Increase the transparency */
for (transparency = 0; transparency < 255; (transparency++))
{
BSP_LCD_SetTransparency(LTDC_ACTIVE_LAYER_FOREGROUND, transparency);
/* Insert a delay of display */
HAL_Delay(10);
}
/* Configure the transparency for foreground layer : decrease the transparency */
for (transparency = 255; transparency > 0; transparency--)
{
BSP_LCD_SetTransparency(LTDC_ACTIVE_LAYER_FOREGROUND, transparency);
/* Insert a delay of display */
HAL_Delay(10);
}
HAL_Delay(1000);
/* Clear the Foreground Layer */
BSP_LCD_Clear(LCD_COLOR_BLACK);
/* Jump to the next image */
counter++;
/* Step2 : Display on Background layer -----------------------------*/
/* Format the string */
sprintf ((char*)str, "Media/%-11.11s", pDirectoryFiles[counter]);
if ((Storage_CheckBitmapFile((const char*)str, &uwBmplen) == 0) || (counter < (ubNumberOfFiles)))
{
/* Connect the Output Buffer to LCD Background Layer */
BSP_LCD_SelectLayer(LTDC_ACTIVE_LAYER_BACKGROUND);
/* Format the string */
sprintf ((char*)str, "Media/%-11.11s", pDirectoryFiles[counter]);
/* Open a file and copy its content to an internal buffer */
Storage_OpenReadFile(uwInternalBuffer, (const char*)str);
/* Write bmp file on LCD frame buffer */
BSP_LCD_DrawBitmap(0, 0, uwInternalBuffer);
/* Configure the transparency for background layer : decrease the transparency */
for (transparency = 0; transparency < 255; (transparency++))
{
BSP_LCD_SetTransparency(LTDC_ACTIVE_LAYER_BACKGROUND, transparency);
/* Insert a delay of display */
HAL_Delay(10);
}
HAL_Delay(1000);
/* Step3 : -------------------------------------------------------*/
/* Configure the transparency for background layer : Increase the transparency */
for (transparency = 255; transparency > 0; transparency--)
{
BSP_LCD_SetTransparency(LTDC_ACTIVE_LAYER_BACKGROUND, transparency);
/* Insert a delay of display */
HAL_Delay(10);
}
HAL_Delay(1000);
/* Clear the Background Layer */
BSP_LCD_Clear(LCD_COLOR_BLACK);
counter++;
}
else if (Storage_CheckBitmapFile((const char*)str, &uwBmplen) == 0)
{
/* Set the Text Color */
BSP_LCD_SetTextColor(LCD_COLOR_RED);
BSP_LCD_DisplayStringAtLine(7, (uint8_t *) str);
BSP_LCD_DisplayStringAtLine(8, (uint8_t*)" File type not supported. ");
while(1) { ; }
}
}
}
}
}
/**
* @brief Draw Touchscreen Background
* @param state : touch zone state
* @retval None
*/
static void Touchscreen_DrawBackground (uint8_t state)
{
switch(state)
{
case 0:
BSP_LCD_SetTextColor(LCD_COLOR_BLUE);
BSP_LCD_FillCircle(CIRCLE_XPOS(1), CIRCLE_YPOS(1), CIRCLE_RADIUS);
BSP_LCD_SetTextColor(LCD_COLOR_RED);
BSP_LCD_FillCircle(CIRCLE_XPOS(2), CIRCLE_YPOS(2), CIRCLE_RADIUS);
BSP_LCD_SetTextColor(LCD_COLOR_YELLOW);
BSP_LCD_FillCircle(CIRCLE_XPOS(3), CIRCLE_YPOS(3), CIRCLE_RADIUS);
BSP_LCD_SetTextColor(LCD_COLOR_GREEN);
BSP_LCD_FillCircle(CIRCLE_XPOS(4), CIRCLE_YPOS(3), CIRCLE_RADIUS);
BSP_LCD_SetTextColor(LCD_COLOR_WHITE);
BSP_LCD_FillCircle(CIRCLE_XPOS(1), CIRCLE_YPOS(1), CIRCLE_RADIUS - 2);
BSP_LCD_FillCircle(CIRCLE_XPOS(2), CIRCLE_YPOS(2), CIRCLE_RADIUS - 2);
BSP_LCD_FillCircle(CIRCLE_XPOS(3), CIRCLE_YPOS(3), CIRCLE_RADIUS - 2);
BSP_LCD_FillCircle(CIRCLE_XPOS(4), CIRCLE_YPOS(3), CIRCLE_RADIUS - 2);
break;
case 1:
BSP_LCD_SetTextColor(LCD_COLOR_BLUE);
BSP_LCD_FillCircle(CIRCLE_XPOS(1), CIRCLE_YPOS(1), CIRCLE_RADIUS);
BSP_LCD_SetTextColor(LCD_COLOR_WHITE);
BSP_LCD_FillCircle(CIRCLE_XPOS(1), CIRCLE_YPOS(1), CIRCLE_RADIUS - 2);
break;
case 2:
BSP_LCD_SetTextColor(LCD_COLOR_RED);
BSP_LCD_FillCircle(CIRCLE_XPOS(2), CIRCLE_YPOS(2), CIRCLE_RADIUS);
BSP_LCD_SetTextColor(LCD_COLOR_WHITE);
BSP_LCD_FillCircle(CIRCLE_XPOS(2), CIRCLE_YPOS(2), CIRCLE_RADIUS - 2);
break;
case 4:
BSP_LCD_SetTextColor(LCD_COLOR_YELLOW);
BSP_LCD_FillCircle(CIRCLE_XPOS(3), CIRCLE_YPOS(3), CIRCLE_RADIUS);
BSP_LCD_SetTextColor(LCD_COLOR_WHITE);
BSP_LCD_FillCircle(CIRCLE_XPOS(3), CIRCLE_YPOS(3), CIRCLE_RADIUS - 2);
break;
case 8:
BSP_LCD_SetTextColor(LCD_COLOR_GREEN);
BSP_LCD_FillCircle(CIRCLE_XPOS(4), CIRCLE_YPOS(4), CIRCLE_RADIUS);
BSP_LCD_SetTextColor(LCD_COLOR_WHITE);
BSP_LCD_FillCircle(CIRCLE_XPOS(4), CIRCLE_YPOS(4), CIRCLE_RADIUS - 2);
break;
}
}
/**
* @brief Animation demo
* @param None
* @retval None
*/
void Animation_demo (void)
{
uint32_t exit = 0;
uint32_t CameraChangeResolutionAsked = 1;
#ifdef USE_CAMERA_IN_ANIMATION
uint32_t camera_status = CAMERA_OK;
uint32_t argb8888_Value = 0x00556677;
uint32_t CameraResX = CAMERA_VGA_RES_X;
uint32_t CameraResY = CAMERA_VGA_RES_Y;
#endif /* USE_CAMERA_IN_ANIMATION */
Animation_SetHint();
/*## Camera Initialization and start capture ############################*/
BSP_LCD_SetBackColor(LCD_COLOR_BLUE);
BSP_LCD_SetTextColor(LCD_COLOR_WHITE);
#ifdef USE_CAMERA_IN_ANIMATION
BSP_LCD_DisplayStringAt(0, BSP_LCD_GetYSize() - ANIMATION_STATUS_TEXT_POS, (uint8_t *)"Wait for camera initialization...", CENTER_MODE);
#endif /* USE_CAMERA_IN_ANIMATION */
/* Infinite loop */
while (exit == 0)
{
if(CameraChangeResolutionAsked) /* A camera change resolution has been asked */
{
CameraChangeResolutionAsked = 0;
BSP_LCD_SetBackColor(LCD_COLOR_WHITE);
BSP_LCD_SetTextColor(LCD_COLOR_BLUE);
#ifdef USE_CAMERA_IN_ANIMATION
/* Initialize the Camera */
camera_status = BSP_CAMERA_Init(RESOLUTION_R640x480);
BSP_LCD_DisplayStringAt(0, BSP_LCD_GetYSize() - ANIMATION_STATUS_TEXT_POS, (uint8_t *)" VGA camera stream ", CENTER_MODE);
if (camera_status != CAMERA_OK)
{
BSP_LCD_DisplayStringAt(0, BSP_LCD_GetYSize() - ANIMATION_STATUS_TEXT_POS - 15, (uint8_t *)" CAMERA INIT ERROR ", CENTER_MODE);
}
#endif /* USE_CAMERA_IN_ANIMATION */
/* Clear first the LCD */
BSP_LCD_Clear(LCD_COLOR_WHITE);
#ifdef USE_CAMERA_IN_ANIMATION
/* Init or Re-Init Camera frame buffer by using DMA2D engine in mode Register to Memory */
camera_status = AnimationCameraFrameBufferRgb565_Init(CameraResX,
CameraResY,
argb8888_Value);
BSP_TEST_APPLI_ASSERT(camera_status != CAMERA_OK);
/* Start / Restart camera stream */
BSP_CAMERA_ContinuousStart((uint8_t *)CAMERA_FB_START_ADDR);
#endif /* USE_CAMERA_IN_ANIMATION */
/* Forbid in that case the DMA2D copy from Camera frame buffer to LCD Frame buffer location by BSP_CAMERA_LineEventCallback() */
Camera_AllowDma2dCopyCamFrmBuffToLcdFrmBuff = 0;
} /* of if (CameraChangeResolutionAsked) */
/* Toggle LED4 */
BSP_LED_Toggle(LED4);
/* Insert 100 ms delay */
HAL_Delay(100);
/* Toggle LED2 */
BSP_LED_Toggle(LED2);
/* Insert 400 ms delay */
HAL_Delay(400);
if(CheckForUserInput() > 0)
{
exit = 1;
}
anime_draw_scene(anime_lcd_frame_buffer);
} /* of while (exit == 0) */
#ifdef USE_CAMERA_IN_ANIMATION
/* Stop camera stream */
camera_status = BSP_CAMERA_Stop();
BSP_TEST_APPLI_ASSERT(camera_status != CAMERA_OK);
#endif /* USE_CAMERA_IN_ANIMATION */
}
/**
* @brief Save the picture in USB Disk.
* @param None
* @retval None
*/
void Save_Picture(void)
{
FRESULT res; /* FatFs function common result code */
uint32_t bytesWritten; /* File write count */
BSP_LCD_SetLayerVisible(1, ENABLE);
BSP_LCD_SetColorKeying(1, LCD_COLOR_WHITE);
/* Set foreground Layer */
BSP_LCD_SelectLayer(1);
BSP_LCD_SetTextColor(LCD_COLOR_DARKRED);
BSP_LCD_SetFont(&Font20);
if (Appli_state == APPLICATION_START)
{
BSP_LCD_DisplayStringAt(10, (BSP_LCD_GetYSize()-100), (uint8_t *)"Saving ... ", RIGHT_MODE);
/*##-1- Prepare the image to be saved ####################################*/
Prepare_Picture();
/*##-2- Create and Open a new bmp file object with write access ##########*/
if(f_open(&MyFile, "image.bmp", FA_CREATE_ALWAYS | FA_WRITE) != FR_OK)
{
/* 'image.bmp' file Open for write Error */
Error_Handler();
}
else
{
/*##-3- Write data to the BMP file #####################################*/
/* Write the BMP header */
res = f_write(&MyFile, (uint32_t *)aBMPHeader, 54, (void *)&bytesWritten);
/* Write the bmp file */
res = f_write(&MyFile, (uint32_t *)CONVERTED_FRAME_BUFFER, ((BSP_LCD_GetYSize()-60)*(BSP_LCD_GetXSize()-60)*3), (void *)&bytesWritten);
if((bytesWritten == 0) || (res != FR_OK))
{
/* 'image' file Write or EOF Error */
Error_Handler();
}
else
{
/*##-4- Close the open text file #####################################*/
f_close(&MyFile);
/* Success of the demo: no error occurrence */
BSP_LED_On(LED3);
BSP_LCD_SetTextColor(LCD_COLOR_DARKGREEN);
BSP_LCD_DisplayStringAt(10, (BSP_LCD_GetYSize()-100), (uint8_t *)"Save ", RIGHT_MODE);
/* Wait for 2s */
HAL_Delay(2000);
/* Disable the Layer 2 */
BSP_LCD_SetLayerVisible(1, DISABLE);
/* Select Layer 1 */
BSP_LCD_SelectLayer(0);
}
}
}
else
{
/* USB not connected */
BSP_LCD_DisplayStringAt(10, (BSP_LCD_GetYSize()-100), (uint8_t *)"USB KO... ", RIGHT_MODE);
/* Wait for 2s */
HAL_Delay(2000);
/* Disable the Layer 2 */
BSP_LCD_SetLayerVisible(1, DISABLE);
/* Select Layer 1 */
BSP_LCD_SelectLayer(0);
}
}
/**
* @brief Touchscreen_Handle_NewTouch: factorization of touch management
* @param None
* @retval TS_OK or TS_ERROR
*/
static uint32_t Touchscreen_Handle_NewTouch(void)
{
#define TS_MULTITOUCH_FOOTPRINT_CIRCLE_RADIUS 15
#define TOUCH_INFO_STRING_SIZE 70
uint16_t x1 = 0;
uint16_t y1 = 0;
uint16_t x2 = 0;
uint16_t y2 = 0;
uint32_t drawTouch1 = 0; /* activate/deactivate draw of footprint of touch 1 */
uint32_t drawTouch2 = 0; /* activate/deactivate draw of footprint of touch 2 */
uint32_t colors[24] = {LCD_COLOR_BLUE, LCD_COLOR_GREEN, LCD_COLOR_RED, LCD_COLOR_CYAN, LCD_COLOR_MAGENTA, LCD_COLOR_YELLOW,
LCD_COLOR_LIGHTBLUE, LCD_COLOR_LIGHTGREEN, LCD_COLOR_LIGHTRED, LCD_COLOR_LIGHTCYAN, LCD_COLOR_LIGHTMAGENTA,
LCD_COLOR_LIGHTYELLOW, LCD_COLOR_DARKBLUE, LCD_COLOR_DARKGREEN, LCD_COLOR_DARKRED, LCD_COLOR_DARKCYAN,
LCD_COLOR_DARKMAGENTA, LCD_COLOR_DARKYELLOW, LCD_COLOR_LIGHTGRAY, LCD_COLOR_GRAY, LCD_COLOR_DARKGRAY,
LCD_COLOR_BLACK, LCD_COLOR_BROWN, LCD_COLOR_ORANGE };
uint32_t ts_status = TS_OK;
uint8_t lcd_string[TOUCH_INFO_STRING_SIZE] = "";
/* Check in polling mode in touch screen the touch status and coordinates */
/* of touches if touch occurred */
ts_status = BSP_TS_GetState(&TS_State);
if(TS_State.touchDetected)
{
/* One or dual touch have been detected */
/* Erase previous information on touchscreen play pad area */
BSP_LCD_SetTextColor(LCD_COLOR_WHITE);
BSP_LCD_FillRect(0, 80, BSP_LCD_GetXSize(), BSP_LCD_GetYSize() - 160);
/* Re-Draw touch screen play area on LCD */
BSP_LCD_SetTextColor(LCD_COLOR_BLUE);
BSP_LCD_DrawRect(10, 90, BSP_LCD_GetXSize() - 20, BSP_LCD_GetYSize() - 180);
BSP_LCD_DrawRect(11, 91, BSP_LCD_GetXSize() - 22, BSP_LCD_GetYSize() - 182);
/* Erase previous information on bottom text bar */
BSP_LCD_FillRect(0, BSP_LCD_GetYSize() - 80, BSP_LCD_GetXSize(), 80);
/* Desactivate drawing footprint of touch 1 and touch 2 until validated against boundaries of touch pad values */
drawTouch1 = drawTouch2 = 0;
/* Get X and Y position of the first touch post calibrated */
x1 = TouchScreen_Get_Calibrated_X(TS_State.touchX[0]);
y1 = TouchScreen_Get_Calibrated_Y(TS_State.touchY[0]);
if((y1 > (90 + TS_MULTITOUCH_FOOTPRINT_CIRCLE_RADIUS)) &&
(y1 < (BSP_LCD_GetYSize() - 90 - TS_MULTITOUCH_FOOTPRINT_CIRCLE_RADIUS)))
{
drawTouch1 = 1;
}
/* If valid touch 1 position : inside the reserved area for the use case : draw the touch */
if(drawTouch1 == 1)
{
/* Draw circle of first touch : turn on colors[] table */
BSP_LCD_SetTextColor(colors[(touchscreen_color_idx++ % 24)]);
BSP_LCD_FillCircle(x1, y1, TS_MULTITOUCH_FOOTPRINT_CIRCLE_RADIUS);
BSP_LCD_SetTextColor(LCD_COLOR_WHITE);
BSP_LCD_SetFont(&Font16);
BSP_LCD_DisplayStringAt(0, BSP_LCD_GetYSize() - 70, (uint8_t *)"TOUCH INFO : ", CENTER_MODE);
BSP_LCD_SetFont(&Font12);
sprintf((char*)lcd_string, "x1 = %d, y1 = %d, Event = %s, Weight = %d",
x1,
y1,
ts_event_string_tab[TS_State.touchEventId[0]],
TS_State.touchWeight[0]);
BSP_LCD_DisplayStringAt(0, BSP_LCD_GetYSize() - 45, lcd_string, CENTER_MODE);
} /* of if(drawTouch1 == 1) */
if(TS_State.touchDetected > 1)
{
/* Get X and Y position of the second touch post calibrated */
x2 = TouchScreen_Get_Calibrated_X(TS_State.touchX[1]);
y2 = TouchScreen_Get_Calibrated_Y(TS_State.touchY[1]);
if((y2 > (90 + TS_MULTITOUCH_FOOTPRINT_CIRCLE_RADIUS)) &&
(y2 < (BSP_LCD_GetYSize() - 90 - TS_MULTITOUCH_FOOTPRINT_CIRCLE_RADIUS)))
{
drawTouch2 = 1;
}
/* If valid touch 2 position : inside the reserved area for the use case : draw the touch */
if(drawTouch2 == 1)
{
sprintf((char*)lcd_string, "x2 = %d, y2 = %d, Event = %s, Weight = %d",
x2,
y2,
ts_event_string_tab[TS_State.touchEventId[1]],
TS_State.touchWeight[1]);
BSP_LCD_DisplayStringAt(0, BSP_LCD_GetYSize() - 35, lcd_string, CENTER_MODE);
/* Draw circle of second touch : turn on color[] table */
BSP_LCD_SetTextColor(colors[(touchscreen_color_idx++ % 24)]);
BSP_LCD_FillCircle(x2, y2, TS_MULTITOUCH_FOOTPRINT_CIRCLE_RADIUS);
} /* of if(drawTouch2 == 1) */
} /* of if(TS_State.touchDetected > 1) */
if((drawTouch1 == 1) || (drawTouch2 == 1))
{
/* Get updated gesture Id in global variable 'TS_State' */
ts_status = BSP_TS_Get_GestureId(&TS_State);
sprintf((char*)lcd_string, "Gesture Id = %s", ts_gesture_id_string_tab[TS_State.gestureId]);
BSP_LCD_SetTextColor(LCD_COLOR_WHITE);
BSP_LCD_DisplayStringAt(0, BSP_LCD_GetYSize() - 15, lcd_string, CENTER_MODE);
}
else
{
/* Invalid touch position */
BSP_LCD_SetTextColor(LCD_COLOR_WHITE);
BSP_LCD_DisplayStringAt(0, BSP_LCD_GetYSize() - 70, (uint8_t *)"Invalid touch position : use drawn touch area : ", CENTER_MODE);
}
} /* of if(TS_State.TouchDetected) */
return(ts_status);
}
/**
* @brief Enter Calibration menu to correct ICError and Capacitance55RH values
* @param None
* @retval None
*/
static void Calibration_Menu(void)
{
uint8_t exitmenu = 0;
uint8_t LCDstr[20] = {0};
/*##-1- Display messages on LCD ############################################*/
/* Set the LCD Text Color */
BSP_LCD_SetBackColor(LCD_COLOR_WHITE);
BSP_LCD_SetTextColor(LCD_COLOR_BLACK);
/* Display Calibration Screen */
BSP_LCD_DisplayStringAt(0, 115, (uint8_t*)"Calibration steps: ", CENTER_MODE);
BSP_LCD_DisplayStringAt(60, 145, (uint8_t *)"1. Set JP19 to REF ", LEFT_MODE);
BSP_LCD_DisplayStringAt(60, 160, (uint8_t *)"2. Press Joystick Sel push-button ", LEFT_MODE);
/*##-2- Calibration Phases #################################################*/
/* ------------- First step calibration using reference capacitance ----- */
while (exitmenu != 1)
{
if (BSP_JOY_GetState() == JOY_SEL)
{
/* Get ICError for reference capacitance */
/* TriggerTime = (AvrgICReadValue - ICError)/SystemCoreClock
* TriggerTime = RES * REFCAP * ln(VDD/(VDD - VREF))
* @VREF = 2.086V (generated by DAC), ln(VDD/(VDD - VREF)) is ~ 1
* ==> TriggerTime = RES * REFCAP
* Then RES * REFCAP = (AvrgICReadValue - ICError)/SystemCoreClock
* ==> ICError = AvrgICReadValue - REFCAP * RES * SystemCoreClock
*/
ICError = (uint16_t) (AvrgICReadValue-REFCAP*RES*SystemCoreClock);
/* Set exitmenu to 1 */
exitmenu = 1;
}
}
/* --------------- Second step calibration using reference humidity ------- */
exitmenu = 0;
/* Clear Calibration Screen */
BSP_LCD_SetBackColor(LCD_COLOR_WHITE);
BSP_LCD_SetTextColor(LCD_COLOR_WHITE);
BSP_LCD_FillRect(12, 92, BSP_LCD_GetXSize()- 24, BSP_LCD_GetYSize() - 104);
/* Set the LCD Text Color */
BSP_LCD_SetTextColor(LCD_COLOR_BLACK);
BSP_LCD_DisplayStringAt(0, 100, (uint8_t *)"Now set JP19 to HUM ", CENTER_MODE);
BSP_LCD_DisplayStringAt(0, 115, (uint8_t *)"and set current humidity value", CENTER_MODE);
BSP_LCD_DisplayStringAt(0, 130, (uint8_t *)"using Up/Down keys", CENTER_MODE);
BSP_LCD_DisplayStringAt(14, 190, (uint8_t *)"Joystick Sel push-button: Apply ", LEFT_MODE);
BSP_LCD_DisplayStringAt(14, 205, (uint8_t *)"Key push-button: Cancel ", LEFT_MODE);
/* Set the LCD Text Color for Humidity value */
BSP_LCD_SetTextColor(LCD_COLOR_RED);
/* Wait for SEL button to be released */
while (BSP_JOY_GetState() != JOY_NONE);
while (exitmenu != 1)
{
if ((BSP_JOY_GetState() == JOY_UP) && (DisplayValue<99))
{
/* Wait for UP button to be released */
while (BSP_JOY_GetState() != JOY_NONE);
DisplayValue++;
UpdateDisplayValue = 1;
}
if ((BSP_JOY_GetState() == JOY_DOWN) && (DisplayValue>0))
{
/* Wait for DOWN button to be released */
while (BSP_JOY_GetState() != JOY_NONE);
DisplayValue--;
UpdateDisplayValue = 1;
}
if (UpdateDisplayValue)
{
UpdateDisplayValue = 0;
/* Display humidity value on LCD Line 4 */
sprintf((char*)LCDstr, " %lu %% ", DisplayValue);
BSP_LCD_DisplayStringAt(0, 160, (uint8_t*) LCDstr, CENTER_MODE);
}
if (BSP_JOY_GetState() == JOY_SEL)
{
/* Calculate Trigger Time Value */
TriggerTime = (float) (AvrgICReadValue-ICError)/SystemCoreClock;
/* Calculate Capacitance Value */
Capacitance = (float) TriggerTime/RES;
/* Update Capacitance55RH value: capacitance @ 55% Relative Humidity */
Capacitance55RH= Capacitance/(P3 * pow(DisplayValue,3) +
P2 * pow(DisplayValue,2) +
P1 * DisplayValue +
P0 );
exitmenu = 1;
}
else if (BSP_PB_GetState(BUTTON_KEY) == GPIO_PIN_RESET)
{
/* Humidity Calibration canceled */
exitmenu = 1;
}
}
/* Clear Calibration Screen */
BSP_LCD_SetBackColor(LCD_COLOR_WHITE);
BSP_LCD_SetTextColor(LCD_COLOR_WHITE);
BSP_LCD_FillRect(12, 92, BSP_LCD_GetXSize()- 24, BSP_LCD_GetYSize() - 104);
/* Set the LCD Text Color */
BSP_LCD_SetTextColor(LCD_COLOR_BLACK);
}
/**
* @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 Displays demonstration menu.
* @param None
* @retval None
*/
static void TFT_DisplayMenu(void)
{
JOYState_TypeDef tmp;
/* Set Menu font */
BSP_LCD_SetFont(&Font12);
/* Set Text color */
BSP_LCD_SetTextColor(LCD_COLOR_RED);
/* Display message */
BSP_LCD_DisplayStringAtLine(1, (uint8_t*)" NUCLEO-STM32F1xx ");
BSP_LCD_DisplayStringAtLine(2, (uint8_t*)" DEMO ");
/* Set Text color */
BSP_LCD_SetTextColor(LCD_COLOR_BLUE);
/* Display message */
BSP_LCD_DisplayStringAtLine(4, (uint8_t*)" Display images ");
BSP_LCD_DisplayStringAtLine(6, (uint8_t*)" stored under uSD ");
BSP_LCD_DisplayStringAtLine(8, (uint8_t*)" on TFT LCD ");
/* Set Text color */
BSP_LCD_SetTextColor(LCD_COLOR_BLACK);
/* Display message */
BSP_LCD_DisplayStringAtLine(11, (uint8_t*)" Press JOY DOWN ");
BSP_LCD_DisplayStringAtLine(12, (uint8_t*)" to continue... ");
/* Wait for JOY_DOWN is pressed */
while (BSP_JOY_GetState() != JOY_DOWN)
{
}
/* Wait for JOY_DOWN is released */
while (BSP_JOY_GetState() == JOY_DOWN)
{
}
/* Set Text color */
BSP_LCD_SetTextColor(LCD_COLOR_BLACK);
/* Display message */
BSP_LCD_DisplayStringAtLine(4, (uint8_t*)" ");
BSP_LCD_DisplayStringAtLine(6, (uint8_t*)" Press Joystick ");
/* Set Text color */
BSP_LCD_SetTextColor(LCD_COLOR_BLUE);
/* Display message */
BSP_LCD_DisplayStringAtLine(8, (uint8_t*)" UP for: ");
BSP_LCD_DisplayStringAtLine(9, (uint8_t*)" Manual Mode ");
BSP_LCD_DisplayStringAtLine(11, (uint8_t*)" DOWN for: ");
BSP_LCD_DisplayStringAtLine(12, (uint8_t*)" Automatic Mode ");
/* Wait for JOY_DOWN or JOY_UP is pressed */
tmp = JOY_RIGHT;
while ((tmp != JOY_DOWN) && (tmp != JOY_UP))
{
tmp = BSP_JOY_GetState();
}
/* LCD Clear */
BSP_LCD_Clear(LCD_COLOR_WHITE);
/* JOY_UP is pressed: Display Manual mode menu #############################*/
if(tmp == JOY_UP)
{
/* Set Text color */
BSP_LCD_SetTextColor(LCD_COLOR_RED);
/* Display message */
BSP_LCD_DisplayStringAtLine(3, (uint8_t*)" Manual Mode ");
BSP_LCD_DisplayStringAtLine(5, (uint8_t*)" Selected ");
/* Set Text color */
BSP_LCD_SetTextColor(LCD_COLOR_BLUE);
/* Display message */
BSP_LCD_DisplayStringAtLine(9, (uint8_t*)" RIGHT: Next image");
BSP_LCD_DisplayStringAtLine(10, (uint8_t*)" LEFT : Previous ");
BSP_LCD_DisplayStringAtLine(11, (uint8_t*)" SEL : Switch to ");
BSP_LCD_DisplayStringAtLine(12, (uint8_t*)" automatic mode ");
JoystickValue = 2;
}
/* JOY_DOWN is pressed: Display Automatic mode menu ########################*/
else if (tmp == JOY_DOWN)
{
/* Set Text color */
BSP_LCD_SetTextColor(LCD_COLOR_RED);
/* Display message */
BSP_LCD_DisplayStringAtLine(3, (uint8_t*)" Automatic Mode ");
BSP_LCD_DisplayStringAtLine(5, (uint8_t*)" Selected ");
JoystickValue = 1;
HAL_Delay(200);
}
}
/**
* @brief Displays adequate message on TFT available on adafruit 1.8" TFT shield
* @param message: Error message to be displayed on the LCD.
* This parameter can be one of following values:
* @arg SD_CARD_NOT_FORMATTED: SD CARD is not FAT formatted
* @arg SD_CARD_FILE_NOT_SUPPORTED: File is not supported
* @arg SD_CARD_OPEN_FAIL: Failure to open directory
* @arg FATFS_NOT_MOUNTED: FatFs is not mounted
* @retval None
*/
static void TFT_DisplayErrorMessage(uint8_t message)
{
/* LCD Clear */
BSP_LCD_Clear(LCD_COLOR_WHITE);
/* Set Error Message Font */
BSP_LCD_SetFont(&Font12);
/* Set Text and Back colors */
BSP_LCD_SetBackColor(LCD_COLOR_GREY);
BSP_LCD_SetTextColor(LCD_COLOR_RED);
if(message == SD_CARD_NOT_FORMATTED)
{
/* Display message */
BSP_LCD_DisplayStringAtLine(5, (uint8_t*)" SD Card is not ");
BSP_LCD_DisplayStringAtLine(6, (uint8_t*)" FAT formatted. ");
BSP_LCD_DisplayStringAtLine(7, (uint8_t*)" Please Format the ");
BSP_LCD_DisplayStringAtLine(8, (uint8_t*)" microSD card. ");
while (1)
{
}
}
if(message == SD_CARD_FILE_NOT_SUPPORTED)
{
/* Display message */
BSP_LCD_DisplayStringAtLine(5, (uint8_t*)" ");
BSP_LCD_DisplayStringAtLine(6, (uint8_t*)" File type is not ");
BSP_LCD_DisplayStringAtLine(7, (uint8_t*)" supported. ");
BSP_LCD_DisplayStringAtLine(8, (uint8_t*)" ");
while(1)
{
}
}
if(message == SD_CARD_OPEN_FAIL)
{
/* Display message */
BSP_LCD_DisplayStringAtLine(5, (uint8_t*)" ");
BSP_LCD_DisplayStringAtLine(6, (uint8_t*)" Open directory ");
BSP_LCD_DisplayStringAtLine(7, (uint8_t*)" fails. ");
BSP_LCD_DisplayStringAtLine(8, (uint8_t*)" ");
while(1)
{
}
}
if(message == FATFS_NOT_MOUNTED)
{
/* Display message */
BSP_LCD_DisplayStringAtLine(5, (uint8_t*)" ");
BSP_LCD_DisplayStringAtLine(6, (uint8_t*)" Cannot mount ");
BSP_LCD_DisplayStringAtLine(7, (uint8_t*)" FatFs on Drive. ");
BSP_LCD_DisplayStringAtLine(8, (uint8_t*)" ");
while (1)
{
}
}
if(message == BSP_SD_INIT_FAILED)
{
/* Display message */
BSP_LCD_DisplayStringAtLine(5, (uint8_t*)" ");
BSP_LCD_DisplayStringAtLine(6, (uint8_t*)" SD Init ");
BSP_LCD_DisplayStringAtLine(7, (uint8_t*)" fails. ");
BSP_LCD_DisplayStringAtLine(8, (uint8_t*)" ");
while(1)
{
}
}
}
/**
* @brief Manages Audio process.
* @param None
* @retval Audio error
*/
AUDIO_ErrorTypeDef AUDIO_Process(void)
{
uint32_t bytesread, elapsed_time;
static uint32_t prev_elapsed_time = 0xFFFFFFFF;
uint8_t str[10];
AUDIO_ErrorTypeDef error_state = AUDIO_ERROR_NONE;
switch(audio_state)
{
case AUDIO_STATE_PLAY:
if(buffer_ctl.fptr >= wav_info.FileSize)
{
error_state = AUDIO_ERROR_EOF;
}
if(buffer_ctl.offset == BUFFER_OFFSET_HALF)
{
if(MTP_GetData(file_pos,
buffer_ctl.fptr,
AUDIO_BUFFER_SIZE /2,
&buffer_ctl.buff[0],
&bytesread)> 0)
{
error_state = AUDIO_ERROR_IO;
}
buffer_ctl.offset = BUFFER_OFFSET_NONE;
buffer_ctl.fptr += bytesread;
}
if(buffer_ctl.offset == BUFFER_OFFSET_FULL)
{
if(MTP_GetData(file_pos,
buffer_ctl.fptr,
AUDIO_BUFFER_SIZE /2,
&buffer_ctl.buff[AUDIO_BUFFER_SIZE /2],
&bytesread)> 0)
{
error_state = AUDIO_ERROR_IO;
}
buffer_ctl.offset = BUFFER_OFFSET_NONE;
buffer_ctl.fptr += bytesread;
}
/* Display elapsed time */
elapsed_time = buffer_ctl.fptr / wav_info.ByteRate;
if(prev_elapsed_time != elapsed_time)
{
prev_elapsed_time = elapsed_time;
sprintf((char *)str, "[%02lu:%02lu]", elapsed_time /60, elapsed_time%60);
BSP_LCD_SetTextColor(LCD_COLOR_CYAN);
BSP_LCD_DisplayStringAt(263, LINE(8), str, LEFT_MODE);
BSP_LCD_SetTextColor(LCD_COLOR_WHITE);
}
break;
case AUDIO_STATE_STOP:
BSP_AUDIO_OUT_Stop(CODEC_PDWN_SW);
audio_state = AUDIO_STATE_IDLE;
error_state = AUDIO_ERROR_IO;
break;
case AUDIO_STATE_NEXT:
if(++file_pos >= MTP_GetWavObjectNumber())
{
file_pos = 0;
}
BSP_AUDIO_OUT_Stop(CODEC_PDWN_SW);
AUDIO_Start(file_pos);
break;
case AUDIO_STATE_PREVIOUS:
if(--file_pos < 0)
{
file_pos = MTP_GetWavObjectNumber() - 1;
}
BSP_AUDIO_OUT_Stop(CODEC_PDWN_SW);
AUDIO_Start(file_pos);
break;
case AUDIO_STATE_PAUSE:
BSP_LCD_DisplayStringAt(250, LINE(14), (uint8_t *)" [PAUSE]", LEFT_MODE);
BSP_AUDIO_OUT_Pause();
audio_state = AUDIO_STATE_WAIT;
break;
case AUDIO_STATE_RESUME:
BSP_LCD_DisplayStringAt(250, LINE(14), (uint8_t *)" [PLAY ]", LEFT_MODE);
BSP_AUDIO_OUT_Resume();
audio_state = AUDIO_STATE_PLAY;
break;
case AUDIO_STATE_VOLUME_UP:
if(uwVolume <= 90)
{
uwVolume += 10;
}
BSP_AUDIO_OUT_SetVolume(uwVolume);
audio_state = AUDIO_STATE_PLAY;
break;
case AUDIO_STATE_VOLUME_DOWN:
if(uwVolume >= 10)
{
uwVolume -= 10;
}
BSP_AUDIO_OUT_SetVolume(uwVolume);
audio_state = AUDIO_STATE_PLAY;
break;
case AUDIO_STATE_WAIT:
case AUDIO_STATE_CONFIG:
case AUDIO_STATE_IDLE:
case AUDIO_STATE_INIT:
default:
/* Do Nothing */
break;
}
return error_state;
}
/**
* @brief Main program
* @param None
* @retval None
*/
int main(void)
{
uwInternelBuffer = (uint8_t *)0xC0260000;
uint32_t counter = 0;
uint8_t str[30];
/* STM32F4xx HAL library initialization:
- Configure the Flash prefetch, instruction and Data caches
- Configure the Systick to generate an interrupt each 1 msec
- Set NVIC Group Priority to 4
- Global MSP (MCU Support Package) initialization
*/
HAL_Init();
/* Configure the system clock to 175 MHz */
SystemClock_Config();
/* Configure LED3 */
BSP_LED_Init(LED3);
/*##-1- Configure LCD ######################################################*/
LCD_Config();
/*##-2- Link the SD Card disk I/O driver ###################################*/
if(FATFS_LinkDriver(&SD_Driver, SD_Path) != 0)
{
Error_Handler();
}
else
{
/*##-3- Initialize the Directory Files pointers (heap) ###################*/
for (counter = 0; counter < MAX_BMP_FILES; counter++)
{
pDirectoryFiles[counter] = malloc(MAX_BMP_FILE_NAME);
if(pDirectoryFiles[counter] == NULL)
{
/* Set the Text Color */
BSP_LCD_SetTextColor(LCD_COLOR_RED);
BSP_LCD_DisplayStringAtLine(8, (uint8_t*)" Cannot allocate memory ");
while(1)
{
}
}
}
/*##-4- Display Background picture #######################################*/
/* Select Background Layer */
BSP_LCD_SelectLayer(0);
/* Register the file system object to the FatFs module */
if(f_mount(&SD_FatFs, (TCHAR const*)SD_Path, 0) != FR_OK)
{
/* FatFs Initialization Error */
/* Set the Text Color */
BSP_LCD_SetTextColor(LCD_COLOR_RED);
BSP_LCD_DisplayStringAtLine(8, (uint8_t*)" FatFs Initialization Error ");
}
else
{
/* Open directory */
if (f_opendir(&directory, (TCHAR const*)"/BACK") != FR_OK)
{
/* Set the Text Color */
BSP_LCD_SetTextColor(LCD_COLOR_RED);
BSP_LCD_DisplayStringAtLine(8, (uint8_t*)" Open directory.. fails");
while(1)
{
}
}
}
if (Storage_CheckBitmapFile("BACK/image.bmp", &uwBmplen) == 0)
{
/* Format the string */
Storage_OpenReadFile(uwInternelBuffer, "BACK/image.bmp");
/* Write bmp file on LCD frame buffer */
BSP_LCD_DrawBitmap(0, 0, uwInternelBuffer);
}
else
{
/* Set the Text Color */
BSP_LCD_SetTextColor(LCD_COLOR_RED);
BSP_LCD_DisplayStringAtLine(8, (uint8_t*)" File type not supported. ");
while(1)
{
}
}
/*##-5- Display Foreground picture #######################################*/
/* Select Foreground Layer */
BSP_LCD_SelectLayer(1);
/* Decrease the foreground transprency */
BSP_LCD_SetTransparency(1, 200);
/* Get the BMP file names on root directory */
ubNumberOfFiles = Storage_GetDirectoryBitmapFiles("/TOP", pDirectoryFiles);
if (ubNumberOfFiles == 0)
{
for (counter = 0; counter < MAX_BMP_FILES; counter++)
{
free(pDirectoryFiles[counter]);
}
/* Set the Text Color */
BSP_LCD_SetTextColor(LCD_COLOR_RED);
BSP_LCD_DisplayStringAtLine(8, (uint8_t*)" No Bitmap files... ");
while(1)
{
}
}
}
/* Infinite loop */
while(1)
{
counter = 0;
while (counter < ubNumberOfFiles)
{
/* Format the string */
sprintf ((char*)str, "TOP/%-11.11s", pDirectoryFiles[counter]);
if (Storage_CheckBitmapFile((const char*)str, &uwBmplen) == 0)
{
/* Format the string */
sprintf ((char*)str, "TOP/%-11.11s", pDirectoryFiles[counter]);
/* Open a file and copy its content to a buffer */
Storage_OpenReadFile(uwInternelBuffer, (const char*)str);
HAL_Delay(100);
/* Write bmp file on LCD frame buffer */
BSP_LCD_DrawBitmap(0, 0, uwInternelBuffer);
/* Jump to next image */
counter++;
}
else
{
/* Set the Text Color */
BSP_LCD_SetTextColor(LCD_COLOR_RED);
BSP_LCD_DisplayStringAtLine(7, (uint8_t *) str);
BSP_LCD_DisplayStringAtLine(8, (uint8_t*)" File type not supported. ");
while(1)
{
}
}
}
}
}
/**
* @brief Show LCD Features
* @param feature : feature index
* @retval None
*/
static void LCD_Show_Feature(uint8_t feature)
{
Point Points[]= {{20, 150}, {80, 150}, {80, 200}};
Point Points2[3];
Points2[0].X = BSP_LCD_GetXSize() - 80;
Points2[0].Y = 150;
Points2[1].X = BSP_LCD_GetXSize() - 20;
Points2[1].Y = 150;
Points2[2].X = BSP_LCD_GetXSize() - 20;
Points2[2].Y = 200;
BSP_LCD_SetBackColor(LCD_COLOR_WHITE);
BSP_LCD_SetTextColor(LCD_COLOR_WHITE);
BSP_LCD_FillRect(12, 92, BSP_LCD_GetXSize() - 24, BSP_LCD_GetYSize()- 104);
BSP_LCD_SetTextColor(LCD_COLOR_BLACK);
switch (feature)
{
case 0:
/* Text Feature */
BSP_LCD_DisplayStringAt(14, 100, (uint8_t *)"Left aligned Text", LEFT_MODE);
BSP_LCD_DisplayStringAt(0, 115, (uint8_t *)"Center aligned Text", CENTER_MODE);
BSP_LCD_DisplayStringAt(14, 130, (uint8_t*)"Right aligned Text", RIGHT_MODE);
BSP_LCD_SetFont(&Font24);
BSP_LCD_DisplayStringAt(14, 180, (uint8_t *)"Font24", LEFT_MODE);
BSP_LCD_SetFont(&Font20);
BSP_LCD_DisplayStringAt(BSP_LCD_GetXSize()/2 -20, 180, (uint8_t *)"Font20", LEFT_MODE);
BSP_LCD_SetFont(&Font16);
BSP_LCD_DisplayStringAt(BSP_LCD_GetXSize() - 80, 184, (uint8_t *)"Font16", LEFT_MODE);
break;
case 1:
/* Draw misc. Shapes */
BSP_LCD_SetTextColor(LCD_COLOR_BLACK);
BSP_LCD_DrawRect(20, 100, 60 , 40);
BSP_LCD_FillRect(100, 100, 60 , 40);
BSP_LCD_SetTextColor(LCD_COLOR_GRAY);
BSP_LCD_DrawCircle(BSP_LCD_GetXSize() - 120, 120, 20);
BSP_LCD_FillCircle(BSP_LCD_GetXSize() - 40, 120, 20);
BSP_LCD_SetTextColor(LCD_COLOR_GREEN);
BSP_LCD_DrawPolygon(Points, 3);
BSP_LCD_SetTextColor(LCD_COLOR_RED);
BSP_LCD_DrawEllipse(130, 170, 30, 20);
BSP_LCD_FillEllipse(200, 170, 30, 20);
BSP_LCD_SetTextColor(LCD_COLOR_BLACK);
BSP_LCD_DrawHLine(20, BSP_LCD_GetYSize() - 30, BSP_LCD_GetXSize() / 5);
BSP_LCD_DrawLine (100, BSP_LCD_GetYSize() - 20, 230, BSP_LCD_GetYSize()- 50);
BSP_LCD_DrawLine (100, BSP_LCD_GetYSize()- 50, 230, BSP_LCD_GetYSize()- 20);
BSP_LCD_SetTextColor(LCD_COLOR_GREEN);
BSP_LCD_FillPolygon(Points2, 3);
break;
case 2:
/* Draw Bitmap */
BSP_LCD_DrawBitmap(20, 100, (uint8_t *)stlogo);
HAL_Delay(500);
BSP_LCD_DrawBitmap(BSP_LCD_GetXSize()/2 - 40, 100, (uint8_t *)stlogo);
HAL_Delay(500);
BSP_LCD_DrawBitmap(BSP_LCD_GetXSize()-100, 100, (uint8_t *)stlogo);
HAL_Delay(500);
BSP_LCD_DrawBitmap(20, BSP_LCD_GetYSize()- 80, (uint8_t *)stlogo);
HAL_Delay(500);
BSP_LCD_DrawBitmap(BSP_LCD_GetXSize()/2 - 40, BSP_LCD_GetYSize()- 80, (uint8_t *)stlogo);
HAL_Delay(500);
BSP_LCD_DrawBitmap(BSP_LCD_GetXSize()-100, BSP_LCD_GetYSize()- 80, (uint8_t *)stlogo);
HAL_Delay(500);
break;
}
}
/**
* @brief Main program
* @param None
* @retval None
*/
int main(void)
{
/* Enable the CPU Cache */
CPU_CACHE_Enable();
/* STM32F7xx HAL library initialization:
- Configure the Flash ART accelerator on ITCM interface
- Configure the Systick to generate an interrupt each 1 msec
- Set NVIC Group Priority to 4
- Global MSP (MCU Support Package) initialization
*/
HAL_Init();
/* Configure the system clock to 200 MHz */
SystemClock_Config();
/* Configure LED1 and LED3 */
BSP_LED_Init(LED1);
BSP_LED_Init(LED3);
/*##-1- Initialize the LCD #################################################*/
/* Two layers are used in this application simultaneously
so "LCD_MIN_PCLK" is recommended to programme the PCLK at 20 MHz */
BSP_LCD_InitEx(LCD_MIN_PCLK);
/* Foreground Layer Initialization */
BSP_LCD_LayerDefaultInit(1, LCD_FRAME_BUFFER_LAYER1);
/* Set Foreground Layer */
BSP_LCD_SelectLayer(1);
/* Clear the LCD Foreground layer */
BSP_LCD_Clear(LCD_COLOR_WHITE);
BSP_LCD_SetLayerVisible(1, DISABLE);
/* Background Layer Initialization */
BSP_LCD_LayerDefaultInit(0, LCD_FRAME_BUFFER);
/* Enable the LCD */
BSP_LCD_DisplayOn();
/* Select the LCD Foreground layer */
BSP_LCD_SelectLayer(0);
BSP_LCD_Clear(LCD_COLOR_WHITE);
BSP_LCD_SetLayerWindow(0, 0, 0, 480, 272);
/*##-2- Init Host Library ##################################################*/
/* Display USB initialization message */
BSP_LCD_SetTextColor(LCD_COLOR_DARKBLUE);
BSP_LCD_SetFont(&Font24);
BSP_LCD_DisplayStringAt(20, (BSP_LCD_GetYSize() - 24), (uint8_t *)"USB init ..", RIGHT_MODE);
USBH_Init(&hUSB_Host, USBH_UserProcess, 0);
/* Add Supported Class */
USBH_RegisterClass(&hUSB_Host, USBH_MSC_CLASS);
/* Start Host Process */
USBH_Start(&hUSB_Host);
/*##-3- Configure TAMPER Button ############################################*/
BSP_PB_Init(BUTTON_TAMPER, BUTTON_MODE_GPIO);
/*##-4- Link the USB Host disk I/O driver ##################################*/
FATFS_LinkDriver(&USBH_Driver, MSC_Path);
/*##-5- Camera Initialization and start capture ############################*/
/* Display camera initialization message */
BSP_LCD_DisplayStringAt(20, (BSP_LCD_GetYSize() - 24), (uint8_t *)"Camera init ..", RIGHT_MODE);
/* Initialize the Camera */
BSP_CAMERA_Init(RESOLUTION_R480x272);
/* Start the Camera Capture */
BSP_CAMERA_ContinuousStart((uint8_t *)CAMERA_FRAME_BUFFER);
/*##-6- Run Application ####################################################*/
while (1)
{
/* USB Host Background task */
USBH_Process(&hUSB_Host);
switch(Appli_state)
{
case STORAGE_READY:
CAMERA_Capture();
break;
case STORAGE_IDLE:
break;
}
}
}
/**
* @brief Saves Picture into USB disk.
* @param None
* @retval None
*/
static void SavePicture(void)
{
FRESULT res1, res2; /* FatFs function common result code */
uint32_t byteswritten; /* File write count */
static uint32_t counter = 0;
uint8_t str[30];
/* Suspend the camera capture */
BSP_CAMERA_Suspend();
/* Prepare the image to be saved */
PicturePrepare();
/* Set foreground Layer */
BSP_LCD_SetLayerVisible(1, ENABLE);
BSP_LCD_SetColorKeying(1, LCD_COLOR_WHITE);
BSP_LCD_SelectLayer(1);
BSP_LCD_SetTextColor(LCD_COLOR_DARKRED);
BSP_LCD_SetFont(&Font24);
/* Format the string */
sprintf((char *)str,"image_%d.bmp", (int)counter);
BSP_LCD_DisplayStringAt(20, (BSP_LCD_GetYSize() - 24), (uint8_t *)"Saving ..", RIGHT_MODE);
/* Create and Open a new text file object with write access */
if(f_open(&MyFile, (const char*)str, FA_CREATE_ALWAYS | FA_WRITE) != FR_OK)
{
Error_Handler();
}
else
{
/* Write data to the BMP file */
res1 = f_write(&MyFile, (uint32_t *)aBMPHeader, 54, (void *)&byteswritten);
res2 = f_write(&MyFile, (uint32_t *)CONVERTED_FRAME_BUFFER, (BSP_LCD_GetXSize()*BSP_LCD_GetYSize()*3), (void *)&byteswritten);
if((res1 != FR_OK) || (res2 != FR_OK) || (byteswritten == 0))
{
Error_Handler();
}
else
{
/* Close the open BMP file */
f_close(&MyFile);
/* Success of the demo: no error occurrence */
BSP_LED_On(LED1);
BSP_LCD_SetTextColor(LCD_COLOR_DARKGREEN);
BSP_LCD_DisplayStringAt(20, (BSP_LCD_GetYSize()-24), (uint8_t *)" Saved ", RIGHT_MODE);
/* Wait for 2s */
HAL_Delay(2000);
/* Disable the Layer 2 */
BSP_LCD_SetLayerVisible(1, DISABLE);
/* Select Layer 1 */
BSP_LCD_SelectLayer(0);
counter++;
BSP_LED_Off(LED1);
/* Resume the camera capture */
BSP_CAMERA_Resume();
}
}
}
/**
* @brief SD Demo
* @param None
* @retval None
*/
void SD_demo (void)
{
uint8_t SD_state = SD_OK;
uint8_t prev_status = 2;
SD_SetHint();
SD_state = BSP_SD_Init();
if (SD_state != SD_OK)
{
if(SD_state == MSD_ERROR_SD_NOT_PRESENT)
{
BSP_LCD_DisplayStringAt(20, 100, (uint8_t *)"SD shall be inserted before running test", LEFT_MODE);
}
else
{
BSP_LCD_DisplayStringAt(20, 100, (uint8_t *)"SD Initialization : FAIL.", LEFT_MODE);
}
BSP_LCD_DisplayStringAt(20, 115, (uint8_t *)"SD Test Aborted.", LEFT_MODE);
}
else
{
BSP_LCD_DisplayStringAt(20, 100, (uint8_t *)"SD Initialization : OK.", LEFT_MODE);
SD_state = BSP_SD_Erase(BLOCK_START_ADDR, (BLOCKSIZE * NUM_OF_BLOCKS));
if (SD_state != SD_OK)
{
BSP_LCD_DisplayStringAt(20, 115, (uint8_t *)"SD ERASE : FAILED.", LEFT_MODE);
BSP_LCD_DisplayStringAt(20, 130, (uint8_t *)"SD Test Aborted.", LEFT_MODE);
}
else
{
BSP_LCD_DisplayStringAt(20, 115, (uint8_t *)"SD ERASE : OK.", LEFT_MODE);
/* Fill the buffer to write */
Fill_Buffer(aTxBuffer, BUFFER_WORDS_SIZE, 0x22FF);
SD_state = BSP_SD_WriteBlocks(aTxBuffer, BLOCK_START_ADDR, BLOCKSIZE, NUM_OF_BLOCKS);
if (SD_state != SD_OK)
{
BSP_LCD_DisplayStringAt(20, 130, (uint8_t *)"SD WRITE : FAILED.", LEFT_MODE);
BSP_LCD_DisplayStringAt(20, 145, (uint8_t *)"SD Test Aborted.", LEFT_MODE);
}
else
{
BSP_LCD_DisplayStringAt(20, 130, (uint8_t *)"SD WRITE : OK.", LEFT_MODE);
SD_state = BSP_SD_ReadBlocks(aRxBuffer, BLOCK_START_ADDR, BLOCKSIZE, NUM_OF_BLOCKS);
if (SD_state != SD_OK)
{
BSP_LCD_DisplayStringAt(20, 145, (uint8_t *)"SD READ : FAILED.", LEFT_MODE);
BSP_LCD_DisplayStringAt(20, 160, (uint8_t *)"SD Test Aborted.", LEFT_MODE);
}
else
{
BSP_LCD_DisplayStringAt(20, 145, (uint8_t *)"SD READ : OK.", LEFT_MODE);
if (Buffercmp(aTxBuffer, aRxBuffer, BUFFER_WORDS_SIZE) > 0)
{
BSP_LCD_DisplayStringAt(20, 160, (uint8_t *)"SD COMPARE : FAILED.", LEFT_MODE);
BSP_LCD_DisplayStringAt(20, 175, (uint8_t *)"SD Test Aborted.", LEFT_MODE);
}
else
{
BSP_LCD_DisplayStringAt(20, 160, (uint8_t *)"SD Test : OK.", LEFT_MODE);
BSP_LCD_DisplayStringAt(20, 175, (uint8_t *)"SD can be removed.", LEFT_MODE);
}
}
}
}
}
while (1)
{
/* Check if the SD card is plugged in the slot */
if (BSP_SD_IsDetected() != SD_PRESENT)
{
if(prev_status != SD_NOT_PRESENT)
{
BSP_SD_Init();
prev_status = SD_NOT_PRESENT;
BSP_LCD_SetTextColor(LCD_COLOR_RED);
BSP_LCD_DisplayStringAt(20, BSP_LCD_GetYSize() - 30, (uint8_t *)"SD Not Connected", LEFT_MODE);
}
}
else if (prev_status != SD_PRESENT)
{
BSP_LCD_SetTextColor(LCD_COLOR_GREEN);
BSP_LCD_DisplayStringAt(20, BSP_LCD_GetYSize() - 30, (uint8_t *)"SD Connected ", LEFT_MODE);
prev_status = SD_PRESENT;
}
if (CheckForUserInput() > 0)
{
return;
}
}
}
/**
* @brief Manages Audio process.
* @param None
* @retval Audio error
*/
AUDIO_ErrorTypeDef AUDIO_Process(void)
{
int32_t diff;
uint32_t bytesread, elapsed_time;
static uint32_t prev_elapsed_time = 0xFFFFFFFF;
uint8_t str [10];
switch(audio_state)
{
case AUDIO_STATE_PLAY:
if((buffer_ctl.out_ptr = USBH_AUDIO_GetOutOffset(&hUSBHost)) < 0) /* End of file */
{
audio_state = AUDIO_STATE_NEXT;
}
else if(buffer_ctl.out_ptr >= (AUDIO_BLOCK_SIZE * AUDIO_BLOCK_NBR)) /* End of buffer */
{
USBH_AUDIO_ChangeOutBuffer(&hUSBHost, &buffer_ctl.buff[0]);
}
else
{
diff = buffer_ctl.out_ptr - buffer_ctl.in_ptr;
if(diff < 0)
{
diff = AUDIO_BLOCK_SIZE * AUDIO_BLOCK_NBR + diff;
}
if(diff >= (AUDIO_BLOCK_SIZE * AUDIO_BLOCK_NBR / 2))
{
buffer_ctl.in_ptr += AUDIO_BLOCK_SIZE;
if( buffer_ctl.in_ptr >= (AUDIO_BLOCK_SIZE * AUDIO_BLOCK_NBR))
{
buffer_ctl.in_ptr = 0;
}
if(f_read(&wav_file,
&buffer_ctl.buff[buffer_ctl.in_ptr],
AUDIO_BLOCK_SIZE,
(void *)&bytesread) != FR_OK)
{
return AUDIO_ERROR_IO;
}
}
}
/* Display elapsed time */
elapsed_time = wav_file.fptr / wav_info.ByteRate;
if(prev_elapsed_time != elapsed_time)
{
prev_elapsed_time = elapsed_time;
sprintf((char *)str, "[%02lu:%02lu]", elapsed_time /60, elapsed_time%60);
BSP_LCD_SetTextColor(LCD_COLOR_CYAN);
BSP_LCD_DisplayStringAt(263, LINE(8), str, LEFT_MODE);
BSP_LCD_SetTextColor(LCD_COLOR_WHITE);
}
break;
case AUDIO_STATE_NEXT:
if(++file_pos >= FileList.ptr)
{
file_pos = 0;
}
USBH_AUDIO_Stop(&hUSBHost);
AUDIO_Start(file_pos);
break;
case AUDIO_STATE_PREVIOUS:
if(--file_pos < 0)
{
file_pos = FileList.ptr - 1;
}
USBH_AUDIO_Stop(&hUSBHost);
AUDIO_Start(file_pos);
break;
case AUDIO_STATE_PAUSE:
BSP_LCD_DisplayStringAt(250, LINE(14), (uint8_t *)" [PAUSE]", LEFT_MODE);
USBH_AUDIO_Suspend(&hUSBHost);
audio_state = AUDIO_STATE_WAIT;
break;
case AUDIO_STATE_RESUME:
BSP_LCD_DisplayStringAt(250, LINE(14), (uint8_t *)" [PLAY ]", LEFT_MODE);
USBH_AUDIO_Resume(&hUSBHost);
audio_state = AUDIO_STATE_PLAY;
break;
case AUDIO_STATE_VOLUME_UP:
USBH_AUDIO_SetVolume(&hUSBHost, VOLUME_UP);
audio_state = AUDIO_STATE_PLAY;
break;
case AUDIO_STATE_VOLUME_DOWN:
USBH_AUDIO_SetVolume (&hUSBHost, VOLUME_DOWN);
audio_state = AUDIO_STATE_PLAY;
break;
case AUDIO_STATE_WAIT:
case AUDIO_STATE_CONFIG:
case AUDIO_STATE_IDLE:
case AUDIO_STATE_INIT:
default:
break;
}
return AUDIO_ERROR_NONE;
}
/**
* @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_IDLE:
BSP_LCD_SetTextColor(LCD_COLOR_GREEN);
BSP_LCD_DisplayStringAtLine(14, (uint8_t *)" ");
BSP_LCD_DisplayStringAtLine(15, (uint8_t *)"Use [Buttons Left/Right] to scroll up/down ");
BSP_LCD_DisplayStringAtLine(16, (uint8_t *)"Use [Joystick Up/Down] to scroll HID menu ");
BSP_LCD_DisplayStringAtLine(17, (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 */
if(Appli_state == APPLICATION_HID)
{
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 AUDIO Menu Process.
* @param None
* @retval None
*/
void AUDIO_MenuProcess(void)
{
if(AppliState == APPLICATION_READY)
{
switch(AudioDemo.state)
{
case AUDIO_DEMO_IDLE:
AUDIO_SelectItem(AUDIO_main_menu, 0);
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;
}
AudioDemo.select = 0;
BSP_LCD_SetTextColor(LCD_COLOR_GREEN);
BSP_LCD_DisplayStringAtLine(17, (uint8_t *)"Use [Joystick Left/Right] to scroll up/down");
BSP_LCD_DisplayStringAtLine(18, (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 *)" ");
BSP_LCD_DisplayStringAtLine(17 ,(uint8_t *)" ");
BSP_LCD_DisplayStringAtLine(18 ,(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 *)" ");
BSP_LCD_DisplayStringAtLine(17 ,(uint8_t *)" ");
BSP_LCD_DisplayStringAtLine(18 ,(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(AppliState == 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(AppliState == APPLICATION_READY)
{
if(AudioState == AUDIO_STATE_IDLE)
{
/* Start Playing */
AudioState = AUDIO_STATE_INIT;
if(AUDIO_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_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(AppliState == 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 */
{
if(AUDIO_REC_Process() == AUDIO_ERROR_IO)
{
AUDIO_ChangeSelectMode(AUDIO_SELECT_MENU);
AudioDemo.state = AUDIO_DEMO_IDLE;
}
}
}
else
{
AudioDemo.state = AUDIO_DEMO_WAIT;
}
break;
default:
break;
}
}
if(AppliState == APPLICATION_DISCONNECT)
{
AppliState = APPLICATION_IDLE;
AUDIO_ChangeSelectMode(AUDIO_SELECT_MENU);
BSP_AUDIO_OUT_Stop(CODEC_PDWN_SW);
}
AudioDemo.select &= 0x7F;
}
/**
* @brief Joystick demo
* @param None
* @retval None
*/
void Joystick_demo(void)
{
static uint16_t xPtr = 12;
static uint16_t yPtr = 92;
static uint16_t old_xPtr = 12;
static uint16_t old_yPtr = 92;
uint8_t status = 0;
Joystick_SetHint();
status = BSP_JOY_Init(JOY_MODE_GPIO);
if (status != IO_OK)
{
BSP_LCD_SetBackColor(LCD_COLOR_WHITE);
BSP_LCD_SetTextColor(LCD_COLOR_RED);
BSP_LCD_DisplayStringAt(0, BSP_LCD_GetYSize()- 95, (uint8_t *)"ERROR", CENTER_MODE);
BSP_LCD_DisplayStringAt(0, BSP_LCD_GetYSize()- 80, (uint8_t *)"Joystick cannot be initialized", CENTER_MODE);
}
while (1)
{
if (status == IO_OK)
{
/* Get the Joystick State */
JoyState = BSP_JOY_GetState();
switch(JoyState)
{
case JOY_UP:
if(yPtr > 92)
{
yPtr--;
}
break;
case JOY_DOWN:
if(yPtr < (BSP_LCD_GetYSize() - 12 - 11))
{
yPtr++;
}
break;
case JOY_LEFT:
if(xPtr > 12)
{
xPtr--;
}
break;
case JOY_RIGHT:
if(xPtr < (BSP_LCD_GetXSize() - 8 - 11))
{
xPtr++;
}
break;
default:
break;
}
BSP_LCD_SetBackColor(LCD_COLOR_WHITE);
BSP_LCD_SetTextColor(LCD_COLOR_BLUE);
if(JoyState == JOY_SEL)
{
BSP_LCD_SetTextColor(LCD_COLOR_RED);
BSP_LCD_DisplayChar(xPtr, yPtr, 'X');
}
else if(JoyState == JOY_NONE)
{
BSP_LCD_SetTextColor(LCD_COLOR_BLUE);
BSP_LCD_DisplayChar(xPtr, yPtr, 'X');
}
else
{
BSP_LCD_SetTextColor(LCD_COLOR_WHITE);
BSP_LCD_DisplayChar(old_xPtr, old_yPtr, 'X');
BSP_LCD_SetTextColor(LCD_COLOR_BLUE);
BSP_LCD_DisplayChar(xPtr, yPtr, 'X');
old_xPtr = xPtr;
old_yPtr = yPtr;
}
}
if(CheckForUserInput() > 0)
{
return;
}
HAL_Delay(5);
}
}
/**
* @brief Configures and gets Touch screen position.
* @param None
* @retval None
*/
static void GetPosition(void)
{
static uint32_t x = 0, y = 0;
static uint32_t color_heigh;
static uint32_t color;
static TS_StateTypeDef TS_State;
/* Heigh of color pen */
color_heigh = 20;
/* Get Touch screen position */
BSP_TS_GetState(&TS_State);
/* Read the coordinate */
x = Calibration_GetX(TS_State.X);
y = Calibration_GetX(TS_State.Y);
if ((TS_State.TouchDetected) & ( x > 0 ) & ( x < 50 ))
{
/* User selects one of the color pens */
if ((TS_State.TouchDetected) & ( y > 0 ) & ( y < color_heigh ))
{
BSP_LCD_SetTextColor(LCD_COLOR_WHITE);
}
else if ((TS_State.TouchDetected) & ( y > color_heigh ) & ( y < (2*color_heigh) ))
{
BSP_LCD_SetTextColor(LCD_COLOR_YELLOW);
}
else if ((TS_State.TouchDetected) & ( y > (2*color_heigh) ) & ( y < (3*color_heigh) ))
{
BSP_LCD_SetTextColor(LCD_COLOR_ORANGE);
}
else if ((TS_State.TouchDetected) & ( y > (3*color_heigh) ) & ( y < (4*color_heigh) ))
{
BSP_LCD_SetTextColor(LCD_COLOR_LIGHTMAGENTA);
}
else if ((TS_State.TouchDetected) & ( y > (4*color_heigh) ) & ( y < (5*color_heigh) ))
{
BSP_LCD_SetTextColor(LCD_COLOR_DARKGREEN);
}
else if ((TS_State.TouchDetected) & ( y > (5*color_heigh) ) &( y < (6*color_heigh) ))
{
BSP_LCD_SetTextColor(LCD_COLOR_GREEN);
}
else if ((TS_State.TouchDetected) & ( y > (6*color_heigh) ) &( y < (7*color_heigh) ))
{
BSP_LCD_SetTextColor(LCD_COLOR_BROWN);
}
else if ((TS_State.TouchDetected) & ( y > (7*color_heigh) ) & ( y < (8*color_heigh) ))
{
BSP_LCD_SetTextColor(LCD_COLOR_RED);
}
else if ((TS_State.TouchDetected) & ( y > (8*color_heigh) ) & ( y < (9*color_heigh) ))
{
BSP_LCD_SetTextColor(LCD_COLOR_DARKMAGENTA);
}
else if ((TS_State.TouchDetected) & ( y > (9*color_heigh) ) & ( y < (10*color_heigh) ))
{
BSP_LCD_SetTextColor(LCD_COLOR_CYAN);
}
else if ((TS_State.TouchDetected) & ( y > (10*color_heigh) ) & ( y < (11*color_heigh) ))
{
BSP_LCD_SetTextColor(LCD_COLOR_DARKBLUE);
}
else if ((TS_State.TouchDetected) & ( y > (11*color_heigh) ) & ( y < (12*color_heigh) ))
{
BSP_LCD_SetTextColor(LCD_COLOR_BLACK);
}
else if ((TS_State.TouchDetected) & ( y > (12*color_heigh) ) & ( y < (13*color_heigh) ))
{
/* Clear screen and reinitialize color and size */
/* Get the current text color */
color = BSP_LCD_GetTextColor();
BSP_LCD_SetTextColor(LCD_COLOR_WHITE);
/* Clear the working window */
BSP_LCD_FillRect(68, 8, 164, 245);
BSP_LCD_SetTextColor(color);
radius = 2;
}
else
{
x = 0;
y = 0;
}
Update_ColorSize();
}
else if ((TS_State.TouchDetected) & ( x > 65 ) & ( y > (BSP_LCD_GetYSize()-48)) & ( y < (BSP_LCD_GetYSize()) ) & ( x < 85 ))
{
radius = 10;
Update_ColorSize();
}
else if ((TS_State.TouchDetected) & ( x > 100 ) & ( y > (BSP_LCD_GetYSize()-48) ) & ( y < (BSP_LCD_GetYSize()) ) & ( x < 110 ))
{
radius = 5;
Update_ColorSize();
}
else if ((TS_State.TouchDetected) & ( x > 133 ) & ( y > (BSP_LCD_GetYSize()-48) ) & ( y < (BSP_LCD_GetYSize()) ) & ( x < 137 ))
{
radius = 2;
Update_ColorSize();
}
else if (((TS_State.TouchDetected) & ( x > (BSP_LCD_GetXSize()-5) ) & ( y > (12*color_heigh) ) & ( y < (13*color_heigh) )) | (( x < 55 ) & ( y < 5 )))
{
x = 0;
y = 0;
}
else if ((TS_State.TouchDetected) & ( x > (67 + radius)) & ( y > (7 + radius) ) & ( x < (BSP_LCD_GetXSize()-(7 + radius )) ) & ( y < (BSP_LCD_GetYSize()-(67 + radius )) ))
{
BSP_LCD_FillCircle((x), (y), radius);
}
else if ((TS_State.TouchDetected) & ( (x > 150) & ( y > (BSP_LCD_GetYSize() - 50) )) & ( x < 200 ) & ( y < (BSP_LCD_GetYSize()) ))
{
Save_Picture();
}
}
/**
* @brief Main program
* @param None
* @retval None
*/
int main(void)
{
/* This sample code shows how to use STM32F7xx CEC HAL API to transmit and
* receive data. The device is set in waiting to receive mode and sends
* messages when the evaluation board buttons are pushed by the user */
/* Configure the MPU attributes as Write Through */
MPU_Config();
/* Enable the CPU Cache */
CPU_CACHE_Enable();
/* STM32F7xx HAL library initialization:
- Configure the Flash ART accelerator
- Systick timer is configured by default as source of time base, but user
can eventually implement his proper time base source (a general purpose
timer for example or other time source), keeping in mind that Time base
duration should be kept 1ms since PPP_TIMEOUT_VALUEs are defined and
handled in milliseconds basis.
- Set NVIC Group Priority to 4
- Low Level Initialization
*/
HAL_Init();
/* Configure the system clock to 200 MHz MHz */
SystemClock_Config();
/*##-1- Initialize the SDRAM ##############################################*/
BSP_SDRAM_Init();
/*##-2- Initialize the LCD #################################################*/
BSP_LCD_Init();
BSP_LCD_LayerDefaultInit(1, LCD_FRAME_BUFFER);
/* Enable the LCD */
BSP_LCD_DisplayOn();
/* Select the LCD Foreground layer */
BSP_LCD_SelectLayer(1);
/* Display test description on screen */
CEC_SetHint();
/* -2- Configure touch screen */
BSP_TS_Init(BSP_LCD_GetXSize(), BSP_LCD_GetYSize());
BSP_TS_ITConfig(); /* Touch screen interrupt configuration and enable */
/* -3- CEC configuration (transfer will take place in Interrupt mode) */
#if defined (DEVICE_1)
DestinationAddress = DEVICE_ADDRESS_2; /* follower address */
#elif defined (DEVICE_2)
DestinationAddress = DEVICE_ADDRESS_1; /* follower address */
#endif
hcec.Instance = CEC;
/* Deinitialize CEC to reinitialize from scratch */
HAL_CEC_DeInit(&hcec);
/* IP configuration */
CEC_Config(&hcec);
/* -4- CEC transfer general variables initialization */
ReceivedFrame = 0;
StartSending = 0;
NbOfReceivedBytes = 0;
CEC_FlushRxBuffer();
/* Test start */
/* Enter infinite reception loop: the CEC device is set in
* waiting to receive mode.
* The CEC "background" state is HAL_CEC_STATE_STANDBY_RX.
* Upon any message reception or transmission, the CEC
* comes back to that state.
* It is up to the user to define exit conditions in modifying
* accordingly the RX, TX or Error callback functions. */
HAL_CEC_Receive_IT(&hcec, (uint8_t *)&Tab_Rx);
while (HAL_CEC_GetState(&hcec) != HAL_CEC_STATE_READY)
{
/* if no reception has occurred and no error has been detected,
* transmit a message if the user has pushed a button */
if( (StartSending == 1) && (ReceivedFrame == 0))
{
HAL_CEC_Transmit_IT(&hcec, DestinationAddress, (uint8_t *)&Tab_Tx, TxSize);
/* loop until TX ends or TX error reported */
while (HAL_CEC_GetState(&hcec) != HAL_CEC_STATE_STANDBY_RX);
StartSending = 0;
}
/* if a frame has been received */
if (ReceivedFrame == 1)
{
if (Tab_Rx[1] == 0x44) /* Test on the opcode value */
{
/* Receive command is equal to Command 1 */
if (Tab_Rx[2] == 0x41) /* Test on the operand value */
{
BSP_LCD_SetTextColor(LCD_COLOR_WHITE);
BSP_LCD_SetBackColor(LCD_COLOR_BLUE);
BSP_LCD_DisplayStringAt(0, (BSP_LCD_GetYSize()/2)+30, (uint8_t *)" Received opcode 44, operand 41 ", CENTER_MODE);
}
else if (Tab_Rx[2] == 0x42) /* Receive command is equal to Command 2 */
{
BSP_LCD_SetTextColor(LCD_COLOR_WHITE);
BSP_LCD_SetBackColor(LCD_COLOR_GREEN);
BSP_LCD_DisplayStringAt(0, (BSP_LCD_GetYSize()/2)+30, (uint8_t *)" Received opcode 44, operand 42 ", CENTER_MODE);
}
}
else if (Tab_Rx[1] == 0x46) /* Test on the opcode value */
{
BSP_LCD_SetTextColor(LCD_COLOR_WHITE);
BSP_LCD_SetBackColor(LCD_COLOR_ORANGE);
BSP_LCD_DisplayStringAt(0, (BSP_LCD_GetYSize()/2)+30, (uint8_t *)" Received opcode 46 ", CENTER_MODE);
}
else if (Tab_Rx[1] == 0x9F) /* Test on the opcode value */
{
BSP_LCD_SetTextColor(LCD_COLOR_WHITE);
BSP_LCD_SetBackColor(LCD_COLOR_DARKMAGENTA);
BSP_LCD_DisplayStringAt(0, (BSP_LCD_GetYSize()/2)+30, (uint8_t *)" Received opcode 9F ", CENTER_MODE);
}
ReceivedFrame = 0;
}
else if (ReceivedFrame == 2) /* means CEC error detected */
{
BSP_LCD_SetTextColor(LCD_COLOR_WHITE);
BSP_LCD_SetBackColor(LCD_COLOR_RED);
BSP_LCD_DisplayStringAt(0, (BSP_LCD_GetYSize()/2)+45, (uint8_t *)" CEC Error ", CENTER_MODE);
ReceivedFrame = 0;
}
} /* while (HAL_CEC_GetState(&hcec) != HAL_CEC_STATE_READY) */
return 0;
}
/**
* @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 Main program
* @param None
* @retval None
*/
int main(void)
{
/* STM32F4xx HAL library initialization:
- Configure the Flash prefetch, instruction and Data caches
- Configure the Systick to generate an interrupt each 1 msec
- Set NVIC Group Priority to 4
- Global MSP (MCU Support Package) initialization
*/
HAL_Init();
/* Configure the system clock to 168 MHz */
SystemClock_Config();
/* Configure TAMPER/KEY button */
BSP_PB_Init(BUTTON_TAMPER, BUTTON_MODE_GPIO);
/*##-1- Initialize the LCD #################################################*/
/* Initialize the LCD */
BSP_LCD_Init();
/* Set LCD font */
BSP_LCD_SetFont(&Font20);
/*##-2- Display messages on LCD ############################################*/
/* Clear the LCD */
BSP_LCD_Clear(LCD_COLOR_WHITE);
/* Set the LCD Text Color */
BSP_LCD_SetTextColor(LCD_COLOR_BLUE);
/* Display test name on LCD */
BSP_LCD_DisplayStringAtLine(0,(uint8_t*)" Flash Write ");
BSP_LCD_DisplayStringAtLine(1,(uint8_t*)" protection test ");
BSP_LCD_DisplayStringAtLine(2,(uint8_t*)" Press User ");
BSP_LCD_DisplayStringAtLine(3,(uint8_t*)" Tamper-button ");
/* Infinite loop */
while (1)
{
/* Wait for TAMPER button to be pushed */
while(BSP_PB_GetState(BUTTON_TAMPER) != RESET)
{
}
/* Get FLASH_WRP_SECTORS write protection status */
HAL_FLASHEx_OBGetConfig(&OBInit);
SectorsWRPStatus = OBInit.WRPSector & FLASH_WRP_SECTORS;
if (SectorsWRPStatus == 0)
{
/* If FLASH_WRP_SECTORS are write protected, disable the write protection */
/* Allow Access to option bytes sector */
HAL_FLASH_OB_Unlock();
/* Allow Access to Flash control registers and user Flash */
HAL_FLASH_Unlock();
/* Disable FLASH_WRP_SECTORS write protection */
OBInit.OptionType = OPTIONBYTE_WRP;
OBInit.WRPState = OB_WRPSTATE_DISABLE;
OBInit.Banks = FLASH_BANK_1;
OBInit.WRPSector = FLASH_WRP_SECTORS;
HAL_FLASHEx_OBProgram(&OBInit);
/* Start the Option Bytes programming process */
if (HAL_FLASH_OB_Launch() != HAL_OK)
{
/* User can add here some code to deal with this error */
while (1)
{
}
}
/* Prevent Access to option bytes sector */
HAL_FLASH_OB_Lock();
/* Disable the Flash option control register access (recommended to protect
the option Bytes against possible unwanted operations) */
HAL_FLASH_Lock();
/* Get FLASH_WRP_SECTORS write protection status */
HAL_FLASHEx_OBGetConfig(&OBInit);
SectorsWRPStatus = OBInit.WRPSector & FLASH_WRP_SECTORS;
/* Check if FLASH_WRP_SECTORS write protection is disabled */
if (SectorsWRPStatus == FLASH_WRP_SECTORS)
{
/* Set the LCD Text Color */
BSP_LCD_SetTextColor(LCD_COLOR_GREEN);
BSP_LCD_DisplayStringAtLine(5,(uint8_t*)" Write ");
BSP_LCD_DisplayStringAtLine(6,(uint8_t*)" protection is ");
BSP_LCD_DisplayStringAtLine(7,(uint8_t*)" disabled ");
}
else
{
/* Set the LCD Text Color */
BSP_LCD_SetTextColor(LCD_COLOR_RED);
BSP_LCD_DisplayStringAtLine(5,(uint8_t*)" Write ");
BSP_LCD_DisplayStringAtLine(6,(uint8_t*)" protection is ");
BSP_LCD_DisplayStringAtLine(7,(uint8_t*)" not disabled ");
}
}
else
{ /* If FLASH_WRP_SECTORS are not write protected, enable the write protection */
/* Allow Access to option bytes sector */
HAL_FLASH_OB_Unlock();
/* Allow Access to Flash control registers and user Flash */
HAL_FLASH_Unlock();
/* Enable FLASH_WRP_SECTORS write protection */
OBInit.OptionType = OPTIONBYTE_WRP;
OBInit.WRPState = OB_WRPSTATE_ENABLE;
OBInit.Banks = FLASH_BANK_1;
OBInit.WRPSector = FLASH_WRP_SECTORS;
HAL_FLASHEx_OBProgram(&OBInit);
/* Start the Option Bytes programming process */
if (HAL_FLASH_OB_Launch() != HAL_OK)
{
/* User can add here some code to deal with this error */
while (1)
{
}
}
/* Prevent Access to option bytes sector */
HAL_FLASH_OB_Lock();
/* Disable the Flash option control register access (recommended to protect
the option Bytes against possible unwanted operations) */
HAL_FLASH_Lock();
/* Get FLASH_WRP_SECTORS write protection status */
HAL_FLASHEx_OBGetConfig(&OBInit);
SectorsWRPStatus = OBInit.WRPSector & FLASH_WRP_SECTORS;
/* Check if FLASH_WRP_SECTORS are write protected */
if (SectorsWRPStatus == 0)
{
/* Set the LCD Text Color */
BSP_LCD_SetTextColor(LCD_COLOR_GREEN);
BSP_LCD_DisplayStringAtLine(5,(uint8_t*)" Write ");
BSP_LCD_DisplayStringAtLine(6,(uint8_t*)" protection is ");
BSP_LCD_DisplayStringAtLine(7,(uint8_t*)" enabled ");
}
else
{
/* Set the LCD Text Color */
BSP_LCD_SetTextColor(LCD_COLOR_RED);
BSP_LCD_DisplayStringAtLine(5,(uint8_t*)" Write ");
BSP_LCD_DisplayStringAtLine(6,(uint8_t*)" protection is ");
BSP_LCD_DisplayStringAtLine(7,(uint8_t*)" enabled ");
}
}
}
}
/**
* @brief Touchscreen Demo1 : test touchscreen calibration and single touch in polling mode
* @param None
* @retval None
*/
void Touchscreen_demo1(void)
{
uint16_t x1, y1;
uint8_t state = 0;
uint8_t exitTsUseCase = 0;
uint32_t ts_status = TS_OK;
/* Reset touch data information */
BSP_TEST_APPLI_ASSERT(BSP_TS_ResetTouchData(&TS_State));
/* If calibration is not yet done, proceed with calibration */
if (TouchScreen_IsCalibrationDone() == 0)
{
ts_status = Touchscreen_Calibration();
if (ts_status == TS_OK)
{
BSP_LCD_DisplayStringAt(0, BSP_LCD_GetYSize() - 65, (uint8_t *) "Touchscreen calibration success.", CENTER_MODE);
}
} /* of if (TouchScreen_IsCalibrationDone() == 0) */
if(ts_status == TS_OK)
{
/* Display touch screen demo description */
Touchscreen_SetHint_Demo(TOUCHSCREEN_DEMO_1);
Touchscreen_DrawBackground_Demo1(state);
while (exitTsUseCase == 0)
{
if (ts_status == TS_OK)
{
/* Check in polling mode in touch screen the touch status and coordinates */
/* of touches if touch occurred */
ts_status = BSP_TS_GetState(&TS_State);
if(TS_State.touchDetected)
{
/* One or dual touch have been detected */
/* Only take into account the first touch so far */
/* Get X and Y position of the first touch post calibrated */
x1 = TouchScreen_Get_Calibrated_X(TS_State.touchX[0]);
y1 = TouchScreen_Get_Calibrated_Y(TS_State.touchY[0]);
if ((y1 > (CIRCLE_YPOS(1) - CIRCLE_RADIUS)) &&
(y1 < (CIRCLE_YPOS(1) + CIRCLE_RADIUS)))
{
if ((x1 > (CIRCLE_XPOS(1) - CIRCLE_RADIUS)) &&
(x1 < (CIRCLE_XPOS(1) + CIRCLE_RADIUS)))
{
if ((state & 1) == 0)
{
Touchscreen_DrawBackground_Demo1(state);
BSP_LCD_SetTextColor(LCD_COLOR_BLUE);
BSP_LCD_FillCircle(CIRCLE_XPOS(1), CIRCLE_YPOS(1), CIRCLE_RADIUS);
state = 1;
}
}
if ((x1 > (CIRCLE_XPOS(2) - CIRCLE_RADIUS)) &&
(x1 < (CIRCLE_XPOS(2) + CIRCLE_RADIUS)))
{
if ((state & 2) == 0)
{
Touchscreen_DrawBackground_Demo1(state);
BSP_LCD_SetTextColor(LCD_COLOR_RED);
BSP_LCD_FillCircle(CIRCLE_XPOS(2), CIRCLE_YPOS(2), CIRCLE_RADIUS);
state = 2;
}
}
if ((x1 > (CIRCLE_XPOS(3) - CIRCLE_RADIUS)) &&
(x1 < (CIRCLE_XPOS(3) + CIRCLE_RADIUS)))
{
if ((state & 4) == 0)
{
Touchscreen_DrawBackground_Demo1(state);
BSP_LCD_SetTextColor(LCD_COLOR_YELLOW);
BSP_LCD_FillCircle(CIRCLE_XPOS(3), CIRCLE_YPOS(3), CIRCLE_RADIUS);
state = 4;
}
}
if ((x1 > (CIRCLE_XPOS(4) - CIRCLE_RADIUS)) &&
(x1 < (CIRCLE_XPOS(4) + CIRCLE_RADIUS)))
{
if ((state & 8) == 0)
{
Touchscreen_DrawBackground_Demo1(state);
BSP_LCD_SetTextColor(LCD_COLOR_GREEN);
BSP_LCD_FillCircle(CIRCLE_XPOS(4), CIRCLE_YPOS(3), CIRCLE_RADIUS);
state = 8;
}
}
}
} /* of if(TS_State.TouchDetected) */
} /* of if (ts_status == TS_OK) */
/* Wait for a key button press to switch to next test case of BSP validation application */
/* Otherwise stay in the test */
exitTsUseCase = CheckForUserInput();
HAL_Delay(20);
} /* of while (exitTsUseCase == 0) */
} /* of if(status == TS_OK) */
}
/**
* @brief Manages Audio process.
* @param None
* @retval Audio error
*/
AUDIO_ErrorTypeDef AUDIO_Process(void)
{
uint32_t bytesread, elapsed_time;
AUDIO_ErrorTypeDef audio_error = AUDIO_ERROR_NONE;
static uint32_t prev_elapsed_time = 0xFFFFFFFF;
uint8_t str[10];
switch(AudioState)
{
case AUDIO_STATE_PLAY:
if(BufferCtl.fptr >= WaveFormat.FileSize)
{
BSP_AUDIO_OUT_Stop(CODEC_PDWN_SW);
AudioState = AUDIO_STATE_NEXT;
}
if(BufferCtl.offset == BUFFER_OFFSET_HALF)
{
if(f_read(&WavFile,
&BufferCtl.buff[0],
AUDIO_BUFFER_SIZE/2,
(void *)&bytesread) != FR_OK)
{
BSP_AUDIO_OUT_Stop(CODEC_PDWN_SW);
return AUDIO_ERROR_IO;
}
BufferCtl.offset = BUFFER_OFFSET_NONE;
BufferCtl.fptr += bytesread;
}
if(BufferCtl.offset == BUFFER_OFFSET_FULL)
{
if(f_read(&WavFile,
&BufferCtl.buff[AUDIO_BUFFER_SIZE /2],
AUDIO_BUFFER_SIZE/2,
(void *)&bytesread) != FR_OK)
{
BSP_AUDIO_OUT_Stop(CODEC_PDWN_SW);
return AUDIO_ERROR_IO;
}
BufferCtl.offset = BUFFER_OFFSET_NONE;
BufferCtl.fptr += bytesread;
}
/* Display elapsed time */
elapsed_time = BufferCtl.fptr / WaveFormat.ByteRate;
if(prev_elapsed_time != elapsed_time)
{
prev_elapsed_time = elapsed_time;
sprintf((char *)str, "[%02d:%02d]", (int)(elapsed_time /60), (int)(elapsed_time%60));
BSP_LCD_SetTextColor(LCD_COLOR_CYAN);
BSP_LCD_DisplayStringAt(263, LINE(8), str, LEFT_MODE);
BSP_LCD_SetTextColor(LCD_COLOR_WHITE);
}
break;
case AUDIO_STATE_STOP:
BSP_AUDIO_OUT_Stop(CODEC_PDWN_SW);
AudioState = AUDIO_STATE_IDLE;
audio_error = AUDIO_ERROR_IO;
break;
case AUDIO_STATE_NEXT:
if(++FilePos >= AUDIO_GetWavObjectNumber())
{
FilePos = 0;
}
BSP_AUDIO_OUT_Stop(CODEC_PDWN_SW);
AUDIO_Start(FilePos);
break;
case AUDIO_STATE_PREVIOUS:
if(--FilePos < 0)
{
FilePos = AUDIO_GetWavObjectNumber() - 1;
}
BSP_AUDIO_OUT_Stop(CODEC_PDWN_SW);
AUDIO_Start(FilePos);
break;
case AUDIO_STATE_PAUSE:
BSP_LCD_DisplayStringAt(250, LINE(14), (uint8_t *)" [PAUSE]", LEFT_MODE);
BSP_AUDIO_OUT_Pause();
AudioState = AUDIO_STATE_WAIT;
break;
case AUDIO_STATE_RESUME:
BSP_LCD_DisplayStringAt(250, LINE(14), (uint8_t *)" [PLAY ]", LEFT_MODE);
BSP_AUDIO_OUT_Resume();
AudioState = AUDIO_STATE_PLAY;
break;
case AUDIO_STATE_VOLUME_UP:
if( uwVolume <= 90)
{
uwVolume += 10;
}
BSP_AUDIO_OUT_SetVolume(uwVolume);
AudioState = AUDIO_STATE_PLAY;
break;
case AUDIO_STATE_VOLUME_DOWN:
if( uwVolume >= 10)
{
uwVolume -= 10;
}
BSP_AUDIO_OUT_SetVolume(uwVolume);
AudioState = AUDIO_STATE_PLAY;
break;
case AUDIO_STATE_WAIT:
case AUDIO_STATE_CONFIG:
case AUDIO_STATE_IDLE:
case AUDIO_STATE_INIT:
default:
/* Do Nothing */
break;
}
return audio_error;
}
/**
* @brief Touchscreen Demo
* @param None
* @retval None
*/
void Touchscreen_demo (void)
{
uint8_t status = 0;
uint16_t x,y;
uint8_t state = 0;
if(stmpe811_ts_drv.ReadID(TS_I2C_ADDRESS) == STMPE811_ID)
{
if(IsCalibrationDone() == 0)
{
Touchscreen_Calibration();
}
}
Touchscreen_SetHint();
status = BSP_TS_Init(BSP_LCD_GetXSize(), BSP_LCD_GetYSize());
if (status != TS_OK)
{
BSP_LCD_SetBackColor(LCD_COLOR_WHITE);
BSP_LCD_SetTextColor(LCD_COLOR_RED);
BSP_LCD_DisplayStringAt(0, BSP_LCD_GetYSize()- 95, (uint8_t *)"ERROR", CENTER_MODE);
BSP_LCD_DisplayStringAt(0, BSP_LCD_GetYSize()- 80, (uint8_t *)"Touchscreen cannot be initialized", CENTER_MODE);
}
else
{
Touchscreen_DrawBackground(state);
}
while (1)
{
if (status == TS_OK)
{
BSP_TS_GetState(&TS_State);
if(stmpe811_ts_drv.ReadID(TS_I2C_ADDRESS) == STMPE811_ID)
{
x = Calibration_GetX(TS_State.x);
y = Calibration_GetY(TS_State.y);
}
else
{
x = TS_State.x;
y = TS_State.y;
}
if((TS_State.TouchDetected) &&
(y > (CIRCLE_YPOS(1) - CIRCLE_RADIUS))&&
(y < (CIRCLE_YPOS(1) + CIRCLE_RADIUS)))
{
if((x > (CIRCLE_XPOS(1) - CIRCLE_RADIUS))&&
(x < (CIRCLE_XPOS(1) + CIRCLE_RADIUS)))
{
if((state & 1) == 0)
{
Touchscreen_DrawBackground(state);
BSP_LCD_SetTextColor(LCD_COLOR_BLUE);
BSP_LCD_FillCircle(CIRCLE_XPOS(1), CIRCLE_YPOS(1), CIRCLE_RADIUS);
state = 1;
}
}
if((x > (CIRCLE_XPOS(2) - CIRCLE_RADIUS))&&
(x < (CIRCLE_XPOS(2) + CIRCLE_RADIUS)))
{
if((state & 2) == 0)
{
Touchscreen_DrawBackground(state);
BSP_LCD_SetTextColor(LCD_COLOR_RED);
BSP_LCD_FillCircle(CIRCLE_XPOS(2), CIRCLE_YPOS(2), CIRCLE_RADIUS);
state = 2;
}
}
if((x > (CIRCLE_XPOS(3) - CIRCLE_RADIUS))&&
(x < (CIRCLE_XPOS(3) + CIRCLE_RADIUS)))
{
if((state & 4) == 0)
{
Touchscreen_DrawBackground(state);
BSP_LCD_SetTextColor(LCD_COLOR_YELLOW);
BSP_LCD_FillCircle(CIRCLE_XPOS(3), CIRCLE_YPOS(3), CIRCLE_RADIUS);
state = 4;
}
}
if((x > (CIRCLE_XPOS(4) - CIRCLE_RADIUS))&&
(x < (CIRCLE_XPOS(4) + CIRCLE_RADIUS)))
{
if((state & 8) == 0)
{
Touchscreen_DrawBackground(state);
BSP_LCD_SetTextColor(LCD_COLOR_GREEN);
BSP_LCD_FillCircle(CIRCLE_XPOS(4), CIRCLE_YPOS(3), CIRCLE_RADIUS);
state = 8;
}
}
}
}
if(CheckForUserInput() > 0)
{
return;
}
HAL_Delay(10);
}
}
/**
* @brief Manages MSC Menu Process.
* @param None
* @retval None
*/
void MSC_MenuProcess(void)
{
switch(demo.msc_state)
{
case APPLI_MSC_START:
if(Appli_HS_state == APPLICATION_HS_READY)
{
BSP_LCD_ClearStringLine(19);
BSP_LCD_ClearStringLine(20);
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_TAMPER) != SET) && (Appli_HS_state != APPLICATION_HS_DISCONNECT))
{
}
demo.msc_state = APPLI_MSC_FILE_OPERATIONS;
/* Prevent debounce effect for user key */
HAL_Delay(400);
BSP_LCD_ClearStringLine(19);
}
break;
case APPLI_MSC_FILE_OPERATIONS:
/* Read and Write File Here */
if(Appli_HS_state == APPLICATION_HS_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_TAMPER) != SET) && (Appli_HS_state != APPLICATION_HS_DISCONNECT))
{
}
demo.msc_state = APPLI_MSC_EXPLORER;
/* Prevent debounce effect for user key */
HAL_Delay(400);
BSP_LCD_ClearStringLine(19);
}
break;
case APPLI_MSC_EXPLORER:
/* Display disk content */
if(Appli_HS_state == APPLICATION_HS_READY)
{
Explore_Disk("0:/", 1);
demo.msc_state = APPLI_MSC_START;
demo.state = DEMO_IDLE;
BSP_LCD_ClearStringLine(19);
BSP_LCD_ClearStringLine(20);
BSP_LCD_SetTextColor(LCD_COLOR_GREEN);
BSP_LCD_DisplayStringAtLine(20, (uint8_t *)"Press User button to exit");
/* Prevent debounce effect for user key */
HAL_Delay(400);
/* Wait for User Input */
while((BSP_PB_GetState(BUTTON_TAMPER) != SET) && (Appli_HS_state != APPLICATION_HS_DISCONNECT))
{
}
/* Prevent debounce effect for user key */
HAL_Delay(400);
}
break;
default:
break;
}
}
/**
* @brief Display temperature
* @param temperature : temperature value
* @retval None
*/
static void TSENSOR_Display_Temperature(uint16_t Temperature)
{
uint8_t tempcelsiusdisplay[] = "+abc.dddd C";
uint16_t temperaturevalue = Temperature;
uint16_t temperaturevaluecelsius = 0;
uint32_t tempcelsius = 0;
BSP_LCD_SetTextColor(LCD_COLOR_BLACK);
BSP_LCD_SetFont(&Font12);
BSP_LCD_DisplayStringAt(0, 115, (uint8_t*)"Measured Temperature : ", CENTER_MODE);
/* Change Font size to display Temperature Value */
BSP_LCD_SetFont(&Font16);
/* Clear previous warning message */
BSP_LCD_SetTextColor(LCD_COLOR_WHITE);
BSP_LCD_DisplayStringAt(0, 160, (uint8_t *)" ", CENTER_MODE);
BSP_LCD_DisplayStringAt(0, 175, (uint8_t *)" ", CENTER_MODE);
/* Verify the sign of the temperature */
if (temperaturevalue <= 2048)
{
/* Positive temperature measured */
tempcelsiusdisplay[0] = '+';
/* Initialize the temperature sensor value*/
temperaturevaluecelsius = temperaturevalue;
/* Set Text color to Green */
BSP_LCD_SetTextColor(LCD_COLOR_GREEN);
}
else
{
/* Negative temperature measured */
tempcelsiusdisplay[0] = '-';
/* Remove temperature value sign */
temperaturevaluecelsius = 0x1000 - temperaturevalue;
/* Set Text color to Red */
BSP_LCD_SetTextColor(LCD_COLOR_BLUE);
}
tempcelsius = 0;
/* Calculate temperature digits in °C */
if (temperaturevaluecelsius & 0x01)
{
tempcelsius += 625;
}
if (temperaturevaluecelsius & 0x02)
{
tempcelsius += 1250;
}
if (temperaturevaluecelsius & 0x04)
{
tempcelsius += 2500;
}
if (temperaturevaluecelsius & 0x08)
{
tempcelsius += 5000;
}
tempcelsiusdisplay[5] = (tempcelsius / 1000) + 0x30;
tempcelsiusdisplay[6] = ((tempcelsius % 1000) / 100) + 0x30;
tempcelsiusdisplay[7] = (((tempcelsius % 1000) % 100) / 10)+ 0x30;
tempcelsiusdisplay[8] = (((tempcelsius % 1000) % 100) % 10) + 0x30;
temperaturevaluecelsius >>= 4;
tempcelsiusdisplay[1] = (temperaturevaluecelsius / 100) + 0x30;
tempcelsiusdisplay[2] = ((temperaturevaluecelsius % 100) / 10) + 0x30;
tempcelsiusdisplay[3] = ((temperaturevaluecelsius % 100) % 10) + 0x30;
/* Display Temperature value on LCD */
BSP_LCD_DisplayStringAt(0, 145, tempcelsiusdisplay, CENTER_MODE);
}
/**
* @brief Camera demo
* @param None
* @retval None
*/
void Camera_demo (void)
{
uint8_t status = 0;
uint16_t *ptrCamera;
uint32_t i;
uint32_t exit = 0;
Camera_SetHint();
status = BSP_JOY_Init(JOY_MODE_GPIO);
/* Initialize the SDRAM for CAMERA_FRAME_BUFFER */
BSP_SDRAM_Init();
if (status != IO_OK)
{
BSP_LCD_SetBackColor(LCD_COLOR_WHITE);
BSP_LCD_SetTextColor(LCD_COLOR_RED);
BSP_LCD_DisplayStringAt(0, BSP_LCD_GetYSize()- CAMERA_STATUS_TEXT_POS, (uint8_t *)"ERROR", CENTER_MODE);
BSP_LCD_DisplayStringAt(0, BSP_LCD_GetYSize()- CAMERA_STATUS_TEXT_POS - 15, (uint8_t *)"Joystick cannot be initialized", CENTER_MODE);
status = 0;
}
/*## Camera Initialization and start capture ############################*/
BSP_LCD_SetBackColor(LCD_COLOR_BLUE);
BSP_LCD_SetTextColor(LCD_COLOR_WHITE);
BSP_LCD_DisplayStringAt(0, BSP_LCD_GetYSize()- CAMERA_STATUS_TEXT_POS, (uint8_t *)"Wait for camera initialization...", CENTER_MODE);
/* Init Camera buffer */
ptrCamera = (uint16_t*)(CAMERA_FRAME_BUFFER);
CameraResIndex = CAMERA_R160x120; /* Set QQVGA default resolution */
CameraChangeResolutionAsked = 1;
for (i=0; i<(CAMERA_QVGA_RES_X * CAMERA_QVGA_RES_Y); i++) /* Camera buffer initialization */
{
ptrCamera[i]=0xFFFF;
}
/* Initialize IO */
BSP_IO_Init();
/* Infinite loop */
while(exit == 0)
{
if (CameraChangeResolutionAsked) /* A camera change resolution has been asked */
{
CameraChangeResolutionAsked = 0;
if (CameraResIndex > CAMERA_R160x120)
{ /* If camera stream already started, it has to be stopped before reconfiguration */
/* Stop camera stream */
status = BSP_CAMERA_Stop();
ASSERT(status != CAMERA_OK);
/* Clear screen */
Camera_SetHint();
BSP_LCD_SetBackColor(LCD_COLOR_BLUE);
BSP_LCD_SetTextColor(LCD_COLOR_WHITE);
BSP_LCD_DisplayStringAt(0, BSP_LCD_GetYSize()- CAMERA_STATUS_TEXT_POS, (uint8_t *)"Wait for camera initialization...", CENTER_MODE);
}
BSP_LCD_SetBackColor(LCD_COLOR_WHITE);
BSP_LCD_SetTextColor(LCD_COLOR_BLUE);
status = 0;
switch (CameraResIndex)
{
case CAMERA_R160x120:
/* Initialize the Camera */
status = BSP_CAMERA_Init(RESOLUTION_R160x120);
BSP_LCD_DisplayStringAt(0, BSP_LCD_GetYSize()- CAMERA_STATUS_TEXT_POS, (uint8_t *)" QQVGA camera stream ", CENTER_MODE);
break;
case CAMERA_R320x240:
/* Initialize the Camera */
status = BSP_CAMERA_Init(RESOLUTION_R320x240);
BSP_LCD_DisplayStringAt(0, BSP_LCD_GetYSize()- CAMERA_STATUS_TEXT_POS, (uint8_t *)" QVGA camera stream ", CENTER_MODE);
break;
}
if (status != CAMERA_OK)
{
BSP_LCD_DisplayStringAt(0, BSP_LCD_GetYSize()- CAMERA_STATUS_TEXT_POS - 15, (uint8_t *)" CAMERA INIT ERROR ", CENTER_MODE);
}
/* Start / Restart camera stream */
BSP_CAMERA_ContinuousStart((uint8_t *)CAMERA_FRAME_BUFFER);
} /* (CameraResIndex != CameraCurrentResIndex) */
/* Toggle LED4 */
BSP_LED_Toggle(LED3);
/* Insert 100 ms delay */
HAL_Delay(100);
/* Toggle LED2 */
BSP_LED_Toggle(LED2);
/* Insert 100 ms delay */
HAL_Delay(100);
if(CheckForUserInput() > 0)
{
if (CameraResIndex < CAMERA_RES_INDEX_MAX)
{
CameraResIndex++; /* Switch to higher resolution */
CameraChangeResolutionAsked = 1;
}
else
{
BSP_CAMERA_DeInit();
exit = 1;
}
}
}
/* Stop camera stream */
status = BSP_CAMERA_Stop();
ASSERT(status != CAMERA_OK);
/* End of camera demo */
}
