/**
* @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
*/
#if defined (RTC_CLOCK_SOURCE_LSI)
/* Enable the LSI OSC */
RCC_LSICmd(ENABLE);
#endif /* RTC_CLOCK_SOURCE_LSI */
/* Configure the external interrupt "WAKEUP" and "TAMPER" buttons */
STM_EVAL_PBInit(BUTTON_TAMPER , BUTTON_MODE_EXTI);
STM_EVAL_PBInit(BUTTON_SEL , BUTTON_MODE_EXTI);
/* Configure LEDs */
STM_EVAL_LEDInit(LED1);
STM_EVAL_LEDInit(LED2);
STM_EVAL_LEDOn(LED1);
/* Initialize the LCD */
#ifdef USE_STM320518_EVAL
STM320518_LCD_Init();
#else
STM32072B_LCD_Init();
#endif /* USE_STM320518_EVAL */
/* Clear the LCD */
LCD_Clear(White);
/* Enable The Display */
LCD_DisplayOn();
/* Set the LCD Back Color and Text Color*/
LCD_SetBackColor(Blue);
LCD_SetTextColor(White);
LCD_DisplayStringLine(LCD_LINE_0,(uint8_t *) " TimeStamp Example " );
/* Set the LCD Text size */
LCD_SetFont(&Font16x24);
if (RTC_ReadBackupRegister(RTC_BKP_DR0) != 0x32F2)
{
/* RTC configuration */
RTC_Config();
/* Configure the time&date register */
RTC_TimeRegulate();
/* Display the Date */
RTC_DateShow();
/* Display the Time */
RTC_TimeShow();
}
else
{
/* Check if the Power On Reset flag is set */
if (RCC_GetFlagStatus(RCC_FLAG_PORRST) != RESET)
{
/* Set the Back Color */
LCD_SetBackColor(LCD_COLOR_CYAN);
/* Set the Text Color */
LCD_SetTextColor(LCD_COLOR_BLACK);
LCD_SetFont(&Font12x12);
LCD_DisplayStringLine(LCD_LINE_2,(uint8_t *) " Power On Reset occurred " );
}
/* Check if the Pin Reset flag is set */
else if (RCC_GetFlagStatus(RCC_FLAG_PINRST) != RESET)
{
/* Set the Back Color */
LCD_SetBackColor(LCD_COLOR_CYAN);
/* Set the Text Color */
LCD_SetTextColor(LCD_COLOR_BLACK);
LCD_SetFont(&Font12x12);
LCD_DisplayStringLine(LCD_LINE_2,(uint8_t *) " External Reset occurred " );
}
/* Set the Back Color */
LCD_SetBackColor(LCD_COLOR_CYAN);
/* Set the Text Color */
LCD_SetTextColor(LCD_COLOR_BLACK);
LCD_SetFont(&Font12x12);
LCD_DisplayStringLine(LCD_LINE_3,(uint8_t *) " No need to configure RTC " );
/* Enable the PWR clock */
RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR, ENABLE);
/* Allow access to RTC */
PWR_BackupAccessCmd(ENABLE);
/* Wait for RTC APB registers synchronisation */
RTC_WaitForSynchro();
/* Clear the RTC Alarm Flag */
RTC_ClearFlag(RTC_FLAG_ALRAF);
/* Clear the EXTI Line 17 Pending bit (Connected internally to RTC Alarm) */
EXTI_ClearITPendingBit(EXTI_Line17);
/* Display the RTC Time/Date and TimeStamp Time/Date */
RTC_DateShow();
RTC_TimeShow();
}
while (1)
{
if (Button_State == TAMPER_ON)
{
/* Turn LED4 ON */
STM_EVAL_LEDOn(LED2);
LCD_SetFont(&Font12x12);
LCD_DisplayStringLine(LCD_LINE_5,(uint8_t *) " TimeStamp Event Occurred " );
LCD_SetFont(&Font16x24);
LCD_ClearLine(LCD_LINE_4);
LCD_ClearLine(LCD_LINE_5);
LCD_ClearLine(LCD_LINE_6);
LCD_ClearLine(LCD_LINE_7);
LCD_ClearLine(LCD_LINE_8);
/* Display the TimeStamp */
RTC_TimeStampShow();
Button_State = 0;
}
else if (Button_State == SEL_ON)
{
/* Turn LED1 ON and LED2 OFF */
STM_EVAL_LEDOn(LED1);
STM_EVAL_LEDOff(LED2);
/* Clear The TSF Flag (Clear TimeStamp Registers) */
RTC_ClearFlag(RTC_FLAG_TSF);
LCD_SetFont(&Font12x12);
LCD_ClearLine(LCD_LINE_5);
LCD_SetFont(&Font12x12);
LCD_DisplayStringLine(LCD_LINE_5,(uint8_t *) " TimeStamp Event Cleared " );
Button_State = 0;
}
}
}
/**
* @brief This function handles NMI exception.
* @param None
* @retval None
*/
void NMI_Handler(void)
{
uint32_t tmp = 318, index = 0;
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_FSMC, ENABLE);
/* 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);
STM_EVAL_LEDOn(LED1);
STM_EVAL_LEDOn(LED2);
STM_EVAL_LEDOn(LED3);
STM_EVAL_LEDOn(LED4);
/* 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();
}
}
/*******************************************************************************
* 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 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);
}
}
void
GAME_Update()
{
//Player1
LCD_SetTextColor( LCD_COLOR_BLACK );
LCD_DrawFullRect( player1X, player1Y, player1W, player1H );
LCD_DrawFullRect( player2X, player2Y, player2W, player2H );
if( demoMode == 0 ){
if( player1IsReversed )
player1X -= 5;
else
player1X += 5;
if( player1X <= 0 )
player1X = 0;
else if( player1X + player1W >= LCD_PIXEL_WIDTH )
player1X = LCD_PIXEL_WIDTH - player1W;
//Player2
if( player2IsReversed )
player2X -= 5;
else
player2X += 5;
if( player2X <= 0 )
player2X = 0;
else if( player2X + player2W >= LCD_PIXEL_WIDTH )
player2X = LCD_PIXEL_WIDTH - player2W;
//Ball
if( ballIsRun == 1 ){
LCD_SetTextColor( LCD_COLOR_BLACK );
LCD_DrawFullRect( ballX, ballY, ballSize, ballSize );
//Touch wall
ballX += ballVX;
if( ballX <= 0 ){
ballX = 0;
ballVX *= -1;
}
else if( ballX + ballSize >= LCD_PIXEL_WIDTH ){
ballX = LCD_PIXEL_WIDTH - ballSize;
ballVX *= -1;
}
//PONG!
ballY += ballVY;
if( ballY + ballSize >= player2Y ){
if( ballX + ballSize >= player2X && ballX <= player2X + player2W ){
if( ballX - ballSize <= player2Y + player2W/4 ){
ballVY =-3;
ballVX =-7;
}
else if( ballX >= player2Y + player2W - player2W/4 ){
ballVY =-3;
ballVX = 7;
}
else if( ballX + ballSize < player2Y + player2W/2 ){
ballVY =-7;
ballVX =-3;
}
else if( ballX > player2Y + player2W/2 ){
ballVY =-7;
ballVX = 3;
}
else{
ballVY =-9;
ballVX = 0;
}
}
else
BallReset();
}
if( ballY <= player1Y + player1H ){
if( ballX + ballSize >= player1X && ballX <= player1X + player1W ){
if( ballX - ballSize <= player1Y + player1W/4 ){
ballVY = 3;
ballVX =-7;
}
else if( ballX >= player1Y + player1W - player1W/4 ){
ballVY = 3;
ballVX = 7;
}
else if( ballX + ballSize < player1Y + player1W/2 ){
ballVY = 7;
ballVX =-3;
}
else if( ballX > player1Y + player1W/2 ){
ballVY = 7;
ballVX = 3;
}
else{
ballVY = 9;
ballVX = 0;
}
}
else
BallReset();
}
}
}
else{ //if demoMode == 1
//Player1 move
if( ballVY < 0 ){
if( player1X + player1W/2 < ballX + ballSize/2 ){
player1X += 8;
player2X += 2;
}
else{
player1X -= 8;
player2X -= 2;
}
}
//Player2 move
if( ballVY > 0 ){
if( player2X + player2W/2 < ballX + ballSize/2 ){
player1X += 2;
player2X += 8;
}
else{
player1X -= 2;
player2X -= 8;
}
}
if( player1X <= 0 )
player1X = 0;
else if( player1X + player1W >= LCD_PIXEL_WIDTH )
player1X = LCD_PIXEL_WIDTH - player1W;
if( player2X <= 0 )
player2X = 0;
else if( player2X + player2W >= LCD_PIXEL_WIDTH )
player2X = LCD_PIXEL_WIDTH - player2W;
//Ball
if( ballIsRun == 1 ){
LCD_SetTextColor( LCD_COLOR_BLACK );
LCD_DrawFullRect( ballX, ballY, ballSize, ballSize );
//Touch wall
ballX += ballVX;
if( ballX <= 0 ){
ballX = 0;
ballVX *= -1;
}
else if( ballX + ballSize >= LCD_PIXEL_WIDTH ){
ballX = LCD_PIXEL_WIDTH - ballSize;
ballVX *= -1;
}
//PONG!
ballY += ballVY;
if( ballY + ballSize >= player2Y ){
if( ballX + ballSize >= player2X && ballX <= player2X + player2W ){
if( ballX - ballSize <= player2Y + player2W/4 ){
ballVY =-3;
ballVX =-7;
}
else if( ballX >= player2Y + player2W - player2W/4 ){
ballVY =-3;
ballVX = 7;
}
else if( ballX + ballSize < player2Y + player2W/2 ){
ballVY =-7;
ballVX =-3;
}
else if( ballX > player2Y + player2W/2 ){
ballVY =-7;
ballVX = 3;
}
else{
ballVY =-9;
ballVX = 0;
}
}
else
BallReset();
}
if( ballY <= player1Y + player1H ){
if( ballX + ballSize >= player1X && ballX <= player1X + player1W ){
if( ballX - ballSize <= player1Y + player1W/4 ){
ballVY = 3;
ballVX =-7;
}
else if( ballX >= player1Y + player1W - player1W/4 ){
ballVY = 3;
ballVX = 7;
}
else if( ballX + ballSize < player1Y + player1W/2 ){
ballVY = 7;
ballVX =-3;
}
else if( ballX > player1Y + player1W/2 ){
ballVY = 7;
ballVX = 3;
}
else{
ballVY = 9;
ballVX = 0;
}
}
else
BallReset();
}
}
}
}
/**
* @brief Main program.
* @param None
* @retval None
*/
int main(void)
{
/*!< At this stage the microcontroller clock setting is already configured,
this is done through SystemInit() function which is called from startup
file (startup_stm32f0xx.s) before to branch to application main.
To reconfigure the default setting of SystemInit() function, refer to
system_stm32f0xx.c file
*/
/* Initialize the LCD */
STM32072B_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_TAMPER, BUTTON_MODE_GPIO);
/* CAN configuration */
CAN_Config();
/* Infinite loop */
while(1)
{
while(STM_EVAL_PBGetState(BUTTON_TAMPER) == TAMPER_PRESSED)
{
if(KeyNumber == 41) KeyNumber = 0;
Display_TransmittedMsg(KeyNumber);
KeyNumber++;
Delay();
while(STM_EVAL_PBGetState(BUTTON_TAMPER) != TAMPER_NOT_PRESSED)
{
}
}
if (MsgReceived != 0)
{
/* Display received the 6 messages on tghe LCD */
Display_ReceivedMsg();
MsgReceived = 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_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 LCD & LEDs periodic handling
* @param localtime: the current LocalTime value
* @retval None
*/
void Display_Periodic_Handle(__IO uint32_t localtime)
{
/* 250 ms */
if (localtime - DisplayTimer >= LCD_TIMER_MSECS)
{
DisplayTimer = localtime;
/* We have got a new IP address so update the display */
if (IPaddress != netif.ip_addr.addr)
{
__IO uint8_t iptab[4];
uint8_t iptxt[20];
/* Read the new IP address */
IPaddress = netif.ip_addr.addr;
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]);
/* Display the new IP address */
#if LWIP_DHCP
if (netif.flags & NETIF_FLAG_DHCP)
{
/* Display the IP address */
LCD_DisplayStringLine(Line7, "IP address assigned ");
LCD_DisplayStringLine(Line8, " by a DHCP server ");
LCD_DisplayStringLine(Line9, iptxt);
Delay(LCD_DELAY);
/** Start the client/server application: only when a dynamic IP address has been obtained **/
/* Clear the LCD */
LCD_Clear(Black);
LCD_SetBackColor(Black);
LCD_SetTextColor(White);
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, "is: %d.%d.%d.%d ", iptab[3], iptab[2], iptab[1], iptab[0]);
LCD_DisplayStringLine(Line0, " You are configured ");
LCD_DisplayStringLine(Line2, iptxt);
if(Server)
{
LCD_DisplayStringLine(Line1, "as a server, your IP");
/* Initialize the server application */
server_init();
}
else
{
LCD_DisplayStringLine(Line1, "as a client, your IP");
/* Configure the IO Expander */
IOE_Config();
/* Enable the Touch Screen and Joystick interrupts */
IOE_ITConfig(IOE_ITSRC_TSC);
/* Initialize the client application */
client_init();
}
}
/**
* @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_stm32f2xx.s) before to branch to application main.
To reconfigure the default setting of SystemInit() function, refer to
system_stm32f2xx.c file
*/
/* Initialize LEDs, Key Button, LCD available on
STM322xG-EVAL board ******************************************************/
STM_EVAL_LEDInit(LED1);
STM_EVAL_LEDInit(LED2);
STM_EVAL_LEDInit(LED3);
STM_EVAL_LEDInit(LED4);
/* Initialize the Push buttons */
STM_EVAL_PBInit(BUTTON_KEY, BUTTON_MODE_GPIO); /* Key button for Pause/Resume */
STM_EVAL_PBInit(BUTTON_WAKEUP, BUTTON_MODE_GPIO); /* Key button for Volume High */
STM_EVAL_PBInit(BUTTON_TAMPER, BUTTON_MODE_GPIO); /* Key button for Volume Low */
/* Initialize the LCD */
STM322xG_LCD_Init();
/* Display message on STM322xG-EVAL LCD *************************************/
/* Clear the LCD */
LCD_Clear(LCD_COLOR_BLUE);
/* 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);
/* Turn on leds available on STM322xG-EVAL **********************************/
STM_EVAL_LEDOn(LED1);
STM_EVAL_LEDOn(LED2);
STM_EVAL_LEDOn(LED3);
STM_EVAL_LEDOn(LED4);
/* SysTick end of count event each 10ms */
RCC_GetClocksFreq(&RCC_Clocks);
SysTick_Config(RCC_Clocks.HCLK_Frequency / 100);
/* Initialize the Audio codec and all related peripherals (I2S, I2C, IOExpander, IOs...) */
if (EVAL_AUDIO_Init(OUTPUT_DEVICE_AUTO, volume, I2S_AudioFreq_48k) == 0)
{
LCD_DisplayStringLine(Line3, "====================");
LCD_DisplayStringLine(Line4, "Key : Play/Pause ");
LCD_DisplayStringLine(Line5, "Tamper: Vol+/Headph");
LCD_DisplayStringLine(Line6, "Wakeup: Vol-/Spkr ");
LCD_DisplayStringLine(Line7, "====================");
LCD_DisplayStringLine(Line8, " AUDIO CODEC OK ");
}
else
{
LCD_DisplayStringLine(Line4, " AUDIO CODEC FAIL ");
LCD_DisplayStringLine(Line5, " Try to reset board ");
}
/*
Normal mode description:
Start playing the audio file (using DMA stream) .
Using this mode, the application can run other tasks in parallel since
the DMA is handling the Audio Transfer instead of the CPU.
The only task remaining for the CPU will be the management of the DMA
Transfer Complete interrupt or the Half Transfer Complete interrupt in
order to load again the buffer and to calculate the remaining data.
Circular mode description:
Start playing the file from a circular buffer, once the DMA is enabled it
always run. User has to fill periodically the buffer with the audio data
using Transfer complete and/or half transfer complete interrupts callbacks
(EVAL_AUDIO_TransferComplete_CallBack() or EVAL_AUDIO_HalfTransfer_CallBack()...
In this case the audio data file is smaller than the DMA max buffer
size 65535 so there is no need to load buffer continuously or manage the
transfer complete or Half transfer interrupts callbacks. */
EVAL_AUDIO_Play((uint16_t*)(AUDIO_SAMPLE + AUIDO_START_ADDRESS), (AUDIO_FILE_SZE - AUIDO_START_ADDRESS));
/* Display the state on the screen */
LCD_DisplayStringLine(Line8, " PLAYING ");
/* Infinite loop */
while (1)
{
/* Check on the Pause/Resume button */
if (STM_EVAL_PBGetState(BUTTON_KEY) != Bit_SET)
{
/* wait to avoid rebound */
while (STM_EVAL_PBGetState(BUTTON_KEY) != Bit_SET);
EVAL_AUDIO_PauseResume(cmd);
if (cmd == AUDIO_PAUSE)
{
/* Display the current state of the player */
LCD_DisplayStringLine(Line8, " PAUSED ");
/* Next time Resume command should be processed */
cmd = AUDIO_RESUME;
/* Push buttons will be used to switch between Speaker and Headphone modes */
SpHpSwitch = 1;
}
else
{
/* Display the current state of the player */
LCD_DisplayStringLine(Line8, " PLAYING ");
/* Next time Pause command should be processed */
cmd = AUDIO_PAUSE;
/* Push buttons will be used to control volume level */
SpHpSwitch = 0;
}
}
/* Check on the Volume high button */
if (STM_EVAL_PBGetState(BUTTON_WAKEUP) == Bit_SET)
{
/* Check if the current state is paused (push buttons are used for volume control or for
speaker/headphone mode switching) */
if (SpHpSwitch)
{
/* Set output to Speaker */
Codec_SwitchOutput(OUTPUT_DEVICE_SPEAKER);
/* Display the current state of the player */
LCD_DisplayStringLine(Line9, " SPEAKER ");
}
else
{
/* wait to avoid rebound */
while (STM_EVAL_PBGetState(BUTTON_WAKEUP) == Bit_SET);
/* Decrease volume by 5% */
if (volume > 5)
volume -= 5;
else
volume = 0;
/* Apply the new volume to the codec */
EVAL_AUDIO_VolumeCtl(volume);
LCD_DisplayStringLine(Line9, " VOL: - ");
}
}
/* Check on the Volume high button */
if (STM_EVAL_PBGetState(BUTTON_TAMPER) != Bit_SET)
{
/* Check if the current state is paused (push buttons are used for volume control or for
speaker/headphone mode switching) */
if (SpHpSwitch)
{
/* Set output to Headphone */
Codec_SwitchOutput(OUTPUT_DEVICE_HEADPHONE);
/* Display the current state of the player */
LCD_DisplayStringLine(Line9, " HEADPHONE ");
}
else
{
/* wait to avoid rebound */
while (STM_EVAL_PBGetState(BUTTON_TAMPER) != Bit_SET);
/* Increase volume by 5% */
if (volume < 95)
volume += 5;
else
volume = 100;
/* Apply the new volume to the codec */
EVAL_AUDIO_VolumeCtl(volume);
LCD_DisplayStringLine(Line9, " VOL: + ");
}
}
/* Toggle LD4 */
STM_EVAL_LEDToggle(LED3);
/* Insert 50 ms delay */
Delay(5);
/* Toggle LD2 */
STM_EVAL_LEDToggle(LED2);
/* Insert 50 ms delay */
Delay(5);
}
}
int main(void)
{
LCD_Init();
LCD_LayerInit();
SysTick_init ();
pushbutton_init();
/* Enable the LTDC */
LTDC_Cmd(ENABLE);
/* Set LCD foreground layer */
LCD_SetLayer(LCD_FOREGROUND_LAYER);
LCD_SetTransparency(0);
/* Set LCD background layer */
LCD_SetLayer(LCD_BACKGROUND_LAYER);
/* LCD display message */
LCD_Clear(LCD_COLOR_BLUE);
LCD_SetBackColor(LCD_COLOR_BLUE);
LCD_SetTextColor(LCD_COLOR_WHITE);
std::stringstream output;
std::string outputstring;
const char * chararray;
Timer mytimerobject(12,34,56);
LCD_DisplayStringLine(LCD_LINE_0,(uint8_t*)"h_da ");
LCD_DisplayStringLine(LCD_LINE_1,(uint8_t*)"RZS ");
LCD_DisplayStringLine(LCD_LINE_2,(uint8_t*)"WS 15/16 ");
STM_EVAL_LEDInit(LED3);
STM_EVAL_LEDInit(LED4);
// Super loop
while(1)
{
switch(get_event()){
case TICK:
if(mystate==RUNNING)
systick_count++;
output.str(std::string());
mytimerobject.setMin(systick_count/100/60);
mytimerobject.setSec(systick_count/100);
mytimerobject.setHun(systick_count/1);
output << "Time " << mytimerobject.printtime();
outputstring = "";
outputstring = output.str();
chararray = "";
chararray = outputstring.c_str();
LCD_DisplayStringLine(LCD_LINE_3,(uint8_t*) chararray);
LCD_ClearLine(LCD_LINE_4);
break;
case START_STOP:
LCD_DisplayStringLine(LCD_LINE_4,(uint8_t*) "START_STOP");
if(mystate == RUNNING)
{
mystate = HALTED;
LCD_ClearLine(LCD_LINE_5);
LCD_DisplayStringLine(LCD_LINE_5,(uint8_t*) "HALTED");
}
else if(mystate == HALTED)
{
mystate = RUNNING;
LCD_DisplayStringLine(LCD_LINE_5,(uint8_t*) "RUNNING");
}
break;
default:
break;
}
}
}
/**
* @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_stm32xxx_xx.s) before to branch to application main.
To reconfigure the default setting of SystemInit() function, refer to
system_stm32xxx.c file
*/
/* 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);
/* Initialize TIM6 */
TIM6_Config();
/* Initialize the LCD */
#ifdef USE_STM322xG_EVAL
STM322xG_LCD_Init();
#elif defined USE_STM324xG_EVAL
STM324xG_LCD_Init();
#elif defined USE_STM3210C_EVAL
STM3210C_LCD_Init();
#elif defined USE_STM32100E_EVAL
STM32100E_LCD_Init();
#elif defined USE_STM32L152_EVAL
STM32L152_LCD_Init();
#elif defined USE_STM32L152D_EVAL
STM32L152D_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(Yellow);
LCD_DisplayStringLine(Line0, MESSAGE1);
LCD_DisplayStringLine(Line1, MESSAGE2);
LCD_DisplayStringLine(Line5, MESSAGE3);
/* Configure the Push buttons in interrupt mode *****************************/
#if defined (USE_STM32100E_EVAL) || defined(USE_STM3210C_EVAL) || defined(USE_STM322xG_EVAL ) || defined (USE_STM324xG_EVAL)
STM_EVAL_PBInit(BUTTON_KEY, Mode_EXTI);
STM_EVAL_PBInit(BUTTON_TAMPER, Mode_EXTI);
#elif defined (USE_STM32L152_EVAL) || defined (USE_STM32L152D_EVAL)
STM_EVAL_PBInit(BUTTON_LEFT, Mode_EXTI);
STM_EVAL_PBInit(BUTTON_RIGHT, Mode_EXTI);
#endif /* USE_STM32100E_EVAL || USE_STM3210C_EVAL || USE_STM322xG_EVAL || USE_STM324xG_EVAL */
/* Start CPAL communication configuration ***********************************/
/* Initialize local Reception structures */
sRxStructure.wNumData = BufferSize; /* Maximum Number of data to be received */
sRxStructure.pbBuffer = tRxBuffer; /* Common Rx buffer for all received data */
sRxStructure.wAddr1 = OWN_ADDRESS; /* The own board address */
sRxStructure.wAddr2 = 0; /* Not needed */
/* Initialize local Transmission structures */
sTxStructure.wNumData = BufferSize; /* Maximum Number of data to be received */
sTxStructure.pbBuffer = (uint8_t*)tStateSignal; /* Common Rx buffer for all received data */
sTxStructure.wAddr1 = OWN_ADDRESS; /* The own board address */
sTxStructure.wAddr2 = 0; /* Not needed */
/* Configure the device structure */
CPAL_I2C_StructInit(&I2C_DevStructure); /* Set all fields to default values */
I2C_DevStructure.CPAL_Mode = CPAL_MODE_SLAVE;
#ifdef CPAL_I2C_DMA_PROGMODEL
I2C_DevStructure.wCPAL_Options = CPAL_OPT_NO_MEM_ADDR | CPAL_OPT_I2C_NACK_ADD;
I2C_DevStructure.CPAL_ProgModel = CPAL_PROGMODEL_DMA;
#elif defined (CPAL_I2C_IT_PROGMODEL)
I2C_DevStructure.wCPAL_Options = CPAL_OPT_NO_MEM_ADDR | CPAL_OPT_I2C_NACK_ADD;
I2C_DevStructure.CPAL_ProgModel = CPAL_PROGMODEL_INTERRUPT;
#else
#error "Please select one of the programming model (in main.h)"
#endif
I2C_DevStructure.pCPAL_I2C_Struct->I2C_ClockSpeed = I2C_SPEED;
I2C_DevStructure.pCPAL_I2C_Struct->I2C_OwnAddress1 = OWN_ADDRESS;
I2C_DevStructure.pCPAL_TransferRx = &sRxStructure;
I2C_DevStructure.pCPAL_TransferTx = &sTxStructure;
/* Initialize CPAL device with the selected parameters */
CPAL_I2C_Init(&I2C_DevStructure);
/* Infinite loop */
while (1)
{
/* Write operations ------------------------------------------------------*/
/* Check if any action has been triggered by push buttons */
if ((ActionState != ACTION_PENDING) && (ActionState != ACTION_NONE))
{
/* Check if the current CPAL device state allows write operation */
if (((DeviceMode == SLAVE) && (LastMode == SLAVE))||\
(((I2C_DevStructure.CPAL_State == CPAL_STATE_READY) ||\
(I2C_DevStructure.CPAL_State == CPAL_STATE_DISABLED)) && (DeviceMode == MASTER)))
{
if (LastMode == SLAVE)
{
/* Set the LCD Back Color */
LCD_SetBackColor(Red);
/* Set the LCD Text Color */
LCD_SetTextColor(White);
LCD_DisplayStringLine(Line3, (uint8_t*)" MASTER MODE ACTIVE ");
/* Set the LCD Back Color */
LCD_SetBackColor(White);
/* Set the LCD Text Color */
LCD_SetTextColor(Blue);
/* Disable CPAL_OPT_I2C_NACK_ADD option when switch to Master mode */
I2C_DevStructure.wCPAL_Options &= (~CPAL_OPT_I2C_NACK_ADD);
}
LastMode = MASTER;
/* Initialize local Reception structures */
sRxStructure.wNumData = BufferSize;
/* Initialize local Transmission structures */
sTxStructure.wNumData = BufferSize;
switch (ActionState)
{
case BUTTON_KEY:
TransmitMode = STATE_ON;
sTxStructure.pbBuffer = (uint8_t*)tSignal;
Divider = 2;
break;
case BUTTON_TAMPER:
TransmitMode = STATE_OFF;
sRxStructure.pbBuffer = tRxBuffer;
Divider = 4;
break;
case ACTION_PERIODIC:
if(TransmitMode == STATE_ON)
{
sTxStructure.pbBuffer = (uint8_t*)tStateSignal;
}
break;
default:
break;
}
/* Configure the device mode to master */
I2C_DevStructure.CPAL_Mode = CPAL_MODE_MASTER;
/* Force the CPAL state to ready (in case a read operation has been initiated) */
I2C_DevStructure.CPAL_State = CPAL_STATE_READY;
/* Prevent other actions to be performed while the current is not finished */
ActionState = ACTION_PENDING;
DeviceMode = MASTER;
/* Configure a Timer to generate periodic interrupt: used to send state signal */
TIM7_Config(PeriodicValue/Divider);
if(TransmitMode == STATE_ON)
{
/* Start writing data in master mode */
if (CPAL_I2C_Write(&I2C_DevStructure) == CPAL_PASS)
{
}
}
else
{
/* Start reading data in master mode */
if (CPAL_I2C_Read(&I2C_DevStructure) == CPAL_PASS)
{
}
}
}
}
/* Read Operations -------------------------------------------------------*/
if (((I2C_DevStructure.CPAL_State == CPAL_STATE_READY) || \
(I2C_DevStructure.CPAL_State == CPAL_STATE_DISABLED)) && \
(DeviceMode == SLAVE))
{
/* Reconfigure device for slave receiver mode */
I2C_DevStructure.CPAL_Mode = CPAL_MODE_SLAVE;
I2C_DevStructure.CPAL_State = CPAL_STATE_READY;
if (LastMode == SLAVE)
{
/* Set the LCD Back Color */
LCD_SetBackColor(Red);
/* Set the LCD Text Color */
LCD_SetTextColor(White);
LCD_DisplayStringLine(Line3, (uint8_t*)" SLAVE MODE ACTIVE ");
/* Set the LCD Back Color */
LCD_SetBackColor(White);
/* Set the LCD Text Color */
LCD_SetTextColor(Blue);
}
/* Start waiting for data to be received in slave mode */
if (CPAL_I2C_Listen(&I2C_DevStructure) == CPAL_PASS)
{
LCD_DisplayStringLine(Line9, MEASSAGE_EMPTY);
}
}
}
}
/**
* @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
files (startup_stm32f40_41xxx.s/startup_stm32f427_437xx.s)
before to branch to application main.
*/
/* Configure the external interrupt "WAKEUP" and "TAMPER" buttons */
STM_EVAL_PBInit(BUTTON_TAMPER , BUTTON_MODE_EXTI);
STM_EVAL_PBInit(BUTTON_WAKEUP , BUTTON_MODE_EXTI);
/* Initialize LEDs mounted on EVAL board */
STM_EVAL_LEDInit(LED1);
STM_EVAL_LEDInit(LED2);
/* Initialize the LCD */
LCD_Init();
LCD_Clear(LCD_COLOR_WHITE);
/* Set the Back Color */
LCD_SetBackColor(LCD_COLOR_BLUE);
/* Set the Text Color */
LCD_SetTextColor(LCD_COLOR_WHITE);
LCD_DisplayStringLine(LCD_LINE_0,(uint8_t *) " TimeStamp Example " );
LCD_SetFont(&Font12x12);
if (RTC_ReadBackupRegister(RTC_BKP_DR0) != 0x32F2)
{
/* RTC configuration */
RTC_Config();
/* Configure the time&date register */
RTC_TimeRegulate();
/* Display the Date and Time */
RTC_DateShow();
RTC_TimeShow();
}
else
{
/* Check if the Power On Reset flag is set */
if (RCC_GetFlagStatus(RCC_FLAG_PORRST) != RESET)
{
/* Set the Back Color */
LCD_SetBackColor(LCD_COLOR_WHITE);
/* Set the Text Color */
LCD_SetTextColor(LCD_COLOR_GREEN);
LCD_DisplayStringLine(LCD_LINE_2,(uint8_t *) "Power On Reset occurred " );
}
/* Check if the Pin Reset flag is set */
else if (RCC_GetFlagStatus(RCC_FLAG_PINRST) != RESET)
{
/* Set the Back Color */
LCD_SetBackColor(LCD_COLOR_WHITE);
/* Set the Text Color */
LCD_SetTextColor(LCD_COLOR_GREEN);
LCD_DisplayStringLine(LCD_LINE_2,(uint8_t *) "External Reset occurred " );
}
/* Set the Back Color */
LCD_SetBackColor(LCD_COLOR_WHITE);
/* Set the Text Color */
LCD_SetTextColor(LCD_COLOR_GREEN);
LCD_DisplayStringLine(LCD_LINE_3,(uint8_t *) "No need to configure RTC " );
/* Enable the PWR clock */
RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR, ENABLE);
/* Allow access to RTC */
PWR_BackupAccessCmd(ENABLE);
/* Wait for RTC APB registers synchronisation */
RTC_WaitForSynchro();
/* Clear the RTC Alarm Flag */
RTC_ClearFlag(RTC_FLAG_ALRAF);
/* Clear the EXTI Line 17 Pending bit (Connected internally to RTC Alarm) */
EXTI_ClearITPendingBit(EXTI_Line17);
/* Display the RTC Time/Date and TimeStamp Time/Date */
RTC_DateShow();
RTC_TimeShow();
}
while (1)
{
}
}
/**
* @brief Configure the RTC peripheral by selecting the clock source.
* @param None
* @retval None
*/
static void RTC_Config(void)
{
/* Enable the PWR clock */
RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR, ENABLE);
/* Allow access to RTC */
PWR_BackupAccessCmd(ENABLE);
#if defined (RTC_CLOCK_SOURCE_LSI) /* LSI used as RTC source clock*/
/* The RTC Clock may varies due to LSI frequency dispersion. */
/* Enable the LSI OSC */
RCC_LSICmd(ENABLE);
/* Wait till LSI is ready */
while(RCC_GetFlagStatus(RCC_FLAG_LSIRDY) == RESET)
{
}
/* Select the RTC Clock Source */
RCC_RTCCLKConfig(RCC_RTCCLKSource_LSI);
/* ck_spre(1Hz) = RTCCLK(LSI) /(uwAsynchPrediv + 1)*(uwSynchPrediv + 1)*/
uwSynchPrediv = 0xFF;
uwAsynchPrediv = 0x7F;
#elif defined (RTC_CLOCK_SOURCE_LSE) /* LSE used as RTC source clock */
/* Enable the LSE OSC */
RCC_LSEConfig(RCC_LSE_ON);
/* Wait till LSE is ready */
while(RCC_GetFlagStatus(RCC_FLAG_LSERDY) == RESET)
{
}
/* Select the RTC Clock Source */
RCC_RTCCLKConfig(RCC_RTCCLKSource_LSE);
/* ck_spre(1Hz) = RTCCLK(LSE) /(uwAsynchPrediv + 1)*(uwSynchPrediv + 1)*/
uwSynchPrediv = 0xFF;
uwAsynchPrediv = 0x7F;
#else
#error Please select the RTC Clock source inside the main.c file
#endif /* RTC_CLOCK_SOURCE_LSI */
/* Configure the RTC data register and RTC prescaler */
RTC_InitStructure.RTC_AsynchPrediv = uwAsynchPrediv;
RTC_InitStructure.RTC_SynchPrediv = uwSynchPrediv;
RTC_InitStructure.RTC_HourFormat = RTC_HourFormat_24;
/* Check on RTC init */
if (RTC_Init(&RTC_InitStructure) == ERROR)
{
/* Set the Back Color */
LCD_SetBackColor(LCD_COLOR_WHITE);
/* Set the Text Color */
LCD_SetTextColor(LCD_COLOR_RED);
LCD_DisplayStringLine(LCD_LINE_3,(uint8_t *) "RTC Prescaler Config failed " );
}
/* Enable the RTC Clock */
RCC_RTCCLKCmd(ENABLE);
/* Wait for RTC APB registers synchronisation */
RTC_WaitForSynchro();
/* Enable The TimeStamp */
RTC_TimeStampCmd(RTC_TimeStampEdge_Falling, ENABLE);
}
/**
* @brief This function handles External line 5 to 9 interrupt request.
* @param None
* @retval None
*/
void EXTI9_5_IRQHandler(void)
{
uint8_t index = 0;
uint32_t tmp = 0, tmp1 = 0;
if((EXTI_GetITStatus(RIGHT_BUTTON_EXTI_LINE) != RESET) )
{
/* Set the LCD Back Color */
LCD_SetBackColor(White);
StartEvent = 0;
/* Reset Counter*/
RTCAlarmCount = 0;
/* Disable the alarm */
RTC_AlarmCmd(RTC_Alarm_A, DISABLE);
/* Display Char on the LCD : XXX% */
LCD_DisplayChar(40,110,0x30);
LCD_DisplayChar(40,88, 0x30);
LCD_DisplayChar(40,66, 0x30);
LCD_DisplayChar(40,44, 0x25);
for (index = 0; index < 100 ; index++)
{
if ((index % 2) ==0)
{
/* Set the LCD Text Color */
LCD_SetTextColor(Blue);
LCD_DrawLine(70 + (index/2) , 120 - (index/2) , 101 - (index + 1) ,Horizontal);
/* Set the LCD Text Color */
LCD_SetTextColor(White);
LCD_DrawLine(170 - (index/2) , 120 - (index/2) , 101 - (index + 1) ,Horizontal);
}
}
/* Displays MESSAGE6 on line 5 */
LCD_SetFont(&Font12x12);
/* Set the LCD Back Color */
LCD_SetBackColor(Blue);
LCD_SetTextColor(White);
LCD_DisplayStringLine(LINE(19), (uint8_t *)MESSAGE6);
LCD_SetFont(&Font16x24);
/* Set the LCD Text Color */
LCD_SetTextColor(Black);
/* Clear the RIGHT EXTI pending bit */
EXTI_ClearITPendingBit(RIGHT_BUTTON_EXTI_LINE);
}
if(EXTI_GetITStatus(DOWN_BUTTON_EXTI_LINE) != RESET)
{
if(RTCAlarmCount == 0)
{
SecondNumb--;
if(SecondNumb < 15) SecondNumb = 15;
tmp = (uint32_t) (SecondNumb/60);
tmp1 = SecondNumb -(tmp*60);
LCD_SetFont(&Font16x24);
/* Set the LCD text color */
LCD_SetTextColor(Blue);
/* Set the LCD Back Color */
LCD_SetBackColor(White);
LCD_DisplayStringLine(95, (uint8_t*) " ");
/* Display Char on the LCD : XXX% */
LCD_DisplayChar(95,294, (tmp / 10) +0x30);
LCD_DisplayChar(95,278, (tmp % 10 ) +0x30);
LCD_DisplayChar(95,262, ':');
LCD_DisplayChar(95,246, (tmp1 / 10) +0x30);
LCD_DisplayChar(95,230, (tmp1 % 10 ) +0x30);
}
/* Clear the RIGHT EXTI pending bit */
EXTI_ClearITPendingBit(DOWN_BUTTON_EXTI_LINE);
}
if (EXTI_GetITStatus(UP_BUTTON_EXTI_LINE) != RESET)
{
if(RTCAlarmCount == 0)
{
SecondNumb++;
tmp = (uint32_t) (SecondNumb/60);
tmp1 = SecondNumb -(tmp*60);
LCD_SetFont(&Font16x24);
/* Set the LCD text color */
LCD_SetTextColor(Blue);
/* Set the LCD Back Color */
LCD_SetBackColor(White);
LCD_DisplayStringLine(95, (uint8_t*) " ");
/* Display Char on the LCD : XXX% */
LCD_DisplayChar(95,294, (tmp / 10) +0x30);
LCD_DisplayChar(95,278, (tmp % 10 ) +0x30);
LCD_DisplayChar(95,262, ':');
LCD_DisplayChar(95,246, (tmp1 / 10) +0x30);
LCD_DisplayChar(95,230, (tmp1 % 10 ) +0x30);
}
/* Clear the EXTI Line 11 */
EXTI_ClearITPendingBit(UP_BUTTON_EXTI_LINE);
}
}
/**
* @brief Processes traffic received on UDP port 69
* @param args: pointer on tftp_connection arguments
* @param upcb: pointer on udp_pcb structure
* @param pbuf: pointer on packet buffer
* @param addr: pointer on the receive IP address
* @param port: receive port number
* @retval none
*/
static void IAP_tftp_recv_callback(void *arg, struct udp_pcb *upcb, struct pbuf *pkt_buf,
struct ip_addr *addr, u16_t port)
{
tftp_opcode op;
struct udp_pcb *upcb_tftp_data;
err_t err;
uint32_t i;
char filename[20],message[20], *ptr;
/* create new UDP PCB structure */
upcb_tftp_data = udp_new();
if (!upcb_tftp_data)
{
/* Error creating PCB. Out of Memory */
return;
}
/* bind to port 0 to receive next available free port */
/* NOTE: This is how TFTP works. There is a UDP PCB for the standard port
* 69 which al transactions begin communication on, however, _all_ subsequent
* transactions for a given "stream" occur on another port */
err = udp_bind(upcb_tftp_data, IP_ADDR_ANY, 0);
if (err != ERR_OK)
{
/* Unable to bind to port */
return;
}
op = IAP_tftp_decode_op(pkt_buf->payload);
if (op != TFTP_WRQ)
{
/* remove PCB */
udp_remove(upcb_tftp_data);
}
else
{
#ifdef USE_LCD
ptr = pkt_buf->payload;
ptr = ptr +2;
/*extract file name info */
i= 0;
while (*(ptr+i)!=0x0)
{
i++;
}
strncpy(filename, ptr, i+1);
/* Set the LCD Text Color */
LCD_SetTextColor(White);
LCD_Clear(Black);
LCD_DisplayStringLine(Line0, (char*)" IAP using TFTP ");
sprintf(message, "File: %s",filename);
LCD_DisplayStringLine(Line3, (uint8_t*)message);
/* Set the LCD Text Color */
LCD_SetTextColor(Red);
LCD_DisplayStringLine(Line9, (char *)"State: Erasing...");
#endif
/* Start the TFTP write mode*/
IAP_tftp_process_write(upcb_tftp_data, addr, port);
}
pbuf_free(pkt_buf);
}
/**
* @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
*/
/* SysTick end of count event each 10ms */
RCC_GetClocksFreq(&RCC_Clocks);
SysTick_Config(RCC_Clocks.HCLK_Frequency / 100);
LIS302DL_Reset();
/* SET USER Key */
/* Configure EXTI Line0 (connected to PA0 pin) in interrupt mode */
EXTILine0_Config();
/* Initialize the LCD */
STM32f4_Discovery_LCD_Init();
LCD_Clear(LCD_COLOR_WHITE);
LCD_SetTextColor(LCD_COLOR_BLUE);
DCMI_Control_IO_Init();
LCD_DisplayStringLine(LINE(2), " Camera Init..");
/* OV9655 Camera Module configuration */
if (DCMI_OV9655Config() == 0x00)
{
LCD_DisplayStringLine(LINE(2), " ");
LCD_SetDisplayWindow(0, 0, 320, 240);
LCD_WriteRAM_Prepare();
/* Start Image capture and Display on the LCD *****************************/
/* Enable DMA transfer */
DMA_Cmd(DMA2_Stream1, ENABLE);
/* Enable DCMI interface */
DCMI_Cmd(ENABLE);
/* Start Image capture */
DCMI_CaptureCmd(ENABLE);
/*init the picture count*/
init_picture_count();
KeyPressFlg = 0;
while (1)
{
/* Insert 100ms delay */
Delay(100);
if (KeyPressFlg) {
KeyPressFlg = 0;
/* press user KEY take a photo */
if (capture_Flag == ENABLE) {
DCMI_CaptureCmd(DISABLE);
capture_Flag = DISABLE;
Capture_Image_TO_Bmp();
LCD_SetDisplayWindow(0, 0, 320, 240);
LCD_WriteRAM_Prepare();
DCMI_CaptureCmd(ENABLE);
capture_Flag = ENABLE;
}
}
}
} else {
LCD_SetTextColor(LCD_COLOR_RED);
LCD_DisplayStringLine(LINE(2), "Camera Init.. fails");
LCD_DisplayStringLine(LINE(4), "Check the Camera HW ");
LCD_DisplayStringLine(LINE(5), " and try again ");
/* Go to infinite loop */
while (1);
}
}
//////////////////////////////////////////////////////////////////////////***START OF PROGRAM***//////////////////////////////////////////////////////////////////////////////////////////////
int main(void){
//Initialization
PLL_Init(); // Set the clocking to run at 80MHz from the PLL.
LCD_Init(); // Initialize LCD
LCD_Goto(10,0);
LCD_SetTextColor(255,255,0); // yellow= red+green, no blue
printf("Lab 10");
LCD_DrawLine(10,16,310,16,BURNTORANGE);
ADC_Initialize();
Timer2_Init(7256);
Timer2A_Stop();
SysTick_Init();
///////////////////////////////////////////////////////////////////////////Set Up Waves///////////////////////////////////////////////////////////////////////////////////////////////
while(1){
//set up for the wave 1 (11 means wave needs to be setup, 10 means wave is set up)
if (wave==11) {
wavesize=5;
enemycount=0;
LCD_SetCursor(140,120);
LCD_SetTextColor(255,0,0);
LCD_PrintString("WAVE ONE");
LCD_SetTextColor(0,0,0);
LCD_PrintString("WAVE ONE");
enemy[0].x=50;
enemy[1].x=90;
enemy[2].x=130;
enemy[3].x=170;
enemy[4].x=210;
for (k=0;k<5;k++) {
enemy[k].y=40;
enemy[k].s=1;
enemy[k].e=0;
enemy[k].c=0;
enemy[k].b=0;
wave=10;
}
}
//set up for wave 2 (22 means wave needs to be setup, 20 means wave is set up)
//e: so we don't print eraser more than once
//s: so we know the state of the sprite
//c; so we don't count the death of a sprite more than once
if (wave==21) {
wavesize=15;
enemycount=0;
LCD_SetCursor(140,120);
LCD_SetTextColor(255,0,0);
LCD_PrintString("WAVE TWO");
LCD_SetTextColor(0,0,0);
LCD_PrintString("WAVE TWO");
enemy[0].x=50;
enemy[1].x=90;
enemy[2].x=130;
enemy[3].x=170;
enemy[4].x=210;
for (k=0;k<5;k++) {
enemy[k].y=40;
enemy[k].s=1;
enemy[k].e=0;
enemy[k].c=0;
enemy[k].b=0;
}
for (k=5;k<10;k++) {
enemy[k].s=4; //set newer coming enemies to 4, so they don't get counted as dead when they don't arrive yet (count happens after printing)
enemy[k].e=0;
enemy[k].y=40;
enemy[k].x=50;
enemy[k].c=0;
enemy[k].b=0;
}
for (k=10;k<15;k++) {
enemy[k].s=4;
enemy[k].s=4; //set newer coming enemies to 4, so they don't get counted as dead when they don't arrive yet (count happens after printing)
enemy[k].e=0;
enemy[k].y=64;
enemy[k].x=296;
enemy[k].c=0;
enemy[k].b=0;
}
wave=20;
}
//set up for wave 3
//set up for wave 3
if(wave==31) {
wavesize=1;
enemycount=0;
LCD_SetCursor(140,30);
LCD_SetTextColor(255,0,0);
LCD_PrintString("Time For Ziping");
for(k=0;k<10;k++) {enemy[k].x=0;enemy[k].y=0;enemy[k].s=0;;enemy[k].e=0;}
enemy[0].s=1;
enemy[0].x=100;
enemy[0].y=40;
enemy[0].b=0;
enemy[0].e=0;
wave=30;
}
////////////////////////////////////////////////////////////////////////////Update and Print User Ship/////////////////////////////////////////////////////////////////////////////////////////
if(Semaphore){ //wait for SysTick
Semaphore = 0; //"acknowledge" SysTick
ADCData = ADC_In();
Position=(ADCData*.4053751277)+157.0113976; //position 0-2000
xShip = ((Position)*.14)+20; //x pixel coordinate of center of ship (.14 = 280/2000)
LCD_DrawBMP(UshipErase,xShipTrail,200); //erase previous image
LCD_DrawBMP(userShip,xShip,200);
xShipTrail = xShip;
////////////////////////////////////////////////////////////////////////////////////Update Enemies/////////////////////////////////////////////////////////////////////////////////////////////
//enemy ship update coordinates for wave 1 (s=1 means alive, s=0 means just dead, s=2 means the moment of death)
if (wave==10) {
for (k=0;k<5;k++){
if (enemy[k].s == 1) {
enemy[k].y = enemy[k].y +1;
trainWreckL = xShip-enemy[k].x; //enemy within left boundary of ship
trainWreckR = enemy[k].x - xShip; //enemy within right boundary of ship
if( (enemy[k].y >= 176) &&
(((trainWreckL <24)&&(trainWreckL >0) )||((trainWreckR < 30)&&(trainWreckR > 0))) ){
enemy[k].s = 2;
DEATH();
userDeath++;
}
if (enemy[k].y>=210) {enemy[k].s=0;}
} }
}
//enemy ship update coordinates for wave 2
//enemy ship update coordinates for wave 2
else if (wave==20) {
for (k=0;k<5;k++) { if(enemy[k].s==1) { //updates only if object is alive (s==1)
if (countx<=92 && wave2==0) {
enemy[k].x = enemy[k].x +1;
}
countx++;
if (countx >92 && wave2==0) {wave2=1; countx=0;}
if (wave2==1) {
for (j=0;j<5;j++) {
enemy[j].y=enemy[j].y+1;
}
wave2=2;
countx=0;
county++;
}
if (countx <=92 && wave2==2) {
enemy[k].x= enemy[k].x-1;
}
countx++;
if (countx >= 92 && wave2==2 ) {wave2=3; countx=0;}
if (wave2==3) {
for (j=0;j<5;j++) {
enemy[j].y=enemy[j].y+1;
}
wave2=0; county++;
}
trainWreckL = xShip-enemy[j].x; //enemy within left boundary of ship
trainWreckR = enemy[j].x - xShip; //enemy within right boundary of ship
if( (enemy[j].y >= 176) &&
(((trainWreckL <24)&&(trainWreckL >0) )||((trainWreckR < 30)&&(trainWreckR > 0))) ){
enemy[j].s = 2;
DEATH();
userDeath++;
}
if (enemy[k].y>=210) {enemy[k].s=0;}
}
}
//fleet 2
if (county==24 || enemycount==10) {enemy[5].s=1; wave3=1;} //activate the bigger ships once there is room vertically, e.i. check if y coordinate has been met
if (countx2==24) {enemy[6].s=1;}
if (countx2==48 ) {enemy[7].s=1;}
if (countx2==72) {enemy[8].s=1;}
if (countx2==96) {enemy[9].s=1;}
//if (enemy[5].x>=196) {wave2big=1;} //once the enemies get to the edge of the screen, set a flag (wave big) to one
if (countx2>=146) {wave2big=1;}
for (k=5;k<10;k++) {
if(wave3==1 && k==5) {countx2++;}
if(enemy[k].s==1 && wave2big==0) { //update coordinates for new ships for wave 2 only if they become active (due to above code) and if max x coordinate hasn't been set
enemy[k].x=enemy[k].x+1; }
if(enemy[k].y>=210) {enemy[k].s=0;} //enemy dead if off the screen vertically, we don't care if horizontally
if(enemy[k].s==1 && wave2big==1) {
if(k==5 || k==6) {enemy[k].x=enemy[k].x-1; enemy[k].y=enemy[k].y+1;}
if(k==8 || k==9) {enemy[k].x=enemy[k].x+1; enemy[k].y=enemy[k].y+1;}
if(k==7 && enemy[k].y<=100) {enemy[k].y=enemy[k].y+1;}
}
}
//fleet 3
if (county==48 || enemycount==10) {enemy[10].s=1; wave4=1;} //activate the bigger ships once there is room vertically, e.i. check if y coordinate has been met
if (countx3==24) {enemy[11].s=1;}
if (countx3==48 ) {enemy[12].s=1;}
if (countx3==72) {enemy[13].s=1;}
if (countx3==96) {enemy[14].s=1;}
if (countx3>=146) {wave3big=1;}
for (k=10;k<15;k++) {
if(wave4==1 && k==10) {countx3++;}
if(enemy[k].s==1 && wave3big==0) { //update coordinates for new ships for wave 2 only if they become active (due to above code) and if max x coordinate hasn't been set
enemy[k].x=enemy[k].x-1; }
if(enemy[k].y>=210) {enemy[k].s=0;} //enemy dead if off the screen vertically, we don't care if horizontally
if(enemy[k].s==1 && wave3big==1) {
if(k==10) {if(enemy[k].y<120 && enemy[k].x==50) {enemy[k].y=enemy[k].y+1;}
if(enemy[k].y==120 && enemy[k].x<130) {enemy[k].x=enemy[k].x+1;}
if(enemy[k].y>64 && enemy[k].x==130) {enemy[k].y=enemy[k].y-1;}
if(enemy[k].y==64 && enemy[k].x>50) {enemy[k].x=enemy[k].x-1;}}
if(k==14) {if(enemy[k].y<120 && enemy[k].x==246) {enemy[k].y=enemy[k].y+1;}
if(enemy[k].y==120 && enemy[k].x>166) {enemy[k].x=enemy[k].x-1;}
if(enemy[k].y>64 && enemy[k].x==166) {enemy[k].y=enemy[k].y-1;}
if(enemy[k].y==64 && enemy[k].x<246) {enemy[k].x=enemy[k].x+1;}}
if(k==11 || k==13 || k==12) {enemy[k].y=enemy[k].y+1;}
}
}
}
///////////////////////////////////////////////////////////////////////Update User missiles////////////////////////////////////////////////////////////////////////////////////////////////
for(i=0;i<100;i++){
if(missile[i].s){
missile[i].y = missile[i].y - 2; //if missile is active, move up the screen
if(missile[i].y < 18 ){
missile[i].s = 0; //if the missile has moved off the screen, deactivate it
LCD_DrawBMP(UmissileErase,missile[i].x,missile[i].y); //cover up with black
}
//////////////////////////////////////////////////////////////////Test for Enemy-Missile Collisions (small aliens)///////////////////////////////////////////////////////////////////////////////////////
for(k=0;k<wavesize;k++){ //(missile:11x15, enemy: 24x24)
crashTestY = ((enemy[k].y + 24) - missile[i].y); //difference in y-coordinates
crashTestXR = (missile[i].x - enemy[k].x); //distance of missile from right border of alien
crashTestXL = (enemy[k].x - missile[i].x); //distance of missile from left border of alien
if ( ( (crashTestY <5) && (crashTestY > 0) ) &&
( ( (crashTestXR < 24) && (crashTestXR > 0 ) ) || ( (crashTestXL < 11)&&(crashTestXL > 0) ) ) ){
enemy[k].s = 2;
}
}
}
}
/////////////////////////////////////////////////////////////////////Test for Enemy-User Collisions///////////////////////////////////////////////////////////////////////////////////////////////////
/* for(k=0;k<5;k++){
trainWreckL = xShip-enemy[k].x; //enemy within left boundary of ship
trainWreckR = enemy[k].x - xShip; //enemy within right boundary of ship
if( (enemy[k].y >= 176) &&
(((trainWreckL <24)&&(trainWreckL >0) )||((trainWreckR < 30)&&(trainWreckR > 0))) ){
enemy[k].s = 2;
DEATH();
userDeath++;
} */
//////////////////////////////////////////////////////////////////////////Activate New Missile/////////////////////////////////////////////////////////////////////////////////////////////
if(newMissile==3){
while(missile[notActiveSlot].s == 1){ //find a non-active missile in the array
if(notActiveSlot == 99){notActiveSlot = 0;} //wrap around if at end of array
notActiveSlot++; //check next slot
}
missile[notActiveSlot].x = xShip + 10; //missile(11x15) aligned to center of ship
missile[notActiveSlot].y = 185; //missile firing out 200 - 15
missile[notActiveSlot].s = 1; //activate
Timer2A_Start(); //arm sound
newMissile=0; //reset button count
tester++;
}
///////////////////////////////////////////////////////Update Enemy Missiles/////////////////////////////////////////////////////////////////////////////////////////////////////////
for(i=0;i<100;i++){
if(emissile[i].s==1){
emissile[i].y = emissile[i].y + 2;
if(emissile[i].y > 210){
emissile[i].s = 0;
LCD_DrawBMP(UmissileErase,emissile[i].x,emissile[i].y);
}
}
}
///////////////////////////////////////////////////////////////////////Test for User Missile Collisions////////////////////////////////////////////////////////////////////////////////////
for(i=0;i<100;i++){
if((emissile[i].s ==1)&&(emissile[i].y >= 185)&&
((((emissile[i].x - xShip)<30)&&((emissile[i].x - xShip)>0))||
(((xShip- emissile[i].x)<11)&&((xShip-emissile[i].x)>0)))){
emissile[i].s = 0;
DEATH();
userDeath++;
}
}
////////////////////////////////////////////////////////////////////////New Enemy Missiles////////////////////////////////////////////////////////////////////////////////////////////////////
//activate new enemy missiles
for(k=0;k<wavesize;k++){
if((enemy[k].s)&&(enemy[k].wait == 1)){ //alive and finished (.wait == 1 means countdown done)
while(emissile[notActiveSlotE].s == 1){ //find a non-active enemy missile slot in array
if(notActiveSlotE == 99){notActiveSlotE = 0;} //wrap around if at end of array
else notActiveSlotE++; //check next slot
}
emissile[notActiveSlotE].x = enemy[k].x + (enemy[k].w / 2); //center horizontal positioning of missile on enemy
emissile[notActiveSlotE].y = enemy[k].y + enemy[k].h; //get correct vertical positioning for missile
emissile[notActiveSlotE].s = 1; //activate missile
enemy[k].wait = 0; //signifying missile fired, reaady for new wait time
}
}
//loading enemies that just fired with new wait times
for(k=0;k<wavesize;k++){
if((enemy[k].s)&&(enemy[k].wait == 0)){ //alive and not currently waiting to fire (.wait == 0 means need new time)
j = (Random()%60); //get random number from 0-30
if(j < 20){j=20;} //minimum # 20 (3 shots per second max firing)
enemy[k].wait = j;
}
}
/////////////////////////////////////////////////////////////////////enemy missile printing//////////////////////////////////////////////////////////////////////////////////////////////
for(i=0;i<100;i++){
if(emissile[i].s == 1){
LCD_DrawBMP(enemyMissile,emissile[i].x,emissile[i].y);}}
/*else if ((emissile[i].s == 0)&&(emissile[i].b==0)){
LCD_DrawBMP(UmissileErase,emissile[i].x,emissile[i].y);}
emissile[i].b = 1;
}*/
//////////////////////////////////////////////////////////////////////////////missile printing///////////////////////////////////////////////////////////////////////////////////////////
for(i=0;i<100;i++){
if(missile[i].s){
LCD_DrawBMP(userMissile,missile[i].x,missile[i].y); //print if missile is active
}
}
///////////////////////////////////////////////////////////////////////////enemy ship printing///////////////////////////////////////////////////////////////////////////////////////
/////////////ship printing for wave 1
if(wave==10) {
for (k=0;k<5;k++) {
if (enemy[k].s ==1) {
LCD_DrawBMP(AlienEnemyBig, enemy[k].x,enemy[k].y); }
if (enemy[k].s ==2 &&enemy[k].b ==0) {
LCD_DrawBMP(Explosion1, enemy[k].x,(enemy[k].y)); LCD_DrawBMP (Explosion1, enemy[k].x, enemy[k].y);
LCD_DrawBMP(Explosion1, enemy[k].x,(enemy[k].y)); LCD_DrawBMP (Explosion1,enemy[k].x, enemy[k].y);
enemy[k].s=0; enemy[k].b=1;
}
if (enemy[k].s ==0 && enemy[k].e ==0) {
LCD_DrawBMP(ExplosionBlack, enemy[k].x,(enemy[k].y));
enemy[k].e=1;}
}
for (k=0;k<5;k++) {
if(enemy[k].s==0 && enemy[k].c==0) {enemycount++; enemy[k].c=1;} //count enemies if s=0 and c=0
}
if (enemycount==5) {wave=21;} //new wave is all five enemies are "dead"
}
/////////////Ship printing for wave 2
if(wave==20) {
for (k=0;k<5;k++) {
if (enemy[k].s ==1) {
LCD_DrawBMP(AlienEnemySmall, enemy[k].x,enemy[k].y); }
if (enemy[k].s ==2 && enemy[k].b ==0) {
LCD_DrawBMP(Explosion1, enemy[k].x,(enemy[k].y)); LCD_DrawBMP (Explosion1,enemy[k].x, enemy[k].y);
LCD_DrawBMP(Explosion1, enemy[k].x,(enemy[k].y)); LCD_DrawBMP (Explosion1,enemy[k].x, enemy[k].y);
enemy[k].s=0; enemy[k].b=1;
}
if (enemy[k].s ==0 && enemy[k].e==0) { //once explosion eraser is printed, set the s to zero and e to one
LCD_DrawBMP(ExplosionBlack, enemy[k].x,(enemy[k].y));
enemy[k].e=1;}
}
for(k=5;k<10;k++) {
if(enemy[k].s==1) {
LCD_DrawBMP(AlienEnemyBig, enemy[k].x,enemy[k].y); }
if (enemy[k].s ==2 && enemy[k].b ==0) {
LCD_DrawBMP(Explosion1, enemy[k].x,(enemy[k].y)); LCD_DrawBMP (Explosion1,enemy[k].x, enemy[k].y);
LCD_DrawBMP(Explosion1, enemy[k].x,(enemy[k].y)); LCD_DrawBMP (Explosion1,enemy[k].x, enemy[k].y);
enemy[k].s=0; enemy[k].b=1;
}
if (enemy[k].s ==0 && enemy[k].e==0) { //once explosion eraser is printed, set the s to zero and e to one
LCD_DrawBMP(ExplosionBlack, enemy[k].x, enemy[k].y);
enemy[k].e=1;}}
for (k=0;k<10;k++) {
if(enemy[k].s==0 && enemy[k].c==0) {enemycount++; enemy[k].c=1;} //count enemy if s=0 and c=0
}
if (enemycount==20) {wave=31;} //new wave if all ten enemies are "dead"
for(k=10;k<15;k++) {
if(enemy[k].s==1) {
LCD_DrawBMP(AlienEnemyBig, enemy[k].x,enemy[k].y); }
if (enemy[k].s ==2 && enemy[k].b ==0) {
LCD_DrawBMP(Explosion1, enemy[k].x,(enemy[k].y)); LCD_DrawBMP (Explosion1,enemy[k].x, enemy[k].y);
LCD_DrawBMP(Explosion1, enemy[k].x,(enemy[k].y)); LCD_DrawBMP (Explosion1,enemy[k].x, enemy[k].y);
enemy[k].s=0; enemy[k].b=1;
}
if (enemy[k].s ==0 && enemy[k].e==0) { //once explosion eraser is printed, set the s to zero and e to one
LCD_DrawBMP(ExplosionBlack, enemy[k].x, enemy[k].y);
enemy[k].e=1;}} }
} //close semaphore
} //close while loop
} //close main
/**
* @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
*/
/* NVIC Configuration */
NVIC_Configuration();
/* Initialize the LCD */
#ifdef USE_STM32100E_EVAL
STM32100E_LCD_Init();
#elif defined USE_STM3210E_EVAL
STM3210E_LCD_Init();
#elif defined USE_STM32100B_EVAL
STM32100B_LCD_Init();
#elif defined USE_STM3210B_EVAL
STM3210B_LCD_Init();
#endif
#ifdef USE_STM3210E_EVAL
/* Disable FSMC only for STM32 High-density and XL-density devices */
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_FSMC, DISABLE);
#endif /* USE_STM3210E_EVAL */
/* Initialize the Temperature Sensor */
LM75_Init();
if (LM75_GetStatus() == SUCCESS)
{
#ifdef USE_STM3210E_EVAL
/* Enable FSMC */
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_FSMC, ENABLE);
#endif /* USE_STM3210E_EVAL */
/* 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 ");
#ifdef USE_STM3210E_EVAL
/* Disable FSMC */
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_FSMC, DISABLE);
/* Initialize the Temperature Sensor */
LM75_Init();
#endif /* USE_STM3210E_EVAL */
/* Configure the Temperature sensor device STLM75:
- Thermostat mode Interrupt
- Fault tolerance: 00
*/
LM75_WriteConfReg(0x02);
/* Configure the THYS and TOS inorder to use the SMbus alert interrupt */
LM75_WriteReg(LM75_REG_THYS, TEMPERATURE_THYS << 8); /*31ÝC*/
LM75_WriteReg(LM75_REG_TOS, TEMPERATURE_TOS << 8); /*32ÝC*/
I2C_ClearITPendingBit(LM75_I2C, I2C_IT_SMBALERT);
SMbusAlertOccurred = 0;
/* Infinite Loop */
while (1)
{
#ifdef USE_STM3210E_EVAL
/* Disable FSMC */
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_FSMC, DISABLE);
/* Initialize the Temperature Sensor */
LM75_Init();
#endif /* USE_STM3210E_EVAL */
/* Get double of Temperature value */
TempValue = LM75_ReadTemp();
#ifdef USE_STM3210E_EVAL
/* Enable FSMC */
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_FSMC, ENABLE);
#endif /* USE_STM3210E_EVAL */
if (TempValue <= 256)
{
/* Positive temperature measured */
TempCelsiusDisplay[7] = '+';
/* Initialize the temperature sensor value*/
TempValueCelsius = TempValue;
}
else
{
/* Negative temperature measured */
TempCelsiusDisplay[7] = '-';
/* Remove temperature value sign */
TempValueCelsius = 0x200 - TempValue;
}
/* Calculate temperature digits in ÝC */
if ((TempValueCelsius & 0x01) == 0x01)
{
TempCelsiusDisplay[12] = 0x05 + 0x30;
TempFahrenheitDisplay[12] = 0x05 + 0x30;
}
else
{
TempCelsiusDisplay[12] = 0x00 + 0x30;
TempFahrenheitDisplay[12] = 0x00 + 0x30;
}
TempValueCelsius >>= 1;
TempCelsiusDisplay[8] = (TempValueCelsius / 100) + 0x30;
TempCelsiusDisplay[9] = ((TempValueCelsius % 100) / 10) + 0x30;
TempCelsiusDisplay[10] = ((TempValueCelsius % 100) % 10) + 0x30;
if (TempValue > 256)
{
if (((9 * TempValueCelsius) / 5) <= 32)
{
/* Convert temperature ÝC to Fahrenheit */
TempValueFahrenheit = abs (32 - ((9 * TempValueCelsius) / 5));
/* Calculate temperature digits in ÝF */
TempFahrenheitDisplay[8] = (TempValueFahrenheit / 100) + 0x30;
TempFahrenheitDisplay[9] = ((TempValueFahrenheit % 100) / 10) + 0x30;
TempFahrenheitDisplay[10] = ((TempValueFahrenheit % 100) % 10) + 0x30;
/* Positive temperature measured */
TempFahrenheitDisplay[7] = '+';
}
else
{
/* Convert temperature ÝC to Fahrenheit */
TempValueFahrenheit = abs(((9 * TempValueCelsius) / 5) - 32);
/* Calculate temperature digits in ÝF */
TempFahrenheitDisplay[8] = (TempValueFahrenheit / 100) + 0x30;
TempFahrenheitDisplay[9] = ((TempValueFahrenheit % 100) / 10) + 0x30;
TempFahrenheitDisplay[10] = ((TempValueFahrenheit % 100) % 10) + 0x30;
/* Negative temperature measured */
TempFahrenheitDisplay[7] = '-';
}
}
else
{
/* Convert temperature ÝC to Fahrenheit */
TempValueFahrenheit = ((9 * TempValueCelsius) / 5) + 32;
/* Calculate temperature digits in ÝF */
TempFahrenheitDisplay[8] = (TempValueFahrenheit / 100) + 0x30;
TempFahrenheitDisplay[9] = ((TempValueFahrenheit % 100) / 10) + 0x30;
TempFahrenheitDisplay[10] = ((TempValueFahrenheit % 100) % 10) + 0x30;
/* Positive temperature measured */
TempFahrenheitDisplay[7] = '+';
}
/* Display Fahrenheit value on LCD */
for (index = 0; index < 20; index++)
{
LCD_DisplayChar(LCD_LINE_6, (319 - (16 * index)), TempCelsiusDisplay[index]);
LCD_DisplayChar(LCD_LINE_7, (319 - (16 * index)), TempFahrenheitDisplay[index]);
}
if (SMbusAlertOccurred == 1)
{
/* Set the Back Color */
LCD_SetBackColor(LCD_COLOR_BLUE);
/* Set the Text Color */
LCD_SetTextColor(LCD_COLOR_RED);
LCD_DisplayStringLine(LCD_LINE_2, "Warning: Temp exceed");
LCD_DisplayStringLine(LCD_LINE_3, " 32 C ");
}
if (SMbusAlertOccurred == 2)
{
/* Set the Back Color */
LCD_SetBackColor(LCD_COLOR_WHITE);
/* Set the Text Color */
LCD_SetTextColor(LCD_COLOR_WHITE);
LCD_ClearLine(LCD_LINE_2);
LCD_ClearLine(LCD_LINE_3);
SMbusAlertOccurred = 0;
/* Set the Back Color */
LCD_SetBackColor(LCD_COLOR_BLUE);
/* Set the Text Color */
LCD_SetTextColor(LCD_COLOR_GREEN);
}
}
}
/*******************************************************************************
* Function Name : Demo_Init
* Description : Initializes the demonstration application.
* Input : None
* Output : None
* Return : None
*******************************************************************************/
void Demo_Init(void)
{
/* RCC system reset(for debug purpose) */
RCC_DeInit();
/* Enable HSE */
RCC_HSEConfig(RCC_HSE_ON);
/* Wait till HSE is ready */
HSEStartUpStatus = RCC_WaitForHSEStartUp();
if(HSEStartUpStatus == SUCCESS)
{
/* Enable Prefetch Buffer */
FLASH_PrefetchBufferCmd(FLASH_PrefetchBuffer_Enable);
/* Flash 2 wait state */
FLASH_SetLatency(FLASH_Latency_2);
/* HCLK = SYSCLK */
RCC_HCLKConfig(RCC_SYSCLK_Div1);
/* PCLK2 = HCLK */
RCC_PCLK2Config(RCC_HCLK_Div1);
/* PCLK1 = HCLK/2 */
RCC_PCLK1Config(RCC_HCLK_Div2);
/* PLLCLK = 8MHz * 9 = 72 MHz */
RCC_PLLConfig(RCC_PLLSource_HSE_Div1, RCC_PLLMul_9);
/* Enable PLL */
RCC_PLLCmd(ENABLE);
/* Wait till PLL is ready */
while(RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET)
{
}
/* Select PLL as system clock source */
RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);
/* Wait till PLL is used as system clock source */
while(RCC_GetSYSCLKSource() != 0x08)
{
}
}
/* Enable GPIOA, GPIOB, GPIOC, GPIOD, GPIOE, GPIOF, GPIOG and AFIO clocks */
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA | RCC_APB2Periph_GPIOB |RCC_APB2Periph_GPIOC
| RCC_APB2Periph_GPIOD | RCC_APB2Periph_GPIOE | RCC_APB2Periph_GPIOF | RCC_APB2Periph_GPIOG
| RCC_APB2Periph_AFIO, ENABLE);
/* TIM1 Periph clock enable */
RCC_APB2PeriphClockCmd(RCC_APB2Periph_TIM1, ENABLE);
/*------------------- Resources Initialization -----------------------------*/
/* GPIO Configuration */
GPIO_Config();
/* Interrupt Configuration */
InterruptConfig();
/* Configure the systick */
SysTick_Configuration();
/*------------------- Drivers Initialization -------------------------------*/
/* Initialize the LEDs toogling */
LedShow_Init();
/* Initialize the Low Power application */
LowPower_Init();
/* Initialize the LCD */
STM3210E_LCD_Init();
/* Clear the LCD */
LCD_Clear(White);
/* If HSE is not detected at program startup */
if(HSEStartUpStatus == ERROR)
{
/* Generate NMI exception */
SCB->ICSR |= SCB_ICSR_NMIPENDSET;
}
/* Checks the availability of the bitmap files */
CheckBitmapFilesStatus();
/* Display the STM32 introduction */
STM32Intro();
/* Clear the LCD */
LCD_Clear(White);
/* Initialize the Calendar */
Calendar_Init();
/* Enable Leds toggling */
LedShow(ENABLE);
/* Initialize the Low Power application*/
LowPower_Init();
/* Set the LCD Back Color */
LCD_SetBackColor(Blue);
/* Set the LCD Text Color */
LCD_SetTextColor(White);
/* Initialize the Menu */
Menu_Init();
/* Display the main menu icons */
ShowMenuIcons();
}
/**
* @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
*/
RTC_TimeTypeDef RTC_TimeStruct;
RTC_TimeTypeDef RTC_TimeStructureInit;
RTC_TimeTypeDef RTC_StampTimeStruct;
/* Configure the external interrupt "RIGHT" and "LEFT" buttons */
STM_EVAL_PBInit(BUTTON_RIGHT,BUTTON_MODE_EXTI);
STM_EVAL_PBInit(BUTTON_LEFT,BUTTON_MODE_EXTI);
/* Configure the RTC peripheral by selecting the clock source.*/
RTC_Config();
/* LCD Display init */
Display_Init();
/* Configure the RTC tamper register : To Clear all the Backup data register */
RTC_TamperConfig();
/* Initialize time Stucture */
RTC_TimeStructInit(&RTC_TimeStruct);
/* Infinite loop */
while (1)
{
/* Set the LCD Back Color and text size */
LCD_SetFont(&Font16x24);
LCD_SetBackColor(White);
/* Check on the event 'start' */
if(StartEvent != 0x0)
{
/* Get the RTC sub second fraction */
SecondFraction = (((256 - (uint32_t)RTC_GetSubSecond()) * 1000) / 256);
/* Get the Curent time */
RTC_GetTime(RTC_Format_BIN, &RTC_TimeStruct);
/* Refresh : Display the curent time and the sub second on the LCD */
RTC_Time_Display(37, Black , RTC_Get_Time(SecondFraction , &RTC_TimeStruct));
}
else
{
/* Re-initialize the Display time on the LCD */
RTC_Time_InitDisplay();
}
/* Left button is pressed */
if (Button_State == LEFT_ON)
{
/* Enable Tamper interrupt */
RTC_ITConfig(RTC_IT_TAMP, ENABLE);
/* Enabale the tamper 1 */
RTC_TamperCmd(RTC_Tamper_1 , ENABLE);
/* Set the LCD Back Color */
LCD_SetBackColor(White);
/* Clear the LCD line 5 */
LCD_ClearLine(Line5);
/* Get the current time */
RTC_GetTime(RTC_Format_BIN, &RTC_TimeStructureInit);
CurrentTimeSec = (RTC_TimeStructureInit.RTC_Hours * 3600) + (RTC_TimeStructureInit.RTC_Minutes * 60) +
RTC_TimeStructureInit.RTC_Seconds;
/* start count */
StartEvent = 0x1;
/* Reinitialize Button_State variable */
Button_State = 0;
}
/* Right button is pressed */
else if (Button_State == RIGHT_ON)
{
uint16_t Colorx;
if (BackupIndex < 5)
{
if((uint8_t)(BackupIndex% 2) != 0x0)
{
/* Set LCD backcolor*/
LCD_SetBackColor(Blue2);
Colorx = White;
}
else
{
/* Set LCD backcolor*/
LCD_SetBackColor(Cyan);
Colorx = Black;
}
SubSecFrac = 0;
/* Get the Current sub second and time */
SubSecFrac = (((256 - (uint32_t)RTC_GetSubSecond()) * 1000) / 256);
RTC_GetTime(RTC_Format_BIN, &RTC_StampTimeStruct);
LCD_SetFont(&Font16x24);
/* Display result on the LCD */
RTC_Time_Display( LINE(3 + BackupIndex), Colorx, RTC_Get_Time(SubSecFrac , &RTC_StampTimeStruct) );
if (BackupIndex < 2)
{
/* Save time register to Backup register ( the first 5 register is reserved for time) */
RTC_WriteBackupRegister(BKPDataReg[BackupIndex],(uint32_t)RTC->TR);
/* Save sub second time stamp register ( the latest 6 register is reserved for time) */
RTC_WriteBackupRegister(BKPDataReg[BackupIndex + 2], SubSecFrac);
}
}
else
{
/* the backup register is full with 10trials */
/* Set the LCD Back Color */
LCD_SetBackColor(White);
LCD_SetFont(&Font12x12);
/* Set the LCD Text Color */
LCD_SetTextColor(Red);
LCD_DisplayStringLine(LINE(16), (uint8_t *)MESSAGE4);
LCD_DisplayStringLine(LINE(17), (uint8_t *)MESSAGE5);
}
BackupIndex++;
/* Set the LCD Back Color */
LCD_SetBackColor(White);
/* Reinitialize Button_State variable */
Button_State = 0;
}
/* TAMPER button is pressed */
else if (Button_RTC == RTC_TAMP)
{
/* Set the LCD Back Color */
LCD_SetBackColor(White);
LCD_SetFont(&Font16x24);
/* Clear LCD line 5 to 9 */
for (i=0; i < 5; i++)
{
/* Clear all the LCD lignes from 3 to 7 */
LCD_ClearLine(LINE(3+i));
}
/* reset Counter */
BackupIndex = 0 ;
/* Enetr to idle */
StartEvent =0x0;
LCD_SetFont(&Font12x12);
RTC_Time_InitDisplay();
LCD_SetFont(&Font12x12);
LCD_ClearLine(LINE(16));
LCD_ClearLine(LINE(17));
/* Enable Tamper interrupt */
RTC_ITConfig(RTC_IT_TAMP, DISABLE);
/* Enabale the tamper 1 */
RTC_TamperCmd(RTC_Tamper_1 , DISABLE);
/* Reinitialize Button_RTC variable */
Button_RTC = 0;
}
}
}
/**
* @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_stm32f0xx.s) before to branch to application main.
To reconfigure the default setting of SystemInit() function, refer to
system_stm32f0xx.c file
*/
/* Initialize LEDs and LCD available on STM320518-EVAL board ****************/
STM_EVAL_LEDInit(LED1);
STM_EVAL_LEDInit(LED2);
STM_EVAL_LEDInit(LED3);
STM_EVAL_LEDInit(LED4);
/* Initialize TIM6 */
TIM6_Config();
/* Initialize the LCD */
STM320518_LCD_Init();
/* 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);
LCD_DisplayStringLine(Line3, MESSAGE3);
/* Set the LCD Back Color */
LCD_SetBackColor(White);
/* Set the LCD Text Color */
LCD_SetTextColor(Blue);
/* Configure the Push buttons in interrupt mode *****************************/
STM_EVAL_PBInit(BUTTON_KEY, Mode_EXTI);
STM_EVAL_PBInit(BUTTON_TAMPER, Mode_EXTI);
/* Start CPAL communication configuration ***********************************/
/* Initialize local Reception structures */
sRxStructure.wNumData = BufferSize; /* Maximum Number of data to be received */
sRxStructure.pbBuffer = tRxBuffer; /* Common Rx buffer for all received data */
sRxStructure.wAddr1 = 0; /* Not needed */
sRxStructure.wAddr2 = 0; /* Not needed */
/* Initialize local Transmission structures */
sTxStructure.wNumData = BufferSize; /* Maximum Number of data to be received */
sTxStructure.pbBuffer = (uint8_t*)tStateSignal; /* Common Rx buffer for all received data */
sTxStructure.wAddr1 = OWN_ADDRESS; /* The own board address */
sTxStructure.wAddr2 = 0; /* Not needed */
/* Set SYSCLK as I2C clock source */
RCC_I2CCLKConfig(RCC_I2C1CLK_SYSCLK);
/* Configure the device structure */
CPAL_I2C_StructInit(&I2C_DevStructure); /* Set all fields to default values */
I2C_DevStructure.CPAL_Mode = CPAL_MODE_SLAVE;
#ifdef CPAL_I2C_DMA_PROGMODEL
I2C_DevStructure.wCPAL_Options = CPAL_OPT_NO_MEM_ADDR | CPAL_OPT_DMATX_TCIT | CPAL_OPT_DMARX_TCIT;
I2C_DevStructure.CPAL_ProgModel = CPAL_PROGMODEL_DMA;
#elif defined (CPAL_I2C_IT_PROGMODEL)
I2C_DevStructure.wCPAL_Options = CPAL_OPT_NO_MEM_ADDR;
I2C_DevStructure.CPAL_ProgModel = CPAL_PROGMODEL_INTERRUPT;
#else
#error "Please select one of the programming model (in stm32f0xx_i2c_cpal_conf.h)"
#endif
I2C_DevStructure.pCPAL_I2C_Struct->I2C_Timing = I2C_TIMING;
I2C_DevStructure.pCPAL_I2C_Struct->I2C_OwnAddress1 = OWN_ADDRESS;
I2C_DevStructure.pCPAL_TransferRx = &sRxStructure;
I2C_DevStructure.pCPAL_TransferTx = &sTxStructure;
/* Initialize CPAL device with the selected parameters */
CPAL_I2C_Init(&I2C_DevStructure);
/* Infinite loop */
while (1)
{
/* Write operations ------------------------------------------------------*/
/* Check if any action has been triggered by push buttons */
if ((ActionState != ACTION_PENDING) && (ActionState != ACTION_NONE))
{
/* Check if the current CPAL device state allows write operation */
if ((I2C_DevStructure.CPAL_State == CPAL_STATE_READY) || \
(I2C_DevStructure.CPAL_State == CPAL_STATE_BUSY_RX) ||\
(I2C_DevStructure.CPAL_State == CPAL_STATE_DISABLED))
{
/* Initialize local Transmission structures */
sTxStructure.wNumData = BufferSize; /* Maximum Number of data to be received */
sTxStructure.wAddr1 = OWN_ADDRESS; /* The own board address */
sTxStructure.wAddr2 = 0; /* Not needed */
switch (ActionState)
{
case BUTTON_KEY:
sTxStructure.pbBuffer = (uint8_t*)tSignal1;
Divider = 1;
break;
case BUTTON_TAMPER:
sTxStructure.pbBuffer = (uint8_t*)tSignal2;
Divider = 2;
break;
case ACTION_PERIODIC:
sTxStructure.pbBuffer = (uint8_t*)tStateSignal;
break;
default:
sTxStructure.pbBuffer = (uint8_t*)tSignal1;
break;
}
/* Configure the device mode to master */
I2C_DevStructure.CPAL_Mode = CPAL_MODE_MASTER;
/* Force the CPAL state to ready (in case a read operation has been initiated) */
I2C_DevStructure.CPAL_State = CPAL_STATE_READY;
/* Prevent other actions to be performed while the current is not finished */
ActionState = ACTION_PENDING;
TransmitMode = STATE_ON;
/* Configure a Timer to generate periodic interrupt: used to send state signal */
TIM17_Config(PeriodicValue/Divider);
/* Start writing data in master mode */
if (CPAL_I2C_Write(&I2C_DevStructure) == CPAL_PASS)
{
}
}
}
/* Read Operations -------------------------------------------------------*/
if (((I2C_DevStructure.CPAL_State == CPAL_STATE_READY) || \
(I2C_DevStructure.CPAL_State == CPAL_STATE_DISABLED)) && \
(TransmitMode == STATE_OFF))
{
/* Initialize local Reception structures */
sRxStructure.wNumData = BufferSize; /* Maximum Number of data to be received */
sRxStructure.pbBuffer = tRxBuffer; /* Common Rx buffer for all received data */
/* Reconfigure device for slave receiver mode */
I2C_DevStructure.CPAL_Mode = CPAL_MODE_SLAVE;
I2C_DevStructure.CPAL_State = CPAL_STATE_READY;
/* Start waiting for data to be received in slave mode */
if (CPAL_I2C_Read(&I2C_DevStructure) == CPAL_PASS)
{
LCD_DisplayStringLine(Line9, MEASSAGE_EMPTY);
}
}
}
}
LLDSPEC void gdisp_lld_fill_area(GDisplay *g) {
LCD_SetTextColor(g->p.color);
LCD_DrawFullRect(g->p.x, g->p.y, g->p.cx, g->p.cy);
}
/**
* @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 */
STM32L152D_LCD_Init();
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 SPI EEPROM driver ----------------------------------------*/
sEE_Init();
#ifdef ENABLE_LCD_MSG_DISPLAY
LCD_DisplayStringLine(LCD_LINE_3, " Transfer 1 Ongoing ");
#endif /* ENABLE_LCD_MSG_DISPLAY */
/* First write in the memory followed by a read of the written data --------*/
/* Write on SPI 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 SPI EEPROM from sEE_READ_ADDRESS1 */
sEE_ReadBuffer(Rx1_Buffer, sEE_READ_ADDRESS1, (uint16_t *)(&NumDataRead));
/* 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 */
#ifdef ENABLE_LCD_MSG_DISPLAY
LCD_DisplayStringLine(LCD_LINE_5, " Transfer 2 Ongoing ");
#endif /* ENABLE_LCD_MSG_DISPLAY */
/* Second write in the memory followed by a read of the written data -------*/
/* Write on SPI 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 SPI EEPROM from sEE_READ_ADDRESS2 */
sEE_ReadBuffer(Rx2_Buffer, sEE_READ_ADDRESS2, (uint16_t *)(&NumDataRead));
/* 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 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 Reset the Bias measurement value stored in Data EEPROM.
* @param None
* @retval None
*/
void IDD_Measurement_Bias_Reset(void)
{
uint8_t pressedkey = 0;
/* Disable the JoyStick interrupts */
Demo_IntExtOnOffConfig(DISABLE);
LCD_Clear(LCD_COLOR_WHITE);
LCD_SetBackColor(LCD_COLOR_BLUE);
LCD_SetTextColor(LCD_COLOR_WHITE);
LCD_Clear(LCD_COLOR_WHITE);
LCD_SetBackColor(LCD_COLOR_BLUE);
LCD_SetTextColor(LCD_COLOR_WHITE);
LCD_DisplayStringLine(LCD_LINE_0, "Current Bias Value ");
LCD_DisplayStringLine(LCD_LINE_1, "stored in DATAEEPROM");
IDD_Measurement_ADC_DisplayValue((*(__IO uint16_t *)DATA_EEPROM_BIAS_ADDR), STM32L_MODE_BIAS);
LCD_DisplayStringLine(LCD_LINE_2, Str);
LCD_DisplayStringLine(LCD_LINE_5, " To reset Bias ");
LCD_DisplayStringLine(LCD_LINE_6, "measurement press ");
LCD_DisplayStringLine(LCD_LINE_7, "SEL push-button. ");
LCD_DisplayStringLine(LCD_LINE_8, "Press JoyStick to ");
LCD_DisplayStringLine(LCD_LINE_9, "exit. ");
pressedkey = Menu_ReadKey();
while (pressedkey == NOKEY)
{
pressedkey = Menu_ReadKey();
}
if (pressedkey != SEL)
{
/* Enable the JoyStick interrupts */
Demo_IntExtOnOffConfig(ENABLE);
/* Display the previous menu */
Menu_DisplayMenu();
return;
}
LCD_Clear(LCD_COLOR_WHITE);
/* Unlock EEPROM write access. */
DATA_EEPROM_Unlock();
/* Store the value in EEPROM for application needs. */
DATA_EEPROM_ProgramHalfWord(DATA_EEPROM_BIAS_ADDR, 0x0);
/* Lock back EEPROM write access. */
DATA_EEPROM_Lock();
LCD_DisplayStringLine(LCD_LINE_1, " Bias Measurement ");
LCD_DisplayStringLine(LCD_LINE_2, " Bias Value is reset");
LCD_DisplayStringLine(LCD_LINE_3, " to 0x0. ");
LCD_DisplayStringLine(LCD_LINE_7, "Press JoyStick to ");
LCD_DisplayStringLine(LCD_LINE_8, "continue. ");
LCD_GLASS_DisplayString(" STM32L ");
while (Menu_ReadKey() == NOKEY)
{}
/* Enable the JoyStick interrupts */
Demo_IntExtOnOffConfig(ENABLE);
/* Display the previous menu */
Menu_DisplayMenu();
}
/*******************************************************************************
* 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 Processes data transfers after a TFTP write request
* @param _args: used as pointer on TFTP connection args
* @param upcb: pointer on udp_pcb structure
* @param pkt_buf: pointer on a pbuf stucture
* @param ip_addr: pointer on the receive IP_address structure
* @param port: receive port address
* @retval none
*/
static void IAP_wrq_recv_callback(void *_args, struct udp_pcb *upcb, struct pbuf *pkt_buf, struct ip_addr *addr, u16_t port)
{
tftp_connection_args *args = (tftp_connection_args *)_args;
uint32_t data_buffer[128];
char message[20];
u16 count=0;
uint16_t bak_dr10;
if (pkt_buf->len != pkt_buf->tot_len)
{
return;
}
/* Does this packet have any valid data to write? */
if ((pkt_buf->len > TFTP_DATA_PKT_HDR_LEN) &&
(IAP_tftp_extract_block(pkt_buf->payload) == (args->block + 1)))
{
/* copy packet payload to data_buffer */
pbuf_copy_partial(pkt_buf, data_buffer, pkt_buf->len - TFTP_DATA_PKT_HDR_LEN,
TFTP_DATA_PKT_HDR_LEN);
total_count += pkt_buf->len - TFTP_DATA_PKT_HDR_LEN;
count = (pkt_buf->len - TFTP_DATA_PKT_HDR_LEN)/4;
if (((pkt_buf->len - TFTP_DATA_PKT_HDR_LEN)%4)!=0)
count++;
/* Write received data in Flash */
FLASH_If_Write(&Flash_Write_Address, data_buffer ,count);
/* update our block number to match the block number just received */
args->block++;
/* update total bytes */
(args->tot_bytes) += (pkt_buf->len - TFTP_DATA_PKT_HDR_LEN);
/* This is a valid pkt but it has no data. This would occur if the file being
written is an exact multiple of 512 bytes. In this case, the args->block
value must still be updated, but we can skip everything else. */
}
else if (IAP_tftp_extract_block(pkt_buf->payload) == (args->block + 1))
{
/* update our block number to match the block number just received */
args->block++;
}
/* Send the appropriate ACK pkt*/
IAP_tftp_send_ack_packet(upcb, addr, port, args->block);
/* If the last write returned less than the maximum TFTP data pkt length,
* then we've received the whole file and so we can quit (this is how TFTP
* signals the EndTransferof a transfer!)
*/
if (pkt_buf->len < TFTP_DATA_PKT_LEN_MAX)
{
IAP_tftp_cleanup_wr(upcb, args);
pbuf_free(pkt_buf);
BKP_WriteBackupRegister(BKP_DR10, 0x0000);
bak_dr10 = BKP_ReadBackupRegister(BKP_DR10);
#ifdef USE_LCD
LCD_SetTextColor(White);
LCD_DisplayStringLine(Line5, (char*)"Tot bytes Received:");
sprintf(message, "%u bytes ",total_count);
LCD_DisplayStringLine(Line6, (uint8_t*)message);
LCD_SetTextColor(Red);
LCD_DisplayStringLine(Line9, (char*)"State: Prog Finished ");
#endif
}
else
{
pbuf_free(pkt_buf);
return;
}
}
/**
* @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 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);
}