/**
* @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
*/
/* SPI configuration ------------------------------------------------------*/
SPI_Config();
/* SysTick configuration ---------------------------------------------------*/
SysTickConfig();
/* Initialize LEDs mounted on STM32L152-EVAL board */
STM_EVAL_LEDInit(LED1);
STM_EVAL_LEDInit(LED2);
STM_EVAL_LEDInit(LED3);
STM_EVAL_LEDInit(LED4);
/* Master board configuration ------------------------------------------------*/
#ifdef SPI_MASTER
/* Initialize push-buttons mounted on STM32L152-EVAL board */
STM_EVAL_PBInit(BUTTON_RIGHT, BUTTON_MODE_GPIO);
STM_EVAL_PBInit(BUTTON_LEFT, BUTTON_MODE_GPIO);
STM_EVAL_PBInit(BUTTON_UP, BUTTON_MODE_GPIO);
STM_EVAL_PBInit(BUTTON_DOWN, BUTTON_MODE_GPIO);
STM_EVAL_PBInit(BUTTON_SEL, BUTTON_MODE_GPIO);
/* Initializes the SPI communication */
SPI_InitStructure.SPI_Mode = SPI_Mode_Master;
SPI_Init(SPIx, &SPI_InitStructure);
/* Enable the Rx buffer not empty interrupt */
SPI_I2S_ITConfig(SPIx, SPI_I2S_IT_RXNE, ENABLE);
/* Enable the SPI Error interrupt */
SPI_I2S_ITConfig(SPIx, SPI_I2S_IT_ERR, ENABLE);
/* Data transfer is performed in the SPI interrupt routine */
/* Enable the SPI peripheral */
SPI_Cmd(SPIx, ENABLE);
while (1)
{
CmdTransmitted = 0x00;
CmdReceived = 0x00;
CmdStatus = 0x00;
Tx_Idx = 0x00;
Rx_Idx = 0x00;
/* Clear the RxBuffer */
Fill_Buffer(RxBuffer, TXBUFFERSIZE);
PressedButton = Read_Joystick();
while (PressedButton == JOY_NONE)
{
PressedButton = Read_Joystick();
}
switch (PressedButton)
{
/* JOY_RIGHT button pressed */
case JOY_RIGHT:
CmdTransmitted = CMD_RIGHT;
NumberOfByte = CMD_RIGHT_SIZE;
break;
/* JOY_LEFT button pressed */
case JOY_LEFT:
CmdTransmitted = CMD_LEFT;
NumberOfByte = CMD_LEFT_SIZE;
break;
/* JOY_UP button pressed */
case JOY_UP:
CmdTransmitted = CMD_UP;
NumberOfByte = CMD_UP_SIZE;
break;
/* JOY_DOWN button pressed */
case JOY_DOWN:
CmdTransmitted = CMD_DOWN;
NumberOfByte = CMD_DOWN_SIZE;
break;
/* JOY_SEL button pressed */
case JOY_SEL:
CmdTransmitted = CMD_SEL;
NumberOfByte = CMD_SEL_SIZE;
break;
default:
break;
}
if (CmdTransmitted != 0x00)
{
/* Enable the Tx buffer empty interrupt */
SPI_I2S_ITConfig(SPIx, SPI_I2S_IT_TXE, ENABLE);
/* Wait until end of data transfer or time out*/
TimeOut = USER_TIMEOUT;
while ((Rx_Idx < GetVar_NbrOfData())&&(TimeOut != 0x00))
{}
if(TimeOut == 0)
{
TimeOut_UserCallback();
}
}
switch (Rx_Idx)
{
/* Right button pressed */
case CMD_RIGHT_SIZE:
if ((Buffercmp(TxBuffer, RxBuffer, CMD_RIGHT_SIZE) == PASSED) && (CmdReceived == CMD_ACK))
{
/* Turn ON LED2 and LED3 */
STM_EVAL_LEDOn(LED2);
STM_EVAL_LEDOn(LED3);
/* Turn all other LEDs off */
STM_EVAL_LEDOff(LED4);
}
break;
/* Left button pressed*/
case CMD_LEFT_SIZE:
if ((Buffercmp(TxBuffer, RxBuffer, CMD_LEFT_SIZE) == PASSED) && (CmdReceived == CMD_ACK))
{
/* Turn ON LED4 */
STM_EVAL_LEDOn(LED4);
/* Turn all other LEDs off */
STM_EVAL_LEDOff(LED2);
STM_EVAL_LEDOff(LED3);
}
break;
/* Up button pressed */
case CMD_UP_SIZE:
if ((Buffercmp(TxBuffer, RxBuffer, CMD_UP_SIZE) == PASSED) && (CmdReceived == CMD_ACK))
{
/* Turn ON LED2 */
STM_EVAL_LEDOn(LED2);
/* Turn all other LEDs off */
STM_EVAL_LEDOff(LED3);
STM_EVAL_LEDOff(LED4);
}
break;
/* Down button pressed */
case CMD_DOWN_SIZE:
if ((Buffercmp(TxBuffer, RxBuffer, CMD_DOWN_SIZE) == PASSED) && (CmdReceived == CMD_ACK))
{
/* Turn ON LED3 */
STM_EVAL_LEDOn(LED3);
/* Turn all other LEDs off */
STM_EVAL_LEDOff(LED2);
STM_EVAL_LEDOff(LED4);
}
break;
/* Sel button pressed */
case CMD_SEL_SIZE:
if ((Buffercmp(TxBuffer, RxBuffer, CMD_SEL_SIZE) == PASSED) && (CmdReceived == CMD_ACK))
{
/* Turn ON all LEDs */
STM_EVAL_LEDOn(LED2);
STM_EVAL_LEDOn(LED3);
STM_EVAL_LEDOn(LED4);
}
break;
default:
break;
}
}
#endif /* SPI_MASTER */
/* Slave board configuration ----------------------------------------------*/
#ifdef SPI_SLAVE
/* Initializes the SPI communication */
SPI_I2S_DeInit(SPIx);
SPI_InitStructure.SPI_Mode = SPI_Mode_Slave;
SPI_Init(SPIx, &SPI_InitStructure);
/* Enable the Rx buffer not empty interrupt */
SPI_I2S_ITConfig(SPIx, SPI_I2S_IT_RXNE, ENABLE);
/* Enable the SPI Error interrupt */
SPI_I2S_ITConfig(SPIx, SPI_I2S_IT_ERR, ENABLE);
/* Enable the SPI peripheral */
SPI_Cmd(SPIx, ENABLE);
/* Infinite Loop */
while (1)
{
CmdStatus = 0x00;
CmdReceived = 0x00;
Rx_Idx = 0x00;
Tx_Idx = 0x00;
/* Write the first data in SPI shift register before enabling the interrupt
this data will be transmitted when the Slave receive the generated clock
by the Master */
/* Enable the Tx buffer empty interrupt */
SPI_I2S_SendData(SPIx, CMD_ACK);
SPI_I2S_ITConfig(SPIx, SPI_I2S_IT_TXE, ENABLE);
/* Waiting Transaction code Byte */
while (CmdStatus == 0x00)
{}
switch (CmdReceived)
{
/* CMD_RIGHT command received or time out*/
case CMD_RIGHT:
TimeOut = USER_TIMEOUT;
while ((Rx_Idx < CMD_RIGHT_SIZE)&&(TimeOut != 0x00))
{}
if(TimeOut == 0)
{
TimeOut_UserCallback();
}
if (Buffercmp(TxBuffer, RxBuffer, CMD_RIGHT_SIZE) != FAILED)
{
/* Turn ON LED2 and LED3 */
STM_EVAL_LEDOn(LED2);
STM_EVAL_LEDOn(LED3);
/* Turn OFF LED4 */
STM_EVAL_LEDOff(LED4);
}
break;
/* CMD_LEFT command received or time out */
case CMD_LEFT:
TimeOut = USER_TIMEOUT;
while ((Rx_Idx < CMD_LEFT_SIZE)&&(TimeOut != 0x00))
{}
if(TimeOut == 0)
{
TimeOut_UserCallback();
}
if (Buffercmp(TxBuffer, RxBuffer, CMD_LEFT_SIZE) != FAILED)
{
/* Turn ON LED4 */
STM_EVAL_LEDOn(LED4);
/* Turn OFF LED2 and LED3 */
STM_EVAL_LEDOff(LED2);
STM_EVAL_LEDOff(LED3);
}
break;
/* CMD_UP command received or time out*/
case CMD_UP:
TimeOut = USER_TIMEOUT;
while ((Rx_Idx < CMD_UP_SIZE)&&(TimeOut != 0x00))
{}
if(TimeOut == 0)
{
TimeOut_UserCallback();
}
if (Buffercmp(TxBuffer, RxBuffer, CMD_UP_SIZE) != FAILED)
{
/* Turn ON LED2 */
STM_EVAL_LEDOn(LED2);
/* Turn OFF LED3 and LED4 */
STM_EVAL_LEDOff(LED3);
STM_EVAL_LEDOff(LED4);
}
break;
/* CMD_DOWN command received or time out */
case CMD_DOWN:
TimeOut = USER_TIMEOUT;
while ((Rx_Idx < CMD_DOWN_SIZE)&&(TimeOut != 0x00))
{}
if(TimeOut == 0)
{
TimeOut_UserCallback();
}
if (Buffercmp(TxBuffer, RxBuffer, CMD_DOWN_SIZE) != FAILED)
{
/* Turn ON LED3 */
STM_EVAL_LEDOn(LED3);
/* Turn OFF LED2 and LED4 */
STM_EVAL_LEDOff(LED2);
STM_EVAL_LEDOff(LED4);
}
break;
/* CMD_SEL command received or time out */
case CMD_SEL:
TimeOut = USER_TIMEOUT;
while ((Rx_Idx < CMD_SEL_SIZE)&&(TimeOut != 0x00))
{}
if(TimeOut == 0)
{
TimeOut_UserCallback();
}
if (Buffercmp(TxBuffer, RxBuffer, CMD_SEL_SIZE) != FAILED)
{
/* Turn ON LED2, LED3 and LED4 */
STM_EVAL_LEDOn(LED2);
STM_EVAL_LEDOn(LED3);
STM_EVAL_LEDOn(LED4);
}
break;
default:
break;
}
/* Disable the Tx buffer empty interrupt */
SPI_I2S_ITConfig(SPIx, SPI_I2S_IT_TXE, DISABLE);
}
#endif /* SPI_SLAVE */
}
/**
* @brief Main program.
* @param None
* @retval None
*/
int main(void)
{
/*!< At this stage the microcontroller clock setting is already configured,
this is done through SystemInit() function which is called from startup
file (startup_stm32f0xx.s) before to branch to application main.
To reconfigure the default setting of SystemInit() function, refer to
system_stm32f0xx.c file
*/
/* SPI configuration ------------------------------------------------------*/
SPI_Config();
/* SysTick configuration ---------------------------------------------------*/
SysTickConfig();
/* Initialize LEDs mounted on STM320518-EVAL board */
STM_EVAL_LEDInit(LED1);
STM_EVAL_LEDInit(LED2);
STM_EVAL_LEDInit(LED3);
STM_EVAL_LEDInit(LED4);
/* Master board configuration ------------------------------------------------*/
#ifdef SPI_MASTER
/* Initialize push-buttons mounted on STM320518-EVAL board */
STM_EVAL_PBInit(BUTTON_RIGHT, BUTTON_MODE_GPIO);
STM_EVAL_PBInit(BUTTON_LEFT, BUTTON_MODE_GPIO);
STM_EVAL_PBInit(BUTTON_UP, BUTTON_MODE_GPIO);
STM_EVAL_PBInit(BUTTON_DOWN, BUTTON_MODE_GPIO);
STM_EVAL_PBInit(BUTTON_SEL, BUTTON_MODE_GPIO);
/* Initializes the SPI communication */
SPI_InitStructure.SPI_Mode = SPI_Mode_Master;
SPI_Init(SPIx, &SPI_InitStructure);
/* Initialize the FIFO threshold */
SPI_RxFIFOThresholdConfig(SPIx, SPI_RxFIFOThreshold_QF);
/* TIM configuration ------------------------------------------------------*/
TIM_Config();
/* Enable the SPI peripheral */
SPI_Cmd(SPIx, ENABLE);
/* Enable NSS output for master mode */
SPI_SSOutputCmd(SPIx, ENABLE);
/* TIM Capture Compare DMA Request enable */
TIM_DMACmd(TIMx, TIMx_DMA_CHANNEL, ENABLE);
while (1)
{
/* DMA channel Rx of SPI Configuration */
DMA_InitStructure.DMA_BufferSize = (uint16_t)1;
DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)SPIx_DR_ADDRESS;
DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t) &CommandReceived;
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC;
DMA_InitStructure.DMA_Priority = DMA_Priority_High;
DMA_Init(SPIx_RX_DMA_CHANNEL, &DMA_InitStructure);
/* DMA TIM trigger channel Configuration */
DMA_InitStructure.DMA_BufferSize = (uint16_t)1;
DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)SPIx_DR_ADDRESS;
DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t) &CommandTransmitted;
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralDST;
DMA_InitStructure.DMA_Priority = DMA_Priority_Low;
DMA_Init(TIMx_CHANNEL_DMA_CHANNEL, &DMA_InitStructure);
/* Enable the SPI Rx DMA request */
SPI_I2S_DMACmd(SPIx, SPI_I2S_DMAReq_Rx, ENABLE);
CommandTransmitted = 0x00;
CommandReceived = 0x00;
/* Clear the RxBuffer */
Fill_Buffer(RxBuffer, TXBUFFERSIZE);
PressedButton = Read_Joystick();
while (PressedButton == JOY_NONE)
{
PressedButton = Read_Joystick();
}
switch (PressedButton)
{
/* JOY_RIGHT button pressed */
case JOY_RIGHT:
CommandTransmitted = CMD_RIGHT;
NumberOfByte = CMD_RIGHT_SIZE;
break;
/* JOY_LEFT button pressed */
case JOY_LEFT:
CommandTransmitted = CMD_LEFT;
NumberOfByte = CMD_LEFT_SIZE;
break;
/* JOY_UP button pressed */
case JOY_UP:
CommandTransmitted = CMD_UP;
NumberOfByte = CMD_UP_SIZE;
break;
/* JOY_DOWN button pressed */
case JOY_DOWN:
CommandTransmitted = CMD_DOWN;
NumberOfByte = CMD_DOWN_SIZE;
break;
/* JOY_SEL button pressed */
case JOY_SEL:
CommandTransmitted = CMD_SEL;
NumberOfByte = CMD_SEL_SIZE;
break;
default:
break;
}
/* Enable the DMA channel */
DMA_Cmd(SPIx_RX_DMA_CHANNEL, ENABLE);
/* Enable DMA1 TIM Trigger Channel */
DMA_Cmd(TIMx_CHANNEL_DMA_CHANNEL, ENABLE);
/* TIM enable counter */
TIM_Cmd(TIMx, ENABLE);
/* Wait the SPI DMA Rx transfer complete or time out*/
TimeOut = USER_TIMEOUT;
while ((DMA_GetFlagStatus(SPIx_RX_DMA_FLAG_TC) == RESET)&&(TimeOut != 0x00))
{}
if(TimeOut == 0)
{
TimeOut_UserCallback();
}
/* The BSY flag can be monitored to ensure that the SPI communication is complete.
This is required to avoid corrupting the last transmission before disabling
the SPI or entering the Stop mode. The software must first wait until TXE=1
and then until BSY=0.*/
TimeOut = USER_TIMEOUT;
while ((SPI_I2S_GetFlagStatus(SPIx, SPI_I2S_FLAG_TXE) == RESET)&&(TimeOut != 0x00))
{}
if(TimeOut == 0)
{
TimeOut_UserCallback();
}
TimeOut = USER_TIMEOUT;
while ((SPI_I2S_GetFlagStatus(SPIx, SPI_I2S_FLAG_BSY) == SET)&&(TimeOut != 0x00))
{}
if(TimeOut == 0)
{
TimeOut_UserCallback();
}
/* Clear DMA1 global flags*/
DMA_ClearFlag(TIMx_CHANNEL_DMA_FLAG_GL);
DMA_ClearFlag(SPIx_RX_DMA_FLAG_GL);
/* disable the DMA channels */
DMA_Cmd(SPIx_RX_DMA_CHANNEL, DISABLE);
DMA_Cmd(TIMx_CHANNEL_DMA_CHANNEL, DISABLE);
/* disable the SPI Rx DMA request */
SPI_I2S_DMACmd(SPIx, SPI_I2S_DMAReq_Rx, DISABLE);
/* TIM disable counter */
TIM_Cmd(TIMx, DISABLE);
if (CommandReceived == CMD_ACK)
{
/* DMA channel Rx of SPI Configuration */
DMA_InitStructure.DMA_BufferSize = (uint16_t)NumberOfByte;
DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)SPIx_DR_ADDRESS;
DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)RxBuffer;
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC;
DMA_InitStructure.DMA_Priority = DMA_Priority_High;
DMA_Init(SPIx_RX_DMA_CHANNEL, &DMA_InitStructure);
/* DMA channel Tx of SPI Configuration */
DMA_InitStructure.DMA_BufferSize = (uint16_t)NumberOfByte;
DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)SPIx_DR_ADDRESS;
DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)TxBuffer;
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralDST;
DMA_InitStructure.DMA_Priority = DMA_Priority_Low;
DMA_Init(TIMx_CHANNEL_DMA_CHANNEL, &DMA_InitStructure);
/* Enable the SPI Rx DMA request */
SPI_I2S_DMACmd(SPIx, SPI_I2S_DMAReq_Rx, ENABLE);
/* Enable the DMA channel */
DMA_Cmd(SPIx_RX_DMA_CHANNEL, ENABLE);
/* Enable DMA1 TIM Trigger Channel */
DMA_Cmd(TIMx_CHANNEL_DMA_CHANNEL, ENABLE);
/* TIM enable counter */
TIM_Cmd(TIMx, ENABLE);
/* Wait the SPI Rx DMA transfer complete or time out */
TimeOut = USER_TIMEOUT;
while ((DMA_GetFlagStatus(SPIx_RX_DMA_FLAG_TC) == RESET)&&(TimeOut != 0x00))
{}
if(TimeOut == 0)
{
TimeOut_UserCallback();
}
/* The BSY flag can be monitored to ensure that the SPI communication is complete.
This is required to avoid corrupting the last transmission before disabling
the SPI or entering the Stop mode. The software must first wait until TXE=1
and then until BSY=0.*/
TimeOut = USER_TIMEOUT;
while ((SPI_I2S_GetFlagStatus(SPIx, SPI_I2S_FLAG_TXE) == RESET)&&(TimeOut != 0x00))
{}
if(TimeOut == 0)
{
TimeOut_UserCallback();
}
TimeOut = USER_TIMEOUT;
while ((SPI_I2S_GetFlagStatus(SPIx, SPI_I2S_FLAG_BSY) == SET)&&(TimeOut != 0x00))
{}
if(TimeOut == 0)
{
TimeOut_UserCallback();
}
/* Clear DMA1 global flags */
DMA_ClearFlag(TIMx_CHANNEL_DMA_FLAG_GL);
DMA_ClearFlag(SPIx_RX_DMA_FLAG_GL);
/* Disable the DMA channels */
DMA_Cmd(SPIx_RX_DMA_CHANNEL, DISABLE);
DMA_Cmd(TIMx_CHANNEL_DMA_CHANNEL, DISABLE);
/* Disable the SPI Rx and Tx DMA requests */
SPI_I2S_DMACmd(SPIx, SPI_I2S_DMAReq_Rx, DISABLE);
/* TIM disable counter */
TIM_Cmd(TIMx, DISABLE);
switch (NumberOfByte)
{
/* CMD_RIGHT command received */
case CMD_RIGHT_SIZE:
if ((Buffercmp(TxBuffer, RxBuffer, CMD_RIGHT_SIZE, SPI_DATAMASK) != FAILED) && (CommandReceived == CMD_ACK))
{
/* Turn ON LED2 and LED3 */
STM_EVAL_LEDOn(LED2);
STM_EVAL_LEDOn(LED3);
/* Turn OFF LED4 */
STM_EVAL_LEDOff(LED4);
}
break;
/* CMD_LEFT command received */
case CMD_LEFT_SIZE:
if ((Buffercmp(TxBuffer, RxBuffer, CMD_LEFT_SIZE, SPI_DATAMASK) != FAILED) && (CommandReceived == CMD_ACK))
{
/* Turn ON LED4 */
STM_EVAL_LEDOn(LED4);
/* Turn OFF LED2 and LED3 */
STM_EVAL_LEDOff(LED2);
STM_EVAL_LEDOff(LED3);
}
break;
/* CMD_UP command received */
case CMD_UP_SIZE:
if ((Buffercmp(TxBuffer, RxBuffer, CMD_UP_SIZE, SPI_DATAMASK) != FAILED) && (CommandReceived == CMD_ACK))
{
/* Turn ON LED2 */
STM_EVAL_LEDOn(LED2);
/* Turn OFF LED3 and LED4 */
STM_EVAL_LEDOff(LED3);
STM_EVAL_LEDOff(LED4);
}
break;
/* CMD_DOWN command received */
case CMD_DOWN_SIZE:
if ((Buffercmp(TxBuffer, RxBuffer, CMD_DOWN_SIZE, SPI_DATAMASK) != FAILED) && (CommandReceived == CMD_ACK))
{
/* Turn ON LED3 */
STM_EVAL_LEDOn(LED3);
/* Turn OFF LED2 and LED4 */
STM_EVAL_LEDOff(LED2);
STM_EVAL_LEDOff(LED4);
}
break;
/* CMD_SEL command received */
case CMD_SEL_SIZE:
if ((Buffercmp(TxBuffer, RxBuffer, CMD_SEL_SIZE, SPI_DATAMASK) != FAILED) && (CommandReceived == CMD_ACK))
{
/* Turn ON LED2, LED3 and LED4 */
STM_EVAL_LEDOn(LED2);
STM_EVAL_LEDOn(LED3);
STM_EVAL_LEDOn(LED4);
}
break;
default:
break;
}
}
}
#endif /* SPI_MASTER */
/* Slave board configuration -----------------------------------------------*/
#ifdef SPI_SLAVE
/* Initializes the SPI communication */
SPI_I2S_DeInit(SPIx);
SPI_InitStructure.SPI_Mode = SPI_Mode_Slave;
SPI_Init(SPIx, &SPI_InitStructure);
/* Initialize the FIFO threshold */
SPI_RxFIFOThresholdConfig(SPIx, SPI_RxFIFOThreshold_QF);
CommandTransmitted = CMD_ACK;
/* Infinite Loop */
while (1)
{
/* DMA channel Rx of SPI Configuration */
DMA_InitStructure.DMA_BufferSize = 1;
DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)SPIx_DR_ADDRESS;
DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t) &CommandReceived;
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC;
DMA_InitStructure.DMA_Priority = DMA_Priority_High;
DMA_Init(SPIx_RX_DMA_CHANNEL, &DMA_InitStructure);
/* DMA channel Tx of SPI Configuration */
DMA_InitStructure.DMA_BufferSize = 1;
DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)SPIx_DR_ADDRESS;
DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t) &CommandTransmitted;
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralDST;
DMA_InitStructure.DMA_Priority = DMA_Priority_Low;
DMA_Init(SPIx_TX_DMA_CHANNEL, &DMA_InitStructure);
/* Enable the SPI Rx and Tx DMA requests */
SPI_I2S_DMACmd(SPIx, SPI_I2S_DMAReq_Rx, ENABLE);
SPI_I2S_DMACmd(SPIx, SPI_I2S_DMAReq_Tx, ENABLE);
/* Enable the SPI peripheral */
SPI_Cmd(SPIx, ENABLE);
CommandReceived = 0x00;
/* Enable the DMA channels */
DMA_Cmd(SPIx_RX_DMA_CHANNEL, ENABLE);
DMA_Cmd(SPIx_TX_DMA_CHANNEL, ENABLE);
/* Wait the SPI DMA transfers complete or time out */
while (DMA_GetFlagStatus(SPIx_RX_DMA_FLAG_TC) == RESET)
{}
TimeOut = USER_TIMEOUT;
while ((DMA_GetFlagStatus(SPIx_TX_DMA_FLAG_TC) == RESET)&&(TimeOut != 0x00))
{}
if(TimeOut == 0)
{
TimeOut_UserCallback();
}
/* The BSY flag can be monitored to ensure that the SPI communication is complete.
This is required to avoid corrupting the last transmission before disabling
the SPI or entering the Stop mode. The software must first wait until TXE=1
and then until BSY=0.*/
TimeOut = USER_TIMEOUT;
while ((SPI_I2S_GetFlagStatus(SPIx, SPI_I2S_FLAG_TXE) == RESET)&&(TimeOut != 0x00))
{}
if(TimeOut == 0)
{
TimeOut_UserCallback();
}
TimeOut = USER_TIMEOUT;
while ((SPI_I2S_GetFlagStatus(SPIx, SPI_I2S_FLAG_BSY) == SET)&&(TimeOut != 0x00))
{}
if(TimeOut == 0)
{
TimeOut_UserCallback();
}
/* Clear DMA1 global flags */
DMA_ClearFlag(SPIx_TX_DMA_FLAG_GL);
DMA_ClearFlag(SPIx_RX_DMA_FLAG_GL);
/* Disable the DMA channels */
DMA_Cmd(SPIx_RX_DMA_CHANNEL, DISABLE);
DMA_Cmd(SPIx_TX_DMA_CHANNEL, DISABLE);
/* Disable the SPI peripheral */
SPI_Cmd(SPIx, DISABLE);
/* Disable the SPI Rx and Tx DMA requests */
SPI_I2S_DMACmd(SPIx, SPI_I2S_DMAReq_Rx, DISABLE);
SPI_I2S_DMACmd(SPIx, SPI_I2S_DMAReq_Tx, DISABLE);
switch (CommandReceived)
{
/* CMD_RIGHT command received */
case CMD_RIGHT:
NumberOfByte = CMD_RIGHT_SIZE;
break;
/* CMD_LEFT command received */
case CMD_LEFT:
NumberOfByte = CMD_LEFT_SIZE;
break;
/* CMD_UP command received */
case CMD_UP:
NumberOfByte = CMD_UP_SIZE;
break;
/* CMD_DOWN command received */
case CMD_DOWN:
NumberOfByte = CMD_DOWN_SIZE;
break;
/* CMD_SEL command received */
case CMD_SEL:
NumberOfByte = CMD_SEL_SIZE;
break;
default:
break;
}
/* DMA channel Rx of SPI Configuration */
DMA_InitStructure.DMA_BufferSize = NumberOfByte;
DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)SPIx_DR_ADDRESS;
DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)RxBuffer;
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC;
DMA_InitStructure.DMA_Priority = DMA_Priority_High;
DMA_Init(SPIx_RX_DMA_CHANNEL, &DMA_InitStructure);
/* DMA channel Tx of SPI Configuration */
DMA_InitStructure.DMA_BufferSize = NumberOfByte;
DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)SPIx_DR_ADDRESS;
DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)TxBuffer;
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralDST;
DMA_InitStructure.DMA_Priority = DMA_Priority_Low;
DMA_Init(SPIx_TX_DMA_CHANNEL, &DMA_InitStructure);
/* Enable the SPI Rx and Tx DMA requests */
SPI_I2S_DMACmd(SPIx, SPI_I2S_DMAReq_Rx, ENABLE);
SPI_I2S_DMACmd(SPIx, SPI_I2S_DMAReq_Tx, ENABLE);
/* Enable the SPI peripheral */
SPI_Cmd(SPIx, ENABLE);
/* Enable the DMA channels */
DMA_Cmd(SPIx_RX_DMA_CHANNEL, ENABLE);
DMA_Cmd(SPIx_TX_DMA_CHANNEL, ENABLE);
/* Wait the SPI DMA transfers complete or time out */
while (DMA_GetFlagStatus(SPIx_RX_DMA_FLAG_TC) == RESET)
{}
TimeOut = USER_TIMEOUT;
while ((DMA_GetFlagStatus(SPIx_TX_DMA_FLAG_TC) == RESET)&&(TimeOut != 0x00))
{}
if(TimeOut == 0)
{
TimeOut_UserCallback();
}
/* The BSY flag can be monitored to ensure that the SPI communication is complete.
This is required to avoid corrupting the last transmission before disabling
the SPI or entering the Stop mode. The software must first wait until TXE=1
and then until BSY=0.*/
TimeOut = USER_TIMEOUT;
while ((SPI_I2S_GetFlagStatus(SPIx, SPI_I2S_FLAG_TXE) == RESET)&&(TimeOut != 0x00))
{}
if(TimeOut == 0)
{
TimeOut_UserCallback();
}
TimeOut = USER_TIMEOUT;
while ((SPI_I2S_GetFlagStatus(SPIx, SPI_I2S_FLAG_BSY) == SET)&&(TimeOut != 0x00))
{}
if(TimeOut == 0)
{
TimeOut_UserCallback();
}
switch (NumberOfByte)
{
/* CMD_RIGHT command received */
case CMD_RIGHT_SIZE:
if (Buffercmp(TxBuffer, RxBuffer, CMD_RIGHT_SIZE, SPI_DATAMASK) != FAILED)
{
/* Turn ON LED2 and LED3 */
STM_EVAL_LEDOn(LED2);
STM_EVAL_LEDOn(LED3);
/* Turn OFF LED4 */
STM_EVAL_LEDOff(LED4);
}
break;
/* CMD_LEFT command received */
case CMD_LEFT_SIZE:
if (Buffercmp(TxBuffer, RxBuffer, CMD_LEFT_SIZE, SPI_DATAMASK) != FAILED)
{
/* Turn ON LED4 */
STM_EVAL_LEDOn(LED4);
/* Turn OFF LED2 and LED3 */
STM_EVAL_LEDOff(LED2);
STM_EVAL_LEDOff(LED3);
}
break;
/* CMD_UP command received */
case CMD_UP_SIZE:
if (Buffercmp(TxBuffer, RxBuffer, CMD_UP_SIZE, SPI_DATAMASK) != FAILED)
{
/* Turn ON LED2 */
STM_EVAL_LEDOn(LED2);
/* Turn OFF LED3 and LED4 */
STM_EVAL_LEDOff(LED3);
STM_EVAL_LEDOff(LED4);
}
break;
/* CMD_DOWN command received */
case CMD_DOWN_SIZE:
if (Buffercmp(TxBuffer, RxBuffer, CMD_DOWN_SIZE, SPI_DATAMASK) != FAILED)
{
/* Turn ON LED3 */
STM_EVAL_LEDOn(LED3);
/* Turn OFF LED2 and LED4 */
STM_EVAL_LEDOff(LED2);
STM_EVAL_LEDOff(LED4);
}
break;
/* CMD_SEL command received */
case CMD_SEL_SIZE:
if (Buffercmp(TxBuffer, RxBuffer, CMD_SEL_SIZE, SPI_DATAMASK) != FAILED)
{
/* Turn ON LED2, LED3 and LED4 */
STM_EVAL_LEDOn(LED2);
STM_EVAL_LEDOn(LED3);
STM_EVAL_LEDOn(LED4);
}
break;
default:
break;
}
/* Clear DMA1 global flags */
DMA_ClearFlag(SPIx_TX_DMA_FLAG_GL);
DMA_ClearFlag(SPIx_RX_DMA_FLAG_GL);
/* Disable the DMA channels */
DMA_Cmd(SPIx_RX_DMA_CHANNEL, DISABLE);
DMA_Cmd(SPIx_TX_DMA_CHANNEL, DISABLE);
/* Disable the SPI peripheral */
SPI_Cmd(SPIx, DISABLE);
/* Disable the SPI Rx and Tx DMA requests */
SPI_I2S_DMACmd(SPIx, SPI_I2S_DMAReq_Rx, DISABLE);
SPI_I2S_DMACmd(SPIx, SPI_I2S_DMAReq_Tx, DISABLE);
}
#endif /* SPI_SLAVE */
}
/**
* @brief Main program.
* @param None
* @retval None
*/
int main(void)
{
/*!< At this stage the microcontroller clock setting is already configured,
this is done through SystemInit() function which is called from startup
file (startup_stm32f0xx.s) before to branch to application main.
To reconfigure the default setting of SystemInit() function, refer to
system_stm32f0xx.c file
*/
/* USART configuration -----------------------------------------------------*/
USART_Config();
/* SysTick configuration ---------------------------------------------------*/
SysTickConfig();
/* Initialize LEDs mounted on EVAL board */
STM_EVAL_LEDInit(LED1);
STM_EVAL_LEDInit(LED2);
STM_EVAL_LEDInit(LED3);
STM_EVAL_LEDInit(LED4);
/* Initialize push-buttons mounted on EVAL board */
STM_EVAL_PBInit(BUTTON_RIGHT, BUTTON_MODE_GPIO);
STM_EVAL_PBInit(BUTTON_LEFT, BUTTON_MODE_GPIO);
STM_EVAL_PBInit(BUTTON_UP, BUTTON_MODE_GPIO);
STM_EVAL_PBInit(BUTTON_DOWN, BUTTON_MODE_GPIO);
STM_EVAL_PBInit(BUTTON_SEL, BUTTON_MODE_GPIO);
while (1)
{
/* Clear Buffers */
Fill_Buffer(CmdBuffer, 0x02);
Fill_Buffer(AckBuffer, 0x02);
Fill_Buffer(RxBuffer, TXBUFFERSIZE);
/* Waiting transaction code in case of USART receiver */
/* DMA channel Rx of USART Configuration */
DMA_DeInit(USARTx_RX_DMA_CHANNEL);
DMA_InitStructure.DMA_PeripheralBaseAddr = USARTx_RDR_ADDRESS;
DMA_InitStructure.DMA_BufferSize = (uint16_t)2;
DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)CmdBuffer;
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC;
DMA_InitStructure.DMA_Priority = DMA_Priority_Low;
DMA_Init(USARTx_RX_DMA_CHANNEL, &DMA_InitStructure);
/* Enable the USART Rx DMA request */
USART_DMACmd(USARTx, USART_DMAReq_Rx, ENABLE);
/* Enable the DMA channel */
DMA_Cmd(USARTx_RX_DMA_CHANNEL, ENABLE);
PressedButton = Read_Joystick();
/* Waiting Joystick pressed in case to transmit data or received Transaction command */
while((PressedButton == JOY_NONE) && (CmdBuffer[0x00] == 0x00))
{
PressedButton = Read_Joystick();
}
/* USART in Mode Transmitter ---------------------------------------------*/
if ((PressedButton != JOY_NONE) && (CmdBuffer[0x00] == 0x00))
{
/* Configure the USART to receive the ACK command Table */
/* DMA channel Rx of USART Configuration */
DMA_DeInit(USARTx_RX_DMA_CHANNEL);
DMA_InitStructure.DMA_PeripheralBaseAddr = USARTx_RDR_ADDRESS;
DMA_InitStructure.DMA_BufferSize = (uint16_t)2;
DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)AckBuffer;
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC;
DMA_InitStructure.DMA_Priority = DMA_Priority_Low;
DMA_Init(USARTx_RX_DMA_CHANNEL, &DMA_InitStructure);
/* Configure the USART to send the command table */
/* DMA channel Tx of USART Configuration */
DMA_DeInit(USARTx_TX_DMA_CHANNEL);
DMA_InitStructure.DMA_PeripheralBaseAddr = USARTx_TDR_ADDRESS;
DMA_InitStructure.DMA_BufferSize = (uint16_t)2;
DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)CmdBuffer;
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralDST;
DMA_InitStructure.DMA_Priority = DMA_Priority_High;
DMA_Init(USARTx_TX_DMA_CHANNEL, &DMA_InitStructure);
switch (PressedButton)
{
/* JOY_RIGHT button pressed */
case JOY_RIGHT:
CmdBuffer[0x00] = CMD_RIGHT;
CmdBuffer[0x01] = CMD_RIGHT_SIZE;
break;
/* JOY_LEFT button pressed */
case JOY_LEFT:
CmdBuffer[0x00] = CMD_LEFT;
CmdBuffer[0x01] = CMD_LEFT_SIZE;
break;
/* JOY_UP button pressed */
case JOY_UP:
CmdBuffer[0x00] = CMD_UP;
CmdBuffer[0x01] = CMD_UP_SIZE;
break;
/* JOY_DOWN button pressed */
case JOY_DOWN:
CmdBuffer[0x00] = CMD_DOWN;
CmdBuffer[0x01] = CMD_DOWN_SIZE;
break;
/* JOY_SEL button pressed */
case JOY_SEL:
CmdBuffer[0x00] = CMD_SEL;
CmdBuffer[0x01] = CMD_SEL_SIZE;
break;
default:
break;
}
/* Enable the USART DMA requests */
USART_DMACmd(USARTx, USART_DMAReq_Rx, ENABLE);
USART_DMACmd(USARTx, USART_DMAReq_Tx, ENABLE);
/* Clear the TC bit in the SR register by writing 0 to it */
USART_ClearFlag(USARTx, USART_FLAG_TC);
/* Enable the DMA USART Tx Channel */
DMA_Cmd(USARTx_TX_DMA_CHANNEL, ENABLE);
/* Enable the DMA USART Rx channel */
DMA_Cmd(USARTx_RX_DMA_CHANNEL, ENABLE);
/* Wait the USART DMA Tx transfer complete or time out */
TimeOut = USER_TIMEOUT;
while ((DMA_GetFlagStatus(USARTx_TX_DMA_FLAG_TC) == RESET)&&(TimeOut != 0x00))
{
}
if(TimeOut == 0)
{
TimeOut_UserCallback();
}
/* The software must wait until TC=1. The TC flag remains cleared during all data
transfers and it is set by hardware at the last frame’s end of transmission*/
TimeOut = USER_TIMEOUT;
while ((USART_GetFlagStatus(USARTx, USART_FLAG_TC) == RESET)&&(TimeOut != 0x00))
{
}
if(TimeOut == 0)
{
TimeOut_UserCallback();
}
/* Wait the USART DMA Rx transfer complete or time out */
TimeOut = USER_TIMEOUT;
while ((DMA_GetFlagStatus(USARTx_RX_DMA_FLAG_TC) == RESET)&&(TimeOut != 0x00))
{}
if(TimeOut == 0)
{
TimeOut_UserCallback();
}
/* Clear DMA1 global flags */
DMA_ClearFlag(USARTx_TX_DMA_FLAG_GL);
DMA_ClearFlag(USARTx_RX_DMA_FLAG_GL);
/* Disable the DMA channels */
DMA_Cmd(USARTx_TX_DMA_CHANNEL, DISABLE);
DMA_Cmd(USARTx_RX_DMA_CHANNEL, DISABLE);
/* Disable the USART Tx DMA request */
USART_DMACmd(USARTx, USART_DMAReq_Tx, DISABLE);
/* Disable the USART Rx DMA requests */
USART_DMACmd(USARTx, USART_DMAReq_Rx, DISABLE);
/* DMA channel Tx of USART Configuration */
DMA_DeInit(USARTx_TX_DMA_CHANNEL);
DMA_InitStructure.DMA_PeripheralBaseAddr = USARTx_TDR_ADDRESS;
DMA_InitStructure.DMA_BufferSize = (uint16_t)CmdBuffer[0x01];
DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)TxBuffer;
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralDST;
DMA_InitStructure.DMA_Priority = DMA_Priority_High;
DMA_Init(USARTx_TX_DMA_CHANNEL, &DMA_InitStructure);
USART_DMACmd(USARTx, USART_DMAReq_Tx, ENABLE);
/* Clear the TC bit in the SR register by writing 0 to it */
USART_ClearFlag(USARTx, USART_FLAG_TC);
/* Enable DMA1 USART Tx Channel */
DMA_Cmd(USARTx_TX_DMA_CHANNEL, ENABLE);
/* Wait the USART DMA Tx transfer complete or time out */
TimeOut = USER_TIMEOUT;
while ((DMA_GetFlagStatus(USARTx_TX_DMA_FLAG_TC) == RESET)&&(TimeOut != 0x00))
{
}
if(TimeOut == 0)
{
TimeOut_UserCallback();
}
/* The software must wait until TC=1. The TC flag remains cleared during all data
transfers and it is set by hardware at the last frame’s end of transmission*/
TimeOut = USER_TIMEOUT;
while ((USART_GetFlagStatus(USARTx, USART_FLAG_TC) == RESET)&&(TimeOut != 0x00))
{
}
if(TimeOut == 0)
{
TimeOut_UserCallback();
}
/* Clear DMA global flags */
DMA_ClearFlag(USARTx_TX_DMA_FLAG_GL);
DMA_ClearFlag(USARTx_RX_DMA_FLAG_GL);
DMA_Cmd(USARTx_TX_DMA_CHANNEL, DISABLE);
/* Disable the USART Tx DMA requests */
USART_DMACmd(USARTx, USART_DMAReq_Tx, DISABLE);
CmdBuffer[0x00] = 0x00;
}
/* USART in Mode Receiver-------------------------------------------------*/
/* USART Receive Transaction command and the number of Bytes to receive */
if (CmdBuffer[0x00] != 0x00)
{
/* Wait the USART DMA Rx transfer complete or time out */
TimeOut = USER_TIMEOUT;
while ((DMA_GetFlagStatus(USARTx_RX_DMA_FLAG_TC) == RESET)&&(TimeOut != 0x00))
{}
if(TimeOut == 0)
{
TimeOut_UserCallback();
}
/* Clear DMA1 global flags */
DMA_ClearFlag(USARTx_TX_DMA_FLAG_GL);
DMA_ClearFlag(USARTx_RX_DMA_FLAG_GL);
/* Disable the DMA channels */
DMA_Cmd(USARTx_RX_DMA_CHANNEL, DISABLE);
/* Disable the USART Rx DMA requests */
USART_DMACmd(USARTx, USART_DMAReq_Rx, DISABLE);
/* At this Steep the USART send the ACK command (after Receive the transaction
command and the number of data to receive this parameter is mandatory
to configure the DMA_BufferSize in the second reception phase */
AckBuffer[0x00] = CmdBuffer[0x00];
AckBuffer[0x01] = CMD_ACK;
/* DMA channel Tx of USART Configuration */
DMA_DeInit(USARTx_TX_DMA_CHANNEL);
DMA_InitStructure.DMA_PeripheralBaseAddr = USARTx_TDR_ADDRESS;
DMA_InitStructure.DMA_BufferSize = (uint16_t)2;
DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)AckBuffer;
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralDST;
DMA_InitStructure.DMA_Priority = DMA_Priority_High;
DMA_Init(USARTx_TX_DMA_CHANNEL, &DMA_InitStructure);
USART_DMACmd(USARTx, USART_DMAReq_Tx, ENABLE);
/* Clear the TC bit in the SR register by writing 0 to it */
USART_ClearFlag(USARTx, USART_FLAG_TC);
/* Enable DMA1 USART Tx Channel */
DMA_Cmd(USARTx_TX_DMA_CHANNEL, ENABLE);
/* Wait the USART DMA Tx transfer complete or time out */
TimeOut = USER_TIMEOUT;
while ((DMA_GetFlagStatus(USARTx_TX_DMA_FLAG_TC) == RESET)&&(TimeOut != 0x00))
{}
if(TimeOut == 0)
{
TimeOut_UserCallback();
}
/* The software must wait until TC=1. The TC flag remains cleared during all data
transfers and it is set by hardware at the last frame’s end of transmission*/
TimeOut = USER_TIMEOUT;
while ((USART_GetFlagStatus(USARTx, USART_FLAG_TC) == RESET)&&(TimeOut != 0x00))
{
}
if(TimeOut == 0)
{
TimeOut_UserCallback();
}
/* Clear DMA1 global flags */
DMA_ClearFlag(USARTx_TX_DMA_FLAG_GL);
DMA_ClearFlag(USARTx_RX_DMA_FLAG_GL);
DMA_Cmd(USARTx_TX_DMA_CHANNEL, DISABLE);
/* Disable the USART Tx DMA requests */
USART_DMACmd(USARTx, USART_DMAReq_Tx, DISABLE);
/* The transmitter After receive the ACK command it sends the defined data
in his TxBuffer */
/* DMA channel Rx of USART Configuration */
DMA_DeInit(USARTx_RX_DMA_CHANNEL);
DMA_InitStructure.DMA_PeripheralBaseAddr = USARTx_RDR_ADDRESS;
DMA_InitStructure.DMA_BufferSize = (uint16_t)CmdBuffer[0x01];
DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t) RxBuffer;
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC;
DMA_InitStructure.DMA_Priority = DMA_Priority_Low;
DMA_Init(USARTx_RX_DMA_CHANNEL, &DMA_InitStructure);
USART_DMACmd(USARTx, USART_DMAReq_Rx , ENABLE);
/* Enable the DMA channel */
DMA_Cmd(USARTx_RX_DMA_CHANNEL, ENABLE);
/* Wait the USART DMA Rx transfer complete or time out */
TimeOut = USER_TIMEOUT;
while ((DMA_GetFlagStatus(USARTx_RX_DMA_FLAG_TC) == RESET)&&(TimeOut != 0x00))
{
}
if(TimeOut == 0)
{
TimeOut_UserCallback();
}
/* Clear DMA1 global flags */
DMA_ClearFlag(USARTx_TX_DMA_FLAG_GL);
DMA_ClearFlag(USARTx_RX_DMA_FLAG_GL);
/* Disable the DMA channels */
DMA_Cmd(USARTx_RX_DMA_CHANNEL, DISABLE);
/* Disable the USART Rx DMA requests */
USART_DMACmd(USARTx, USART_DMAReq_Rx, DISABLE);
switch (CmdBuffer[0x01])
{
/* CMD_RIGHT command received */
case CMD_RIGHT_SIZE:
if (Buffercmp(TxBuffer, RxBuffer, CMD_RIGHT_SIZE) != FAILED)
{
/* Turn ON LED2 and LED3 */
STM_EVAL_LEDOn(LED2);
STM_EVAL_LEDOn(LED3);
/* Turn OFF LED4 */
STM_EVAL_LEDOff(LED4);
}
break;
/* CMD_LEFT command received */
case CMD_LEFT_SIZE:
if (Buffercmp(TxBuffer, RxBuffer, CMD_LEFT_SIZE) != FAILED)
{
/* Turn ON LED4 */
STM_EVAL_LEDOn(LED4);
/* Turn OFF LED2 and LED3 */
STM_EVAL_LEDOff(LED2);
STM_EVAL_LEDOff(LED3);
}
break;
/* CMD_UP command received */
case CMD_UP_SIZE:
if (Buffercmp(TxBuffer, RxBuffer, CMD_UP_SIZE) != FAILED)
{
/* Turn ON LED2 */
STM_EVAL_LEDOn(LED2);
/* Turn OFF LED3 and LED4 */
STM_EVAL_LEDOff(LED3);
STM_EVAL_LEDOff(LED4);
}
break;
/* CMD_DOWN command received */
case CMD_DOWN_SIZE:
if (Buffercmp(TxBuffer, RxBuffer, CMD_DOWN_SIZE) != FAILED)
{
/* Turn ON LED3 */
STM_EVAL_LEDOn(LED3);
/* Turn OFF LED2 and LED4 */
STM_EVAL_LEDOff(LED2);
STM_EVAL_LEDOff(LED4);
}
break;
/* CMD_SEL command received */
case CMD_SEL_SIZE:
if (Buffercmp(TxBuffer, RxBuffer, CMD_SEL_SIZE) != FAILED)
{
/* Turn ON all LED2, LED3 and LED4 */
STM_EVAL_LEDOn(LED2);
STM_EVAL_LEDOn(LED3);
STM_EVAL_LEDOn(LED4);
}
break;
default:
break;
}
CmdBuffer[0x00] = 0x00;
}
}
}