/**
* @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
*/
/* Configure Clocks */
RCC_Config();
/* Initialize LEDsand LCD available on EVAL board ***************************/
STM_EVAL_LEDInit(LED1);
STM_EVAL_LEDInit(LED2);
STM_EVAL_LEDInit(LED3);
STM_EVAL_LEDInit(LED4);
/* Initialize the LCD */
#ifdef USE_STM320518_EVAL
STM320518_LCD_Init();
#else
STM32072B_LCD_Init();
#endif /* USE_STM320518_EVAL */
/* Display message on LCD ***********************************************/
/* Clear the LCD */
LCD_Clear(White);
/* Set the LCD Back Color */
LCD_SetBackColor(Blue);
/* Set the LCD Text Color */
LCD_SetTextColor(Yellow);
LCD_DisplayStringLine(Line0, MESSAGE1);
LCD_DisplayStringLine(Line1, MESSAGE2);
/* Set the LCD Back Color */
LCD_SetBackColor(White);
/* Set the LCD Text Color */
LCD_SetTextColor(Blue);
/* Configure the Push buttons in Polling mode */
STM_EVAL_PBInit(BUTTON_SEL, Mode_GPIO);
/* if STM32 device is set as Master */
#ifdef I2C_MASTER
/* Configure and enable the systick timer to generate an interrupt each 1 ms */
SysTick_Config((SystemCoreClock / 1000));
/* Deinitialize I2Cx Device */
CPAL_I2C_DeInit(&MASTERSTRUCTURE);
/* Initialize CPAL I2C structure parameters values */
CPAL_I2C_StructInit(&MASTERSTRUCTURE);
#ifdef CPAL_I2C_DMA_PROGMODEL
MASTERSTRUCTURE.wCPAL_Options = CPAL_OPT_NO_MEM_ADDR | CPAL_OPT_DMATX_TCIT;
MASTERSTRUCTURE.CPAL_ProgModel = CPAL_PROGMODEL_DMA;
#elif defined (CPAL_I2C_IT_PROGMODEL)
MASTERSTRUCTURE.wCPAL_Options = CPAL_OPT_NO_MEM_ADDR;
MASTERSTRUCTURE.CPAL_ProgModel = CPAL_PROGMODEL_INTERRUPT;
#else
#error "Please select one of the programming model (in main.h)"
#endif
/* Set I2C Speed */
MASTERSTRUCTURE.pCPAL_I2C_Struct->I2C_Timing = MASTER_I2C_TIMING;
/* Select Master Mode */
MASTERSTRUCTURE.CPAL_Mode = CPAL_MODE_MASTER;
/* Initialize I2Cx Device*/
CPAL_I2C_Init(&MASTERSTRUCTURE);
/* Infinite loop */
while(1)
{
/* Initialize Transfer parameters */
MASTERSTRUCTURE.pCPAL_TransferTx = &sTxStructure;
sTxStructure.wNumData = BufferSize;
sTxStructure.pbBuffer = (uint8_t*)BufferTX;
sTxStructure.wAddr1 = OWNADDRESS;
/* Update LCD Display */
LCD_SetBackColor(White);
LCD_SetTextColor(Blue);
LCD_DisplayStringLine(Line8, MEASSAGE_EMPTY);
LCD_DisplayStringLine(Line5, MESSAGE4);
LCD_DisplayStringLine(Line6, MESSAGE5);
/* wait until Key button is pushed */
while(! STM_EVAL_PBGetState(BUTTON_SEL));
/* Update LCD Display */
LCD_DisplayStringLine(Line5, MEASSAGE_EMPTY);
LCD_DisplayStringLine(Line6, MEASSAGE_EMPTY);
/* Write operation */
CPAL_I2C_Write(&MASTERSTRUCTURE);
/* Wait until communication finishes */
while ((MASTERSTRUCTURE.CPAL_State != CPAL_STATE_READY) && (MASTERSTRUCTURE.CPAL_State != CPAL_STATE_ERROR));
if (TransferStatus == PASSED)
{
/* Update LCD Display */
LCD_SetBackColor(Red);
LCD_SetTextColor(White);
LCD_DisplayStringLine(Line8, MESSAGE6);
}
else
{
TransferStatus = PASSED;
}
Delay(1000);
}
#endif /* I2C_MASTER */
/* if STM32 device is set as Slave */
#ifdef I2C_SLAVE
/* GPIOA Periph clock enable */
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOA, ENABLE);
/* Output System Clock on MCO pin (PA.08) */
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_Init(GPIOA, &GPIO_InitStructure);
#ifdef USE_STM320518_EVAL
RCC_MCOConfig(RCC_MCOSource_SYSCLK);
#else
RCC_MCOConfig(RCC_MCOSource_SYSCLK, RCC_MCOPrescaler_1);
#endif /* USE_STM320518_EVAL */
/* Deinitialize I2Cx Device */
CPAL_I2C_DeInit(&SLAVESTRUCTURE);
/* Initialize CPAL I2C structure parameters values */
CPAL_I2C_StructInit(&SLAVESTRUCTURE);
#ifdef CPAL_I2C_DMA_PROGMODEL
SLAVESTRUCTURE.wCPAL_Options = CPAL_OPT_I2C_NACK_ADD | CPAL_OPT_I2C_WAKEUP_STOP | CPAL_OPT_DMARX_TCIT;
SLAVESTRUCTURE.CPAL_ProgModel = CPAL_PROGMODEL_DMA;
#elif defined (CPAL_I2C_IT_PROGMODEL)
SLAVESTRUCTURE.wCPAL_Options = CPAL_OPT_I2C_NACK_ADD | CPAL_OPT_I2C_WAKEUP_STOP;
SLAVESTRUCTURE.CPAL_ProgModel = CPAL_PROGMODEL_INTERRUPT;
#else
#error "Please select one of the programming model (in main.h)"
#endif
/* Configure Own address 1 */
SLAVESTRUCTURE.pCPAL_I2C_Struct->I2C_OwnAddress1 = OWNADDRESS;
/* Set I2C Speed */
SLAVESTRUCTURE.pCPAL_I2C_Struct->I2C_Timing = SLAVE_I2C_TIMING;
/* Select Slave Mode */
SLAVESTRUCTURE.CPAL_Mode = CPAL_MODE_SLAVE;
/* Initialize I2Cx Device*/
CPAL_I2C_Init(&SLAVESTRUCTURE);
/* Infinite loop */
while(1)
{
/* Reset BufferRX value */
Reset_bBuffer(BufferRX, (uint16_t)BufferSize);
/* Initialize Transfer parameters */
SLAVESTRUCTURE.pCPAL_TransferRx = &sRxStructure;
sRxStructure.wNumData = BufferSize;
sRxStructure.pbBuffer = (uint8_t*)BufferRX;
/* Update LCD Display */
LCD_SetBackColor(White);
LCD_SetTextColor(Blue);
LCD_DisplayStringLine(Line8, MEASSAGE_EMPTY);
LCD_DisplayStringLine(Line9, MEASSAGE_EMPTY);
LCD_DisplayStringLine(Line5, MESSAGE7);
Delay(1000);
/* Update LCD Display */
LCD_DisplayStringLine(Line5, MEASSAGE_EMPTY);
LCD_DisplayStringLine(Line6, MESSAGE8);
/* Read operation */
CPAL_I2C_Read(&SLAVESTRUCTURE);
/* Enter Stop Mode and wait for interrupt to wake up */
PWR_EnterSTOPMode(PWR_Regulator_LowPower, PWR_STOPEntry_WFI);
/* Wait until communication finishes */
while ((SLAVESTRUCTURE.CPAL_State != CPAL_STATE_READY) && (SLAVESTRUCTURE.CPAL_State != CPAL_STATE_ERROR));
/* Configure SystemClock*/
Restore_Configuration();
/* Configure and enable the systick timer to generate an interrupt each 1 ms */
SysTick_Config((SystemCoreClock / 1000));
/* Update LCD Display */
LCD_DisplayStringLine(Line6, MEASSAGE_EMPTY);
LCD_SetBackColor(Red);
LCD_SetTextColor(White);
LCD_DisplayStringLine(Line8, MESSAGE9);
/* If are received correctly */
if (Compare_bBuffer((uint8_t*)BufferTX, BufferRX, BufferSize) == PASSED )
{
/* Update LCD Display */
LCD_DisplayStringLine(Line9, MESSAGE6);
}
else
{
/* Update LCD Display */
LCD_DisplayStringLine(Line9, MESSAGE10);
}
Delay(1500);
}
#endif /* I2C_SLAVE */
}
/**
* @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_stm32f30x.s) before to branch to application main.
To reconfigure the default setting of SystemInit() function, refer to
system_stm32f30x.c file
*/
/* Initialize the LCD */
STM32303C_LCD_Init();
/* Clear the LCD */
LCD_Clear(LCD_COLOR_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);
LCD_SetFont(&Font12x12);
/* Display Messages on the the LCD */
LCD_DisplayStringLine(LINE(0x3), (uint8_t *)MESSAGE2);
/* Set the LCD Text size */
LCD_SetFont(&Font16x24);
/* Configure Push button key */
STM_EVAL_PBInit(BUTTON_KEY, BUTTON_MODE_GPIO);
/* CAN configuration */
CAN_Config();
/* Infinite loop */
while(1)
{
while(STM_EVAL_PBGetState(BUTTON_KEY) == KEY_PRESSED)
{
if(KeyNumber == 41) KeyNumber = 0;
Display_TransmittedMsg(KeyNumber);
KeyNumber++;
Delay();
while(STM_EVAL_PBGetState(BUTTON_KEY) != KEY_NOT_PRESSED)
{
}
}
if (MsgReceived != 0)
{
/* Display received the 6 messages on tghe LCD */
Display_ReceivedMsg();
MsgReceived = 0;
}
}
}
/*******************************************************************************
* Function Name : LCD_ClearLine
* Description : Clears the selected line.
* Input : - Line: the Line to be cleared.
* This parameter can be one of the following values:
* - Linex: where x can be 0..9
* Output : None
* Return : None
*******************************************************************************/
void LCD_ClearLine(u8 Line)
{
LCD_DisplayStringLine(Line, " ");
}
static void prvLCDTask( void *pvParameters )
{
xQueueMessage xReceivedMessage;
long lLine = Line1;
const long lFontHeight = (((sFONT *)LCD_GetFont())->Height);
/* Buffer into which strings are formatted and placed ready for display on the
LCD. Note this is a static variable to prevent it being allocated on the task
stack, which is too small to hold such a variable. The stack size is configured
when the task is created. */
static char cBuffer[ 512 ];
/* This function is the only function that uses printf(). If printf() is
used from any other function then some sort of mutual exclusion on stdout
will be necessary.
This is also the only function that is permitted to access the LCD.
First print out the number of bytes that remain in the FreeRTOS heap. This
can be viewed in the terminal IO window within the IAR Embedded Workbench. */
printf( "%d bytes of heap space remain unallocated\n", xPortGetFreeHeapSize() );
for( ;; )
{
/* Wait for a message to be received. Using portMAX_DELAY as the block
time will result in an indefinite wait provided INCLUDE_vTaskSuspend is
set to 1 in FreeRTOSConfig.h, therefore there is no need to check the
function return value and the function will only return when a value
has been received. */
xQueueReceive( xLCDQueue, &xReceivedMessage, portMAX_DELAY );
/* Clear the LCD if no room remains for any more text output. */
if( lLine > Line9 )
{
LCD_Clear( Blue );
lLine = 0;
}
/* What is this message? What does it contain? */
switch( xReceivedMessage.cMessageID )
{
case mainMESSAGE_BUTTON_UP : /* The button poll task has just
informed this task that the up
button on the joystick input has
been pressed or released. */
sprintf( cBuffer, "Button up = %d", xReceivedMessage.lMessageValue );
break;
case mainMESSAGE_BUTTON_SEL : /* The select button interrupt
just informed this task that the
select button was pressed.
Generate a table of task run time
statistics and output this to
the terminal IO window in the IAR
embedded workbench. */
printf( "\nTask\t Abs Time\t %%Time\n*****************************************" );
vTaskGetRunTimeStats( cBuffer );
printf( cBuffer );
/* Also print out a message to
the LCD - in this case the
pointer to the string to print
is sent directly in the
lMessageValue member of the
message. This just demonstrates
a different communication
technique. */
sprintf( cBuffer, "%s", ( char * ) xReceivedMessage.lMessageValue );
break;
case mainMESSAGE_STATUS : /* The tick interrupt hook
function has just informed this
task of the system status.
Generate a string in accordance
with the status value. */
prvGenerateStatusMessage( cBuffer, xReceivedMessage.lMessageValue );
break;
default : sprintf( cBuffer, "Unknown message" );
break;
}
/* Output the message that was placed into the cBuffer array within the
switch statement above. */
LCD_DisplayStringLine( lLine, ( uint8_t * ) cBuffer );
/* Move onto the next LCD line, ready for the next iteration of this
loop. */
lLine += lFontHeight;
}
}
/**
* @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_stm32f4xx.s) before to branch to application main.
To reconfigure the default setting of SystemInit() function, refer to
system_stm32f4xx.c file
*/
/* Initialize the LCD */
STM324xG_LCD_Init();
/* 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 1 */
LCD_DisplayStringLine(LINE(0), (uint8_t *)MESSAGE1);
/* RTC configuration */
RTC_Config();
/* Set the LCD Text Color */
LCD_SetTextColor(Red);
/* Set the LCD Back Color */
LCD_SetBackColor(White);
/* Draw rectangle on the LCD */
LCD_DrawRect(43, 300, 30, 260);
/* Configure the external interrupt "WAKEUP" and "KEY" buttons */
STM_EVAL_PBInit(BUTTON_WAKEUP,BUTTON_MODE_EXTI);
STM_EVAL_PBInit(BUTTON_KEY,BUTTON_MODE_EXTI);
/* Configure the RTC tamper register */
RTC_TamperConfig();
/* Set the LCD Text Color */
LCD_SetTextColor(Blue);
/* Displays MESSAGE2 on line 5 */
LCD_DisplayStringLine(LINE(5), (uint8_t *)MESSAGE2);
/* Infinite loop */
while (1)
{
/* Set The LCD font size */
LCD_SetFont(&Font16x24);
/* Set the LCD Back Color */
LCD_SetBackColor(White);
/* Check on the event 'start'*/
if(Startevent != 0x0)
{
/* Get the RTC sub second fraction */
Secondfraction = 1000 - ((uint32_t)((uint32_t)RTC_GetSubSecond() * 1000) / (uint32_t)0x3FF);
}
else
{
/* Idle */
Secondfraction =0x0;
}
/* Get the Curent time */
RTC_GetTime(RTC_Format_BCD, &RTC_TimeStruct);
/* Display the curent time and the sub second on the LCD */
RTC_Time_display(Line2, Black , RTC_Get_Time(Secondfraction , &RTC_TimeStruct));
}
}
/**
* @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
*/
#ifdef ENABLE_LCD_MSG_DISPLAY
/* Initialize the LCD screen for information display */
#ifdef USE_STM32L152D_EVAL
STM32L152D_LCD_Init();
#else
STM32L152_LCD_Init();
#endif
LCD_Clear(LCD_COLOR_BLUE);
LCD_SetBackColor(LCD_COLOR_BLUE);
LCD_SetTextColor(LCD_COLOR_WHITE);
LCD_DisplayStringLine(LCD_LINE_0, "SMT32L1xx FW Library");
LCD_DisplayStringLine(LCD_LINE_1, " EEPROM Example ");
#endif /* ENABLE_LCD_MSG_DISPLAY */
/* Initialize the I2C EEPROM driver ----------------------------------------*/
sEE_Init();
/* First write in the memory followed by a read of the written data --------*/
/* Write on I2C EEPROM from sEE_WRITE_ADDRESS1 */
sEE_WriteBuffer(Tx1_Buffer, sEE_WRITE_ADDRESS1, BUFFER_SIZE1);
/* Wait for EEPROM standby state */
sEE_WaitEepromStandbyState();
/* Set the Number of data to be read */
NumDataRead = BUFFER_SIZE1;
/* Read from I2C EEPROM from sEE_READ_ADDRESS1 */
sEE_ReadBuffer(Rx1_Buffer, sEE_READ_ADDRESS1, (uint16_t *)(&NumDataRead));
/* Starting from this point, if the requested number of data is higher than 1,
then only the DMA is managing the data transfer. Meanwhile, CPU is free to
perform other tasks:
// Add your code here:
//...
//...
For simplicity reasons, this example is just waiting till the end of the
transfer. */
#ifdef ENABLE_LCD_MSG_DISPLAY
LCD_DisplayStringLine(LCD_LINE_3, " Transfer 1 Ongoing ");
#endif /* ENABLE_LCD_MSG_DISPLAY */
/* Wait till DMA transfer is compelete (Tranfer complete interrupt handler
resets the variable holding the number of data to be read) */
while (NumDataRead > 0)
{}
/* Check if the data written to the memory is read correctly */
TransferStatus1 = Buffercmp(Tx1_Buffer, Rx1_Buffer, BUFFER_SIZE1);
/* TransferStatus1 = PASSED, if the transmitted and received data
to/from the EEPROM are the same */
/* TransferStatus1 = FAILED, if the transmitted and received data
to/from the EEPROM are different */
#ifdef ENABLE_LCD_MSG_DISPLAY
if (TransferStatus1 == PASSED)
{
LCD_DisplayStringLine(LCD_LINE_3, " Transfer 1 PASSED ");
}
else
{
LCD_DisplayStringLine(LCD_LINE_3, " Transfer 1 FAILED ");
}
#endif /* ENABLE_LCD_MSG_DISPLAY */
/* Second write in the memory followed by a read of the written data -------*/
/* Write on I2C EEPROM from sEE_WRITE_ADDRESS2 */
sEE_WriteBuffer(Tx2_Buffer, sEE_WRITE_ADDRESS2, BUFFER_SIZE2);
/* Wait for EEPROM standby state */
sEE_WaitEepromStandbyState();
/* Set the Number of data to be read */
NumDataRead = BUFFER_SIZE2;
/* Read from I2C EEPROM from sEE_READ_ADDRESS2 */
sEE_ReadBuffer(Rx2_Buffer, sEE_READ_ADDRESS2, (uint16_t *)(&NumDataRead));
/* Starting from this point, if the requested number of data is higher than 1,
then only the DMA is managing the data transfer. Meanwhile, CPU is free to
perform other tasks:
// Add your code here:
//...
//...
For simplicity reasons, this example is just waiting till the end of the
transfer. */
#ifdef ENABLE_LCD_MSG_DISPLAY
LCD_DisplayStringLine(LCD_LINE_5, " Transfer 2 Ongoing ");
#endif /* ENABLE_LCD_MSG_DISPLAY */
/* Wait till DMA transfer is compelete (Tranfer complete interrupt handler
resets the variable holding the number of data to be read) */
while (NumDataRead > 0)
{}
/* Check if the data written to the memory is read correctly */
TransferStatus2 = Buffercmp(Tx2_Buffer, Rx2_Buffer, BUFFER_SIZE2);
/* TransferStatus2 = PASSED, if the transmitted and received data
to/from the EEPROM are the same */
/* TransferStatus2 = FAILED, if the transmitted and received data
to/from the EEPROM are different */
#ifdef ENABLE_LCD_MSG_DISPLAY
if (TransferStatus2 == PASSED)
{
LCD_DisplayStringLine(LCD_LINE_5, " Transfer 2 PASSED ");
}
else
{
LCD_DisplayStringLine(LCD_LINE_5, " Transfer 2 FAILED ");
}
#endif /* ENABLE_LCD_MSG_DISPLAY */
/* Free all used resources */
sEE_DeInit();
while (1)
{
}
}
/**
* @brief This function handles External lines 9 to 5 interrupt request.
* @param None
* @retval None
*/
void EXTI9_5_IRQHandler(void)
{
if(EXTI_GetITStatus(IOE16_IT_EXTI_LINE) != RESET)
{
#ifdef IOE_INTERRUPT_MODE
__IO uint16_t tmpsr = 0;
static JOY_State_TypeDef JoyState = JOY_NONE;
static TS_STATE* TS_State;
/* Get the interrupt status register */
tmpsr = IOE16_GetITStatus();
/* Check Touch screen interrupt event occurred */
if((tmpsr & IOE16_TS_IT) != 0)
{
/* Update the structure with the current position */
TS_State = IOE_TS_GetState();
if ((TS_State->TouchDetected) && (TS_State->Y < 92) && (TS_State->Y > 52))
{
if ((TS_State->X > 60) && (TS_State->X < 120))
{
LCD_SetTextColor(LCD_COLOR_GREEN);
LCD_DisplayStringLine(LCD_LINE_10, (uint8_t *)" LED1 ");
STM_EVAL_LEDOn(LED1);
}
else if ((TS_State->X > 140) && (TS_State->X < 200))
{
LCD_SetTextColor(LCD_COLOR_YELLOW);
LCD_DisplayStringLine(LCD_LINE_10, (uint8_t *)" LED2 ");
STM_EVAL_LEDOn(LED2);
}
else if ((TS_State->X > 220) && (TS_State->X < 280))
{
LCD_SetTextColor(LCD_COLOR_RED);
LCD_DisplayStringLine(LCD_LINE_10, (uint8_t *)" LED3 ");
STM_EVAL_LEDOn(LED3);
}
else if ((TS_State->X > 300) && (TS_State->X < 360))
{
LCD_SetTextColor(LCD_COLOR_BLUE);
LCD_DisplayStringLine(LCD_LINE_10, (uint8_t *)" LED4");
STM_EVAL_LEDOn(LED4);
}
}
else
{
STM_EVAL_LEDOff(LED1);
STM_EVAL_LEDOff(LED2);
STM_EVAL_LEDOff(LED3);
STM_EVAL_LEDOff(LED4);
}
/* Clear the interrupt pending bits */
IOE_ClearGITPending(IOE16_TS_IT);
}
/* Check joystick interrupt event occurred */
if((tmpsr & IOE16_JOY_IT) != 0 )
{
/* Get the joystick State */
JoyState = IOE16_JoyStickGetState();
/* Set the LCD Text Color */
LCD_SetTextColor(Blue);
switch (JoyState)
{
case JOY_NONE:
LCD_DisplayStringLine(LCD_LINE_5, (uint8_t *)" JOY: ---- ");
break;
case JOY_UP:
LCD_DisplayStringLine(LCD_LINE_5, (uint8_t *)" JOY: UP ");
break;
case JOY_DOWN:
LCD_DisplayStringLine(LCD_LINE_5, (uint8_t *)" JOY: DOWN ");
break;
case JOY_LEFT:
LCD_DisplayStringLine(LCD_LINE_5, (uint8_t *)" JOY: LEFT ");
break;
case JOY_RIGHT:
LCD_DisplayStringLine(LCD_LINE_5, (uint8_t *)" JOY: RIGHT ");
break;
case JOY_CENTER:
LCD_DisplayStringLine(LCD_LINE_5, (uint8_t *)" JOY: CENTER ");
break;
default:
LCD_DisplayStringLine(LCD_LINE_5, (uint8_t *)" JOY: ERROR ");
break;
}
}
#endif /* IOE_INTERRUPT_MODE */
/* Clear all pending bits */
EXTI_ClearITPendingBit(IOE16_IT_EXTI_LINE);
IOE_ClearGITPending(ALL_GIT);
IOE16_GetITStatus();
}
}
/*******************************************************************************
* Function Name : EnterSTOPMode_EXTI
* Description : Enters MCU in STOP mode. The wake-up from STOP mode is
* performed by an external interrupt.
* Input : None
* Output : None
* Return : None
*******************************************************************************/
void EnterSTOPMode_EXTI(void)
{
NVIC_InitTypeDef NVIC_InitStructure;
EXTI_InitTypeDef EXTI_InitStructure;
STOPModeStatus = 0;
/* Clear the LCD */
LCD_Clear(White);
/* Set the LCD Back Color */
LCD_SetBackColor(Blue);
/* Set the LCD Text Color */
LCD_SetTextColor(White);
/* Disable the JoyStick interrupts */
IntExtOnOffConfig(DISABLE);
/* Configure the EXTI Line 9 */
EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;
EXTI_InitStructure.EXTI_Line = EXTI_Line9;
EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Falling;
EXTI_InitStructure.EXTI_LineCmd = ENABLE;
EXTI_Init(&EXTI_InitStructure);
/* Enable the EXTI9_5 Interrupt */
NVIC_InitStructure.NVIC_IRQChannel = EXTI9_5_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
LCD_DisplayStringLine(Line4, " MCU in STOP Mode ");
LCD_DisplayStringLine(Line5, "To exit press Key ");
LCD_DisplayStringLine(Line6, "push button ");
/* Clear the RTC Alarm flag */
RTC_ClearFlag(RTC_FLAG_ALR);
/* Save the GPIO pins current configuration then put all GPIO pins in Analog
Input mode ...*/
GPIO_SaveConfig();
/* ... and keep PB.09 configuration which will be used as EXTI Line9 source */
GPIOB->CRH = 0x40;
/* Request to enter STOP mode with regulator in low power */
PWR_EnterSTOPMode(PWR_Regulator_LowPower, PWR_STOPEntry_WFI);
/* Restore the GPIO Configurations*/
GPIO_RestoreConfig();
/* At this stage the system has resumed from STOP mode ************************/
EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;
EXTI_InitStructure.EXTI_Line = EXTI_Line9;
EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Falling;
EXTI_InitStructure.EXTI_LineCmd = DISABLE;
EXTI_Init(&EXTI_InitStructure);
/* Enable the EXTI9_5 Interrupt */
NVIC_InitStructure.NVIC_IRQChannel = EXTI9_5_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 2;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
/* Configures system clock after wake-up from STOP: enable HSE, PLL and select PLL
as system clock source (HSE and PLL are disabled in STOP mode) */
SYSCLKConfig_STOP();
if(STOPModeStatus != RESET)
{
LCD_DisplayStringLine(Line4, " STOP Mode ");
LCD_DisplayStringLine(Line5, "Wake-Up by RTC Alarm");
LCD_DisplayStringLine(Line6, "Press JoyStick to ");
LCD_DisplayStringLine(Line7, "continue... ");
}
else
{
LCD_DisplayStringLine(Line4, " STOP Mode ");
LCD_DisplayStringLine(Line5, "WakeUp by Key Button");
LCD_DisplayStringLine(Line6, "Press JoyStick to ");
LCD_DisplayStringLine(Line7, "continue... ");
}
while(ReadKey() == NOKEY)
{
}
/* Clear the LCD */
LCD_Clear(White);
/* Display the previous menu */
DisplayMenu();
/* Enable the JoyStick interrupts */
IntExtOnOffConfig(ENABLE);
}
/**
* @brief Initialize resources used for this demo.
* @param None
* @retval Digit value
*/
uint8_t Demo_Init(void)
{
__IO uint32_t tmpValue = 0;
PressedKey = NOKEY;
/* Configure the IO Expander */
if(IOE_Config() == IOE_OK)
{
LCD_DisplayStringLine(LINE(6), (uint8_t*)"IO Expander OK ");
Delay(0xFF);
}
else
{
LCD_SetTextColor(LCD_COLOR_RED);
LCD_DisplayStringLine(LINE(6), (uint8_t*)"IO Expander FAILED Please Reset the board");
while (1);
}
/* Enable the Joystick interrupt */
IOE_ITConfig(IOE_ITSRC_JOYSTICK);
Demo_LCD_Clear();
LCD_DisplayStringLine(LINE(6), (uint8_t*)"Main Menu: ");
LCD_DisplayStringLine(LINE(7), (uint8_t*)"==========");
LCD_DisplayStringLine(LINE(8), (uint8_t*)"Use UP and DOWN Buttons to Navigate");
LCD_DisplayStringLine(LINE(9), (uint8_t*)"Use SEL Button to Select Image Format");
LCD_DisplayStringLine(LINE(11), (uint8_t*)"Select the Image Format:");
Display_Menu(ValueMin, ValueMax);
while (1)
{
/* If "UP" pushbutton is pressed */
if (PressedKey == UP)
{
PressedKey = NOKEY;
/* Increase the value of the digit */
if (tmpValue == ValueMin)
{
tmpValue = ValueMax - 1;
}
else
{
tmpValue--;
}
/* Display new Menu */
Display_Menu(tmpValue, ValueMax);
}
/* If "DOWN" pushbutton is pressed */
if (PressedKey == DOWN)
{
PressedKey = NOKEY;
/* Decrease the value of the digit */
if (tmpValue == (ValueMax - 1))
{
tmpValue = ValueMin;
}
else
{
tmpValue++;
}
/* Display new Menu */
Display_Menu(tmpValue, ValueMax);
}
/* If "SEL" pushbutton is pressed */
if (PressedKey == SEL)
{
PressedKey = NOKEY;
/* Return the digit value and exit */
return (ImageFormat_TypeDef)tmpValue;
}
}
}
/**
* @brief Main program.
* @param None
* @retval None
*/
int main(void)
{
RCC_ClocksTypeDef RCC_Clocks;
/*!< At this stage the microcontroller clock setting is already configured,
this is done through SystemInit() function which is called from startup
file (startup_stm32f4xx.s) before to branch to application main.
To reconfigure the default setting of SystemInit() function, refer to
system_stm32f4xx.c file
*/
/* SysTick end of count event each 10ms */
RCC_GetClocksFreq(&RCC_Clocks);
SysTick_Config(RCC_Clocks.HCLK_Frequency / 100);
/* Initialize LEDs and LCD available on STM324xG-EVAL board *****************/
STM_EVAL_LEDInit(LED1);
STM_EVAL_LEDInit(LED2);
STM_EVAL_LEDInit(LED3);
STM_EVAL_LEDInit(LED4);
/* Initialize the LCD */
STM324xG_LCD_Init();
/* Display message on STM324xG-EVAL LCD *************************************/
/* Clear the LCD */
LCD_Clear(White);
/* Set the LCD Back Color */
LCD_SetBackColor(Blue);
/* Set the LCD Text Color */
LCD_SetTextColor(White);
LCD_DisplayStringLine(LINE(0), (uint8_t *)MESSAGE1);
LCD_DisplayStringLine(LINE(1), (uint8_t *)MESSAGE2);
LCD_DisplayStringLine(LINE(2), (uint8_t *)MESSAGE3);
/* Turn on LEDs available on STM324xG-EVAL **********************************/
STM_EVAL_LEDOn(LED1);
STM_EVAL_LEDOn(LED2);
STM_EVAL_LEDOn(LED3);
STM_EVAL_LEDOn(LED4);
/* Add your application code here
*/
/* Infinite loop */
while (1)
{
/* Toggle LD4 */
STM_EVAL_LEDToggle(LED4);
/* Insert 50 ms delay */
Delay(5);
/* Toggle LD2 */
STM_EVAL_LEDToggle(LED2);
/* Insert 50 ms delay */
Delay(5);
}
}
/*******************************************************************************
* Function Name : EnterSTOPMode_RTCAlarm
* Description : Enters MCU in STOP mode. The wake-up from STOP mode is
* performed by an RTC Alarm.
* Input : None
* Output : None
* Return : None
*******************************************************************************/
void EnterSTOPMode_RTCAlarm(void)
{
uint32_t tmp = 0;
/* Clear the LCD */
LCD_Clear(White);
/* Set the LCD Back Color */
LCD_SetBackColor(Blue);
/* Set the LCD Text Color */
LCD_SetTextColor(White);
/* Disable the JoyStick interrupts */
IntExtOnOffConfig(DISABLE);
if(BKP_ReadBackupRegister(BKP_DR1) != 0xA5A5)
{
LCD_DisplayStringLine(Line1, "Time and Date are ");
LCD_DisplayStringLine(Line2, "not configured, ");
LCD_DisplayStringLine(Line3, "please go to the ");
LCD_DisplayStringLine(Line4, "calendar menu and ");
LCD_DisplayStringLine(Line5, "set the time and ");
LCD_DisplayStringLine(Line6, "date parameters. ");
LCD_DisplayStringLine(Line7, "Press JoyStick to ");
LCD_DisplayStringLine(Line8, "continue... ");
while(ReadKey() == NOKEY)
{
}
/* Clear the LCD */
LCD_Clear(White);
/* Display the previous menu */
DisplayMenu();
/* Enable the JoyStick interrupts */
IntExtOnOffConfig(ENABLE);
return;
}
tmp = RTC_GetCounter();
/* Save the Alarm value in the Backup register */
BKP_WriteBackupRegister(BKP_DR6, (tmp & 0x0000FFFF));
BKP_WriteBackupRegister(BKP_DR7, (tmp >> 16));
Alarm_PreAdjust();
LCD_ClearLine(Line8);
LCD_DisplayStringLine(Line6, " MCU in STOP Mode ");
LCD_DisplayStringLine(Line7, " Wait For RTC Alarm ");
/* Save the GPIO pins current configuration then put all GPIO pins in Analog Input mode */
GPIO_SaveConfig();
/* Request to enter STOP mode with regulator in low power */
PWR_EnterSTOPMode(PWR_Regulator_LowPower, PWR_STOPEntry_WFI);
/* Restore the GPIO Configurations*/
GPIO_RestoreConfig();
/* Configures system clock after wake-up from STOP: enable HSE, PLL and select PLL
as system clock source (HSE and PLL are disabled in STOP mode) */
SYSCLKConfig_STOP();
LCD_DisplayStringLine(Line4, " STOP Mode ");
LCD_DisplayStringLine(Line5, "Wake-Up by RTC Alarm");
LCD_DisplayStringLine(Line6, "Press JoyStick to ");
LCD_DisplayStringLine(Line7, "continue... ");
while(ReadKey() == NOKEY)
{
}
/* Clear the LCD */
LCD_Clear(White);
/* Display the previous menu */
DisplayMenu();
/* Enable the JoyStick interrupts */
IntExtOnOffConfig(ENABLE);
}
/**
* @brief This function handles External lines 15 to 10 interrupt request.
* @param None
* @retval None
*/
void EXTI15_10_IRQHandler(void)
{
#ifdef USE_STM32100E_EVAL
if(EXTI_GetITStatus(RIGHT_BUTTON_EXTI_LINE) != RESET)
{
if (ReadKey == 1)
{
PressedKey = RIGHT;
}
else
{
if (GetMutex == 1)
{
ShowMutex = 0;
}
else
{
ReqOperation = SHOW_TEMPERATURE_OP ;
}
}
/* Clear EXTI interrupts pending bits */
EXTI_ClearITPendingBit(RIGHT_BUTTON_EXTI_LINE);
}
if(EXTI_GetITStatus(LEFT_BUTTON_EXTI_LINE) != RESET)
{
if (ReadKey == 1)
{
PressedKey = LEFT;
}
else
{
if (GetMutex == 1)
{
ShowMutex = 0;
}
else
{
ReqOperation = SHOW_TIME_OP;
}
}
/* Clear EXTI interrupts pending bits */
EXTI_ClearITPendingBit(LEFT_BUTTON_EXTI_LINE);
}
if(EXTI_GetITStatus(UP_BUTTON_EXTI_LINE) != RESET)
{
if (ReadKey == 1)
{
PressedKey = UP;
}
else
{
if (GetMutex == 0)
{
ReqOperation = GET_REPORT_OP;
}
}
/* Clear EXTI interrupts pending bits */
EXTI_ClearITPendingBit(UP_BUTTON_EXTI_LINE);
}
if(EXTI_GetITStatus(DOWN_BUTTON_EXTI_LINE) != RESET)
{
if (ReadKey == 1)
{
PressedKey = DOWN;
}
else
{
if (GetMutex == 0)
{
ReqOperation = ERASE_EEPROM_OP;
}
}
/* Clear EXTI interrupts pending bits */
EXTI_ClearITPendingBit(DOWN_BUTTON_EXTI_LINE);
}
#endif /* USE_STM32100E_EVAL */
if(EXTI_GetITStatus(IOE_IT_EXTI_LINE) != RESET)
{
#ifdef USE_STM3210C_EVAL
static JOY_State_TypeDef JoyState = JOY_NONE;
#endif /* USE_STM3210C_EVAL */
static TS_STATE* TS_State;
/* Check if the interrupt source is the Touch Screen */
if (IOE_GetGITStatus(IOE_1_ADDR, IOE_TS_IT) & IOE_TS_IT)
{
/* Update the structure with the current position */
TS_State = IOE_TS_GetState();
if ((TS_State->TouchDetected) && (TS_State->Y < 230) && (TS_State->Y > 200))
{
if ((TS_State->X > 10) && (TS_State->X < 70))
{
LCD_DisplayStringLine(Line7, (uint8_t*)" TS1 ");
}
else if ((TS_State->X > 90) && (TS_State->X < 150))
{
LCD_DisplayStringLine(Line7, (uint8_t*)" TS2 ");
}
else if ((TS_State->X > 170) && (TS_State->X < 230))
{
LCD_DisplayStringLine(Line7, (uint8_t*)" TS3 ");
}
else if ((TS_State->X > 250) && (TS_State->X < 310))
{
LCD_DisplayStringLine(Line7, (uint8_t*)" TS4 ");
}
}
else
{
STM_EVAL_LEDOff(LED1);
STM_EVAL_LEDOff(LED2);
STM_EVAL_LEDOff(LED3);
STM_EVAL_LEDOff(LED4);
}
/* Clear the interrupt pending bits */
IOE_ClearGITPending(IOE_1_ADDR, IOE_TS_IT);
}
#ifdef USE_STM3210C_EVAL
else if (IOE_GetGITStatus(IOE_2_ADDR, IOE_GIT_GPIO))
{
/* Get the Joystick State */
JoyState = IOE_JoyStickGetState();
switch (JoyState)
{
case JOY_NONE:
break;
case JOY_UP:
if (ReadKey == 1)
{
PressedKey = UP;
}
else
{
if (GetMutex == 0)
{
ReqOperation = GET_REPORT_OP;
}
}
break;
case JOY_DOWN:
if (ReadKey == 1)
{
PressedKey = DOWN;
}
else
{
if (GetMutex == 0)
{
ReqOperation = ERASE_EEPROM_OP;
}
}
break;
case JOY_RIGHT :
if (ReadKey == 1)
{
PressedKey = RIGHT;
}
else
{
if (GetMutex == 1)
{
ShowMutex = 0;
}
else
{
ReqOperation = SHOW_TEMPERATURE_OP ;
}
}
break;
case JOY_LEFT:
if (ReadKey == 1)
{
PressedKey = LEFT;
}
else
{
if (GetMutex == 1)
{
ShowMutex = 0;
}
else
{
ReqOperation = SHOW_TIME_OP;
}
}
break;
case JOY_CENTER:
if (ReadKey == 1)
{
PressedKey = SEL;
}
else
{
if (GetMutex == 1)
{
NextRep = 1;
ExitMutex = 1;
}
}
break;
default:
LCD_DisplayStringLine(Line9, (uint8_t*)" JOY ERROR ");
break;
}
/* Clear the interrupt pending bits */
IOE_ClearGITPending(IOE_2_ADDR, IOE_GIT_GPIO);
IOE_ClearIOITPending(IOE_2_ADDR, IOE_JOY_IT);
}
#endif /* USE_STM3210C_EVAL */
else
{
/* Clear the interrupt pending bits */
#ifdef USE_STM3210C_EVAL
IOE_ClearGITPending(IOE_1_ADDR, ALL_IT);
IOE_ClearGITPending(IOE_2_ADDR, ALL_IT);
#else
IOE_ClearGITPending(IOE_1_ADDR, ALL_IT);
#endif /* USE_STM3210C_EVAL */
}
}
/* Clear EXTI interrupts pending bits */
EXTI_ClearITPendingBit(IOE_IT_EXTI_LINE);
}
int main(void){
//configure push-button interrupts
PB_Config();
/* LCD initiatization */
LCD_Init();
/* LCD Layer initiatization */
LCD_LayerInit();
/* Enable the LTDC */
LTDC_Cmd(ENABLE);
/* Set LCD foreground layer */
LCD_SetLayer(LCD_FOREGROUND_LAYER);
//======You need to develop the following functions======
//Note: these are just placeholders; function definitions are at bottom of this file
//configure real-time clock
RTC_Config();
//configure external push-buttons and interrupts
ExtPB_Config();
ExtPBNum2();
//main program
LCD_Clear(LCD_COLOR_WHITE);
//line=0;
//Display a string in one line, on the first line (line=0)
//LCD_DisplayStringLine(LINE(line), (uint8_t *) "Init EEPROM...");
//line++;
//i2c_init(); //initialize the i2c chip
sEE_Init();
//LCD_DisplayStringLine(LINE(line), (uint8_t *) "done...");
//line++;
//LCD_DisplayStringLine(LINE(line), (uint8_t *) "Writing...");
//line++;
/* First write in the memory followed by a read of the written data --------*/
/* Write on I2C EEPROM from memLocation */
//sEE_WriteBuffer(&Tx1_Buffer, memLocation,1);
/* Wait for EEPROM standby state */
//sEE_WaitEepromStandbyState();
//LCD_DisplayStringLine(LINE(line), (uint8_t *) "Reading...");
/* Read from I2C EEPROM from memLocation */
//sEE_ReadBuffer(&Rx1_Buffer, memLocation, (uint16_t *)(&NumDataRead));
//line++;
//LCD_DisplayStringLine(LINE(line), (uint8_t *) "Comparing...");
//line++;
//if(Tx1_Buffer== Rx1_Buffer){
//LCD_DisplayStringLine(LINE(line), (uint8_t *) "Success!");
//}else{
//LCD_DisplayStringLine(LINE(line), (uint8_t *) "Mismatch!");
//}
//main loop
while(1){
RTC_GetTime(RTC_Format_BIN,&RTC_TimeStructure);
hours = RTC_TimeStructure.RTC_Hours;
minutes = RTC_TimeStructure.RTC_Minutes;
seconds = RTC_TimeStructure.RTC_Seconds;
sprintf(time,"%0.2d:%0.2d:%0.2d",hours,minutes,seconds);
LCD_DisplayStringLine(LINE(6), (uint8_t *) time);
if(UBPressed == 1){
toBeSaved = time[7];
sEE_WriteBuffer(&toBeSaved, memLocation+1,1);
sEE_WaitEepromStandbyState();
sEE_ReadBuffer(&Rx1_Buffer, memLocation+1, (uint16_t *)(&NumDataRead));
saved[0] = Rx1_Buffer;
LCD_DisplayStringLine(LINE(7), (uint8_t *) saved);
UBPressed = 0;
PB_Config();
}
if(EB1Pressed == 1 && state == 0){
state = 1;
EB1Pressed = 0;
ExtPB_Config();
}
if(EB1Pressed == 1 && state == 1){
state = 2;
EB1Pressed = 0;
ExtPB_Config();
}
if(EB1Pressed == 1 && state == 2){
state = 3;
EB1Pressed = 0;
ExtPB_Config();
}
if(EB1Pressed == 1 && state == 3){
state = 0;
EB1Pressed = 0;
ExtPB_Config();
}
if(EB2Pressed == 1 && state == 1){
RTC_TimeStructure.RTC_Hours = hours + 1;
RTC_SetTime(RTC_Format_BCD, &RTC_TimeStructure);
EB2Pressed = 0;
ExtPBNum2();
}
if(EB2Pressed == 1 && state == 2){
RTC_TimeStructure.RTC_Minutes = minutes + 1;
RTC_SetTime(RTC_Format_BCD, &RTC_TimeStructure);
EB2Pressed = 0;
ExtPBNum2();
}
if(EB2Pressed == 1 && state == 3){
RTC_TimeStructure.RTC_Seconds = seconds + 1;
RTC_SetTime(RTC_Format_BCD, &RTC_TimeStructure);
EB2Pressed = 0;
ExtPBNum2();
}
}
}
/**
* @brief Initializes the lwIP stack
* @param None
* @retval None
*/
void LwIP_Init(void)
{
struct ip_addr ipaddr;
struct ip_addr netmask;
struct ip_addr gw;
#ifndef USE_DHCP
uint8_t iptab[4] = {0};
uint8_t iptxt[20];
#endif
/* Initializes the dynamic memory heap defined by MEM_SIZE.*/
mem_init();
/* Initializes the memory pools defined by MEMP_NUM_x.*/
memp_init();
#ifdef USE_DHCP
ipaddr.addr = 0;
netmask.addr = 0;
gw.addr = 0;
#else
IP4_ADDR(&ipaddr, IP_ADDR0, IP_ADDR1, IP_ADDR2, IP_ADDR3);
IP4_ADDR(&netmask, NETMASK_ADDR0, NETMASK_ADDR1 , NETMASK_ADDR2, NETMASK_ADDR3);
IP4_ADDR(&gw, GW_ADDR0, GW_ADDR1, GW_ADDR2, GW_ADDR3);
#endif
/* - netif_add(struct netif *netif, struct ip_addr *ipaddr,
struct ip_addr *netmask, struct ip_addr *gw,
void *state, err_t (* init)(struct netif *netif),
err_t (* input)(struct pbuf *p, struct netif *netif))
Adds your network interface to the netif_list. Allocate a struct
netif and pass a pointer to this structure as the first argument.
Give pointers to cleared ip_addr structures when using DHCP,
or fill them with sane numbers otherwise. The state pointer may be NULL.
The init function pointer must point to a initialization function for
your ethernet netif interface. The following code illustrates it's use.*/
netif_add(&gnetif, &ipaddr, &netmask, &gw, NULL, ðernetif_init, ðernet_input);
/* Registers the default network interface.*/
netif_set_default(&gnetif);
if (EthStatus == (ETH_INIT_FLAG | ETH_LINK_FLAG))
{
/* Set Ethernet link flag */
gnetif.flags |= NETIF_FLAG_LINK_UP;
/* When the netif is fully configured this function must be called.*/
netif_set_up(&gnetif);
#ifdef USE_DHCP
DHCP_state = DHCP_START;
#else
#ifdef USE_LCD
iptab[0] = IP_ADDR3;
iptab[1] = IP_ADDR2;
iptab[2] = IP_ADDR1;
iptab[3] = IP_ADDR0;
sprintf((char*)iptxt, " %d.%d.%d.%d", iptab[3], iptab[2], iptab[1], iptab[0]);
LCD_DisplayStringLine(Line8, (uint8_t*)" Static IP address ");
LCD_DisplayStringLine(Line9, iptxt);
#endif
#endif /* USE_DHCP */
}
else
{
/* When the netif link is down this function must be called.*/
netif_set_down(&gnetif);
#ifdef USE_DHCP
DHCP_state = DHCP_LINK_DOWN;
#endif /* USE_DHCP */
/* Set the LCD Text Color */
LCD_SetTextColor(Red);
/* Display message on the LCD */
LCD_DisplayStringLine(Line5, (uint8_t*)" Network Cable is ");
LCD_DisplayStringLine(Line6, (uint8_t*)" not connected ");
/* Set the LCD Text Color */
LCD_SetTextColor(White);
}
/* Set the link callback function, this function is called on change of link status*/
netif_set_link_callback(&gnetif, ETH_link_callback);
}
/**
* @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_stm32f10x_xx.s) before to branch to application main.
To reconfigure the default setting of SystemInit() function, refer to
system_stm32f10x.c file
*/
Set_System();
Set_USBClock();
Led_Config();
USB_Interrupts_Config();
USB_Init();
/* Initialize LEDs, Key Button, LCD and COM port(USART) available on
STM3210X-EVAL board ******************************************************/
STM_EVAL_LEDInit(LED1);
STM_EVAL_LEDInit(LED2);
STM_EVAL_LEDInit(LED3);
STM_EVAL_LEDInit(LED4);
/* USARTx configured as follow:
- BaudRate = 115200 baud
- Word Length = 8 Bits
- One Stop Bit
- No parity
- Hardware flow control disabled (RTS and CTS signals)
- Receive and transmit enabled
*/
USART_InitStructure.USART_BaudRate = 115200;
USART_InitStructure.USART_WordLength = USART_WordLength_8b;
USART_InitStructure.USART_StopBits = USART_StopBits_1;
USART_InitStructure.USART_Parity = USART_Parity_No;
USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
STM_EVAL_COMInit(COM1, &USART_InitStructure);
/* Initialize the LCD */
#ifdef USE_STM32100B_EVAL
STM32100B_LCD_Init();
#elif defined (USE_STM3210B_EVAL)
STM3210B_LCD_Init();
#elif defined (USE_STM3210E_EVAL)
STM3210E_LCD_Init();
#elif defined (USE_STM3210C_EVAL)
STM3210C_LCD_Init();
#endif
/* Display message on STM3210X-EVAL LCD *************************************/
/* Clear the LCD */
LCD_Clear(White);
/* Set the LCD Back Color */
LCD_SetBackColor(Blue);
/* Set the LCD Text Color */
LCD_SetTextColor(White);
LCD_DisplayStringLine(Line0, MESSAGE1);
LCD_DisplayStringLine(Line1, MESSAGE2);
LCD_DisplayStringLine(Line2, MESSAGE3);
/* Retarget the C library printf function to the USARTx, can be USART1 or USART2
depending on the EVAL board you are using ********************************/
printf("\n\r %s", MESSAGE1);
printf(" %s", MESSAGE2);
printf(" %s\n\r", MESSAGE3);
printf("This is my first usrat log from mass storage");
/* Turn on leds available on STM3210X-EVAL **********************************/
STM_EVAL_LEDOn(LED1);
STM_EVAL_LEDOn(LED2);
STM_EVAL_LEDOn(LED3);
STM_EVAL_LEDOn(LED4);
/* Add your application code here
*/
/* Infinite loop */
while (1)
{
}
}
/*******************************************************************************
* Function Name : NMI_Handler
* Description : This function handles NMI exception.
* Input : None
* Output : None
* Return : None
*******************************************************************************/
void NMI_Handler(void)
{
uint32_t tmp = 318, index = 0;
/* Disable LCD Window mode */
LCD_WindowModeDisable();
/* If HSE is not detected at program startup or HSE clock failed during program execution */
if((Get_HSEStartUpStatus() == ERROR) || (RCC_GetITStatus(RCC_IT_CSS) != RESET))
{
/* Clear the LCD */
LCD_Clear(White);
/* Set the LCD Back Color */
LCD_SetBackColor(Blue);
/* Set the LCD Text Color */
LCD_SetTextColor(White);
/* Display " No Clock Detected " message */
LCD_DisplayStringLine(Line0, "No HSE Clock ");
LCD_DisplayStringLine(Line1, "Detected. STANDBY ");
LCD_DisplayStringLine(Line2, "mode in few seconds. ");
LCD_DisplayStringLine(Line5, "If HSE Clock ");
LCD_DisplayStringLine(Line6, "recovers before the ");
LCD_DisplayStringLine(Line7, "time out, a System ");
LCD_DisplayStringLine(Line8, "Reset is generated. ");
LCD_ClearLine(Line9);
/* Clear Clock Security System interrupt pending bit */
RCC_ClearITPendingBit(RCC_IT_CSS);
GPIO_SetBits(GPIOC, GPIO_Pin_6 | GPIO_Pin_7 | GPIO_Pin_8 | GPIO_Pin_9);
/* Enable HSE */
RCC_HSEConfig(RCC_HSE_ON);
LCD_ClearLine(Line4);
/* Set the Back Color */
LCD_SetBackColor(White);
/* Set the Text Color */
LCD_SetTextColor(Red);
LCD_DrawRect(71, 319, 25, 320);
LCD_SetBackColor(Green);
LCD_SetTextColor(White);
/* Wait till HSE is ready */
while(RCC_GetFlagStatus(RCC_FLAG_HSERDY) == RESET)
{
if(index == 0x3FFFF)
{
LCD_DisplayChar(Line3, tmp, 0x20);
tmp -= 16;
index = 0;
}
index++;
/* Enters the system in STANDBY mode */
if(tmp < 16)
{
LCD_SetBackColor(Blue);
LCD_ClearLine(Line3);
LCD_ClearLine(Line4);
LCD_ClearLine(Line5);
LCD_ClearLine(Line6);
LCD_DisplayStringLine(Line7, " MCU in STANDBY Mode");
LCD_DisplayStringLine(Line8, "To exit press Wakeup");
/* Request to enter STANDBY mode */
PWR_EnterSTANDBYMode();
}
}
/* Generate a system reset */
NVIC_SystemReset();
}
}
/**
* @brief Main program
* @param None
* @retval None: no exit point
*/
int main(void)
{
uint16_t u16Menu = 0;
uint16_t uVal;
NVIC_Relocate();
/* Initialize SysTick - 1msec resolution */
SysTick_Config(SystemCoreClock / 1000);
/* Initialize main board peripherals */
MBD_Init();
printf("miniSTM32 mainboard initialized.\n");
/* Initialize LCD support */
LCD_Init();
LCD_DisplayOn();
printf("LCD initialized.\n");
LCD_BacklightOn();
printf("\n\nPress the button to start demo.\n\n");
while (1)
{
/* main menu controlled by pushbutton interrupt */
if( uIRQFlag == MAIN_BTN_EXTI_LINE ) {
/* clear button interrupt flag */
uIRQFlag = 0;
/* droid family fonts */
if( u16Menu == MENU_FONT_TEST1 ) {
uVal = START_Y;
LCD_Clear(LCD_COLOR_BLACK);
LCD_SetFGColor(LCD_COLOR_YELLOW);
LCD_SetBGColor(LCD_COLOR(40,40,80));
/* 2.4inch LCD has not enough space to draw long string */
#if defined(LCD_QD024CPS25)
LCD_SetFont(&DroidSans_18);
LCD_DisplayStringLine(START_X, uVal, "Droid Sans 18 point");
uVal += DroidSans_18.Height + LINE_SEP;
LCD_SetFont(&DroidSans_Bold_18);
LCD_DisplayStringLine(START_X, uVal, "Droid Sans Bold 18 pt");
uVal += DroidSans_Bold_18.Height + LINE_SEP;
LCD_SetFont(&DroidSerif_18);
LCD_DisplayStringLine(START_X, uVal, "Droid Serif 18 point");
uVal += DroidSerif_18.Height + LINE_SEP;
LCD_SetFont(&DroidSerif_Bold_18);
LCD_DisplayStringLine(START_X, uVal, "Droid Serif Bold 18 pt");
uVal += DroidSerif_Bold_18.Height + LINE_SEP;
LCD_SetFont(&DroidSerif_Italic_18);
LCD_DisplayStringLine(START_X, uVal, "Droid Serif Italic 18");
#else
LCD_SetFont(&DroidSans_18);
LCD_DisplayStringLine(START_X, uVal, "Droid Sans 18 point");
uVal += DroidSans_18.Height + LINE_SEP;
LCD_SetFont(&DroidSans_Bold_18);
LCD_DisplayStringLine(START_X, uVal, "Droid Sans Bold 18 point");
uVal += DroidSans_Bold_18.Height + LINE_SEP;
LCD_SetFont(&DroidSerif_18);
LCD_DisplayStringLine(START_X, uVal, "Droid Serif 18 point");
uVal += DroidSerif_18.Height + LINE_SEP;
LCD_SetFont(&DroidSerif_Bold_18);
LCD_DisplayStringLine(START_X, uVal, "Droid Serif Bold 18 point");
uVal += DroidSerif_Bold_18.Height + LINE_SEP;
LCD_SetFont(&DroidSerif_Italic_18);
LCD_DisplayStringLine(START_X, uVal, "Droid Serif Italic 18 point");
#endif
}
/* liberation family fonts, federant font */
else if( u16Menu == MENU_FONT_TEST2 ) {
uVal = START_Y;
LCD_Clear(LCD_COLOR_BLACK);
LCD_SetFGColor(LCD_COLOR_YELLOW);
LCD_SetBGColor(LCD_COLOR(40,40,80));
/* 2.4inch LCD has not enough space to draw long string */
#if defined(LCD_QD024CPS25)
LCD_SetFont(&LiberationSans_18);
LCD_DisplayStringLine(START_X, uVal, "Liberation Sans 18 point");
uVal += LiberationSans_18.Height + LINE_SEP;
LCD_SetFont(&LiberationSerif_18);
LCD_DisplayStringLine(START_X, uVal, "Liberation Serif 18 point");
uVal += LiberationSerif_18.Height + LINE_SEP;
LCD_SetFont(&LiberationSerif_Italic_18);
LCD_DisplayStringLine(START_X, uVal, "Liberation Serif Italic 18");
uVal += LiberationSerif_Italic_18.Height + LINE_SEP;
LCD_SetFont(&Federant_18);
LCD_DisplayStringLine(START_X, uVal, "Federant 18 point");
#else
LCD_SetFont(&LiberationSans_18);
LCD_DisplayStringLine(START_X, uVal, "Liberation Sans 18 point");
uVal += LiberationSans_18.Height + LINE_SEP;
LCD_SetFont(&LiberationSerif_18);
LCD_DisplayStringLine(START_X, uVal, "Liberation Serif 18 point");
uVal += LiberationSerif_18.Height + LINE_SEP;
LCD_SetFont(&LiberationSerif_Italic_18);
LCD_DisplayStringLine(START_X, uVal, "Liberation Serif Italic 18 point");
uVal += LiberationSerif_Italic_18.Height + LINE_SEP;
LCD_SetFont(&Federant_18);
LCD_DisplayStringLine(START_X, uVal, "Federant 18 point");
#endif
}
/* Ubuntu family fonts */
else if( u16Menu == MENU_FONT_TEST3 ) {
uVal = START_Y;
LCD_Clear(LCD_COLOR_BLACK);
LCD_SetFGColor(LCD_COLOR_YELLOW);
LCD_SetBGColor(LCD_COLOR(40,40,80));
/* 2.4inch LCD has not enough space to draw long string */
#if defined(LCD_QD024CPS25)
LCD_SetFont(&Ubuntu_18);
LCD_DisplayStringLine(START_X, uVal, "Ubuntu 18 point");
uVal += Ubuntu_18.Height + LINE_SEP;
LCD_SetFont(&Ubuntu_Bold_18);
LCD_DisplayStringLine(START_X, uVal, "Ubuntu Bold 18 point");
uVal += Ubuntu_Bold_18.Height + LINE_SEP;
LCD_SetFont(&Ubuntu_Italic_18);
LCD_DisplayStringLine(START_X, uVal, "Ubuntu Italic 18");
#else
LCD_SetFont(&Ubuntu_18);
LCD_DisplayStringLine(START_X, uVal, "Ubuntu 18 point");
uVal += Ubuntu_18.Height + LINE_SEP;
LCD_SetFont(&Ubuntu_Bold_18);
LCD_DisplayStringLine(START_X, uVal, "Ubuntu Bold 18 point");
uVal += Ubuntu_Bold_18.Height + LINE_SEP;
LCD_SetFont(&Ubuntu_Italic_18);
LCD_DisplayStringLine(START_X, uVal, "Ubuntu Italic 18 point");
#endif
}
/* various size of droid sans */
else if( u16Menu == MENU_FONT_TEST4 ) {
uVal = START_Y;
LCD_Clear(LCD_COLOR_BLACK);
LCD_SetFGColor(LCD_COLOR_YELLOW);
LCD_SetBGColor(LCD_COLOR(40,40,80));
LCD_SetFont(&DroidSans_10);
LCD_DisplayStringLine(START_X, uVal, "DroidSans 10 point");
uVal += DroidSans_10.Height + LINE_SEP;
LCD_SetFont(&DroidSans_12);
LCD_DisplayStringLine(START_X, uVal, "DroidSans 12 point");
uVal += DroidSans_12.Height + LINE_SEP;
LCD_SetFont(&DroidSans_14);
LCD_DisplayStringLine(START_X, uVal, "DroidSans 14 point");
uVal += DroidSans_14.Height + LINE_SEP;
LCD_SetFont(&DroidSans_16);
LCD_DisplayStringLine(START_X, uVal, "DroidSans 16 point");
uVal += DroidSans_16.Height + LINE_SEP;
LCD_SetFont(&DroidSans_18);
LCD_DisplayStringLine(START_X, uVal, "DroidSans 18 point");
uVal += DroidSans_18.Height + LINE_SEP;
LCD_SetFont(&DroidSans_20);
LCD_DisplayStringLine(START_X, uVal, "DroidSans 20 point");
}
/* at the end of menu, restart all over */
if( ++u16Menu == MENU_END )
{
printf("\n\nEnd of Demo: Press the button to restart... \n\n\n");
u16Menu = 0;
}
}
/* usual household routine goes here */
{
}
}
}
/**
* @brief USBH_USR_MSC_Application
* Demo application for mass storage
* @param None
* @retval Staus
*/
int USBH_USR_MSC_Application(void)
{
FRESULT res;
uint8_t writeTextBuff[] = "BIG_MANTA FS/HS STM32 Connectivity line Host Demo application using FAT_FS ";
uint16_t bytesWritten, bytesToWrite;
/* Set LCD Layer size and pixel format */
LTDC_LayerPixelFormat(LTDC_Layer2, LTDC_Pixelformat_RGB565);
LTDC_LayerSize(LTDC_Layer2, 240, 320);
/* LTDC reload configuration */
LTDC_ReloadConfig(LTDC_IMReload);
switch(USBH_USR_ApplicationState)
{
case USH_USR_FS_INIT:
/* Initialises the File System*/
if ( f_mount( 0, &fatfs ) != FR_OK )
{
/* efs initialisation fails*/
LCD_ErrLog("> Cannot initialize File System.\n");
return(-1);
}
LCD_UsrLog("> File System initialized.\n");
LCD_UsrLog("> Disk capacity : %d Bytes\n", USBH_MSC_Param.MSCapacity * \
USBH_MSC_Param.MSPageLength);
if(USBH_MSC_Param.MSWriteProtect == DISK_WRITE_PROTECTED)
{
LCD_ErrLog((void *)MSG_WR_PROTECT);
}
USBH_USR_ApplicationState = USH_USR_FS_READLIST;
break;
case USH_USR_FS_READLIST:
LCD_UsrLog((void *)MSG_ROOT_CONT);
Explore_Disk("0:/", 1);
line_idx = 0;
USBH_USR_ApplicationState = USH_USR_FS_WRITEFILE;
break;
case USH_USR_FS_WRITEFILE:
/*Key B3 in polling*/
while((HCD_IsDeviceConnected(&USB_OTG_Core)) && \
(STM_EVAL_PBGetState (BUTTON_USER) != RESET))
{
Toggle_Leds();
}
/* Writes a text file, STM32.TXT in the disk*/
LCD_UsrLog("> Writing File to disk flash ...\n");
if(USBH_MSC_Param.MSWriteProtect == DISK_WRITE_PROTECTED)
{
LCD_ErrLog ( "> Disk flash is write protected \n");
USBH_USR_ApplicationState = USH_USR_FS_DRAW;
break;
}
/* Register work area for logical drives */
f_mount(0, &fatfs);
if(f_open(&file, "0:STM32.TXT",FA_CREATE_ALWAYS | FA_WRITE) == FR_OK)
{
/* Write buffer to file */
bytesToWrite = sizeof(writeTextBuff);
res= f_write (&file, writeTextBuff, bytesToWrite, (void *)&bytesWritten);
if((bytesWritten == 0) || (res != FR_OK)) /*EOF or Error*/
{
LCD_ErrLog("> STM32.TXT CANNOT be writen.\n");
}
else
{
LCD_UsrLog("> 'STM32.TXT' file created\n");
}
/*close file and filesystem*/
f_close(&file);
f_mount(0, NULL);
}
else
{
LCD_UsrLog ("> STM32.TXT created in the disk\n");
}
USBH_USR_ApplicationState = USH_USR_FS_DRAW;
LCD_SetTextColor(Green);
LCD_DisplayStringLine(LCD_LINE_15,"To start Image slide show ");
LCD_DisplayStringLine(LCD_LINE_16,"Press Key ");
LCD_SetTextColor(LCD_LOG_DEFAULT_COLOR);
while(STM_EVAL_PBGetState (BUTTON_USER) != SET)
{
Toggle_Leds();
}
break;
case USH_USR_FS_DRAW:
/*Key B3 in polling*/
while((HCD_IsDeviceConnected(&USB_OTG_Core)) && \
(STM_EVAL_PBGetState (BUTTON_USER) != RESET))
{
Toggle_Leds();
}
while(HCD_IsDeviceConnected(&USB_OTG_Core))
{
if ( f_mount( 0, &fatfs ) != FR_OK )
{
/* fat_fs initialisation fails*/
return(-1);
}
return Image_Browser("0:/");
}
break;
default: break;
}
return(0);
}
/**
* @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_stm32f429_439xx.s) before to branch to application main.
To reconfigure the default setting of SystemInit() function, refer to
system_stm32f4xx.c file
*/
/* LCD initiatization */
LCD_Init();
LCD_LayerInit();
/* LTDC reload configuration */
LTDC_ReloadConfig(LTDC_IMReload);
/* Enable the LTDC */
LTDC_Cmd(ENABLE);
/* Set LCD foreground layer */
LCD_SetLayer(LCD_FOREGROUND_LAYER);
/* Initialize LEDs mounted on STM32F429I-DISCO */
STM_EVAL_LEDInit(LED3);
STM_EVAL_LEDInit(LED4);
/* Initialize User Button mounted on STM32F429I-DISCO */
STM_EVAL_PBInit(BUTTON_USER, BUTTON_MODE_GPIO);
/* Display tset name on LCD */
LCD_Clear(LCD_COLOR_WHITE);
LCD_SetBackColor(LCD_COLOR_BLUE);
LCD_SetTextColor(LCD_COLOR_WHITE);
LCD_DisplayStringLine(LCD_LINE_4,(uint8_t*)" Flash Write ");
LCD_DisplayStringLine(LCD_LINE_5,(uint8_t*)"protection test");
LCD_DisplayStringLine(LCD_LINE_7,(uint8_t*)" Press User ");
LCD_DisplayStringLine(LCD_LINE_8,(uint8_t*)" push-button ");
while (1)
{
/* Wait for User push-button is pressed */
while (STM_EVAL_PBGetState(BUTTON_USER) != Bit_RESET)
{
}
/* Wait for User push-button is released */
while (STM_EVAL_PBGetState(BUTTON_USER) != Bit_SET)
{
}
/* Get FLASH_WRP_SECTORS write protection status */
SectorsWRPStatus = FLASH_OB_GetWRP() & FLASH_WRP_SECTORS;
if (SectorsWRPStatus == 0x00)
{
/* If FLASH_WRP_SECTORS are write protected, disable the write protection */
/* Enable the Flash option control register access */
FLASH_OB_Unlock();
/* Disable FLASH_WRP_SECTORS write protection */
FLASH_OB_WRPConfig(FLASH_WRP_SECTORS, DISABLE);
/* Start the Option Bytes programming process */
if (FLASH_OB_Launch() != FLASH_COMPLETE)
{
/* User can add here some code to deal with this error */
while (1)
{
}
}
/* Disable the Flash option control register access (recommended to protect
the option Bytes against possible unwanted operations) */
FLASH_OB_Lock();
/* Get FLASH_WRP_SECTORS write protection status */
SectorsWRPStatus = FLASH_OB_GetWRP() & FLASH_WRP_SECTORS;
/* Check if FLASH_WRP_SECTORS write protection is disabled */
if (SectorsWRPStatus == FLASH_WRP_SECTORS)
{
LCD_Clear(LCD_COLOR_GREEN);
LCD_SetTextColor(LCD_COLOR_BLACK);
LCD_DisplayStringLine(LCD_LINE_5,(uint8_t*)" Write ");
LCD_DisplayStringLine(LCD_LINE_6,(uint8_t*)" protection is ");
LCD_DisplayStringLine(LCD_LINE_7,(uint8_t*)" disabled ");
}
else
{
LCD_Clear(LCD_COLOR_RED);
LCD_SetTextColor(LCD_COLOR_BLACK);
LCD_DisplayStringLine(LCD_LINE_5,(uint8_t*)" Write ");
LCD_DisplayStringLine(LCD_LINE_6,(uint8_t*)" protection is ");
LCD_DisplayStringLine(LCD_LINE_7,(uint8_t*)" not disabled ");
}
}
else
{ /* If FLASH_WRP_SECTORS are not write protected, enable the write protection */
/* Enable the Flash option control register access */
FLASH_OB_Unlock();
/* Enable FLASH_WRP_SECTORS write protection */
FLASH_OB_WRPConfig(FLASH_WRP_SECTORS, ENABLE);
/* Start the Option Bytes programming process */
if (FLASH_OB_Launch() != FLASH_COMPLETE)
{
/* User can add here some code to deal with this error */
while (1)
{
}
}
/* Disable the Flash option control register access (recommended to protect
the option Bytes against possible unwanted operations) */
FLASH_OB_Lock();
/* Get FLASH_WRP_SECTORS write protection status */
SectorsWRPStatus = FLASH_OB_GetWRP() & FLASH_WRP_SECTORS;
/* Check if FLASH_WRP_SECTORS are write protected */
if (SectorsWRPStatus == 0x00)
{
LCD_Clear(LCD_COLOR_GREEN);
LCD_SetTextColor(LCD_COLOR_BLACK);
LCD_DisplayStringLine(LCD_LINE_5,(uint8_t*)" Write ");
LCD_DisplayStringLine(LCD_LINE_6,(uint8_t*)" protection is ");
LCD_DisplayStringLine(LCD_LINE_7,(uint8_t*)" enabled ");
}
else
{
LCD_Clear(LCD_COLOR_RED);
LCD_SetTextColor(LCD_COLOR_BLACK);
LCD_DisplayStringLine(LCD_LINE_5,(uint8_t*)" Write ");
LCD_DisplayStringLine(LCD_LINE_6,(uint8_t*)" protection is ");
LCD_DisplayStringLine(LCD_LINE_7,(uint8_t*)" not enabled ");
}
}
}
}
/**
* @brief Explore_Disk
* Displays disk content
* @param path: pointer to root path
* @retval None
*/
static uint8_t Explore_Disk (char* path , uint8_t recu_level)
{
FRESULT res;
FILINFO fno;
DIR dir;
char *fn;
char tmp[14];
res = f_opendir(&dir, path);
if (res == FR_OK) {
while(HCD_IsDeviceConnected(&USB_OTG_Core))
{
res = f_readdir(&dir, &fno);
if (res != FR_OK || fno.fname[0] == 0)
{
break;
}
if (fno.fname[0] == '.')
{
continue;
}
fn = fno.fname;
strcpy(tmp, fn);
line_idx++;
if(line_idx > 9)
{
line_idx = 0;
LCD_SetTextColor(Green);
LCD_DisplayStringLine (LCD_LINE_15, "Press Key to continue... ");
LCD_DisplayStringLine (LCD_LINE_16, " ");
LCD_SetTextColor(LCD_LOG_DEFAULT_COLOR);
/*Key B3 in polling*/
while((HCD_IsDeviceConnected(&USB_OTG_Core)) && \
(STM_EVAL_PBGetState (BUTTON_USER) != SET))
{
Toggle_Leds();
}
}
if(recu_level == 1)
{
LCD_DbgLog(" |__");
}
else if(recu_level == 2)
{
LCD_DbgLog(" | |__");
}
if((fno.fattrib & AM_MASK) == AM_DIR)
{
strcat(tmp, "\n");
LCD_UsrLog((void *)tmp);
}
else
{
strcat(tmp, "\n");
LCD_DbgLog((void *)tmp);
}
if(((fno.fattrib & AM_MASK) == AM_DIR)&&(recu_level == 1))
{
Explore_Disk(fn, 2);
}
}
}
return res;
}
int main(void)
{
CanTxMsg TxMessage;
float X_offset =0.0f,Y_offset =0.0f,Z_offset =0.0f;
float test_float=0.0f; uint8_t test_int=0;
float GyX =0.0f, GyY =0.0f, GyZ =0.0f;
float GyX_prev=0.0f,GyY_prev=0.0f,GyZ_prev=0.0f;
uint16_t x_len=240;
uint16_t y_len=320;
uint16_t i=0;
uint16_t buffer_screen[x_len][y_len];
/* For gyro receiving */
float receivedGyro1=0,receivedGyro1_prev=0;
float receivedGyro2=0,receivedGyro2_prev=0;
float receivedGyro3=0,receivedGyro3_prev=0;
uint8_t *ptr = & receivedGyro1;
// uint16_t *buf_ptr = &buffer_screen;
float runner=-8.0;
rectangular_t rect1;
rectangular_t prev_rect;
rectangular_t rect_screen;
char lcd_text_main[100];
/* LCD Initialization */
lcd_init();
lcd_drawBackground(20,60,250);
//lcd_drawBGPersimmon(20, 60, 250);
/* LED Initialization */
LED_Initialization();
/* CAN Initialization */
CAN2_Config();
CAN2_NVIC_Config();
/* MEMS Initialization */
Demo_GyroConfig();
Delay_1us(10000);
#define CALIBRATE_COUNT 1000
for (i=0;i<CALIBRATE_COUNT ;i++){
Demo_GyroReadAngRate (Buffer);
X_offset+= Buffer[0];
Y_offset+= Buffer[1];
Z_offset+= Buffer[2];
}
X_offset = X_offset/ (float)CALIBRATE_COUNT;
Y_offset = Y_offset/ (float)CALIBRATE_COUNT;
Z_offset = Z_offset/ (float)CALIBRATE_COUNT;
rect_screen.xlen = x_len;
rect_screen.ylen = y_len;
rect_screen.xpos = 0;
rect_screen.ypos = 0;
#define NEEDLE_RADIUS 65
#define NEEDLE_BASE_WIDTH 14
#define NEEDLE_FRAME_THICKNESS 5
#define NEEDLE1_CENTER_X 80
#define NEEDLE1_CENTER_Y 100
#define NEEDLE2_CENTER_X 80
#define NEEDLE2_CENTER_Y 200
#define NEEDLE3_CENTER_X 80
#define NEEDLE3_CENTER_Y 300
/* Drawing Needle frame 1 */
LCD_SetLayer(LCD_BACKGROUND_LAYER);
DrawThickCircle(NEEDLE1_CENTER_X ,NEEDLE1_CENTER_Y,NEEDLE_RADIUS+NEEDLE_FRAME_THICKNESS, 4,LCD_COLOR_BLACK,LCD_COLOR_WHITE-1);
LCD_SetLayer(LCD_FOREGROUND_LAYER);
DrawThickCircle(NEEDLE1_CENTER_X ,NEEDLE1_CENTER_Y,NEEDLE_BASE_WIDTH, 6,LCD_COLOR_BLACK,LCD_COLOR_WHITE-1);
LCD_SetLayer(LCD_BACKGROUND_LAYER);
LCD_SetColors(ASSEMBLE_RGB(20, 60, 250),LCD_COLOR_BLACK);
LCD_DrawFullRect(NEEDLE1_CENTER_X- NEEDLE_RADIUS-NEEDLE_FRAME_THICKNESS*2,NEEDLE1_CENTER_Y+ NEEDLE_BASE_WIDTH+3,NEEDLE_RADIUS*2+NEEDLE_FRAME_THICKNESS*4,NEEDLE_RADIUS);
LCD_SetLayer(LCD_FOREGROUND_LAYER);
LCD_SetColors(LCD_COLOR_BLACK,LCD_COLOR_BLACK);
LCD_DrawFullRect(NEEDLE1_CENTER_X- NEEDLE_RADIUS,NEEDLE1_CENTER_Y+ NEEDLE_BASE_WIDTH,NEEDLE_RADIUS*2,NEEDLE_FRAME_THICKNESS-1);
/* Drawing Needle frame 2 */
LCD_SetLayer(LCD_BACKGROUND_LAYER);
DrawThickCircle(NEEDLE2_CENTER_X ,NEEDLE2_CENTER_Y,NEEDLE_RADIUS+NEEDLE_FRAME_THICKNESS, 4,LCD_COLOR_BLACK,LCD_COLOR_WHITE-1);
LCD_SetLayer(LCD_FOREGROUND_LAYER);
DrawThickCircle(NEEDLE2_CENTER_X ,NEEDLE2_CENTER_Y,NEEDLE_BASE_WIDTH, 6,LCD_COLOR_BLACK,LCD_COLOR_WHITE-1);
LCD_SetLayer(LCD_BACKGROUND_LAYER);
LCD_SetColors(ASSEMBLE_RGB(20, 60, 250),LCD_COLOR_BLACK);
LCD_DrawFullRect(NEEDLE2_CENTER_X- NEEDLE_RADIUS-NEEDLE_FRAME_THICKNESS*2,NEEDLE2_CENTER_Y+ NEEDLE_BASE_WIDTH+3,NEEDLE_RADIUS*2+NEEDLE_FRAME_THICKNESS*4,NEEDLE_RADIUS);
LCD_SetLayer(LCD_FOREGROUND_LAYER);
LCD_SetColors(LCD_COLOR_BLACK,LCD_COLOR_BLACK);
LCD_DrawFullRect(NEEDLE2_CENTER_X- NEEDLE_RADIUS,NEEDLE2_CENTER_Y+ NEEDLE_BASE_WIDTH,NEEDLE_RADIUS*2,NEEDLE_FRAME_THICKNESS-1);
/* Drawing Needle frame 2 */
LCD_SetLayer(LCD_BACKGROUND_LAYER);
DrawThickCircle(NEEDLE3_CENTER_X ,NEEDLE3_CENTER_Y,NEEDLE_RADIUS+NEEDLE_FRAME_THICKNESS, 4,LCD_COLOR_BLACK,LCD_COLOR_WHITE-1);
LCD_SetLayer(LCD_FOREGROUND_LAYER);
DrawThickCircle(NEEDLE3_CENTER_X ,NEEDLE3_CENTER_Y,NEEDLE_BASE_WIDTH, 6,LCD_COLOR_BLACK,LCD_COLOR_WHITE-1);
LCD_SetLayer(LCD_BACKGROUND_LAYER);
LCD_SetColors(ASSEMBLE_RGB(20, 60, 250),LCD_COLOR_BLACK);
LCD_DrawFullRect(NEEDLE3_CENTER_X- NEEDLE_RADIUS-NEEDLE_FRAME_THICKNESS*2,NEEDLE3_CENTER_Y+ NEEDLE_BASE_WIDTH+3,NEEDLE_RADIUS*2+NEEDLE_FRAME_THICKNESS*4,NEEDLE_RADIUS);
LCD_SetLayer(LCD_FOREGROUND_LAYER);
LCD_SetColors(LCD_COLOR_BLACK,LCD_COLOR_BLACK);
LCD_DrawFullRect(NEEDLE3_CENTER_X- NEEDLE_RADIUS,NEEDLE3_CENTER_Y+ NEEDLE_BASE_WIDTH,NEEDLE_RADIUS*2,NEEDLE_FRAME_THICKNESS-1);
/* Clear drawing buffer */
PadRectangular(&buffer_screen,x_len,y_len,LCD_COLOR_WHITE, &rect_screen);
while(1)
{
board_ID = PIN_ID_Read();
LCD_SetColors(LCD_COLOR_BLACK,LCD_COLOR_WHITE-1);
sprintf(lcd_text_main," CAN Demo ID:%d ",board_ID);
LCD_DisplayStringLine(LINE(0), (uint8_t*)lcd_text_main);
Demo_GyroReadAngRate (Buffer);
//Delay_1us(1000);
/* MEMS Filtering */
#define LP_ALPHA 0.1f
GyX = GyX*(1.0f - LP_ALPHA) + (Buffer[0] - X_offset)*LP_ALPHA;
GyY = GyY*(1.0f - LP_ALPHA) + (Buffer[1] - Y_offset)*LP_ALPHA;
GyZ = GyZ*(1.0f - LP_ALPHA) + (Buffer[2] - Z_offset)*LP_ALPHA;
if(GyX > 90.0f) GyX = 90.0f;
if(GyX < -90.0f) GyX = -90.0f;
if(GyY > 90.0f) GyY = 90.0f;
if(GyY < -90.0f) GyY = -90.0f;
if(GyZ > 90.0f) GyZ = 90.0f;
if(GyZ < -90.0f) GyZ = -90.0f;
/* Start drawing rectangular */
prev_rect = rect1;
rect1.xlen = 25;
rect1.ylen = 30;
rect1.xpos = x_len/2+ (int16_t)(GyY)-10;
rect1.ypos = y_len/2 + (int16_t)(GyX)-10;
if(board_ID == 1){
MoveNeedle(LCD_BACKGROUND_LAYER,&buffer_screen,x_len,y_len,LCD_COLOR_GREEN,NEEDLE1_CENTER_X,NEEDLE1_CENTER_Y,-GyZ,-GyZ_prev,NEEDLE_RADIUS,NEEDLE_BASE_WIDTH);
}else if(board_ID == 2){
MoveNeedle(LCD_BACKGROUND_LAYER,&buffer_screen,x_len,y_len,LCD_COLOR_GREEN,NEEDLE2_CENTER_X,NEEDLE2_CENTER_Y,-GyZ,-GyZ_prev,NEEDLE_RADIUS,NEEDLE_BASE_WIDTH);
}else {
MoveNeedle(LCD_BACKGROUND_LAYER,&buffer_screen,x_len,y_len,LCD_COLOR_GREEN,NEEDLE3_CENTER_X,NEEDLE3_CENTER_Y,-GyZ,-GyZ_prev,NEEDLE_RADIUS,NEEDLE_BASE_WIDTH);
}
CAN2_TransmitGyro(board_ID,GyZ);
/* Received Data */
if( can2_rx_isr_flag ==1){
do{
if( can2_rx_isr_flag ==1){
can2RxMessage = CAN2_PassRXMessage();
can2_rx_isr_flag=0;
}else{
CAN_Receive(CAN2, CAN_FIFO0, &can2RxMessage);
}
GPIO_ToggleBits(GPIOG,GPIO_Pin_14);
ptr[0] = can2RxMessage.Data[0];
ptr[1] = can2RxMessage.Data[1];
ptr[2] = can2RxMessage.Data[2];
ptr[3] = can2RxMessage.Data[3];
if(( can2RxMessage.ExtId & 0x0000FFFF) == 1){
ptr = & receivedGyro1;
ptr[0] = can2RxMessage.Data[0];
ptr[1] = can2RxMessage.Data[1];
ptr[2] = can2RxMessage.Data[2];
ptr[3] = can2RxMessage.Data[3];
MoveNeedle(LCD_BACKGROUND_LAYER,&buffer_screen,x_len,y_len,LCD_COLOR_RED,NEEDLE1_CENTER_X,NEEDLE1_CENTER_Y,-receivedGyro1,-receivedGyro1_prev,NEEDLE_RADIUS,NEEDLE_BASE_WIDTH);
receivedGyro1_prev = receivedGyro1;
}else if (( can2RxMessage.ExtId & 0x0000FFFF) == 2){
ptr = & receivedGyro2;
ptr[0] = can2RxMessage.Data[0];
ptr[1] = can2RxMessage.Data[1];
ptr[2] = can2RxMessage.Data[2];
ptr[3] = can2RxMessage.Data[3];
MoveNeedle(LCD_BACKGROUND_LAYER,&buffer_screen,x_len,y_len,LCD_COLOR_RED,NEEDLE2_CENTER_X,NEEDLE2_CENTER_Y,-receivedGyro2,-receivedGyro2_prev,NEEDLE_RADIUS,NEEDLE_BASE_WIDTH);
receivedGyro2_prev = receivedGyro2;
}else if (( can2RxMessage.ExtId & 0x0000FFFF) == 3){
ptr = & receivedGyro3;
ptr[0] = can2RxMessage.Data[0];
ptr[1] = can2RxMessage.Data[1];
ptr[2] = can2RxMessage.Data[2];
ptr[3] = can2RxMessage.Data[3];
MoveNeedle(LCD_BACKGROUND_LAYER,&buffer_screen,x_len,y_len,LCD_COLOR_RED,NEEDLE3_CENTER_X,NEEDLE3_CENTER_Y,-receivedGyro3,-receivedGyro3_prev,NEEDLE_RADIUS,NEEDLE_BASE_WIDTH);
receivedGyro3_prev = receivedGyro3;
}
// LCD_SetColors(LCD_COLOR_BLACK,LCD_COLOR_WHITE-1);
// sprintf(lcd_text_main," ID :%d ", can2RxMessage.StdId);
// LCD_DisplayStringLine(LINE(1), (uint8_t*)lcd_text_main);
// LCD_SetColors(LCD_COLOR_BLACK,LCD_COLOR_WHITE-1);
// sprintf(lcd_text_main," Data :%f ", receivedGyro);
// LCD_DisplayStringLine(LINE(2), (uint8_t*)lcd_text_main);
}while(CAN_MessagePending(CAN2, CAN_FIFO0) > 0);
}
// {
// uint8_t status=0;
// while(CAN_TransmitStatus(CAN2, 0) != CAN_TxStatus_Ok ){
// status = CAN_TransmitStatus(CAN2, 0);
// if(status == CAN_TxStatus_Failed){
// GPIO_ToggleBits(GPIOG,GPIO_Pin_14);
// }
// }
// }
// TxMessage.StdId = (uint32_t)board_ID;
// TxMessage.RTR = CAN_RTR_DATA;
// TxMessage.IDE = CAN_ID_STD;
// TxMessage.DLC = 8;
// TxMessage.Data[0] = 0x01;
// TxMessage.Data[1] = 0x01;
// TxMessage.Data[2] = 0x01;
// TxMessage.Data[3] = 0x01;
// TxMessage.Data[4] = 0x01;
// TxMessage.Data[5] = 0x01;
// TxMessage.Data[6] = 0x01;
// TxMessage.Data[7] = 0x01;
// CAN_Transmit(CAN2, &TxMessage);
//CAN2_TransmitGyro(test_int++,test_float);
test_float += 0.1f;
GyX_prev = GyX;
GyZ_prev = GyZ;
GyY_prev = GyY;
runner += 1.0f;
/* Faster method */
//MoveAndUpdateRectangular(LCD_FOREGROUND_LAYER,&buffer_screen,x_len,y_len,LCD_COLOR_BLACK,&prev_rect, &rect1);
/* Regular method */
// PadRectangular(&buffer_screen,x_len,y_len,LCD_COLOR_WHITE, &prev_rect);
// PadRectangular(&buffer_screen,x_len,y_len,LCD_COLOR_BLACK, &rect1);
//DrawBufferToScreen(LCD_FOREGROUND_LAYER,buf_ptr,0,0, x_len,y_len);
}
}
/*******************************************************************************
* Function Name : Mass_Storage_Start
* Description : Starts the mass storage demo.
* Input : None
* Output : None
* Return : None
*******************************************************************************/
void Mass_Storage_Start (void)
{
NVIC_InitTypeDef NVIC_InitStructure;
/* Disble 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(USB_ICON);
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_FSMC, ENABLE);
/* Disable LCD Window mode */
LCD_WindowModeDisable();
/* Set the Back Color */
LCD_SetBackColor(Blue);
/* Set the Text Color */
LCD_SetTextColor(White);
/* Display the " Plug the USB " message */
LCD_DisplayStringLine(Line8, " Plug the USB Cable ");
LCD_DisplayStringLine(Line9, "Exit: Push JoyStick");
/* Enable and GPIOD clock */
USB_Disconnect_Config();
/* MAL configuration */
MAL_Config();
Set_USBClock();
NVIC_InitStructure.NVIC_IRQChannel = USB_LP_CAN1_RX0_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
NVIC_InitStructure.NVIC_IRQChannel = USB_HP_CAN1_TX_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
NVIC_InitStructure.NVIC_IRQChannel = SDIO_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
USB_Init();
while (bDeviceState != CONFIGURED)
{
if(ReadKey() != NOKEY)
{
PowerOff();
LCD_Clear(White);
DisplayMenu();
IntExtOnOffConfig(ENABLE);
return;
}
}
LCD_ClearLine(Line9);
/* Display the "To stop Press SEL" message */
LCD_DisplayStringLine(Line8, " To stop Press SEL ");
/* Loop until SEL key pressed */
while(ReadKey() != SEL)
{
}
PowerOff();
LCD_Clear(White);
DisplayMenu();
IntExtOnOffConfig(ENABLE);
}
/**
* @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
*/
/* Set the vector table address */
#if defined(BOOT_FROM_BANK1)
/* Set the vector table to the Bank1 start address */
NVIC_SetVectorTable(NVIC_VectTab_FLASH, BANK1_START_ADDRESS);
#elif defined(BOOT_FROM_BANK2)
/* Set the vector table to the Bank1 start address */
NVIC_SetVectorTable(NVIC_VectTab_FLASH, BANK2_START_ADDRESS);
#endif /* BOOT_FROM_BANK1 */
/* Initialize LEDs, Buttons and LCD on STM32L152D-EVAL board ****************/
STM_EVAL_LEDInit(LED1);
STM_EVAL_LEDInit(LED2);
STM_EVAL_LEDInit(LED3);
STM_EVAL_LEDInit(LED4);
/* Save the first BANK1 page */
FLASH_SaveBANK1();
/* Save the first BANK2 page */
FLASH_SaveBANK2();
/* SysTick end of count event each 10ms */
RCC_GetClocksFreq(&RCC_Clocks);
SysTick_Config(RCC_Clocks.HCLK_Frequency / 100);
/* Configure the Joystick buttons */
STM_EVAL_PBInit(BUTTON_UP, BUTTON_MODE_GPIO);
STM_EVAL_PBInit(BUTTON_SEL, BUTTON_MODE_GPIO);
STM_EVAL_PBInit(BUTTON_DOWN, BUTTON_MODE_GPIO);
STM_EVAL_PBInit(BUTTON_RIGHT, BUTTON_MODE_GPIO);
STM_EVAL_PBInit(BUTTON_LEFT, BUTTON_MODE_GPIO);
/* Initialize the LCD */
STM32L152D_LCD_Init();
/* Display message on STM32L152D-EVAL LCD ************************************/
/* Clear the LCD */
LCD_Clear(LCD_COLOR_WHITE);
/* Set the LCD Back Color */
#if defined(BOOT_FROM_BANK1)
LCD_SetBackColor(LCD_COLOR_BLUE);
#elif defined(BOOT_FROM_BANK2)
LCD_SetBackColor(LCD_COLOR_RED);
#endif /* BOOT_FROM_BANK1 */
/* Set the LCD Text Color */
LCD_SetTextColor(LCD_COLOR_WHITE);
LCD_DisplayStringLine(LCD_LINE_0, MESSAGE1);
LCD_DisplayStringLine(LCD_LINE_1, MESSAGE2);
LCD_DisplayStringLine(LCD_LINE_2, MESSAGE3);
LCD_DisplayStringLine(LCD_LINE_4, MESSAGE4);
LCD_SetFont(&Font12x12);
LCD_SetTextColor(LCD_COLOR_GREEN);
LCD_DisplayStringLine(LCD_LINE_10, MESSAGE5);
LCD_DisplayStringLine(LCD_LINE_11, MESSAGE6);
LCD_SetTextColor(LCD_COLOR_WHITE);
LCD_DisplayStringLine(LCD_LINE_12, MESSAGE7);
LCD_DisplayStringLine(LCD_LINE_13, MESSAGE8);
LCD_SetTextColor(LCD_COLOR_GREEN);
LCD_DisplayStringLine(LCD_LINE_14, MESSAGE9);
LCD_DisplayStringLine(LCD_LINE_15, MESSAGE10);
LCD_SetTextColor(LCD_COLOR_WHITE);
LCD_DisplayStringLine(LCD_LINE_16, MESSAGE11);
LCD_DisplayStringLine(LCD_LINE_17, MESSAGE12);
LCD_SetTextColor(LCD_COLOR_GREEN);
LCD_DisplayStringLine(LCD_LINE_18, MESSAGE13);
LCD_DisplayStringLine(LCD_LINE_19, MESSAGE14);
LCD_SetTextColor(LCD_COLOR_WHITE);
LCD_SetFont(&Font16x24);
/* Turn on leds available on STM32L152D-EVAL ************************************/
STM_EVAL_LEDOn(LED1);
STM_EVAL_LEDOn(LED2);
STM_EVAL_LEDOn(LED3);
STM_EVAL_LEDOn(LED4);
/* Infinite loop */
while (1)
{
/*--- If Joystick DOWN button is pushed, reset BFB2 bit to enable boot from Bank2
(active after next reset, w/ Boot pins set in Boot from Flash memory position ---*/
if (STM_EVAL_PBGetState(BUTTON_DOWN) == 0)
{
/* Reset BFB2 bit to enable boot from Flash Bank2 */
FLASH_Unlock();
FLASH_OB_Unlock();
FLASH_ClearFlag(FLASH_FLAG_EOP|FLASH_FLAG_WRPERR | FLASH_FLAG_PGAERR |
FLASH_FLAG_SIZERR | FLASH_FLAG_OPTVERR | FLASH_FLAG_OPTVERRUSR);
FLASH_OB_UserConfig(OB_IWDG_SW, OB_STOP_NoRST, OB_STDBY_NoRST);
FLASH_OB_BORConfig(OB_BOR_LEVEL1);
if (FLASH_OB_BootConfig(OB_BOOT_BANK2) == FLASH_COMPLETE)
{
/* Generate System Reset to load the new option byte values */
FLASH_OB_Launch();
}
else
{
/* Display information */
LCD_DisplayStringLine(LCD_LINE_6, MESSAGE15);
}
}
/*--- If Joystick UP button is pushed, set BFB2 bit to enable boot from Bank1
(active after next reset, w/ Boot pins set in Boot from Flash memory position ---*/
if (STM_EVAL_PBGetState(BUTTON_UP) == 0)
{
/* Set BFB2 bit to enable boot from Flash Bank2 */
FLASH_Unlock();
FLASH_OB_Unlock();
FLASH_ClearFlag(FLASH_FLAG_EOP|FLASH_FLAG_WRPERR | FLASH_FLAG_PGAERR |
FLASH_FLAG_SIZERR | FLASH_FLAG_OPTVERR | FLASH_FLAG_OPTVERRUSR);
FLASH_OB_UserConfig(OB_IWDG_SW, OB_STOP_NoRST, OB_STDBY_NoRST);
FLASH_OB_BORConfig(OB_BOR_LEVEL1);
if (FLASH_OB_BootConfig(OB_BOOT_BANK1) == FLASH_COMPLETE)
{
/* Generate System Reset to load the new option byte values */
FLASH_OB_Launch();
}
else
{
/* Display information */
LCD_DisplayStringLine(LCD_LINE_6, MESSAGE15);
}
}
/*--- If Joystick LEFT button is pushed, program the content of address 0x08000000
(base address of Bank1) to 0x00 ---*/
if (STM_EVAL_PBGetState(BUTTON_LEFT) == 0)
{
FLASH_Unlock();
FLASH_ClearFlag(FLASH_FLAG_EOP | FLASH_FLAG_WRPERR | FLASH_FLAG_PGAERR |
FLASH_FLAG_SIZERR | FLASH_FLAG_OPTVERR | FLASH_FLAG_OPTVERRUSR);
/* Erase stack pointer value at Bank 1 start address */
FLASH_ErasePage(0x08000000);
FLASH_Lock();
LCD_ClearLine(LCD_LINE_5);
LCD_ClearLine(LCD_LINE_7);
LCD_ClearLine(LCD_LINE_8);
LCD_ClearLine(LCD_LINE_9);
/* Check if erase operation is OK */
if ((uint32_t)(*(uint32_t *)BANK1_START_ADDRESS) != 0x00)
{
/* Display information */
LCD_DisplayStringLine(LCD_LINE_6, MESSAGE15);
}
else
{
/* Display information */
LCD_DisplayStringLine(LCD_LINE_6, MESSAGE16);
}
}
/*--- If Joystick RIGHT button is pushed, program the content of address 0x08030000
(base address of Bank2) to 0x00 ---*/
if (STM_EVAL_PBGetState(BUTTON_RIGHT) == 0)
{
FLASH_Unlock();
FLASH_ClearFlag(FLASH_FLAG_EOP|FLASH_FLAG_WRPERR | FLASH_FLAG_PGAERR |
FLASH_FLAG_SIZERR | FLASH_FLAG_OPTVERR | FLASH_FLAG_OPTVERRUSR);
/* Erase stack pointer value at Bank 2 start address */
FLASH_ErasePage(0x08030000);
FLASH_Lock();
LCD_ClearLine(LCD_LINE_5);
LCD_ClearLine(LCD_LINE_7);
LCD_ClearLine(LCD_LINE_8);
LCD_ClearLine(LCD_LINE_9);
/* Check if erase operation is OK */
if ((uint32_t)(*(uint32_t *)BANK2_START_ADDRESS) != 0x00)
{
/* Display information */
LCD_DisplayStringLine(LCD_LINE_6, MESSAGE15);
}
else
{
/* Display information */
LCD_DisplayStringLine(LCD_LINE_6, MESSAGE16);
}
}
/*--- If Joystick UP button is pushed, copy the program to the cross bank --*/
if (STM_EVAL_PBGetState(BUTTON_SEL) == 0)
{
FLASH_Unlock();
FLASH_ClearFlag(FLASH_FLAG_EOP|FLASH_FLAG_WRPERR | FLASH_FLAG_PGAERR |
FLASH_FLAG_SIZERR | FLASH_FLAG_OPTVERR | FLASH_FLAG_OPTVERRUSR);
#if defined (BOOT_FROM_BANK1)
/* Erase one page in BANK2 to store the first page */
FLASH_ErasePage(0x08030000);
for(index = 0; index < 64; index++)
{
FLASH_FastProgramWord((0x08030000 + (index * 4)), (*(uint32_t *)(0x08020000 + (index * 4))));
}
#elif defined (BOOT_FROM_BANK2)
/* Erase one page in BANK1 to store the first page */
FLASH_ErasePage(0x08000000);
for(index = 0; index < 64; index++)
{
FLASH_FastProgramWord((0x08000000 + (index * 4)), (*(uint32_t *)(0x08050000 + (index * 4))));
}
#endif
}
/* Toggle LD3 */
STM_EVAL_LEDToggle(LED3);
/* Insert 50 ms delay */
Delay(5);
/* Toggle LD2 */
STM_EVAL_LEDToggle(LED2);
/* Insert 100 ms delay */
Delay(10);
}
}
/**
* @brief Main program
* @param None
* @retval None
*/
int main(void)
{
uint32_t counter = 0, transparency = 0;
uint8_t str[30];
/*!< At this stage the microcontroller clock setting is already configured,
this is done through SystemInit() function which is called from startup
files (startup_stm32f429_439xx.s) before to branch to application main.
*/
/* TAMPER button will be used */
STM_EVAL_PBInit(BUTTON_TAMPER, BUTTON_MODE_GPIO);
/* SysTick end of count event each 10ms */
SysTick_Config(SystemCoreClock / 1000);
/* Configure LCD */
LCD_Config();
/* SD Card Configuration */
SDCard_Config();
/* Configure the File System */
FileSystem_Config();
/* Get the BMP file names on root directory */
ubNumberOfFiles = Storage_GetDirectoryBitmapFiles("/PICT", pDirectoryFiles);
if (ubNumberOfFiles == 0)
{
for (counter = 0; counter < MAX_BMP_FILES; counter++)
{
free(pDirectoryFiles[counter]);
}
LCD_DisplayStringLine(LCD_LINE_8, (uint8_t*)" No Bitmap files... ");
while(1)
{
}
}
while(1)
{
counter = 0;
while ((counter) < ubNumberOfFiles)
{
/* Step1 : Display on Foreground layer -------------------------------*/
/* Format the string */
sprintf ((char*)str, "PICT/%-11.11s", pDirectoryFiles[counter]);
if (Storage_CheckBitmapFile((const char*)str, &uwBmplen) == 0)
{
/* Format the string */
sprintf ((char*)str, "PICT/%-11.11s", pDirectoryFiles[counter]);
/* Set LCD foreground Layer */
LCD_SetLayer(LCD_FOREGROUND_LAYER);
/* Open a file and copy its content to an internal buffer */
Storage_OpenReadFile(uwInternelBuffer, (const char*)str);
/* Write bmp file on LCD frame buffer */
LCD_WriteBMP(uwInternelBuffer);
/* Configure the transparency for background layer : Increase the transparency */
for (transparency = 0; transparency < 255; (transparency++))
{
LCD_SetTransparency(transparency);
/* Insert a delay of display */
Delay(5);
}
/* Wait for tamper button pressed */
while (STM_EVAL_PBGetState(BUTTON_TAMPER) == Bit_SET)
{
}
/* Configure the transparency for foreground layer : decrease the transparency */
for (transparency = 255; transparency > 0; transparency--)
{
LCD_SetTransparency(transparency);
/* Insert a delay of display */
Delay(5);
}
/* Jump to the next image */
counter++;
/* Step2 : Display on Background layer -----------------------------*/
/* Format the string */
sprintf ((char*)str, "PICT/%-11.11s", pDirectoryFiles[counter]);
if ((Storage_CheckBitmapFile((const char*)str, &uwBmplen) == 0) || (counter < (ubNumberOfFiles)))
{
/* Connect the Output Buffer to LCD Background Layer */
LCD_SetLayer(LCD_BACKGROUND_LAYER);
/* Format the string */
sprintf ((char*)str, "PICT/%-11.11s", pDirectoryFiles[counter]);
/* Open a file and copy its content to an internal buffer */
Storage_OpenReadFile(uwInternelBuffer, (const char*)str);
/* Write bmp file on LCD frame buffer */
LCD_WriteBMP(uwInternelBuffer);
/* Configure the transparency for background layer : decrease the transparency */
for (transparency = 0; transparency < 255; (transparency++))
{
LCD_SetTransparency(transparency);
/* Insert a delay of display */
Delay(5);
}
/* wait for tamper button pressed */
while (STM_EVAL_PBGetState(BUTTON_TAMPER) == Bit_SET)
{
}
/* Step3 : -------------------------------------------------------*/
/* Configure the transparency for background layer : Increase the transparency */
for (transparency = 255; transparency > 0; transparency--)
{
LCD_SetTransparency(transparency);
/* Insert a delay of display */
Delay(5);
}
counter++;
}
else if (Storage_CheckBitmapFile((const char*)str, &uwBmplen) == 0)
{
/* Set the Text Color */
LCD_SetTextColor(LCD_COLOR_RED);
LCD_DisplayStringLine(LCD_LINE_7, (uint8_t *) str);
LCD_DisplayStringLine(LCD_LINE_8, (uint8_t*)" File type not supported. ");
while(1)
{
}
}
}
}
}
}
/**
* @brief Display Init (LCD or/and USART)
* @param None
* @retval None
*/
static void Display_Init(void)
{
#ifdef PRINT_ON_USART
USART_InitTypeDef USART_InitStructure;
/* USARTx configured as follows:
- BaudRate = 115200 baud
- Word Length = 8 Bits
- One Stop Bit
- No parity
- Hardware flow control disabled (RTS and CTS signals)
- Receive and transmit enabled
*/
USART_InitStructure.USART_BaudRate = 115200;
USART_InitStructure.USART_WordLength = USART_WordLength_8b;
USART_InitStructure.USART_StopBits = USART_StopBits_1;
USART_InitStructure.USART_Parity = USART_Parity_No;
USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
STM_EVAL_COMInit(COM1, &USART_InitStructure);
printf("\n\r ========================================\n");
printf("\n\r ==== Multiple RNG Generator Example ====\n");
printf("\n\r ======================================== \n\n\r");
printf("\n\r Press key button to generate 8 x 32bit random number\n");
#endif
#ifdef PRINT_ON_LCD
/* Initialize the LCD */
LCD_Init();
/* Display message on LCD ***************************************************/
#if defined (USE_STM324x9I_EVAL)
/* Initialize the LCD Layers */
LCD_LayerInit();
/* Enable The Display */
LCD_DisplayOn();
/* Set LCD Background Layer */
LCD_SetLayer(LCD_BACKGROUND_LAYER);
/* Clear the Background Layer */
LCD_Clear(LCD_COLOR_WHITE);
/* Set LCD Foreground Layer */
LCD_SetLayer(LCD_FOREGROUND_LAYER);
/* Configure the transparency for foreground */
LCD_SetTransparency(100);
#endif /* USE_STM324x9I_EVAL */
/* Clear the LCD */
LCD_Clear(White);
/* Set the LCD Text size */
LCD_SetFont(&FONTSIZE);
/* Set the LCD Back Color and Text Color*/
LCD_SetBackColor(Blue);
LCD_SetTextColor(White);
LCD_DisplayStringLine(LINE(LINENUM), (uint8_t*)MESSAGE1);
LCD_DisplayStringLine(LINE(0x16), (uint8_t*)" ");
/* Set the LCD Text size */
LCD_SetFont(&Font16x24);
LCD_DisplayStringLine(LINE(0), (uint8_t*)MESSAGE2);
/* Set the LCD Back Color and Text Color*/
LCD_SetBackColor(White);
LCD_SetTextColor(Blue);
LCD_DisplayStringLine(LINE(3), (uint8_t*)MESSAGE3);
LCD_DisplayStringLine(LINE(5), (uint8_t*)MESSAGE4);
#endif
}
/**
* @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);
}
}
}
/**
* @brief LwIP_DHCP_Process_Handle
* @param None
* @retval None
*/
void LwIP_DHCP_Process_Handle()
{
struct ip_addr ipaddr;
struct ip_addr netmask;
struct ip_addr gw;
uint8_t iptab[4];
uint8_t iptxt[20];
switch (DHCP_state)
{
case DHCP_START:
{
dhcp_start(&netif);
IPaddress = 0;
DHCP_state = DHCP_WAIT_ADDRESS;
#ifdef USE_LCD
LCD_DisplayStringLine(Line4, (uint8_t*)" Looking for ");
LCD_DisplayStringLine(Line5, (uint8_t*)" DHCP server ");
LCD_DisplayStringLine(Line6, (uint8_t*)" please wait... ");
#endif
}
break;
case DHCP_WAIT_ADDRESS:
{
/* Read the new IP address */
IPaddress = netif.ip_addr.addr;
if (IPaddress!=0) {
DHCP_state = DHCP_ADDRESS_ASSIGNED;
/* Stop DHCP */
dhcp_stop(&netif);
#ifdef USE_LCD
iptab[0] = (uint8_t)(IPaddress >> 24);
iptab[1] = (uint8_t)(IPaddress >> 16);
iptab[2] = (uint8_t)(IPaddress >> 8);
iptab[3] = (uint8_t)(IPaddress);
sprintf((char*)iptxt, " %d.%d.%d.%d", iptab[3], iptab[2], iptab[1], iptab[0]);
LCD_ClearLine(Line4);
LCD_ClearLine(Line5);
LCD_ClearLine(Line6);
/* Display the IP address */
LCD_DisplayStringLine(Line7, (uint8_t*)"IP address assigned ");
LCD_DisplayStringLine(Line8, (uint8_t*)" by a DHCP server ");
LCD_DisplayStringLine(Line9, iptxt);
#endif
} else {
/* DHCP timeout */
if (netif.dhcp->tries > MAX_DHCP_TRIES) {
DHCP_state = DHCP_TIMEOUT;
/* Stop DHCP */
dhcp_stop(&netif);
/* Static address used */
IP4_ADDR(&ipaddr, IP_ADDR0 ,IP_ADDR1 , IP_ADDR2 , IP_ADDR3 );
IP4_ADDR(&netmask, NETMASK_ADDR0, NETMASK_ADDR1, NETMASK_ADDR2, NETMASK_ADDR3);
IP4_ADDR(&gw, GW_ADDR0, GW_ADDR1, GW_ADDR2, GW_ADDR3);
netif_set_addr(&netif, &ipaddr , &netmask, &gw);
#ifdef USE_LCD
LCD_DisplayStringLine(Line7, (uint8_t*)" DHCP timeout ");
iptab[0] = IP_ADDR3;
iptab[1] = IP_ADDR2;
iptab[2] = IP_ADDR1;
iptab[3] = IP_ADDR0;
sprintf((char*)iptxt, " %d.%d.%d.%d", iptab[3], iptab[2], iptab[1], iptab[0]);
LCD_ClearLine(Line4);
LCD_ClearLine(Line5);
LCD_ClearLine(Line6);
LCD_DisplayStringLine(Line8, (uint8_t*)" Static IP address ");
LCD_DisplayStringLine(Line9, iptxt);
#endif
}
}
}
static void DrawText(uint8_t* text)
{
/* Windowing configuration */
/* In this case all the active display area is used to display a picture then :
Horizontal start = horizontal synchronization + Horizontal back porch = 30
Horizontal stop = Horizontal start + window width -1 = 30 + 240 -1
Vertical start = vertical synchronization + vertical back porch = 4
Vertical stop = Vertical start + window height -1 = 4 + 320 -1 */
LTDC_Layer_InitStruct.LTDC_HorizontalStart = 30;
LTDC_Layer_InitStruct.LTDC_HorizontalStop = (LCD_PIXEL_WIDTH + 30 - 1);
LTDC_Layer_InitStruct.LTDC_VerticalStart = 4;
LTDC_Layer_InitStruct.LTDC_VerticalStop = (LCD_PIXEL_HEIGHT + 4 - 1);
/* Pixel Format configuration*/
LTDC_Layer_InitStruct.LTDC_PixelFormat = LTDC_Pixelformat_RGB565;
/* Alpha constant (255 totally opaque) */
LTDC_Layer_InitStruct.LTDC_ConstantAlpha = 255;
/* Default Color configuration (configure A,R,G,B component values) */
LTDC_Layer_InitStruct.LTDC_DefaultColorBlue = 0;
LTDC_Layer_InitStruct.LTDC_DefaultColorGreen = 0;
LTDC_Layer_InitStruct.LTDC_DefaultColorRed = 0;
LTDC_Layer_InitStruct.LTDC_DefaultColorAlpha = 255;
/* the length of one line of pixels in bytes + 3 then :
Line Lenth = Active high width x number of bytes per pixel + 3
Active high width = LCD_PIXEL_WIDTH
number of bytes per pixel = 2 (pixel_format : RGB565)
*/
LTDC_Layer_InitStruct.LTDC_CFBLineLength = ((LCD_PIXEL_WIDTH * 2) + 3);
/* the pitch is the increment from the start of one line of pixels to the
start of the next line in bytes, then :
Pitch = Active high width x number of bytes per pixel */
LTDC_Layer_InitStruct.LTDC_CFBPitch = (LCD_PIXEL_WIDTH * 2);
/* Configure the number of lines */
LTDC_Layer_InitStruct.LTDC_CFBLineNumber = LCD_PIXEL_HEIGHT;
/* Configure Layer2 */
/* Start Address configuration : the LCD Frame buffer is defined on SDRAM w/ Offset */
LTDC_Layer_InitStruct.LTDC_CFBStartAdress = LCD_FRAME_BUFFER + BUFFER_OFFSET;
/* Configure blending factors */
LTDC_Layer_InitStruct.LTDC_BlendingFactor_1 = LTDC_BlendingFactor1_PAxCA;
LTDC_Layer_InitStruct.LTDC_BlendingFactor_2 = LTDC_BlendingFactor2_PAxCA;
/* Initialize LTDC layer 2 */
LTDC_LayerInit(LTDC_Layer2, <DC_Layer_InitStruct);
/* LTDC configuration reload */
LTDC_ReloadConfig(LTDC_IMReload);
/* Enable foreground & background Layers */
LTDC_LayerCmd(LTDC_Layer2, ENABLE);
/* Set default font */
LCD_SetFont(&LCD_DEFAULT_FONT);
/* Set LCD foreground layer */
LCD_SetLayer(LCD_FOREGROUND_LAYER);
LCD_SetColorKeying(0x0);
/* LCD display message */
LCD_Clear(LCD_COLOR_BLACK);
LCD_SetTextColor(LCD_COLOR_RED);
LCD_SetBackColor(LCD_COLOR_BLACK);
LCD_DisplayStringLine(LCD_LINE_1,(uint8_t*)text);
}
/**
* @brief Returns the time entered by user, using menu navigation keys.
* @param None
* @retval Current date value
*/
static void Date_Regulate(void)
{
uint8_t weekday = 0, date = 0, month = 0, year = 0;
LCD_DisplayStringLine(LCD_LINE_15, (uint8_t*)"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);
}
void ui_start_tuner()
{
int i = 0, solmization = 0;
int index = 0,min = 999,tmp = 0;
int stage = 0;
int pos = 0;
if(hz < frequency_stage_threshold[0]){
stage = 0;
}else if(hz > frequency_stage_threshold[0] && hz < frequency_stage_threshold[1]){
stage = 1;
}else{
stage = 2;
}
for(i = 0; i < 7; i++){
tmp = hz - frequency_stage[stage][i];
if(tmp < 0)
{
tmp *= -1;
}
if(tmp < min){
min = tmp;
index = i;
}
}
solmization = index;
min = 9999;
tmp = 0;
for(i = 0; i < 7; i++){
tmp = hz - frequency_stage[stage][i];
if(tmp < min && tmp > 0){
min = tmp;
index = i;
}
}
tmp = hz - frequency_stage[stage][index];
if(hz <= 65){
pos = 0;
}else if(hz > 490){
pos = 30*6;
}else{
pos = 30 * index + 30 * tmp/(frequency_stage[stage][index+1] - frequency_stage[stage][index]);
}
itoa(hz, hz_value_str, 10);
frequency_str[0] = '\0';
strcat((char *)frequency_str, (char *)space_str);
strcat((char *)frequency_str, (char *)hz_value_str);
strcat((char *)frequency_str, (char *)hz_str);
LCD_SetColors(LCD_COLOR_MAGENTA , LCD_COLOR_WHITE);
//base scale line
LCD_DrawLine(20, 200, 200, LCD_DIR_HORIZONTAL);
LCD_DrawLine(30, 180, 40, LCD_DIR_VERTICAL);
//draw scale
for(i = 1; i <= 6; i++){
LCD_DrawLine(30 + 30*i, 180, 40, LCD_DIR_VERTICAL);
}
LCD_DisplayChar(LCD_LINE_2, 115, solmization_char[solmization]);
LCD_DisplayStringLine(LCD_LINE_4, frequency_str);
ui_draw_solmization();
ui_draw_pos(pos);
ui_swap_layer();
}
