void USART1_IRQHandler(void)
{
rt_uint8_t ch;
rt_interrupt_enter();
if( USART_GetITStatus( USART1, USART_IT_RXNE ) != RESET )
{
ch = USART_ReceiveData( USART1 );
USART_ClearITPendingBit( USART1, USART_IT_RXNE );
//rt_ringbuffer_putchar(&rb_vuart,ch);
if(flag_bd_upgrade_uart==0)
{
rt_ringbuffer_putchar(&rb_vuart,ch);
//if (dev_vuart.rx_indicate != RT_NULL) /*默认finsh使用*/
{
dev_vuart.rx_indicate(&dev_vuart,1);
}
}
#if 1
else /*接收升级数据，由于串口波特率可变,需要同步到正确的数据头*/
{
switch(bd_packet_status)
{
case BD_SYNC_40:
if(ch==0x40)
{
rt_ringbuffer_init(&rb_vuart,vuart_rxbuf,VUART_RXBUF_SIZE);
rt_ringbuffer_putchar(&rb_vuart,ch);
bd_packet_status=BD_SYNC_0D;
}
break;
case BD_SYNC_0D:
if(ch==0x0D) bd_packet_status=BD_SYNC_0A;
rt_ringbuffer_putchar(&rb_vuart,ch);
break;
case BD_SYNC_0A:
if(ch==0x0A) bd_packet_status=BD_SYNC_40;
else bd_packet_status=BD_SYNC_0D;
rt_ringbuffer_putchar(&rb_vuart,ch);
break;
}
}
#endif
}
rt_interrupt_leave();
}
static int _vcom_putc(struct rt_serial_device *serial, char c)
{
rt_uint32_t level;
if (vcom_connected != RT_TRUE) return 0;
level = rt_hw_interrupt_disable();
if (RT_RINGBUFFER_EMPTY(&tx_ringbuffer))
{
rt_ringbuffer_putchar(&tx_ringbuffer, c);
}
rt_hw_interrupt_enable(level);
return 1;
}
static rt_size_t telnet_write (rt_device_t dev, rt_off_t pos, const void* buffer, rt_size_t size)
{
const rt_uint8_t *ptr;
ptr = (rt_uint8_t*) buffer;
rt_mutex_take(telnet->tx_ringbuffer_lock, RT_WAITING_FOREVER);
while (size)
{
if (*ptr == '\n')
rt_ringbuffer_putchar(&telnet->tx_ringbuffer, '\r');
if (rt_ringbuffer_putchar(&telnet->tx_ringbuffer, *ptr) == 0) /* overflow */
break;
ptr++;
size--;
}
rt_mutex_release(telnet->tx_ringbuffer_lock);
/* send data to telnet client */
send_to_client(telnet);
return (rt_uint32_t) ptr - (rt_uint32_t) buffer;
}
/***********************************************************
* Function:
* Description: uart4的中断服务函数
* Input:
* Input:
* Output:
* Return:
* Others:
***********************************************************/
void UART4_IRQHandler( void )
{
rt_interrupt_enter( );
if( USART_GetITStatus( UART4, USART_IT_RXNE ) != RESET )
{
rt_ringbuffer_putchar( &rb_uart4_rx, USART_ReceiveData( UART4 ) );
USART_ClearITPendingBit( UART4, USART_IT_RXNE );
//rt_sem_release( &sem_uart );
last_tick = rt_tick_get( );
}
/*
if (USART_GetITStatus(UART4, USART_IT_TC) != RESET)
{
USART_ClearITPendingBit(UART4, USART_IT_TC);
}
*/
rt_interrupt_leave( );
}
static int _vcom_putc(struct rt_serial_device *serial, char c)
{
rt_uint32_t level;
int cnt;
/*if (vcom_connected != RT_TRUE)
{
return 0;
}*/
/* if the buffer is full, there is a chance that the host would pull some
* data out soon. But we cannot rely on that and if we wait to long, just
* return. */
for (cnt = 500;
RT_RINGBUFFER_EMPTY(&tx_ringbuffer) == 0 && cnt;
cnt--)
{
/*rt_kprintf("wait for %d\n", cnt);*/
/*if (vcom_connected != RT_TRUE)
return 0;*/
}
if (cnt == 0)
{
/* OK, we believe that the connection is lost. So don't send any more
* data and act as the USB cable is not plugged in. Reset the VCOM
* state machine */
_vcom_reset_state();
return 0;
}
level = rt_hw_interrupt_disable();
if (RT_RINGBUFFER_EMPTY(&tx_ringbuffer))
{
rt_ringbuffer_putchar(&tx_ringbuffer, c);
}
rt_hw_interrupt_enable(level);
return 1;
}
static void wrtnode2r_spi_stm32_set_read_buf_data(rt_uint8_t ch)
{
rt_ringbuffer_putchar(&spi_bridge.read_buf, ch);
}
/* process rx data */
static void process_rx(struct telnet_session* telnet, rt_uint8_t *data, rt_size_t length)
{
rt_size_t rx_length, index;
for (index = 0; index < length; index ++)
{
switch(telnet->state)
{
case STATE_IAC:
if (*data == TELNET_IAC)
{
rt_mutex_take(telnet->rx_ringbuffer_lock, RT_WAITING_FOREVER);
/* put buffer to ringbuffer */
rt_ringbuffer_putchar(&(telnet->rx_ringbuffer), *data);
rt_mutex_release(telnet->rx_ringbuffer_lock);
telnet->state = STATE_NORMAL;
}
else
{
/* set telnet state according to received package */
switch (*data)
{
case TELNET_WILL: telnet->state = STATE_WILL; break;
case TELNET_WONT: telnet->state = STATE_WONT; break;
case TELNET_DO: telnet->state = STATE_DO; break;
case TELNET_DONT: telnet->state = STATE_DONT; break;
default: telnet->state = STATE_NORMAL; break;
}
}
break;
/* don't option */
case STATE_WILL:
case STATE_WONT:
send_option_to_client(telnet, TELNET_DONT, *data);
telnet->state = STATE_NORMAL;
break;
/* won't option */
case STATE_DO:
case STATE_DONT:
send_option_to_client(telnet, TELNET_WONT, *data);
telnet->state = STATE_NORMAL;
break;
case STATE_NORMAL:
if (*data == TELNET_IAC) telnet->state = STATE_IAC;
else if (*data != '\r') /* ignore '\r' */
{
rt_mutex_take(telnet->rx_ringbuffer_lock, RT_WAITING_FOREVER);
/* put buffer to ringbuffer */
rt_ringbuffer_putchar(&(telnet->rx_ringbuffer), *data);
rt_mutex_release(telnet->rx_ringbuffer_lock);
}
break;
}
data ++;
}
rt_mutex_take(telnet->rx_ringbuffer_lock, RT_WAITING_FOREVER);
/* get total size */
rx_length = rt_ringbuffer_data_len(&telnet->rx_ringbuffer);
rt_mutex_release(telnet->rx_ringbuffer_lock);
/* indicate there are reception data */
if ((rx_length > 0) && (telnet->device.rx_indicate != RT_NULL))
telnet->device.rx_indicate(&telnet->device, rx_length);
return;
}
