/**
* @brief Show EEPROM Features
* @param feature : feature index
* @retval None
*/
static void EEPROM_Show_Feature(uint8_t feature)
{
uint8_t Tx1Buffer[] = "STM32F303C EEPROM";
uint8_t Rx1Buffer[BUFFER_SIZE1] = {0};
uint8_t Tx2Buffer[BUFFER_SIZE1] = {0};
__IO TestStatus TransferStatus1 = FAILED;
__IO uint32_t NumDataRead = 0;
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);
/* Initialize the EEPROM driver --------------------------------------------*/
if (BSP_EEPROM_Init() != EEPROM_OK)
{
BSP_LCD_SetTextColor(LCD_COLOR_RED);
BSP_LCD_DisplayStringAt(0, 115, (uint8_t*)"Initialization problem", CENTER_MODE);
BSP_LCD_DisplayStringAt(0, 130, (uint8_t*)"Check if HW connected or", CENTER_MODE);
BSP_LCD_DisplayStringAt(0, 145, (uint8_t*)"HW version not supported", CENTER_MODE);
return;
}
EepromDetected = 1;
switch (feature)
{
case 0:
/* Read old parameter in EEPROM */
if (EepromDetected == 1)
{
/* Set the Number of data to be read */
NumDataRead = (uint32_t)BUFFER_SIZE1;
/* Read from I2C EEPROM from EEPROM_READ_ADDRESS1 */
if (BSP_EEPROM_ReadBuffer(Rx1Buffer, EEPROM_READ_ADDRESS1, (uint32_t *)(&NumDataRead)) != EEPROM_OK)
{
BSP_LCD_SetTextColor(LCD_COLOR_RED);
BSP_LCD_DisplayStringAt(0, 115, (uint8_t*)"Init issue at read old data", CENTER_MODE);
BSP_LCD_SetTextColor(LCD_COLOR_BLACK);
BSP_LCD_DisplayStringAt(0, 145, (uint8_t*)"Press again KEY button", CENTER_MODE);
BSP_LCD_DisplayStringAt(0, 160, (uint8_t*)"To write new data", CENTER_MODE);
return;
}
BSP_LCD_DisplayStringAt(0, 115, (uint8_t*)"String read", CENTER_MODE);
BSP_LCD_DisplayStringAt(0, 130, (uint8_t*)"in the current EEPROM selected:", CENTER_MODE);
BSP_LCD_SetTextColor(LCD_COLOR_BLUE);
BSP_LCD_DisplayStringAt(0, 160, Rx1Buffer, CENTER_MODE);
BSP_LCD_SetTextColor(LCD_COLOR_BLACK);
BSP_LCD_DisplayStringAt(0, 190, (uint8_t*)"Press KEY button", CENTER_MODE);
BSP_LCD_DisplayStringAt(0, 205, (uint8_t*)"To write new data", CENTER_MODE);
}
else
{
BSP_LCD_SetTextColor(LCD_COLOR_RED);
BSP_LCD_DisplayStringAt(0, 115, (uint8_t*)"Problem to communicate", CENTER_MODE);
BSP_LCD_DisplayStringAt(0, 130, (uint8_t*)"with EEPROM", CENTER_MODE);
BSP_LCD_DisplayStringAt(0, 145, (uint8_t*)"Press again KEY button", CENTER_MODE);
}
break;
case 1:
/* Write new parameter in EEPROM */
if (EepromDetected == 1)
{
snprintf((char*)Tx2Buffer, BUFFER_SIZE1, "%s_%d Ex. test %d", Tx1Buffer, EepromTestNb, NbLoop);
/* First write in the memory followed by a read of the written data ----*/
/* Write on I2C EEPROM to EEPROM_WRITE_ADDRESS1 */
if (BSP_EEPROM_WriteBuffer(Tx2Buffer, EEPROM_WRITE_ADDRESS1, BUFFER_SIZE1) != EEPROM_OK)
{
BSP_LCD_SetTextColor(LCD_COLOR_RED);
BSP_LCD_DisplayStringAt(0, 115, (uint8_t*)"Init issue at write", CENTER_MODE);
return;
}
/* Set the Number of data to be read */
NumDataRead = (uint32_t)BUFFER_SIZE1;
/* Read from I2C EEPROM from EEPROM_READ_ADDRESS1 */
if (BSP_EEPROM_ReadBuffer(Rx1Buffer, EEPROM_READ_ADDRESS1, (uint32_t *)(&NumDataRead)) != EEPROM_OK)
{
BSP_LCD_SetTextColor(LCD_COLOR_RED);
BSP_LCD_DisplayStringAt(0, 115, (uint8_t*)"Init issue at read", CENTER_MODE);
return;
}
/* Check if the data written to the memory is read correctly */
TransferStatus1 = Buffercmp(Tx2Buffer, Rx1Buffer, BUFFER_SIZE1);
if(TransferStatus1 != FAILED)
{
BSP_LCD_DisplayStringAt(0, 115, (uint8_t*)"String writes", CENTER_MODE);
BSP_LCD_DisplayStringAt(0, 130, (uint8_t*)"in the current EEPROM selected:", CENTER_MODE);
BSP_LCD_SetTextColor(LCD_COLOR_BLUE);
BSP_LCD_DisplayStringAt(0, 160, Tx2Buffer, CENTER_MODE);
}
else
{
BSP_LCD_SetTextColor(LCD_COLOR_RED);
BSP_LCD_DisplayStringAt(0, 115, (uint8_t*)"FAILED to write!", CENTER_MODE);
BSP_LCD_DisplayStringAt(0, 130, (uint8_t*)"Press KEY button to end test", CENTER_MODE);
}
}
else
{
BSP_LCD_SetTextColor(LCD_COLOR_RED);
BSP_LCD_DisplayStringAt(0, 115, (uint8_t*)"Problem to communicate", CENTER_MODE);
BSP_LCD_DisplayStringAt(0, 130, (uint8_t*)"again with EEPROM", CENTER_MODE);
BSP_LCD_DisplayStringAt(0, 145, (uint8_t*)"Press KEY button to end test", CENTER_MODE);
}
break;
}
}
/**
* @brief Main program
* @param None
* @retval None
*/
int main(void)
{
uint8_t lcd_status = LCD_OK;
uint8_t sdram_status = SDRAM_OK;
/* This sample code displays a fixed image 800x480 on LCD KoD in */
/* orientation mode landscape and DSI mode video burst */
/* STM32F4xx HAL library initialization:
- Configure the Flash prefetch, instruction and Data caches
- 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: global MSP (MCU Support Package) initialization
*/
HAL_Init();
/* Configure the system clock to 180 MHz */
SystemClock_Config();
/* Initialize MFX */
BSP_IO_Init();
/* Initialize used Leds */
BSP_LED_Init(LED1);
BSP_LED_Init(LED3);
/* Configure Tamper push-button */
BSP_PB_Init(BUTTON_TAMPER, BUTTON_MODE_GPIO);
/* Initialize the SDRAM */
sdram_status = BSP_SDRAM_Init();
OnError_Handler(sdram_status != SDRAM_OK);
/*##-1- Initialize the LCD depending on 'lcd_mode' #################################################*/
/* Get DSI configuration for mode Video Burst */
lcd_status = BSP_LCD_Init();
OnError_Handler(lcd_status != LCD_OK);
HAL_LTDC_ProgramLineEvent(&hltdc_eval, 0);
/* Copy texture to be displayed on LCD from Flash to SDRAM */
CopyPicture((uint32_t *)&candies_800x480_argb8888, (uint32_t *)LCD_FB_START_ADDRESS, 0, 0, BSP_LCD_GetXSize(), BSP_LCD_GetYSize());
BSP_LCD_LayerDefaultInit(LTDC_ACTIVE_LAYER_BACKGROUND, LCD_FB_START_ADDRESS);
BSP_LCD_SelectLayer(LTDC_ACTIVE_LAYER_BACKGROUND);
/* Prepare area to display frame number in the image displayed on LCD */
BSP_LCD_SetTextColor(LCD_COLOR_BLUE);
BSP_LCD_FillRect(0, 400, BSP_LCD_GetXSize(), 80);
BSP_LCD_SetTextColor(LCD_COLOR_WHITE);
BSP_LCD_SetBackColor(LCD_COLOR_BLUE);
BSP_LCD_SetFont(&Font16);
/* Display title */
BSP_LCD_DisplayStringAt(0, 420, (uint8_t *) "LCD_DSI_ULPM_Data example", CENTER_MODE);
BSP_LCD_DisplayStringAt(0, 440, (uint8_t *) "Press TAMPER button to enter ULPM", CENTER_MODE);
BSP_LCD_SetTextColor(LCD_COLOR_WHITE);
BSP_LCD_SetBackColor(LCD_COLOR_BLUE);
BSP_LCD_SetFont(&Font16);
/* Infinite loop */
while (1)
{
/* Clear previous line */
BSP_LCD_ClearStringLine(460);
/* New text to display */
sprintf(str_display, ">> Frame Nb : %lu", frameCnt);
/* Print updated frame number */
BSP_LCD_DisplayStringAt(0, 460, (uint8_t *)str_display, CENTER_MODE);
if (CheckForUserInput() > 0)
{
/* Clear previous line */
BSP_LCD_SetTextColor(LCD_COLOR_GREEN);
BSP_LCD_ClearStringLine(440);
BSP_LCD_DisplayStringAt(0, 440, (uint8_t *) "Enter ULPM - switch Off LCD 6 seconds", CENTER_MODE);
BSP_LCD_SetTextColor(LCD_COLOR_WHITE);
/* Display Off with ULPM management Data lane only integrated */
BSP_LCD_DisplayOff();
HAL_Delay(1000);
/* Switch Off bit LTDCEN */
__HAL_LTDC_DISABLE(&hltdc_eval);
/* Enter ultra low power mode (data lane only integrated) */
HAL_DSI_EnterULPMData(&hdsi_eval);
HAL_Delay(6000);
BSP_LCD_ClearStringLine(440);
BSP_LCD_DisplayStringAt(0, 440, (uint8_t *) " Exited ULPM with success - Press To enter Again ULPM. ", CENTER_MODE);
/* Exit ultra low power mode (data lane only integrated) */
HAL_DSI_ExitULPMData(&hdsi_eval);
/* Switch On bit LTDCEN */
__HAL_LTDC_ENABLE(&hltdc_eval);
/* Display On with ULPM exit Data lane only integrated */
BSP_LCD_DisplayOn();
}
}
}
/**
* @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[]= {{100, 150}, {160, 150}, {160, 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_FillPolygon(Points2, 3);
BSP_LCD_SetTextColor(LCD_COLOR_RED);
BSP_LCD_DrawEllipse(BSP_LCD_GetXSize() - 120, 170, 30, 20);
BSP_LCD_FillEllipse(BSP_LCD_GetXSize() - 50, 170, 30, 20);
BSP_LCD_SetTextColor(LCD_COLOR_BLACK);
BSP_LCD_DrawHLine(20, BSP_LCD_GetYSize() - 30, BSP_LCD_GetXSize() / 5);
BSP_LCD_DrawLine (BSP_LCD_GetXSize() - 150, BSP_LCD_GetYSize()- 20, BSP_LCD_GetXSize()- 20, BSP_LCD_GetYSize()- 50);
BSP_LCD_DrawLine (BSP_LCD_GetXSize() - 150, BSP_LCD_GetYSize()- 50, BSP_LCD_GetXSize()- 20, BSP_LCD_GetYSize()- 20);
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 Audio Play demo
* @param None
* @retval None
*/
void AudioPlay_demo (void)
{
uint8_t ts_status = TS_OK;
uint32_t *AudioFreq_ptr;
AudioFreq_ptr = AudioFreq+6; /*AF_48K*/
uint8_t FreqStr[256] = {0};
Point Points2[] = {{100, 140}, {160, 180}, {100, 220}};
uwPauseEnabledStatus = 1; /* 0 when audio is running, 1 when Pause is on */
uwVolume = AUDIO_DEFAULT_VOLUME;
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);
}
else
{
BSP_LCD_DisplayStringAt(0, BSP_LCD_GetYSize() - 65, (uint8_t *)"ERROR : touchscreen not yet calibrated.", CENTER_MODE);
ts_status = TS_ERROR;
}
} /* of if (TouchScreen_IsCalibrationDone() == 0) */
AudioPlay_SetHint();
BSP_LCD_SetFont(&Font20);
/* if(BSP_AUDIO_OUT_Init(OUTPUT_DEVICE_SPEAKER, uwVolume, *AudioFreq_ptr) == 0)
if(BSP_AUDIO_OUT_Init(OUTPUT_DEVICE_BOTH, uwVolume, *AudioFreq_ptr) == 0)*/
if(BSP_AUDIO_OUT_Init(OUTPUT_DEVICE_BOTH, uwVolume, *AudioFreq_ptr) == 0)
{
BSP_LCD_SetBackColor(LCD_COLOR_WHITE);
BSP_LCD_SetTextColor(LCD_COLOR_GREEN);
BSP_LCD_DisplayStringAt(0, LINE(6), (uint8_t *)" AUDIO CODEC OK ", CENTER_MODE);
}
else
{
BSP_LCD_SetBackColor(LCD_COLOR_WHITE);
BSP_LCD_SetTextColor(LCD_COLOR_RED);
BSP_LCD_DisplayStringAt(0, LINE(6), (uint8_t *)" AUDIO CODEC FAIL ", CENTER_MODE);
BSP_LCD_DisplayStringAt(0, LINE(7), (uint8_t *)" Try to reset board ", CENTER_MODE);
}
/*
Start playing the file from a circular buffer, once the DMA is enabled, it is
always in running state. Application has to fill the buffer with the audio data
using Transfer complete and/or half transfer complete interrupts callbacks
(DISCOVERY_AUDIO_TransferComplete_CallBack() or DISCOVERY_AUDIO_HalfTransfer_CallBack()...
*/
AUDIO_Play_Start((uint32_t *)AUDIO_SRC_FILE_ADDRESS, (uint32_t)AUDIO_FILE_SIZE);
/* Display the state on the screen */
BSP_LCD_SetBackColor(LCD_COLOR_WHITE);
BSP_LCD_SetTextColor(LCD_COLOR_BLUE);
BSP_LCD_DisplayStringAt(0, LINE(8), (uint8_t *)" PLAYING... ", CENTER_MODE);
sprintf((char*)FreqStr, " VOL: %3lu ", uwVolume);
BSP_LCD_DisplayStringAt(0, LINE(9), (uint8_t *)FreqStr, CENTER_MODE);
sprintf((char*)FreqStr, " FREQ: %6lu ", *AudioFreq_ptr);
BSP_LCD_DisplayStringAt(0, LINE(10), (uint8_t *)FreqStr, CENTER_MODE);
BSP_LCD_SetFont(&Font16);
BSP_LCD_DisplayStringAt(0, BSP_LCD_GetYSize() - 40, (uint8_t *)"Hear nothing ? Have you copied the audio file with STM-LINK UTILITY ?", CENTER_MODE);
if(ts_status == TS_OK)
{
/* Set touchscreen in Interrupt mode and program EXTI accordingly on falling edge of TS_INT pin */
ts_status = BSP_TS_ITConfig();
BSP_TEST_APPLI_ASSERT(ts_status != TS_OK);
Touchscreen_DrawBackground_Circle_Buttons(16);
}
BSP_LCD_SetFont(&Font20);
/* draw play triangle */
BSP_LCD_SetTextColor(LCD_COLOR_GREEN);
BSP_LCD_FillPolygon(Points2, 3);
/* IMPORTANT:
AUDIO_Play_Process() is called by the SysTick Handler, as it should be called
within a periodic process */
/* Infinite loop */
while (1)
{
BSP_LCD_SetBackColor(LCD_COLOR_WHITE);
BSP_LCD_SetTextColor(LCD_COLOR_BLUE);
/* Get the TouchScreen State */
ts_action = (TS_ActionTypeDef) TouchScreen_GetTouchPosition();
switch (ts_action)
{
case TS_ACT_VOLUME_UP:
/* Increase volume by 5% */
if (uwVolume < 95)
uwVolume += 5;
else
uwVolume = 100;
sprintf((char*)FreqStr, " VOL: %3lu ", uwVolume);
BSP_AUDIO_OUT_SetVolume(uwVolume);
BSP_LCD_DisplayStringAt(0, LINE(9), (uint8_t *)FreqStr, CENTER_MODE);
break;
case TS_ACT_VOLUME_DOWN:
/* Decrease volume by 5% */
if (uwVolume > 5)
uwVolume -= 5;
else
uwVolume = 0;
sprintf((char*)FreqStr, " VOL: %3lu ", uwVolume);
BSP_AUDIO_OUT_SetVolume(uwVolume);
BSP_LCD_DisplayStringAt(0, LINE(9), (uint8_t *)FreqStr, CENTER_MODE);
break;
case TS_ACT_FREQ_DOWN:
/*Decrease Frequency */
if (*AudioFreq_ptr != 8000)
{
AudioFreq_ptr--;
sprintf((char*)FreqStr, " FREQ: %6lu ", *AudioFreq_ptr);
BSP_AUDIO_OUT_Pause();
BSP_AUDIO_OUT_SetFrequency(*AudioFreq_ptr);
BSP_AUDIO_OUT_Resume();
BSP_AUDIO_OUT_SetVolume(uwVolume);
}
BSP_LCD_DisplayStringAt(0, LINE(10), (uint8_t *)FreqStr, CENTER_MODE);
break;
case TS_ACT_FREQ_UP:
/* Increase Frequency */
if (*AudioFreq_ptr != 96000)
{
AudioFreq_ptr++;
sprintf((char*)FreqStr, " FREQ: %6lu ", *AudioFreq_ptr);
BSP_AUDIO_OUT_Pause();
BSP_AUDIO_OUT_SetFrequency(*AudioFreq_ptr);
BSP_AUDIO_OUT_Resume();
BSP_AUDIO_OUT_SetVolume(uwVolume);
}
BSP_LCD_DisplayStringAt(0, LINE(10), (uint8_t *)FreqStr, CENTER_MODE);
break;
case TS_ACT_PAUSE:
/* Set Pause / Resume */
if (uwPauseEnabledStatus == 1)
{ /* Pause is enabled, call Resume */
BSP_AUDIO_OUT_Resume();
uwPauseEnabledStatus = 0;
BSP_LCD_DisplayStringAt(0, LINE(8), (uint8_t *)" PLAYING... ", CENTER_MODE);
BSP_LCD_SetTextColor(LCD_COLOR_WHITE);
BSP_LCD_FillPolygon(Points2, 3);
BSP_LCD_SetTextColor(LCD_COLOR_BLACK);
BSP_LCD_FillRect(100, 140, 25 , 80);
BSP_LCD_FillRect(140, 140, 25 , 80);
}
else
{ /* Pause the playback */
BSP_AUDIO_OUT_Pause();
uwPauseEnabledStatus = 1;
BSP_LCD_DisplayStringAt(0, LINE(8), (uint8_t *)" PAUSE ... ", CENTER_MODE);
BSP_LCD_SetTextColor(LCD_COLOR_WHITE);
BSP_LCD_FillRect(100, 140, 80 , 80);
BSP_LCD_SetTextColor(LCD_COLOR_GREEN);
BSP_LCD_FillPolygon(Points2, 3);
}
HAL_Delay(200);
break;
default:
break;
}
/* Toggle LED4 */
BSP_LED_Toggle(LED4);
/* Insert 100 ms delay */
HAL_Delay(100);
if (CheckForUserInput() > 0)
{
/* Set LED4 */
BSP_LED_On(LED4);
BSP_AUDIO_OUT_Stop(CODEC_PDWN_SW);
return;
}
}
}
/**
* @brief Show LCD Features
* @param feature_index : feature index
* @retval None
*/
static void LCD_Show_Feature(uint8_t feature_index)
{
uint8_t lcd_status = LCD_OK;
if(feature_index < LCD_FEAT_NB_MAX)
{
LCD_SetHint(feature_index);
BSP_LCD_SetBackColor(LCD_COLOR_WHITE);
BSP_LCD_SetTextColor(LCD_COLOR_WHITE);
/* Clear in white the internal part of rectangle */
BSP_LCD_FillRect(12, 92, BSP_LCD_GetXSize() - 24, BSP_LCD_GetYSize() - 104);
BSP_LCD_SetTextColor(LCD_COLOR_BLACK);
switch(feature_index)
{
case LCD_FEAT_TEXT :
/* Keep default LCD/DSI and LTDC Mode for this demo item */
LCD_Show_FeatureText();
break;
case LCD_FEAT_SIMPLE_SHAPES :
/* Keep default LCD/DSI and LTDC Mode for this demo item */
LCD_Show_FeatureSimpleShapes();
break;
case LCD_FEAT_BASIC_BITMAP :
/* Keep default LCD/DSI and LTDC Mode for this demo item */
LCD_Show_FeatureBasicBitmap();
break;
case LCD_FEAT_ULPM_DATA_ONLY :
BSP_LCD_SetFont(&Font16);
BSP_LCD_DisplayStringAt(0, BSP_LCD_GetYSize() / 2, (uint8_t *)"Only testable in mode Video Burst", CENTER_MODE);
break;
case LCD_FEAT_ULPM_DATA_AND_CLOCK :
BSP_LCD_SetFont(&Font16);
BSP_LCD_DisplayStringAt(0, BSP_LCD_GetYSize() / 2, (uint8_t *)"Only testable in mode Video Burst", CENTER_MODE);
break;
default :
break;
} /* of switch(feature_index) */
} /* of if(feature_index < LCD_FEAT_NB_MAX) */
else if(feature_index == LCD_FEAT_NB_MAX)
{
/* Just after last index, restore the normal BSP LCD mode for following tests of the BSP display results */
/* Proceed to LTDC and DSI initialization with the configuration filled in above */
lcd_status = BSP_LCD_Init();
while(lcd_status != LCD_OK);
/* Clear the LCD */
BSP_LCD_Clear(LCD_COLOR_WHITE);
/* Print text to Describe the current LCD DSI configuration */
/* Print text to Describe the current LCD DSI configuration */
BSP_LCD_SetTextColor(LCD_COLOR_BLACK);
BSP_LCD_SetBackColor(LCD_COLOR_WHITE);
BSP_LCD_SetFont(&Font16);
BSP_LCD_DisplayStringAt(0, BSP_LCD_GetYSize() / 2 - 20, (uint8_t *)"Successfully restored", CENTER_MODE);
BSP_LCD_DisplayStringAt(0, BSP_LCD_GetYSize() / 2 - 0, (uint8_t *)"Default LCD Mode.", CENTER_MODE);
BSP_LCD_DisplayStringAt(0, BSP_LCD_GetYSize() / 2 + 20, (uint8_t *)"Press on TAMPER button to switch to next demo", CENTER_MODE);
} /* of else if(feature_index == LCD_FEAT_NB_MAX) */
}
void LCD_DISCO_F469NI::FillRect(uint16_t Xpos, uint16_t Ypos, uint16_t Width, uint16_t Height)
{
BSP_LCD_FillRect(Xpos, Ypos, Width, Height);
}
/**
* @brief Manages Audio process.
* @param None
* @retval Audio error
*/
AUDIO_ErrorTypeDef AUDIO_PLAYER_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.state == BUFFER_OFFSET_HALF)
{
if(f_read(&WavFile,
&BufferCtl.buff[0],
AUDIO_OUT_BUFFER_SIZE/2,
(void *)&bytesread) != FR_OK)
{
BSP_AUDIO_OUT_Stop(CODEC_PDWN_SW);
return AUDIO_ERROR_IO;
}
BufferCtl.state = BUFFER_OFFSET_NONE;
BufferCtl.fptr += bytesread;
}
if(BufferCtl.state == BUFFER_OFFSET_FULL)
{
if(f_read(&WavFile,
&BufferCtl.buff[AUDIO_OUT_BUFFER_SIZE /2],
AUDIO_OUT_BUFFER_SIZE/2,
(void *)&bytesread) != FR_OK)
{
BSP_AUDIO_OUT_Stop(CODEC_PDWN_SW);
return AUDIO_ERROR_IO;
}
BufferCtl.state = 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);
}
/* Update audio state machine according to touch acquisition */
AUDIO_AcquireTouchButtons();
break;
case AUDIO_STATE_STOP:
BSP_LCD_SetTextColor(LCD_COLOR_RED);
BSP_LCD_FillRect(TOUCH_STOP_XMIN, TOUCH_STOP_YMIN , /* Stop rectangle */
TOUCH_STOP_XMAX - TOUCH_STOP_XMIN,
TOUCH_STOP_YMAX - TOUCH_STOP_YMIN);
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_PLAYER_Start(FilePos);
break;
case AUDIO_STATE_PREVIOUS:
if(--FilePos < 0)
{
FilePos = AUDIO_GetWavObjectNumber() - 1;
}
BSP_AUDIO_OUT_Stop(CODEC_PDWN_SW);
AUDIO_PLAYER_Start(FilePos);
break;
case AUDIO_STATE_PAUSE:
BSP_LCD_SetTextColor(LCD_COLOR_CYAN);
BSP_LCD_DisplayStringAt(250, LINE(9), (uint8_t *)" [PAUSE]", LEFT_MODE);
BSP_LCD_SetTextColor(LCD_COLOR_RED); /* Display red pause rectangles */
BSP_LCD_FillRect(TOUCH_PAUSE_XMIN, TOUCH_PAUSE_YMIN , 15, TOUCH_PAUSE_YMAX - TOUCH_PAUSE_YMIN);
BSP_LCD_FillRect(TOUCH_PAUSE_XMIN + 20, TOUCH_PAUSE_YMIN, 15, TOUCH_PAUSE_YMAX - TOUCH_PAUSE_YMIN);
BSP_AUDIO_OUT_Pause();
AudioState = AUDIO_STATE_WAIT;
break;
case AUDIO_STATE_RESUME:
BSP_LCD_SetTextColor(LCD_COLOR_CYAN);
BSP_LCD_DisplayStringAt(250, LINE(9), (uint8_t *)" [PLAY ]", LEFT_MODE);
/* Display blue cyan pause rectangles */
BSP_LCD_FillRect(TOUCH_PAUSE_XMIN, TOUCH_PAUSE_YMIN , 15, TOUCH_PAUSE_YMAX - TOUCH_PAUSE_YMIN);
BSP_LCD_FillRect(TOUCH_PAUSE_XMIN + 20, TOUCH_PAUSE_YMIN, 15, TOUCH_PAUSE_YMAX - TOUCH_PAUSE_YMIN);
BSP_AUDIO_OUT_Resume();
AudioState = AUDIO_STATE_PLAY;
break;
case AUDIO_STATE_VOLUME_UP:
if( uwVolume <= 90)
{
uwVolume += 10;
}
BSP_AUDIO_OUT_SetVolume(uwVolume);
BSP_LCD_SetTextColor(LCD_COLOR_WHITE);
sprintf((char *)str, "Volume : %lu ", uwVolume);
BSP_LCD_DisplayStringAtLine(9, str);
AudioState = AUDIO_STATE_PLAY;
break;
case AUDIO_STATE_VOLUME_DOWN:
if( uwVolume >= 10)
{
uwVolume -= 10;
}
BSP_AUDIO_OUT_SetVolume(uwVolume);
BSP_LCD_SetTextColor(LCD_COLOR_WHITE);
sprintf((char *)str, "Volume : %lu ", uwVolume);
BSP_LCD_DisplayStringAtLine(9, str);
AudioState = AUDIO_STATE_PLAY;
break;
case AUDIO_STATE_WAIT:
case AUDIO_STATE_IDLE:
case AUDIO_STATE_INIT:
default:
/* Update audio state machine according to touch acquisition */
AUDIO_AcquireTouchButtons();
break;
}
return audio_error;
}
/**
* @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 Save the picture in USB Disk.
* @param None
* @retval None
*/
void Save_Picture(void)
{
FRESULT res1, res2; /* FatFs function common result code */
uint32_t byteswritten; /* File write count */
static uint32_t color;
/* Get the current text color */
color = BSP_LCD_GetTextColor();
BSP_LCD_SetTextColor(LCD_COLOR_DARKRED);
BSP_LCD_SetFont(&Font20);
/* Turn LED1 and LED3 Off */
BSP_LED_Off(LED1);
BSP_LED_Off(LED3);
if (Appli_state == APPLICATION_RUNNIG)
{
BSP_LCD_DisplayStringAt(0, (BSP_LCD_GetYSize()-35), (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 */
if (BSP_LCD_GetXSize() == 640)
{
/* if ampire 640x480 LCD is used */
res1 = f_write(&MyFile, (uint32_t *)aBMPHeader1, 54, (void *)&byteswritten);
}
else
{
/* if ampire 480x272 LCD is used */
res1 = f_write(&MyFile, (uint32_t *)aBMPHeader2, 54, (void *)&byteswritten);
}
/* Write the bmp file */
res2 = f_write(&MyFile, (uint32_t *)CONVERTED_FRAME_BUFFER, ((BSP_LCD_GetYSize()-60)*(BSP_LCD_GetXSize()-60)*3), (void *)&byteswritten);
if((res1 != FR_OK) || (res2 != FR_OK) || (byteswritten == 0))
{
/* 'image' file Write or EOF Error */
BSP_LED_On(LED3);
BSP_LCD_DisplayStringAt(0, (BSP_LCD_GetYSize()-35), (uint8_t *)" Aborted...", RIGHT_MODE);
/* Wait for 2s */
HAL_Delay(2000);
}
else
{
/*##-4- Close the open text file #####################################*/
f_close(&MyFile);
/* Success of the demo: no error occurrence */
BSP_LED_On(LED1);
BSP_LCD_SetTextColor(LCD_COLOR_DARKGREEN);
BSP_LCD_DisplayStringAt(0, (BSP_LCD_GetYSize()-35), (uint8_t *)" Saved ", RIGHT_MODE);
/* Wait for 2s */
HAL_Delay(2000);
}
}
}
else
{
/* USB not connected */
BSP_LCD_DisplayStringAt(0, (BSP_LCD_GetYSize()-35), (uint8_t *)"USB KO... ", RIGHT_MODE);
/* Wait for 2s */
HAL_Delay(2000);
}
BSP_LCD_SetTextColor(LCD_COLOR_WHITE);
BSP_LCD_FillRect(480, 430, 160, 50);
BSP_LCD_SetTextColor(color);
}
/**
* @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 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 Function in charge to hanlde the menu selection
* @param menu
* @param sel : slected item
* @retval None
*/
void kMenu_HandleSelection(tMenu MainMenu, uint8_t *sel)
{
uint8_t exit = 0;
JOYState_TypeDef joyState = JOY_NONE;
tMenu psCurrentMenu = MainMenu;
uint8_t index;
switch(psCurrentMenu.nType)
{
case TYPE_ICON :
{
/* display the default selection */
BSP_LCD_SetBackColor(LCD_COLOR_WHITE);
BSP_LCD_SetTextColor(LCD_COLOR_BLUE);
BSP_LCD_DrawRect(psCurrentMenu.psItems[*sel].x, psCurrentMenu.psItems[*sel].y, 64, 64);
do{
/* Poolling on joystick event */
joyState = BSP_JOY_GetState();
if(joyState != JOY_NONE)
{
/* Remove previous selection */
BSP_LCD_SetBackColor(LCD_COLOR_WHITE);
BSP_LCD_SetTextColor(LCD_COLOR_WHITE);
BSP_LCD_DrawRect(psCurrentMenu.psItems[*sel].x, psCurrentMenu.psItems[*sel].y, 64, 64);
/* Wait to have good MMI behavior */
HAL_Delay(400);
switch(joyState)
{
case JOY_SEL :
exit = 1;
break;
case JOY_DOWN :
/* check if sel is on the latest line position */
if(*sel >= ((psCurrentMenu.line - 1)*psCurrentMenu.column))
{
*sel = ((*sel) % psCurrentMenu.column);
}
else
{
(*sel)+= psCurrentMenu.column;
}
break;
case JOY_LEFT :
if(*sel == 0 ) {
*sel = psCurrentMenu.nItems -1;
}
else { (*sel)--; }
break;
case JOY_RIGHT :
(*sel)++;
if ((*sel) >= (psCurrentMenu.nItems)) { (*sel) = 0; }
break;
case JOY_UP :
/** check if sel is on the first line */
if ((*sel) < psCurrentMenu.column) {
(*sel)+= ((psCurrentMenu.line - 1)*psCurrentMenu.column);
} else {
(*sel)-= psCurrentMenu.column; }
break;
default:
break;
}
/* display the new selection */
BSP_LCD_SetTextColor(LCD_COLOR_BLUE);
BSP_LCD_DrawRect(psCurrentMenu.psItems[*sel].x, psCurrentMenu.psItems[*sel].y, 64, 64);
/* display the new header file */
BSP_LCD_SetTextColor(LCD_COLOR_BLUE);
BSP_LCD_SetBackColor(LCD_COLOR_BLUE);
BSP_LCD_FillRect(0, 0, BSP_LCD_GetXSize(), Font24.Height);
BSP_LCD_SetTextColor(LCD_COLOR_WHITE);
BSP_LCD_DisplayStringAt(0, 0, (uint8_t *)psCurrentMenu.psItems[*sel].pszTitle, CENTER_MODE);
}
} while(exit == 0);
}
break;
case TYPE_TEXT :
{
do
{
index = 0;
while (!(index >= psCurrentMenu.nItems))
{
if (index == (*sel))
{
/* Set the Back Color */
BSP_LCD_SetBackColor(LCD_COLOR_GREEN);
/* Set the Text Color */
BSP_LCD_SetTextColor(LCD_COLOR_WHITE);
}
else
{
/* Set the Back Color */
BSP_LCD_SetBackColor(LCD_COLOR_WHITE);
/* Set the Text Color */
BSP_LCD_SetTextColor(LCD_COLOR_BLUE);
}
/* Get the current menu */
BSP_LCD_DisplayStringAt(0, Font24.Height*(index+1), (uint8_t *)psCurrentMenu.psItems[index].pszTitle,LEFT_MODE);
index++;
}
/* Wait to have good MMI behavior */
HAL_Delay(400);
while((joyState = BSP_JOY_GetState()) == JOY_NONE);
switch(joyState)
{
case JOY_SEL :
exit = 1;
break;
case JOY_DOWN :
(*sel)++;
/* check if sel is on the latest line position */
if(*sel >= psCurrentMenu.nItems)
{
*sel = psCurrentMenu.nItems - 1;
}
break;
case JOY_UP :
/** check if sel is on the first line */
if ((*sel) != 0) { (*sel)--; }
break;
default:
break;
}
} while(exit == 0);
}
break;
}
return;
}
/**
* @brief Function in charge to execture a menu
* @param menu
* @retval None
*/
void kMenu_Execute(tMenu psCurrentMenu)
{
uint32_t index = 0, exit = 1;
uint32_t k_MenuState = KMENU_HEADER;
uint8_t sel = 0;
do
{
switch(k_MenuState)
{
case KMENU_HEADER :
{
/****************************** Display Header *************************/
/* Clear the LCD Screen */
BSP_LCD_Clear(LCD_COLOR_WHITE);
if(psCurrentMenu.pszTitle != NULL)
{
/* Set the Back Color */
BSP_LCD_SetFont(&Font24);
BSP_LCD_SetBackColor(LCD_COLOR_BLUE);
BSP_LCD_SetTextColor(LCD_COLOR_BLUE);
BSP_LCD_FillRect(0, 0, BSP_LCD_GetXSize(), Font24.Height);
/* Set the Text Color */
BSP_LCD_SetTextColor(LCD_COLOR_WHITE);
BSP_LCD_DisplayStringAt(0, 0, (uint8_t *)psCurrentMenu.pszTitle, CENTER_MODE);
}
switch(psCurrentMenu.nType)
{
case TYPE_ICON :
k_MenuState = KMENU_ICON;
break;
case TYPE_TEXT :
k_MenuState = KMENU_TEXT;
break;
case TYPE_EXEC :
k_MenuState = KMENU_EXEC;
break;
default :
k_MenuState = KMENU_EXIT;
break;
}
}
break;
case KMENU_ICON :
{
BSP_LCD_SetTextColor(LCD_COLOR_BLUE);
BSP_LCD_FillRect(0, 0, BSP_LCD_GetXSize(), Font24.Height);
BSP_LCD_SetTextColor(LCD_COLOR_WHITE);
BSP_LCD_DisplayStringAt(0, 0, (uint8_t *)psCurrentMenu.psItems[0].pszTitle, CENTER_MODE);
for(index = 0; index < psCurrentMenu.nItems; index++)
{
if(psCurrentMenu.psItems[index].pIconPath != NULL)
{
kStorage_OpenFileDrawBMP(psCurrentMenu.psItems[index].x, psCurrentMenu.psItems[index].y, (uint8_t *)psCurrentMenu.psItems[index].pIconPath);
}
}
k_MenuState = KMENU_WAITEVENT;
}
break;
case KMENU_TEXT :
{
/* Set the Back Color */
BSP_LCD_SetBackColor(LCD_COLOR_WHITE);
/* Set the Text Color */
BSP_LCD_SetTextColor(LCD_COLOR_BLUE);
k_MenuState = KMENU_WAITEVENT;
}
break;
case KMENU_EXEC :
{
while(BSP_JOY_GetState() != JOY_NONE);
/* if the function need user feedback enable JOY interrupt and set callback function */
if(psCurrentMenu.psItems[0].pfActionFunc != NULL)
{
/* start the Joystick interrupt */
BSP_JOY_Init(JOY_MODE_EXTI);
HAL_Delay(300);
/* set the function to report joystick event */
kMenuEventForward = psCurrentMenu.psItems[0].pfActionFunc;
}
kMenu_Header(psCurrentMenu.psItems[0].pszTitle);
/* Execute the test */
psCurrentMenu.psItems[0].pfExecFunc();
/* rest user feedback, in polling mode */
if(psCurrentMenu.psItems[0].pfActionFunc != NULL)
{
/* stop the Joystick interrupt */
BSP_JOY_Init(JOY_MODE_GPIO);
HAL_Delay(300);
/* set the function to report to NULL */
kMenuEventForward = NULL;
}
k_MenuState = KMENU_EXIT;
}
break;
case KMENU_WAITEVENT:
{
kMenu_HandleSelection(psCurrentMenu,&sel);
/* The user has selected an execution menu */
switch(psCurrentMenu.psItems[sel].SelType)
{
case SEL_MODULE:
/* start the module execution */
kModule_Execute(psCurrentMenu.psItems[sel].ModuleId);
k_MenuState = KMENU_HEADER;
break;
case SEL_EXEC :
while(BSP_JOY_GetState() != JOY_NONE);
/* if the function need user feedback enable JOY interrupt and set callback function */
if(psCurrentMenu.psItems[sel].pfActionFunc != NULL)
{
/* start the Joystick interrupt */
BSP_JOY_Init(JOY_MODE_EXTI);
HAL_Delay(300);
/* set the function to report joystick event */
kMenuEventForward = psCurrentMenu.psItems[sel].pfActionFunc;
}
/* start the function execution */
psCurrentMenu.psItems[sel].pfExecFunc();
/* rest user feedback, in polling mode */
if(psCurrentMenu.psItems[sel].pfActionFunc != NULL)
{
/* stop the Joystick interrupt */
BSP_JOY_Init(JOY_MODE_GPIO);
HAL_Delay(300);
/* set the function to report to NULL */
kMenuEventForward = NULL;
}
k_MenuState = KMENU_HEADER;
break;
case SEL_SUBMENU :
/* Select submenu or return on the main module menu */
kMenu_Execute(*(psCurrentMenu.psItems[sel].psSubMenu));
k_MenuState = KMENU_HEADER;
break;
case SEL_EXIT :
k_MenuState = KMENU_EXIT;
break;
}
}
break;
case KMENU_EXIT :
exit = 0;
break;
}
}while(exit);
}
/**
* @brief Show EEPROM Features
* @param feature: feature index
* @retval None
*/
static void EEPROM_Show_Feature(uint8_t feature)
{
uint8_t Tx1Buffer[] = "STM322xG-EVAL EEPROM Ex.";
uint8_t Rx1Buffer[BUFFER_SIZE1] = {0};
uint8_t Tx2Buffer[BUFFER_SIZE1] = {0};
__IO TestStatus TransferStatus1 = FAILED;
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);
/* Initialize the I2C EEPROM driver ----------------------------------------*/
if(BSP_EEPROM_Init() != EEPROM_OK)
{
BSP_LCD_SetTextColor(LCD_COLOR_RED);
BSP_LCD_DisplayStringAt(0, 115, (uint8_t *)"Initialization Issue", CENTER_MODE);
BSP_LCD_DisplayStringAt(0, 130, (uint8_t *)"Check if HW connected or", CENTER_MODE);
BSP_LCD_DisplayStringAt(0, 145, (uint8_t *)"HW version not supported", CENTER_MODE);
return;
}
switch (feature)
{
case 0:
/* Read old parameter in EEPROM */
/* Set the Number of data to be read */
NumDataRead = BUFFER_SIZE1;
/* Read from I2C EEPROM from EEPROM_READ_ADDRESS1 */
if(BSP_EEPROM_ReadBuffer(Rx1Buffer, EEPROM_READ_ADDRESS1, (uint16_t *)(&NumDataRead)) != EEPROM_OK)
{
BSP_LCD_SetTextColor(LCD_COLOR_RED);
BSP_LCD_DisplayStringAt(0, 115, (uint8_t *)"Init issue at read old data", CENTER_MODE);
BSP_LCD_SetTextColor(LCD_COLOR_BLACK);
BSP_LCD_DisplayStringAt(0, 145, (uint8_t *)"Press again USER key", CENTER_MODE);
BSP_LCD_DisplayStringAt(0, 160, (uint8_t *)"To write new data", CENTER_MODE);
return;
}
BSP_LCD_DisplayStringAt(0, 115, (uint8_t *)"PASSED String read", CENTER_MODE);
BSP_LCD_DisplayStringAt(0, 130, (uint8_t *)"in EEPROM:", CENTER_MODE);
BSP_LCD_SetTextColor(LCD_COLOR_BLUE);
BSP_LCD_DisplayStringAt(0, 160, Rx1Buffer, CENTER_MODE);
BSP_LCD_SetTextColor(LCD_COLOR_BLACK);
BSP_LCD_DisplayStringAt(0, 190, (uint8_t *)"Press USER key", CENTER_MODE);
BSP_LCD_DisplayStringAt(0, 205, (uint8_t *)"To write new data", CENTER_MODE);
break;
case 1:
/* Write new parameter in EEPROM */
snprintf((char*)Tx2Buffer, BUFFER_SIZE1, "%s Test %d", Tx1Buffer, NbLoop);
/* First write in the memory followed by a read of the written data ------*/
/* Write on I2C EEPROM to EEPROM_WRITE_ADDRESS1 */
if(BSP_EEPROM_WriteBuffer(Tx2Buffer, EEPROM_WRITE_ADDRESS1, BUFFER_SIZE1) != EEPROM_OK)
{
BSP_LCD_SetTextColor(LCD_COLOR_RED);
BSP_LCD_DisplayStringAt(0, 115, (uint8_t *)"Init issue at write", CENTER_MODE);
return;
}
/* Set the Number of data to be read */
NumDataRead = BUFFER_SIZE1;
/* Read from I2C EEPROM from EEPROM_READ_ADDRESS1 */
if(BSP_EEPROM_ReadBuffer(Rx1Buffer, EEPROM_READ_ADDRESS1, (uint16_t *)(&NumDataRead)) != EEPROM_OK)
{
BSP_LCD_SetTextColor(LCD_COLOR_RED);
BSP_LCD_DisplayStringAt(0, 115, (uint8_t *)"Init issue at read", CENTER_MODE);
return;
}
/* Check if the data written to the memory is read correctly */
TransferStatus1 = Buffercmp(Tx2Buffer, Rx1Buffer, BUFFER_SIZE1);
if(TransferStatus1 != FAILED)
{
BSP_LCD_DisplayStringAt(0, 115, (uint8_t *)"PASSED String writes", CENTER_MODE);
BSP_LCD_DisplayStringAt(0, 130, (uint8_t *)"in EEPROM:", CENTER_MODE);
BSP_LCD_SetTextColor(LCD_COLOR_BLUE);
BSP_LCD_DisplayStringAt(0, 160, Tx2Buffer, CENTER_MODE);
}
else
{
BSP_LCD_SetTextColor(LCD_COLOR_RED);
BSP_LCD_DisplayStringAt(0, 115, (uint8_t *)"FAILED to write!", CENTER_MODE);
BSP_LCD_DisplayStringAt(0, 130, (uint8_t *)"Press USER key to end test", CENTER_MODE);
}
break;
}
}
/**
* @brief Configures and gets Touch screen position.
* @param None
* @retval None
*/
static void GetPosition(void)
{
static uint32_t color_width;
static uint32_t color;
uint16_t x, y;
color_width = 35;
/* Get Touch screen position */
BSP_TS_GetState(&TS_State);
if(TS_State.touchDetected)
{
/* A touch occured, read the touch coordinates */
/* Get X and Y position of the first touch post calibrated */
x = TouchScreen_Get_Calibrated_X(TS_State.touchX[0]);
y = TouchScreen_Get_Calibrated_Y(TS_State.touchY[0]);
if((x > (90 + Radius)) & (y > (7 + Radius) ) & ( x < (BSP_LCD_GetXSize() - (7 + Radius ))) & (y < (BSP_LCD_GetYSize() - (95 + Radius ))))
{
BSP_LCD_FillCircle((x), (y), Radius);
}
else if((x > 0 ) & ( x < 90 ))
{
if((y > 0 ) & (y < color_width ))
{
BSP_LCD_SetTextColor(LCD_COLOR_WHITE);
Update_Size(Radius);
}
else if((y > color_width ) & (y < (2 * color_width)))
{
BSP_LCD_SetTextColor(LCD_COLOR_YELLOW);
Update_Size(Radius);
}
else if((y > (2 * color_width)) & (y < (3 * color_width)))
{
BSP_LCD_SetTextColor(LCD_COLOR_ORANGE);
Update_Size(Radius);
}
else if((y > (3 * color_width)) & (y < (4 * color_width)))
{
BSP_LCD_SetTextColor(LCD_COLOR_LIGHTMAGENTA);
Update_Size(Radius);
}
else if((y > (4 * color_width)) & (y < (5 * color_width)))
{
BSP_LCD_SetTextColor(LCD_COLOR_DARKGREEN);
Update_Size(Radius);
}
else if((y > (5 * color_width)) &(y < (6 * color_width)))
{
BSP_LCD_SetTextColor(LCD_COLOR_GREEN);
Update_Size(Radius);
}
else if((y > (6 * color_width)) &(y < (7 * color_width)))
{
BSP_LCD_SetTextColor(LCD_COLOR_BROWN);
Update_Size(Radius);
}
else if((y > (7 * color_width)) & (y < (8 * color_width)))
{
BSP_LCD_SetTextColor(LCD_COLOR_RED);
Update_Size(Radius);
}
else if((y > (8 * color_width)) & (y < (9 * color_width)))
{
BSP_LCD_SetTextColor(LCD_COLOR_DARKMAGENTA);
Update_Size(Radius);
}
else if((y > (9 * color_width)) & (y < (10 * color_width)))
{
BSP_LCD_SetTextColor(LCD_COLOR_CYAN);
Update_Size(Radius);
}
else if((y > (10 * color_width)) & (y < (11 * color_width)))
{
BSP_LCD_SetTextColor(LCD_COLOR_DARKBLUE);
Update_Size(Radius);
}
else if((y > (11 * color_width)) & (y < (12 * color_width)))
{
BSP_LCD_SetTextColor(LCD_COLOR_BLACK);
Update_Size(Radius);
}
else if((y > (12 * color_width)) & (y < (14 * color_width)))
{
/* Get the current text color */
color = BSP_LCD_GetTextColor();
BSP_LCD_SetTextColor(LCD_COLOR_WHITE);
/* Clear the working window */
BSP_LCD_FillRect(97, 8, 694, 374);
BSP_LCD_SetTextColor(color);
}
else
{
x = 0;
y = 0;
}
Update_Color();
}
else if((x > 100) & (y > (BSP_LCD_GetYSize() - 90)) & (y < (BSP_LCD_GetYSize()) ) & ( x < 170))
{
Radius = 15;
Update_Size(Radius);
}
else if((x > 170) & (y > (BSP_LCD_GetYSize() - 90)) & (y < (BSP_LCD_GetYSize()) ) & ( x < 240))
{
Radius = 10;
Update_Size(Radius);
}
else if((x > 240) & (y > (BSP_LCD_GetYSize() - 90)) & (y < (BSP_LCD_GetYSize()) ) & ( x < 310))
{
Radius = 5;
Update_Size(Radius);
}
else if(((x > (BSP_LCD_GetXSize()-5) ) & (y > (14 * color_width)) & (y < (15 * color_width))) | ((x < 90) & (y < 5)))
{
TS_State.touchX[0] = 0;
TS_State.touchY[0] = 0;
}
else if((x > 320) & (y > (BSP_LCD_GetYSize() - 90)) & (x < 410) & (y < BSP_LCD_GetYSize() - 5))
{
Save_Picture();
}
}
}
/**
* @brief Configures and gets Touch screen position.
* @param None
* @retval None
*/
static void GetPosition(void)
{
static uint32_t color_width;
static uint32_t color;
color_width = 18;
/* Get Touch screen position */
BSP_TS_GetState(&TS_State);
if(TS_State.TouchDetected)
{
/* Read the coordinate */
x = Calibration_GetX(TS_State.x);
y = Calibration_GetX(TS_State.y);
if((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((x > 0 ) & ( x < 50 ))
{
if((y > 0 ) & (y < color_width ))
{
BSP_LCD_SetTextColor(LCD_COLOR_WHITE);
Update_Size(Radius);
}
else if((y > color_width ) & (y < (2 * color_width)))
{
BSP_LCD_SetTextColor(LCD_COLOR_YELLOW);
Update_Size(Radius);
}
else if((y > (2 * color_width)) & (y < (3 * color_width)))
{
BSP_LCD_SetTextColor(LCD_COLOR_ORANGE);
Update_Size(Radius);
}
else if((y > (3 * color_width)) & (y < (4 * color_width)))
{
BSP_LCD_SetTextColor(LCD_COLOR_LIGHTMAGENTA);
Update_Size(Radius);
}
else if((y > (4 * color_width)) & (y < (5 * color_width)))
{
BSP_LCD_SetTextColor(LCD_COLOR_DARKGREEN);
Update_Size(Radius);
}
else if((y > (5 * color_width)) &(y < (6 * color_width)))
{
BSP_LCD_SetTextColor(LCD_COLOR_GREEN);
Update_Size(Radius);
}
else if((y > (6 * color_width)) &(y < (7 * color_width)))
{
BSP_LCD_SetTextColor(LCD_COLOR_BROWN);
Update_Size(Radius);
}
else if((y > (7 * color_width)) & (y < (8 * color_width)))
{
BSP_LCD_SetTextColor(LCD_COLOR_RED);
Update_Size(Radius);
}
else if((y > (8 * color_width)) & (y < (9 * color_width)))
{
BSP_LCD_SetTextColor(LCD_COLOR_DARKMAGENTA);
Update_Size(Radius);
}
else if((y > (9 * color_width)) & (y < (10 * color_width)))
{
BSP_LCD_SetTextColor(LCD_COLOR_CYAN);
Update_Size(Radius);
}
else if((y > (10 * color_width)) & (y < (11 * color_width)))
{
BSP_LCD_SetTextColor(LCD_COLOR_DARKBLUE);
Update_Size(Radius);
}
else if((y > (11 * color_width)) & (y < (12 * color_width)))
{
BSP_LCD_SetTextColor(LCD_COLOR_BLACK);
Update_Size(Radius);
}
else if((y > (12 * color_width)) & (y < (13 * color_width)))
{
/* Get the current text color */
color = BSP_LCD_GetTextColor();
BSP_LCD_SetTextColor(LCD_COLOR_WHITE);
/* Clear the working window */
BSP_LCD_FillRect(68, 8, 245, 164);
BSP_LCD_SetTextColor(color);
}
else
{
x = 0;
y = 0;
}
Update_Color();
}
else if((x > 70) & (y > (BSP_LCD_GetYSize() - 50)) & (y < (BSP_LCD_GetYSize()) ) & ( x < 100))
{
Radius = 10;
Update_Size(Radius);
}
else if((x > 100) & (y > (BSP_LCD_GetYSize() - 50)) & (y < (BSP_LCD_GetYSize()) ) & ( x < 130))
{
Radius = 5;
Update_Size(Radius);
}
else if((x > 130) & (y > (BSP_LCD_GetYSize() - 50)) & (y < (BSP_LCD_GetYSize()) ) & ( x < 160))
{
Radius = 2;
Update_Size(Radius);
}
else if(((x > (BSP_LCD_GetXSize()-5) ) & (y > (12 * color_width)) & (y < (13 * color_width))) | ((x < 55) & (y < 5)))
{
TS_State.x = 0;
TS_State.y = 0;
}
else if((x > 160) & (y > (BSP_LCD_GetYSize() - 50)) & (x < 210) & (y < BSP_LCD_GetYSize()))
{
Save_Picture();
}
}
}
/**
* @brief Show EEPROM Features
* @param Feature : feature index
* @retval None
*/
static void EEPROM_Show_Feature(uint8_t Feature)
{
__IO TestStatus TransferStatus1 = FAILED;
__IO uint16_t NumDataRead = 0;
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);
/* Initialize the I2C EEPROM driver ----------------------------------------*/
if(BSP_EEPROM_Init() != EEPROM_OK)
{
BSP_LCD_SetTextColor(LCD_COLOR_RED);
BSP_LCD_DisplayStringAt(0, 115, (uint8_t *)"Initialization problem", CENTER_MODE);
BSP_LCD_DisplayStringAt(0, 130, (uint8_t *)"Check if HW connected or", CENTER_MODE);
BSP_LCD_DisplayStringAt(0, 145, (uint8_t *)"HW version not supported", CENTER_MODE);
return;
}
EEPROMConnected = 1;
/* Wait for EEPROM standby state */
BSP_EEPROM_WaitEepromStandbyState();
switch (Feature)
{
case 0:
/* Read old parameter in EEPROM */
if(EEPROMConnected == 1)
{
/* Set the Number of data to be read */
NumDataRead = BUFFER_SIZE1;
/* Read from I2C EEPROM from EEPROM_READ_ADDRESS1 */
if(BSP_EEPROM_ReadBuffer(Rx1Buffer, EEPROM_READ_ADDRESS1, (uint16_t *)(&NumDataRead)) != EEPROM_OK)
{
BSP_LCD_SetTextColor(LCD_COLOR_RED);
BSP_LCD_DisplayStringAt(0, 115, (uint8_t *)"Init issue at read old data", CENTER_MODE);
BSP_LCD_SetTextColor(LCD_COLOR_BLACK);
BSP_LCD_DisplayStringAt(0, 145, (uint8_t *)"Press again USER key", CENTER_MODE);
BSP_LCD_DisplayStringAt(0, 160, (uint8_t *)"To write new data", CENTER_MODE);
return;
}
BSP_LCD_DisplayStringAt(0, 115, (uint8_t *)"PASSED String read", CENTER_MODE);
BSP_LCD_DisplayStringAt(0, 130, (uint8_t *)"in EEPROM:", CENTER_MODE);
BSP_LCD_SetTextColor(LCD_COLOR_BLUE);
BSP_LCD_DisplayStringAt(0, 160, Rx1Buffer, CENTER_MODE);
BSP_LCD_SetTextColor(LCD_COLOR_BLACK);
BSP_LCD_DisplayStringAt(0, 190, (uint8_t *)"Press USER key", CENTER_MODE);
BSP_LCD_DisplayStringAt(0, 205, (uint8_t *)"To write new data", CENTER_MODE);
}
else
{
BSP_LCD_SetTextColor(LCD_COLOR_RED);
BSP_LCD_DisplayStringAt(0, 115, (uint8_t *)"Problem to communicate", CENTER_MODE);
BSP_LCD_DisplayStringAt(0, 130, (uint8_t *)"with EEPROM", CENTER_MODE);
BSP_LCD_DisplayStringAt(0, 145, (uint8_t *)"Press again USER key", CENTER_MODE);
}
break;
case 1:
/* Write new parameter in EEPROM */
if(EEPROMConnected == 1)
{
BSP_LCD_SetTextColor(LCD_COLOR_BLACK);
BSP_LCD_DisplayStringAt(0, 115, (uint8_t *)"Writing...", CENTER_MODE);
snprintf((char*)Tx2Buffer, BUFFER_SIZE1, "%s Test %d", Tx1Buffer, NbLoop);
/* First write in the memory followed by a read of the written data --------*/
/* Write on I2C EEPROM to EEPROM_WRITE_ADDRESS1 */
if (BSP_EEPROM_WriteBuffer(Tx2Buffer, EEPROM_WRITE_ADDRESS1, BUFFER_SIZE1) != EEPROM_OK)
{
BSP_LCD_SetTextColor(LCD_COLOR_RED);
BSP_LCD_DisplayStringAt(0, 115, (uint8_t *)"Init issue at write 1", CENTER_MODE);
return;
}
if (BSP_EEPROM_WriteBuffer(Tx2Buffer, EEPROM_WRITE_ADDRESS1, BUFFER_SIZE1) != EEPROM_OK)
{
BSP_LCD_SetTextColor(LCD_COLOR_RED);
BSP_LCD_DisplayStringAt(0, 115, (uint8_t *)"Init issue at write 2", CENTER_MODE);
return;
}
if (BSP_EEPROM_WriteBuffer(Tx2Buffer, EEPROM_WRITE_ADDRESS1, BUFFER_SIZE1) != EEPROM_OK)
{
BSP_LCD_SetTextColor(LCD_COLOR_RED);
BSP_LCD_DisplayStringAt(0, 115, (uint8_t *)"Init issue at write 3", CENTER_MODE);
return;
}
if (BSP_EEPROM_WriteBuffer(Tx2Buffer, EEPROM_WRITE_ADDRESS1, BUFFER_SIZE1) != EEPROM_OK)
{
BSP_LCD_SetTextColor(LCD_COLOR_RED);
BSP_LCD_DisplayStringAt(0, 115, (uint8_t *)"Init issue at write 4", CENTER_MODE);
return;
}
if (BSP_EEPROM_WriteBuffer(Tx2Buffer, EEPROM_WRITE_ADDRESS1, BUFFER_SIZE1) != EEPROM_OK)
{
BSP_LCD_SetTextColor(LCD_COLOR_RED);
BSP_LCD_DisplayStringAt(0, 115, (uint8_t *)"Init issue at write 5", CENTER_MODE);
return;
}
/* Wait for EEPROM standby state */
BSP_EEPROM_WaitEepromStandbyState();
/* Set the Number of data to be read */
NumDataRead = BUFFER_SIZE1;
/* Read from I2C EEPROM from EEPROM_READ_ADDRESS1 */
if (BSP_EEPROM_ReadBuffer(Rx1Buffer, EEPROM_READ_ADDRESS1, (uint16_t *)(&NumDataRead)) != EEPROM_OK)
{
BSP_LCD_SetTextColor(LCD_COLOR_RED);
BSP_LCD_DisplayStringAt(0, 115, (uint8_t *)"Init issue at read", CENTER_MODE);
return;
}
/* Check if the data written to the memory is read correctly */
TransferStatus1 = Buffercmp(Tx2Buffer, Rx1Buffer, BUFFER_SIZE1);
if (TransferStatus1 != FAILED)
{
BSP_LCD_DisplayStringAt(0, 115, (uint8_t *)"PASSED String write", CENTER_MODE);
BSP_LCD_DisplayStringAt(0, 130, (uint8_t *)"in EEPROM:", CENTER_MODE);
BSP_LCD_SetTextColor(LCD_COLOR_BLUE);
BSP_LCD_DisplayStringAt(0, 160, Tx2Buffer, CENTER_MODE);
}
else
{
BSP_LCD_SetTextColor(LCD_COLOR_RED);
BSP_LCD_DisplayStringAt(0, 115, (uint8_t *)"FAILED to write!", CENTER_MODE);
BSP_LCD_DisplayStringAt(0, 130, (uint8_t *)"Press USER key to end test", CENTER_MODE);
}
}
else
{
BSP_LCD_SetTextColor(LCD_COLOR_RED);
BSP_LCD_DisplayStringAt(0, 115, (uint8_t *)"Problem to communicate", CENTER_MODE);
BSP_LCD_DisplayStringAt(0, 130, (uint8_t *)"again with EEPROM", CENTER_MODE);
BSP_LCD_DisplayStringAt(0, 130, (uint8_t *)"Press USER key to end test", CENTER_MODE);
}
break;
}
}
/**
* @brief Manages Audio process.
* @param None
* @retval Audio error
*/
AUDIO_ErrorTypeDef AUDIO_REC_Process(void)
{
uint32_t byteswritten = 0;
AUDIO_ErrorTypeDef audio_error = AUDIO_ERROR_NONE;
uint32_t elapsed_time;
static uint32_t prev_elapsed_time = 0xFFFFFFFF;
uint8_t str[10];
static TS_StateTypeDef TS_State={0};
switch(AudioState)
{
case AUDIO_STATE_PRERECORD:
if(TS_State.touchDetected == 1) /* If previous touch has not been released, we don't proceed any touch command */
{
BSP_TS_GetState(&TS_State);
}
else
{
BSP_TS_GetState(&TS_State);
if(TS_State.touchDetected == 1)
{
if ((TS_State.touchX[0] > TOUCH_STOP_XMIN) && (TS_State.touchX[0] < TOUCH_STOP_XMAX) &&
(TS_State.touchY[0] > TOUCH_STOP_YMIN) && (TS_State.touchY[0] < TOUCH_STOP_YMAX))
{
AudioState = AUDIO_STATE_STOP;
}
else 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))
{
display_update = 1;
AudioState = AUDIO_STATE_RECORD;
}
else if((TS_State.touchX[0] > TOUCH_VOL_MINUS_XMIN) && (TS_State.touchX[0] < TOUCH_VOL_MINUS_XMAX) &&
(TS_State.touchY[0] > TOUCH_VOL_MINUS_YMIN) && (TS_State.touchY[0] < TOUCH_VOL_MINUS_YMAX))
{
AudioState = AUDIO_STATE_VOLUME_DOWN;
if(uwVolume >= 5)
{
uwVolume -= 5;
}
}
else if((TS_State.touchX[0] > TOUCH_VOL_PLUS_XMIN) && (TS_State.touchX[0] < TOUCH_VOL_PLUS_XMAX) &&
(TS_State.touchY[0] > TOUCH_VOL_PLUS_YMIN) && (TS_State.touchY[0] < TOUCH_VOL_PLUS_YMAX))
{
AudioState = AUDIO_STATE_VOLUME_UP;
if(uwVolume <= 95)
{
uwVolume += 5;
}
}
if ((AudioState == AUDIO_STATE_VOLUME_DOWN) || (AudioState == AUDIO_STATE_VOLUME_UP))
{
sprintf((char *)str, "Volume : %d ", (int)uwVolume);
BSP_LCD_ClearStringLine(7);
BSP_LCD_DisplayStringAtLine(7, str);
BSP_AUDIO_IN_SetVolume(uwVolume);
AudioState = AUDIO_STATE_PRERECORD;
}
}
else
{
AudioState = AUDIO_STATE_PRERECORD;
}
}
break;
case AUDIO_STATE_RECORD:
if (display_update)
{
BSP_LCD_SetTextColor(LCD_COLOR_RED); /* Display red record circle */
BSP_LCD_FillCircle((TOUCH_RECORD_XMAX+TOUCH_RECORD_XMIN)/2,
(TOUCH_RECORD_YMAX+TOUCH_RECORD_YMIN)/2,
(TOUCH_RECORD_XMAX-TOUCH_RECORD_XMIN)/2);
BSP_LCD_SetFont(&LCD_LOG_TEXT_FONT);
BSP_LCD_SetTextColor(LCD_COLOR_YELLOW);
BSP_LCD_DisplayStringAt(247, LINE(6), (uint8_t *)" [RECORD]", LEFT_MODE);
display_update = 0;
}
if(TS_State.touchDetected == 1) /* If previous touch has not been released, we don't proceed any touch command */
{
BSP_TS_GetState(&TS_State);
}
else
{
BSP_TS_GetState(&TS_State);
if(TS_State.touchDetected == 1)
{
if ((TS_State.touchX[0] > TOUCH_STOP_XMIN) && (TS_State.touchX[0] < TOUCH_STOP_XMAX) &&
(TS_State.touchY[0] > TOUCH_STOP_YMIN) && (TS_State.touchY[0] < TOUCH_STOP_YMAX))
{
AudioState = AUDIO_STATE_STOP;
}
else if ((TS_State.touchX[0] > TOUCH_PAUSE_XMIN) && (TS_State.touchX[0] < TOUCH_PAUSE_XMAX) &&
(TS_State.touchY[0] > TOUCH_PAUSE_YMIN) && (TS_State.touchY[0] < TOUCH_PAUSE_YMAX))
{
AudioState = AUDIO_STATE_PAUSE;
}
else if((TS_State.touchX[0] > TOUCH_VOL_MINUS_XMIN) && (TS_State.touchX[0] < TOUCH_VOL_MINUS_XMAX) &&
(TS_State.touchY[0] > TOUCH_VOL_MINUS_YMIN) && (TS_State.touchY[0] < TOUCH_VOL_MINUS_YMAX))
{
AudioState = AUDIO_STATE_VOLUME_DOWN;
}
else if((TS_State.touchX[0] > TOUCH_VOL_PLUS_XMIN) && (TS_State.touchX[0] < TOUCH_VOL_PLUS_XMAX) &&
(TS_State.touchY[0] > TOUCH_VOL_PLUS_YMIN) && (TS_State.touchY[0] < TOUCH_VOL_PLUS_YMAX))
{
AudioState = AUDIO_STATE_VOLUME_UP;
}
}
}
/* MAX Recording time reached, so stop audio interface and close file */
if(BufferCtl.fptr >= REC_SAMPLE_LENGTH)
{
display_update = 1;
AudioState = AUDIO_STATE_STOP;
break;
}
/* Check if there are Data to write to USB Key */
if(BufferCtl.wr_state == BUFFER_FULL)
{
/* write buffer in file */
if(f_write(&WavFile, (uint8_t*)(BufferCtl.pcm_buff + BufferCtl.offset),
AUDIO_IN_PCM_BUFFER_SIZE,
(void*)&byteswritten) != FR_OK)
{
BSP_LCD_SetTextColor(LCD_COLOR_RED);
BSP_LCD_DisplayStringAtLine(14, (uint8_t *)"RECORD FAIL");
return AUDIO_ERROR_IO;
}
BufferCtl.fptr += byteswritten;
BufferCtl.wr_state = BUFFER_EMPTY;
}
/* Display elapsed time */
elapsed_time = BufferCtl.fptr / (DEFAULT_AUDIO_IN_FREQ * DEFAULT_AUDIO_IN_CHANNEL_NBR * 2);
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_YELLOW);
BSP_LCD_DisplayStringAt(263, LINE(8), str, LEFT_MODE);
sprintf((char *)str, "%4d KB", (int)((int32_t)BufferCtl.fptr/1024));
BSP_LCD_DisplayStringAt(83, LINE(8), str, LEFT_MODE);
}
break;
case AUDIO_STATE_STOP:
/* Stop recorder */
BSP_AUDIO_IN_Stop();
BSP_LCD_SetTextColor(LCD_COLOR_CYAN); /* Display blue cyan record circle */
BSP_LCD_FillCircle((TOUCH_RECORD_XMAX+TOUCH_RECORD_XMIN)/2,
(TOUCH_RECORD_YMAX+TOUCH_RECORD_YMIN)/2,
(TOUCH_RECORD_XMAX-TOUCH_RECORD_XMIN)/2);
BSP_LCD_SetTextColor(LCD_COLOR_RED);
BSP_LCD_FillRect(TOUCH_STOP_XMIN, TOUCH_STOP_YMIN , /* Stop rectangle */
TOUCH_STOP_XMAX - TOUCH_STOP_XMIN,
TOUCH_STOP_YMAX - TOUCH_STOP_YMIN);
BSP_LCD_SetTextColor(LCD_COLOR_CYAN);
display_update = 1;
HAL_Delay(150);
if(f_lseek(&WavFile, 0) == FR_OK)
{
/* Update the wav file header save it into wav file */
WavProcess_HeaderUpdate(pHeaderBuff, &WaveFormat);
if(f_write(&WavFile, pHeaderBuff, sizeof(WAVE_FormatTypeDef), (void*)&byteswritten) == FR_OK)
{
audio_error = AUDIO_ERROR_EOF;
}
else
{
audio_error = AUDIO_ERROR_IO;
BSP_LCD_SetTextColor(LCD_COLOR_RED);
BSP_LCD_DisplayStringAtLine(14, (uint8_t *)"RECORD FAIL");
}
}
else
{
BSP_LCD_SetTextColor(LCD_COLOR_RED);
BSP_LCD_DisplayStringAtLine(14, (uint8_t *)"RECORD FAIL");
audio_error = AUDIO_ERROR_IO;
}
AudioState = AUDIO_STATE_IDLE;
/* Close file */
f_close(&WavFile);
break;
case AUDIO_STATE_PAUSE:
BSP_LCD_SetTextColor(LCD_COLOR_RED); /* Displays red pause rectangles */
BSP_LCD_FillRect(TOUCH_PAUSE_XMIN, TOUCH_PAUSE_YMIN , 15, TOUCH_PAUSE_YMAX - TOUCH_PAUSE_YMIN);
BSP_LCD_FillRect(TOUCH_PAUSE_XMIN + 20, TOUCH_PAUSE_YMIN, 15, TOUCH_PAUSE_YMAX - TOUCH_PAUSE_YMIN);
BSP_LCD_SetTextColor(LCD_COLOR_CYAN); /* Display blue cyan record circle */
BSP_LCD_FillCircle((TOUCH_RECORD_XMAX+TOUCH_RECORD_XMIN)/2,
(TOUCH_RECORD_YMAX+TOUCH_RECORD_YMIN)/2,
(TOUCH_RECORD_XMAX-TOUCH_RECORD_XMIN)/2);
BSP_LCD_SetTextColor(LCD_COLOR_YELLOW);
BSP_LCD_DisplayStringAt(247, LINE(6), (uint8_t *)" [PAUSE] ", LEFT_MODE);
BSP_AUDIO_IN_Pause();
AudioState = AUDIO_STATE_WAIT;
break;
case AUDIO_STATE_RESUME:
BSP_LCD_SetTextColor(LCD_COLOR_CYAN); /* Displays blue cyan pause rectangles */
BSP_LCD_FillRect(TOUCH_PAUSE_XMIN, TOUCH_PAUSE_YMIN , 15, TOUCH_PAUSE_YMAX - TOUCH_PAUSE_YMIN);
BSP_LCD_FillRect(TOUCH_PAUSE_XMIN + 20, TOUCH_PAUSE_YMIN, 15, TOUCH_PAUSE_YMAX - TOUCH_PAUSE_YMIN);
BSP_LCD_SetTextColor(LCD_COLOR_RED); /* Display red record circle */
BSP_LCD_FillCircle((TOUCH_RECORD_XMAX+TOUCH_RECORD_XMIN)/2,
(TOUCH_RECORD_YMAX+TOUCH_RECORD_YMIN)/2,
(TOUCH_RECORD_XMAX-TOUCH_RECORD_XMIN)/2);
BSP_LCD_SetTextColor(LCD_COLOR_YELLOW);
BSP_LCD_DisplayStringAt(247, LINE(6), (uint8_t *)" [RECORD]", LEFT_MODE);
BSP_AUDIO_IN_Resume();
AudioState = AUDIO_STATE_RECORD;
break;
case AUDIO_STATE_VOLUME_UP:
if(uwVolume <= 95)
{
uwVolume += 5;
}
sprintf((char *)str, "Volume : %d ", (int)uwVolume);
BSP_LCD_SetTextColor(LCD_COLOR_YELLOW);
BSP_LCD_ClearStringLine(7);
BSP_LCD_DisplayStringAtLine(7, str);
BSP_AUDIO_IN_SetVolume(uwVolume);
AudioState = AUDIO_STATE_RECORD;
break;
case AUDIO_STATE_VOLUME_DOWN:
if(uwVolume >= 5)
{
uwVolume -= 5;
}
sprintf((char *)str, "Volume : %d ", (int)uwVolume);
BSP_LCD_SetTextColor(LCD_COLOR_YELLOW);
BSP_LCD_ClearStringLine(7);
BSP_LCD_DisplayStringAtLine(7, str);
BSP_AUDIO_IN_SetVolume(uwVolume);
AudioState = AUDIO_STATE_RECORD;
break;
case AUDIO_STATE_NEXT:
case AUDIO_STATE_PREVIOUS:
AudioState = AUDIO_STATE_RECORD;
break;
case AUDIO_STATE_WAIT:
if(TS_State.touchDetected == 1) /* If previous touch has not been released, we don't proceed any touch command */
{
BSP_TS_GetState(&TS_State);
}
else
{
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))
{
AudioState = AUDIO_STATE_RESUME;
}
else if ((TS_State.touchX[0] > TOUCH_PAUSE_XMIN) && (TS_State.touchX[0] < TOUCH_PAUSE_XMAX) &&
(TS_State.touchY[0] > TOUCH_PAUSE_YMIN) && (TS_State.touchY[0] < TOUCH_PAUSE_YMAX))
{
AudioState = AUDIO_STATE_RESUME;
}
}
}
case AUDIO_STATE_IDLE:
case AUDIO_STATE_INIT:
default:
/* Do Nothing */
break;
}
return audio_error;
}
