/*
* Init all related hardware in here
* rt_hw_serial_init() will register all supported USART device
*/
void rt_hw_usart_init()
{
USART_InitTypeDef USART_InitStructure;
USART_ClockInitTypeDef USART_ClockInitStructure;
RCC_Configuration();
GPIO_Configuration();
NVIC_Configuration();
DMA_Configuration();
/* uart init */
#ifdef RT_USING_UART1
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;
USART_ClockInitStructure.USART_Clock = USART_Clock_Disable;
USART_ClockInitStructure.USART_CPOL = USART_CPOL_Low;
USART_ClockInitStructure.USART_CPHA = USART_CPHA_2Edge;
USART_ClockInitStructure.USART_LastBit = USART_LastBit_Disable;
USART_Init(USART1, &USART_InitStructure);
USART_ClockInit(USART1, &USART_ClockInitStructure);
/* register uart1 */
rt_hw_serial_register(&uart1_device, "uart1",
RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_INT_RX | RT_DEVICE_FLAG_STREAM,
&uart1);
/* enable interrupt */
USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);
#endif
#ifdef RT_USING_UART2
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;
USART_ClockInitStructure.USART_Clock = USART_Clock_Disable;
USART_ClockInitStructure.USART_CPOL = USART_CPOL_Low;
USART_ClockInitStructure.USART_CPHA = USART_CPHA_2Edge;
USART_ClockInitStructure.USART_LastBit = USART_LastBit_Disable;
USART_Init(USART2, &USART_InitStructure);
USART_ClockInit(USART2, &USART_ClockInitStructure);
/* register uart2 */
rt_hw_serial_register(&uart2_device, "uart2",
RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_INT_RX | RT_DEVICE_FLAG_STREAM,
&uart2);
/* Enable USART2 DMA Rx request */
USART_ITConfig(USART2, USART_IT_RXNE, ENABLE);
#endif
#ifdef RT_USING_UART3
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;
USART_ClockInitStructure.USART_Clock = USART_Clock_Disable;
USART_ClockInitStructure.USART_CPOL = USART_CPOL_Low;
USART_ClockInitStructure.USART_CPHA = USART_CPHA_2Edge;
USART_ClockInitStructure.USART_LastBit = USART_LastBit_Disable;
USART_Init(USART3, &USART_InitStructure);
USART_ClockInit(USART3, &USART_ClockInitStructure);
uart3_dma_tx.dma_channel= UART3_TX_DMA;
/* register uart3 */
rt_hw_serial_register(&uart3_device, "uart3",
RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_INT_RX | RT_DEVICE_FLAG_DMA_TX,
&uart3);
/* Enable USART3 DMA Tx request */
USART_DMACmd(USART3, USART_DMAReq_Tx , ENABLE);
/* enable interrupt */
USART_ITConfig(USART3, USART_IT_RXNE, ENABLE);
#endif
}
void led_init(void)
{
RCC_Configuration();
GPIO_Configuration();
}
/*
* Init all related hardware in here
* rt_hw_serial_init() will register all supported USART device
*/
void rt_hw_usart_init()
{
USART_InitTypeDef USART_InitStructure;
RCC_Configuration();
GPIO_Configuration();
NVIC_Configuration();
DMA_Configuration();
/* uart init */
#ifdef RT_USING_UART1
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;
USART_Init(USART1, &USART_InitStructure);
/* register uart1 */
rt_hw_serial_register(&uart1_device, "uart1",
RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_INT_RX | RT_DEVICE_FLAG_STREAM,
&uart1);
/* enable interrupt */
USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);
#endif
#ifdef RT_USING_UART2
USART_InitStructure.USART_BaudRate = 57600; //485
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;
USART_Init(USART2, &USART_InitStructure);
/* register uart2 */
rt_hw_serial_register(&uart2_device, "uart2",
RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_INT_RX | RT_DEVICE_FLAG_STREAM,
&uart2);
/* Enable USART2 DMA Rx request */
USART_ITConfig(USART2, USART_IT_RXNE, ENABLE);
#endif
#ifdef RT_USING_UART3
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;
USART_Init(USART3, &USART_InitStructure);
/* register uart3 */
//rt_hw_serial_register(&uart3_device, "uart3",
//RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_INT_RX | RT_DEVICE_FLAG_DMA_TX,
//&uart3);
rt_hw_serial_register(&uart3_device, "uart3",
RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_INT_RX | RT_DEVICE_FLAG_STREAM,
&uart3);
/* Enable USART3 DMA Tx request */
//USART_DMACmd(USART3, USART_DMAReq_Tx , ENABLE); //mask by nathan
/* enable interrupt */
USART_ITConfig(USART3, USART_IT_RXNE, ENABLE);
#endif
#ifdef RT_USING_UART4
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;
USART_Init(UART4, &USART_InitStructure);
/* register uart4 */
rt_hw_serial_register(&uart4_device, "uart4",
RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_INT_RX | RT_DEVICE_FLAG_STREAM,
&uart4);
/* enable interrupt */
USART_ITConfig(UART4, USART_IT_RXNE, ENABLE);
#endif
#ifdef RT_USING_UART5
USART_InitStructure.USART_BaudRate = 9600;
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;
USART_Init(UART5, &USART_InitStructure);
/* register uart1 */
rt_hw_serial_register(&uart5_device, "uart5",
RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_INT_RX | RT_DEVICE_FLAG_STREAM,
&uart5);
/* enable interrupt */
USART_ITConfig(UART5, USART_IT_RXNE, ENABLE);
#endif
}
void rt_hw_usart_init(void)
{
struct stm32_uart* uart;
struct serial_configure config = RT_SERIAL_CONFIG_DEFAULT;
RCC_Configuration();
GPIO_Configuration();
#if defined(RT_USING_UART1)
uart = &uart1;
config.baud_rate = BAUD_RATE_115200;
serial1.ops = &stm32_uart_ops;
serial1.config = config;
NVIC_Configuration(&uart1);
/* register UART1 device */
rt_hw_serial_register(&serial1, "uart1",
RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_INT_RX ,
uart);
#endif /* RT_USING_UART1 */
#if defined(RT_USING_UART2)
uart = &uart2;
config.baud_rate = BAUD_RATE_115200;
serial2.ops = &stm32_uart_ops;
serial2.config = config;
NVIC_Configuration(&uart2);
/* register UART1 device */
rt_hw_serial_register(&serial2, "uart2",
RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_INT_RX,
uart);
#endif /* RT_USING_UART2 */
#if defined(RT_USING_UART3)
uart = &uart3;
config.baud_rate = BAUD_RATE_115200;
serial3.ops = &stm32_uart_ops;
serial3.config = config;
NVIC_Configuration(&uart3);
/* register UART1 device */
rt_hw_serial_register(&serial3, "uart3",
RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_INT_RX,
uart);
#endif /* RT_USING_UART3 */
#if defined(RT_USING_UART4)
uart = &uart4;
config.baud_rate = BAUD_RATE_115200;
serial4.ops = &stm32_uart_ops;
serial4.config = config;
NVIC_Configuration(&uart4);
/* register UART4 device */
rt_hw_serial_register(&serial4, "uart4",
RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_INT_RX,
uart);
#endif /* RT_USING_UART4 */
}
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
*/
//================= Initialisation pin et interruptions =============================
GPIO_Configuration();
NVIC_Configuration(); /* Interrupt Config SDIO*/
EXTILine0_Config(); // Interrupt PA0
Timer2_Config(); //Configure timer2 1[s]
Init_Uart2(4800);
Init_Uart3(4800);
Init_SDCard(); //Mount sd card and use fat32 format
fileUart2 = initialiserFile(); //Init fifo pile
fileUart3 = initialiserFile(); //Init fifo pile
while(1) /* Infinite loop */
{
switch(etatBtBleu)
{
case START:
enableUsartIt();
GPIO_SetBits(GPIOD, GPIO_Pin_12); //Turn on green led
led_gr_blink = 1; //Activate the blink mod in an interruption
writeHeader(head_txt2, file2_path); //header for the usart2 file
writeHeader(head_txt3, file3_path); //header for the usart3 file
etatBtBleu = RUN;
break;
case STOP:
disableUsartIt(); //we will read the fifo pile so it's better to inibit usart interrupt
led_gr_blink = 0;
GPIO_ResetBits(GPIOD, GPIO_Pin_12); //green led off
GPIO_SetBits(GPIOD, GPIO_Pin_15); //blue led on
writeDynamicTabData(pullN(fileUart2, nbCaractUart2), nbCaractUart2, file2_path); //write all the fifo's uart2 data
writeDynamicTabData(pullN(fileUart3, nbCaractUart3), nbCaractUart3, file3_path); //write all the fifo's uart3 data
GPIO_ResetBits(GPIOD, GPIO_Pin_15); //blue led off
nbCaractUart2 = 0;
nbCaractUart3 = 0;
etatBtBleu=WAIT;
break;
case RUN:
//=========== write data when we have NB_CARACT_STOCK into the usart2 fifo pile =============
if(flag_fileUart2Ready)
{
flag_fileUart2Ready=0;
writeDynamicTabData(pullN(fileUart2, NB_CARACT_STOCK), NB_CARACT_STOCK, file2_path); //write NB_CARACT_STOCK of uart2 data
GPIO_ResetBits(GPIOD, GPIO_Pin_15); //blue led off
}
//=========== write data when we have NB_CARACT_STOCK into the usart3 fifo pile =============
if(flag_fileUart3Ready)
{
flag_fileUart3Ready = 0;
writeDynamicTabData(pullN(fileUart3, NB_CARACT_STOCK), NB_CARACT_STOCK, file3_path); //write NB_CARACT_STOCK of uart3 data
GPIO_ResetBits(GPIOD, GPIO_Pin_15); //blue led off
}
break;
}
}
}
/**
* @brief Main program
* @param None
* @retval None
*/
int main(void)
{
/* System clocks configuration ---------------------------------------------*/
RCC_Configuration();
/* GPIO configuration ------------------------------------------------------*/
GPIO_Configuration();
/* I2S peripheral configuration */
I2S_InitStructure.I2S_Standard = I2S_Standard_Phillips;
I2S_InitStructure.I2S_DataFormat = I2S_DataFormat_16bextended;
I2S_InitStructure.I2S_MCLKOutput = I2S_MCLKOutput_Disable;
I2S_InitStructure.I2S_AudioFreq = I2S_AudioFreq_48k;
I2S_InitStructure.I2S_CPOL = I2S_CPOL_Low;
/* I2S3 Master Transmitter to I2S2 Slave Receiver communication ------------*/
/* I2S3 configuration */
I2S_InitStructure.I2S_Mode = I2S_Mode_MasterTx;
I2S_Init(SPI3, &I2S_InitStructure);
/* I2S2 configuration */
I2S_InitStructure.I2S_Mode = I2S_Mode_SlaveRx;
I2S_Init(SPI2, &I2S_InitStructure);
/* Enable the I2S2 */
I2S_Cmd(SPI2, ENABLE);
/* Enable the I2S3 */
I2S_Cmd(SPI3, ENABLE);
/* Begin the communication in I2S mode */
while (RxIdx < BufferSize)
{
/* Wait the Tx buffer to be empty */
while (SPI_I2S_GetFlagStatus(SPI3, SPI_I2S_FLAG_TXE) == RESET)
{}
/* Send a data from I2S3 */
SPI_I2S_SendData(SPI3, I2S3_Buffer_Tx[TxIdx++]);
/* Wait the Rx buffer to be full */
while (SPI_I2S_GetFlagStatus(SPI2, SPI_I2S_FLAG_RXNE) == RESET)
{}
/* Store the I2S2 received data in the relative data table */
I2S2_Buffer_Rx[RxIdx++] = SPI_I2S_ReceiveData(SPI2);
}
TransferStatus1 = Buffercmp(I2S2_Buffer_Rx, I2S3_Buffer_Tx, BufferSize);
/* TransferStatus1 = PASSED, if the data transmitted from I2S3 and received by
I2S2 are the same
TransferStatus1 = FAILED, if the data transmitted from I2S3 and received by
I2S2 are different */
/* Reset TxIdx, RxIdx indexes */
TxIdx = 0;
RxIdx = 0;
/* Switch to SPI mode communication ----------------------------------------*/
/* SPI3 configuration */
SPI_InitStructure.SPI_Direction = SPI_Direction_1Line_Tx;
SPI_InitStructure.SPI_Mode = SPI_Mode_Master;
SPI_InitStructure.SPI_DataSize = SPI_DataSize_16b;
SPI_InitStructure.SPI_CPOL = SPI_CPOL_Low;
SPI_InitStructure.SPI_CPHA = SPI_CPHA_2Edge;
SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;
SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_4;
SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;
SPI_InitStructure.SPI_CRCPolynomial = 7;
SPI_Init(SPI3, &SPI_InitStructure);
/* SPI2 configuration ------------------------------------------------------*/
SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_RxOnly;
SPI_InitStructure.SPI_Mode = SPI_Mode_Slave;
SPI_Init(SPI2, &SPI_InitStructure);
/* Enable SPI2 */
SPI_Cmd(SPI2, ENABLE);
/* Enable SPI3 */
SPI_Cmd(SPI3, ENABLE);
/* Begin the communication in SPI mode */
while (RxIdx < BufferSize)
{
/* Wait the Tx buffer to be empty */
while (SPI_I2S_GetFlagStatus(SPI3, SPI_I2S_FLAG_TXE) == RESET)
{}
/* Send a data from SPI3 */
SPI_I2S_SendData(SPI3, SPI3_Buffer_Tx[TxIdx++]);
/* Wait the Rx buffer to be full */
while (SPI_I2S_GetFlagStatus(SPI2, SPI_I2S_FLAG_RXNE) == RESET)
{}
/* Store the SPI2 received data in the relative data table */
SPI2_Buffer_Rx[RxIdx++] = SPI_I2S_ReceiveData(SPI2);
}
TransferStatus2 = Buffercmp(SPI2_Buffer_Rx, SPI3_Buffer_Tx, BufferSize);
/* TransferStatus2 = PASSED, if the data transmitted from SPI3 and received by
SPI2 are the same
TransferStatus2 = FAILED, if the data transmitted from SPI3 and received by
SPI2 are different */
/* Reset TxIdx, RxIdx indexes and receive table values */
for (TxIdx = 0; TxIdx < BufferSize; TxIdx++)
{
I2S2_Buffer_Rx[TxIdx] = 0;
}
TxIdx = 0;
RxIdx = 0;
/* I2S3 Slave Transmitter to I2S2 Master Receiver communication ------------*/
/* I2S3 configuration */
I2S_InitStructure.I2S_Mode = I2S_Mode_SlaveTx;
I2S_Init(SPI3, &I2S_InitStructure);
/* I2S2 configuration */
I2S_InitStructure.I2S_Mode = I2S_Mode_MasterRx;
I2S_Init(SPI2, &I2S_InitStructure);
/* Wait the Tx buffer to be empty */
while (SPI_I2S_GetFlagStatus(SPI3, SPI_I2S_FLAG_TXE) == RESET)
{}
/* Prepare the first data to be sent from the slave */
SPI_I2S_SendData(SPI3, I2S3_Buffer_Tx[TxIdx++]);
/* Enable the I2S3 */
I2S_Cmd(SPI3, ENABLE);
/* Enable the I2S2 */
I2S_Cmd(SPI2, ENABLE);
/* Begin the communication in I2S mode */
while (RxIdx < BufferSize)
{
/* Wait the Rx buffer to be full */
while (SPI_I2S_GetFlagStatus(SPI2, SPI_I2S_FLAG_RXNE) == RESET)
{}
/* Store the I2S2 received data in the relative data table */
I2S2_Buffer_Rx[RxIdx++] = SPI_I2S_ReceiveData(SPI2);
/* Wait the Tx buffer to be empty */
while (SPI_I2S_GetFlagStatus(SPI3, SPI_I2S_FLAG_TXE) == RESET)
{}
/* Send a data from I2S3 */
SPI_I2S_SendData(SPI3, I2S3_Buffer_Tx[TxIdx++]);
}
TransferStatus3 = Buffercmp(I2S2_Buffer_Rx, I2S3_Buffer_Tx, BufferSize);
/* TransferStatus3 = PASSED, if the data transmitted from I2S3 and received by
I2S2 are the same
TransferStatus3 = FAILED, if the data transmitted from I2S3 and received by
I2S2 are different */
while (1)
{}
}
/**
* @brief Main program
* @param None
* @retval None
*/
int main(void)
{
/* System Clocks Configuration */
RCC_Configuration();
/* Configure the GPIO ports */
GPIO_Configuration();
/* TIM4 configuration: One Pulse mode ------------------------
The external signal is connected to TIM4_CH2 pin (PA.01),
The Rising edge is used as active edge,
The One Pulse signal is output on TIM4_CH1 pin (PA.00)
The TIM_Pulse defines the delay value
The (TIM_Period - TIM_Pulse) defines the One Pulse value.
The TIM4CLK is fixed to 72 MHz, the Prescaler is 1, so the
TIM4 counter clock is 36 MHz.
The Autoreload value is 65535 (TIM4->ARR), so the maximum
frequency value to trigger the TIM4 input is 500 Hz.
The TIM_Pulse defines the delay value, the delay value is fixed
to 455.08 us:
delay = CCR1/TIM4 counter clock = 455.08 us.
The (TIM_Period - TIM_Pulse) defines the One Pulse value,
the pulse value is fixed to 1.365ms:
One Pulse value = (TIM_Period - TIM_Pulse)/TIM4 counter clock = 1.365 ms.
------------------------------------------------------------ */
/* Time base configuration */
TIM_TimeBaseStructure.TIM_Period = 65535;
TIM_TimeBaseStructure.TIM_Prescaler = 1;
TIM_TimeBaseStructure.TIM_ClockDivision = 0;
TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;
TIM_TimeBaseInit(TIM4, &TIM_TimeBaseStructure);
/* TIM4 PWM2 Mode configuration: Channel1 */
TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM2;
TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;
TIM_OCInitStructure.TIM_Pulse = 16383;
TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_High;
TIM_OC1Init(TIM4, &TIM_OCInitStructure);
/* TIM4 configuration in Input Capture Mode */
TIM_ICStructInit(&TIM_ICInitStructure);
TIM_ICInitStructure.TIM_Channel = TIM_Channel_2;
TIM_ICInitStructure.TIM_ICPolarity = TIM_ICPolarity_Rising;
TIM_ICInitStructure.TIM_ICSelection = TIM_ICSelection_DirectTI;
TIM_ICInitStructure.TIM_ICPrescaler = TIM_ICPSC_DIV1;
TIM_ICInitStructure.TIM_ICFilter = 0;
TIM_ICInit(TIM4, &TIM_ICInitStructure);
/* One Pulse Mode selection */
TIM_SelectOnePulseMode(TIM4, TIM_OPMode_Single);
/* Input Trigger selection */
TIM_SelectInputTrigger(TIM4, TIM_TS_TI2FP2);
/* Slave Mode selection: Trigger Mode */
TIM_SelectSlaveMode(TIM4, TIM_SlaveMode_Trigger);
while (1)
{}
}
/**
* @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
*/
SystemInit();
/* System clocks configuration ---------------------------------------------*/
RCC_Configuration();
/* GPIO configuration ------------------------------------------------------*/
GPIO_Configuration();
/* DMA1 channel1 configuration ----------------------------------------------*/
DMA_DeInit(DMA1_Channel1);
DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)&ADC1->DR;
DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)ADCConvertedValue;
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC;
DMA_InitStructure.DMA_BufferSize = 2;
DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_HalfWord;
DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_HalfWord;
DMA_InitStructure.DMA_Mode = DMA_Mode_Circular;
DMA_InitStructure.DMA_Priority = DMA_Priority_High;
DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;
DMA_Init(DMA1_Channel1, &DMA_InitStructure);
/* Enable DMA1 channel1 */
DMA_Cmd(DMA1_Channel1, ENABLE);
/* ADC1 configuration ------------------------------------------------------*/
ADC_InitStructure.ADC_Mode = ADC_Mode_Independent;
ADC_InitStructure.ADC_ScanConvMode = ENABLE;
ADC_InitStructure.ADC_ContinuousConvMode = DISABLE;
ADC_InitStructure.ADC_ExternalTrigConv = ADC_ExternalTrigConv_None;
ADC_InitStructure.ADC_DataAlign = ADC_DataAlign_Right;
ADC_InitStructure.ADC_NbrOfChannel = 2;
ADC_Init(ADC1, &ADC_InitStructure);
/* ADC1 regular channel0 configuration */
ADC_RegularChannelConfig(ADC1, ADC_Channel_2, 1, ADC_SampleTime_55Cycles5);
ADC_RegularChannelConfig(ADC1, ADC_Channel_3, 2, ADC_SampleTime_55Cycles5);
/* Enable ADC1 DMA */
ADC_DMACmd(ADC1, ENABLE);
/* Enable ADC1 */
ADC_Cmd(ADC1, ENABLE);
/* Enable ADC1 reset calibration register */
ADC_ResetCalibration(ADC1);
/* Check the end of ADC1 reset calibration register */
while(ADC_GetResetCalibrationStatus(ADC1));
/* Start ADC1 calibration */
ADC_StartCalibration(ADC1);
/* Check the end of ADC1 calibration */
while(ADC_GetCalibrationStatus(ADC1));
/* Start ADC1 Software Conversion */
ADC_SoftwareStartConvCmd(ADC1, ENABLE);
/* To achieve GPIO toggling maximum frequency, the following sequence is mandatory.
You can monitor PD0 or PD2 on the scope to measure the output signal.
If you need to fine tune this frequency, you can add more GPIO set/reset
cycles to minimize more the infinite loop timing.
This code needs to be compiled with high speed optimization option. */
/*Init LCD*/
LCD_Init();
while (1)
{
/* Start ADC1 Software Conversion */
ADC_SoftwareStartConvCmd(ADC1, ENABLE);
sprintf(LCD_Buffer,"ADC1=%d ",ADCConvertedValue[0]);
LCD_GotoXY(0,0);
LCD_PutStr(LCD_Buffer);
sprintf(LCD_Buffer,"ADC2=%d ",ADCConvertedValue[1]);
LCD_GotoXY(0,1);
LCD_PutStr(LCD_Buffer);
delay_ms(1000);
}
}
/**
* @brief Main program
* @param None
* @retval None
*/
int main(void)
{
/* System Clocks Configuration */
RCC_Configuration();
/* Configure the GPIO ports */
GPIO_Configuration();
/* Initialize Leds, Wakeup and Key Buttons mounted on STM3210X-EVAL board */
STM_EVAL_LEDInit(LED1);
STM_EVAL_LEDInit(LED2);
STM_EVAL_LEDInit(LED3);
STM_EVAL_LEDInit(LED4);
STM_EVAL_PBInit(Button_WAKEUP, Mode_EXTI);
STM_EVAL_PBInit(Button_KEY, Mode_EXTI);
/* USARTy and USARTz configuration -------------------------------------------*/
/* USARTy and USARTz configured as follow:
- BaudRate = 9600 baud
- Word Length = 9 Bits
- One Stop Bit
- No parity
- Hardware flow control disabled (RTS and CTS signals)
- Receive and transmit enabled
*/
USART_InitStructure.USART_BaudRate = 9600;
USART_InitStructure.USART_WordLength = USART_WordLength_9b;
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;
/* Configure USARTy */
USART_Init(USARTy, &USART_InitStructure);
/* Configure USARTz */
USART_Init(USARTz, &USART_InitStructure);
/* Enable the USARTy */
USART_Cmd(USARTy, ENABLE);
/* Enable the USARTz */
USART_Cmd(USARTz, ENABLE);
/* Set the USARTy Address */
USART_SetAddress(USARTy, 0x1);
/* Set the USARTz Address */
USART_SetAddress(USARTz, 0x2);
/* Select the USARTz WakeUp Method */
USART_WakeUpConfig(USARTz, USART_WakeUp_AddressMark);
while (1)
{
/* Send one byte from USARTy to USARTz */
USART_SendData(USARTy, 0x33);
/* Wait while USART1 TXE = 0 */
while(USART_GetFlagStatus(USARTz, USART_FLAG_TXE) == RESET)
{
}
if(USART_GetFlagStatus(USARTz, USART_FLAG_RXNE) != RESET)
{
if(USART_ReceiveData(USARTz) == 0x33)
{
STM_EVAL_LEDToggle(LED1);
Delay(0x5FFFF);
STM_EVAL_LEDToggle(LED2);
Delay(0x5FFFF);
STM_EVAL_LEDToggle(LED3);
Delay(0x5FFFF);
STM_EVAL_LEDToggle(LED4);
Delay(0x5FFFF);
}
}
}
}
/**
* @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
*/
/* System Clocks Configuration */
RCC_Configuration();
/* Configure the GPIO ports */
GPIO_Configuration();
/* USARTy and USARTz configuration -------------------------------------------*/
/* USARTy and USARTz configured as follow:
- BaudRate = 230400 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 = 230400;
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;
/* Configure USARTy */
USART_Init(USARTy, &USART_InitStructure);
/* Configure USARTz */
USART_Init(USARTz, &USART_InitStructure);
/* Enable the USARTy */
USART_Cmd(USARTy, ENABLE);
/* Enable the USARTz */
USART_Cmd(USARTz, ENABLE);
/* Enable USARTy Half Duplex Mode*/
USART_HalfDuplexCmd(USARTy, ENABLE);
/* Enable USARTz Half Duplex Mode*/
USART_HalfDuplexCmd(USARTz, ENABLE);
while(NbrOfDataToRead2--)
{
/* Wait until end of transmit */
while(USART_GetFlagStatus(USARTy, USART_FLAG_TXE) == RESET)
{
}
/* Write one byte in the USARTy Transmit Data Register */
USART_SendData(USARTy, TxBuffer1[TxCounter1++]);
/* Wait the byte is entirtly received by USARTz */
while(USART_GetFlagStatus(USARTz, USART_FLAG_RXNE) == RESET)
{
}
/* Store the received byte in the RxBuffer2 */
RxBuffer2[RxCounter2++] = USART_ReceiveData(USARTz);
}
/* Clear the USARTy Data Register */
USART_ReceiveData(USARTy);
while(NbrOfDataToRead1--)
{
/* Wait until end of transmit */
while(USART_GetFlagStatus(USARTz, USART_FLAG_TXE)== RESET)
{
}
/* Write one byte in the USARTz Transmit Data Register */
USART_SendData(USARTz, TxBuffer2[TxCounter2++]);
/* Wait the byte is entirtly received by USARTy */
while(USART_GetFlagStatus(USARTy,USART_FLAG_RXNE) == RESET)
{
}
/* Store the received byte in the RxBuffer1 */
RxBuffer1[RxCounter1++] = USART_ReceiveData(USARTy);
}
/* Check the received data with the send ones */
TransferStatus1 = Buffercmp(TxBuffer1, RxBuffer2, TxBufferSize1);
/* TransferStatus = PASSED, if the data transmitted from USARTy and
received by USARTz are the same */
/* TransferStatus = FAILED, if the data transmitted from USARTy and
received by USARTz are different */
TransferStatus2 = Buffercmp(TxBuffer2, RxBuffer1, TxBufferSize2);
/* TransferStatus = PASSED, if the data transmitted from USARTz and
received by USARTy are the same */
/* TransferStatus = FAILED, if the data transmitted from USARTz and
received by USARTy are different */
while (1)
{
}
}
/**
* @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
*/
/* System Clocks Configuration */
RCC_Configuration();
/* Configure the GPIO ports */
GPIO_Configuration();
#ifndef USE_STM3210C_EVAL
/* Initialize JoyStick Button mounted on STM3210X-EVAL board */
STM_EVAL_PBInit(BUTTON_UP, BUTTON_MODE_GPIO);
STM_EVAL_PBInit(BUTTON_DOWN, BUTTON_MODE_GPIO);
STM_EVAL_PBInit(BUTTON_LEFT, BUTTON_MODE_GPIO);
STM_EVAL_PBInit(BUTTON_RIGHT, BUTTON_MODE_GPIO);
STM_EVAL_PBInit(BUTTON_SEL, BUTTON_MODE_GPIO);
#else
/* Configure the IO Expander */
if (IOE_Config())
{
/* IO Expander config error */
while(1);
}
#endif
/* USARTy configuration ------------------------------------------------------*/
/* USARTy configured as follow:
- BaudRate = 115200 baud
- Word Length = 8 Bits
- One Stop Bit
- No parity
- Hardware flow control disabled (RTS and CTS signals)
- Receive and transmit enabled
*/
USART_InitStructure.USART_BaudRate = 115200;
USART_InitStructure.USART_WordLength = USART_WordLength_8b;
USART_InitStructure.USART_StopBits = USART_StopBits_1;
USART_InitStructure.USART_Parity = USART_Parity_No ;
USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
/* Configure the USARTy */
USART_Init(USARTy, &USART_InitStructure);
/* Enable the USARTy */
USART_Cmd(USARTy, ENABLE);
/* Set the USARTy prescaler */
USART_SetPrescaler(USARTy, 0x1);
/* Configure the USARTy IrDA mode */
USART_IrDAConfig(USARTy, USART_IrDAMode_Normal);
/* Enable the USARTy IrDA mode */
USART_IrDACmd(USARTy, ENABLE);
while (1)
{
/* Read Key */
MyKey = ReadKey();
switch(MyKey)
{
case JOY_UP:
USART_SendData(USARTy, JOY_UP);
while(USART_GetFlagStatus(USARTy, USART_FLAG_TXE) == RESET)
{
}
break;
case JOY_DOWN:
USART_SendData(USARTy, JOY_DOWN);
while(USART_GetFlagStatus(USARTy, USART_FLAG_TXE) == RESET)
{
}
break;
case JOY_LEFT:
USART_SendData(USARTy, JOY_LEFT);
while(USART_GetFlagStatus(USARTy, USART_FLAG_TXE) == RESET)
{
}
break;
case JOY_RIGHT:
USART_SendData(USARTy, JOY_RIGHT);
while(USART_GetFlagStatus(USARTy, USART_FLAG_TXE) == RESET)
{
}
break;
case JOY_SEL:
USART_SendData(USARTy, JOY_SEL);
while(USART_GetFlagStatus(USARTy, USART_FLAG_TXE) == RESET)
{
}
break;
case JOY_NONE:
USART_SendData(USARTy, JOY_NONE);
while(USART_GetFlagStatus(USARTy, USART_FLAG_TXE) == RESET)
{
}
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_stm32f10x_xx.s) before to branch to application main.
To reconfigure the default setting of SystemInit() function, refer to
system_stm32f10x.c file
*/
/* System clocks configuration ---------------------------------------------*/
RCC_Configuration();
/* 1st phase: SPIy Master and SPIz Slave */
/* GPIO configuration ------------------------------------------------------*/
GPIO_Configuration(SPI_Mode_Master, SPI_Mode_Slave);
/* SPIy Config -------------------------------------------------------------*/
SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
SPI_InitStructure.SPI_Mode = SPI_Mode_Master;
SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;
SPI_InitStructure.SPI_CPOL = SPI_CPOL_Low;
SPI_InitStructure.SPI_CPHA = SPI_CPHA_2Edge;
SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;
SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_4;
SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_LSB;
SPI_InitStructure.SPI_CRCPolynomial = 7;
SPI_Init(SPIy, &SPI_InitStructure);
/* SPIz Config -------------------------------------------------------------*/
SPI_InitStructure.SPI_Mode = SPI_Mode_Slave;
SPI_Init(SPIz, &SPI_InitStructure);
/* Enable SPIy */
SPI_Cmd(SPIy, ENABLE);
/* Enable SPIz */
SPI_Cmd(SPIz, ENABLE);
/* Transfer procedure */
while (TxIdx < BufferSize)
{
/* Wait for SPIy Tx buffer empty */
while (SPI_I2S_GetFlagStatus(SPIy, SPI_I2S_FLAG_TXE) == RESET);
/* Send SPIz data */
SPI_I2S_SendData(SPIz, SPIz_Buffer_Tx[TxIdx]);
/* Send SPIy data */
SPI_I2S_SendData(SPIy, SPIy_Buffer_Tx[TxIdx++]);
/* Wait for SPIz data reception */
while (SPI_I2S_GetFlagStatus(SPIz, SPI_I2S_FLAG_RXNE) == RESET);
/* Read SPIz received data */
SPIz_Buffer_Rx[RxIdx] = SPI_I2S_ReceiveData(SPIz);
/* Wait for SPIy data reception */
while (SPI_I2S_GetFlagStatus(SPIy, SPI_I2S_FLAG_RXNE) == RESET);
/* Read SPIy received data */
SPIy_Buffer_Rx[RxIdx++] = SPI_I2S_ReceiveData(SPIy);
}
/* Check the correctness of written dada */
TransferStatus1 = Buffercmp(SPIz_Buffer_Rx, SPIy_Buffer_Tx, BufferSize);
TransferStatus2 = Buffercmp(SPIy_Buffer_Rx, SPIz_Buffer_Tx, BufferSize);
/* TransferStatus1, TransferStatus2 = PASSED, if the transmitted and received data
are equal */
/* TransferStatus1, TransferStatus2 = FAILED, if the transmitted and received data
are different */
/* 2nd phase: SPIy Slave and SPIz Master */
/* GPIO configuration ------------------------------------------------------*/
GPIO_Configuration(SPI_Mode_Slave , SPI_Mode_Master);
/* SPIy Re-configuration ---------------------------------------------------*/
SPI_InitStructure.SPI_Mode = SPI_Mode_Slave;
SPI_Init(SPIy, &SPI_InitStructure);
/* SPIz Re-configuration ---------------------------------------------------*/
SPI_InitStructure.SPI_Mode = SPI_Mode_Master;
SPI_Init(SPIz, &SPI_InitStructure);
/* Reset TxIdx, RxIdx indexes and receive tables values */
TxIdx = 0;
RxIdx = 0;
for (k = 0; k < BufferSize; k++) SPIz_Buffer_Rx[k] = 0;
for (k = 0; k < BufferSize; k++) SPIy_Buffer_Rx[k] = 0;
/* Transfer procedure */
while (TxIdx < BufferSize)
{
/* Wait for SPIz Tx buffer empty */
while (SPI_I2S_GetFlagStatus(SPIz, SPI_I2S_FLAG_TXE) == RESET);
/* Send SPIy data */
SPI_I2S_SendData(SPIy, SPIy_Buffer_Tx[TxIdx]);
/* Send SPIz data */
SPI_I2S_SendData(SPIz, SPIz_Buffer_Tx[TxIdx++]);
/* Wait for SPIy data reception */
while (SPI_I2S_GetFlagStatus(SPIy, SPI_I2S_FLAG_RXNE) == RESET);
/* Read SPIy received data */
SPIy_Buffer_Rx[RxIdx] = SPI_I2S_ReceiveData(SPIy);
/* Wait for SPIz data reception */
while (SPI_I2S_GetFlagStatus(SPIz, SPI_I2S_FLAG_RXNE) == RESET);
/* Read SPIz received data */
SPIz_Buffer_Rx[RxIdx++] = SPI_I2S_ReceiveData(SPIz);
}
/* Check the correctness of written dada */
TransferStatus3 = Buffercmp(SPIz_Buffer_Rx, SPIy_Buffer_Tx, BufferSize);
TransferStatus4 = Buffercmp(SPIy_Buffer_Rx, SPIz_Buffer_Tx, BufferSize);
/* TransferStatus3, TransferStatus4 = PASSED, if the transmitted and received data
are equal */
/* TransferStatus3, TransferStatus4 = FAILED, if the transmitted and received data
are different */
while (1)
{}
}
/**
* @brief Main program.
* @param None
* @retval None
*/
int main(void)
{
/* Configure System clocks -----------------------------------------------*/
RCC_Configuration();
/* Configure NVIC --------------------------------------------------------*/
NVIC_Configuration();
/* Configure GPIO ports --------------------------------------------------*/
GPIO_Configuration();
/* Configure TIM2 --------------------------------------------------------*/
/* Configure Time Base */
TIMER_BaseStructInit(&TIM_TimeBaseStructure);
TIM_TimeBaseStructure.TIMER_Period = 256;
TIM_TimeBaseStructure.TIMER_Prescaler = 6;
TIM_TimeBaseStructure.TIMER_ClockDivision = 0x0;
TIM_TimeBaseStructure.TIMER_CounterMode = TIMER_COUNTER_UP;
TIMER_BaseInit(TIMER2, &TIM_TimeBaseStructure);
/* Configure TIM2 channel2 in PWM mode */
TIM_OCInitStructure.TIMER_OCMode = TIMER_OC_MODE_PWM1;
TIM_OCInitStructure.TIMER_OutputState = TIMER_OUTPUT_STATE_ENABLE;
TIM_OCInitStructure.TIMER_Pulse = 128;
TIM_OCInitStructure.TIMER_OCPolarity = TIMER_OC_POLARITY_LOW;
TIMER_OC2_Init(TIMER2, &TIM_OCInitStructure);
/* Configure DMA1 Channel1 -----------------------------------------------*/
DMA_DeInit(DMA1_CHANNEL1);
DMA_InitStructure.DMA_PeripheralBaseAddr = ADC_RDTR_Address;
DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)ADC_RegularConvertedValueTab;
DMA_InitStructure.DMA_DIR = DMA_DIR_PERIPHERALSRC;
DMA_InitStructure.DMA_BufferSize = 64;
DMA_InitStructure.DMA_PeripheralInc = DMA_PERIPHERALINC_DISABLE;
DMA_InitStructure.DMA_MemoryInc = DMA_MEMORYINC_ENABLE;
DMA_InitStructure.DMA_PeripheralDataSize = DMA_PERIPHERALDATASIZE_HALFWORD;
DMA_InitStructure.DMA_MemoryDataSize = DMA_MEMORYDATASIZE_HALFWORD;
DMA_InitStructure.DMA_Mode = DMA_MODE_NORMAL;
DMA_InitStructure.DMA_Priority = DMA_PRIORITY_HIGH;
DMA_InitStructure.DMA_MTOM = DMA_MEMTOMEM_DISABLE;
DMA_Init(DMA1_CHANNEL1, &DMA_InitStructure);
/* Enable DMA1 channel1 */
DMA_Enable(DMA1_CHANNEL1, ENABLE);
/* Configure ADC ---------------------------------------------------------*/
ADC_InitStructure.ADC_Mode_Scan = ENABLE;
ADC_InitStructure.ADC_Mode_Continuous = DISABLE;
ADC_InitStructure.ADC_Trig_External = ADC_EXTERNAL_TRIGGER_MODE_T2_CC2;
ADC_InitStructure.ADC_Data_Align = ADC_DATAALIGN_RIGHT;
ADC_InitStructure.ADC_Channel_Number = 1;
ADC_Init(&ADC_InitStructure);
/* Configure ADC regular channel14 */
ADC_RegularChannel_Config(ADC_CHANNEL_14, 1, ADC_SAMPLETIME_55POINT5);
/* Set inserted sequencer length */
ADC_InsertedSequencerLength_Config(1);
/* Configure ADC inserted channel */
ADC_InsertedChannel_Config(ADC_CHANNEL_11, 1, ADC_SAMPLETIME_55POINT5);
/* Configure ADC inserted external trigger */
ADC_ExternalTrigInsertedConv_Config(ADC_EXTERNAL_TRIG_INSERTCONV_NONE);
/* Enable automatic inserted conversion start after regular one */
ADC_AutoInsertedConv_Enable(ENABLE);
/* Enable ADC DMA */
ADC_DMA_Enable(ENABLE);
/* Enable ADC external trigger */
ADC_ExternalTrigConv_Enable( ENABLE);
/* Enable EOIC interrupt */
ADC_INTConfig(ADC_INT_EOIC, ENABLE);
/* Enable ADC */
ADC_Enable(ENABLE);
ADC_Calibration();
/* TIM2 counter enable */
TIMER_Enable(TIMER2, ENABLE);
/* TIM2 main Output enable */
TIMER_CtrlPWMOutputs(TIMER2, ENABLE);
/* Test on channel1 transfer complete flag */
while(!DMA_GetBitState(DMA1_FLAG_TC1));
/* Clear channel1 transfer complete flag */
DMA_ClearBitState(DMA1_FLAG_TC1);
/* TIM2 counter disable */
TIMER_Enable(TIMER2, DISABLE);
/* Turn on the Led1 */
GD_EVAL_LEDOn(LED1);
while (1)
{
}
}
/**
* @brief Main program
* @param None
* @retval : None
*/
int main(void)
{
/* System clocks configuration ---------------------------------------------*/
RCC_Configuration();
/* GPIO configuration ------------------------------------------------------*/
GPIO_Configuration();
/* DMA1 channel1 configuration ----------------------------------------------*/
DMA_DeInit(DMA1_Channel1);
DMA_InitStructure.DMA_PeripheralBaseAddr = ADC1_DR_Address;
DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)&ADCConvertedValue;
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC;
DMA_InitStructure.DMA_BufferSize = 1;
DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Disable;
DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_HalfWord;
DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_HalfWord;
DMA_InitStructure.DMA_Mode = DMA_Mode_Circular;
DMA_InitStructure.DMA_Priority = DMA_Priority_High;
DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;
DMA_Init(DMA1_Channel1, &DMA_InitStructure);
/* Enable DMA1 channel1 */
DMA_Cmd(DMA1_Channel1, ENABLE);
/* ADC1 configuration ------------------------------------------------------*/
ADC_InitStructure.ADC_Mode = ADC_Mode_Independent;
ADC_InitStructure.ADC_ScanConvMode = ENABLE;
ADC_InitStructure.ADC_ContinuousConvMode = ENABLE;
ADC_InitStructure.ADC_ExternalTrigConv = ADC_ExternalTrigConv_None;
ADC_InitStructure.ADC_DataAlign = ADC_DataAlign_Right;
ADC_InitStructure.ADC_NbrOfChannel = 1;
ADC_Init(ADC1, &ADC_InitStructure);
/* ADC1 regular channel14 configuration */
ADC_RegularChannelConfig(ADC1, ADC_Channel_14, 1, ADC_SampleTime_55Cycles5);
/* Enable ADC1 DMA */
ADC_DMACmd(ADC1, ENABLE);
/* Enable ADC1 */
ADC_Cmd(ADC1, ENABLE);
/* Enable ADC1 reset calibaration register */
ADC_ResetCalibration(ADC1);
/* Check the end of ADC1 reset calibration register */
while(ADC_GetResetCalibrationStatus(ADC1));
/* Start ADC1 calibaration */
ADC_StartCalibration(ADC1);
/* Check the end of ADC1 calibration */
while(ADC_GetCalibrationStatus(ADC1));
/* Start ADC1 Software Conversion */
ADC_SoftwareStartConvCmd(ADC1, ENABLE);
while (1)
{
}
}
/*
* Init all related hardware in here
* rt_hw_serial_init() will register all supported USART device
*/
void rt_hw_usart_init()
{
struct stm32_uart* uart;
struct serial_configure config;
RCC_Configuration();
GPIO_Configuration();
DMA_Configuration();
/* uart init */
#ifdef RT_USING_UART1
uart = &uart1;
config.baud_rate = BAUD_RATE_115200;
config.bit_order = BIT_ORDER_LSB;
config.data_bits = DATA_BITS_8;
config.parity = PARITY_NONE;
config.stop_bits = STOP_BITS_1;
config.invert = NRZ_NORMAL;
serial1.ops = &stm32_uart_ops;
serial1.int_rx = &uart1_int_rx;
serial1.config = config;
NVIC_Configuration(&uart1);
/* register UART1 device */
rt_hw_serial_register(&serial1, "uart1",
RT_DEVICE_FLAG_RDWR |
RT_DEVICE_FLAG_INT_RX |
RT_DEVICE_FLAG_STREAM,
uart);
#endif
#ifdef RT_USING_UART2
uart = &uart2;
config.baud_rate = BAUD_RATE_115200;
config.bit_order = BIT_ORDER_LSB;
config.data_bits = DATA_BITS_8;
config.parity = PARITY_NONE;
config.stop_bits = STOP_BITS_1;
config.invert = NRZ_NORMAL;
serial2.ops = &stm32_uart_ops;
serial2.int_rx = &uart2_int_rx;
serial2.config = config;
NVIC_Configuration(&uart2);
/* register UART2 device */
rt_hw_serial_register(&serial2, "uart2",
RT_DEVICE_FLAG_RDWR |
RT_DEVICE_FLAG_INT_RX |
RT_DEVICE_FLAG_STREAM,
uart);
#endif
#ifdef RT_USING_UART3
uart = &uart3;
config.baud_rate = BAUD_RATE_115200;
config.bit_order = BIT_ORDER_LSB;
config.data_bits = DATA_BITS_8;
config.parity = PARITY_NONE;
config.stop_bits = STOP_BITS_1;
config.invert = NRZ_NORMAL;
serial3.ops = &stm32_uart_ops;
serial3.int_rx = &uart3_int_rx;
serial3.config = config;
NVIC_Configuration(&uart3);
/* register UART3 device */
rt_hw_serial_register(&serial3, "uart3",
RT_DEVICE_FLAG_RDWR |
RT_DEVICE_FLAG_INT_RX |
RT_DEVICE_FLAG_STREAM,
uart);
#endif
}
static void key_thread_entry(void *parameter)
{
rt_time_t next_delay;
struct rtgui_event_kbd kbd_event;
GPIO_Configuration();
// EXTI_Configuration();
// NVIC_Configuration();
/* init keyboard event */
RTGUI_EVENT_KBD_INIT(&kbd_event);
kbd_event.wid = RT_NULL;
kbd_event.mod = RTGUI_KMOD_NONE;
kbd_event.unicode = 0;
while (1)
{
next_delay = 10;
kbd_event.key = RTGUIK_UNKNOWN;
kbd_event.type = RTGUI_KEYDOWN;
if ( key_enter_GETVALUE() == 1 )
{
rt_thread_delay( next_delay*4 );
if (key_enter_GETVALUE() == 1)
{
/* HOME key */
rt_kprintf("key_home\n");
kbd_event.key = RTGUIK_HOME;
}
else
{
rt_kprintf("key_enter\n");
kbd_event.key = RTGUIK_RETURN;
}
}
if ( key_up_GETVALUE() == 1 )
{
rt_kprintf("key_up\n");
kbd_event.key = RTGUIK_UP;
}
if ( key_down_GETVALUE() == 1 )
{
rt_kprintf("key_down\n");
kbd_event.key = RTGUIK_DOWN;
}
if ( key_left_GETVALUE() == 1 )
{
rt_kprintf("key_left\n");
kbd_event.key = RTGUIK_LEFT;
}
if ( key_right_GETVALUE() == 1 )
{
rt_kprintf("key_right\n");
kbd_event.key = RTGUIK_RIGHT;
}
if(key_stop_GETVALUE() == 1)
{
rt_kprintf("key_stop\n");
}
if(key_menu_GETVALUE() == 1)
{
rt_kprintf("key_menu\n");
}
if (kbd_event.key != RTGUIK_UNKNOWN)
{
/* post down event */
rtgui_server_post_event(&(kbd_event.parent), sizeof(kbd_event));
next_delay = 10;
/* delay to post up event */
rt_thread_delay(next_delay);
/* post up event */
kbd_event.type = RTGUI_KEYUP;
rtgui_server_post_event(&(kbd_event.parent), sizeof(kbd_event));
}
/* wait next key press */
rt_thread_delay(next_delay);
}
}
/*******************************************************************************
* Function Name : main
* Description : Main program
* Input : None
* Output : None
* Return : None
*******************************************************************************/
int main(void)
{
#ifdef DEBUG
debug();
#endif
/* Configure the system clocks */
RCC_Configuration();
/* Configure GPIOs */
GPIO_Configuration();
/* Configures the EXTI Lines */
EXTI_Configuration();
#ifdef VECT_TAB_RAM
/* Set the Vector Table base location at 0x20000000 */
NVIC_SetVectorTable(NVIC_VectTab_RAM, 0x0);
#else /* VECT_TAB_FLASH */
/* Set the Vector Table base location at 0x08000000 */
NVIC_SetVectorTable(NVIC_VectTab_FLASH, 0x0);
#endif
NVIC_PriorityGroupConfig(NVIC_PriorityGroup_1);
NVIC_InitStructure.NVIC_IRQChannel = EXTI15_10_IRQChannel;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
NVIC_InitStructure.NVIC_IRQChannel = EXTI0_IRQChannel;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
NVIC_Init(&NVIC_InitStructure);
while (1)
{
if(LowPowerMode == 1)
{
LowPowerMode = 0;
/* Toggle GPIO_LED pin 6 */
GPIO_WriteBit(GPIO_LED, GPIO_Pin_6, (BitAction)(1 - GPIO_ReadOutputDataBit(GPIO_LED, GPIO_Pin_6)));
#ifdef WFISLEEPONEXIT
NVIC_SystemLPConfig(NVIC_LP_SLEEPONEXIT, ENABLE);
#endif
#ifdef WFISLEEPNOW
NVIC_SystemLPConfig(NVIC_LP_SLEEPONEXIT, DISABLE);
__WFI();
#endif
#ifdef WFESEVONPEND
NVIC_SystemLPConfig(NVIC_LP_SEVONPEND, ENABLE);
/* Boost the execution priority to 0: no further exception can be asserted */
NVIC_SETPRIMASK();
#ifdef RTC_Alarm_WFEWakeUp
/* Set the RTC Alarm interrupt after 6s */
RTC_SetAlarm(0xFFFFFFFA);
/* Wait until last write operation on RTC registers has finished */
RTC_WaitForLastTask();
/* Set the Counter to 0xFFFFFFF5 */
RTC_SetCounter(0xFFFFFFF5);
/* Wait until last write operation on RTC registers has finished */
RTC_WaitForLastTask();
#endif
__WFE();
#endif
#ifdef WFESEVONEVENT
NVIC_SystemLPConfig(NVIC_LP_SEVONPEND, DISABLE);
#ifdef RTC_Alarm_WFEWakeUp
/* Set the RTC Alarm interrupt after 6s */
RTC_SetAlarm(0xFFFFFFFA);
/* Wait until last write operation on RTC registers has finished */
RTC_WaitForLastTask();
/* Set the Counter to 0xFFFFFFF5 */
RTC_SetCounter(0xFFFFFFF5);
/* Wait until last write operation on RTC registers has finished */
RTC_WaitForLastTask();
#endif
__WFE();
#endif
}
Delay(0xFFFFF);
/* Toggle GPIO_LED pin 9 */
GPIO_WriteBit(GPIO_LED, GPIO_Pin_9, (BitAction)(1 - GPIO_ReadOutputDataBit(GPIO_LED, GPIO_Pin_9)));
}
}
/**
* @brief Main program.
* @param None
* @retval : None
*/
int main(void)
{
/* System Clocks Configuration */
RCC_Configuration();
/* NVIC configuration */
NVIC_Configuration();
/* Configure the GPIOs */
GPIO_Configuration();
/* Configure the USART1 */
USART_Configuration();
if (BKP_ReadBackupRegister(BKP_DR1) != 0xA5A5)
{
/* Backup data register value is not correct or not yet programmed (when
the first time the program is executed) */
printf("\r\n\n RTC not yet configured....");
/* RTC Configuration */
RTC_Configuration();
printf("\r\n RTC configured....");
/* Adjust time by values entred by the user on the hyperterminal */
Time_Adjust();
BKP_WriteBackupRegister(BKP_DR1, 0xA5A5);
}
else
{
/* Check if the Power On Reset flag is set */
if (RCC_GetFlagStatus(RCC_FLAG_PORRST) != RESET)
{
printf("\r\n\n Power On Reset occurred....");
}
/* Check if the Pin Reset flag is set */
else if (RCC_GetFlagStatus(RCC_FLAG_PINRST) != RESET)
{
printf("\r\n\n External Reset occurred....");
}
printf("\r\n No need to configure RTC....");
/* Wait for RTC registers synchronization */
RTC_WaitForSynchro();
/* Enable the RTC Second */
RTC_ITConfig(RTC_IT_SEC, ENABLE);
/* Wait until last write operation on RTC registers has finished */
RTC_WaitForLastTask();
}
#ifdef RTCClockOutput_Enable
/* Enable PWR and BKP clocks */
RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR | RCC_APB1Periph_BKP, ENABLE);
/* Allow access to BKP Domain */
PWR_BackupAccessCmd(ENABLE);
/* Disable the Tamper Pin */
BKP_TamperPinCmd(DISABLE); /* To output RTCCLK/64 on Tamper pin, the tamper
functionality must be disabled */
/* Enable RTC Clock Output on Tamper Pin */
BKP_RTCOutputConfig(BKP_RTCOutputSource_CalibClock);
#endif
/* Clear reset flags */
RCC_ClearFlag();
/* Display time in infinite loop */
Time_Show();
}
/**
* @brief Main program
* @param None
* @retval None
*/
int main(void)
{
/* System Clocks Configuration */
RCC_Configuration();
/* Configure the GPIO ports */
GPIO_Configuration();
/* USART1 and USART2 configuration */
USART_InitStructure.USART_BRR = 230400;
USART_InitStructure.USART_WL = USART_WL_8B;
USART_InitStructure.USART_STBits = USART_STBITS_1;
USART_InitStructure.USART_Parity = USART_PARITY_RESET;
USART_InitStructure.USART_HardwareFlowControl = USART_HARDWAREFLOWCONTROL_NONE;
USART_InitStructure.USART_RxorTx = USART_RXORTX_RX | USART_RXORTX_TX;
/* Configure USART1 */
USART_Init(USART1, &USART_InitStructure);
/* Configure USART2 */
USART_Init(USART2, &USART_InitStructure);
/* Enable USART1 */
USART_Enable(USART1, ENABLE);
/* Enable USART2 */
USART_Enable(USART2, ENABLE);
/* Enable USART1 Half Duplex Mode*/
USART_HalfDuplex_Enable(USART1, ENABLE);
/* Enable USART2 Half Duplex Mode*/
USART_HalfDuplex_Enable(USART2, ENABLE);
while(NbrOfDataToRead2--)
{
/* Wait until end of transmit */
while(USART_GetBitState(USART1, USART_FLAG_TBE) == RESET)
{
}
/* Write one byte in the USARTy Transmit Data Register */
USART_DataSend(USART1, TxBuffer1[TxCounter1++]);
/* Wait the byte is entirely received by USARTz */
while(USART_GetBitState(USART2, USART_FLAG_RBNE) == RESET)
{
}
/* Store the received byte in the RxBuffer2 */
RxBuffer2[RxCounter2++] = USART_DataReceive(USART2);
}
/* Clear the USARTy Data Register */
USART_DataReceive(USART1);
while(NbrOfDataToRead1--)
{
/* Wait until end of transmit */
while(USART_GetBitState(USART2, USART_FLAG_TBE)== RESET)
{
}
/* Write one byte in the USARTz Transmit Data Register */
USART_DataSend(USART2, TxBuffer2[TxCounter2++]);
/* Wait the byte is entirely received by USARTy */
while(USART_GetBitState(USART1,USART_FLAG_RBNE) == RESET)
{
}
/* Store the received byte in the RxBuffer1 */
RxBuffer1[RxCounter1++] = USART_DataReceive(USART1);
}
/* Check the received data with the send ones */
TransferStatus1 = Buffercmp(TxBuffer2, RxBuffer1, TxBufferSize2);
/* TransferStatus1 = PASSED, if the data transmitted from USART2 and
received by USART1 are the same */
/* TransferStatus1 = FAILED, if the data transmitted from USART2 and
received by USART1 are different */
TransferStatus2 = Buffercmp(TxBuffer1, RxBuffer2, TxBufferSize1);
/* TransferStatus2 = PASSED, if the data transmitted from USART1 and
received by USART2 are the same */
/* TransferStatus2 = FAILED, if the data transmitted from USART1 and
received by USART2 are different */
while (1)
{
}
}
/**
* @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
*/
/* System clocks configuration ---------------------------------------------*/
RCC_Configuration();
/* GPIO configuration ------------------------------------------------------*/
GPIO_Configuration();
/* DMA1 channel1 configuration ----------------------------------------------*/
DMA_DeInit(DMA1_Channel1);
DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)ADC1_DR_Address;
DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)ADC_DualConvertedValueTab;
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC;
DMA_InitStructure.DMA_BufferSize = 16;
DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Word;
DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Word;
DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;
DMA_InitStructure.DMA_Priority = DMA_Priority_High;
DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;
DMA_Init(DMA1_Channel1, &DMA_InitStructure);
/* Enable DMA1 Channel1 */
DMA_Cmd(DMA1_Channel1, ENABLE);
/* ADC1 configuration ------------------------------------------------------*/
ADC_InitStructure.ADC_Mode = ADC_Mode_RegSimult;
ADC_InitStructure.ADC_ScanConvMode = ENABLE;
ADC_InitStructure.ADC_ContinuousConvMode = ENABLE;
ADC_InitStructure.ADC_ExternalTrigConv = ADC_ExternalTrigConv_None;
ADC_InitStructure.ADC_DataAlign = ADC_DataAlign_Right;
ADC_InitStructure.ADC_NbrOfChannel = 2;
ADC_Init(ADC1, &ADC_InitStructure);
/* ADC1 regular channels configuration */
ADC_RegularChannelConfig(ADC1, ADC_Channel_14, 1, ADC_SampleTime_239Cycles5);
ADC_RegularChannelConfig(ADC1, ADC_Channel_17, 2, ADC_SampleTime_239Cycles5);
/* Enable ADC1 DMA */
ADC_DMACmd(ADC1, ENABLE);
/* ADC2 configuration ------------------------------------------------------*/
ADC_InitStructure.ADC_Mode = ADC_Mode_RegSimult;
ADC_InitStructure.ADC_ScanConvMode = ENABLE;
ADC_InitStructure.ADC_ContinuousConvMode = ENABLE;
ADC_InitStructure.ADC_ExternalTrigConv = ADC_ExternalTrigConv_None;
ADC_InitStructure.ADC_DataAlign = ADC_DataAlign_Right;
ADC_InitStructure.ADC_NbrOfChannel = 2;
ADC_Init(ADC2, &ADC_InitStructure);
/* ADC2 regular channels configuration */
ADC_RegularChannelConfig(ADC2, ADC_Channel_11, 1, ADC_SampleTime_239Cycles5);
ADC_RegularChannelConfig(ADC2, ADC_Channel_12, 2, ADC_SampleTime_239Cycles5);
/* Enable ADC2 external trigger conversion */
ADC_ExternalTrigConvCmd(ADC2, ENABLE);
/* Enable ADC1 */
ADC_Cmd(ADC1, ENABLE);
/* Enable Vrefint channel17 */
ADC_TempSensorVrefintCmd(ENABLE);
/* Enable ADC1 reset calibaration register */
ADC_ResetCalibration(ADC1);
/* Check the end of ADC1 reset calibration register */
while(ADC_GetResetCalibrationStatus(ADC1));
/* Start ADC1 calibaration */
ADC_StartCalibration(ADC1);
/* Check the end of ADC1 calibration */
while(ADC_GetCalibrationStatus(ADC1));
/* Enable ADC2 */
ADC_Cmd(ADC2, ENABLE);
/* Enable ADC2 reset calibaration register */
ADC_ResetCalibration(ADC2);
/* Check the end of ADC2 reset calibration register */
while(ADC_GetResetCalibrationStatus(ADC2));
/* Start ADC2 calibaration */
ADC_StartCalibration(ADC2);
/* Check the end of ADC2 calibration */
while(ADC_GetCalibrationStatus(ADC2));
/* Start ADC1 Software Conversion */
ADC_SoftwareStartConvCmd(ADC1, ENABLE);
/* Test on DMA1 channel1 transfer complete flag */
while(!DMA_GetFlagStatus(DMA1_FLAG_TC1));
/* Clear DMA1 channel1 transfer complete flag */
DMA_ClearFlag(DMA1_FLAG_TC1);
while (1)
{
}
}
/**
* @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
*/
/* System Clocks Configuration */
RCC_Configuration();
/* Configure the GPIO ports */
GPIO_Configuration();
/* USARTy and USARTz configuration ------------------------------------------------------*/
/* USARTy and USARTz configured as follow:
- BaudRate = 230400 baud
- Word Length = 8 Bits
- One Stop Bit
- Even parity
- Hardware flow control disabled (RTS and CTS signals)
- Receive and transmit enabled
*/
USART_InitStructure.USART_BaudRate = 230400;
USART_InitStructure.USART_WordLength = USART_WordLength_8b;
USART_InitStructure.USART_StopBits = USART_StopBits_1;
USART_InitStructure.USART_Parity = USART_Parity_Even;
USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
/* Configure USARTy */
USART_Init(USARTy, &USART_InitStructure);
/* Configure USARTz */
USART_Init(USARTz, &USART_InitStructure);
/* Enable the USARTy */
USART_Cmd(USARTy, ENABLE);
/* Enable the USARTz */
USART_Cmd(USARTz, ENABLE);
while(TxCounter < TxBufferSize)
{
/* Send one byte from USARTy to USARTz */
USART_SendData(USARTy, TxBuffer[TxCounter++]);
/* Loop until USARTy DR register is empty */
while(USART_GetFlagStatus(USARTy, USART_FLAG_TXE) == RESET)
{
}
/* Loop until the USARTz Receive Data Register is not empty */
while(USART_GetFlagStatus(USARTz, USART_FLAG_RXNE) == RESET)
{
}
/* Store the received byte in RxBuffer */
RxBuffer[RxCounter++] = (USART_ReceiveData(USARTz) & 0x7F);
}
/* Check the received data with the send ones */
TransferStatus = Buffercmp(TxBuffer, RxBuffer, TxBufferSize);
/* TransferStatus = PASSED, if the data transmitted from USARTy and
received by USARTz are the same */
/* TransferStatus = FAILED, if the data transmitted from USARTy and
received by USARTz are different */
while (1)
{
}
}
/**
* @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
*/
/* Configure the STM32_EVAL LED */
STM_EVAL_LEDInit(LED1);
STM_EVAL_LEDInit(LED2);
/* Turn Off LED1 and LED2 */
STM_EVAL_LEDOff(LED1);
STM_EVAL_LEDOff(LED2);
/* System Clocks Configuration */
RCC_Configuration();
/* Configure the GPIO ports */
GPIO_Configuration();
/* SPI_MASTER configuration ------------------------------------------------*/
SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
SPI_InitStructure.SPI_Mode = SPI_Mode_Master;
SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;
SPI_InitStructure.SPI_CPOL = SPI_CPOL_Low;
SPI_InitStructure.SPI_CPHA = SPI_CPHA_2Edge;
SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;
SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_8;
SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;
SPI_InitStructure.SPI_CRCPolynomial = CRCPolynomial;
SPI_Init(SPI_MASTER, &SPI_InitStructure);
/* SPI_SLAVE configuration -------------------------------------------------*/
SPI_InitStructure.SPI_Mode = SPI_Mode_Slave;
SPI_Init(SPI_SLAVE, &SPI_InitStructure);
/* SPI_MASTER_Rx_DMA_Channel configuration ---------------------------------*/
DMA_DeInit(SPI_MASTER_Rx_DMA_Channel);
DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)SPI_MASTER_DR_Base;
DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)SPI_MASTER_Buffer_Rx;
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC;
DMA_InitStructure.DMA_BufferSize = BufferSize;
DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;
DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;
DMA_InitStructure.DMA_Priority = DMA_Priority_High;
DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;
DMA_Init(SPI_MASTER_Rx_DMA_Channel, &DMA_InitStructure);
/* SPI_MASTER_Tx_DMA_Channel configuration ---------------------------------*/
DMA_DeInit(SPI_MASTER_Tx_DMA_Channel);
DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)SPI_MASTER_DR_Base;
DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)SPI_MASTER_Buffer_Tx;
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralDST;
DMA_InitStructure.DMA_Priority = DMA_Priority_Low;
DMA_Init(SPI_MASTER_Tx_DMA_Channel, &DMA_InitStructure);
/* SPI_SLAVE_Rx_DMA_Channel configuration ----------------------------------*/
DMA_DeInit(SPI_SLAVE_Rx_DMA_Channel);
DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)SPI_SLAVE_DR_Base;
DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)SPI_SLAVE_Buffer_Rx;
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC;
DMA_InitStructure.DMA_Priority = DMA_Priority_VeryHigh;
DMA_Init(SPI_SLAVE_Rx_DMA_Channel, &DMA_InitStructure);
/* SPI_SLAVE_Tx_DMA_Channel configuration ----------------------------------*/
DMA_DeInit(SPI_SLAVE_Tx_DMA_Channel);
DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)SPI_SLAVE_DR_Base;
DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)SPI_SLAVE_Buffer_Tx;
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralDST;
DMA_InitStructure.DMA_Priority = DMA_Priority_Medium;
DMA_Init(SPI_SLAVE_Tx_DMA_Channel, &DMA_InitStructure);
/* Enable SPI_MASTER DMA Tx request */
SPI_I2S_DMACmd(SPI_MASTER, SPI_I2S_DMAReq_Tx, ENABLE);
/* Enable SPI_MASTER DMA Rx request */
SPI_I2S_DMACmd(SPI_MASTER, SPI_I2S_DMAReq_Rx, ENABLE);
/* Enable SPI_SLAVE DMA Tx request */
SPI_I2S_DMACmd(SPI_SLAVE, SPI_I2S_DMAReq_Tx, ENABLE);
/* Enable SPI_SLAVE DMA Rx request */
SPI_I2S_DMACmd(SPI_SLAVE, SPI_I2S_DMAReq_Rx, ENABLE);
/* Enable SPI_MASTER CRC calculation */
SPI_CalculateCRC(SPI_MASTER, ENABLE);
/* Enable SPI_SLAVE CRC calculation */
SPI_CalculateCRC(SPI_SLAVE, ENABLE);
/* Enable SPI_SLAVE */
SPI_Cmd(SPI_SLAVE, ENABLE);
/* Enable SPI_MASTER */
SPI_Cmd(SPI_MASTER, ENABLE);
/* Enable DMA channels */
DMA_Cmd(SPI_MASTER_Rx_DMA_Channel, ENABLE);
DMA_Cmd(SPI_SLAVE_Rx_DMA_Channel, ENABLE);
DMA_Cmd(SPI_SLAVE_Tx_DMA_Channel, ENABLE);
DMA_Cmd(SPI_MASTER_Tx_DMA_Channel, ENABLE);
/* Transfer complete */
while(!DMA_GetFlagStatus(SPI_MASTER_Rx_DMA_FLAG));
while(!DMA_GetFlagStatus(SPI_SLAVE_Rx_DMA_FLAG));
while(!DMA_GetFlagStatus(SPI_SLAVE_Tx_DMA_FLAG));
while(!DMA_GetFlagStatus(SPI_MASTER_Tx_DMA_FLAG));
/* Wait for SPI_MASTER data reception: CRC transmitted by SPI_SLAVE */
while(SPI_I2S_GetFlagStatus(SPI_MASTER, SPI_I2S_FLAG_RXNE)==RESET);
/* Wait for SPI_SLAVE data reception: CRC transmitted by SPI_MASTER */
while(SPI_I2S_GetFlagStatus(SPI_SLAVE, SPI_I2S_FLAG_RXNE)==RESET);
/* Check the corectness of written dada */
TransferStatus1 = Buffercmp(SPI_SLAVE_Buffer_Rx, SPI_MASTER_Buffer_Tx, BufferSize);
TransferStatus2 = Buffercmp(SPI_MASTER_Buffer_Rx, SPI_SLAVE_Buffer_Tx, BufferSize);
/* TransferStatus1, TransferStatus2 = PASSED, if the data transmitted and received
are correct */
/* TransferStatus1, TransferStatus2 = FAILED, if the data transmitted and received
are different */
/* Test on the SPI_MASTER CRCR ERROR flag */
if ((SPI_I2S_GetFlagStatus(SPI_MASTER, SPI_FLAG_CRCERR)) != RESET)
{
TransferStatus1 = FAILED;
}
/* Test on the SPI_SLAVE CRCR ERROR flag */
if ((SPI_I2S_GetFlagStatus(SPI_SLAVE, SPI_FLAG_CRCERR)) != RESET)
{
TransferStatus2 = FAILED;
}
/* Read SPI_MASTER received CRC value */
SPI_MASTERCRCValue = SPI_I2S_ReceiveData(SPI_MASTER);
/* Read SPI_SLAVE received CRC value */
SPI_SLAVECRCValue = SPI_I2S_ReceiveData(SPI_SLAVE);
if (TransferStatus1 != FAILED)
{
/* OK */
/* Turn on LD1 */
STM_EVAL_LEDOn(LED1);
}
else
{
/* KO */
/* Turn Off LD1 */
STM_EVAL_LEDOff(LED1);
}
if (TransferStatus2 != FAILED)
{
/* OK */
/* Turn on LD2 */
STM_EVAL_LEDOn(LED2);
}
else
{
/* KO */
/* Turn Off LD2 */
STM_EVAL_LEDOff(LED2);
}
while (1)
{
}
}
/*******************************************************************************
* Function Name : main
* Description : Main program.
* Input : None
* Output : None
* Return : None
*******************************************************************************/
int main(void)
{
uint16 i;
RCC_Configuration(); // Configure the system clocks
NVIC_Configuration(); // NVIC Configuration
GPIO_Configuration();
USART1_Init(115200);
Timer_Configuration();
printf("============================================\r\n");
printf(" HTTP client for W5200 \r\n");
printf("============================================\r\n");
WIZ_SPI_Init();
Reset_W5200();
wizInit();
InitNetInfo();
DisplayNetInfo();
// LED3 and LED4 On!
LED3_onoff(ON);
LED4_onoff(ON);
uint8 url[MAX_URL_SIZE]; //full url
uint8 url_dn[MAX_URL_SIZE]; //domain name url
uint8 url_path[MAX_URL_SIZE]; //local path in html server
char * split; //string split pointer
uint16 done_http = 0;
uint16 start_idx = 0 ;
uint16 end_idx = 0;
uint16 tmp_start;
uint16 tmp_end;
uint8 BR [4]= "<BR>";
uint8 rBR [4]= "\r\n";
uint8 TITLE [7]= "<TITLE>";
uint8 bTITLE [8]= "</TITLE>";
uint16 tmp_idx;
uint8 no_pr = 0;
uint8 str[17];
while (1)
{
sprintf((char*)str,"%.3d.%.3d.%.3d.%.3d ",
IINCHIP_READ (SIPR0+0), IINCHIP_READ (SIPR0+1),
IINCHIP_READ (SIPR0+2), IINCHIP_READ (SIPR0+3));
/* Get Http Address */
printf("\r\n Please enter a HTTP Address without 'http://' \n\r");
printf("http://");
memset(url,0,sizeof(url));
//Modified by Gang 2011-10-04
zScanf_s(1, url);
printf("\r\n Your HTTP address is: %s \r\n",url);
/* Parse URL Path */
split = strchr((char const*)url,'/');
strcpy((char*)url_path,split);
printf("Domain path: %s \r\n",url_path);
/* Parse URL Domain */
split = strtok((char*)url,"/");
strcpy((char*)url_dn,split);
printf("Domain name: %s \r\n",url_dn);
/* Do DNS Client */
memset(httpclient_NetInfo.HTTPs_IP,0,sizeof(httpclient_NetInfo.HTTPs_IP));
//Delay_ms(10);
done_dns = dns_query(DNS_SOCK, url_dn, httpclient_NetInfo.HTTPs_IP);
printf("\r\n HTTPs_IP= %d.%d.%d.%d",httpclient_NetInfo.HTTPs_IP[0],httpclient_NetInfo.HTTPs_IP[1],httpclient_NetInfo.HTTPs_IP[2],httpclient_NetInfo.HTTPs_IP[3]);
while(done_dns) {
/* Do HTTP Client */
done_http = http_client(HTTPC_SOCK, httpclient_NetInfo.HTTPs_IP, url_path, url_dn,data_buf);
if(done_http) { // on success, done_dns is not '0'
#define Recieved_DATA
#ifdef Recieved_DATA
printf("\r\n<< Recieved Data -- START>> \r\n");
for(i=0; i<done_http; i++){
printf("%c",(uint8)data_buf[i]);
}
printf("\r\n");
printf("<< Recieved Data -- END>> \r\n");
#endif
/* parsed index */
//All other HTML elements are nested between the opening <html> and </html> tags.
start_idx = pased_idx((uint8 *)str_start , sizeof(str_start), done_http );
end_idx = pased_idx((uint8 *)str_end , sizeof(str_end), done_http );
/* printf get <html> ...</html> */
for(i=start_idx; i<(end_idx+7); i++){
/* remove header */
data_buf[i-start_idx] = data_buf[i];
}
printf("\r\n");
/* replace <br> tag to \r\n */
//The br tag is used for specifying a line break.
do{
tmp_idx = pased_idx((uint8*)BR, sizeof(BR) , end_idx-start_idx) ;
if(tmp_idx == 0 )
break;
memcpy((uint8 *)data_buf+tmp_idx, (uint8*)rBR, sizeof(rBR)) ;
}while(tmp_idx!=end_idx-start_idx);
#define Parsed_DATA
#ifdef Parsed_DATA
/* parsed DATA */
printf("\r\n<< Parsed Data -- START >>");
printf("\r\nTITLE : \r\n");
/* parse <TITLE> and </TITLE> tags */
tmp_start = pased_idx((uint8 *)TITLE , sizeof(TITLE),(end_idx-start_idx) ) + sizeof(TITLE);
tmp_end = pased_idx((uint8 *)bTITLE , sizeof(bTITLE),(end_idx-start_idx) );
for(i=tmp_start; i<tmp_end; i++){
printf("%c",(uint8)data_buf[i]); // printf title
}
printf("\r\n BODY : \r\n");
/*DO NOT PRINT TAG COMMAND: between '<' with '>' */
for(i=tmp_end; i<(end_idx-start_idx); i++){
//Tag command - ex.)<PRE>
//'<' is a start point of tag command.
if((uint8)data_buf[i]=='<'){
no_pr = 0;
}
//'>' is a end point of Tag command.
//To avoid in row tags -> ex.) <PRE><H1>
if((uint8)data_buf[i]=='>' && (uint8)data_buf[i+1] !='<' ) {
no_pr = 1;
i++;
}
if(no_pr){
Delay_ms(1);
printf("%c",(uint8)data_buf[i]);
}
}
printf("\r\n<< Parsed Data -- END >>\r\n");
#endif
/* Init. parameter */
start_idx= 0;
end_idx= 0;
done_dns = 0;
break;
}
//done_http
//done_dns=0;
}//while : done_dns == 1
}
}
/*******************************************************************************
* Function Name : main
* Description : Main program
* Input : None
* Output : None
* Return : None
*******************************************************************************/
int main(void)
{
#ifdef DEBUG
debug();
#endif
/* System Clocks Configuration */
RCC_Configuration();
/* NVIC configuration */
NVIC_Configuration();
/* Configure the GPIO ports */
GPIO_Configuration();
/* ---------------------------------------------------------------
TIM2 Configuration: generate 4 signals with 4 different delays:
TIM2CLK = 36 MHz, Prescaler = 35999, TIM2 counter clock = 1 KHz
TIM2_CH1 delay = CCR1_Val/TIM2 counter clock = 1000 ms
TIM2_CH2 delay = CCR2_Val/TIM2 counter clock = 500 ms
TIM2_CH3 delay = CCR3_Val/TIM2 counter clock = 250 ms
TIM2_CH4 delay = CCR4_Val/TIM2 counter clock = 125 ms
--------------------------------------------------------------- */
/* Time base configuration */
TIM_TimeBaseStructure.TIM_Period = 65535;
TIM_TimeBaseStructure.TIM_Prescaler = 35999;
TIM_TimeBaseStructure.TIM_ClockDivision = 0;
TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;
TIM_TimeBaseInit(TIM2, &TIM_TimeBaseStructure);
/* Output Compare Active Mode configuration: Channel1 */
TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_Active;
TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;
TIM_OCInitStructure.TIM_Pulse = CCR1_Val;
TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_High;
TIM_OC1Init(TIM2, &TIM_OCInitStructure);
TIM_OC1PreloadConfig(TIM2, TIM_OCPreload_Disable);
/* Output Compare Active Mode configuration: Channel2 */
TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;
TIM_OCInitStructure.TIM_Pulse = CCR2_Val;
TIM_OC2Init(TIM2, &TIM_OCInitStructure);
TIM_OC2PreloadConfig(TIM2, TIM_OCPreload_Disable);
/* Output Compare Active Mode configuration: Channel3 */
TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;
TIM_OCInitStructure.TIM_Pulse = CCR3_Val;
TIM_OC3Init(TIM2, &TIM_OCInitStructure);
TIM_OC3PreloadConfig(TIM2, TIM_OCPreload_Disable);
/* Output Compare Active Mode configuration: Channel4 */
TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;
TIM_OCInitStructure.TIM_Pulse = CCR4_Val;
TIM_OC4Init(TIM2, &TIM_OCInitStructure);
TIM_OC4PreloadConfig(TIM2, TIM_OCPreload_Disable);
TIM_ARRPreloadConfig(TIM2, ENABLE);
/* Set PC.06 pin */
GPIO_SetBits(GPIOC, GPIO_Pin_6);
/* TIM2 enable counter */
TIM_Cmd(TIM2, ENABLE);
while (1)
{}
}
/**
* @brief Main program.
* @param None
* @retval None
*/
int main(void)
{
/* System Clocks Configuration */
RCC_Configuration();
/* Once the DAC channel is enabled, the corresponding GPIO pin is automatically
connected to the DAC converter. In order to avoid parasitic consumption,
the GPIO pin should be configured in analog */
GPIO_Configuration();
/* TIM2 Configuration */
/* Time base configuration */
TIM_TimeBaseStructInit(&TIM_TimeBaseStructure);
TIM_TimeBaseStructure.TIM_Period = 0x19;
TIM_TimeBaseStructure.TIM_Prescaler = 0x0;
TIM_TimeBaseStructure.TIM_ClockDivision = 0x0;
TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;
TIM_TimeBaseInit(TIM2, &TIM_TimeBaseStructure);
/* TIM2 TRGO selection */
TIM_SelectOutputTrigger(TIM2, TIM_TRGOSource_Update);
/* DAC channel1 Configuration */
DAC_InitStructure.DAC_Trigger = DAC_Trigger_T2_TRGO;
DAC_InitStructure.DAC_WaveGeneration = DAC_WaveGeneration_None;
DAC_InitStructure.DAC_OutputBuffer = DAC_OutputBuffer_Disable;
DAC_Init(DAC_Channel_1, &DAC_InitStructure);
/* DAC channel2 Configuration */
DAC_Init(DAC_Channel_2, &DAC_InitStructure);
/* Fill Sine32bit table */
for (Idx = 0; Idx < 32; Idx++)
{
DualSine12bit[Idx] = (Sine12bit[Idx] << 16) + (Sine12bit[Idx]);
}
/* DMA2 channel4 configuration */
DMA_DeInit(DMA2_Channel4);
DMA_InitStructure.DMA_PeripheralBaseAddr = DAC_DHR12RD_Address;
DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)&DualSine12bit;
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralDST;
DMA_InitStructure.DMA_BufferSize = 32;
DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Word;
DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Word;
DMA_InitStructure.DMA_Mode = DMA_Mode_Circular;
DMA_InitStructure.DMA_Priority = DMA_Priority_High;
DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;
DMA_Init(DMA2_Channel4, &DMA_InitStructure);
/* Enable DMA2 Channel4 */
DMA_Cmd(DMA2_Channel4, ENABLE);
/* Enable DAC Channel1: Once the DAC channel1 is enabled, PA.04 is
automatically connected to the DAC converter. */
DAC_Cmd(DAC_Channel_1, ENABLE);
/* Enable DAC Channel2: Once the DAC channel2 is enabled, PA.05 is
automatically connected to the DAC converter. */
DAC_Cmd(DAC_Channel_2, ENABLE);
/* Enable DMA for DAC Channel2 */
DAC_DMACmd(DAC_Channel_2, ENABLE);
/* TIM2 enable counter */
TIM_Cmd(TIM2, ENABLE);
while (1)
{
}
}
/**
* @brief .
* @param None
* @retval None
*/
void ILI_Configuration (void)
{
GPIO_Configuration ();
SPI_Configuration ();
ILI_Initial ();
}
/**
* @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
*/
/* System Clocks Configuration */
RCC_Configuration();
/* GPIO Configuration */
GPIO_Configuration();
/* TIM1 and Timers(TIM3 and TIM4) synchronisation in parallel mode -----------
1/TIM1 is configured as Master Timer:
- PWM Mode is used
- The TIM1 Update event is used as Trigger Output
2/TIM3 and TIM4 are slaves for TIM1,
- PWM Mode is used
- The ITR0(TIM1) is used as input trigger for both slaves
- Gated mode is used, so starts and stops of slaves counters
are controlled by the Master trigger output signal(update event).
o For Low-density, Medium-density, High-density and Connectivity line devices:
The TIMxCLK is fixed to 72 MHz, Prescaler = 0 so the TIM1 counter clock is 72 MHz.
The Master Timer TIM1 is running at:
TIM1 frequency = TIM1 counter clock / (TIM1_Period + 1) = 281.250 KHz
and the duty cycle is equal to: TIM1_CCR1/(TIM1_ARR + 1) = 50%
The TIM3 is running at:
(TIM1 frequency)/ ((TIM3 period +1)* (Repetition_Counter+1)) = 18.750 KHz and
a duty cycle equal to TIM3_CCR1/(TIM3_ARR + 1) = 33.3%
The TIM4 is running at:
(TIM1 frequency)/ ((TIM4 period +1)* (Repetition_Counter+1)) = 28.125 KHz and
a duty cycle equal to TIM4_CCR1/(TIM4_ARR + 1) = 50%
o For Low-Density Value line and Medium-Density Value line devices:
The TIMxCLK is fixed to 24 MHz, Prescaler = 0 so the TIM1 counter clock is 24 MHz.
TIM1 frequency = 93.75 KHz
TIM3 frequency = 6.25 KHz
TIM4 frequency = 9.375 KHz
--------------------------------------------------------------------------- */
/* TIM3 Peripheral Configuration ----------------------------------------*/
/* TIM3 Slave Configuration: PWM1 Mode */
TIM_TimeBaseStructure.TIM_Period = 2;
TIM_TimeBaseStructure.TIM_Prescaler = 0;
TIM_TimeBaseStructure.TIM_ClockDivision = 0;
TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;
TIM_TimeBaseInit(TIM3, &TIM_TimeBaseStructure);
TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM1;
TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;
TIM_OCInitStructure.TIM_Pulse = 1;
TIM_OC1Init(TIM3, &TIM_OCInitStructure);
/* Slave Mode selection: TIM3 */
TIM_SelectSlaveMode(TIM3, TIM_SlaveMode_Gated);
TIM_SelectInputTrigger(TIM3, TIM_TS_ITR0);
/* TIM4 Peripheral Configuration ----------------------------------------*/
/* TIM4 Slave Configuration: PWM1 Mode */
TIM_TimeBaseStructure.TIM_Period = 1;
TIM_TimeBaseStructure.TIM_Prescaler = 0;
TIM_TimeBaseStructure.TIM_ClockDivision = 0;
TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;
TIM_TimeBaseInit(TIM4, &TIM_TimeBaseStructure);
TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM1;
TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;
TIM_OCInitStructure.TIM_Pulse = 1;
TIM_OC1Init(TIM4, &TIM_OCInitStructure);
/* Slave Mode selection: TIM4 */
TIM_SelectSlaveMode(TIM4, TIM_SlaveMode_Gated);
TIM_SelectInputTrigger(TIM4, TIM_TS_ITR0);
/* TIM1 Peripheral Configuration ----------------------------------------*/
/* Time Base configuration */
TIM_TimeBaseStructure.TIM_Prescaler = 0;
TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;
TIM_TimeBaseStructure.TIM_Period = 255;
TIM_TimeBaseStructure.TIM_ClockDivision = 0;
TIM_TimeBaseStructure.TIM_RepetitionCounter = 4;
TIM_TimeBaseInit(TIM1, &TIM_TimeBaseStructure);
/* Channel 1 Configuration in PWM mode */
TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM2;
TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;
TIM_OCInitStructure.TIM_OutputNState = TIM_OutputNState_Enable;
TIM_OCInitStructure.TIM_Pulse = 127;
TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_Low;
TIM_OCInitStructure.TIM_OCNPolarity = TIM_OCNPolarity_Low;
TIM_OCInitStructure.TIM_OCIdleState = TIM_OCIdleState_Set;
TIM_OCInitStructure.TIM_OCNIdleState = TIM_OCIdleState_Reset;
TIM_OC1Init(TIM1, &TIM_OCInitStructure);
/* Automatic Output enable, Break, dead time and lock configuration*/
TIM_BDTRInitStructure.TIM_OSSRState = TIM_OSSRState_Enable;
TIM_BDTRInitStructure.TIM_OSSIState = TIM_OSSIState_Enable;
TIM_BDTRInitStructure.TIM_LOCKLevel = TIM_LOCKLevel_1;
TIM_BDTRInitStructure.TIM_DeadTime = 5;
TIM_BDTRInitStructure.TIM_Break = TIM_Break_Disable;
TIM_BDTRInitStructure.TIM_BreakPolarity = TIM_BreakPolarity_High;
TIM_BDTRInitStructure.TIM_AutomaticOutput = TIM_AutomaticOutput_Disable;
TIM_BDTRConfig(TIM1, &TIM_BDTRInitStructure);
/* Master Mode selection */
TIM_SelectOutputTrigger(TIM1, TIM_TRGOSource_Update);
/* Select the Master Slave Mode */
TIM_SelectMasterSlaveMode(TIM1, TIM_MasterSlaveMode_Enable);
/* TIM1 counter enable */
TIM_Cmd(TIM1, ENABLE);
/* TIM enable counter */
TIM_Cmd(TIM3, ENABLE);
TIM_Cmd(TIM4, ENABLE);
/* Main Output Enable */
TIM_CtrlPWMOutputs(TIM1, ENABLE);
while (1)
{}
}
/**
* @brief Main program
* @param None
* @retval None
*/
int main(void)
{
/* System Clocks Configuration */
RCC_Configuration();
/* NVIC Configuration */
NVIC_Configuration();
/* GPIO Configuration */
GPIO_Configuration();
/* ---------------------------------------------------------------
TIM2 Configuration: Output Compare Timing Mode:
TIM2CLK = 36 MHz, Prescaler = 4, TIM2 counter clock = 7.2 MHz
CC1 update rate = TIM2 counter clock / CCR1_Val = 146.48 Hz
CC2 update rate = TIM2 counter clock / CCR2_Val = 219.7 Hz
CC3 update rate = TIM2 counter clock / CCR3_Val = 439.4 Hz
CC4 update rate = TIM2 counter clock / CCR4_Val = 878.9 Hz
--------------------------------------------------------------- */
/* Time base configuration */
TIM_TimeBaseStructure.TIM_Period = 65535;
TIM_TimeBaseStructure.TIM_Prescaler = 0;
TIM_TimeBaseStructure.TIM_ClockDivision = 0;
TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;
TIM_TimeBaseInit(TIM2, &TIM_TimeBaseStructure);
/* Prescaler configuration */
TIM_PrescalerConfig(TIM2, 4, TIM_PSCReloadMode_Immediate);
/* Output Compare Timing Mode configuration: Channel1 */
TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_Timing;
TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;
TIM_OCInitStructure.TIM_Pulse = CCR1_Val;
TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_High;
TIM_OC1Init(TIM2, &TIM_OCInitStructure);
TIM_OC1PreloadConfig(TIM2, TIM_OCPreload_Disable);
/* Output Compare Timing Mode configuration: Channel2 */
TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;
TIM_OCInitStructure.TIM_Pulse = CCR2_Val;
TIM_OC2Init(TIM2, &TIM_OCInitStructure);
TIM_OC2PreloadConfig(TIM2, TIM_OCPreload_Disable);
/* Output Compare Timing Mode configuration: Channel3 */
TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;
TIM_OCInitStructure.TIM_Pulse = CCR3_Val;
TIM_OC3Init(TIM2, &TIM_OCInitStructure);
TIM_OC3PreloadConfig(TIM2, TIM_OCPreload_Disable);
/* Output Compare Timing Mode configuration: Channel4 */
TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;
TIM_OCInitStructure.TIM_Pulse = CCR4_Val;
TIM_OC4Init(TIM2, &TIM_OCInitStructure);
TIM_OC4PreloadConfig(TIM2, TIM_OCPreload_Disable);
/* TIM IT enable */
TIM_ITConfig(TIM2, TIM_IT_CC1 | TIM_IT_CC2 | TIM_IT_CC3 | TIM_IT_CC4, ENABLE);
/* TIM2 enable counter */
TIM_Cmd(TIM2, ENABLE);
while (1);
}
int configure_PWM(void)
{
//TIMER 4 CHANNEL 3
/* System Clocks Configuration */
RCC_Configuration();
/* GPIO Configuration */
GPIO_Configuration();
/* -----------------------------------------------------------------------
TIM4 Configuration: generate 4 PWM signals with 4 different duty cycles:
The TIM4CLK frequency is set to SystemCoreClock (Hz), to get TIM4 counter
clock at 24 MHz the Prescaler is computed as following:
- Prescaler = (TIM4CLK / TIM4 counter clock) - 1
SystemCoreClock is set to 72 MHz for Low-density, Medium-density, High-density
and Connectivity line devices and to 24 MHz for Low-Density Value line and
Medium-Density Value line devices
The TIM4 is running at 36 KHz: TIM4 Frequency = TIM4 counter clock/(ARR + 1)
= 24 MHz / 666 = 36 KHz
TIM4 Channel1 duty cycle = (TIM4_CCR1/ TIM4_ARR)* 100 = 50%
TIM4 Channel2 duty cycle = (TIM4_CCR2/ TIM4_ARR)* 100 = 37.5%
TIM4 Channel3 duty cycle = (TIM4_CCR3/ TIM4_ARR)* 100 = 25%
TIM4 Channel4 duty cycle = (TIM4_CCR4/ TIM4_ARR)* 100 = 12.5%
----------------------------------------------------------------------- */
TIM_OCStructInit(&TIM_OCInitStructure);
TIM_TimeBaseStructInit(&TIM_TimeBaseStructure);
/* Compute the prescaler value */
int SystemCoreClock = 72000000;
PrescalerValue = (uint16_t) (SystemCoreClock / 24000000) - 1;
/* Time base configuration */
int horloge_sur_duree = SystemCoreClock*20000*1e-6;
int TIM_PSC = (horloge_sur_duree)/65536 + 1;
int ARR = (horloge_sur_duree)/TIM_PSC +1;
//ARR configuré à 20 ms
TIM_TimeBaseStructure.TIM_Period = ARR-1;//ARR
ARR_G = ARR-1;
TIM_TimeBaseStructure.TIM_Prescaler = TIM_PSC-1;
TIM_TimeBaseStructure.TIM_ClockDivision = 0;
TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;
TIM_TimeBaseInit(TIM4, &TIM_TimeBaseStructure);
/* PWM1 Mode configuration: Channel3 */
TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;
TIM_OCInitStructure.TIM_Pulse = CCR3_Val;
TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM1;
TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_High;
TIM_OC3Init(TIM4, &TIM_OCInitStructure);
TIM_OC3PreloadConfig(TIM4, TIM_OCPreload_Enable);
TIM_ARRPreloadConfig(TIM4,ENABLE);
TIM_Cmd(TIM4, ENABLE);
}
/*******************************************************************************
* Function Name : main
* Description : Main program
* Input : None
* Output : None
* Return : None
*******************************************************************************/
int main(void)
{
#ifdef DEBUG
debug();
#endif
/* System clocks configuration ---------------------------------------------*/
RCC_Configuration();
/* NVIC configuration ------------------------------------------------------*/
NVIC_Configuration();
/* GPIO configuration ------------------------------------------------------*/
GPIO_Configuration();
/* TIM1 configuration ------------------------------------------------------*/
/* Time Base configuration */
TIM_TimeBaseStructInit(&TIM_TimeBaseStructure);
TIM_TimeBaseStructure.TIM_Period = 0xFF;
TIM_TimeBaseStructure.TIM_Prescaler = 0x4;
TIM_TimeBaseStructure.TIM_ClockDivision = 0x0;
TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;
TIM_TimeBaseInit(TIM1, &TIM_TimeBaseStructure);
/* TIM1 channel1 configuration in PWM mode */
TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM1;
TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;
TIM_OCInitStructure.TIM_Pulse = 0x7F;
TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_Low;
TIM_OC1Init(TIM1, &TIM_OCInitStructure);
/* DMA1 Channel1 Configuration ----------------------------------------------*/
DMA_DeInit(DMA1_Channel1);
DMA_InitStructure.DMA_PeripheralBaseAddr = ADC1_DR_Address;
DMA_InitStructure.DMA_MemoryBaseAddr = (u32)ADC_RegularConvertedValueTab;
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC;
DMA_InitStructure.DMA_BufferSize = 32;
DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_HalfWord;
DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_HalfWord;
DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;
DMA_InitStructure.DMA_Priority = DMA_Priority_High;
DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;
DMA_Init(DMA1_Channel1, &DMA_InitStructure);
/* Enable DMA1 channel1 */
DMA_Cmd(DMA1_Channel1, ENABLE);
/* ADC1 configuration ------------------------------------------------------*/
ADC_InitStructure.ADC_Mode = ADC_Mode_Independent;
ADC_InitStructure.ADC_ScanConvMode = DISABLE;
ADC_InitStructure.ADC_ContinuousConvMode = DISABLE;
ADC_InitStructure.ADC_ExternalTrigConv = ADC_ExternalTrigConv_T1_CC1;
ADC_InitStructure.ADC_DataAlign = ADC_DataAlign_Right;
ADC_InitStructure.ADC_NbrOfChannel = 1;
ADC_Init(ADC1, &ADC_InitStructure);
/* ADC1 regular channel14 configuration */
ADC_RegularChannelConfig(ADC1, ADC_Channel_14, 1, ADC_SampleTime_13Cycles5);
/* Set injected sequencer length */
ADC_InjectedSequencerLengthConfig(ADC1, 1);
/* ADC1 injected channel Configuration */
ADC_InjectedChannelConfig(ADC1, ADC_Channel_11, 1, ADC_SampleTime_71Cycles5);
/* ADC1 injected external trigger configuration */
ADC_ExternalTrigInjectedConvConfig(ADC1, ADC_ExternalTrigInjecConv_None);
/* Enable automatic injected conversion start after regular one */
ADC_AutoInjectedConvCmd(ADC1, ENABLE);
/* Enable ADC1 DMA */
ADC_DMACmd(ADC1, ENABLE);
/* Enable ADC1 external trigger */
ADC_ExternalTrigConvCmd(ADC1, ENABLE);
/* Enable JEOC interupt */
ADC_ITConfig(ADC1, ADC_IT_JEOC, ENABLE);
/* Enable ADC1 */
ADC_Cmd(ADC1, ENABLE);
/* Enable ADC1 reset calibaration register */
ADC_ResetCalibration(ADC1);
/* Check the end of ADC1 reset calibration register */
while(ADC_GetResetCalibrationStatus(ADC1));
/* Start ADC1 calibaration */
ADC_StartCalibration(ADC1);
/* Check the end of ADC1 calibration */
while(ADC_GetCalibrationStatus(ADC1));
/* TIM1 counter enable */
TIM_Cmd(TIM1, ENABLE);
/* TIM1 main Output Enable */
TIM_CtrlPWMOutputs(TIM1, ENABLE);
/* Test on channel1 transfer complete flag */
while(!DMA_GetFlagStatus(DMA1_FLAG_TC1));
/* Clear channel1 transfer complete flag */
DMA_ClearFlag(DMA1_FLAG_TC1);
/* TIM1 counter disable */
TIM_Cmd(TIM1, DISABLE);
while (1)
{
}
}