floratest2
/
xiuos
forked from xuos/xiuos
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fix: fix ch32v307 cannot enter shell

This commit is contained in:
Allenn 2023-12-13 10:48:18 +08:00
parent 093f362387
commit 402f25a2fd
3 changed files with 101 additions and 116 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

29
Ubiquitous/XiZi_IIoT/arch/risc-v/ch32v307vct6/User/ch32v30x_it.c
View File

@ -1,16 +1,16 @@
/********************************** (C) COPYRIGHT ******************************* /********************************** (C) COPYRIGHT *******************************
* File Name : ch32v10x_it.c * File Name : ch32v10x_it.c
* Author : WCH * Author : WCH
* Version : V1.0.0 * Version : V1.0.0
* Date : 2020/04/30 * Date : 2020/04/30
* Description : Main Interrupt Service Routines. * Description : Main Interrupt Service Routines.
* Copyright (c) 2021 Nanjing Qinheng Microelectronics Co., Ltd. * Copyright (c) 2021 Nanjing Qinheng Microelectronics Co., Ltd.
* SPDX-License-Identifier: Apache-2.0 * SPDX-License-Identifier: Apache-2.0
*******************************************************************************/ *******************************************************************************/
/************************************************* /*************************************************
File name: ch32v30x_it.c File name: ch32v30x_it.c
Description: include peripheral supports for ch32v30x Description: include peripheral supports for ch32v30x
History: History:
1. Date: 2022-08-09 1. Date: 2022-08-09
Author: AIIT XUOS Lab Author: AIIT XUOS Lab
Modification: Modification:
@ -20,10 +20,8 @@ Modification:
#include "board.h" #include "board.h"
#include <xs_isr.h> #include <xs_isr.h>
void NMI_Handler(void) __attribute__((interrupt()));
void HardFault_Handler(void) __attribute__((interrupt()));
void NMI_Handler(void) __attribute__((interrupt("WCH-Interrupt-fast")));
void HardFault_Handler(void) __attribute__((interrupt("WCH-Interrupt-fast")));
/********************************************************************* /*********************************************************************
* @fn NMI_Handler * @fn NMI_Handler
@ -56,6 +54,3 @@ void HardFault_Handler(void)
isrManager.done->decCounter(); isrManager.done->decCounter();
FREE_INT_SP(); FREE_INT_SP();
} }

2
Ubiquitous/XiZi_IIoT/arch/risc-v/ch32v307vct6/tick.c
View File

@ -19,7 +19,7 @@
extern void KTaskOsAssignAfterIrq(void *); extern void KTaskOsAssignAfterIrq(void *);
void SysTick_Handler(void) __attribute__((interrupt("WCH-Interrupt-fast"))); void SysTick_Handler(void) __attribute__((interrupt()));
void SysTick_Handler(void) void SysTick_Handler(void)
{ {
GET_INT_SP(); GET_INT_SP();

186
Ubiquitous/XiZi_IIoT/board/ch32v307vct6/third_party_driver/uart/connect_uart.c
View File

@ -1,35 +1,35 @@
/* /*
* Copyright (c) 2020 AIIT XUOS Lab * Copyright (c) 2020 AIIT XUOS Lab
* XiUOS is licensed under Mulan PSL v2. * XiUOS is licensed under Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2. * You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at: * You may obtain a copy of Mulan PSL v2 at:
* http://license.coscl.org.cn/MulanPSL2 * http://license.coscl.org.cn/MulanPSL2
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details. * See the Mulan PSL v2 for more details.
*/ */
/** /**
* @file connect_usart.c * @file connect_usart.c
* @brief support ch32v307 vct6 uart function and register to bus framework * @brief support ch32v307 vct6 uart function and register to bus framework
* @version 1.0 * @version 1.0
* @author AIIT XUOS Lab * @author AIIT XUOS Lab
* @date 2022-08-01 * @date 2022-08-01
*/ */
#include <xizi.h>
#include "ch32v30x.h"
#include "xsconfig.h"
#include "connect_uart.h" #include "connect_uart.h"
#include "ch32v30x.h"
#include "ch32v30x_usart.h" #include "ch32v30x_usart.h"
#include "xsconfig.h"
#include <xizi.h>
/* uart driver */ /* uart driver */
static void SerialCfgParamCheck(struct SerialCfgParam* serial_cfg_default, struct SerialCfgParam* serial_cfg_new) static void SerialCfgParamCheck(struct SerialCfgParam* serial_cfg_default, struct SerialCfgParam* serial_cfg_new)
{ {
struct SerialDataCfg *data_cfg_default = &serial_cfg_default->data_cfg; struct SerialDataCfg* data_cfg_default = &serial_cfg_default->data_cfg;
struct SerialDataCfg *data_cfg_new = &serial_cfg_new->data_cfg; struct SerialDataCfg* data_cfg_new = &serial_cfg_new->data_cfg;
if ((data_cfg_default->serial_baud_rate != data_cfg_new->serial_baud_rate) && (data_cfg_new->serial_baud_rate)) { if ((data_cfg_default->serial_baud_rate != data_cfg_new->serial_baud_rate) && (data_cfg_new->serial_baud_rate)) {
data_cfg_default->serial_baud_rate = data_cfg_new->serial_baud_rate; data_cfg_default->serial_baud_rate = data_cfg_new->serial_baud_rate;
@ -64,40 +64,39 @@ static void SerialCfgParamCheck(struct SerialCfgParam* serial_cfg_default, struc
} }
} }
static void UartIsr(struct SerialDriver *serial_drv, struct SerialHardwareDevice *serial_dev) static void UartIsr(struct SerialDriver* serial_drv, struct SerialHardwareDevice* serial_dev)
{ {
struct SerialCfgParam *serial_cfg = (struct SerialCfgParam *)serial_drv->private_data; struct SerialCfgParam* serial_cfg = (struct SerialCfgParam*)serial_drv->private_data;
if (RESET != USART_GetITStatus((USART_TypeDef *)serial_cfg->hw_cfg.serial_register_base, USART_IT_RXNE)) if (RESET != USART_GetITStatus((USART_TypeDef*)serial_cfg->hw_cfg.serial_register_base, USART_IT_RXNE)) {
{
SerialSetIsr(serial_dev, SERIAL_EVENT_RX_IND); SerialSetIsr(serial_dev, SERIAL_EVENT_RX_IND);
USART_ClearITPendingBit((USART_TypeDef *)serial_cfg->hw_cfg.serial_register_base, USART_IT_RXNE); USART_ClearITPendingBit((USART_TypeDef*)serial_cfg->hw_cfg.serial_register_base, USART_IT_RXNE);
} }
} }
static uint32 SerialInit(struct SerialDriver *serial_drv, struct BusConfigureInfo *configure_info) static uint32 SerialInit(struct SerialDriver* serial_drv, struct BusConfigureInfo* configure_info)
{ {
NULL_PARAM_CHECK(serial_drv); NULL_PARAM_CHECK(serial_drv);
struct SerialCfgParam* serial_cfg = (struct SerialCfgParam*)serial_drv->private_data; struct SerialCfgParam* serial_cfg = (struct SerialCfgParam*)serial_drv->private_data;
// struct UsartHwCfg *serial_hw_cfg = (struct UsartHwCfg *)serial_cfg->hw_cfg.private_data; // struct UsartHwCfg *serial_hw_cfg = (struct UsartHwCfg *)serial_cfg->hw_cfg.private_data;
struct SerialHardwareDevice *serial_dev = (struct SerialHardwareDevice *)serial_drv->driver.owner_bus->owner_haldev; struct SerialHardwareDevice* serial_dev = (struct SerialHardwareDevice*)serial_drv->driver.owner_bus->owner_haldev;
struct SerialDevParam *dev_param = (struct SerialDevParam *)serial_dev->haldev.private_data; struct SerialDevParam* dev_param = (struct SerialDevParam*)serial_dev->haldev.private_data;
if (configure_info->private_data) { if (configure_info->private_data) {
struct SerialCfgParam *serial_cfg_new = (struct SerialCfgParam *)configure_info->private_data; struct SerialCfgParam* serial_cfg_new = (struct SerialCfgParam*)configure_info->private_data;
SerialCfgParamCheck(serial_cfg, serial_cfg_new); SerialCfgParamCheck(serial_cfg, serial_cfg_new);
if (serial_cfg_new->data_cfg.dev_recv_callback) { if (serial_cfg_new->data_cfg.dev_recv_callback) {
BusDevRecvCallback(&(serial_dev->haldev), serial_cfg_new->data_cfg.dev_recv_callback); BusDevRecvCallback(&(serial_dev->haldev), serial_cfg_new->data_cfg.dev_recv_callback);
} }
} }
// config serial receive sem timeout // config serial receive sem timeout
dev_param->serial_timeout = serial_cfg->data_cfg.serial_timeout; dev_param->serial_timeout = serial_cfg->data_cfg.serial_timeout;
// init usart type def // init usart type def
GPIO_InitTypeDef GPIO_InitStructure; GPIO_InitTypeDef GPIO_InitStructure;
RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1 | RCC_APB2Periph_GPIOA, ENABLE); RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1 | RCC_APB2Periph_GPIOA, ENABLE);
@ -109,8 +108,7 @@ static uint32 SerialInit(struct SerialDriver *serial_drv, struct BusConfigureInf
USART_InitTypeDef USART_InitStructure; USART_InitTypeDef USART_InitStructure;
USART_InitStructure.USART_BaudRate = serial_cfg->data_cfg.serial_baud_rate; USART_InitStructure.USART_BaudRate = serial_cfg->data_cfg.serial_baud_rate;
switch (serial_cfg->data_cfg.serial_data_bits) switch (serial_cfg->data_cfg.serial_data_bits) {
{
case DATA_BITS_8: case DATA_BITS_8:
USART_InitStructure.USART_WordLength = USART_WordLength_8b; USART_InitStructure.USART_WordLength = USART_WordLength_8b;
break; break;
@ -122,9 +120,8 @@ static uint32 SerialInit(struct SerialDriver *serial_drv, struct BusConfigureInf
USART_InitStructure.USART_WordLength = USART_WordLength_8b; USART_InitStructure.USART_WordLength = USART_WordLength_8b;
break; break;
} }
switch (serial_cfg->data_cfg.serial_stop_bits) switch (serial_cfg->data_cfg.serial_stop_bits) {
{
case STOP_BITS_1: case STOP_BITS_1:
USART_InitStructure.USART_StopBits = USART_StopBits_1; USART_InitStructure.USART_StopBits = USART_StopBits_1;
break; break;
@ -135,9 +132,8 @@ static uint32 SerialInit(struct SerialDriver *serial_drv, struct BusConfigureInf
USART_InitStructure.USART_StopBits = USART_StopBits_1; USART_InitStructure.USART_StopBits = USART_StopBits_1;
break; break;
} }
switch (serial_cfg->data_cfg.serial_parity_mode) switch (serial_cfg->data_cfg.serial_parity_mode) {
{
case PARITY_NONE: case PARITY_NONE:
USART_InitStructure.USART_Parity = USART_Parity_No; USART_InitStructure.USART_Parity = USART_Parity_No;
break; break;
@ -160,81 +156,77 @@ static uint32 SerialInit(struct SerialDriver *serial_drv, struct BusConfigureInf
// usart_hardware_flow_rts_config(serial_cfg->hw_cfg.serial_register_base, USART_RTS_DISABLE); // usart_hardware_flow_rts_config(serial_cfg->hw_cfg.serial_register_base, USART_RTS_DISABLE);
// usart_hardware_flow_cts_config(serial_cfg->hw_cfg.serial_register_base, USART_CTS_DISABLE); // usart_hardware_flow_cts_config(serial_cfg->hw_cfg.serial_register_base, USART_CTS_DISABLE);
return EOK; return EOK;
} }
static uint32 SerialConfigure(struct SerialDriver *serial_drv, int serial_operation_cmd) static uint32 SerialConfigure(struct SerialDriver* serial_drv, int serial_operation_cmd)
{ {
NULL_PARAM_CHECK(serial_drv); NULL_PARAM_CHECK(serial_drv);
struct SerialCfgParam *serial_cfg = (struct SerialCfgParam *)serial_drv->private_data; struct SerialCfgParam* serial_cfg = (struct SerialCfgParam*)serial_drv->private_data;
switch (serial_operation_cmd) switch (serial_operation_cmd) {
{
case OPER_CLR_INT: case OPER_CLR_INT:
NVIC_DisableIRQ(serial_cfg->hw_cfg.serial_irq_interrupt); NVIC_DisableIRQ(serial_cfg->hw_cfg.serial_irq_interrupt);
USART_ITConfig((USART_TypeDef *)serial_cfg->hw_cfg.serial_register_base, USART_IT_RXNE, DISABLE); USART_ITConfig((USART_TypeDef*)serial_cfg->hw_cfg.serial_register_base, USART_IT_RXNE, DISABLE);
break; break;
case OPER_SET_INT: case OPER_SET_INT:
NVIC_EnableIRQ(serial_cfg->hw_cfg.serial_irq_interrupt); NVIC_EnableIRQ(serial_cfg->hw_cfg.serial_irq_interrupt);
/* enable USART0 receive interrupt */ /* enable USART0 receive interrupt */
USART_ITConfig((USART_TypeDef *)serial_cfg->hw_cfg.serial_register_base, USART_IT_RXNE, ENABLE); USART_ITConfig((USART_TypeDef*)serial_cfg->hw_cfg.serial_register_base, USART_IT_RXNE, ENABLE);
break; break;
} }
return EOK; return EOK;
} }
static uint32 SerialDrvConfigure(void *drv, struct BusConfigureInfo *configure_info) static uint32 SerialDrvConfigure(void* drv, struct BusConfigureInfo* configure_info)
{ {
NULL_PARAM_CHECK(drv); NULL_PARAM_CHECK(drv);
NULL_PARAM_CHECK(configure_info); NULL_PARAM_CHECK(configure_info);
x_err_t ret = EOK; x_err_t ret = EOK;
int serial_operation_cmd; int serial_operation_cmd;
struct SerialDriver *serial_drv = (struct SerialDriver *)drv; struct SerialDriver* serial_drv = (struct SerialDriver*)drv;
switch (configure_info->configure_cmd) switch (configure_info->configure_cmd) {
{ case OPE_INT:
case OPE_INT: ret = SerialInit(serial_drv, configure_info);
ret = SerialInit(serial_drv, configure_info); break;
break; case OPE_CFG:
case OPE_CFG: serial_operation_cmd = *(int*)configure_info->private_data;
serial_operation_cmd = *(int *)configure_info->private_data; ret = SerialConfigure(serial_drv, serial_operation_cmd);
ret = SerialConfigure(serial_drv, serial_operation_cmd); break;
break; default:
default: break;
break;
} }
return ret; return ret;
} }
static int SerialPutChar(struct SerialHardwareDevice *serial_dev, char c) static int SerialPutChar(struct SerialHardwareDevice* serial_dev, char c)
{ {
struct SerialCfgParam* serial_cfg = (struct SerialCfgParam*)serial_dev->private_data; struct SerialCfgParam* serial_cfg = (struct SerialCfgParam*)serial_dev->private_data;
while (USART_GetFlagStatus((USART_TypeDef *)serial_cfg->hw_cfg.serial_register_base, USART_FLAG_TXE) == RESET); while (USART_GetFlagStatus((USART_TypeDef*)serial_cfg->hw_cfg.serial_register_base, USART_FLAG_TXE) == RESET)
USART_SendData((USART_TypeDef *)serial_cfg->hw_cfg.serial_register_base, (uint8_t) c); ;
USART_SendData((USART_TypeDef*)serial_cfg->hw_cfg.serial_register_base, (uint8_t)c);
return 0; return 0;
} }
static int SerialGetChar(struct SerialHardwareDevice *serial_dev) static int SerialGetChar(struct SerialHardwareDevice* serial_dev)
{ {
int ch = -1; int ch = -1;
struct SerialCfgParam *serial_cfg = (struct SerialCfgParam *)serial_dev->private_data; struct SerialCfgParam* serial_cfg = (struct SerialCfgParam*)serial_dev->private_data;
if (RESET != USART_GetFlagStatus((USART_TypeDef *)serial_cfg->hw_cfg.serial_register_base, USART_FLAG_RXNE)) if (RESET != USART_GetFlagStatus((USART_TypeDef*)serial_cfg->hw_cfg.serial_register_base, USART_FLAG_RXNE)) {
{
ch = USART_ReceiveData((USART_TypeDef*)serial_cfg->hw_cfg.serial_register_base) & 0xff; ch = USART_ReceiveData((USART_TypeDef*)serial_cfg->hw_cfg.serial_register_base) & 0xff;
} }
return ch; return ch;
} }
static const struct SerialDataCfg data_cfg_init = static const struct SerialDataCfg data_cfg_init = {
{
.serial_baud_rate = BAUD_RATE_115200, .serial_baud_rate = BAUD_RATE_115200,
.serial_data_bits = DATA_BITS_8, .serial_data_bits = DATA_BITS_8,
.serial_stop_bits = STOP_BITS_1, .serial_stop_bits = STOP_BITS_1,
@ -246,20 +238,18 @@ static const struct SerialDataCfg data_cfg_init =
}; };
/*manage the serial device operations*/ /*manage the serial device operations*/
static const struct SerialDrvDone drv_done = static const struct SerialDrvDone drv_done = {
{
.init = SerialInit, .init = SerialInit,
.configure = SerialConfigure, .configure = SerialConfigure,
}; };
/*manage the serial device hal operations*/ /*manage the serial device hal operations*/
static struct SerialHwDevDone hwdev_done = static struct SerialHwDevDone hwdev_done = {
{
.put_char = SerialPutChar, .put_char = SerialPutChar,
.get_char = SerialGetChar, .get_char = SerialGetChar,
}; };
static int BoardSerialBusInit(struct SerialBus *serial_bus, struct SerialDriver *serial_driver, const char *bus_name, const char *drv_name) static int BoardSerialBusInit(struct SerialBus* serial_bus, struct SerialDriver* serial_driver, const char* bus_name, const char* drv_name)
{ {
x_err_t ret = EOK; x_err_t ret = EOK;
@ -282,13 +272,13 @@ static int BoardSerialBusInit(struct SerialBus *serial_bus, struct SerialDriver
if (EOK != ret) { if (EOK != ret) {
KPrintf("InitHwUart SerialDriverAttachToBus error %d\n", ret); KPrintf("InitHwUart SerialDriverAttachToBus error %d\n", ret);
return ERROR; return ERROR;
} }
return ret; return ret;
} }
/*Attach the serial device to the serial bus*/ /*Attach the serial device to the serial bus*/
static int BoardSerialDevBend(struct SerialHardwareDevice *serial_device, void *serial_param, const char *bus_name, const char *dev_name) static int BoardSerialDevBend(struct SerialHardwareDevice* serial_device, void* serial_param, const char* bus_name, const char* dev_name)
{ {
x_err_t ret = EOK; x_err_t ret = EOK;
@ -296,27 +286,27 @@ static int BoardSerialDevBend(struct SerialHardwareDevice *serial_device, void *
if (EOK != ret) { if (EOK != ret) {
KPrintf("InitHwUart SerialDeviceInit device %s error %d\n", dev_name, ret); KPrintf("InitHwUart SerialDeviceInit device %s error %d\n", dev_name, ret);
return ERROR; return ERROR;
} }
ret = SerialDeviceAttachToBus(dev_name, bus_name); ret = SerialDeviceAttachToBus(dev_name, bus_name);
if (EOK != ret) { if (EOK != ret) {
KPrintf("InitHwUart SerialDeviceAttachToBus device %s error %d\n", dev_name, ret); KPrintf("InitHwUart SerialDeviceAttachToBus device %s error %d\n", dev_name, ret);
return ERROR; return ERROR;
} }
return ret; return ret;
} }
#ifdef BSP_USING_UART1 #ifdef BSP_USING_UART1
struct SerialDriver serial_driver_1; struct SerialDriver serial_driver_1;
struct SerialHardwareDevice serial_device_1; struct SerialHardwareDevice serial_device_1;
void USART1_IRQHandler(void) __attribute__((interrupt("WCH-Interrupt-fast"))); void USART1_IRQHandler(void) __attribute__((interrupt()));
void USART1_IRQHandler(void) void USART1_IRQHandler(void)
{ {
GET_INT_SP(); GET_INT_SP();
x_base level; x_base level;
level= DisableLocalInterrupt(); level = DisableLocalInterrupt();
isrManager.done->incCounter(); isrManager.done->incCounter();
EnableLocalInterrupt(level); EnableLocalInterrupt(level);
UartIsr(&serial_driver_1, &serial_device_1); UartIsr(&serial_driver_1, &serial_device_1);
@ -333,7 +323,7 @@ int InitHwUart(void)
static struct SerialBus serial_bus; static struct SerialBus serial_bus;
memset(&serial_bus, 0, sizeof(struct SerialBus)); memset(&serial_bus, 0, sizeof(struct SerialBus));
memset(&serial_driver_1, 0, sizeof(struct SerialDriver)); memset(&serial_driver_1, 0, sizeof(struct SerialDriver));
memset(&serial_device_1, 0, sizeof(struct SerialHardwareDevice)); memset(&serial_device_1, 0, sizeof(struct SerialHardwareDevice));
@ -343,7 +333,7 @@ int InitHwUart(void)
static struct SerialDevParam serial_dev_param; static struct SerialDevParam serial_dev_param;
memset(&serial_dev_param, 0, sizeof(struct SerialDevParam)); memset(&serial_dev_param, 0, sizeof(struct SerialDevParam));
serial_driver_1.drv_done = &drv_done; serial_driver_1.drv_done = &drv_done;
serial_driver_1.configure = &SerialDrvConfigure; serial_driver_1.configure = &SerialDrvConfigure;
serial_device_1.hwdev_done = &hwdev_done; serial_device_1.hwdev_done = &hwdev_done;
@ -354,11 +344,11 @@ int InitHwUart(void)
serial_cfg.hw_cfg.serial_register_base = (uint32)USART1; serial_cfg.hw_cfg.serial_register_base = (uint32)USART1;
serial_cfg.hw_cfg.serial_irq_interrupt = USART1_IRQn; serial_cfg.hw_cfg.serial_irq_interrupt = USART1_IRQn;
#endif #endif
serial_driver_1.private_data = (void*)&serial_cfg; serial_driver_1.private_data = (void*)&serial_cfg;
serial_dev_param.serial_work_mode = SIGN_OPER_INT_RX; serial_dev_param.serial_work_mode = SIGN_OPER_INT_RX;
serial_device_1.haldev.private_data = (void *)&serial_dev_param; serial_device_1.haldev.private_data = (void*)&serial_dev_param;
ret = BoardSerialBusInit(&serial_bus, &serial_driver_1, SERIAL_BUS_NAME_1, SERIAL_DRV_NAME_1); ret = BoardSerialBusInit(&serial_bus, &serial_driver_1, SERIAL_BUS_NAME_1, SERIAL_DRV_NAME_1);
if (EOK != ret) { if (EOK != ret) {
@ -366,7 +356,7 @@ int InitHwUart(void)
return ERROR; return ERROR;
} }
ret = BoardSerialDevBend(&serial_device_1, (void *)&serial_cfg, SERIAL_BUS_NAME_1, SERIAL_1_DEVICE_NAME_0); ret = BoardSerialDevBend(&serial_device_1, (void*)&serial_cfg, SERIAL_BUS_NAME_1, SERIAL_1_DEVICE_NAME_0);
if (EOK != ret) { if (EOK != ret) {
KPrintf("InitHwUart uarths error ret %u\n", ret); KPrintf("InitHwUart uarths error ret %u\n", ret);
return ERROR; return ERROR;
@ -384,14 +374,14 @@ int InitHwUart(void)
GPIO_Init(GPIOA, &gpio_init_struct); GPIO_Init(GPIOA, &gpio_init_struct);
USART_InitTypeDef usart_init_struct; USART_InitTypeDef usart_init_struct;
usart_init_struct.USART_BaudRate = 115200; usart_init_struct.USART_BaudRate = 115200;
usart_init_struct.USART_HardwareFlowControl = USART_HardwareFlowControl_None; usart_init_struct.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
usart_init_struct.USART_Mode = USART_Mode_Tx|USART_Mode_Rx; usart_init_struct.USART_Mode = USART_Mode_Tx | USART_Mode_Rx;
usart_init_struct.USART_WordLength = USART_WordLength_8b; usart_init_struct.USART_WordLength = USART_WordLength_8b;
usart_init_struct.USART_StopBits = USART_StopBits_1; usart_init_struct.USART_StopBits = USART_StopBits_1;
usart_init_struct.USART_Parity = USART_Parity_No; usart_init_struct.USART_Parity = USART_Parity_No;
USART_Init((USART_TypeDef *)serial_cfg.hw_cfg.serial_register_base, &usart_init_struct); USART_Init((USART_TypeDef*)serial_cfg.hw_cfg.serial_register_base, &usart_init_struct);
USART_Cmd((USART_TypeDef*)serial_cfg.hw_cfg.serial_register_base, ENABLE); USART_Cmd((USART_TypeDef*)serial_cfg.hw_cfg.serial_register_base, ENABLE);
return ret; return ret;
} }