/*輸出一個字符，系統函數，函數名不可更改 */
void rt_hw_console_output(const char *str);

/* finsh 獲取一個字符，系統函數，函數名不可更改 */
char rt_hw_console_getchar(void)；

/* 移植 FinSH，實現命令行交互, 需要添加 FinSH 源碼，然后再對接 rt_hw_console_getchar */
char rt_hw_console_getchar(void)
{
  int ch = -1;
  if (USART_GetFlagStatus(USART1, USART_FLAG_RXDNE) != RESET)
  {
    ch = (int)USART_ReceiveData(USART1);
  }
  else
  {
    if(USART_GetFlagStatus(USART1, USART_FLAG_OREF) != RESET)
    {
      USART_ClrFlag(USART1,USART_FLAG_TXC);
    }
    rt_thread_mdelay(10);
  }
  return ch; 
}

/* 第一部分：ringbuffer 實現部分 */
#include 
#include 


#define rt_ringbuffer_space_len(rb) ((rb)->buffer_size - rt_ringbuffer_data_len(rb))


struct rt_ringbuffer
{
  rt_uint8_t *buffer_ptr;


  rt_uint16_t read_mirror : 1;
  rt_uint16_t read_index : 15;
  rt_uint16_t write_mirror : 1;
  rt_uint16_t write_index : 15;


  rt_int16_t buffer_size;
};


enum rt_ringbuffer_state
{
  RT_RINGBUFFER_EMPTY,
  RT_RINGBUFFER_FULL,
  /* half full is neither full nor empty */
  RT_RINGBUFFER_HALFFULL,
};


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;
}


/* 第二部分：finsh 移植對接部分 */
#define UART_RX_BUF_LEN 16
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; /* 定義一個靜態信號量 */


/**
 * [url=home.php?mod=space&uid=2666770]@Brief[/url] 配置USART接收中斷
 * [url=home.php?mod=space&uid=3142012]@param[/url] uint8_t IRQChannel, uint8_t PreemptionPriority, uint8_t SubPriority
 * @retval None
 */
static void BSP_USART_NVIC_Configuration(uint8_t IRQChannel, uint8_t PreemptionPriority, uint8_t SubPriority)
{
  NVIC_InitType NVIC_InitStructure; 


  /* Enable the USARTy Interrupt */
  NVIC_InitStructure.NVIC_IRQChannel = IRQChannel;
  NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = PreemptionPriority;
  NVIC_InitStructure.NVIC_IRQChannelSubPriority = SubPriority;
  NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
  NVIC_Init(&NVIC_InitStructure);
}


/**
 * @brief USART GPIO 配置
 * @param ST_BSP_USART_Dev *BSP_USART_Dev, uint32_t BaudRate, uint8_t PreemptionPriority, uint8_t SubPriority
 * @retval None
 */
void BSP_USART_Init(ST_BSP_USART_Dev *BSP_USART_Dev, uint32_t BaudRate, uint8_t PreemptionPriority, uint8_t SubPriority)
{
  GPIO_InitType GPIO_InitStructure;
  USART_InitType USART_InitStructure;


  /* config USART GPIO clock */
  RCC_EnableAPB2PeriphClk(BSP_USART_Dev->usart_rx_gpio_clk | BSP_USART_Dev->usart_tx_gpio_clk, ENABLE);


  /* config USART clock */
  RCC_EnableAPB2PeriphClk(BSP_USART_Dev->usart_clk, ENABLE);


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


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


  /* USART GPIO config */
  /* Configure USART Tx as alternate function push-pull */
  GPIO_InitStructure.Pin = BSP_USART_Dev->usart_tx_pin;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_InitPeripheral(BSP_USART_Dev->usart_tx_port, &GPIO_InitStructure);  
  /* Configure USART Rx as input floating */
  GPIO_InitStructure.Pin = BSP_USART_Dev->usart_rx_pin;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
  GPIO_InitPeripheral(BSP_USART_Dev->usart_rx_port, &GPIO_InitStructure);


  USART_DeInit(BSP_USART_Dev->usart);
  /* USART mode config */
  USART_InitStructure.BaudRate = BaudRate;
  USART_InitStructure.WordLength = USART_WL_8B;
  USART_InitStructure.StopBits = USART_STPB_1;
  USART_InitStructure.Parity = USART_PE_NO ;
  USART_InitStructure.HardwareFlowControl = USART_HFCTRL_NONE;
  USART_InitStructure.Mode = USART_MODE_RX | USART_MODE_TX;
  USART_Init(BSP_USART_Dev->usart, &USART_InitStructure);


  // 配置中斷
  BSP_USART_NVIC_Configuration(BSP_USART_Dev->usart_irqn, PreemptionPriority, SubPriority);
  /* 使能串口接收中斷 */
  USART_ConfigInt(BSP_USART_Dev->usart, USART_INT_RXDNE, ENABLE);
  //USART_ConfigInt(BSP_USART_Dev->usart, USART_INT_IDLEF, ENABLE); // 空閑中斷


  USART_Enable(BSP_USART_Dev->usart, ENABLE);
}




/*輸出一個字符，系統函數，函數名不可更改 */
void rt_hw_console_output(const char *str)
{
  rt_size_t i = 0, size = 0;
  char a = '
';
  
  /*清楚標志位*/
  USART_ClrFlag(USART1,USART_FLAG_TXC);
  
  size = rt_strlen(str);
  for (i = 0; i < size; i++)
  {
    if (*(str + i) == '
')
    {
      /* 發送一個字節數據到USART1 */
      USART_SendData(USART1, (uint8_t) a);
      /* 等待發送完畢 */
      while (USART_GetFlagStatus(USART1, USART_FLAG_TXC) == RESET);      
    }
    /* 發送一個字節數據到USART1 */
    USART_SendData(USART1, (uint8_t) *(str+i));
    /* 等待發送完畢 */    
    while (USART_GetFlagStatus(USART1, USART_FLAG_TXC) == RESET);  
  }
}


/* 移植 FinSH，實現命令行交互, 需要添加 FinSH 源碼，然后再對接 rt_hw_console_getchar */
/* 中斷方式 */
char rt_hw_console_getchar(void)
{
  char ch = 0;


  /* 從 ringbuffer 中拿出數據 */
  while (rt_ringbuffer_getchar(&uart_rxcb, (rt_uint8_t *)&ch) != 1)
  {
    rt_sem_take(&shell_rx_sem, RT_WAITING_FOREVER);
  } 
  return ch;  
}


/* 第三部分：中斷部分*/
void USART1_IRQHandler(void)
{
  int ch = -1;  
 
  /* enter interrupt */
  rt_interrupt_enter();     //在中斷中一定要調用這對函數，進入中斷
  
  if( (USART_GetIntStatus(USART1, USART_INT_RXDNE) != RESET) && (USART_GetFlagStatus(USART1, USART_FLAG_RXDNE) != RESET) )
  {   
      while (1)   
      {
        ch = -1;
        if(USART_GetIntStatus(USART1, USART_INT_RXDNE) != RESET)
        {
          ch = USART_ReceiveData(USART1);
        }
        if(ch ==-1)
        {
          break;
        }
        /* 讀取到數據，將數據存入 ringbuffer */
        rt_ringbuffer_putchar(&uart_rxcb, ch);
      }
      rt_sem_release(&shell_rx_sem);
  } 
  /* leave interrupt */
  rt_interrupt_leave();  //在中斷中一定要調用這對函數，離開中斷
}

uint32_t ChipUniqueID[3];


void GetChipID(void)
{
  ChipUniqueID[0] = *(volatile uint32_t *)(0x1FFFF7F0);//ID最高位
  ChipUniqueID[1] = *(volatile uint32_t *)(0x1FFFF7EC);//ID最高位
  ChipUniqueID[2] = *(volatile uint32_t *)(0x1FFFF7E8);//ID最高位


  rt_kprintf("
Chip ID id:0x%08X-0x%08X-0x%08X

",ChipUniqueID[0],ChipUniqueID[1],ChipUniqueID[2]);
}


MSH_CMD_EXPORT(GetChipID, Get 96 bit unique chip ID);


void GetFlashCapactity(void)
{
  rt_kprintf("
Chip flash capacity is:%dK

",*(volatile uint16_t *)(0x1FFFF7E0));
}


MSH_CMD_EXPORT(GetFlashCapactity, Get Chip flash capacity);