static void uartReconfigure(uartPort_t *uartPort)
{
USART_InitTypeDef USART_InitStructure;
USART_Cmd(uartPort->USARTx, DISABLE);
USART_InitStructure.USART_BaudRate = uartPort->port.baudRate;
USART_InitStructure.USART_WordLength = USART_WordLength_8b;
USART_InitStructure.USART_StopBits = (uartPort->port.options & SERIAL_STOPBITS_2) ? USART_StopBits_2 : USART_StopBits_1;
USART_InitStructure.USART_Parity = (uartPort->port.options & SERIAL_PARITY_EVEN) ? USART_Parity_Even : USART_Parity_No;
USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
USART_InitStructure.USART_Mode = 0;
if (uartPort->port.mode & MODE_RX)
USART_InitStructure.USART_Mode |= USART_Mode_Rx;
if (uartPort->port.mode & MODE_TX)
USART_InitStructure.USART_Mode |= USART_Mode_Tx;
USART_Init(uartPort->USARTx, &USART_InitStructure);
usartConfigurePinInversion(uartPort);
if(uartPort->port.options & SERIAL_BIDIR)
USART_HalfDuplexCmd(uartPort->USARTx, ENABLE);
else
USART_HalfDuplexCmd(uartPort->USARTx, DISABLE);
USART_Cmd(uartPort->USARTx, ENABLE);
}
/**
* Hardware initialization.
*/
void OW_Init(void) {
GPIO_InitTypeDef GPIO_InitStruct;
USART_InitTypeDef USART_InitStructure;
/* Enable clock for periphetials */
OW_GPIO_TX_CLOCK();
#ifndef OW_USE_SINGLE_PIN
OW_GPIO_RX_CLOCK();
#endif
OW_USART_CLOCK();
/* Alternate function config on TX pin */
GPIO_PinAFConfig(OW_TX_PIN_PORT, OW_TX_PIN_SOURCE, OW_USART_AF);
/* TX pin configuration */
GPIO_InitStruct.GPIO_Pin = OW_TX_PIN_PIN;
GPIO_InitStruct.GPIO_Mode = GPIO_Mode_AF;
GPIO_InitStruct.GPIO_OType = GPIO_OType_OD;
GPIO_InitStruct.GPIO_Speed = GPIO_Speed_100MHz;
GPIO_InitStruct.GPIO_PuPd = GPIO_PuPd_UP;
GPIO_Init(OW_TX_PIN_PORT, &GPIO_InitStruct);
#ifndef OW_USE_SINGLE_PIN
/* Alternate function config on RX pin */
GPIO_PinAFConfig(OW_RX_PIN_PORT, OW_RX_PIN_SOURCE, OW_USART_AF);
GPIO_InitStruct.GPIO_Pin = OW_RX_PIN_PIN;
GPIO_InitStruct.GPIO_Mode = GPIO_Mode_AF;
GPIO_InitStruct.GPIO_Speed = GPIO_Speed_100MHz;
GPIO_InitStruct.GPIO_PuPd = GPIO_PuPd_UP;
GPIO_Init(OW_RX_PIN_PORT, &GPIO_InitStruct);
#endif
/* USART configuration */
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_Tx | USART_Mode_Rx;
USART_Init(OW_USART, &USART_InitStructure);
/* BRR register backup for 115200 Baud */
iUSART115200 = OW_USART->BRR;
/* BRR register backup for 9600 Baud */
USART_StructInit(&USART_InitStructure);
USART_InitStructure.USART_BaudRate = 9600;
USART_Init(OW_USART, &USART_InitStructure);
iUSART9600 = OW_USART->BRR;
#ifdef OW_USE_SINGLE_PIN
/* Half duplex enable, for single pin communication */
USART_HalfDuplexCmd(OW_USART, ENABLE);
#endif
/* USART enable */
USART_Cmd(OW_USART, ENABLE);
}
/**
* Set RX/TX pin into weak pull-up state.
*/
void OW_WeakPullUp(void) {
#ifdef OW_USE_PARASITE_POWER
GPIO_SetBits(OW_TX_PIN_PORT, OW_TX_PIN_PIN);
OW_TX_PIN_PORT->OTYPER |= OW_TX_PIN_PIN;
#ifdef OW_USE_SINGLE_PIN
USART_HalfDuplexCmd(OW_USART, ENABLE);
#endif
#endif
}
/**
* Set RX/TX pin into strong pull-up state.
*/
void OW_StrongPullUp(void) {
#ifdef OW_USE_PARASITE_POWER
#ifdef OW_USE_SINGLE_PIN
USART_HalfDuplexCmd(OW_USART, DISABLE);
#endif
GPIO_SetBits(OW_TX_PIN_PORT, OW_TX_PIN_PIN);
OW_TX_PIN_PORT->OTYPER &= ~(OW_TX_PIN_PIN);
#endif
}
void HAL_USART_Half_Duplex(HAL_USART_Serial serial, bool Enable)
{
if (HAL_USART_Is_Enabled(serial)) {
USART_Cmd(usartMap[serial]->usart_peripheral, DISABLE);
}
if (Enable) {
usartMap[serial]->usart_config |= SERIAL_HALF_DUPLEX;
} else {
usartMap[serial]->usart_config &= ~(SERIAL_HALF_DUPLEX);
}
HAL_USART_Configure_Pin_Modes(serial, usartMap[serial]->usart_config);
// These bits need to be cleared according to the reference manual
usartMap[serial]->usart_peripheral->CR2 &= ~(USART_CR2_LINEN | USART_CR2_CLKEN);
usartMap[serial]->usart_peripheral->CR3 &= ~(USART_CR3_IREN | USART_CR3_SCEN);
USART_HalfDuplexCmd(usartMap[serial]->usart_peripheral, Enable ? ENABLE : DISABLE);
if (HAL_USART_Is_Enabled(serial)) {
USART_Cmd(usartMap[serial]->usart_peripheral, ENABLE);
}
}
void uart2_init(u32 bound){
//GPIO端口设置
GPIO_InitTypeDef GPIO_InitStructure;
USART_InitTypeDef USART_InitStructure;
NVIC_InitTypeDef NVIC_InitStructure;
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE); //使能USART2，GPIOA时钟
RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2, ENABLE);
USART_DeInit(USART2); //复位串口2
//USART2_TX PA.2
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2; //PA.2
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP; //复用推挽输出
GPIO_Init(GPIOA, &GPIO_InitStructure); //初始化PA2
//USART2_RX PA.3
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;//浮空输入
GPIO_Init(GPIOA, &GPIO_InitStructure); //初始化PA3
#if 1
//Usart2 NVIC 配置
NVIC_InitStructure.NVIC_IRQChannel = USART2_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=0 ;//抢占优先级3
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 2; //子优先级3
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; //IRQ通道使能
NVIC_Init(&NVIC_InitStructure); //根据指定的参数初始化VIC寄存器
//USART 初始化设置
USART_InitStructure.USART_BaudRate = bound;//一般设置为9600;
USART_InitStructure.USART_WordLength = USART_WordLength_9b;//字长为9位数据格式
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; //收发模式
#endif
USART_Init(USART2, &USART_InitStructure); //初始化串口
USART_ITConfig(USART2, USART_IT_RXNE, ENABLE);//开启中断
USART_HalfDuplexCmd(USART2, ENABLE);//半双工
USART_Cmd(USART2, ENABLE); //使能串口
}
serialPort_t *uartOpen(USART_TypeDef *USARTx, serialReceiveCallbackPtr callback, uint32_t baudRate, portMode_t mode, serialInversion_e inversion)
{
uartPort_t *s = NULL;
if (USARTx == USART1) {
s = serialUSART1(baudRate, mode);
#ifdef USE_USART2
} else if (USARTx == USART2) {
s = serialUSART2(baudRate, mode);
#endif
#ifdef USE_USART3
} else if (USARTx == USART3) {
s = serialUSART3(baudRate, mode);
#endif
} else {
return (serialPort_t *)s;
}
s->txDMAEmpty = true;
// common serial initialisation code should move to serialPort::init()
s->port.rxBufferHead = s->port.rxBufferTail = 0;
s->port.txBufferHead = s->port.txBufferTail = 0;
// callback works for IRQ-based RX ONLY
s->port.callback = callback;
s->port.mode = mode;
s->port.baudRate = baudRate;
s->port.inversion = inversion;
uartReconfigure(s);
// Receive DMA or IRQ
DMA_InitTypeDef DMA_InitStructure;
if ((mode & MODE_RX) || (mode & MODE_BIDIR)) {
if (s->rxDMAChannel) {
DMA_StructInit(&DMA_InitStructure);
DMA_InitStructure.DMA_PeripheralBaseAddr = s->rxDMAPeripheralBaseAddr;
DMA_InitStructure.DMA_Priority = DMA_Priority_Medium;
DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;
DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;
DMA_InitStructure.DMA_BufferSize = s->port.rxBufferSize;
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC;
DMA_InitStructure.DMA_Mode = DMA_Mode_Circular;
DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)s->port.rxBuffer;
DMA_DeInit(s->rxDMAChannel);
DMA_Init(s->rxDMAChannel, &DMA_InitStructure);
DMA_Cmd(s->rxDMAChannel, ENABLE);
USART_DMACmd(s->USARTx, USART_DMAReq_Rx, ENABLE);
s->rxDMAPos = DMA_GetCurrDataCounter(s->rxDMAChannel);
} else {
USART_ClearITPendingBit(s->USARTx, USART_IT_RXNE);
USART_ITConfig(s->USARTx, USART_IT_RXNE, ENABLE);
}
}
// Transmit DMA or IRQ
if ((mode & MODE_TX) || (mode & MODE_BIDIR)) {
if (s->txDMAChannel) {
DMA_StructInit(&DMA_InitStructure);
DMA_InitStructure.DMA_PeripheralBaseAddr = s->txDMAPeripheralBaseAddr;
DMA_InitStructure.DMA_Priority = DMA_Priority_Medium;
DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;
DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;
DMA_InitStructure.DMA_BufferSize = s->port.txBufferSize;
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralDST;
DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;
DMA_DeInit(s->txDMAChannel);
DMA_Init(s->txDMAChannel, &DMA_InitStructure);
DMA_ITConfig(s->txDMAChannel, DMA_IT_TC, ENABLE);
DMA_SetCurrDataCounter(s->txDMAChannel, 0);
s->txDMAChannel->CNDTR = 0;
USART_DMACmd(s->USARTx, USART_DMAReq_Tx, ENABLE);
} else {
USART_ITConfig(s->USARTx, USART_IT_TXE, ENABLE);
}
}
USART_Cmd(s->USARTx, ENABLE);
if (mode & MODE_BIDIR)
USART_HalfDuplexCmd(s->USARTx, ENABLE);
else
USART_HalfDuplexCmd(s->USARTx, DISABLE);
return (serialPort_t *)s;
}
/**
* @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)
{
}
}
/**
* Initialise a single USART device
*/
int32_t PIOS_USART_Init(uintptr_t * usart_id, const struct pios_usart_cfg * cfg)
{
PIOS_DEBUG_Assert(usart_id);
PIOS_DEBUG_Assert(cfg);
struct pios_usart_dev * usart_dev;
usart_dev = (struct pios_usart_dev *) PIOS_USART_alloc();
if (!usart_dev) goto out_fail;
/* Bind the configuration to the device instance */
usart_dev->cfg = cfg;
/* Map pins to USART function */
if (usart_dev->cfg->remap) {
if (usart_dev->cfg->rx.gpio != 0)
GPIO_PinAFConfig(usart_dev->cfg->rx.gpio,
usart_dev->cfg->rx.pin_source,
usart_dev->cfg->remap);
if (usart_dev->cfg->tx.gpio != 0)
GPIO_PinAFConfig(usart_dev->cfg->tx.gpio,
usart_dev->cfg->tx.pin_source,
usart_dev->cfg->remap);
}
/* Initialize the USART Rx and Tx pins */
if (usart_dev->cfg->rx.gpio != 0)
GPIO_Init(usart_dev->cfg->rx.gpio, (GPIO_InitTypeDef *)&usart_dev->cfg->rx.init);
if (usart_dev->cfg->tx.gpio != 0)
GPIO_Init(usart_dev->cfg->tx.gpio, (GPIO_InitTypeDef *)&usart_dev->cfg->tx.init);
/* Apply inversion and swap settings */
if (usart_dev->cfg->rx_invert == true)
USART_InvPinCmd(usart_dev->cfg->regs, USART_InvPin_Rx, ENABLE);
else
USART_InvPinCmd(usart_dev->cfg->regs, USART_InvPin_Rx, DISABLE);
if (usart_dev->cfg->tx_invert == true)
USART_InvPinCmd(usart_dev->cfg->regs, USART_InvPin_Tx, ENABLE);
else
USART_InvPinCmd(usart_dev->cfg->regs, USART_InvPin_Tx, DISABLE);
if (usart_dev->cfg->rxtx_swap == true)
USART_SWAPPinCmd(usart_dev->cfg->regs, ENABLE);
else
USART_SWAPPinCmd(usart_dev->cfg->regs, DISABLE);
if (usart_dev->cfg->single_wire == true)
USART_HalfDuplexCmd(usart_dev->cfg->regs, ENABLE);
else
USART_HalfDuplexCmd(usart_dev->cfg->regs, DISABLE);
/* Configure the USART */
USART_Init(usart_dev->cfg->regs, (USART_InitTypeDef *)&usart_dev->cfg->init);
*usart_id = (uintptr_t)usart_dev;
/* Configure USART Interrupts */
switch ((uint32_t)usart_dev->cfg->regs) {
case (uint32_t)USART1:
PIOS_USART_1_id = (uintptr_t)usart_dev;
break;
case (uint32_t)USART2:
PIOS_USART_2_id = (uintptr_t)usart_dev;
break;
case (uint32_t)USART3:
PIOS_USART_3_id = (uintptr_t)usart_dev;
break;
case (uint32_t)UART4:
PIOS_UART_4_id = (uintptr_t)usart_dev;
break;
case (uint32_t)UART5:
PIOS_UART_5_id = (uintptr_t)usart_dev;
break;
}
NVIC_Init((NVIC_InitTypeDef *)&(usart_dev->cfg->irq.init));
USART_ITConfig(usart_dev->cfg->regs, USART_IT_RXNE, ENABLE);
USART_ITConfig(usart_dev->cfg->regs, USART_IT_TXE, ENABLE);
// FIXME XXX Clear / reset uart here - sends NUL char else
/* Enable USART */
USART_Cmd(usart_dev->cfg->regs, ENABLE);
return(0);
out_fail:
return(-1);
}
void HAL_USART_Half_Duplex(HAL_USART_Serial serial, bool Enable)
{
USART_HalfDuplexCmd(usartMap[serial]->usart_peripheral, Enable ? ENABLE : DISABLE);
}
/******************************************************************************
* USART1 Initialization Code Template
******************************************************************************/
void USART1__Init()
{
USART_InitTypeDef USART_InitStruct;
#if (STRCMP($modeSelect$, USART_MODE_SYNCHRONOUS) == 1)
//PUT_A_NEW_LINE_HERE
USART_ClockInitTypeDef USART_ClockInitStruct;
#endif
#if (!STRCMP($USARTIntSet$, 0))
NVIC_InitTypeDef NVIC_InitStructure;
#endif
//PUT_A_NEW_LINE_HERE
//
// Enable peripheral clock of USART1 and GPIOA
//
RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);
//PUT_A_NEW_LINE_HERE
//
// USART Config
//
USART_InitStruct.USART_BaudRate = $baudRate$;
USART_InitStruct.USART_WordLength = $dataBits$;
USART_InitStruct.USART_StopBits = $stopBits$;
USART_InitStruct.USART_Parity = $parityBits$;
USART_InitStruct.USART_Mode = $modeSet$;
USART_InitStruct.USART_HardwareFlowControl = $HardwareFlowControl$;
USART_Init(USART1, &USART_InitStruct);
#if ($guardTime$ != 0)
//PUT_A_NEW_LINE_HERE
//
// Set Guard Time
//
USART_SetGuardTime(USART1, $guardTime$);
#endif
//PUT_A_NEW_LINE_HERE
USART_WakeUpConfig(USART1, $WakeUpmethod$);
//PUT_A_NEW_LINE_HERE
#if (STRCMP($modeSelect$, USART_MODE_NORMAL) == 1)
#elif (STRCMP($modeSelect$, USART_MODE_IRDA) == 1)
//PUT_A_NEW_LINE_HERE
//
//USART IrDA Mode Config
//
USART_IrDAConfig(USART1, $IrDAModeSel$);
USART_IrDACmd(USART1, ENABLE);
#elif (STRCMP($modeSelect$, USART_MODE_DMA) == 1)
//PUT_A_NEW_LINE_HERE
//
//USART DMA Mode Config
//
USART_DMACmd(USART1, $DMAReq$, ENABLE);
#elif (STRCMP($modeSelect$, USART_MODE_SYNCHRONOUS) == 1)
//PUT_A_NEW_LINE_HERE
//
// USART Synchronous Mode Config
//
USART_Clock_InitStruct.USART_Clock = USART_CLOCK_ENABLE;
USART_Clock_InitStruct.USART_CPOL = $synClockPolSet$;
USART_Clock_InitStruct.USART_CPHA = $synClockPhaseSet$;
USART_Clock_InitStruct.USART_LastBit = $lastbitenable$;
USART_ClockInit(USART1, &USART_Clock_InitStruct);
#elif (STRCMP($modeSelect$, USART_MODE_LIN) == 1)
//PUT_A_NEW_LINE_HERE
//
// USART LIN Mode Config
//
USART_LINBreakDetectLengthConfig(USART1, $LINBreakDetectLen$);
USART_LINCmd(USART1, ENABLE);
#elif (STRCMP($modeSelect$, USART_MODE_SMARTCARD) == 1)
//PUT_A_NEW_LINE_HERE
//
// USART SmartCard Mode Config
//
USART_SmartCardCmd(USART1, ENABLE);
#elif (STRCMP($NACKTrans$, ENABLE) == 1)
//PUT_A_NEW_LINE_HERE
USART_SmartCardNACKCmd(USART1, ENABLE);
#elif (STRCMP($modeSelect$, USART_MODE_HALFDUPLEX) == 1)
//PUT_A_NEW_LINE_HERE
//
// USART HalfDuplex Mode Config
//
USART_HalfDuplexCmd(USART1, ENABLE);
#endif
#if (!STRCMP($USARTIntSet$, 0))
//PUT_A_NEW_LINE_HERE
//
// Enable the USART Interrupt Function
//
USART_ITConfig(USART1, $USARTIntSet$, ENABLE);
NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
#endif
}
//-----------------------------------------------------------------------------
// инициализирует USART и DMA
//-----------------------------------------------------------------------------
uint8_t OW_Init() {
GPIO_InitTypeDef GPIO_InitStruct;
USART_InitTypeDef USART_InitStructure;
if (OW_USART == USART1) {
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA | RCC_APB2Periph_AFIO,
ENABLE);
// USART TX
GPIO_InitStruct.GPIO_Pin = GPIO_Pin_9;
GPIO_InitStruct.GPIO_Mode = GPIO_Mode_AF_OD;
GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOA, &GPIO_InitStruct);
// USART RX
/* GPIO_InitStruct.GPIO_Pin = GPIO_Pin_10;
GPIO_InitStruct.GPIO_Mode = GPIO_Mode_IN_FLOATING;
GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOA, &GPIO_InitStruct); */
RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE);
}
if (OW_USART == USART2) {
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA | RCC_APB2Periph_AFIO,
ENABLE);
GPIO_InitStruct.GPIO_Pin = GPIO_Pin_2;
GPIO_InitStruct.GPIO_Mode = GPIO_Mode_AF_PP;
GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOA, &GPIO_InitStruct);
GPIO_InitStruct.GPIO_Pin = GPIO_Pin_3;
GPIO_InitStruct.GPIO_Mode = GPIO_Mode_IN_FLOATING;
GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOA, &GPIO_InitStruct);
RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2, ENABLE);
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE);
}
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_Tx | USART_Mode_Rx;
USART_Init(OW_USART, &USART_InitStructure);
USART_Cmd(OW_USART, ENABLE);
USART_HalfDuplexCmd(OW_USART, ENABLE);
return OW_OK;
}