/*******************************************************************************
* Function Name : LCD_DisplayStringLine
* Description : Displays a maximum of 20 char on the LCD.
* Input : - Line: the Line where to display the character shape .
* This parameter can be one of the following values:
* - Linex: where x can be 0..9
* - *ptr: pointer to string to display on LCD.
* Output : None
* Return : None
*******************************************************************************/
void LCD_DisplayStringLine(u8 Line, u8 *ptr)
{
u32 i = 0;
u16 refcolumn = 319;
/* Send the string character by character on lCD */
while ((*ptr != 0) & (i < 20))
{
/* Display one character on LCD */
LCD_DisplayChar(Line, refcolumn, *ptr);
/* Decrement the column position by 16 */
refcolumn -= 16;
/* Point on the next character */
ptr++;
/* Increment the character counter */
i++;
}
}
void LCD_DisplayFloatNumber(double v_floatNum_f32)
{
uint32_t v_decNumber_u32;
/* Dirty hack to support the floating point by extracting the integer and fractional part.
1.Type cast the number to int to get the integer part.
2.Display the extracted integer part followed by a decimal point(.)
3.Later the integer part is made zero by subtracting with the extracted integer value.
4.Finally the fractional part is multiplied by 100000 to support 6-digit precision */
v_decNumber_u32 = (uint32_t) v_floatNum_f32;
LCD_DisplayNumber(C_DECIMAL_U8,v_decNumber_u32,C_DisplayDefaultDigits_U8);
LCD_DisplayChar('.');
v_floatNum_f32 = v_floatNum_f32 - v_decNumber_u32;
v_decNumber_u32 = v_floatNum_f32 * 1000000;
LCD_DisplayNumber(C_DECIMAL_U8,v_decNumber_u32,C_DisplayDefaultDigits_U8);
}
int fputc( int ch, FILE *f )
{
static unsigned portSHORT usColumn = 0, usRefColumn = mainCOLUMN_START;
static unsigned portCHAR ucLine = 0;
if( ( usColumn == 0 ) && ( ucLine == 0 ) )
{
LCD_Clear();
}
if( ch != '\n' )
{
/* Display one character on LCD */
LCD_DisplayChar( ucLine, usRefColumn, (u8) ch );
/* Decrement the column position by 16 */
usRefColumn -= mainCOLUMN_INCREMENT;
/* Increment the character counter */
usColumn++;
if( usColumn == mainMAX_COLUMN )
{
ucLine += mainROW_INCREMENT;
usRefColumn = mainCOLUMN_START;
usColumn = 0;
}
}
else
{
/* Move back to the first column of the next line. */
ucLine += mainROW_INCREMENT;
usRefColumn = mainCOLUMN_START;
usColumn = 0;
}
/* Wrap back to the top of the display. */
if( ucLine >= mainMAX_LINE )
{
ucLine = 0;
}
return ch;
}
/**
* @brief Displays the current time.
* @param None
* @retval None
*/
void Time_Display(void)
{
/* Clear Line13 */
LCD_ClearLine(LCD_LINE_13);
/* Display time separators ":" on Line4 */
LCD_DisplayChar(LCD_LINE_13, 212, ':');
LCD_DisplayChar(LCD_LINE_13, 166, ':');
/* Get the current Time */
RTC_GetTime(RTC_Format_BIN, &RTC_TimeStructure);
/* Display time hours */
LCD_DisplayChar(LCD_LINE_13, 244,((RTC_TimeStructure.RTC_Hours / 10) + 0x30));
LCD_DisplayChar(LCD_LINE_13, 228,((RTC_TimeStructure.RTC_Hours % 10) + 0x30));
/* Display time minutes */
LCD_DisplayChar(LCD_LINE_13, 196,((RTC_TimeStructure.RTC_Minutes /10) + 0x30));
LCD_DisplayChar(LCD_LINE_13, 182,((RTC_TimeStructure.RTC_Minutes % 10) + 0x30));
/* Display time seconds */
LCD_DisplayChar(LCD_LINE_13, 150,((RTC_TimeStructure.RTC_Seconds / 10) + 0x30));
LCD_DisplayChar(LCD_LINE_13, 134,((RTC_TimeStructure.RTC_Seconds % 10) + 0x30));
}
void lcdPutChar(char_t c)
{
if(c == '\r')
{
lcdColumn = 0;
}
else if(c == '\n')
{
lcdColumn = 0;
lcdLine++;
}
else if(lcdLine < 10 && lcdColumn < 20)
{
//Display current character
LCD_DisplayChar(lcdLine * 24, 319 - (lcdColumn * 16), c);
//Advance the cursor position
if(++lcdColumn >= 20)
{
lcdColumn = 0;
lcdLine++;
}
}
}
/*******************************************************************************
* Function Name : Time_Display
* Description : Displays the current time.
* Input : None
* Output : None
* Return : None
*******************************************************************************/
void Time_Display(uint32_t TimeVar)
{
/* Display time hours */
time_struct.hour_h=(uint8_t)( TimeVar / 3600)/10;
LCD_DisplayChar(Line8, 244,(time_struct.hour_h + 0x30));
time_struct.hour_l=(uint8_t)(((TimeVar)/3600)%10);
LCD_DisplayChar(Line8, 228,(time_struct.hour_l + 0x30));
/* Display time minutes */
time_struct.min_h=(uint8_t)(((TimeVar)%3600)/60)/10;
LCD_DisplayChar(Line8, 196,(time_struct.min_h + 0x30));
time_struct.min_l=(uint8_t)(((TimeVar)%3600)/60)%10;
LCD_DisplayChar(Line8, 182,(time_struct.min_l + 0x30));
/* Display time seconds */
time_struct.sec_h=(uint8_t)(((TimeVar)%3600)%60)/10;
LCD_DisplayChar(Line8, 150,(time_struct.sec_h + 0x30));
time_struct.sec_l=(uint8_t)(((TimeVar)%3600)%60)%10;
LCD_DisplayChar(Line8, 134,(time_struct.sec_l + 0x30));
}
/*******************************************************************************
* Function Name : Alarm_Display
* Description : Displays alarm time.
* Input : None
* Output : None
* Return : None
*******************************************************************************/
void Alarm_Display(uint32_t AlarmVar)
{
/* Display alarm hours */
alarm_struct.hour_h=(uint8_t)( AlarmVar / 3600)/10;
LCD_DisplayChar(Line8, 244,(alarm_struct.hour_h + 0x30));
alarm_struct.hour_l=(uint8_t)(((AlarmVar)/3600)%10);
LCD_DisplayChar(Line8, 228,(alarm_struct.hour_l + 0x30));
/* Display alarm minutes */
alarm_struct.min_h=(uint8_t)(((AlarmVar)%3600)/60)/10;
LCD_DisplayChar(Line8, 196,(alarm_struct.min_h + 0x30));
alarm_struct.min_l=(uint8_t)(((AlarmVar)%3600)/60)%10;
LCD_DisplayChar(Line8, 182,(alarm_struct.min_l + 0x30));
/* Display alarm seconds */
alarm_struct.sec_h=(uint8_t)(((AlarmVar)%3600)%60)/10;
LCD_DisplayChar(Line8, 150,(alarm_struct.sec_h + 0x30));
alarm_struct.sec_l=(uint8_t)(((AlarmVar)%3600)%60)%10;
LCD_DisplayChar(Line8, 134,(alarm_struct.sec_l + 0x30));
}
/**
* @brief USR_KEYBRD_ProcessData
* Process Keyboard data
* @param data : Keyboard data to be displayed
* @retval None
*/
void USR_KEYBRD_ProcessData (uint8_t data)
{
char temp[20];
if(DEMO_HID_ShowData == 0)
{
LCD_SetTextColor(LCD_COLOR_GREEN);
if(data == '\n')
{
Ypos = KYBRD_FIRST_COLUMN;
/*Increment char X position*/
Xpos+=SMALL_FONT_LINE_WIDTH;
}
else if (data == '\r')
{
/* Manage deletion of character and update cursor location*/
if( Ypos == KYBRD_FIRST_COLUMN)
{
/*First character of first line to be deleted*/
if(Xpos == KYBRD_FIRST_LINE)
{
Ypos =KYBRD_FIRST_COLUMN;
}
else
{
Xpos-=SMALL_FONT_LINE_WIDTH;
Ypos =(KYBRD_LAST_COLUMN+SMALL_FONT_COLUMN_WIDTH);
}
}
else
{
Ypos +=SMALL_FONT_COLUMN_WIDTH;
}
LCD_DisplayChar(Xpos,Ypos, ' ');
}
else
{
LCD_DisplayChar(Xpos,Ypos, data);
/* Update the cursor position on LCD */
/*Increment char Y position*/
Ypos -=SMALL_FONT_COLUMN_WIDTH;
/*Check if the Y position has reached the last column*/
if(Ypos == KYBRD_LAST_COLUMN)
{
Ypos = KYBRD_FIRST_COLUMN;
/*Increment char X position*/
Xpos+=SMALL_FONT_LINE_WIDTH;
if( Xpos > KYBRD_LAST_LINE)
{
Xpos =KYBRD_FIRST_LINE;
}
}
}
}
else
{
sprintf(temp ,"> %02xh %02xh %02xh %02xh\n" , HID_Machine.buff[0],
HID_Machine.buff[1],
HID_Machine.buff[2],
HID_Machine.buff[3]);
LCD_DbgLog(temp);
}
}
void LCD_Printf(const char *argList, ...)
{
const char *ptr;
va_list argp;
sint16_t v_num_s16;
sint32_t v_num_s32;
uint16_t v_num_u16;
uint32_t v_num_u32;
char *str;
char ch;
uint8_t v_numOfDigitsToDisp_u8;
#if (Enable_LCD_DisplayFloatNumber == 1)
double v_floatNum_f32;
#endif
va_start(argp, argList);
/* Loop through the list to extract all the input arguments */
for(ptr = argList; *ptr != '\0'; ptr++)
{
ch= *ptr;
if(ch == '%') /*Check for '%' as there will be format specifier after it */
{
ptr++;
ch = *ptr;
if((ch>=0x30) && (ch<=0x39))
{
v_numOfDigitsToDisp_u8 = 0;
while((ch>=0x30) && (ch<=0x39))
{
v_numOfDigitsToDisp_u8 = (v_numOfDigitsToDisp_u8 * 10) + (ch-0x30);
ptr++;
ch = *ptr;
}
}
else
{
v_numOfDigitsToDisp_u8 = C_MaxDigitsToDisplayUsingPrintf_U8;
}
switch(ch) /* Decode the type of the argument */
{
case 'C':
case 'c': /* Argument type is of char, hence read char data from the argp */
ch = va_arg(argp, int);
LCD_DisplayChar(ch);
break;
case 'd': /* Argument type is of signed integer, hence read 16bit data from the argp */
v_num_s16 = va_arg(argp, int);
if(v_num_s16<0)
{ /* If the number is -ve then display the 2's complement along with '-' sign */
v_num_s16 = -v_num_s16;
LCD_DisplayChar('-');
}
LCD_DisplayNumber(C_DECIMAL_U8,v_num_s16,v_numOfDigitsToDisp_u8);
break;
case 'D': /* Argument type is of integer, hence read 16bit data from the argp */
v_num_s32 = va_arg(argp, sint32_t);
if(v_num_s32<0)
{ /* If the number is -ve then display the 2's complement along with '-' sign */
v_num_s32 = -v_num_s32;
LCD_DisplayChar('-');
}
LCD_DisplayNumber(C_DECIMAL_U8,v_num_s32,v_numOfDigitsToDisp_u8);
break;
case 'u': /* Argument type is of unsigned integer, hence read 16bit unsigned data */
v_num_u16 = va_arg(argp, int);
LCD_DisplayNumber(C_DECIMAL_U8,v_num_u16,v_numOfDigitsToDisp_u8);
break;
case 'U': /* Argument type is of integer, hence read 32bit unsigend data */
v_num_u32 = va_arg(argp, uint32_t);
LCD_DisplayNumber(C_DECIMAL_U8,v_num_u32,v_numOfDigitsToDisp_u8);
break;
case 'x': /* Argument type is of hex, hence hexadecimal data from the argp */
v_num_u16 = va_arg(argp, int);
LCD_DisplayNumber(C_HEX_U8,v_num_u16,v_numOfDigitsToDisp_u8);
break;
case 'X': /* Argument type is of hex, hence hexadecimal data from the argp */
v_num_u32 = va_arg(argp, uint32_t);
LCD_DisplayNumber(C_HEX_U8,v_num_u32,v_numOfDigitsToDisp_u8);
break;
case 'b': /* Argument type is of binary,Read int and convert to binary */
v_num_u16 = va_arg(argp, int);
if(v_numOfDigitsToDisp_u8 == C_MaxDigitsToDisplayUsingPrintf_U8)
v_numOfDigitsToDisp_u8 = 16;
LCD_DisplayNumber(C_BINARY_U8,v_num_u16,v_numOfDigitsToDisp_u8);
break;
case 'B': /* Argument type is of binary,Read int and convert to binary */
v_num_u32 = va_arg(argp, uint32_t);
if(v_numOfDigitsToDisp_u8 == C_MaxDigitsToDisplayUsingPrintf_U8)
v_numOfDigitsToDisp_u8 = 16;
LCD_DisplayNumber(C_BINARY_U8,v_num_u32,v_numOfDigitsToDisp_u8);
break;
case 'F':
case 'f': /* Argument type is of float, hence read double data from the argp */
#if (Enable_LCD_DisplayFloatNumber == 1)
v_floatNum_f32 = va_arg(argp, double);
LCD_DisplayFloatNumber(v_floatNum_f32);
#endif
break;
case 'S':
case 's': /* Argument type is of string, hence get the pointer to sting passed */
str = va_arg(argp, char *);
LCD_DisplayString(str);
break;
case '%':
LCD_DisplayChar('%');
break;
}
}
else
{
/*******************************************************************************
* Function Name : Calendar_Init
* Description : Initializes calendar application.
* Input : None
* Output : None
* Return : None
*******************************************************************************/
void Calendar_Init(void)
{
uint32_t i = 0, tmp = 0, pressedkey = 0;
/* Initialize Date structure */
date_s.month = 01;
date_s.day = 01;
date_s.year = 2009;
if(BKP_ReadBackupRegister(BKP_DR1) != 0xA5A5)
{
LCD_SetBackColor(Blue);
LCD_SetTextColor(White);
LCD_DisplayStringLine(Line7, "Time and Date Config");
LCD_DisplayStringLine(Line8, "Select: Press SEL ");
LCD_DisplayStringLine(Line9, "Abort: Press Any Key");
while(1)
{
pressedkey = ReadKey();
if(pressedkey == SEL)
{
/* Adjust Time */
Time_PreAdjust();
return;
}
else if (pressedkey != NOKEY)
{
return;
}
}
}
else
{
/* PWR and BKP clocks selection ------------------------------------------*/
RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR | RCC_APB1Periph_BKP, ENABLE);
/* Allow access to BKP Domain */
PWR_BackupAccessCmd(ENABLE);
/* Wait until last write operation on RTC registers has finished */
RTC_WaitForLastTask();
/* Enable the RTC Second */
RTC_ITConfig(RTC_IT_SEC, ENABLE);
/* Wait until last write operation on RTC registers has finished */
RTC_WaitForLastTask();
/* Initialize Date structure */
date_s.month = (BKP_ReadBackupRegister(BKP_DR3) & 0xFF00) >> 8;
date_s.day = (BKP_ReadBackupRegister(BKP_DR3) & 0x00FF);
date_s.year = BKP_ReadBackupRegister(BKP_DR2);
daycolumn = BKP_ReadBackupRegister(BKP_DR4);
dayline = BKP_ReadBackupRegister(BKP_DR5);
if(RTC_GetCounter() / 86399 != 0)
{
for(i = 0; i < (RTC_GetCounter() / 86399); i++)
{
Date_Update();
}
RTC_SetCounter(RTC_GetCounter() % 86399);
LCD_DisplayStringLine(Line8, " Days elapsed ");
tmp = i/100;
LCD_DisplayChar(Line8, 276,(tmp + 0x30));
tmp = ((i%100)/10);
LCD_DisplayChar(Line8, 260,(tmp + 0x30));
tmp = ((i%100)%10);
LCD_DisplayChar(Line8, 244,(tmp + 0x30));
LCD_DisplayStringLine(Line9, " Press SEL ");
while(ReadKey() != SEL)
{
}
LCD_ClearLine(Line8);
LCD_ClearLine(Line9);
LCD_DisplayStringLine(Line9, "Push SEL to Continue");
Date_Display(date_s.year, date_s.month, date_s.day);
while(ReadKey() != SEL)
{
}
BKP_WriteBackupRegister(BKP_DR4, daycolumn);
BKP_WriteBackupRegister(BKP_DR5, dayline);
}
}
}
void LCD_DisplayNumber(uint8_t v_numericSystem_u8, uint32_t v_number_u32, uint8_t v_numOfDigitsToDisplay_u8)
{
uint8_t i=0,a[10];
if(C_BINARY_U8 == v_numericSystem_u8)
{
while(v_numOfDigitsToDisplay_u8!=0)
{
/* Start Extracting the bits from the specified bit positions.
Get the Acsii values of the bits and display */
i = util_GetBitStatus(v_number_u32,(v_numOfDigitsToDisplay_u8-1));
LCD_DisplayChar(util_Dec2Ascii(i));
v_numOfDigitsToDisplay_u8--;
}
}
else if(v_number_u32==0)
{
/* If the number is zero then display Specified number of zeros*/
/*TODO: Display single zero or multiple. Currently single zero is displayed*/
for(i=0;((i<v_numOfDigitsToDisplay_u8) && (i<C_MaxDigitsToDisplay_U8));i++)
LCD_DisplayChar('0');
}
else
{
for(i=0;i<v_numOfDigitsToDisplay_u8;i++)
{
/* Continue extracting the digits from right side
till the Specified v_numOfDigitsToDisplay_u8 */
if(v_number_u32!=0)
{
/* Extract the digits from the number till it becomes zero.
First get the remainder and divide the number by TypeOfNum(10-Dec, 16-Hex) each time.
example for Decimal number:
If v_number_u32 = 123 then extracted remainder will be 3 and number will be 12.
The process continues till it becomes zero or max digits reached*/
a[i]=util_GetMod32(v_number_u32,v_numericSystem_u8);
v_number_u32=v_number_u32/v_numericSystem_u8;
}
else if( (v_numOfDigitsToDisplay_u8 == C_DisplayDefaultDigits_U8) ||
(v_numOfDigitsToDisplay_u8 > C_MaxDigitsToDisplay_U8))
{
/* Stop the iteration if the Max number of digits are reached or
the user expects exact(Default) digits in the number to be displayed */
break;
}
else
{
/* In case user expects more digits to be displayed than the actual digits in number,
then update the remaining digits with zero.
Ex: v_num_u32 is 123 and user wants five digits then 00123 has to be displayed */
a[i]=0;
}
}
while(i!=0)
{
/* Finally get the ascii values of the digits and display*/
LCD_DisplayChar(util_Hex2Ascii(a[i-1]));
i--;
}
}
}
void Meter(uint16_t x,uint16_t y,uint16_t radius,float max,float min)
{
char num[100] ;//= "123456789";
float midpoint = (max + min)/2;
float range = max - min;
float angle = 0;
int16_t point2x;
int16_t point2y;
uint8_t buff_len;
// LCD_DisplayChar(30 ,40 ,0x55);
// sprintf(num,"%f",-3.33333);
// buff_len = strlen(num);
// sprintf(num,"%d",buff_len);
// LCD_DisplayChar(50 ,115 ,num[0]);
// LCD_DisplayChar(50 ,125 ,num[1]);
/*Line = x : Column = y*/
// LCD_DisplayChar(50 ,50 ,num[0]);
float i;
uint8_t k = 0;
uint8_t j = 0;
static uint8_t interval = 5;
uint8_t odd = 5;
for (i = min + range/10 ; i < max ; i += range/10)
{
angle += 360/10;
point2x = x - radius*sin(angle*3.14/180);
point2y = y + radius*cos(angle*3.14/180);
// LCD_DisplayChar(point2y,point2x,num[j]);
// j++;
sprintf(num,"%f",i);
buff_len = strlen(num);
for(j = 0; j < buff_len; j++)
{
if((buff_len % 2)==0)
{
LCD_DisplayChar(point2y,point2x-9,num[0]);
LCD_DisplayChar(point2y,point2x-3,num[1]);
LCD_DisplayChar(point2y,point2x+3,num[2]);
LCD_DisplayChar(point2y,point2x+9,num[3]);
}
else if((buff_len % 2)==1)
{
LCD_DisplayChar(point2y,point2x-12,num[0]);
LCD_DisplayChar(point2y,point2x-6,num[1]);
LCD_DisplayChar(point2y,point2x,num[2]);
LCD_DisplayChar(point2y,point2x+6,num[3]);
LCD_DisplayChar(point2y,point2x+12,num[4]);
}
}
}
//DrawThickCircle(x,y,radius-15,5);
}
/**
* @brief Main program.
* @param None
* @retval None
*/
int main(void)
{
/*!< At this stage the microcontroller clock setting is already configured,
this is done through SystemInit() function which is called from startup
file (startup_stm32f0xx.s) before to branch to application main.
To reconfigure the default setting of SystemInit() function, refer to
system_stm32f0xx.c file
*/
/* Initialize the LCD */
#ifdef USE_STM320518_EVAL
STM320518_LCD_Init();
#else
STM32072B_LCD_Init();
#endif /* USE_STM320518_EVAL */
/* Enable The Display */
LCD_DisplayOn();
/* Clear the Background Layer */
LCD_Clear(LCD_COLOR_WHITE);
/* Clear the LCD */
LCD_Clear(White);
/* Set the LCD Back Color */
LCD_SetBackColor(Blue);
/* Set the LCD Text Color */
LCD_SetTextColor(White);
/* Displays MESSAGE1 on line 0 */
LCD_DisplayStringLine(LINE(0), (uint8_t *)MESSAGE1);
/* RTC configuration */
RTC_Config();
/* Set the LCD Text Color */
LCD_SetTextColor(Red);
/* Displays a rectangle on the LCD */
LCD_DrawRect(80, 280, 25, 240 );
/* Configure the external interrupt "WAKEUP" and "TAMPER" buttons */
STM_EVAL_PBInit(BUTTON_SEL, BUTTON_MODE_EXTI);
STM_EVAL_PBInit(BUTTON_TAMPER, BUTTON_MODE_EXTI);
/* Configure RTC AlarmA register to generate 8 interrupts per 1 Second */
RTC_AlarmConfig();
/* set LCD Font */
LCD_SetFont(&Font12x12);
/* Set the LCD Back Color */
LCD_SetBackColor(White);
/* Set the LCD Text Color */
LCD_SetTextColor(Black);
/* Set the Back Color */
LCD_SetBackColor(LCD_COLOR_CYAN);
/* Displays MESSAGE2 and MESSAGE3 on the LCD */
LCD_DisplayStringLine(LINE(18), (uint8_t *)MESSAGE2);
LCD_DisplayStringLine(LINE(19), (uint8_t *)MESSAGE3);
/* Infinite loop */
while (1)
{
uint32_t tmp =0;
/* ALARM Interrupt */
if (ALARM_Occured)
{
if(RTCAlarmCount != 480)
{
/* Increament the counter of Alarma interrupts */
RTCAlarmCount++;
/* Set the LCD Back Color */
LCD_SetTextColor(Green);
/* Draw rectangle on the LCD */
LCD_DrawFullRect(81, 359, 80+ (((RTCAlarmCount)-1)/2) , 24);
/* Set the LCD text color */
LCD_SetTextColor(Red);
/* Display rectangle on the LCD */
LCD_DrawRect(80, 280, 25, 240 );
/* Define the rate of Progress bar */
tmp = (RTCAlarmCount * 100)/ 480;
/* Set the LCD Font */
LCD_SetFont(&Font16x24);
/* Display Char on the LCD : XXX% */
LCD_DisplayChar(LINE(2),200, (tmp / 100) +0x30);
LCD_DisplayChar(LINE(2),180, ((tmp % 100 ) / 10) +0x30);
LCD_DisplayChar(LINE(2),160, (tmp % 10) +0x30);
LCD_DisplayChar(LINE(2),140, 0x25);
}
else
{
/* Disable the RTC Clock */
RCC_RTCCLKCmd(DISABLE);
}
/* Reinitialize the ALARM variable */
ALARM_Occured = 0;
}
}
}
/**
* @brief Displays the current date.
* @param None
* @retval None
*/
void Date_Display(void)
{
/* Clear Line16 */
LCD_ClearLine(LCD_LINE_16);
/* Display time separators "/" on Line14 */
LCD_DisplayChar(LCD_LINE_16, 260, '/');
LCD_DisplayChar(LCD_LINE_16, 212, '/');
LCD_DisplayChar(LCD_LINE_16, 166, '/');
/* Get the current Date */
RTC_GetDate(RTC_Format_BIN, &RTC_DateStructure);
/* Display Date WeekDay */
LCD_DisplayChar(LCD_LINE_16, 276,((RTC_DateStructure.RTC_WeekDay) + 0x30));
/* Display Date Day */
LCD_DisplayChar(LCD_LINE_16, 244,((RTC_DateStructure.RTC_Date /10) + 0x30));
LCD_DisplayChar(LCD_LINE_16, 228,((RTC_DateStructure.RTC_Date % 10) + 0x30));
/* Display Date Month */
LCD_DisplayChar(LCD_LINE_16, 196,((RTC_DateStructure.RTC_Month / 10) + 0x30));
LCD_DisplayChar(LCD_LINE_16, 182,((RTC_DateStructure.RTC_Month % 10) + 0x30));
/* Display Date Year */
LCD_DisplayChar(LCD_LINE_16, 150, '2');
LCD_DisplayChar(LCD_LINE_16, 134, '0');
LCD_DisplayChar(LCD_LINE_16, 118,((RTC_DateStructure.RTC_Year / 10) + 0x30));
LCD_DisplayChar(LCD_LINE_16, 102,((RTC_DateStructure.RTC_Year % 10) + 0x30));
}
/*******************************************************************************
* Function Name : Alarm_Show
* Description : Shows alarm time (HH/MM/SS) on LCD.
* Input : None
* Output : None
* Return : None
*******************************************************************************/
void Alarm_Show(void)
{
uint32_t tmp = 0;
/* Disable the JoyStick interrupts */
IntExtOnOffConfig(DISABLE);
while(ReadKey() != NOKEY)
{
}
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_FSMC, ENABLE);
/* Clear the LCD screen */
LCD_Clear(White);
LCD_SetDisplayWindow(160, 223, 128, 128);
LCD_NORDisplay(ALARM_ICON);
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_FSMC, ENABLE);
/* Disable LCD Window mode */
LCD_WindowModeDisable();
/* Set the LCD Back Color */
LCD_SetBackColor(Blue);
/* Set the LCD Text Color */
LCD_SetTextColor(White);
if(BKP_ReadBackupRegister(BKP_DR1) != 0xA5A5)
{
LCD_DisplayStringLine(Line8, "Time not configured ");
LCD_DisplayStringLine(Line9, " Press SEL ");
while(ReadKey() == NOKEY)
{
}
/* Clear the LCD */
LCD_Clear(White);
/* Display the menu */
DisplayMenu();
/* Enable the JoyStick interrupts */
IntExtOnOffConfig(ENABLE);
return;
}
/* Read the alarm value stored in the Backup register */
tmp = BKP_ReadBackupRegister(BKP_DR6);
tmp |= BKP_ReadBackupRegister(BKP_DR7) << 16;
LCD_ClearLine(Line8);
/* Display alarm separators ":" on Line2 */
LCD_DisplayChar(Line8, 212, ':');
LCD_DisplayChar(Line8, 166, ':');
/* Display actual alarm value */
Alarm_Display(tmp);
/* Wait a press on pushbuttons */
while(ReadKey() != NOKEY)
{
}
/* Wait a press on pushbuttons */
while(ReadKey() == NOKEY)
{
}
/* Clear the LCD */
LCD_Clear(White);
/* Display the menu */
DisplayMenu();
/* Enable the JoyStick interrupts */
IntExtOnOffConfig(ENABLE);
}
/*******************************************************************************
* Function Name : LCD_DisplayString
* Description : Displays a maximum of 200 char on the LCD.
* Input : - Line: the starting Line where to display the character shape.
* This parameter can be one of the following values:
* - Linex: where x can be 0..9
* - *ptr: pointer to string to display on LCD.
* Output : None
* Return : None
*******************************************************************************/
void LCD_DisplayString(u8 Line, u8 *ptr)
{
u32 i = 0, column = 0, index = 0, spaceindex = 0;
u16 refcolumn = 319;
u32 length = 0;
/* Get the string length */
length = StrLength(ptr);
if(length > 200)
{
/* Set the Cursor position */
LCD_SetCursor(Line, 0x013F);
/* Clear the Selected Line */
LCD_ClearLine(Line);
LCD_DisplayStringLine(Line, " String too long ");
}
else
{
/* Set the Cursor position */
LCD_SetCursor(Line, 0x013F);
/* Clear the Selected Line */
// LCD_ClearLine(Line);
while(length--)
{
if(index == 20)
{
if(*ptr == 0x20)
{
ptr++;
}
else
{
for(i = 0; i < spaceindex; i++)
{
LCD_DisplayChar(Line, column, ' ');
column -= 16;
}
ptr -= (spaceindex - 1);
length += (spaceindex - 1);
}
Line += 24;
/* Clear the Selected Line */
// LCD_ClearLine(Line);
refcolumn = 319;
index = 0;
}
/* Display one character on LCD */
LCD_DisplayChar(Line, refcolumn, *ptr);
/* Increment character number in one line */
index++;
/* Decrement the column position by 16 */
refcolumn -= 16;
/* Point on the next character */
ptr++;
/* Increment the number of character after the last space */
spaceindex++;
if(*ptr == 0x20)
{
spaceindex = 0;
column = refcolumn - 16;
}
}
}
}
/*******************************************************************************
* Function Name : Date_Show
* Description : Shows date in a graphic mode on LCD.
* Input : None
* Output : None
* Return : None
*******************************************************************************/
void Date_Show(void)
{
uint32_t tmpValue = 0;
uint32_t MyKey = 0, ValueMax = 0;
uint32_t firstdaycolumn = 0, lastdaycolumn = 0, lastdayline = 0;
uint32_t testvalue = 0, pressedkey = 0;
/* Disable the JoyStick interrupts */
IntExtOnOffConfig(DISABLE);
LCD_Clear(White);
while(ReadKey()!= NOKEY)
{
}
LCD_SetBackColor(Blue);
LCD_SetTextColor(White);
if(BKP_ReadBackupRegister(BKP_DR1) != 0xA5A5)
{
LCD_DisplayStringLine(Line7, "Time and Date Config");
LCD_DisplayStringLine(Line8, "Select: Press SEL ");
LCD_DisplayStringLine(Line9, "Abort: Press Any Key");
while(testvalue == 0)
{
pressedkey = ReadKey();
if(pressedkey == SEL)
{
/* Adjust Time */
Time_PreAdjust();
/* Clear the LCD */
LCD_Clear(White);
testvalue = 0x01;
}
else if (pressedkey != NOKEY)
{
/* Clear the LCD */
LCD_Clear(White);
/* Display the menu */
DisplayMenu();
/* Enable the JoyStick interrupts */
IntExtOnOffConfig(ENABLE);
return;
}
}
}
/* Clear the LCD */
LCD_Clear(White);
LCD_DisplayStringLine(Line9, " To Exit Press SEL ");
/* Display the current date */
Date_Display(date_s.year, date_s.month, date_s.day);
if(date_s.month == 2)
{
if(IsLeapYear(date_s.year))
{
ValueMax = 29;
}
else
{
ValueMax = (MonLen[date_s.month - 1] - 1);
}
}
else
{
ValueMax = (MonLen[date_s.month - 1] - 1);
}
firstdaycolumn = 0x13F - (0x30 * dn);
lastdaycolumn = ValueMax - (7 - dn);
lastdayline = lastdaycolumn / 7;
lastdaycolumn %= 7;
if(lastdaycolumn == 0)
{
lastdayline = Line3 + (lastdayline * 24);
lastdaycolumn = 31;
}
else
{
lastdayline = Line4 + (lastdayline * 24);
lastdaycolumn = 0x13F -(0x30 * (lastdaycolumn - 1));
}
/* Initialize tmpValue */
tmpValue = date_s.day;
/* Endless loop */
while(1)
{
/* Check which key is pressed */
MyKey = ReadKey();
/* If "RIGHT" pushbutton is pressed */
if(MyKey == RIGHT)
{
LCD_SetTextColor(White);
LCD_DrawRect(dayline, daycolumn, 24, 32);
/* Increase the value of the digit */
if(tmpValue == ValueMax)
{
tmpValue = 0;
dayline = Line3;
daycolumn = firstdaycolumn + 48;
}
if(daycolumn == 31)
{
daycolumn = 367;
dayline += 24;
}
daycolumn -= 48;
LCD_SetTextColor(Red);
LCD_DrawRect(dayline, daycolumn, 24, 32);
tmpValue++;
WeekDayNum(date_s.year, date_s.month, tmpValue);
LCD_SetBackColor(Blue2);
LCD_SetTextColor(White);
LCD_DisplayStringLine(Line1, " WEEK DAY N: ");
if(wn/10)
{
LCD_DisplayChar(Line1, 223, ((wn/10)+ 0x30));
LCD_DisplayChar(Line1, 207, ((wn%10)+ 0x30));
}
else
{
LCD_DisplayChar(Line1, 223, ((wn%10)+ 0x30));
}
if(dc/100)
{
LCD_DisplayChar(Line1, 47, ((dc/100)+ 0x30));
LCD_DisplayChar(Line1, 31, (((dc%100)/10)+ 0x30));
LCD_DisplayChar(Line1, 15, (((dc%100)%10)+ 0x30));
}
else if(dc/10)
{
LCD_DisplayChar(Line1, 47, ((dc/10)+ 0x30));
LCD_DisplayChar(Line1, 31, ((dc%10)+ 0x30));
}
else
{
LCD_DisplayChar(Line1, 47, ((dc%10)+ 0x30));
}
LCD_SetBackColor(White);
}
/* If "LEFT" pushbutton is pressed */
if(MyKey == LEFT)
{
LCD_SetTextColor(White);
LCD_DrawRect(dayline, daycolumn, 24, 32);
/* Decrease the value of the digit */
if(tmpValue == 1)
{
tmpValue = ValueMax + 1;
dayline = lastdayline;
daycolumn = lastdaycolumn - 48;
}
if(daycolumn == 319)
{
daycolumn = 0xFFEF;
dayline -= 24;
}
daycolumn += 48;
LCD_SetTextColor(Red);
LCD_DrawRect(dayline, daycolumn, 24, 32);
tmpValue--;
WeekDayNum(date_s.year, date_s.month, tmpValue);
LCD_SetBackColor(Blue2);
LCD_SetTextColor(White);
LCD_DisplayStringLine(Line1, " WEEK DAY N: ");
if(wn/10)
{
LCD_DisplayChar(Line1, 223, ((wn/10)+ 0x30));
LCD_DisplayChar(Line1, 207, ((wn%10)+ 0x30));
}
else
{
LCD_DisplayChar(Line1, 223, ((wn%10)+ 0x30));
}
if(dc/100)
{
LCD_DisplayChar(Line1, 47, ((dc/100)+ 0x30));
LCD_DisplayChar(Line1, 31, (((dc%100)/10)+ 0x30));
LCD_DisplayChar(Line1, 15, (((dc%100)%10)+ 0x30));
}
else if(dc/10)
{
LCD_DisplayChar(Line1, 47, ((dc/10)+ 0x30));
LCD_DisplayChar(Line1, 31, ((dc%10)+ 0x30));
}
else
{
LCD_DisplayChar(Line1, 47, ((dc%10)+ 0x30));
}
LCD_SetBackColor(White);
}
/* If "UP" pushbutton is pressed */
if(MyKey == UP)
{
LCD_SetTextColor(White);
LCD_DrawRect(dayline, daycolumn, 24, 32);
if(tmpValue == 1)
{
dayline = lastdayline;
daycolumn = lastdaycolumn;
tmpValue = ValueMax;
}
else if(tmpValue < 8)
{
tmpValue = 1;
dayline = Line3;
daycolumn = firstdaycolumn;
}
else
{
dayline -= 24;
tmpValue -= 7;
}
LCD_SetTextColor(Red);
LCD_DrawRect(dayline, daycolumn, 24, 32);
WeekDayNum(date_s.year, date_s.month, tmpValue);
LCD_SetBackColor(Blue2);
LCD_SetTextColor(White);
LCD_DisplayStringLine(Line1, " WEEK DAY N: ");
if(wn/10)
{
LCD_DisplayChar(Line1, 223, ((wn/10)+ 0x30));
LCD_DisplayChar(Line1, 207, ((wn%10)+ 0x30));
}
else
{
LCD_DisplayChar(Line1, 223, ((wn%10)+ 0x30));
}
if(dc/100)
{
LCD_DisplayChar(Line1, 47, ((dc/100)+ 0x30));
LCD_DisplayChar(Line1, 31, (((dc%100)/10)+ 0x30));
LCD_DisplayChar(Line1, 15, (((dc%100)%10)+ 0x30));
}
else if(dc/10)
{
LCD_DisplayChar(Line1, 47, ((dc/10)+ 0x30));
LCD_DisplayChar(Line1, 31, ((dc%10)+ 0x30));
}
else
{
LCD_DisplayChar(Line1, 47, ((dc%10)+ 0x30));
}
LCD_SetBackColor(White);
}
/* If "DOWN" pushbutton is pressed */
if(MyKey == DOWN)
{
LCD_SetTextColor(White);
LCD_DrawRect(dayline, daycolumn, 24, 32);
if(tmpValue == ValueMax)
{
dayline = Line3;
daycolumn = firstdaycolumn;
tmpValue = 1;
}
else
{
dayline += 24;
tmpValue += 7;
}
if(tmpValue > ValueMax)
{
tmpValue = ValueMax;
dayline = lastdayline;
daycolumn = lastdaycolumn;
}
LCD_SetTextColor(Red);
LCD_DrawRect(dayline, daycolumn, 24, 32);
WeekDayNum(date_s.year, date_s.month, tmpValue);
LCD_SetBackColor(Blue2);
LCD_SetTextColor(White);
LCD_DisplayStringLine(Line1, " WEEK DAY N: ");
if(wn/10)
{
LCD_DisplayChar(Line1, 223, ((wn/10)+ 0x30));
LCD_DisplayChar(Line1, 207, ((wn%10)+ 0x30));
}
else
{
LCD_DisplayChar(Line1, 223, ((wn%10)+ 0x30));
}
if(dc/100)
{
LCD_DisplayChar(Line1, 47, ((dc/100)+ 0x30));
LCD_DisplayChar(Line1, 31, (((dc%100)/10)+ 0x30));
LCD_DisplayChar(Line1, 15, (((dc%100)%10)+ 0x30));
}
else if(dc/10)
{
LCD_DisplayChar(Line1, 47, ((dc/10)+ 0x30));
LCD_DisplayChar(Line1, 31, ((dc%10)+ 0x30));
}
else
{
LCD_DisplayChar(Line1, 47, ((dc%10)+ 0x30));
}
LCD_SetBackColor(White);
}
/* If "SEL" pushbutton is pressed */
if(MyKey == SEL)
{
/* Clear the LCD */
LCD_Clear(White);
/* Display the menu */
DisplayMenu();
/* Enable the JoyStick interrupts */
IntExtOnOffConfig(ENABLE);
return;
}
}
}
/*******************************************************************************
* Function Name : Date_Display
* Description : Displays the date in a graphic mode.
* Input : None
* Output : None
* Return : None
*******************************************************************************/
void Date_Display(uint16_t nYear, uint8_t nMonth, uint8_t nDay)
{
uint32_t mline = 0, mcolumn = 319, month = 0;
uint32_t monthlength = 0;
if(nMonth == 2)
{
if(IsLeapYear(nYear))
{
monthlength = 30;
}
else
{
monthlength = MonLen[nMonth - 1];
}
}
else
{
monthlength = MonLen[nMonth - 1];
}
/* Set the Back Color */
LCD_SetBackColor(Blue2);
/* Set the Text Color */
LCD_SetTextColor(Yellow);
LCD_DisplayStringLine(Line0, MonthNames[nMonth - 1]);
LCD_DisplayChar(Line0, 95, ((nYear/1000)+ 0x30));
LCD_DisplayChar(Line0, 79, (((nYear%1000)/100)+ 0x30));
LCD_DisplayChar(Line0, 63, ((((nYear%1000)%100)/10)+ 0x30));
LCD_DisplayChar(Line0, 47, ((((nYear%1000)%100)%10)+ 0x30));
WeekDayNum(nYear, nMonth, nDay);
LCD_SetTextColor(White);
LCD_DisplayStringLine(Line1, " WEEK DAY N: ");
if(wn/10)
{
LCD_DisplayChar(Line1, 223, ((wn/10)+ 0x30));
LCD_DisplayChar(Line1, 207, ((wn%10)+ 0x30));
}
else
{
LCD_DisplayChar(Line1, 223, ((wn%10)+ 0x30));
}
if(dc/100)
{
LCD_DisplayChar(Line1, 47, ((dc/100)+ 0x30));
LCD_DisplayChar(Line1, 31, (((dc%100)/10)+ 0x30));
LCD_DisplayChar(Line1, 15, (((dc%100)%10)+ 0x30));
}
else if(dc/10)
{
LCD_DisplayChar(Line1, 47, ((dc/10)+ 0x30));
LCD_DisplayChar(Line1, 31, ((dc%10)+ 0x30));
}
else
{
LCD_DisplayChar(Line1, 47, ((dc%10)+ 0x30));
}
/* Set the Back Color */
LCD_SetBackColor(Red);
LCD_SetTextColor(White);
LCD_DisplayStringLine(Line2, "Mo Tu We Th Fr Sa Su");
LCD_SetBackColor(White);
LCD_SetTextColor(Blue2);
/* Determines the week number, day of the week of the selected date */
WeekDayNum(nYear, nMonth, 1);
mline = Line3;
mcolumn = 0x13F - (0x30 * dn);
for(month = 1; month < monthlength; month++)
{
if(month == nDay)
{
daycolumn = mcolumn;
dayline = mline;
}
if(month/10)
{
LCD_DisplayChar(mline, mcolumn, ((month/10)+ 0x30));
}
else
{
LCD_DisplayChar(mline, mcolumn, ' ');
}
mcolumn -= 16;
LCD_DisplayChar(mline, mcolumn, ((month%10)+ 0x30));
if(mcolumn < 31)
{
mcolumn = 319;
mline += 24;
}
else
{
mcolumn -= 16;
LCD_DisplayChar(mline, mcolumn, ' ');
mcolumn -= 16;
}
}
LCD_SetTextColor(Red);
LCD_DrawRect(dayline, daycolumn, 24, 32);
}
/*******************************************************************************
* Function Name : Time_Show
* Description : Shows the current time (HH/MM/SS) on LCD.
* Input : None
* Output : None
* Return : None
******************************************************************************/
void Time_Show(void)
{
uint32_t testvalue = 0, pressedkey = 0;
/* Set the Back Color */
LCD_SetBackColor(White);
/* Set the Text Color */
LCD_SetTextColor(Blue);
/* Disable the JoyStick interrupts */
IntExtOnOffConfig(DISABLE);
while(ReadKey()!= NOKEY)
{
}
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_FSMC, ENABLE);
/* Clear the LCD screen */
LCD_Clear(White);
LCD_SetDisplayWindow(160, 223, 128, 128);
LCD_NORDisplay(WATCH_ICON);
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_FSMC, ENABLE);
/* Disable LCD Window mode */
LCD_WindowModeDisable();
if(BKP_ReadBackupRegister(BKP_DR1) != 0xA5A5)
{
LCD_DisplayStringLine(Line7, "Time and Date Config");
LCD_DisplayStringLine(Line8, "Select: Press SEL ");
LCD_DisplayStringLine(Line9, "Abort: Press Any Key");
while(testvalue == 0)
{
pressedkey = ReadKey();
if(pressedkey == SEL)
{
/* Adjust Time */
Time_PreAdjust();
/* Clear the LCD */
LCD_Clear(White);
testvalue = 0x01;
}
else if (pressedkey != NOKEY)
{
/* Clear the LCD */
LCD_ClearLine(Line8);
/* Display the menu */
DisplayMenu();
/* Enable the JoyStick interrupts */
IntExtOnOffConfig(ENABLE);
return;
}
}
/* Display time separators ":" on Line8 */
LCD_DisplayChar(Line8, 212, ':');
LCD_DisplayChar(Line8, 166, ':');
/* Wait a press on any JoyStick pushbuttons */
while(ReadKey() == NOKEY)
{
/* Display current time */
Time_Display(RTC_GetCounter());
}
}
else
{
while(ReadKey() != NOKEY)
{
}
/* Display time separators ":" on Line8 */
LCD_DisplayChar(Line8, 212, ':');
LCD_DisplayChar(Line8, 166, ':');
/* Wait a press on any JoyStick pushbuttons */
while(ReadKey() == NOKEY)
{
/* Display current time */
Time_Display(RTC_GetCounter());
}
}
/* Clear the LCD */
LCD_ClearLine(Line8);
/* Display the menu */
DisplayMenu();
/* Enable the JoyStick interrupts */
IntExtOnOffConfig(ENABLE);
}
/*******************************************************************************
* Function Name : Time_PreAdjust
* Description : Returns the time entered by user, using demoboard keys.
* Input : None
* Output : None
* Return : None
*******************************************************************************/
static void Time_PreAdjust(void)
{
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_FSMC, ENABLE);
/* Clear the LCD screen */
LCD_Clear(White);
LCD_SetDisplayWindow(160, 223, 128, 128);
LCD_NORDisplay(WATCH_ICON);
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_FSMC, ENABLE);
/* Disable LCD Window mode */
LCD_WindowModeDisable();
if(BKP_ReadBackupRegister(BKP_DR1) != 0xA5A5)
{
RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR | RCC_APB1Periph_BKP, ENABLE);
/* Allow access to BKP Domain */
PWR_BackupAccessCmd(ENABLE);
LCD_DisplayStringLine(Line7, "RTC Config PLZ Wait.");
/* RTC Configuration */
RTC_Configuration();
LCD_DisplayStringLine(Line7, " TIME ");
/* Clear Line8 */
LCD_ClearLine(Line8);
/* Display time separators ":" on Line4 */
LCD_DisplayChar(Line8, 212, ':');
LCD_DisplayChar(Line8, 166, ':');
/* Display the current time */
Time_Display(RTC_GetCounter());
/* Wait until last write operation on RTC registers has finished */
RTC_WaitForLastTask();
/* Change the current time */
RTC_SetCounter(Time_Regulate());
BKP_WriteBackupRegister(BKP_DR1, 0xA5A5);
/* Clear Line7 */
LCD_ClearLine(Line7);
/* Clear Line8 */
LCD_ClearLine(Line8);
/* Adjust Date */
Date_PreAdjust();
}
else
{
/* Clear Line8 */
LCD_ClearLine(Line8);
/* Display time separators ":" on Line4 */
LCD_DisplayChar(Line8, 212, ':');
LCD_DisplayChar(Line8, 166, ':');
/* Display the current time */
Time_Display(RTC_GetCounter());
/* Wait until last write operation on RTC registers has finished */
RTC_WaitForLastTask();
/* Change the current time */
RTC_SetCounter(Time_Regulate());
}
}
/**
* @brief Calibration of External crystal oscillator auto(through Timer
*
* @param None
* @retval : None
*/
void AutoClockCalibration(void)
{
RCC_ClocksTypeDef ClockValue;
uint16_t TimerPrescalerValue=0x0003;
uint16_t CountWait;
uint16_t DeviationInteger;
uint32_t CalibrationTimer;
float f32_Deviation;
TIM_ICInitTypeDef TIM_ICInitStructure;
TIM_DeInit(TIM2);
BKP_TamperPinCmd(DISABLE);
BKP_RTCOutputConfig(BKP_RTCOutputSource_CalibClock);
/* TIM2 configuration: PWM Input mode ------------------------
The external signal is connected to TIM2 CH2 pin (PA.01),
The Rising edge is used as active edge,
The TIM2 CCR2 is used to compute the frequency value
The TIM2 CCR1 is used to compute the duty cycle value
------------------------------------------------------------ */
TIM_PrescalerConfig(TIM2,TimerPrescalerValue,TIM_PSCReloadMode_Immediate);
TIM_ICInitStructure.TIM_Channel = TIM_Channel_2;
TIM_ICInitStructure.TIM_ICPolarity = TIM_ICPolarity_Rising;
TIM_ICInitStructure.TIM_ICSelection = TIM_ICSelection_DirectTI;
TIM_ICInitStructure.TIM_ICPrescaler = TIM_ICPSC_DIV1;
TIM_ICInitStructure.TIM_ICFilter = 0x00;
TIM_PWMIConfig(TIM2, &TIM_ICInitStructure);
TIM_ICInit(TIM2, &TIM_ICInitStructure);
/* Select the TIM2 Input Trigger: TI2FP2 */
TIM_SelectInputTrigger(TIM2, TIM_TS_TI2FP2);
/* Select the slave Mode: Reset Mode */
TIM_SelectSlaveMode(TIM2, TIM_SlaveMode_Reset);
/* Enable the Master/Slave Mode */
TIM_SelectMasterSlaveMode(TIM2, TIM_MasterSlaveMode_Enable);
/* TIM enable Counter */
TIM_Cmd(TIM2, ENABLE);
LCD_Clear(Blue2);
LCD_DisplayString(Line4,Column1,"Please Wait.....");
/* Wait for 2 seconds */
CalibrationTimer = RTC_GetCounter();
while((RTC_GetCounter() - CalibrationTimer) < 2)
{
}
RCC_GetClocksFreq(&ClockValue);
TimerFrequency=(ClockValue.PCLK1_Frequency * 2)/(TimerPrescalerValue+1);
/* Enable the CC2 Interrupt Request */
TIM_ITConfig(TIM2, TIM_IT_CC2, ENABLE);
/* Wait for 2 seconds */
CalibrationTimer = RTC_GetCounter();
while((RTC_GetCounter() - CalibrationTimer) < 2)
{
}
if(!(TIM_GetFlagStatus(TIM2, TIM_FLAG_CC1)))
/* There is no signal at the timer TIM2 peripheral input */
{
LCD_Clear(Blue2);
LCD_DisplayString(Line3,Column0,"Please connect wire");
LCD_DisplayString(Line4,Column0,"link between PC13");
LCD_DisplayString(Line5,Column0,"and PA1");
LCD_DisplayString(Line7,Column0,"No calibration done");
}
else
{
/* Calulate Deviation in ppm using the formula :
Deviation in ppm = (Deviation from 511.968/511.968)*1 million*/
if(f32_Frequency > 511.968)
{
f32_Deviation=((f32_Frequency-511.968)/511.968)*1000000;
}
else
{
f32_Deviation=((511.968-f32_Frequency)/511.968)*1000000;
}
DeviationInteger = (uint16_t)f32_Deviation;
if(f32_Deviation >= (DeviationInteger + 0.5))
{
DeviationInteger = ((uint16_t)f32_Deviation)+1;
}
CountWait=0;
/* Frequency deviation in ppm should be les than equal to 121 ppm*/
if(DeviationInteger <= 121)
{
while(CountWait<128)
{
if(CalibrationPpm[CountWait] == DeviationInteger)
break;
CountWait++;
}
BKP_SetRTCCalibrationValue(CountWait);
LCD_Clear(Blue2);
LCD_DisplayString(Line4,Column1,"Calibration Value");
LCD_DisplayChar(Line5,Column10,(CountWait%10)+0x30);
CountWait=CountWait/10;
LCD_DisplayChar(Line5,Column9,(CountWait%10)+0x30);
CountWait=CountWait/10;
if(CountWait>0)
{
LCD_DisplayChar(Line5,Column8,(CountWait%10)+0x30);
}
}
else /* Frequency deviation in ppm is more than 121 ppm, hence calibration
can not be done */
{
LCD_Clear(Blue2);
LCD_DisplayString(Line3,Column1,"Out Of Calibration");
LCD_DisplayString(Line4,Column4,"Range");
}
}
BKP_RTCOutputConfig(BKP_RTCOutputSource_None);
TIM_ITConfig(TIM2, TIM_IT_CC2, DISABLE);
TIM_Cmd(TIM2, DISABLE);
TIM_DeInit(TIM2);
CalibrationTimer=RTC_GetCounter();
/* Wait for 2 seconds */
while((RTC_GetCounter() - CalibrationTimer) < 5)
{
}
MenuInit();
}
/**
* @brief Set Grid
* @param void
* @retval Null
*/
void setGrid(){
LCD_SetFont(&Font8x8);
LCD_SetTextColor(LCD_COLOR_BLACK);
int i, j;
//Draws horizontal lines
for(i =20; i <= 300; i +=10)
{
LCD_DrawLine(20, i, 200, LCD_DIR_HORIZONTAL);
}
//Draws vertical lines
for(j = 20; j <= 220; j +=10)
{
LCD_DrawLine(j, 20, 280, LCD_DIR_VERTICAL);
}
LCD_DisplayStringLine(310, (uint8_t*)" Y DISPLACEMENT ");
LCD_DisplayChar(90, 10, (uint8_t)'X');
LCD_DisplayChar(110, 10, (uint8_t)'D');
LCD_DisplayChar(120, 10, (uint8_t)'I');
LCD_DisplayChar(130, 10, (uint8_t)'S');
LCD_DisplayChar(140, 10, (uint8_t)'P');
LCD_DisplayChar(150, 10, (uint8_t)'L');
LCD_DisplayChar(160, 10, (uint8_t)'A');
LCD_DisplayChar(170, 10, (uint8_t)'C');
LCD_DisplayChar(180, 10, (uint8_t)'E');
LCD_DisplayChar(190, 10, (uint8_t)'M');
LCD_DisplayChar(200, 10, (uint8_t)'E');
LCD_DisplayChar(210, 10, (uint8_t)'N');
LCD_DisplayChar(220, 10, (uint8_t)'T');
LCD_SetFont(&Font12x12);
LCD_SetTextColor(LCD_COLOR_RED);
}
/**
* @brief Returns the time entered by user, using menu navigation keys.
* @param None
* @retval Current date value
*/
void Date_Regulate(void)
{
uint8_t weekday = 0, date = 0, month = 0, year = 0;
LCD_DisplayStringLine(LCD_LINE_15, "Set date: Weekday / Date / Month / Year");
/* Read Date Weekday */
weekday = ReadDigit(LCD_LINE_16, 276, (RTC_DateStructure.RTC_WeekDay / 10), 0x7, 0x1);
/* Read Date Day */
date = ReadDigit(LCD_LINE_16, 244, (RTC_DateStructure.RTC_Date / 10), 3, 0x0);
if(date == 3)
{
if((RTC_DateStructure.RTC_Date % 10) > 1)
{
RTC_DateStructure.RTC_Date = 0;
}
date = date * 10 + ReadDigit(LCD_LINE_16, 228, (RTC_DateStructure.RTC_Date % 10), 0x1, 0x0);
}
else
{
date = date * 10 + ReadDigit(LCD_LINE_16, 228, (RTC_DateStructure.RTC_Date % 10), 0x9, 0x0);
}
/* Read Date Month */
month = ReadDigit(LCD_LINE_16, 196, (RTC_DateStructure.RTC_Month / 10), 1, 0x0);
if(month == 1)
{
if((RTC_DateStructure.RTC_Month % 10) > 2)
{
RTC_DateStructure.RTC_Month = 0;
}
month = month * 10 + ReadDigit(LCD_LINE_16, 182, (RTC_DateStructure.RTC_Month % 10), 0x2, 0x0);
}
else
{
month = month * 10 + ReadDigit(LCD_LINE_16, 182, (RTC_DateStructure.RTC_Month % 10), 0x9, 0x0);
}
/* Read Date Year */
LCD_DisplayChar(LCD_LINE_16, 150, '2');
LCD_DisplayChar(LCD_LINE_16, 134, '0');
year = ReadDigit(LCD_LINE_16, 118, (RTC_DateStructure.RTC_Year / 10), 0x9, 0x0);
year = year * 10 + ReadDigit(LCD_LINE_16, 102, (RTC_DateStructure.RTC_Year % 10), 0x9, 0x0);
RTC_DateStructure.RTC_WeekDay = weekday;
RTC_DateStructure.RTC_Date = date;
RTC_DateStructure.RTC_Month = month;
RTC_DateStructure.RTC_Year = year;
RTC_SetDate(RTC_Format_BIN, &RTC_DateStructure);
/* Set the Back Color */
LCD_SetBackColor(LCD_COLOR_BLACK);
/* Set the Text Color */
LCD_SetTextColor(LCD_COLOR_WHITE);
/* Clear Line15 */
LCD_ClearLine(LCD_LINE_15);
}
/**
* @brief Display LCD
* @param Pre-Set Argument
* @retval Null
*/
void DisplayLCD(void const *argument){
char* s;
int cnt, i = 0;
LCD_Clear(LCD_COLOR_WHITE);
LCD_SetFont(&Font8x8);
LCD_SetTextColor(LCD_COLOR_BLACK);
LCD_DisplayStringLine(1, (uint8_t*)" NOW DISPLAYING TRAJECTORY ");
LCD_DisplayStringLine(310, (uint8_t*)" Y DISPLACEMENT ");
LCD_DisplayChar(90, 10, (uint8_t)'X');
LCD_DisplayChar(110, 10, (uint8_t)'D');
LCD_DisplayChar(120, 10, (uint8_t)'I');
LCD_DisplayChar(130, 10, (uint8_t)'S');
LCD_DisplayChar(140, 10, (uint8_t)'P');
LCD_DisplayChar(150, 10, (uint8_t)'L');
LCD_DisplayChar(160, 10, (uint8_t)'A');
LCD_DisplayChar(170, 10, (uint8_t)'C');
LCD_DisplayChar(180, 10, (uint8_t)'E');
LCD_DisplayChar(190, 10, (uint8_t)'M');
LCD_DisplayChar(200, 10, (uint8_t)'E');
LCD_DisplayChar(210, 10, (uint8_t)'N');
LCD_DisplayChar(220, 10, (uint8_t)'T');
//setGrid();
while(1){
if((cnt > 1)&&(received[0] < 255)&&(received[1] < 255))
{
LCD_DrawUniLine((uint16_t)(120+received[0]*5), (uint16_t)(160-received[1]*5), plot[0], plot[1]);
}
plot[0] = (uint16_t)(120+received[0]*5); //0.862745
plot[1] = (uint16_t)(160-received[1]*5); //1.176
cnt++;
osDelay(200);
}
}
/**
* @brief This function handles External lines 9 to 5 interrupt request.
* @param None
* @retval None
*/
void EXTI9_5_IRQHandler(void)
{
uint32_t tmp = 0, tmp1 = 0;
uint8_t index = 0;
if((EXTI_GetITStatus(LEFT_BUTTON_EXTI_LINE) != RESET) )
{
/* Set the LCD Back Color */
LCD_SetBackColor(White);
StartEvent = 0;
/* Reset Counter*/
RTCAlarmCount = 0;
/* Disable the alarm */
RTC_AlarmCmd(RTC_Alarm_A, DISABLE);
/* Display Char on the LCD : XXX% */
LCD_DisplayChar(40,110,0x30);
LCD_DisplayChar(40,88, 0x30);
LCD_DisplayChar(40,66, 0x30);
LCD_DisplayChar(40,44, 0x25);
for (index = 0; index < 100 ; index++)
{
if ((index % 2) ==0)
{
/* Set the LCD Text Color */
LCD_SetTextColor(Blue);
LCD_DrawLine(70 + (index/2) , 120 - (index/2) , 101 - (index + 1) ,Horizontal);
/* Set the LCD Text Color */
LCD_SetTextColor(White);
LCD_DrawLine(170 - (index/2) , 120 - (index/2) , 101 - (index + 1) ,Horizontal);
}
}
/* Displays MESSAGE6 on line 5 */
LCD_SetFont(&Font12x12);
/* Set the LCD Back Color */
LCD_SetBackColor(Blue);
LCD_SetTextColor(White);
LCD_DisplayStringLine(LINE(19), (uint8_t *)MESSAGE6);
LCD_SetFont(&Font16x24);
/* Set the LCD Text Color */
LCD_SetTextColor(Black);
/* Clear the LEFT EXTI pending bit */
EXTI_ClearITPendingBit(LEFT_BUTTON_EXTI_LINE);
}
else if (EXTI_GetITStatus(RIGHT_BUTTON_EXTI_LINE) != RESET)
{
if(StartEvent == 8)
{
StartEvent = 0;
/* Enable the alarmA */
RTC_AlarmCmd(RTC_Alarm_A, DISABLE);
/* Clear the TAMPER EXTI pending bit */
EXTI_ClearITPendingBit(RIGHT_BUTTON_EXTI_LINE);
/* Displays MESSAGE4 on line 5 */
LCD_SetFont(&Font12x12);
/* Set the LCD Back Color */
LCD_SetBackColor(Blue);
LCD_SetTextColor(White);
LCD_DisplayStringLine(LINE(19), (uint8_t *)MESSAGE4);
LCD_SetFont(&Font16x24);
/* Set the LCD Text Color */
LCD_SetTextColor(Black);
}
else
{
/* Displays MESSAGE5 on line 5 */
LCD_SetFont(&Font12x12);
/* Set the LCD Back Color */
LCD_SetBackColor(Blue);
LCD_SetTextColor(White);
LCD_DisplayStringLine(LINE(19), (uint8_t *)MESSAGE5);
LCD_SetFont(&Font16x24);
/* Set the LCD Back Color */
LCD_SetBackColor(White);
/* Enable the alarmA */
RTC_AlarmCmd(RTC_Alarm_A, ENABLE);
StartEvent = 8;
/* Clear the LEFT EXTI pending bit */
EXTI_ClearITPendingBit(RIGHT_BUTTON_EXTI_LINE);
}
}
else if(EXTI_GetITStatus(DOWN_BUTTON_EXTI_LINE) != RESET)
{
if(RTCAlarmCount == 0)
{
SecondNumb--;
if(SecondNumb < 15) SecondNumb = 15;
tmp = (uint32_t) (SecondNumb/60);
tmp1 = SecondNumb -(tmp*60);
LCD_SetFont(&Font16x24);
/* Set the LCD text color */
LCD_SetTextColor(Blue);
/* Set the LCD Back Color */
LCD_SetBackColor(White);
LCD_DisplayStringLine(95, " ");
/* Display Char on the LCD : XXX% */
LCD_DisplayChar(95,294, (tmp / 10) +0x30);
LCD_DisplayChar(95,278, (tmp % 10 ) +0x30);
LCD_DisplayChar(95,262, ':');
LCD_DisplayChar(95,246, (tmp1 / 10) +0x30);
LCD_DisplayChar(95,230, (tmp1 % 10 ) +0x30);
}
/* Clear the LEFT EXTI pending bit */
EXTI_ClearITPendingBit(DOWN_BUTTON_EXTI_LINE);
/* Clear the EXTI Line 8 */
EXTI_ClearITPendingBit(EXTI_Line8);
}
}
/**
* @brief Main program.
* @param None
* @retval None
*/
int main(void)
{
/*!< At this stage the microcontroller clock setting is already configured,
this is done through SystemInit() function which is called from startup
file (startup_stm32l1xx_xx.s) before to branch to application main.
To reconfigure the default setting of SystemInit() function, refer to
system_stm32l1xx.c file
*/
uint32_t index = 0;
/* Configure all GPIO pins in Analog mode for lowsest consumption */
GPIO_Config();
/* ADC configuration: Channel 18 or 31 (PB12 or PF10) is used, End Of Conversion (EOC) interrupt is enabled */
ADC_Config();
#ifdef USE_STM32L152_EVAL
/* LCD GLASS Configuration: LSI as LCD clock source */
LCD_Glass_Config();
/* Initialize the TFT-LCD */
STM32L152_LCD_Init();
#elif defined USE_STM32L152D_EVAL
/* Initialize the TFT-LCD */
STM32L152D_LCD_Init();
#endif
/* Clear the TFT-LCD */
LCD_Clear(LCD_COLOR_WHITE);
while(1)
{
if (State == STATE_OVER_THRESHOLD) /* Input voltage is over the threshold */
{
/* Indicator LED: MCU in RUN mode */
STM_EVAL_LEDOff(LED1);
/* Disable COMP IRQ */
NVIC_InitStructure.NVIC_IRQChannel = COMP_IRQn;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelCmd = DISABLE;
NVIC_Init(&NVIC_InitStructure);
/* Enable ADC1 IRQ */
NVIC_InitStructure.NVIC_IRQChannel = ADC1_IRQn;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
/* COMP clock disable */
RCC_APB1PeriphClockCmd(RCC_APB1Periph_COMP, DISABLE);
/* Restore MCU configuration */
RestoreConfiguration();
/* Enable ADC1 */
ADC_Cmd(ADC1, ENABLE);
/* Start ADC1 Software Conversion */
ADC_SoftwareStartConv(ADC1);
/* Wait for ADC to be ready */
while(!ADC_GetFlagStatus(ADC1, ADC_FLAG_ADONS));
while(State == STATE_OVER_THRESHOLD)
{
/* Display measured value on Glass LCD */
DisplayVoltage(ADCVal);
/* Display measured value on LCD */
for (index = 0; index < 20; index++)
{
LCD_DisplayChar(LCD_LINE_3, (319 - (16 * index)), VoltageDisplay[index]);
}
/* Check if the measured value is below the threshold VREFINT: 1.22 V */
if (ADCVal <= 0x000005EA)
{
State = STATE_UNDER_THRESHOLD;
}
}
}
else /* Input voltage is under the threshold */
{
/* LED1 ON: MCU in STOP mode */
STM_EVAL_LEDInit(LED1);
STM_EVAL_LEDOn(LED1);
/* Disable ADC1 IRQ */
NVIC_InitStructure.NVIC_IRQChannel = ADC1_IRQn;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelCmd = DISABLE;
NVIC_Init(&NVIC_InitStructure);
/* Disable ADC1 */
ADC_Cmd(ADC1, DISABLE);
/* Configure COMP2 with interrupt enabled */
COMP_Config();
/* Check COMP2 output level before entering STOP mode */
if (COMP_GetOutputLevel(COMP_Selection_COMP2) == COMP_OutputLevel_Low)
{
/* Disable LSI oscillator before entering STOP mode */
RCC_LSICmd(DISABLE);
/* Enter STOP mode with regulator in low power */
PWR_EnterSTOPMode(PWR_Regulator_LowPower, PWR_STOPEntry_WFI);
}
}
}
}
/**
* @brief Main program.
* @param None
* @retval None
*/
int main(void)
{
/*!< At this stage the microcontroller clock setting is already configured,
this is done through SystemInit() function which is called from startup
file (startup_stm32f0xx.s) before to branch to application main.
To reconfigure the default setting of SystemInit() function, refer to
system_stm32f0xx.c file
*/
uint32_t index = 0;
/* NVIC Configuration */
NVIC_Config();
/* Initialize the LCD */
STM320518_LCD_Init();
/* Initialize the Temperature Sensor */
LM75_Init();
if (LM75_GetStatus() == SUCCESS)
{
/* Clear the LCD */
LCD_Clear(LCD_COLOR_WHITE);
/* Set the Back Color */
LCD_SetBackColor(LCD_COLOR_BLUE);
/* Set the Text Color */
LCD_SetTextColor(LCD_COLOR_GREEN);
LCD_DisplayStringLine(LCD_LINE_0, " Temperature ");
/* Configure the Temperature sensor device STLM75:
- Thermostat mode Interrupt
- Fault tolerance: 00
*/
LM75_WriteConfReg(0x02);
/* Configure the THYS and TOS in order to use the SMbus alert interrupt */
LM75_WriteReg(LM75_REG_THYS, TEMPERATURE_THYS << 8); /*31°C*/
LM75_WriteReg(LM75_REG_TOS, TEMPERATURE_TOS << 8); /*32°C*/
/* Enables the I2C SMBus Alert feature */
I2C_SMBusAlertCmd(LM75_I2C, ENABLE);
I2C_ClearFlag(LM75_I2C, I2C_FLAG_ALERT);
SMbusAlertOccurred = 0;
/* Enable SMBus Alert interrupt */
I2C_ITConfig(LM75_I2C, I2C_IT_ERRI, ENABLE);
/* Infinite Loop */
while (1)
{
/* Get double of Temperature value */
TempValue = LM75_ReadTemp();
if (TempValue <= 256)
{
/* Positive temperature measured */
TempCelsiusDisplay[7] = '+';
/* Initialize the temperature sensor value*/
TempValueCelsius = TempValue;
}
else
{
/* Negative temperature measured */
TempCelsiusDisplay[7] = '-';
/* Remove temperature value sign */
TempValueCelsius = 0x200 - TempValue;
}
/* Calculate temperature digits in °C */
if ((TempValueCelsius & 0x01) == 0x01)
{
TempCelsiusDisplay[12] = 0x05 + 0x30;
TempFahrenheitDisplay[12] = 0x05 + 0x30;
}
else
{
TempCelsiusDisplay[12] = 0x00 + 0x30;
TempFahrenheitDisplay[12] = 0x00 + 0x30;
}
TempValueCelsius >>= 1;
TempCelsiusDisplay[8] = (TempValueCelsius / 100) + 0x30;
TempCelsiusDisplay[9] = ((TempValueCelsius % 100) / 10) + 0x30;
TempCelsiusDisplay[10] = ((TempValueCelsius % 100) % 10) + 0x30;
if (TempValue > 256)
{
if (((9 * TempValueCelsius) / 5) <= 32)
{
/* Convert temperature °C to Fahrenheit */
TempValueFahrenheit = abs (32 - ((9 * TempValueCelsius) / 5));
/* Calculate temperature digits in °F */
TempFahrenheitDisplay[8] = (TempValueFahrenheit / 100) + 0x30;
TempFahrenheitDisplay[9] = ((TempValueFahrenheit % 100) / 10) + 0x30;
TempFahrenheitDisplay[10] = ((TempValueFahrenheit % 100) % 10) + 0x30;
/* Positive temperature measured */
TempFahrenheitDisplay[7] = '+';
}
else
{
/* Convert temperature °C to Fahrenheit */
TempValueFahrenheit = abs(((9 * TempValueCelsius) / 5) - 32);
/* Calculate temperature digits in °F */
TempFahrenheitDisplay[8] = (TempValueFahrenheit / 100) + 0x30;
TempFahrenheitDisplay[9] = ((TempValueFahrenheit % 100) / 10) + 0x30;
TempFahrenheitDisplay[10] = ((TempValueFahrenheit % 100) % 10) + 0x30;
/* Negative temperature measured */
TempFahrenheitDisplay[7] = '-';
}
}
else
{
/* Convert temperature °C to Fahrenheit */
TempValueFahrenheit = ((9 * TempValueCelsius) / 5) + 32;
/* Calculate temperature digits in °F */
TempFahrenheitDisplay[8] = (TempValueFahrenheit / 100) + 0x30;
TempFahrenheitDisplay[9] = ((TempValueFahrenheit % 100) / 10) + 0x30;
TempFahrenheitDisplay[10] = ((TempValueFahrenheit % 100) % 10) + 0x30;
/* Positive temperature measured */
TempFahrenheitDisplay[7] = '+';
}
/* Display Fahrenheit value on LCD */
for (index = 0; index < 20; index++)
{
LCD_DisplayChar(LCD_LINE_6, (319 - (16 * index)), TempCelsiusDisplay[index]);
LCD_DisplayChar(LCD_LINE_7, (319 - (16 * index)), TempFahrenheitDisplay[index]);
}
if (SMbusAlertOccurred == 1)
{
/* Set the Back Color */
LCD_SetBackColor(LCD_COLOR_BLUE);
/* Set the Text Color */
LCD_SetTextColor(LCD_COLOR_RED);
LCD_DisplayStringLine(LCD_LINE_2, "Warning: Temp exceed");
LCD_DisplayStringLine(LCD_LINE_3, " 32 C ");
}
if (SMbusAlertOccurred == 2)
{
/* Set the Back Color */
LCD_SetBackColor(LCD_COLOR_WHITE);
/* Set the Text Color */
LCD_SetTextColor(LCD_COLOR_WHITE);
LCD_ClearLine(LCD_LINE_2);
LCD_ClearLine(LCD_LINE_3);
SMbusAlertOccurred = 0;
/* Set the Back Color */
LCD_SetBackColor(LCD_COLOR_BLUE);
/* Set the Text Color */
LCD_SetTextColor(LCD_COLOR_GREEN);
}
}
}
void LCD_DisplayString(const char *ptr_stringPointer_u8)
{
while((*ptr_stringPointer_u8)!=0)
LCD_DisplayChar(*ptr_stringPointer_u8++); // Loop through the string and display char by char
}
/*******************************************************************************
* Function Name : LCD_Update
* Description : Controls the wave player application LCD display messages.
* Input : None
* Output : None
* Return : None
*******************************************************************************/
void LCD_Update(uint32_t Status)
{
uint8_t tmp = 0;
uint32_t counter = 0;
/* Enable the FSMC that share a pin w/ I2C1 (LBAR) */
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_FSMC, ENABLE);
switch (Status)
{
case PROGRESS:
tmp = (uint8_t) ((uint32_t)((GetVar_AudioDataIndex()) * 100) / GetVar_AudioDataLength());
if (tmp == 0)
{
LCD_SetTextColor(Magenta);
LCD_ClearLine(Line8);
LCD_DrawRect(Line8, 310, 16, 300);
}
else
{
LCD_SetTextColor(Magenta);
LCD_DrawLine(Line8, 310 - (tmp * 3), 16, Vertical);
}
break;
case FRWD:
tmp = (uint8_t) ((uint32_t)((GetVar_AudioDataIndex()) * 100) / GetVar_AudioDataLength());
LCD_SetTextColor(Magenta);
LCD_ClearLine(Line8);
LCD_DrawRect(Line8, 310, 16, 300);
LCD_SetTextColor(Magenta);
for (counter = 0; counter <= tmp; counter++)
{
LCD_DrawLine(Line8, 310 - (counter * 3), 16, Vertical);
}
break;
case STOP:
/* Display the stopped status menu */
LCD_SetTextColor(White);
LCD_DisplayStringLine(Line3, CmdTitle1Stopped);
LCD_DisplayStringLine(Line4, CmdTitle2Stopped);
LCD_SetTextColor(Red);
LCD_DisplayStringLine(Line6, StatusTitleStopped);
LCD_ClearLine(Line9);
LCD_SetTextColor(Black);
LCD_DisplayChar(Line9, 250, 'v');
LCD_DisplayChar(Line9, 235, 'o');
LCD_DisplayChar(Line9, 220, 'l');
LCD_DisplayChar(Line9, 200, '-');
LCD_DisplayChar(Line9, 85, '+');
LCD_DrawRect(Line9 + 8, 185, 10, 100);
break;
case PAUSE:
/* Display the paused status menu */
LCD_SetTextColor(White);
LCD_DisplayStringLine(Line3, CmdTitle1Paused);
LCD_DisplayStringLine(Line4, CmdTitle2Paused);
LCD_SetTextColor(Red);
LCD_DisplayStringLine(Line6, StatusTitlePaused);
break;
case PLAY:
/* Display the Titles */
LCD_SetTextColor(Black);
LCD_DisplayStringLine(Line0, DemoTitle);
LCD_DisplayStringLine(Line2, CmdTitle0);
/* Display the Playing status menu */
LCD_SetTextColor(White);
LCD_DisplayStringLine(Line3, CmdTitle1Playing);
LCD_DisplayStringLine(Line4, CmdTitle2Playing);
LCD_SetTextColor(Red);
LCD_DisplayStringLine(Line6, StatusTitlePlaying);
LCD_ClearLine(Line9);
LCD_SetTextColor(Black);
LCD_DisplayChar(Line9, 250, 'v');
LCD_DisplayChar(Line9, 235, 'o');
LCD_DisplayChar(Line9, 220, 'l');
LCD_DisplayChar(Line9, 200, '-');
LCD_DisplayChar(Line9, 85, '+');
LCD_DrawRect(Line9 + 8, 185, 10, 100);
break;
case ALL:
I2S_CODEC_LCDConfig();
/* Display the stopped status menu */
LCD_SetTextColor(White);
LCD_DisplayStringLine(Line3, CmdTitle1Stopped);
LCD_DisplayStringLine(Line4, CmdTitle2Stopped);
LCD_SetTextColor(Red);
LCD_DisplayStringLine(Line6, StatusTitleStopped);
LCD_ClearLine(Line9);
LCD_SetTextColor(Black);
LCD_DisplayChar(Line9, 250, 'v');
LCD_DisplayChar(Line9, 235, 'o');
LCD_DisplayChar(Line9, 220, 'l');
LCD_DisplayChar(Line9, 200, '-');
LCD_DisplayChar(Line9, 85, '+');
LCD_DrawRect(Line9 + 8, 185, 10, 100);
break;
}
/* Update the volume bar in all cases except when progress bar is to be apdated */
if (Status != PROGRESS)
{
/* Compute the current volume percentage */
tmp = (uint8_t) ((uint16_t)((0xFF - GetVar_CurrentVolume()) * 100) / 0xFF) ;
/* Clear the previuos volume bar */
LCD_SetTextColor(Blue);
LCD_DrawLine(Line9 + 10, 185 - previoustmp , 8, Vertical);
LCD_DrawLine(Line9 + 10, 185 - previoustmp + 1 , 8, Vertical);
/* Draw the new volume bar */
LCD_SetTextColor(Red);
LCD_DrawLine(Line9 + 10, 185 - tmp , 8, Vertical);
LCD_DrawLine(Line9 + 10, 185 - tmp + 1 , 8, Vertical);
/* save the current position */
previoustmp = tmp;
}
/* Disable the FSMC that share a pin w/ I2C1 (LBAR) */
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_FSMC, DISABLE);
}
/**
* @brief Main program.
* @param None
* @retval None
*/
void I2C_TSENSOR_Example(void)
{
/*!< At this stage the microcontroller clock setting is already configured,
this is done through SystemInit() function which is called from startup
file (startup_stm32f30x.s) before to branch to application main.
To reconfigure the default setting of SystemInit() function, refer to
system_stm32f30x.c file
*/
uint32_t i = 0;
/* Initialize the LCD */
STM32303C_LCD_Init();
/* Initialize the Temperature Sensor */
TS751_Init();
if (TS751_GetStatus() == SUCCESS)
{
/* Clear the LCD */
LCD_Clear(LCD_COLOR_WHITE);
/* Set the Back Color */
LCD_SetBackColor(LCD_COLOR_BLUE);
/* Set the Text Color */
LCD_SetTextColor(LCD_COLOR_GREEN);
LCD_DisplayStringLine(LCD_LINE_0, " Temperature ");
LCD_DisplayStringLine(LCD_LINE_8, " Check JP1 closed ");
/* Set the Back Color */
LCD_SetBackColor(LCD_COLOR_WHITE);
/* Set the Text Color */
LCD_SetTextColor(LCD_COLOR_BLACK);
/* NVIC Configuration */
NVIC_Config();
/* Enables the I2C SMBus Alert feature */
I2C_SMBusAlertCmd(I2C2, ENABLE);
I2C_ClearFlag(I2C2, I2C_FLAG_ALERT);
SMbusAlertOccurred = 0;
/* Enable SMBus Alert interrupt */
I2C_ITConfig(I2C2, I2C_IT_ERRI, ENABLE);
/* Configure the Temperature sensor device STTS751 */
TS751_WriteConfReg(0x0C);
/* Configure the Temperature Therm limit as 40°C */
TS751_WriteReg(0x05, TEMPERATURE_TOS);
TS751_WriteReg(0x20, TEMPERATURE_TOS);
/* Configure the Temperature Thys limit as 20°C */
TS751_WriteReg(0x07, TEMPERATURE_THYS);
TS751_WriteReg(0x21, TEMPERATURE_THYS);
/* Infinite Loop */
while (1)
{
/* Get double of Temperature value */
TempValue = TS751_ReadTemp();
if (TempValue <= 2048)
{
/* Positive temperature measured */
TempCelsiusDisplay[4] = '+';
/* Initialize the temperature sensor value */
TempValueCelsius = TempValue;
}
else
{
/* Negative temperature measured */
TempCelsiusDisplay[4] = '-';
/* Remove temperature value sign */
TempValueCelsius = 0x1000 - TempValue;
}
TempCelsius = 0;
/* Calculate temperature digits in ÝC */
if (TempValueCelsius & 0x01)
{
TempCelsius += 625;
}
if (TempValueCelsius & 0x02)
{
TempCelsius += 1250;
}
if (TempValueCelsius & 0x04)
{
TempCelsius += 2500;
}
if (TempValueCelsius & 0x08)
{
TempCelsius += 5000;
}
TempCelsiusDisplay[9] = (TempCelsius / 1000) + 0x30;
TempCelsiusDisplay[10] = ((TempCelsius % 1000) / 100) + 0x30;
TempCelsiusDisplay[11] = (((TempCelsius % 1000) % 100) / 10)+ 0x30;
TempCelsiusDisplay[12] = (((TempCelsius % 1000) % 100) % 10) + 0x30;
TempValueCelsius >>= 4;
TempCelsiusDisplay[5] = (TempValueCelsius / 100) + 0x30;
TempCelsiusDisplay[6] = ((TempValueCelsius % 100) / 10) + 0x30;
TempCelsiusDisplay[7] = ((TempValueCelsius % 100) % 10) + 0x30;
TempValueCelsiusFloat = TempValueCelsius + (float) (TempCelsius/10000.0);
if (TempValue > 2048)
{
if (((9 * TempValueCelsiusFloat) / 5) <= 32)
{
/* Convert temperature °C to Fahrenheit */
TempValueFahrenheitFloat = abs ((int)(32 - ((9 * TempValueCelsiusFloat) / 5)));
TempValueFahrenheit = (int) (TempValueFahrenheitFloat);
/* Calculate temperature digits in °F */
TempFahrenheitDisplay[5] = (TempValueFahrenheit / 100) + 0x30;
TempFahrenheitDisplay[6] = ((TempValueFahrenheit % 100) / 10) + 0x30;
TempFahrenheitDisplay[7] = ((TempValueFahrenheit % 100) % 10) + 0x30;
/* Positive temperature measured */
TempFahrenheitDisplay[4] = '+';
TempFahrenheit = TempValueFahrenheitFloat - TempValueFahrenheit;
TempFahrenheitDisplay[9] = (int)(TempFahrenheit * 10) + 0x30;
TempFahrenheitDisplay[10] = ((int)(TempFahrenheit * 100) % 10) + 0x30;
TempFahrenheitDisplay[11] = ((int)(TempFahrenheit * 1000) % 10) + 0x30;
TempFahrenheitDisplay[12] = ((int)(TempFahrenheit * 10000) % 10) + 0x30;
}
else
{
/* Convert temperature °C to Fahrenheit */
TempValueFahrenheitFloat = abs((int)(((9 * TempValueCelsiusFloat) / 5) - 32));
TempValueFahrenheit = (int) (TempValueFahrenheitFloat);
/* Calculate temperature digits in °F */
TempFahrenheitDisplay[5] = (TempValueFahrenheit / 100) + 0x30;
TempFahrenheitDisplay[6] = ((TempValueFahrenheit % 100) / 10) + 0x30;
TempFahrenheitDisplay[7] = ((TempValueFahrenheit % 100) % 10) + 0x30;
/* Negative temperature measured */
TempFahrenheitDisplay[4] = '-';
TempFahrenheit = TempValueFahrenheitFloat - TempValueFahrenheit;
TempFahrenheitDisplay[9] = (int)(TempFahrenheit * 10) + 0x30;
TempFahrenheitDisplay[10] = ((int)(TempFahrenheit * 100) % 10) + 0x30;
TempFahrenheitDisplay[11] = ((int)(TempFahrenheit * 1000) % 10) + 0x30;
TempFahrenheitDisplay[12] = ((int)(TempFahrenheit * 10000) % 10) + 0x30;
}
}
else
{
/* Convert temperature °C to Fahrenheit */
TempValueFahrenheitFloat = ((9 * TempValueCelsiusFloat) / 5) + 32;
TempValueFahrenheit = (int) (TempValueFahrenheitFloat);
/* Calculate temperature digits in °F */
TempFahrenheitDisplay[5] = (TempValueFahrenheit / 100) + 0x30;
TempFahrenheitDisplay[6] = ((TempValueFahrenheit % 100) / 10) + 0x30;
TempFahrenheitDisplay[7] = ((TempValueFahrenheit % 100) % 10) + 0x30;
/* Positive temperature measured */
TempFahrenheitDisplay[4] = '+';
TempFahrenheit = TempValueFahrenheitFloat - TempValueFahrenheit;
TempFahrenheitDisplay[9] = (int)(TempFahrenheit * 10) + 0x30;
TempFahrenheitDisplay[10] = ((int)(TempFahrenheit * 100) % 10) + 0x30;
TempFahrenheitDisplay[11] = ((int)(TempFahrenheit * 1000) % 10) + 0x30;
TempFahrenheitDisplay[12] = ((int)(TempFahrenheit * 10000) % 10) + 0x30;
}
/* Display Fahrenheit value on LCD */
for (i = 0; i < 20; i++)
{
LCD_DisplayChar(LCD_LINE_6, (319 - (16 * i)), TempCelsiusDisplay[i]);
LCD_DisplayChar(LCD_LINE_7, (319 - (16 * i)), TempFahrenheitDisplay[i]);
}
if ((SMbusAlertOccurred == 1) && ((TempValueCelsius > (TEMPERATURE_TOS-1)) && (TempValue < 2048)))
{
Var = 1;
/* Set the Back Color */
LCD_SetBackColor(LCD_COLOR_BLUE);
/* Set the Text Color */
LCD_SetTextColor(LCD_COLOR_RED);
LCD_DisplayStringLine(LCD_LINE_1, "Temp higher than 40C");
}
if ((SMbusAlertOccurred == 1) && ((TempValueCelsius < TEMPERATURE_THYS) || (TempValue > 2048)))
{
Var = 2;
/* Set the Back Color */
LCD_SetBackColor(LCD_COLOR_BLUE);
/* Set the Text Color */
LCD_SetTextColor(LCD_COLOR_RED);
LCD_DisplayStringLine(LCD_LINE_1, "Temp lower than 20C ");
}
if ((SMbusAlertOccurred == 1) && (TempValueCelsius < TEMPERATURE_TOS) && (Var == 1))
{
Var = 0;
SMbusAlertOccurred = 0;
Tmp = TS751_AlerteResponseAddressRead();
/* Set the Back Color */
LCD_SetBackColor(LCD_COLOR_WHITE);
/* Set the Text Color */
LCD_SetTextColor(LCD_COLOR_WHITE);
LCD_ClearLine(LCD_LINE_1);
/* Set the Text Color */
LCD_SetTextColor(LCD_COLOR_BLACK);
}
if (((SMbusAlertOccurred == 1) && (TempValueCelsius > (TEMPERATURE_THYS-1)) && (Var == 2)) && (TempValue < 2048))
{
Var = 0;
SMbusAlertOccurred = 0;
Tmp = TS751_AlerteResponseAddressRead();
/* Set the Back Color */
LCD_SetBackColor(LCD_COLOR_WHITE);
/* Set the Text Color */
LCD_SetTextColor(LCD_COLOR_WHITE);
LCD_ClearLine(LCD_LINE_1);
/* Set the Text Color */
LCD_SetTextColor(LCD_COLOR_BLACK);
}
}
}
