RISC-V單片機快速入門04-基于RT_Thread Nano添加FinSH

    /* section information for finsh shell */
    . = ALIGN(4);
    __fsymtab_start = .;
    KEEP(*(FSymTab))
    __fsymtab_end = .;
    . = ALIGN(4);
    __vsymtab_start = .;
    KEEP(*(VSymTab))
    __vsymtab_end = .;
    . = ALIGN(4);
 
    /* section information for initial. */
    . = ALIGN(4);
    __rt_init_start = .;
    KEEP(*(SORT(.rti_fn*)))
    __rt_init_end = .;
    . = ALIGN(4);

    /* section information for modules */
    . = ALIGN(4);
    __rtmsymtab_start = .;
    KEEP(*(RTMSymTab))
    __rtmsymtab_end = .;

#define UART_RX_BUF_LEN 128
rt_uint8_t uart_rx_buf[UART_RX_BUF_LEN] = {0};
struct rt_ringbuffer uart_rxcb; /* 定義一個 ringbuffer cb */
static struct rt_semaphore shell_rx_sem; /* 定義一個靜態(tài)信號量 */


void gd_eval_com_init(uint32_t com)
{
 uint32_t com_id = 0U;
 if(EVAL_COM0 == com){
        com_id = 0U;
    }else if(EVAL_COM1 == com){
        com_id = 1U;
    }

 /* 初始化串口接收 ringbuffer  */
    rt_ringbuffer_init(&uart_rxcb, uart_rx_buf, UART_RX_BUF_LEN);

 /* 初始化串口接收數(shù)據(jù)的信號量 */
    rt_sem_init(&(shell_rx_sem), "shell_rx", 0, 0);

    eclic_irq_enable(USART0_IRQn, 1, 0);

 /* enable GPIO clock */
    rcu_periph_clock_enable(COM_GPIO_CLK[com_id]);

 /* enable USART clock */
    rcu_periph_clock_enable(COM_CLK[com_id]);

 /* connect port to USARTx_Tx */
    gpio_init(COM_GPIO_PORT[com_id], GPIO_MODE_AF_PP, GPIO_OSPEED_50MHZ, COM_TX_PIN[com_id]);

 /* connect port to USARTx_Rx */
    gpio_init(COM_GPIO_PORT[com_id], GPIO_MODE_IN_FLOATING, GPIO_OSPEED_50MHZ, COM_RX_PIN[com_id]);

 /* USART configure */
    usart_deinit(com);
    usart_baudrate_set(com, 115200U);
    usart_word_length_set(com, USART_WL_8BIT);
    usart_stop_bit_set(com, USART_STB_1BIT);
    usart_parity_config(com, USART_PM_NONE);
    usart_hardware_flow_rts_config(com, USART_RTS_DISABLE);
    usart_hardware_flow_cts_config(com, USART_CTS_DISABLE);
    usart_receive_config(com, USART_RECEIVE_ENABLE);
    usart_transmit_config(com, USART_TRANSMIT_ENABLE);
    usart_enable(com);
    usart_interrupt_enable(com, USART_INT_RBNE);
}

char rt_hw_console_getchar(const char str)
{
 int ch = 0;
    / 從 ringbuffer 中拿出數(shù)據(jù) */
 while (rt_ringbuffer_getchar(&uart_rxcb, (rt_uint8_t *)&ch) != 1)
    {
        rt_sem_take(&shell_rx_sem, RT_WAITING_FOREVER);
    }
 return ch;
}

void USART0_IRQHandler() {
 int ch = -1;
 int recv_flag = 0;
 /* enter interrupt /
    rt_interrupt_enter();
 if(RESET != usart_interrupt_flag_get(EVAL_COM0, USART_INT_FLAG_RBNE)){
 while (1)
        {
            ch = -1;
 if (RESET != usart_interrupt_flag_get(EVAL_COM0, USART_INT_FLAG_RBNE))
            {
                ch =  usart_data_receive(EVAL_COM0);
//                rt_kprintf("recv data is :%xrn", ch);
            }
 if (ch == -1)
            {
 break;
            }
            recv_flag = 1;
            / 讀取到數(shù)據(jù)，將數(shù)據(jù)存入 ringbuffer */
            rt_ringbuffer_putchar(&uart_rxcb, ch);
        }
//        if (1 == recv_flag)
//        {
            rt_sem_release(&shell_rx_sem);
//        }
    }
    rt_interrupt_leave();
}

新增ringbuffer.c函數(shù)
/* 第一部分：ringbuffer 實現(xiàn)部分 */
#include <rtthread.h>
#include <string.h>
#include "ringbuffer.h"
rt_inline enum rt_ringbuffer_state rt_ringbuffer_status(struct rt_ringbuffer *rb)
{
 if (rb->read_index == rb->write_index)
    {
 if (rb->read_mirror == rb->write_mirror)
 return RT_RINGBUFFER_EMPTY;
 else
 return RT_RINGBUFFER_FULL;
    }
 return RT_RINGBUFFER_HALFFULL;
}
/**
 * get the size of data in rb
 */
rt_size_t rt_ringbuffer_data_len(struct rt_ringbuffer *rb)
{
 switch (rt_ringbuffer_status(rb))
    {
 case RT_RINGBUFFER_EMPTY:
 return 0;
 case RT_RINGBUFFER_FULL:
 return rb->buffer_size;
 case RT_RINGBUFFER_HALFFULL:
 default:
 if (rb->write_index > rb->read_index)
 return rb->write_index - rb->read_index;
 else
 return rb->buffer_size - (rb->read_index - rb->write_index);
    };
}

void rt_ringbuffer_init(struct rt_ringbuffer *rb,
                        rt_uint8_t           *pool,
                        rt_int16_t            size)
{
    RT_ASSERT(rb != RT_NULL);
    RT_ASSERT(size > 0);

 /* initialize read and write index */
    rb->read_mirror = rb->read_index = 0;
    rb->write_mirror = rb->write_index = 0;

 /* set buffer pool and size */
    rb->buffer_ptr = pool;
    rb->buffer_size = RT_ALIGN_DOWN(size, RT_ALIGN_SIZE);
}

/**
 * put a character into ring buffer
 */
rt_size_t rt_ringbuffer_putchar(struct rt_ringbuffer *rb, const rt_uint8_t ch)
{
    RT_ASSERT(rb != RT_NULL);

 /* whether has enough space */
 if (!rt_ringbuffer_space_len(rb))
 return 0;

    rb->buffer_ptr[rb->write_index] = ch;

 /* flip mirror */
 if (rb->write_index == rb->buffer_size-1)
    {
        rb->write_mirror = ~rb->write_mirror;
        rb->write_index = 0;
    }
 else
    {
        rb->write_index++;
    }

 return 1;
}
/**
 * get a character from a ringbuffer
 */
rt_size_t rt_ringbuffer_getchar(struct rt_ringbuffer *rb, rt_uint8_t *ch)
{
    RT_ASSERT(rb != RT_NULL);

 /* ringbuffer is empty */
 if (!rt_ringbuffer_data_len(rb))
 return 0;

 /* put character */
    *ch = rb->buffer_ptr[rb->read_index];

 if (rb->read_index == rb->buffer_size-1)
    {
        rb->read_mirror = ~rb->read_mirror;
        rb->read_index = 0;
    }
 else
    {
        rb->read_index++;
    }

 return 1;
}