/**
* @brief Wait For Pressed State
* @param Pressed: Pressed State
* @retval None
*/
static void WaitForPressedState(uint8_t Pressed)
{
TS_StateTypeDef State;
do
{
BSP_TS_GetState(&State);
HAL_Delay(10);
if (State.TouchDetected == Pressed)
{
uint16_t TimeStart = HAL_GetTick();
do {
BSP_TS_GetState(&State);
HAL_Delay(10);
if (State.TouchDetected != Pressed)
{
break;
} else if ((HAL_GetTick() - 100) > TimeStart)
{
return;
}
} while (1);
}
} while (1);
}
/**
* @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)
{
TS_StateTypeDef TS_State;
if(GPIO_Pin == TS_INT_PIN)
{
BSP_TS_GetState(&TS_State);
if(TS_State.touchDetected)
{
if (TS_State.touchY[0] < 30)
{
/* Top of the screen touch detected */
BSP_LCD_SetTextColor(LCD_COLOR_WHITE);
BSP_LCD_SetBackColor(LCD_COLOR_BLUE);
BSP_LCD_DisplayStringAt(0, (BSP_LCD_GetYSize()/2)+15, (uint8_t *)" Send opcode 44, operand 41 ", CENTER_MODE);
Tab_Tx[0] = 0x44;
Tab_Tx[1] = 0x41;
TxSize = 0x02;
StartSending = 1;
}
else if (TS_State.touchY[0] > (BSP_LCD_GetYSize() - 30))
{
/* Bottom of the screen touch detected */
BSP_LCD_SetTextColor(LCD_COLOR_WHITE);
BSP_LCD_SetBackColor(LCD_COLOR_GREEN);
BSP_LCD_DisplayStringAt(0, (BSP_LCD_GetYSize()/2)+15, (uint8_t *)" Send opcode 44, operand 42 ", CENTER_MODE);
Tab_Tx[0] = 0x44;
Tab_Tx[1] = 0x42;
TxSize = 0x02;
StartSending = 1;
}
else if (TS_State.touchX[0] < 30)
{
/* Left of the screen touch detected */
BSP_LCD_SetTextColor(LCD_COLOR_WHITE);
BSP_LCD_SetBackColor(LCD_COLOR_ORANGE);
BSP_LCD_DisplayStringAt(0, (BSP_LCD_GetYSize()/2)+15, (uint8_t *)" Send opcode 46 ", CENTER_MODE);
Tab_Tx[0] = 0x46;
TxSize = 0x01;
StartSending = 1;
}
else if (TS_State.touchX[0] > (BSP_LCD_GetXSize() - 30))
{
/* Right of the screen touch detected */
BSP_LCD_SetTextColor(LCD_COLOR_WHITE);
BSP_LCD_SetBackColor(LCD_COLOR_DARKMAGENTA);
BSP_LCD_DisplayStringAt(0, (BSP_LCD_GetYSize()/2)+15, (uint8_t *)" Send opcode 9F ", CENTER_MODE);
Tab_Tx[0] = 0x9F;
TxSize = 0x01;
StartSending = 1;
}
/* Wait for touch screen no touch detected */
do
{
BSP_TS_GetState(&TS_State);
}while(TS_State.touchDetected > 0);
}
}
}
/**
* @brief Test touch screen state and modify audio state machine according to that
* @param None
* @retval None
*/
static void AUDIO_AcquireTouchButtons(void)
{
static TS_StateTypeDef TS_State= {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_PAUSE_XMIN) && (TS_State.touchX[0] < TOUCH_PAUSE_XMAX) &&
(TS_State.touchY[0] > TOUCH_PAUSE_YMIN) && (TS_State.touchY[0] < TOUCH_PAUSE_YMAX))
{
if (AudioState == AUDIO_STATE_PLAY)
{
AudioState = AUDIO_STATE_PAUSE;
}
else
{
AudioState = AUDIO_STATE_RESUME;
}
}
else if ((TS_State.touchX[0] > TOUCH_NEXT_XMIN) && (TS_State.touchX[0] < TOUCH_NEXT_XMAX) &&
(TS_State.touchY[0] > TOUCH_NEXT_YMIN) && (TS_State.touchY[0] < TOUCH_NEXT_YMAX))
{
AudioState = AUDIO_STATE_NEXT;
}
else if ((TS_State.touchX[0] > TOUCH_PREVIOUS_XMIN) && (TS_State.touchX[0] < TOUCH_PREVIOUS_XMAX) &&
(TS_State.touchY[0] > TOUCH_PREVIOUS_YMIN) && (TS_State.touchY[0] < TOUCH_PREVIOUS_YMAX))
{
AudioState = AUDIO_STATE_PREVIOUS;
}
else 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_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;
}
}
}
}
/**
* @brief Provide the GUI with current state of the touch screen
* @param None
* @retval None
*/
void BSP_Pointer_Update(void)
{
GUI_PID_STATE TS_State;
static TS_StateTypeDef prev_state;
TS_StateTypeDef ts;
uint16_t xDiff, yDiff;
BSP_TS_GetState(&ts);
TS_State.Pressed = ts.TouchDetected;
xDiff = (prev_state.x > ts.x) ? (prev_state.x - ts.x) : (ts.x - prev_state.x);
yDiff = (prev_state.y > ts.y) ? (prev_state.y - ts.y) : (ts.y - prev_state.y);
if(ts.TouchDetected)
{
if((prev_state.TouchDetected != ts.TouchDetected )||
(xDiff > 3 )||
(yDiff > 3))
{
prev_state = ts;
TS_State.Layer = 0;
TS_State.x = ts.x;
TS_State.y = ts.y;
GUI_TOUCH_StoreStateEx(&TS_State);
}
}
}
/**
* @brief Provide the GUI with current state of the touch screen
* @param None
* @retval None
*/
void BSP_Pointer_Update(void)
{
GUI_PID_STATE TS_State;
static TS_StateTypeDef prev_state;
TS_StateTypeDef ts;
uint16_t xDiff, yDiff;
BSP_TS_GetState(&ts);
TS_State.Pressed = ts.TouchDetected;
xDiff = (prev_state.x > ts.x) ? (prev_state.x - ts.x) : (ts.x - prev_state.x);
yDiff = (prev_state.y > ts.y) ? (prev_state.y - ts.y) : (ts.y - prev_state.y);
if((prev_state.TouchDetected != ts.TouchDetected )||
(xDiff > 3 )||
(yDiff > 3))
{
prev_state.TouchDetected = ts.TouchDetected;
if((ts.x != 0) && (ts.y != 0))
{
prev_state.x = ts.x;
prev_state.y = ts.y;
}
if(CALIBRATION_IsDone())
{
TS_State.Layer = 0;
TS_State.x = CALIBRATION_GetX (prev_state.x);
TS_State.y = CALIBRATION_GetY (prev_state.y);
}
else
{
TS_State.Layer = 0;
TS_State.x = prev_state.x;
TS_State.y = prev_state.y;
}
GUI_TOUCH_StoreStateEx(&TS_State);
}
}
/**
* @brief Provide the GUI with current state of the touch screen
* @param None
* @retval None
*/
void BSP_Pointer_Update(void)
{
GUI_PID_STATE TS_State;
static TS_StateTypeDef prev_state;
TS_StateTypeDef ts;
uint16_t xDiff, yDiff;
BSP_TS_GetState(&ts);
TS_State.Pressed = ts.TouchDetected;
xDiff = (prev_state.X > ts.X) ? (prev_state.X - ts.X) : (ts.X - prev_state.X);
yDiff = (prev_state.Y > ts.Y) ? (prev_state.Y - ts.Y) : (ts.Y - prev_state.Y);
if((prev_state.TouchDetected != ts.TouchDetected )||
(xDiff > 3 )||
(yDiff > 3))
{
prev_state.TouchDetected = ts.TouchDetected;
if((ts.X != 0) && (ts.Y != 0))
{
prev_state.X = ts.X;
prev_state.Y = ts.Y;
}
if(CALIBRATION_IsDone())
{
TS_State.Layer = 0;
TS_State.x = CALIBRATION_GetX (prev_state.X);
TS_State.y = CALIBRATION_GetY (prev_state.Y);
}
else
{
TS_State.Layer = 0;
TS_State.x = prev_state.X;
TS_State.y = prev_state.Y;
}
GUI_TOUCH_StoreStateEx(&TS_State);
}
}
/**
* @brief Read the coordinate of the point touched and assign their
* value to the variables u32_TSXCoordinate and u32_TSYCoordinate
* @param None
* @retval None
*/
void k_TouchUpdate(void)
{
GUI_PID_STATE TS_State;
static TS_StateTypeDef prev_state;
__IO TS_StateTypeDef ts;
uint16_t xDiff, yDiff;
BSP_TS_GetState((TS_StateTypeDef *)&ts);
TS_State.Pressed = ts.TouchDetected;
xDiff = (prev_state.x > ts.x) ? (prev_state.x - ts.x) : (ts.x - prev_state.x);
yDiff = (prev_state.y > ts.y) ? (prev_state.y - ts.y) : (ts.y - prev_state.y);
if((prev_state.TouchDetected != ts.TouchDetected )||
(xDiff > 3 )||
(yDiff > 3))
{
prev_state.TouchDetected = ts.TouchDetected;
if((ts.x != 0) && (ts.y != 0))
{
prev_state.x = ts.x;
prev_state.y = ts.y;
}
if(k_CalibrationIsDone())
{
TS_State.Layer = 0;
TS_State.x = k_CalibrationGetX (prev_state.x);
TS_State.y = k_CalibrationGetY (prev_state.y);
}
else
{
TS_State.Layer = 0;
TS_State.x = prev_state.x;
TS_State.y = prev_state.y;
}
GUI_TOUCH_StoreStateEx(&TS_State);
}
}
/**
* @brief Get Physical position
* @param LogX : logical X position
* @param LogY : logical Y position
* @param pPhysX : Physical X position
* @param pPhysY : Physical Y position
* @retval None
*/
static void GetPhysValues(int16_t LogX, int16_t LogY, int16_t * pPhysX, int16_t * pPhysY)
{
/* Draw the ring */
BSP_LCD_SetTextColor(LCD_COLOR_BLACK);
BSP_LCD_FillCircle(LogX, LogY, 5);
BSP_LCD_SetTextColor(LCD_COLOR_WHITE);
BSP_LCD_FillCircle(LogX, LogY, 2);
/* Wait until touch is pressed */
WaitForPressedState(1);
BSP_TS_GetState(&TS_State);
*pPhysX = TS_State.X;
*pPhysY = TS_State.Y;
/* Wait until touch is released */
WaitForPressedState(0);
BSP_LCD_SetTextColor(LCD_COLOR_WHITE);
BSP_LCD_FillCircle(LogX, LogY, 5);
}
/**
* @brief Read the coordinate of the point touched and assign their
* value to the variables u32_TSXCoordinate and u32_TSYCoordinate
* @param None
* @retval None
*/
void k_TouchUpdate(void)
{
static GUI_PID_STATE TS_State = {0, 0, 0, 0};
__IO TS_StateTypeDef ts;
uint16_t xDiff, yDiff;
BSP_TS_GetState((TS_StateTypeDef *)&ts);
if((ts.x >= LCD_GetXSize()) ||(ts.y >= LCD_GetYSize()) )
{
ts.x = 0;
ts.y = 0;
ts.TouchDetected =0;
}
xDiff = (TS_State.x > ts.x) ? (TS_State.x - ts.x) : (ts.x - TS_State.x);
yDiff = (TS_State.y > ts.y) ? (TS_State.y - ts.y) : (ts.y - TS_State.y);
if((TS_State.Pressed != ts.TouchDetected ) ||
(xDiff > 30 )||
(yDiff > 30))
{
TS_State.Pressed = ts.TouchDetected;
TS_State.Layer = SelLayer;
if(ts.TouchDetected)
{
TS_State.x = ts.x;
TS_State.y = ts.y;
GUI_TOUCH_StoreStateEx(&TS_State);
}
else
{
GUI_TOUCH_StoreStateEx(&TS_State);
TS_State.x = 0;
TS_State.y = 0;
}
}
}
void BSP_Pointer_Update(void)
{
GUI_PID_STATE TS_State;
static TS_StateTypeDef prev_state;
TS_StateTypeDef ts;
uint16_t xDiff, yDiff;
BSP_TS_GetState(&ts);
TS_State.Pressed = ts.TouchDetected;
if (ts.TouchDetected)
{
xDiff = (prev_state.X > ts.X) ? (prev_state.X - ts.X) : (ts.X - prev_state.X);
yDiff = (prev_state.Y > ts.Y) ? (prev_state.Y - ts.Y) : (ts.Y - prev_state.Y);
if ((prev_state.TouchDetected != ts.TouchDetected) || (xDiff > 3) || (yDiff > 3))
{
prev_state = ts;
TS_State.Layer = 0;
TS_State.x = ts.X;
TS_State.y = ts.Y;
GUI_TOUCH_StoreStateEx(&TS_State);
}
}
else
{
// Use -1 if touch is not pressed.
TS_State.Layer = 0;
TS_State.x = -1;
TS_State.y = -1;
GUI_TOUCH_StoreStateEx(&TS_State);
}
}
/**
* @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 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 = 0x00FF00FF; /* = 0xF81F in RGB565 format */
TS_StateTypeDef TS_State;
uint32_t TS_command = TS_RESOLUTION;
Camera_SetHint();
status = BSP_TS_Init(BSP_LCD_GetXSize(), BSP_LCD_GetYSize());
if (status != TS_OK)
{
BSP_LCD_SetBackColor(LCD_COLOR_WHITE);
BSP_LCD_SetTextColor(LCD_COLOR_RED);
BSP_LCD_DisplayStringAt(0, BSP_LCD_GetYSize() - 95, (uint8_t *)"ERROR", CENTER_MODE);
BSP_LCD_DisplayStringAt(0, BSP_LCD_GetYSize() - 80, (uint8_t *)"Touchscreen cannot be initialized", CENTER_MODE);
}
/*## Camera Initialization and start capture ############################*/
CameraResIndex = CAMERA_R160x120; /* Set QQVGA default resolution */
CameraResX = CAMERA_QQVGA_RES_X;
CameraResY = CAMERA_QQVGA_RES_Y;
/* Infinite loop */
while (exit == 0)
{
if (TS_command == TS_RESOLUTION) /* A camera change resolution has been asked */
{
TS_command = TS_NO_COMMAND;
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);
}
else
{
offset_cam = 0;
offset_lcd = 0;
display_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 */
CameraFrameBufferInitComplete = 0;
CameraFrameBufferInitError = 0;
/* 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);
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 */
ASSERT(CameraFrameBufferInitComplete != 1);
/* Start / Restart camera stream */
BSP_CAMERA_ContinuousStart((uint8_t *)CAMERA_FRAME_BUFFER);
/* Allow DMA2D copy from Camera frame buffer to LCD Frame buffer location */
Camera_AllowDma2dCopyCamFrmBuffToLcdFrmBuff = 1;
}
} /* (CameraResIndex != CameraCurrentResIndex) */
if (camera_status == CAMERA_OK)
{
/* Check in polling mode in touch screen the touch status and coordinates */
/* if touch occurred */
BSP_TS_GetState(&TS_State);
if(TS_State.touchDetected >= 1)
{
/* Check touch position to apply brightness or contrast change */
if (TS_State.touchDetected == 1)
{
if ((TS_State.touchY[0] < 30) && (brightness < CAMERA_BRIGHTNESS_MAX))
{
TS_command = TS_BRIGHTNESS_INC;
brightness++;
}
else if ((TS_State.touchY[0] > (BSP_LCD_GetYSize() - 30)) && (brightness > CAMERA_BRIGHTNESS_MIN) )
{
TS_command = TS_BRIGHTNESS_DEC;
brightness--;
}
else if ((TS_State.touchX[0] < 30) && (contrast > CAMERA_CONTRAST_MIN))
{
TS_command = TS_CONTRAST_DEC;
contrast--;
}
else if ((TS_State.touchX[0] > (BSP_LCD_GetXSize() - 30)) && (contrast < CAMERA_CONTRAST_MAX))
{
TS_command = TS_CONTRAST_INC;
contrast++;
}
else
{
TS_command = TS_NO_COMMAND;
}
}
/* Special effect change */
if (TS_State.touchDetected == 2)
{
TS_command = TS_EFFECT;
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_BLUE;
}
break;
case CAMERA_COLOR_EFFECT :
if (color_effect < CAMERA_COLOR_EFFECT_ANTIQUE)
{
/* 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;
}
}
if (TS_command == TS_NO_COMMAND)
{
BSP_LCD_DisplayStringAt(0, BSP_LCD_GetYSize() - CAMERA_STATUS_TEXT_POS, (uint8_t *)" ", CENTER_MODE);
}
if ((TS_command == TS_BRIGHTNESS_INC) || (TS_command == TS_BRIGHTNESS_DEC) || (TS_command == TS_CONTRAST_INC) || (TS_command == TS_CONTRAST_DEC))
{
/* A brightness change has been asked */
BSP_CAMERA_ContrastBrightnessConfig(contrast, brightness);
if ((TS_command == TS_BRIGHTNESS_INC) || (TS_command == TS_BRIGHTNESS_DEC))
{
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 (TS_command == TS_EFFECT)
{
/* 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;
}
}
if (TS_State.touchDetected >= 3) /* 3 or more fingers touch to change resolution */
{
TS_command = TS_RESOLUTION;
if (CameraResIndex < CAMERA_RES_INDEX_MAX)
{
CameraResIndex++; /* Switch to higher resolution */
}
else
{
CameraResIndex = CAMERA_RES_INDEX_MIN;
}
/* Disallow DMA2D copy from Camera frame buffer to LCD Frame buffer location */
Camera_AllowDma2dCopyCamFrmBuffToLcdFrmBuff = 0;
/* Insert 10 ms delay */
HAL_Delay(10);
/* Stop camera stream */
camera_status = BSP_CAMERA_Stop();
ASSERT(camera_status != CAMERA_OK);
/* Clear screen */
Camera_SetHint();
}
/* Wait for touch screen no touch detected */
do
{
BSP_TS_GetState(&TS_State);
}while(TS_State.touchDetected > 0);
}
}
if (CheckForUserInput() > 0)
{
exit = 1;
}
}
if (camera_status == CAMERA_OK)
{
/* Stop camera stream */
camera_status = BSP_CAMERA_Stop();
ASSERT(camera_status != CAMERA_OK);
}
/* End of camera demo */
}
/**
* @brief Touchscreen Demo1 : test touchscreen calibration and single touch in polling mode
* @param None
* @retval None
*/
void Touchscreen_demo1(void)
{
uint16_t x1, y1;
uint8_t state = 0;
uint8_t exitTsUseCase = 0;
uint32_t ts_status = TS_OK;
/* Reset touch data information */
BSP_TEST_APPLI_ASSERT(BSP_TS_ResetTouchData(&TS_State));
/* If calibration is not yet done, proceed with calibration */
if (TouchScreen_IsCalibrationDone() == 0)
{
ts_status = Touchscreen_Calibration();
if (ts_status == TS_OK)
{
BSP_LCD_DisplayStringAt(0, BSP_LCD_GetYSize() - 65, (uint8_t *) "Touchscreen calibration success.", CENTER_MODE);
}
} /* of if (TouchScreen_IsCalibrationDone() == 0) */
if(ts_status == TS_OK)
{
/* Display touch screen demo description */
Touchscreen_SetHint_Demo(TOUCHSCREEN_DEMO_1);
Touchscreen_DrawBackground_Demo1(state);
while (exitTsUseCase == 0)
{
if (ts_status == TS_OK)
{
/* Check in polling mode in touch screen the touch status and coordinates */
/* of touches if touch occurred */
ts_status = BSP_TS_GetState(&TS_State);
if(TS_State.touchDetected)
{
/* One or dual touch have been detected */
/* Only take into account the first touch so far */
/* Get X and Y position of the first touch post calibrated */
x1 = TouchScreen_Get_Calibrated_X(TS_State.touchX[0]);
y1 = TouchScreen_Get_Calibrated_Y(TS_State.touchY[0]);
if ((y1 > (CIRCLE_YPOS(1) - CIRCLE_RADIUS)) &&
(y1 < (CIRCLE_YPOS(1) + CIRCLE_RADIUS)))
{
if ((x1 > (CIRCLE_XPOS(1) - CIRCLE_RADIUS)) &&
(x1 < (CIRCLE_XPOS(1) + CIRCLE_RADIUS)))
{
if ((state & 1) == 0)
{
Touchscreen_DrawBackground_Demo1(state);
BSP_LCD_SetTextColor(LCD_COLOR_BLUE);
BSP_LCD_FillCircle(CIRCLE_XPOS(1), CIRCLE_YPOS(1), CIRCLE_RADIUS);
state = 1;
}
}
if ((x1 > (CIRCLE_XPOS(2) - CIRCLE_RADIUS)) &&
(x1 < (CIRCLE_XPOS(2) + CIRCLE_RADIUS)))
{
if ((state & 2) == 0)
{
Touchscreen_DrawBackground_Demo1(state);
BSP_LCD_SetTextColor(LCD_COLOR_RED);
BSP_LCD_FillCircle(CIRCLE_XPOS(2), CIRCLE_YPOS(2), CIRCLE_RADIUS);
state = 2;
}
}
if ((x1 > (CIRCLE_XPOS(3) - CIRCLE_RADIUS)) &&
(x1 < (CIRCLE_XPOS(3) + CIRCLE_RADIUS)))
{
if ((state & 4) == 0)
{
Touchscreen_DrawBackground_Demo1(state);
BSP_LCD_SetTextColor(LCD_COLOR_YELLOW);
BSP_LCD_FillCircle(CIRCLE_XPOS(3), CIRCLE_YPOS(3), CIRCLE_RADIUS);
state = 4;
}
}
if ((x1 > (CIRCLE_XPOS(4) - CIRCLE_RADIUS)) &&
(x1 < (CIRCLE_XPOS(4) + CIRCLE_RADIUS)))
{
if ((state & 8) == 0)
{
Touchscreen_DrawBackground_Demo1(state);
BSP_LCD_SetTextColor(LCD_COLOR_GREEN);
BSP_LCD_FillCircle(CIRCLE_XPOS(4), CIRCLE_YPOS(3), CIRCLE_RADIUS);
state = 8;
}
}
}
} /* of if(TS_State.TouchDetected) */
} /* of if (ts_status == TS_OK) */
/* Wait for a key button press to switch to next test case of BSP validation application */
/* Otherwise stay in the test */
exitTsUseCase = CheckForUserInput();
HAL_Delay(20);
} /* of while (exitTsUseCase == 0) */
} /* of if(status == TS_OK) */
}
/**
* @brief 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 Manages AUDIO Menu Process.
* @param None
* @retval None
*/
void AUDIO_MenuProcess(void)
{
AUDIO_ErrorTypeDef status;
TS_StateTypeDef TS_State;
Point PlaybackLogoPoints[] = {{TOUCH_PLAYBACK_XMIN, TOUCH_PLAYBACK_YMIN},
{TOUCH_PLAYBACK_XMAX, (TOUCH_PLAYBACK_YMIN+TOUCH_PLAYBACK_YMAX)/2},
{TOUCH_PLAYBACK_XMIN, TOUCH_PLAYBACK_YMAX}};
if(appli_state == APPLICATION_READY)
{
switch(AudioDemo.state)
{
case AUDIO_DEMO_IDLE:
if(AUDIO_ShowWavFiles() > 0)
{
LCD_ErrLog("There is no WAV file on the USB Key.\n");
AUDIO_ChangeSelectMode(AUDIO_SELECT_MENU);
AudioDemo.state = AUDIO_DEMO_IDLE;
}
else
{
AudioDemo.state = AUDIO_DEMO_WAIT;
}
BSP_LCD_SetFont(&LCD_LOG_HEADER_FONT);
BSP_LCD_ClearStringLine(13); /* Clear touch screen buttons dedicated zone */
BSP_LCD_ClearStringLine(14);
BSP_LCD_ClearStringLine(15);
BSP_LCD_SetTextColor(LCD_COLOR_CYAN);
BSP_LCD_FillPolygon(PlaybackLogoPoints, 3); /* Playback sign */
BSP_LCD_FillCircle((TOUCH_RECORD_XMAX+TOUCH_RECORD_XMIN)/2, /* Record circle */
(TOUCH_RECORD_YMAX+TOUCH_RECORD_YMIN)/2,
(TOUCH_RECORD_XMAX-TOUCH_RECORD_XMIN)/2);
BSP_LCD_SetTextColor(LCD_COLOR_GREEN);
BSP_LCD_SetFont(&LCD_LOG_TEXT_FONT);
BSP_LCD_DisplayStringAtLine(15, (uint8_t *)"Use touch screen to enter playback or record menu");
break;
case AUDIO_DEMO_WAIT:
BSP_TS_GetState(&TS_State);
if(TS_State.touchDetected == 1)
{
if ((TS_State.touchX[0] > TOUCH_RECORD_XMIN) && (TS_State.touchX[0] < TOUCH_RECORD_XMAX) &&
(TS_State.touchY[0] > TOUCH_RECORD_YMIN) && (TS_State.touchY[0] < TOUCH_RECORD_YMAX))
{
AudioDemo.state = AUDIO_DEMO_IN;
}
else if ((TS_State.touchX[0] > TOUCH_PLAYBACK_XMIN) && (TS_State.touchX[0] < TOUCH_PLAYBACK_XMAX) &&
(TS_State.touchY[0] > TOUCH_PLAYBACK_YMIN) && (TS_State.touchY[0] < TOUCH_PLAYBACK_YMAX))
{
AudioDemo.state = AUDIO_DEMO_PLAYBACK;
}
else
{
AudioDemo.state = AUDIO_DEMO_EXPLORE;
}
/* Wait for touch released */
do
{
BSP_TS_GetState(&TS_State);
}while(TS_State.touchDetected > 0);
}
break;
case AUDIO_DEMO_EXPLORE:
if(appli_state == APPLICATION_READY)
{
if(AUDIO_ShowWavFiles() > 0)
{
LCD_ErrLog("There is no WAV file on the USB Key.\n");
AUDIO_ChangeSelectMode(AUDIO_SELECT_MENU);
AudioDemo.state = AUDIO_DEMO_IDLE;
}
else
{
AudioDemo.state = AUDIO_DEMO_WAIT;
}
}
else
{
AudioDemo.state = AUDIO_DEMO_WAIT;
}
break;
case AUDIO_DEMO_PLAYBACK:
if(appli_state == APPLICATION_READY)
{
if(AudioState == AUDIO_STATE_IDLE)
{
/* Start Playing */
AudioState = AUDIO_STATE_INIT;
/* Clear the LCD */
LCD_ClearTextZone();
if(AUDIO_PLAYER_Start(0) == AUDIO_ERROR_IO)
{
AUDIO_ChangeSelectMode(AUDIO_SELECT_MENU);
AudioDemo.state = AUDIO_DEMO_IDLE;
}
}
else /* Not idle */
{
if(AUDIO_PLAYER_Process() == AUDIO_ERROR_IO)
{
/* Clear the LCD */
LCD_ClearTextZone();
AUDIO_ChangeSelectMode(AUDIO_SELECT_MENU);
AudioDemo.state = AUDIO_DEMO_IDLE;
}
}
}
else
{
AudioDemo.state = AUDIO_DEMO_WAIT;
}
break;
case AUDIO_DEMO_IN:
if(appli_state == APPLICATION_READY)
{
if(AudioState == AUDIO_STATE_IDLE)
{
/* Start Playing */
AudioState = AUDIO_STATE_INIT;
/* Clear the LCD */
LCD_ClearTextZone();
/* Configure the audio recorder: sampling frequency, bits-depth, number of channels */
if(AUDIO_REC_Start() == AUDIO_ERROR_IO)
{
AUDIO_ChangeSelectMode(AUDIO_SELECT_MENU);
AudioDemo.state = AUDIO_DEMO_IDLE;
}
}
else /* Not idle */
{
status = AUDIO_REC_Process();
if((status == AUDIO_ERROR_IO) || (status == AUDIO_ERROR_EOF))
{
/* Clear the LCD */
LCD_ClearTextZone();
AUDIO_ChangeSelectMode(AUDIO_SELECT_MENU);
AudioDemo.state = AUDIO_DEMO_IDLE;
}
}
}
else
{
AudioDemo.state = AUDIO_DEMO_WAIT;
}
break;
default:
break;
}
}
if(appli_state == APPLICATION_DISCONNECT)
{
appli_state = APPLICATION_IDLE;
AUDIO_ChangeSelectMode(AUDIO_SELECT_MENU);
BSP_AUDIO_OUT_Stop(CODEC_PDWN_SW);
}
}
/**
* @brief Main program
* @param None
* @retval None
*/
int main(void)
{
uint8_t lcd_status = LCD_OK;
/* 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();
BSP_IO_Init();
/* Initialise QSPI */
BSP_QSPI_Init();
BSP_QSPI_MemoryMappedMode();
/* Initialize the SDRAM */
BSP_SDRAM_Init();
/* Initialize the LCD */
lcd_status = LCD_Init();
OnError_Handler(lcd_status != LCD_OK);
/* Initialize LTDC layer 0 iused for Hint */
LCD_LayertInit(0, LAYER0_ADDRESS);
BSP_LCD_SelectLayer(0);
/* Configure the User Button in GPIO Mode */
BSP_PB_Init(BUTTON_TAMPER, BUTTON_MODE_EXTI);
/* Initialize the Touch Screen */
BSP_TS_Init(800, 480);
/* Set active display window */
HAL_DSI_LongWrite(&hdsi_eval, 0, DSI_DCS_LONG_PKT_WRITE, 4, OTM8009A_CMD_CASET, pColLeft);
HAL_DSI_LongWrite(&hdsi_eval, 0, DSI_DCS_LONG_PKT_WRITE, 4, OTM8009A_CMD_PASET, pPage);
/* Update pitch : the draw is done on the whole physical X Size */
HAL_LTDC_SetPitch(&hltdc_eval, BSP_LCD_GetXSize(), 0);
/* Show first image */
LL_CopyPicture((uint32_t *)image[ImageIndex], (uint32_t *)LAYER0_ADDRESS);
valid_buffer = 1;
active_area = LEFT_AREA;
HAL_DSI_LongWrite(&hdsi_eval, 0, DSI_DCS_LONG_PKT_WRITE, 2, OTM8009A_CMD_WRTESCN, pSyncLeft);
/* Infinite loop */
while (1)
{
BSP_TS_GetState(&TS_State);
if(draw_method == HORIZONTAL_SLIDER)
{
LCD_DSI_HorizontalSlider();
}
else
{
LCD_DSI_VerticalSlider();
}
}
}
/**
* @brief Audio Play demo
* @param None
* @retval None
*/
void AudioPlay_demo (void)
{
uint32_t *AudioFreq_ptr;
uint8_t FreqStr[256] = {0};
TS_StateTypeDef TS_State;
AudioFreq_ptr = AudioFreq+6; /*AF_48K*/
uwPauseEnabledStatus = 1; /* 0 when audio is running, 1 when Pause is on */
uwVolume = 70;
Audio_SetHint();
if (BSP_AUDIO_OUT_Init(OUTPUT_DEVICE_HEADPHONE, uwVolume, *AudioFreq_ptr) == 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);
}
if (BSP_TS_Init(BSP_LCD_GetXSize(), BSP_LCD_GetYSize()) != TS_OK)
{
BSP_LCD_SetBackColor(LCD_COLOR_WHITE);
BSP_LCD_SetTextColor(LCD_COLOR_RED);
BSP_LCD_DisplayStringAt(0, BSP_LCD_GetYSize() - 65, (uint8_t *)"ERROR", CENTER_MODE);
BSP_LCD_DisplayStringAt(0, BSP_LCD_GetYSize() - 50, (uint8_t *)"Touchscreen cannot be initialized", 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_Start(AUDIO_FILE_ADDRESS, 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, BSP_LCD_GetYSize() - 80, (uint8_t *)" PLAYING... ", CENTER_MODE);
sprintf((char*)FreqStr, " VOL: %3lu ", uwVolume);
BSP_LCD_DisplayStringAt(0, BSP_LCD_GetYSize() - 65, (uint8_t *)FreqStr, CENTER_MODE);
sprintf((char*)FreqStr, " FREQ: %6lu ", *AudioFreq_ptr);
BSP_LCD_DisplayStringAt(0, BSP_LCD_GetYSize() - 50, (uint8_t *)FreqStr, CENTER_MODE);
BSP_AUDIO_OUT_SetVolume(70);
BSP_LCD_SetBackColor(LCD_COLOR_WHITE);
BSP_LCD_SetTextColor(LCD_COLOR_BLUE);
/* Infinite loop */
while (1)
{
/* Check in polling mode in touch screen the touch status and coordinates */
/* if touch occurred */
BSP_TS_GetState(&TS_State);
if(TS_State.touchDetected == 1)
{
if (TS_State.touchY[0] < 30)
{
/* 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, BSP_LCD_GetYSize() - 65, (uint8_t *)FreqStr, CENTER_MODE);
}
else if (TS_State.touchY[0] > (BSP_LCD_GetYSize() - 30))
{
/* 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, BSP_LCD_GetYSize() - 65, (uint8_t *)FreqStr, CENTER_MODE);
}
else if (TS_State.touchX[0] < 30)
{
/*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, BSP_LCD_GetYSize() - 50, (uint8_t *)FreqStr, CENTER_MODE);
}
else if (TS_State.touchX[0] > (BSP_LCD_GetXSize() - 30))
{
/* 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, BSP_LCD_GetYSize() - 50, (uint8_t *)FreqStr, CENTER_MODE);
}
/* Wait for touch screen no touch detected */
do
{
BSP_TS_GetState(&TS_State);
}while(TS_State.touchDetected > 0);
}
if (TS_State.touchDetected >= 2)
{
/* Set Pause / Resume */
if (uwPauseEnabledStatus == 1)
{ /* Pause is enabled, call Resume */
BSP_AUDIO_OUT_Resume();
uwPauseEnabledStatus = 0;
BSP_LCD_DisplayStringAt(0, BSP_LCD_GetYSize() - 80, (uint8_t *)" PLAYING... ", CENTER_MODE);
}
else
{ /* Pause the playback */
BSP_AUDIO_OUT_Pause();
uwPauseEnabledStatus = 1;
BSP_LCD_DisplayStringAt(0, BSP_LCD_GetYSize() - 80, (uint8_t *)" PAUSE ... ", CENTER_MODE);
}
/* Wait for touch screen no touch detected */
do
{
BSP_TS_GetState(&TS_State);
}while(TS_State.touchDetected > 0);
}
if (CheckForUserInput() > 0)
{
BSP_AUDIO_OUT_Stop(CODEC_PDWN_SW);
BSP_AUDIO_OUT_DeInit();
return;
}
}
}
/*
Conditions:
22
Exit points:
0
M = 22 - 0 + 2 = 25
Cyclomatic complexity
25
*/
void fp_test(void)
{
uint32_t retCode = 0;
GUI_Button_t fp_start,
fp_refresh,
fp_close,
fp_continue;
TS_StateTypeDef ts;
uint32_t action = 0, id = 0;
gui_button_init(&fp_start);
fp_start.XPosition = 20;
fp_start.YPosition = 50;
fp_start.Height = 50;
fp_start.Width = 200;
fp_start.BorderWidth = 2;
fp_start.BorderColor = LCD_COLOR_BLACK;
fp_start.FillColor = LCD_COLOR_WHITE;
fp_start.TextColor = LCD_COLOR_BLACK;
fp_start.Text = (uint8_t*)"Start";
gui_button_init(&fp_refresh);
fp_refresh.XPosition = 20;
fp_refresh.YPosition = 125;
fp_refresh.Height = 50;
fp_refresh.Width = 200;
fp_refresh.BorderWidth = 2;
fp_refresh.BorderColor = LCD_COLOR_BLACK;
fp_refresh.FillColor = LCD_COLOR_WHITE;
fp_refresh.TextColor = LCD_COLOR_BLACK;
fp_refresh.Text = (uint8_t*)"Refresh";
gui_button_init(&fp_close);
fp_close.XPosition = 20;
fp_close.YPosition = 200;
fp_close.Height = 50;
fp_close.Width = 200;
fp_close.BorderWidth = 2;
fp_close.BorderColor = LCD_COLOR_BLACK;
fp_close.FillColor = LCD_COLOR_WHITE;
fp_close.TextColor = LCD_COLOR_BLACK;
fp_close.Text = (uint8_t*)"Close";
gui_button_init(&fp_continue);
fp_continue.XPosition = 20;
fp_continue.YPosition = 250;
fp_continue.Height = 50;
fp_continue.Width = 200;
fp_continue.BorderWidth = 2;
fp_continue.BorderColor = LCD_COLOR_BLACK;
fp_continue.FillColor = LCD_COLOR_WHITE;
fp_continue.TextColor = LCD_COLOR_BLACK;
fp_continue.Text = (uint8_t*)"Continue";
while (1)
{
BSP_LCD_Clear(LCD_COLOR_WHITE);
gui_button_draw(&fp_start);
gui_button_draw(&fp_refresh);
gui_button_draw(&fp_close);
action = 0;
while (action == 0)
{
BSP_TS_GetState(&ts);
if (gui_button_check_touch(&fp_start, &ts) == GUI_Button_Error_Yes)
{
action = 1;
}
else if (gui_button_check_touch(&fp_refresh, &ts) == GUI_Button_Error_Yes)
{
action = 2;
}
else if (gui_button_check_touch(&fp_close, &ts) == GUI_Button_Error_Yes)
{
action = 3;
}
else
{
vTaskDelay(5);
}
}
switch (action)
{
case 1:
id = fp_session_start();
BSP_LCD_Clear(LCD_COLOR_WHITE);
BSP_LCD_DisplayStringAtLine(1, (uint8_t*)"Session start");
if (id < 20)
BSP_LCD_DisplayStringAtLine(2, format_string("ID: %d", id));
else
BSP_LCD_DisplayStringAtLine(2, format_string("Error code: %x", id));
gui_button_draw(&fp_continue);
while (1)
{
BSP_TS_GetState(&ts);
if (gui_button_check_touch(&fp_continue, &ts) == GUI_Button_Error_Yes)
break;
vTaskDelay(5);
}
break;
case 2:
retCode = fp_session_refresh(id);
BSP_LCD_Clear(LCD_COLOR_WHITE);
BSP_LCD_DisplayStringAtLine(1, (uint8_t*)"Session refresh");
if (retCode < 20)
BSP_LCD_DisplayStringAtLine(2, format_string("ID: %d", id));
else
BSP_LCD_DisplayStringAtLine(2, format_string("Error code: %x", retCode));
gui_button_draw(&fp_continue);
while (1)
{
BSP_TS_GetState(&ts);
if (gui_button_check_touch(&fp_continue, &ts) == GUI_Button_Error_Yes)
break;
vTaskDelay(5);
}
break;
case 3:
retCode = fp_session_close(id);
BSP_LCD_Clear(LCD_COLOR_WHITE);
BSP_LCD_DisplayStringAtLine(1, (uint8_t*)"Session close");
if (retCode < 20)
BSP_LCD_DisplayStringAtLine(2, format_string("ID: %d", id));
else
BSP_LCD_DisplayStringAtLine(2, format_string("Error code: %x", retCode));
gui_button_draw(&fp_continue);
while (1)
{
BSP_TS_GetState(&ts);
if (gui_button_check_touch(&fp_continue, &ts) == GUI_Button_Error_Yes)
break;
vTaskDelay(5);
}
break;
default:
id = fp_error_session_not_started;
break;
}
}
}
/**
* @brief TouchScreen_Calibration_WaitForPressedState : wait until a particular press/depress action
* The function is managing anti-rebound : that is the awaited state when detected
* needs to be stable for a sufficient time (timeout time), otherwise a new sense to search
* for awaited state is performed. When awaited state is found and state is stable for timeout
* duration, the function is exited.
* @param uint8_t Pressed : Awaited pressed state
* - Await touch (single/multiple) detection if Pressed == 1
* - Await no touch detection if Pressed == 0
* @retval None
*/
static void TouchScreen_Calibration_WaitForPressedState(uint8_t Pressed)
{
uint16_t TimeStart = 0;
uint8_t status = TS_OK;
uint32_t exitFirstLevelWhileLoopReq = 0; /* By default no exit request from first level while loop */
uint32_t exitSecondLevelWhileLoopReq = 0; /* By default no exit request from second level while loop */
/* First level while loop entry */
do
{
/* reset exit second level while loop in case it was set */
exitSecondLevelWhileLoopReq = 0;
/* Sense of touch state from touch IC until get the awaited state in parameter 'Pressed' */
status = BSP_TS_GetState(&TS_State);
if(status == TS_OK)
{
if (((Pressed == 0) && (TS_State.touchDetected == 0)) ||
((Pressed == 1) && ((TS_State.touchDetected == 1) || (TS_State.touchDetected == 2))))
{
/* Got awaited press state */
/* Record in 'TimeStart' the time of awaited touch event for anti-rebound calculation */
/* The state should persist for a minimum sufficient time */
TimeStart = HAL_GetTick();
/* Is state of the touch changing ? */
/* Second level while loop entry */
do
{
/* New sense of touch state from touch IC : to evaluate if state was stable */
status = BSP_TS_GetState(&TS_State);
if(status == TS_OK)
{
/* Is there a state change compared since having found the awaited state ? */
if (((Pressed == 0) && ((TS_State.touchDetected == 1) || (TS_State.touchDetected == 2))) ||
((Pressed == 1) && ((TS_State.touchDetected == 0))))
{
/* Too rapid state change => anti-rebound management : restart first touch search */
exitSecondLevelWhileLoopReq = 1; /* exit request from second level while loop */
}
else if ((HAL_GetTick() - 100) > TimeStart)
{
/* State have not changed for the timeout duration (stable touch for 100 ms) */
/* This means the touch state is stable : can exit function */
/* found valid touch, exit both while levels */
exitSecondLevelWhileLoopReq = 1;
exitFirstLevelWhileLoopReq = 1;
}
/* Wait 10 ms before next sense of touch at next loop iteration */
HAL_Delay(10);
} /* of if(status == TS_OK) */
}
while (!exitSecondLevelWhileLoopReq);
} /* of if (((Pressed == 0) && .... */
} /* of if(status == TS_OK) */
if(!exitFirstLevelWhileLoopReq)
{
/* Wait some time before next sense of touch at next loop iteration */
HAL_Delay(10);
}
/* Scan User button in case early exit requested by user to switch to an other use case while calibrating */
/* the touch screen */
if (CheckForUserInput() > 0)
{
exitSecondLevelWhileLoopReq = 1;
}
}
while (!exitSecondLevelWhileLoopReq);
}
/**
* @brief Touchscreen Demo
* @param None
* @retval None
*/
void Touchscreen_demo (void)
{
uint8_t status = 0;
uint16_t x,y;
uint8_t state = 0;
if(stmpe811_ts_drv.ReadID(TS_I2C_ADDRESS) == STMPE811_ID)
{
if(IsCalibrationDone() == 0)
{
Touchscreen_Calibration();
}
}
Touchscreen_SetHint();
status = BSP_TS_Init(BSP_LCD_GetXSize(), BSP_LCD_GetYSize());
if (status != TS_OK)
{
BSP_LCD_SetBackColor(LCD_COLOR_WHITE);
BSP_LCD_SetTextColor(LCD_COLOR_RED);
BSP_LCD_DisplayStringAt(0, BSP_LCD_GetYSize()- 95, (uint8_t *)"ERROR", CENTER_MODE);
BSP_LCD_DisplayStringAt(0, BSP_LCD_GetYSize()- 80, (uint8_t *)"Touchscreen cannot be initialized", CENTER_MODE);
}
else
{
Touchscreen_DrawBackground(state);
}
while (1)
{
if (status == TS_OK)
{
BSP_TS_GetState(&TS_State);
if(stmpe811_ts_drv.ReadID(TS_I2C_ADDRESS) == STMPE811_ID)
{
x = Calibration_GetX(TS_State.x);
y = Calibration_GetY(TS_State.y);
}
else
{
x = TS_State.x;
y = TS_State.y;
}
if((TS_State.TouchDetected) &&
(y > (CIRCLE_YPOS(1) - CIRCLE_RADIUS))&&
(y < (CIRCLE_YPOS(1) + CIRCLE_RADIUS)))
{
if((x > (CIRCLE_XPOS(1) - CIRCLE_RADIUS))&&
(x < (CIRCLE_XPOS(1) + CIRCLE_RADIUS)))
{
if((state & 1) == 0)
{
Touchscreen_DrawBackground(state);
BSP_LCD_SetTextColor(LCD_COLOR_BLUE);
BSP_LCD_FillCircle(CIRCLE_XPOS(1), CIRCLE_YPOS(1), CIRCLE_RADIUS);
state = 1;
}
}
if((x > (CIRCLE_XPOS(2) - CIRCLE_RADIUS))&&
(x < (CIRCLE_XPOS(2) + CIRCLE_RADIUS)))
{
if((state & 2) == 0)
{
Touchscreen_DrawBackground(state);
BSP_LCD_SetTextColor(LCD_COLOR_RED);
BSP_LCD_FillCircle(CIRCLE_XPOS(2), CIRCLE_YPOS(2), CIRCLE_RADIUS);
state = 2;
}
}
if((x > (CIRCLE_XPOS(3) - CIRCLE_RADIUS))&&
(x < (CIRCLE_XPOS(3) + CIRCLE_RADIUS)))
{
if((state & 4) == 0)
{
Touchscreen_DrawBackground(state);
BSP_LCD_SetTextColor(LCD_COLOR_YELLOW);
BSP_LCD_FillCircle(CIRCLE_XPOS(3), CIRCLE_YPOS(3), CIRCLE_RADIUS);
state = 4;
}
}
if((x > (CIRCLE_XPOS(4) - CIRCLE_RADIUS))&&
(x < (CIRCLE_XPOS(4) + CIRCLE_RADIUS)))
{
if((state & 8) == 0)
{
Touchscreen_DrawBackground(state);
BSP_LCD_SetTextColor(LCD_COLOR_GREEN);
BSP_LCD_FillCircle(CIRCLE_XPOS(4), CIRCLE_YPOS(3), CIRCLE_RADIUS);
state = 8;
}
}
}
}
if(CheckForUserInput() > 0)
{
return;
}
HAL_Delay(10);
}
}
/**
* @brief Configures and gets Touch screen position.
* @param None
* @retval None
*/
static void GetPosition(void)
{
static uint32_t color_width;
static uint32_t color;
if (BSP_LCD_GetXSize() == 640)
{
color_width = 36;
}
else
{
color_width = 19;
}
/* 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 > (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 > 0 ) & ( x < 50 ))
{
if ((TS_State.TouchDetected) & ( y > 0 ) & ( y < color_width ))
{
BSP_LCD_SetTextColor(LCD_COLOR_WHITE);
Update_Size(Radius);
}
else if ((TS_State.TouchDetected) & ( y > color_width ) & (y < (2 * color_width)))
{
BSP_LCD_SetTextColor(LCD_COLOR_YELLOW);
Update_Size(Radius);
}
else if ((TS_State.TouchDetected) & (y > (2 * color_width)) & (y < (3 * color_width)))
{
BSP_LCD_SetTextColor(LCD_COLOR_ORANGE);
Update_Size(Radius);
}
else if ((TS_State.TouchDetected) & (y > (3 * color_width)) & (y < (4 * color_width)))
{
BSP_LCD_SetTextColor(LCD_COLOR_LIGHTMAGENTA);
Update_Size(Radius);
}
else if ((TS_State.TouchDetected) & (y > (4 * color_width)) & (y < (5 * color_width)))
{
BSP_LCD_SetTextColor(LCD_COLOR_DARKGREEN);
Update_Size(Radius);
}
else if ((TS_State.TouchDetected) & (y > (5 * color_width)) &(y < (6 * color_width)))
{
BSP_LCD_SetTextColor(LCD_COLOR_GREEN);
Update_Size(Radius);
}
else if ((TS_State.TouchDetected) & (y > (6 * color_width)) &(y < (7 * color_width)))
{
BSP_LCD_SetTextColor(LCD_COLOR_BROWN);
Update_Size(Radius);
}
else if ((TS_State.TouchDetected) & (y > (7 * color_width)) & (y < (8 * color_width)))
{
BSP_LCD_SetTextColor(LCD_COLOR_RED);
Update_Size(Radius);
}
else if ((TS_State.TouchDetected) & (y > (8 * color_width)) & (y < (9 * color_width)))
{
BSP_LCD_SetTextColor(LCD_COLOR_DARKMAGENTA);
Update_Size(Radius);
}
else if ((TS_State.TouchDetected) & (y > (9 * color_width)) & (y < (10 * color_width)))
{
BSP_LCD_SetTextColor(LCD_COLOR_CYAN);
Update_Size(Radius);
}
else if ((TS_State.TouchDetected) & (y > (10 * color_width)) & (y < (11 * color_width)))
{
BSP_LCD_SetTextColor(LCD_COLOR_DARKBLUE);
Update_Size(Radius);
}
else if ((TS_State.TouchDetected) & (y > (11 * color_width)) & (y < (12 * color_width)))
{
BSP_LCD_SetTextColor(LCD_COLOR_BLACK);
Update_Size(Radius);
}
else if ((TS_State.TouchDetected) & (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, (BSP_LCD_GetXSize() - 75), (BSP_LCD_GetYSize() - 75));
BSP_LCD_SetTextColor(color);
}
else
{
x = 0;
y = 0;
}
Update_Color();
}
else if ((TS_State.TouchDetected) & (x > 70 ) & (y > (12 * color_width)) & (y < (13 * color_width)) & ( x < 120 ))
{
Radius = 20;
Update_Size(Radius);
}
else if ((TS_State.TouchDetected) & (x > 120 ) & (y > (12 * color_width)) & (y < (13 * color_width)) & ( x < 170 ))
{
Radius = 15;
Update_Size(Radius);
}
else if ((TS_State.TouchDetected) & (x > 170 ) & (y > (12 * color_width)) & (y < (13 * color_width)) & ( x < 220 ))
{
Radius = 10;
Update_Size(Radius);
}
else if ((TS_State.TouchDetected) & (x > 220 ) & (y > (12 * color_width)) & (y < (13 * color_width)) & ( x < 270 ))
{
Radius = 5;
Update_Size(Radius);
}
else if ((TS_State.TouchDetected) & (x > 270 ) & (y > (12 * color_width)) & (y < (13 * color_width)) & ( x < 320 ))
{
Radius = 2;
Update_Size(Radius);
}
else if ((TS_State.TouchDetected) & (((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 ((TS_State.TouchDetected) & (x > 320) & (y > (BSP_LCD_GetYSize() - 50)) & (x < 370) & (y < BSP_LCD_GetYSize() ))
{
Save_Picture();
}
}
/**
* @brief Touchscreen Demo
* @param None
* @retval None
*/
void Touchscreen_demo (void)
{
uint8_t status = 0;
uint16_t x, y;
uint8_t state = 0;
uint8_t text[30];
uint8_t radius;
uint8_t radius_previous = 0;
Touchscreen_SetHint();
status = BSP_TS_Init(BSP_LCD_GetXSize(), BSP_LCD_GetYSize());
if (status != TS_OK)
{
BSP_LCD_SetBackColor(LCD_COLOR_WHITE);
BSP_LCD_SetTextColor(LCD_COLOR_RED);
BSP_LCD_DisplayStringAt(0, BSP_LCD_GetYSize() - 95, (uint8_t *)"ERROR", CENTER_MODE);
BSP_LCD_DisplayStringAt(0, BSP_LCD_GetYSize() - 80, (uint8_t *)"Touchscreen cannot be initialized", CENTER_MODE);
}
else
{
Touchscreen_DrawBackground(state);
}
while (1)
{
if (status == TS_OK)
{
/* Check in polling mode in touch screen the touch status and coordinates */
/* if touch occurred */
BSP_TS_GetState(&TS_State);
if(TS_State.touchDetected)
{
/* Get X and Y position of the touch post calibrated */
x = TS_State.touchX[0];
y = TS_State.touchY[0];
BSP_LCD_SetBackColor(LCD_COLOR_WHITE);
BSP_LCD_SetTextColor(LCD_COLOR_BLACK);
sprintf((char*)text, "Nb touch detected = %d", TS_State.touchDetected);
BSP_LCD_DisplayStringAt(15, BSP_LCD_GetYSize() - 40, (uint8_t *)&text, LEFT_MODE);
/* Display 1st touch detected coordinates */
sprintf((char*)text, "1[%d,%d] ", x, y);
BSP_LCD_DisplayStringAt(15,
BSP_LCD_GetYSize() - 25,
(uint8_t *)&text,
LEFT_MODE);
if (TS_State.touchDetected >= 2) /* Display 2nd touch detected coordinates if applicable */
{
sprintf((char*)text, "2[%d,%d] ", TS_State.touchX[1], TS_State.touchY[1]);
}
else
{
sprintf((char*)text, " ");
}
BSP_LCD_DisplayStringAt((((BSP_LCD_GetXSize() - 30) * 1) / 5) + 15,
BSP_LCD_GetYSize() - 25,
(uint8_t *)&text,
LEFT_MODE);
if (TS_State.touchDetected >= 3) /* Display 3rd touch detected coordinates if applicable */
{
sprintf((char*)text, "3[%d,%d] ", TS_State.touchX[2], TS_State.touchY[2]);
}
else
{
sprintf((char*)text, " ");
}
BSP_LCD_DisplayStringAt((((BSP_LCD_GetXSize() - 30) * 2) / 5) + 15,
BSP_LCD_GetYSize() - 25,
(uint8_t *)&text,
LEFT_MODE);
if (TS_State.touchDetected >= 4) /* Display 4th touch detected coordinates if applicable */
{
sprintf((char*)text, "4[%d,%d] ", TS_State.touchX[3], TS_State.touchY[3]);
}
else
{
sprintf((char*)text, " ");
}
BSP_LCD_DisplayStringAt((((BSP_LCD_GetXSize() - 30) * 3) / 5) + 15,
BSP_LCD_GetYSize() - 25,
(uint8_t *)&text,
LEFT_MODE);
if (TS_State.touchDetected >= 5) /* Display 5th touch detected coordinates if applicable */
{
sprintf((char*)text, "5[%d,%d] ", TS_State.touchX[4], TS_State.touchY[4]);
}
else
{
sprintf((char*)text, " ");
}
BSP_LCD_DisplayStringAt((((BSP_LCD_GetXSize() - 30) * 4) / 5) + 15,
BSP_LCD_GetYSize() - 25,
(uint8_t *)&text,
LEFT_MODE);
/* Calculate circle radius to fill according to finger pressure applied on screen (weight) */
radius = TS_State.touchWeight[0]/3;
if (radius > CIRCLE_RADIUS)
{
radius = CIRCLE_RADIUS;
}
else if (radius < 1)
{
radius = 1;
}
if ((y > (CIRCLE_YPOS(1) - CIRCLE_RADIUS)) &&
(y < (CIRCLE_YPOS(1) + CIRCLE_RADIUS)))
{
if ((x > (CIRCLE_XPOS(1) - CIRCLE_RADIUS)) &&
(x < (CIRCLE_XPOS(1) + CIRCLE_RADIUS)))
{
if ((radius != radius_previous) || (state != 1))
{
if (state != 1) /* Erase previous filled circle */
{
Touchscreen_DrawBackground(state);
}
BSP_LCD_SetTextColor(LCD_COLOR_BLUE);
BSP_LCD_FillCircle(CIRCLE_XPOS(1), CIRCLE_YPOS(1), radius);
radius_previous = radius;
state = 1;
}
}
if ((x > (CIRCLE_XPOS(2) - CIRCLE_RADIUS)) &&
(x < (CIRCLE_XPOS(2) + CIRCLE_RADIUS)))
{
if ((radius != radius_previous) || (state != 2))
{
if (state != 2) /* Erase previous filled circle */
{
Touchscreen_DrawBackground(state);
}
BSP_LCD_SetTextColor(LCD_COLOR_RED);
BSP_LCD_FillCircle(CIRCLE_XPOS(2), CIRCLE_YPOS(2), radius);
radius_previous = radius;
state = 2;
}
}
if ((x > (CIRCLE_XPOS(3) - CIRCLE_RADIUS)) &&
(x < (CIRCLE_XPOS(3) + CIRCLE_RADIUS)))
{
if ((radius != radius_previous) || (state != 4))
{
if (state != 4) /* Erase previous filled circle */
{
Touchscreen_DrawBackground(state);
}
BSP_LCD_SetTextColor(LCD_COLOR_YELLOW);
BSP_LCD_FillCircle(CIRCLE_XPOS(3), CIRCLE_YPOS(3), radius);
radius_previous = radius;
state = 4;
}
}
if ((x > (CIRCLE_XPOS(4) - CIRCLE_RADIUS)) &&
(x < (CIRCLE_XPOS(4) + CIRCLE_RADIUS)))
{
if ((radius != radius_previous) || (state != 8))
{
if (state != 8) /* Erase previous filled circle */
{
Touchscreen_DrawBackground(state);
}
BSP_LCD_SetTextColor(LCD_COLOR_GREEN);
BSP_LCD_FillCircle(CIRCLE_XPOS(4), CIRCLE_YPOS(3), radius);
radius_previous = radius;
state = 8;
}
}
}
} /* of if(TS_State.touchDetected) */
}
if (CheckForUserInput() > 0)
{
return;
}
HAL_Delay(10);
}
}
/*
Conditions:
7
Exit points:
1
M = 7 - 1 + 2 = 8
Cyclomatic complexity
8
*/
uint32_t fp_session_start(void)
{
uint32_t id = 0;
TickType_t lastWake = 0;
uint32_t action = 0;
TS_StateTypeDef ts;
GUI_Button_t newID, existing;
gui_button_init(&newID);
newID.XPosition = 20;
newID.YPosition = 100;
newID.Height = 75;
newID.Width = 200;
newID.BorderWidth = 2;
newID.BorderColor = LCD_COLOR_BLACK;
newID.FillColor = LCD_COLOR_WHITE;
newID.TextColor = LCD_COLOR_BLACK;
newID.Text = (uint8_t*)"New user";
gui_button_init(&existing);
existing.XPosition = 20;
existing.YPosition = 200;
existing.Height = 75;
existing.Width = 200;
existing.BorderWidth = 2;
existing.BorderColor = LCD_COLOR_BLACK;
existing.FillColor = LCD_COLOR_WHITE;
existing.TextColor = LCD_COLOR_BLACK;
existing.Text = (uint8_t*)"Existing user";
lastWake = xTaskGetTickCount();
BSP_LCD_Clear(LCD_COLOR_WHITE);
/*
Display buttons to user
1. New ID
2. Existing
*/
BSP_LCD_DisplayStringAt(0, BSP_LCD_GetFont()->Height * 3 / 2, (uint8_t*)"Authenticate", CENTER_MODE);
gui_button_draw(&newID);
gui_button_draw(&existing);
// Wait for user selection
while (1)
{
// If canceled,
// Abort
BSP_TS_GetState(&ts);
if (gui_button_check_touch(&newID, &ts) == GUI_Button_Error_Yes)
{
action = 1;
break;
}
else if (gui_button_check_touch(&existing, &ts) == GUI_Button_Error_Yes)
{
action = 2;
break;
}
vTaskDelayUntil(&lastWake, 100);
}
//__asm__("bkpt #1");
switch (action)
{
// On New ID,
case 1:
// Call fp_session_new
id = fp_session_new();
break;
// On Existing,
case 2:
// Call fp_session_open
id = fp_session_open();
break;
default:
id = fp_error_session_not_started;
break;
}
if (id < 20)
{
Session_ActivityStamps[id] = fp_get_rtc_time();
}
return id;
}
/**
* @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 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;
}
