/**
* @brief Joystick Exti demo
* @param None
* @retval None
*/
void Joystick_exti_demo (void)
{
uint8_t status = 0;
uint32_t ITstatus = 0;
Joystick_SetHint(1);
status = BSP_JOY_Init(JOY_MODE_EXTI);
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);
}
if (status == IO_OK)
{
Joystick_SetCursorPosition();
}
while (1) /* pull for USER button in GPIO mode */
{
if (status == IO_OK)
{
if (MfxExtiReceived == 1)
{
MfxExtiReceived = 0;
ITstatus = BSP_IO_ITGetStatus(JOY_ALL_PINS);
if (ITstatus)
{
/* Get the Joystick State */
JoyState = BSP_JOY_GetState();
Joystick_SetCursorPosition();
}
BSP_IO_ITClear();
/* poll if joystick is still pressed until it is released*/
while ( BSP_JOY_GetState() != JOY_NONE)
{
Joystick_SetCursorPosition();
HAL_Delay(5);
}
}
}
if(CheckForUserInput() > 0)
{
return;
}
HAL_Delay(5);
}
}
/**
* @brief Joystick Msc menu
* @param None
* @retval None
*/
void Joystick_MscMenu(void)
{
static JOYState_TypeDef JoyState = JOY_NONE;
/* Get the Joystick State */
JoyState = BSP_JOY_GetState();
MSC_DEMO_ProbeKey(JoyState);
switch(JoyState)
{
case JOY_LEFT:
LCD_LOG_ScrollBack();
break;
case JOY_RIGHT:
LCD_LOG_ScrollForward();
break;
default:
break;
}
osSemaphoreRelease(MenuEvent);
}
/**
* @brief Joystick Gpio demo
* @param None
* @retval None
*/
void Joystick_demo (void)
{
uint8_t status = 0;
Joystick_SetHint();
status = BSP_JOY_Init();
if (status != HAL_OK)
{
BSP_LCD_SetBackColor(LCD_COLOR_WHITE);
BSP_LCD_SetTextColor(LCD_COLOR_RED);
BSP_LCD_DisplayStringAt(0, BSP_LCD_GetYSize()- 70, (uint8_t *)"ERROR", CENTER_MODE);
BSP_LCD_DisplayStringAt(0, BSP_LCD_GetYSize()- 55, (uint8_t *)"Joystick cannot", CENTER_MODE);
BSP_LCD_DisplayStringAt(0, BSP_LCD_GetYSize()- 40, (uint8_t *)"be initialized", CENTER_MODE);
}
while (1)
{
if (status == HAL_OK)
{
/* Get the Joystick State */
JoyState = BSP_JOY_GetState();
Joystick_SetCursorPosition();
}
if(CheckForUserInput() > 0)
{
return;
}
HAL_Delay(6);
}
}
/**
* @brief Gets Pointer Data.
* @param pbuf: Pointer to report
* @retval None
*/
static void GetPointerData(uint8_t *pbuf)
{
int8_t x = 0, y = 0 ;
switch (BSP_JOY_GetState())
{
case JOY_LEFT:
x -= CURSOR_STEP;
break;
case JOY_RIGHT:
x += CURSOR_STEP;
break;
case JOY_UP:
y -= CURSOR_STEP;
break;
case JOY_DOWN:
y += CURSOR_STEP;
break;
default:
break;
}
pbuf[0] = 0;
pbuf[1] = x;
pbuf[2] = y;
pbuf[3] = 0;
}
/**
* @brief EXTI line detection callbacks.
* @param GPIO_Pin: Specifies the pins connected EXTI line
* @retval None
*/
void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{
__IO JOYState_TypeDef JoyState = JOY_NONE;
if(GPIO_Pin == GPIO_PIN_8)
{
/* Get the Joystick State */
JoyState = BSP_JOY_GetState();
HID_DEMO_ProbeKey(JoyState);
switch(JoyState)
{
case JOY_LEFT:
LCD_LOG_ScrollBack();
break;
case JOY_RIGHT:
LCD_LOG_ScrollForward();
break;
default:
break;
}
/* Clear joystick interrupt pending bits */
BSP_IO_ITClear();
osSemaphoreRelease(MenuEvent);
}
}
/**
* @brief EXTI line detection callbacks.
* @param GPIO_Pin: Specifies the pins connected EXTI line
* @retval None
*/
void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{
static JOYState_TypeDef JoyState = JOY_NONE;
if(GPIO_Pin == GPIO_PIN_2)
{
/* Get the Joystick State */
JoyState = BSP_JOY_GetState();
MSC_DEMO_ProbeKey(JoyState);
switch(JoyState)
{
case JOY_LEFT:
LCD_LOG_ScrollBack();
break;
case JOY_RIGHT:
LCD_LOG_ScrollForward();
break;
default:
break;
}
/* Clear joystick interrupt pending bits */
BSP_IO_ITClear(JOY_ALL_PINS);
}
}
/**
* @brief Joystick audio menu
* @param None
* @retval None
*/
void Joystick_AudioMenu(void)
{
static JOYState_TypeDef JoyState = JOY_NONE;
/* Get the Joystick State */
JoyState = BSP_JOY_GetState();
if(AudioSelectMode == AUDIO_SELECT_MENU)
{
AUDIO_MenuProbeKey(JoyState);
switch(JoyState)
{
case JOY_LEFT:
LCD_LOG_ScrollBack();
break;
case JOY_RIGHT:
LCD_LOG_ScrollForward();
break;
default:
break;
}
}
else if(AudioSelectMode == AUDIO_PLAYBACK_CONTROL)
{
AUDIO_PlaybackProbeKey(JoyState);
}
}
/**
* @brief LCD Log demo
* @param None
* @retval None
*/
void Log_demo(void)
{
JOYState_TypeDef JoyState = JOY_NONE;
uint8_t i = 0;
/* Wait For User inputs */
while(CheckForUserInput() == 0);
BSP_JOY_Init(JOY_MODE_GPIO);
/* Initialize LCD Log module */
LCD_LOG_Init();
/* Show Header and Footer texts */
LCD_LOG_SetHeader((uint8_t *)"Log Example");
LCD_LOG_SetFooter((uint8_t *)"Use Joystick to scroll up/down");
/* Output User logs */
for (i = 0; i < 10; i++)
{
LCD_UsrLog ("This is Line %d \n", i);
}
HAL_Delay(2000);
/* Clear Old logs */
LCD_LOG_ClearTextZone();
/* Output new user logs */
for (i = 0; i < 30; i++)
{
LCD_UsrLog ("This is Line %d \n", i);
}
/* Check for joystick user input for scroll (back and forward) */
while (1)
{
JoyState = BSP_JOY_GetState();
switch(JoyState)
{
case JOY_UP:
LCD_LOG_ScrollBack();
break;
case JOY_DOWN:
LCD_LOG_ScrollForward();
break;
default:
break;
}
if(CheckForUserInput() > 0)
{
return;
}
HAL_Delay (10);
}
}
/**
* @brief EXTI line detection callbacks.
* @param GPIO_Pin: Specifies the pins connected EXTI line
* @retval None
*/
void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{
/* If the interruption comes from the Joystick, check which
Joystick button has been pressed */
JoyState = BSP_JOY_GetState();
if(JoyState == JOY_SEL)
{
/* SEL is used to pause and resume the audio playback */
if (PressCount == 1)
{
/* Resume playing Wave status */
PauseResumeStatus = RESUME_STATUS;
PressCount = 0;
}
else
{
/* Pause playing Wave status */
PauseResumeStatus = PAUSE_STATUS;
PressCount = 1;
}
}
else if(JoyState == JOY_UP)
{
/* UP is used to increment the volume of the audio playback */
volume ++;
if (volume > 100)
{
volume = 100;
}
VolumeChange = 1;
}
else if(JoyState == JOY_DOWN)
{
/* DOWN is used to decrement the volume of the audio playback */
volume --;
if ((int8_t)volume < 50)
{
volume = 50;
}
VolumeChange = 1;
}
/* Clear MFX IT */
BSP_IO_ITClear();
}
/**
* @brief EXTI line detection callbacks.
* @param GPIO_Pin: Specifies the pins connected EXTI line
* @retval None
*/
void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{
static JOYState_TypeDef JoyState = JOY_NONE;
if(GPIO_Pin == MFX_IRQOUT_PIN)
{
/* The different functionalities of MFX (TS, Joystick, SD detection, etc. )
can be configured in exti mode to generate an IRQ on given events.
The MFX IRQ_OUT pin is unique and common to all functionalities, so if several
functionalities are configured in exit mode, the MCU has to enquire MFX about
the IRQ source (see BSP_IO_ITGetStatus). Communication with Mfx is done by I2C.
Often the sw requires ISRs (irq service routines) to be quick while communication
with I2C can be considered relatively long (hundreds of usec depending on I2C clk).
Considering that the features for human interaction like TS, Joystick, SD detection
don’t need immediate reaction, it is suggested to use POLLING instead of EXTI mode,
in order to avoid "blocking I2C communication" on interrupt service routines */
/* Get the Joystick State */
JoyState = BSP_JOY_GetState();
HAL_Delay(200);
MSC_DEMO_ProbeKey(JoyState);
switch(JoyState)
{
case JOY_LEFT:
LCD_LOG_ScrollBack();
break;
case JOY_RIGHT:
LCD_LOG_ScrollForward();
break;
default:
break;
}
/* Clear joystick interrupt pending bits */
BSP_IO_ITClear();
}
}
/**
* @brief EXTI line detection callbacks.
* @param GPIO_Pin: Specifies the pins connected EXTI line
* @retval None
*/
void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{
__IO JOYState_TypeDef JoyState = JOY_NONE;
if(GPIO_Pin == MFX_IRQOUT_PIN)
{
/* The different functionalities of MFX (TS, Joystick, SD detection, etc. )
can be configured in exti mode to generate an IRQ on given events.
The MFX IRQ_OUT pin is unique and common to all functionalities, so if several
functionalities are configured in exit mode, the MCU has to enquire MFX about
the IRQ source (see BSP_IO_ITGetStatus). Communication with Mfx is done by I2C.
Often the sw requires ISRs (irq service routines) to be quick while communication
with I2C can be considered relatively long (hundreds of usec depending on I2C clk).
In order to avoid to use "blocking I2C communication" on interrupt service routines
it's suggested (as alternative to this implementation) to use dedicated semaphore*/
/* Get the Joystick State */
JoyState = BSP_JOY_GetState();
HID_DEMO_ProbeKey(JoyState);
switch(JoyState)
{
case JOY_LEFT:
LCD_LOG_ScrollBack();
break;
case JOY_RIGHT:
LCD_LOG_ScrollForward();
break;
default:
break;
}
/* Clear joystick interrupt pending bits */
BSP_IO_ITClear();
osSemaphoreRelease(MenuEvent);
}
}
/**
* @brief Select the type of device
* @param None
* @retval None
*/
static void HdmiCec_SelectDevice(void)
{
JOYState_TypeDef JoyKey;
BSP_LCD_DisplayStringAt(20, 100, (uint8_t *)"Select your CEC Device Type", LEFT_MODE);
BSP_LCD_DisplayStringAt(20, 130, (uint8_t *)"RIGHT --> Recording", LEFT_MODE);
BSP_LCD_DisplayStringAt(20, 145, (uint8_t *)"LEFT --> Tuner", LEFT_MODE);
BSP_LCD_DisplayStringAt(20, 160, (uint8_t *)"UP --> Playback", LEFT_MODE);
BSP_LCD_DisplayStringAt(20, 175, (uint8_t *)"DOWN --> AudioSystem", LEFT_MODE);
do
{
JoyKey = BSP_JOY_GetState();
} while(JoyKey == JOY_NONE);
switch(JoyKey)
{
case JOY_DOWN :
DeviceType = HDMI_CEC_AUDIOSYSTEM;
BSP_LCD_DisplayStringAt(20, BSP_LCD_GetYSize()-30, (uint8_t *)"Device selected : AudioSystem", LEFT_MODE);
break;
case JOY_LEFT :
DeviceType = HDMI_CEC_TUNER;
BSP_LCD_DisplayStringAt(20, BSP_LCD_GetYSize()-30, (uint8_t *)"Device selected : Tuner", LEFT_MODE);
break;
case JOY_RIGHT :
DeviceType = HDMI_CEC_RECORDING;
BSP_LCD_DisplayStringAt(20, BSP_LCD_GetYSize()-30, (uint8_t *)"Device selected : Recording", LEFT_MODE);
break;
case JOY_UP :
DeviceType = HDMI_CEC_PLAYBACK;
BSP_LCD_DisplayStringAt(20, BSP_LCD_GetYSize()-30, (uint8_t *)"Device selected : Playback", LEFT_MODE);
break;
default :
DeviceType = HDMI_CEC_TV;
BSP_LCD_DisplayStringAt(20, BSP_LCD_GetYSize()-30, (uint8_t *)"No device selected (TV by default)", LEFT_MODE);
}
}
void HID_Joysticky(void)
{
static JOYState_TypeDef JoyState = JOY_NONE;
/* Get the Joystick State */
JoyState = BSP_JOY_GetState();
HID_DEMO_ProbeKey(JoyState);
switch(JoyState)
{
case JOY_LEFT:
LCD_LOG_ScrollBack();
break;
case JOY_RIGHT:
LCD_LOG_ScrollForward();
break;
default:
break;
}
}
/**
* @brief EXTI line detection callbacks.
* @param GPIO_Pin: Specifies the pins connected EXTI line
* @retval None
*/
void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{
static JOYState_TypeDef JoyState = JOY_NONE;
static uint32_t debounce_time = 0;
if(GPIO_Pin == GPIO_PIN_2)
{
/* Get the Joystick State */
JoyState = BSP_JOY_GetState();
/* Clear joystick interrupt pending bits */
BSP_IO_ITClear(JOY_ALL_PINS);
if(mtp_select_mode == MTP_SELECT_MENU)
{
MTP_MenuProbeKey(JoyState);
switch(JoyState)
{
case JOY_LEFT:
LCD_LOG_ScrollBack();
break;
case JOY_RIGHT:
LCD_LOG_ScrollForward();
break;
default:
break;
}
}
else if(mtp_select_mode == MTP_PLAYBACK_CONTROL)
{
AUDIO_PlaybackProbeKey(JoyState);
}
}
if(mtp_demo.state == MTP_DEMO_PLAYBACK)
{
if(GPIO_Pin == KEY_BUTTON_PIN)
{
/* Prevent debounce effect for user key */
if((HAL_GetTick() - debounce_time) > 50)
{
debounce_time = HAL_GetTick();
}
else
{
return;
}
/* Change the selection type */
if(mtp_select_mode == MTP_SELECT_MENU)
{
MTP_ChangeSelectMode(MTP_PLAYBACK_CONTROL);
}
else if(mtp_select_mode == MTP_PLAYBACK_CONTROL)
{
AUDIO_Stop();
}
}
}
}
/**
* @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 EXTI line detection callbacks.
* @param GPIO_Pin: Specifies the pins connected EXTI line
* @retval None
*/
void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{
static JOYState_TypeDef JoyState = JOY_NONE;
static uint32_t debounce_time = 0;
if(GPIO_Pin == GPIO_PIN_8)
{
/* Get the Joystick State */
JoyState = BSP_JOY_GetState();
CDC_DEMO_ProbeKey(JoyState);
/* Clear joystick interrupt pending bits */
BSP_IO_ITClear();
if((CdcSelectMode == CDC_SELECT_MENU) && (CdcDemo.state != CDC_DEMO_RECEIVE))
{
switch(JoyState)
{
case JOY_LEFT:
LCD_LOG_ScrollBack();
break;
case JOY_RIGHT:
LCD_LOG_ScrollForward();
break;
default:
break;
}
}
}
if(CdcDemo.state == CDC_DEMO_CONFIGURATION)
{
if(GPIO_Pin == KEY_BUTTON_PIN)
{
/* Prevent debounce effect for user key */
if((HAL_GetTick() - debounce_time) > 50)
{
debounce_time = HAL_GetTick();
}
else
{
return;
}
BSP_LCD_SetBackColor(LCD_COLOR_BLACK);
/* Change the selection type */
if(CdcSelectMode == CDC_SELECT_MENU)
{
CDC_ChangeSelectMode(CDC_SELECT_CONFIG);
}
else if(CdcSelectMode == CDC_SELECT_CONFIG)
{
CDC_ChangeSelectMode(CDC_SELECT_MENU);
}
else if(CdcSelectMode == CDC_SELECT_FILE)
{
CDC_ChangeSelectMode(CDC_SELECT_FILE);
}
}
}
if(CdcDemo.state == CDC_DEMO_SEND)
{
if(GPIO_Pin == KEY_BUTTON_PIN)
{
/* Prevent debounce effect for user key */
if((HAL_GetTick() - debounce_time) > 50)
{
debounce_time = HAL_GetTick();
}
else
{
return;
}
if(CdcDemo.Send_state == CDC_SEND_SELECT_FILE)
{
BSP_LCD_SetBackColor(LCD_COLOR_BLACK);
/* Change the selection type */
if(CdcSelectMode == CDC_SELECT_MENU)
{
CDC_ChangeSelectMode(CDC_SELECT_FILE);
}
else if(CdcSelectMode == CDC_SELECT_FILE)
{
LCD_ClearTextZone();
LCD_LOG_UpdateDisplay();
CDC_ChangeSelectMode(CDC_SELECT_MENU);
CdcDemo.Send_state = CDC_SEND_WAIT;
}
}
}
}
}
/**
* @brief Audio Play demo
* @param None
* @retval None
*/
void AudioPlay_demo (void)
{
uint32_t *AudioFreq_ptr;
uint8_t status = 0;
uint8_t FreqStr[256] = {0};
AudioFreq_ptr = AudioFreq+6; /*AF_48K*/
uwPauseEnabledStatus = 1; /* 0 when audio is running, 1 when Pause is on */
uwVolume = 50;
Audio_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()- 100, (uint8_t *)"ERROR", CENTER_MODE);
BSP_LCD_DisplayStringAt(0, BSP_LCD_GetYSize()- 85, (uint8_t *)"Joystick cannot be initialized", CENTER_MODE);
}
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, BSP_LCD_GetYSize()- 100, (uint8_t *)" AUDIO CODEC OK ", CENTER_MODE);
}
else
{
BSP_LCD_SetBackColor(LCD_COLOR_WHITE);
BSP_LCD_SetTextColor(LCD_COLOR_RED);
BSP_LCD_DisplayStringAt(0, BSP_LCD_GetYSize()- 100, (uint8_t *)" AUDIO CODEC FAIL ", CENTER_MODE);
BSP_LCD_DisplayStringAt(0, BSP_LCD_GetYSize()- 85, (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
(EVAL_AUDIO_TransferComplete_CallBack() or EVAL_AUDIO_HalfTransfer_CallBack()...
*/
AUDIO_Start();
/* Display the state on the screen */
BSP_LCD_SetBackColor(LCD_COLOR_WHITE);
BSP_LCD_SetTextColor(LCD_COLOR_BLUE);
BSP_LCD_DisplayStringAt(0, BSP_LCD_GetYSize()- 85, (uint8_t *)" PLAYING... ", CENTER_MODE);
sprintf((char*)FreqStr," VOL: %lu ",uwVolume);
BSP_LCD_DisplayStringAt(0, BSP_LCD_GetYSize()- 55, (uint8_t *)FreqStr, CENTER_MODE);
sprintf((char*)FreqStr," FREQ: %lu ",*AudioFreq_ptr);
BSP_LCD_DisplayStringAt(0, BSP_LCD_GetYSize()- 40, (uint8_t *)FreqStr, CENTER_MODE);
/* IMPORTANT:
AUDIO_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 Joystick State */
JoyState = BSP_JOY_GetState();
switch(JoyState)
{
case JOY_UP:
/* Increase volume by 5% */
if (uwVolume < 95)
uwVolume += 5;
else
uwVolume = 100;
sprintf((char*)FreqStr," VOL: %lu ",uwVolume);
BSP_AUDIO_OUT_SetVolume(uwVolume);
BSP_LCD_DisplayStringAt(0, BSP_LCD_GetYSize()- 55, (uint8_t *)FreqStr, CENTER_MODE);
BSP_LCD_DisplayStringAt(0, LINE(14), (uint8_t *)" ", CENTER_MODE);
break;
case JOY_DOWN:
/* Decrease volume by 5% */
if (uwVolume > 5)
uwVolume -= 5;
else
uwVolume = 0;
sprintf((char*)FreqStr," VOL: %lu ",uwVolume);
BSP_AUDIO_OUT_SetVolume(uwVolume);
BSP_LCD_DisplayStringAt(0, BSP_LCD_GetYSize()- 55, (uint8_t *)FreqStr, CENTER_MODE);
BSP_LCD_DisplayStringAt(0, LINE(14), (uint8_t *)" ", CENTER_MODE);
break;
case JOY_LEFT:
/*Decrease Frequency */
if (*AudioFreq_ptr != 8000)
{
AudioFreq_ptr--;
sprintf((char*)FreqStr," FREQ: %lu ", *AudioFreq_ptr);
BSP_AUDIO_OUT_Pause();
BSP_AUDIO_OUT_SetFrequency(*AudioFreq_ptr);
BSP_AUDIO_OUT_Resume();
}
BSP_LCD_DisplayStringAt(0, BSP_LCD_GetYSize()- 40, (uint8_t *)FreqStr, CENTER_MODE);
BSP_LCD_DisplayStringAt(0, LINE(14), (uint8_t *)" ", CENTER_MODE);
break;
case JOY_RIGHT:
/* Increase Frequency */
if (*AudioFreq_ptr != 96000)
{
AudioFreq_ptr++;
sprintf((char*)FreqStr," FREQ: %lu ",*AudioFreq_ptr);
BSP_AUDIO_OUT_Pause();
BSP_AUDIO_OUT_SetFrequency(*AudioFreq_ptr);
BSP_AUDIO_OUT_Resume();
}
BSP_LCD_DisplayStringAt(0, BSP_LCD_GetYSize()- 40, (uint8_t *)FreqStr, CENTER_MODE);
BSP_LCD_DisplayStringAt(0, LINE(14), (uint8_t *)" ", CENTER_MODE);
break;
case JOY_SEL:
/* Set Pause / Resume */
if (uwPauseEnabledStatus == 1)
{ /* Pause is enabled, call Resume */
BSP_AUDIO_OUT_Resume();
uwPauseEnabledStatus = 0;
BSP_LCD_DisplayStringAt(0, BSP_LCD_GetYSize()- 85, (uint8_t *)" PLAYING... ", CENTER_MODE);
} else
{ /* Pause the playback */
BSP_AUDIO_OUT_Pause();
uwPauseEnabledStatus = 1;
BSP_LCD_DisplayStringAt(0, BSP_LCD_GetYSize()- 85, (uint8_t *)" PAUSE ... ", CENTER_MODE);
}
BSP_LCD_DisplayStringAt(0, LINE(14), (uint8_t *)" ", CENTER_MODE);
HAL_Delay(200);
break;
default:
break;
}
/* Toggle LED3 */
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)
{
BSP_AUDIO_OUT_Stop(CODEC_PDWN_SW);
BSP_AUDIO_OUT_DeInit();
return;
}
}
}
/**
* @brief Displays on TFT Images or error messages when error occurred.
* @param None
* @retval None
*/
static void TFT_DisplayImages(void)
{
uint32_t bmplen = 0x00;
uint32_t checkstatus = 0x00;
uint32_t filesnumbers = 0x00;
uint32_t joystickstatus = JOY_NONE;
uint32_t bmpcounter = 0x00;
DIR directory;
FRESULT res;
/* Initialize the Joystick available on adafruit 1.8" TFT shield */
BSP_JOY_Init();
/* Welcome message */
TFT_DisplayMenu();
/* Open directory */
res = f_opendir(&directory, "/");
if((res != FR_OK))
{
if(res == FR_NO_FILESYSTEM)
{
/* Display message: SD card not FAT formated */
TFT_DisplayErrorMessage(SD_CARD_NOT_FORMATTED);
}
else
{
/* Display message: Fail to open directory */
TFT_DisplayErrorMessage(SD_CARD_OPEN_FAIL);
}
}
/* Get number of bitmap files */
filesnumbers = Storage_GetDirectoryBitmapFiles ("/", pDirectoryFiles);
/* Set bitmap counter to display first image */
bmpcounter = 1;
while (1)
{
/* Get JoyStick status */
joystickstatus = BSP_JOY_GetState();
if(joystickstatus == JOY_SEL)
{
JoystickValue++;
if (JoystickValue > 2)
{
JoystickValue = 1;
}
joystickstatus = JOY_NONE;
}
/*## Display BMP pictures in Automatic mode ##############################*/
if(JoystickValue == 1)
{
sprintf((char*)str, "%-11.11s", pDirectoryFiles[bmpcounter -1]);
checkstatus = Storage_CheckBitmapFile((const char*)str, &bmplen);
if(checkstatus == 0)
{
/* Format the string */
checkstatus = Storage_OpenReadFile(POSITION_X_BITMAP, POSITION_Y_BITMAP, (const char*)str);
}
if (checkstatus == 1)
{
/* Display message: File not supported */
TFT_DisplayErrorMessage(SD_CARD_FILE_NOT_SUPPORTED);
}
bmpcounter++;
if(bmpcounter > filesnumbers)
{
bmpcounter = 1;
}
}
/*## Display BMP pictures in Manual mode #################################*/
if(JoystickValue == 2)
{
if(joystickstatus == JOY_RIGHT)
{
if((bmpcounter + 1) > filesnumbers)
{
bmpcounter = 1;
}
else
{
bmpcounter++;
}
sprintf ((char*)str, "%-11.11s", pDirectoryFiles[bmpcounter - 1]);
checkstatus = Storage_CheckBitmapFile((const char*)str, &bmplen);
if(checkstatus == 0)
{
/* Format the string */
Storage_OpenReadFile(POSITION_X_BITMAP, POSITION_Y_BITMAP, (const char*)str);
}
if(checkstatus == 1)
{
/* Display message: File not supported */
TFT_DisplayErrorMessage(SD_CARD_FILE_NOT_SUPPORTED);
}
joystickstatus = JOY_NONE;
JoystickValue = 2;
}
else if(joystickstatus == JOY_LEFT)
{
if((bmpcounter - 1) == 0)
{
bmpcounter = filesnumbers;
}
else
{
bmpcounter--;
}
sprintf ((char*)str, "%-11.11s", pDirectoryFiles[bmpcounter - 1]);
checkstatus = Storage_CheckBitmapFile((const char*)str, &bmplen);
if(checkstatus == 0)
{
/* Format the string */
Storage_OpenReadFile(POSITION_X_BITMAP, POSITION_Y_BITMAP, (const char*)str);
}
if (checkstatus == 1)
{
/* Display message: File not supported */
TFT_DisplayErrorMessage(SD_CARD_FILE_NOT_SUPPORTED);
}
joystickstatus = JOY_NONE;
JoystickValue = 2;
}
}
}
}
/**
* @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 EXTI line detection callbacks
* @param GPIO_Pin: Specifies the pins connected EXTI line
* @retval None
*/
void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{
uint32_t ITstatus = 0;
JOYState_TypeDef JoyState = JOY_NONE;
if(GPIO_Pin == TAMPER_BUTTON_PIN)
{
/* Toggle GREEN LED1 */
BSP_LED_Toggle(LED1);
DestinationAddress = MyFollowerAddress1;
TxSize = 0x0; /* no payload, ping only */
StartSending = 1;
}
if(GPIO_Pin == MFX_IRQOUT_PIN) /* Interrupt received from MFX */
{
/* The different functionalities of MFX (TS, Joystick, SD detection, etc. )
can be configured in exti mode to generate an IRQ on given events.
The MFX IRQ_OUT pin is unique and common to all functionalities, so if several
functionalities are configured in exit mode, the MCU has to enquire MFX about
the IRQ source (see BSP_IO_ITGetStatus). Communication with Mfx is done by I2C.
Often the sw requires ISRs (irq service routines) to be quick while communication
with I2C can be considered relatively long (hundreds of usec depending on I2C clk).
Considering that the features for human interaction like TS, Joystick, SD detection
don’t need immediate reaction, it is suggested to use POLLING instead of EXTI mode,
in order to avoid "blocking I2C communication" on interrupt service routines */
ITstatus = BSP_IO_ITGetStatus(JOY_ALL_PINS);
if (ITstatus) /* Checks if interrupt comes from joystick */
{
/* Get the Joystick State */
JoyState = BSP_JOY_GetState();
if(JoyState == JOY_UP)
{
/* Toggle RED LED3 */
BSP_LED_Toggle(LED3);
}
if(JoyState == JOY_DOWN)
{
/* Toggle BLUE LED4 */
BSP_LED_Toggle(LED4);
#if defined (DEVICE_1)
DestinationAddress = MyFollowerAddress2;
#elif defined (DEVICE_2)
DestinationAddress = MyFollowerAddress1;
#endif /* DEVICE_1 */
TxSize = 0x0; /* no payload, ping only */
StartSending = 1;
}
if(JoyState == JOY_SEL)
{
/* Toggle ORANGE LED2 */
BSP_LED_Toggle(LED2);
DestinationAddress = 0xF; /* broadcast message indicator */
TxSize = 0x0; /* no payload, ping only */
StartSending = 1;
}
}
BSP_IO_ITClear();
}
}
/**
* @brief EXTI line detection callbacks.
* @param GPIO_Pin: Specifies the pins connected EXTI line
* @retval None
*/
void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{
static JOYState_TypeDef JoyState = JOY_NONE;
static uint32_t debounce_time = 0;
if(GPIO_Pin == GPIO_PIN_8)
{
/* Get the Joystick State */
JoyState = BSP_JOY_GetState();
HAL_Delay(200);
/* Clear joystick interrupt pending bits */
BSP_IO_ITClear();
if(Appli_state == APPLICATION_MSC)
{
MSC_DEMO_ProbeKey(JoyState);
}
else if(Appli_state == APPLICATION_HID)
{
HID_DEMO_ProbeKey(JoyState);
}
else if(Appli_state == APPLICATION_AUDIO)
{
if(audio_select_mode == AUDIO_SELECT_MENU)
{
AUDIO_MenuProbeKey(JoyState);
}
else if(audio_select_mode == AUDIO_PLAYBACK_CONTROL)
{
AUDIO_PlaybackProbeKey(JoyState);
}
}
switch(JoyState)
{
case JOY_LEFT:
LCD_LOG_ScrollBack();
break;
case JOY_RIGHT:
LCD_LOG_ScrollForward();
break;
default:
break;
}
}
if(audio_demo.state == AUDIO_DEMO_PLAYBACK)
{
if(GPIO_Pin == KEY_BUTTON_PIN)
{
/* Prevent debounce effect for user key */
if((HAL_GetTick() - debounce_time) > 50)
{
debounce_time = HAL_GetTick();
}
else
{
return;
}
/* Change the selection type */
if(audio_select_mode == AUDIO_SELECT_MENU)
{
Audio_ChangeSelectMode(AUDIO_PLAYBACK_CONTROL);
}
else if(audio_select_mode == AUDIO_PLAYBACK_CONTROL)
{
Audio_ChangeSelectMode(AUDIO_SELECT_MENU);
}
}
}
}
/**
* @brief Audio Play demo
* @param None
* @retval None
*/
void AudioRec_demo (void)
{
uint16_t NbRecord_done = 0;
uint8_t FreqStr[256] = {0};
AudioRec_State = REC_NONE_STATE;
buffer_ctl.rec_length = 0;
/* Initialize AudioRecFullBuff at the address of the audio_play reader */
AudioRecFullBuff_addr = AUDIO_REC_START_ADDR;
AudioRec_SetHint();
#ifdef JOYSTICK
/* Initialize Joystick */
if (BSP_JOY_Init(JOY_MODE_GPIO) != 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);
}
#endif
/* Initialize Audio Recorder */
if (BSP_AUDIO_IN_Init(DEFAULT_AUDIO_IN_FREQ, DEFAULT_AUDIO_IN_BIT_RESOLUTION, DEFAULT_AUDIO_IN_CHANNEL_NBR) == AUDIO_OK)
{
AudioRec_State = REC_RESET_STATE;
BSP_LCD_SetBackColor(LCD_COLOR_WHITE);
BSP_LCD_SetTextColor(LCD_COLOR_GREEN);
BSP_LCD_DisplayStringAt(0, BSP_LCD_GetYSize() - 95, (uint8_t *)" AUDIO RECORD INIT OK ", CENTER_MODE);
}
else
{
AudioRec_State = REC_ERROR_STATE;
BSP_LCD_SetBackColor(LCD_COLOR_WHITE);
BSP_LCD_SetTextColor(LCD_COLOR_RED);
BSP_LCD_DisplayStringAt(0, BSP_LCD_GetYSize() - 95, (uint8_t *)" AUDIO RECORD INIT FAIL", CENTER_MODE);
BSP_LCD_DisplayStringAt(0, BSP_LCD_GetYSize() - 80, (uint8_t *)" Try to reset board ", CENTER_MODE);
}
/* Infinite loop */
while (buffer_ctl.rec_length < AUDIO_REC_TOTAL_SIZE)
{
BSP_LCD_SetBackColor(LCD_COLOR_WHITE);
BSP_LCD_SetTextColor(LCD_COLOR_BLUE);
if (buffer_ctl.it_state == TRANSFER_HALF)
{
/* PDM to PCM data convert */
BSP_AUDIO_IN_PDMToPCM((uint16_t*)&buffer_ctl.pdm_buff[0],
&buffer_ctl.pcm_buff[buffer_ctl.pcm_ptr]);
buffer_ctl.pcm_ptr+= AUDIO_IN_PDM_BUFFER_SIZE/4/2;
if(buffer_ctl.pcm_ptr == AUDIO_IN_PCM_BUFFER_SIZE/2)
{
buffer_ctl.wr_state = BUFFER_FULL;
buffer_ctl.offset = 0;
}
if(buffer_ctl.pcm_ptr >= AUDIO_IN_PCM_BUFFER_SIZE)
{
buffer_ctl.wr_state = BUFFER_FULL;
buffer_ctl.offset = AUDIO_IN_PCM_BUFFER_SIZE/2;
buffer_ctl.pcm_ptr = 0;
}
buffer_ctl.it_state = TRANSFER_NONE;
}
if (buffer_ctl.it_state == TRANSFER_FULL)
{
/* PDM to PCM data convert */
if (BSP_AUDIO_IN_PDMToPCM((uint16_t*)&buffer_ctl.pdm_buff[INTERNAL_BUFF_SIZE/2], &buffer_ctl.pcm_buff[buffer_ctl.pcm_ptr]) == 0)
{
buffer_ctl.pcm_ptr+= AUDIO_IN_PDM_BUFFER_SIZE/4/2;
if(buffer_ctl.pcm_ptr == AUDIO_IN_PCM_BUFFER_SIZE/2)
{
buffer_ctl.wr_state = BUFFER_FULL;
buffer_ctl.offset = 0;
}
if(buffer_ctl.pcm_ptr >= AUDIO_IN_PCM_BUFFER_SIZE)
{
buffer_ctl.wr_state = BUFFER_FULL;
buffer_ctl.offset = AUDIO_IN_PCM_BUFFER_SIZE/2;
buffer_ctl.pcm_ptr = 0;
}
}
buffer_ctl.it_state = TRANSFER_NONE;
NbRecord_done++;
}
/* PCM buffer is full, copy it into the record_file */
if (buffer_ctl.wr_state == BUFFER_FULL)
{
memcpy((uint32_t *)AudioRecFullBuff_addr, (uint8_t*)(buffer_ctl.pcm_buff + buffer_ctl.offset), AUDIO_IN_PCM_BUFFER_SIZE);
AudioRecFullBuff_addr += AUDIO_IN_PCM_BUFFER_SIZE;
buffer_ctl.rec_length += AUDIO_IN_PCM_BUFFER_SIZE;
buffer_ctl.wr_state = BUFFER_EMPTY;
}
#ifdef JOYSTICK
/* Get the Joystick State */
JoyState = BSP_JOY_GetState();
switch (JoyState)
{
case JOY_SEL:
#endif
if (AudioRec_State == REC_RESET_STATE)
{
/* Display the state on the screen */
BSP_LCD_SetBackColor(LCD_COLOR_WHITE);
BSP_LCD_SetTextColor(LCD_COLOR_BLUE);
BSP_LCD_DisplayStringAt(0, BSP_LCD_GetYSize() - 80, (uint8_t *)" RECORDING... ", CENTER_MODE);
/* Start Recording */
buffer_ctl.rec_length = 0;
buffer_ctl.wr_state = BUFFER_EMPTY;
buffer_ctl.it_state = TRANSFER_NONE;
BSP_AUDIO_IN_Record((uint16_t*)&buffer_ctl.pdm_buff[0], INTERNAL_BUFF_SIZE);
AudioRec_State = RECORD_ONGOING;
}
#ifdef JOYSTICK
break;
default:
break;
}
#endif
if (CheckForUserInput() > 0)
{
/* Stop recorder and exit the test (go to next test) */
BSP_AUDIO_IN_Stop();
return;
}
}
/* Stop recorder once buffer_ctl.rec_length < AUDIO_REC_TOTAL_SIZE*/
BSP_AUDIO_IN_Stop();
BSP_LCD_SetBackColor(LCD_COLOR_WHITE);
BSP_LCD_SetTextColor(LCD_COLOR_BLUE);
sprintf((char*)FreqStr, "RECORDING DONE, %d frames, START PLAYBACK", NbRecord_done);
BSP_LCD_DisplayStringAt(0, BSP_LCD_GetYSize() - 65, (uint8_t *)FreqStr, CENTER_MODE);
NbRecord_done = buffer_ctl.rec_length / (DEFAULT_AUDIO_IN_FREQ * DEFAULT_AUDIO_IN_CHANNEL_NBR * 2);
sprintf((char*)FreqStr, "Elapsed_time: %d frames", NbRecord_done);
BSP_LCD_DisplayStringAt(0, BSP_LCD_GetYSize() - 45, (uint8_t *)FreqStr, CENTER_MODE);
/* -----------Start Playback -------------- */
/* Initialize audio IN at REC_FREQ*/
if(BSP_AUDIO_OUT_Init(OUTPUT_DEVICE_HEADPHONE, 95, DEFAULT_AUDIO_IN_FREQ/2) == 0)
{
BSP_LCD_SetBackColor(LCD_COLOR_WHITE);
BSP_LCD_SetTextColor(LCD_COLOR_GREEN);
BSP_LCD_DisplayStringAt(0, BSP_LCD_GetYSize() - 95, (uint8_t *)" AUDIO CODEC OK ", CENTER_MODE);
}
else
{
BSP_LCD_SetBackColor(LCD_COLOR_WHITE);
BSP_LCD_SetTextColor(LCD_COLOR_RED);
BSP_LCD_DisplayStringAt(0, BSP_LCD_GetYSize() - 95, (uint8_t *)" AUDIO CODEC FAIL ", CENTER_MODE);
BSP_LCD_DisplayStringAt(0, BSP_LCD_GetYSize() - 80, (uint8_t *)" Try to reset board ", CENTER_MODE);
}
/* Play the recorded buffer*/
if(AUDIO_Play_Start((uint32_t *)AUDIO_REC_START_ADDR, (uint32_t)AUDIO_REC_TOTAL_SIZE) == 0)
{
BSP_LCD_SetBackColor(LCD_COLOR_WHITE);
BSP_LCD_SetTextColor(LCD_COLOR_GREEN);
BSP_LCD_DisplayStringAt(0, BSP_LCD_GetYSize() - 95, (uint8_t *)" AUDIO PLAYBACK OK ", CENTER_MODE);
} else
{
BSP_LCD_SetBackColor(LCD_COLOR_WHITE);
BSP_LCD_SetTextColor(LCD_COLOR_RED);
BSP_LCD_DisplayStringAt(0, BSP_LCD_GetYSize() - 95, (uint8_t *)" AUDIO PLAYBACK FAIL ", CENTER_MODE);
}
BSP_LCD_DisplayStringAt(0, BSP_LCD_GetYSize() - 25, (uint8_t *)"PLAYBACK DONE", CENTER_MODE);
while (1)
{
/* Toggle LED4 */
BSP_LED_Toggle(LED4);
/* Insert 100 ms delay */
HAL_Delay(100);
if (CheckForUserInput() > 0)
{
/* Set LED4 */
BSP_LED_On(LED4);
/* Stop recorder */
BSP_AUDIO_IN_Stop();
/* Stop Player before close Test */
BSP_AUDIO_OUT_Stop(CODEC_PDWN_SW);
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 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 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 Camera demo
* @param None
* @retval None
*/
void Camera_demo (void)
{
uint8_t status = 0;
uint32_t exit = 0;
uint32_t camera_status = CAMERA_OK;
uint32_t argb8888_Value = 0x00556677;
Camera_SetHint();
/* Activate joystick as used for contrast, brightness and visual effect settings */
/* on image from camera sensor */
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() - 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);
}
/*## 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);
CameraResIndex = CAMERA_R160x120; /* Set QQVGA default resolution */
CameraChangeResolutionAsked = 1;
CameraResX = CAMERA_QQVGA_RES_X;
CameraResY = CAMERA_QQVGA_RES_Y;
/* 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 */
refresh_authorized = 0;
camera_status = BSP_CAMERA_Stop();
BSP_TEST_APPLI_ASSERT(camera_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);
switch (CameraResIndex)
{
case CAMERA_R160x120:
CameraResX = CAMERA_QQVGA_RES_X;
CameraResY = CAMERA_QQVGA_RES_Y;
/* Initialize the Camera */
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:
CameraResX = CAMERA_QVGA_RES_X;
CameraResY = CAMERA_QVGA_RES_Y;
/* Initialize the Camera */
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;
case CAMERA_R480x272:
CameraResX = CAMERA_480x272_RES_X;
CameraResY = CAMERA_480x272_RES_Y;
/* Initialize the Camera */
camera_status = BSP_CAMERA_Init(RESOLUTION_R480x272);
BSP_LCD_DisplayStringAt(0, BSP_LCD_GetYSize() - CAMERA_STATUS_TEXT_POS, (uint8_t *)" 480x272 camera stream ", CENTER_MODE);
break;
case CAMERA_R640x480:
CameraResX = CAMERA_VGA_RES_X;
CameraResY = CAMERA_VGA_RES_Y;
/* Initialize the Camera */
camera_status = BSP_CAMERA_Init(RESOLUTION_R640x480);
BSP_LCD_DisplayStringAt(0, BSP_LCD_GetYSize() - CAMERA_STATUS_TEXT_POS, (uint8_t *)" VGA camera stream ", CENTER_MODE);
break;
default :
break;
}
if (camera_status != CAMERA_OK)
{
BSP_LCD_DisplayStringAt(0, BSP_LCD_GetYSize() - CAMERA_STATUS_TEXT_POS - 15, (uint8_t *)" CAMERA INIT ERROR ", CENTER_MODE);
}
offset_cam = 0;
offset_lcd = 0;
display_line_counter = 0;
display_rotated_line_counter = 0;
special_effect = CAMERA_BLACK_WHITE; /* No special effect applied */
color_effect = CAMERA_BLACK_WHITE_NORMAL;
contrast = CAMERA_CONTRAST_LEVEL2; /* Mid-level brightness */
brightness = CAMERA_BRIGHTNESS_LEVEL2; /* Mid-level contrast */
refresh_authorized = 1;
CameraFrameBufferInitComplete = 0;
CameraFrameBufferInitError = 0;
if(CameraResIndex == CAMERA_R640x480)
{
/* Clear first the LCD */
BSP_LCD_Clear(LCD_COLOR_WHITE);
}
/* Init or Re-Init Camera frame buffer by using DMA2D engine in mode Register to Memory */
camera_status = CameraFrameBufferRgb565_Init(CAMERA_VGA_RES_X,
CAMERA_VGA_RES_Y,
argb8888_Value);
BSP_TEST_APPLI_ASSERT(camera_status != CAMERA_OK);
/* Wait end of DMA2D operation of error : via IT callback update */
while((CameraFrameBufferInitComplete == 0) && (CameraFrameBufferInitError == 0)) {;}
/* Assert if error : no transfer complete */
BSP_TEST_APPLI_ASSERT(CameraFrameBufferInitComplete != 1);
/* Start / Restart camera stream */
BSP_CAMERA_ContinuousStart((uint8_t *)CAMERA_FB_START_ADDR);
/* Allow DMA2D copy from Camera frame buffer to LCD Frame buffer location */
Camera_AllowDma2dCopyCamFrmBuffToLcdFrmBuff = 1;
} /* (CameraResIndex != CameraCurrentResIndex) */
/* Get the Joystick State */
JoyState = BSP_JOY_GetState();
switch (JoyState)
{
case JOY_UP:
if (brightness < CAMERA_BRIGHTNESS_MAX)
{
brightness++;
}
else
{
JoyState = JOY_NONE; /* Cancel brightness change */
}
break;
case JOY_DOWN:
if (brightness > CAMERA_BRIGHTNESS_MIN)
{
brightness--;
}
else
{
JoyState = JOY_NONE; /* Cancel brightness change */
}
break;
case JOY_LEFT:
if (contrast > CAMERA_CONTRAST_MIN)
{
contrast--;
}
else
{
JoyState = JOY_NONE; /* Cancel contrast change */
}
break;
case JOY_RIGHT:
if (contrast < CAMERA_CONTRAST_MAX)
{
contrast++;
}
else
{
JoyState = JOY_NONE; /* Cancel contrast change */
}
break;
case JOY_SEL:
switch (special_effect)
{
case CAMERA_BLACK_WHITE :
if (color_effect < CAMERA_BLACK_WHITE_NORMAL)
{
/* From BW effect to another BW effect */
color_effect++;
}
else
{
/* From BW or none effect to color effect */
special_effect = CAMERA_COLOR_EFFECT;
color_effect = CAMERA_COLOR_EFFECT_ANTIQUE;
}
break;
case CAMERA_COLOR_EFFECT :
if (color_effect < CAMERA_COLOR_EFFECT_RED)
{
/* From color effect to another color effect */
color_effect++;
}
else
{
/* From color effect to BW effect */
special_effect = CAMERA_BLACK_WHITE;
color_effect = CAMERA_BLACK_WHITE_BW;
}
break;
default :
/* None effect */
special_effect = CAMERA_BLACK_WHITE;
color_effect = CAMERA_BLACK_WHITE_NORMAL;
break;
}
break;
default:
break;
}
if ((JoyState == JOY_UP) || (JoyState == JOY_DOWN) || (JoyState == JOY_LEFT) || (JoyState == JOY_RIGHT))
{
/* A brightness change has been asked */
BSP_CAMERA_ContrastBrightnessConfig(contrast, brightness);
if ((JoyState == JOY_UP) || (JoyState == JOY_DOWN))
{
BSP_LCD_DisplayStringAt(0, BSP_LCD_GetYSize() - CAMERA_STATUS_TEXT_POS, (uint8_t *)" Brightness change ", CENTER_MODE);
}
else
{
BSP_LCD_DisplayStringAt(0, BSP_LCD_GetYSize() - CAMERA_STATUS_TEXT_POS, (uint8_t *)" Contrast change ", CENTER_MODE);
}
}
if (JoyState == JOY_SEL)
{
/* A color effect change has been asked */
switch (special_effect)
{
case CAMERA_BLACK_WHITE :
BSP_CAMERA_BlackWhiteConfig(color_effect);
switch (color_effect)
{
case CAMERA_BLACK_WHITE_NORMAL :
BSP_LCD_DisplayStringAt(0, BSP_LCD_GetYSize() - CAMERA_STATUS_TEXT_POS, (uint8_t *)" No effect applied ", CENTER_MODE);
break;
case CAMERA_BLACK_WHITE_BW :
BSP_LCD_DisplayStringAt(0, BSP_LCD_GetYSize() - CAMERA_STATUS_TEXT_POS, (uint8_t *)" Black and white effect applied ", CENTER_MODE);
break;
case CAMERA_BLACK_WHITE_NEGATIVE :
BSP_LCD_DisplayStringAt(0, BSP_LCD_GetYSize() - CAMERA_STATUS_TEXT_POS, (uint8_t *)" Negative effect applied ", CENTER_MODE);
break;
case CAMERA_BLACK_WHITE_BW_NEGATIVE :
BSP_LCD_DisplayStringAt(0, BSP_LCD_GetYSize() - CAMERA_STATUS_TEXT_POS, (uint8_t *)" BW negative effect applied ", CENTER_MODE);
break;
}
break;
case CAMERA_COLOR_EFFECT :
BSP_CAMERA_ColorEffectConfig(color_effect);
switch (color_effect)
{
case CAMERA_COLOR_EFFECT_ANTIQUE :
BSP_LCD_DisplayStringAt(0, BSP_LCD_GetYSize() - CAMERA_STATUS_TEXT_POS, (uint8_t *)" Sepia color effect applied ", CENTER_MODE);
break;
case CAMERA_COLOR_EFFECT_BLUE :
BSP_LCD_DisplayStringAt(0, BSP_LCD_GetYSize() - CAMERA_STATUS_TEXT_POS, (uint8_t *)" Blue color effect applied ", CENTER_MODE);
break;
case CAMERA_COLOR_EFFECT_GREEN :
BSP_LCD_DisplayStringAt(0, BSP_LCD_GetYSize() - CAMERA_STATUS_TEXT_POS, (uint8_t *)" Green color effect applied ", CENTER_MODE);
break;
case CAMERA_COLOR_EFFECT_RED :
BSP_LCD_DisplayStringAt(0, BSP_LCD_GetYSize() - CAMERA_STATUS_TEXT_POS, (uint8_t *)" Red color effect applied ", CENTER_MODE);
break;
}
break;
}
}
/* 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;
/* Disallow DMA2D copy from Camera frame buffer to LCD Frame buffer location */
Camera_AllowDma2dCopyCamFrmBuffToLcdFrmBuff = 0;
/* Insert 10 ms delay */
HAL_Delay(10);
}
else
{
BSP_CAMERA_DeInit();
exit = 1;
}
}
}
/* Stop camera stream */
camera_status = BSP_CAMERA_Stop();
BSP_TEST_APPLI_ASSERT(camera_status != CAMERA_OK);
/* End of camera demo */
}
