shell 在tcp上的应用

发布于 2014-10-21 20:29:05 浏览：3978 订阅该版

大家都知道RTT的 shell很好用，但是只能通过串口，无疑在系统使用网络，而串口又不足的情况增加了不少限制，

本帖提供一种将 shell  设备设置为tcp的方案

设计为创建一个tcp服务器，和一个serial 设备，tcp服务器收到数据则等同于串口ISR， 操作serial 缓存，

初始化之后  使用超级终端  telnet  目标板即可启动  tcp上的 shell
下面为代码

```#include "serial.h"
#include <stm32f4xx_hal_dma.h>
#include <stm32f4xx_hal_usart.h>
#include <shell.h>

#include <finsh.h>
#include <lwip/api.h>
#include <lwip/sockets.h>

int connected;
/* RT-Thread Device Interface */
static rt_err_t rt_tcp_serial_init (rt_device_t dev)
{
    struct stm32_serial_device* uart = (struct stm32_serial_device*) dev->user_data;

if (!(dev->flag & RT_DEVICE_FLAG_ACTIVATED))
    {
        if (dev->flag & RT_DEVICE_FLAG_INT_RX)
        {
            rt_memset(uart->int_rx->rx_buffer, 0,
                sizeof(uart->int_rx->rx_buffer));
            uart->int_rx->read_index = 0;
            uart->int_rx->save_index = 0;
        }
        dev->flag |= RT_DEVICE_FLAG_ACTIVATED;
    }

return RT_EOK;
}

static rt_err_t rt_tcp_serial_open(rt_device_t dev, rt_uint16_t oflag)
{
    return RT_EOK;
}

static rt_err_t rt_tcp_serial_close(rt_device_t dev)
{
    return RT_EOK;
}

static rt_size_t rt_tcp_serial_read (rt_device_t dev, rt_off_t pos, void* buffer, rt_size_t size)
{
    rt_uint8_t* ptr;
    rt_err_t err_code;
    struct stm32_serial_device* uart;

ptr = buffer;
    err_code = RT_EOK;
    uart = (struct stm32_serial_device*)dev->user_data;

if (dev->flag & RT_DEVICE_FLAG_INT_RX)
    {
        /* interrupt mode Rx */
        while (size)
        {
            rt_base_t level;

/* disable interrupt */
            level = rt_hw_interrupt_disable();

if (uart->int_rx->read_index != uart->int_rx->save_index)
            {
                /* read a character */
                *ptr++ = uart->int_rx->rx_buffer[uart->int_rx->read_index];
                size--;

/* move to next position */
                uart->int_rx->read_index ++;
                if (uart->int_rx->read_index >= UART_RX_BUFFER_SIZE)
                    uart->int_rx->read_index = 0;
            }
            else
            {
                /* set error code */
                err_code = -RT_EEMPTY;

/* enable interrupt */
                rt_hw_interrupt_enable(level);
                break;
            }

/* enable interrupt */
            rt_hw_interrupt_enable(level);
        }
    }
    else
    {
        /* polling mode */
        while ((rt_uint32_t)ptr - (rt_uint32_t)buffer < size)
        {
            while (uart->uart_device->SR & USART_FLAG_RXNE)
            {
                *ptr = uart->uart_device->DR & 0xff;
                ptr ++;
            }
        }
    }

/* set error code */
    rt_set_errno(err_code);
    return (rt_uint32_t)ptr - (rt_uint32_t)buffer;
}
static rt_size_t rt_tcp_serial_write (rt_device_t dev, rt_off_t pos, const void* buffer, rt_size_t size)
{
    rt_uint8_t* ptr;
    rt_err_t err_code;
    struct stm32_serial_device* uart;

err_code = RT_EOK;
    ptr = (rt_uint8_t*)buffer;
    uart = (struct stm32_serial_device*)dev->user_data;

if (dev->flag & RT_DEVICE_FLAG_INT_TX)
    {
        /* interrupt mode Tx, does not support */
        RT_ASSERT(0);
    }
    {
			
			  
        /* polling mode */
        if (dev->flag & RT_DEVICE_FLAG_STREAM)
        {
        if(*(ptr+size-1)=='
')
					{
						char n[3]={'
','
',0};
						lwip_write(connected,buffer,size-1);
						lwip_write(connected,n,2);
						size++;
					}
					else 
					lwip_write(connected,buffer,size);
        }
				else
					lwip_write(connected,buffer,size);
    }

/* set error code */
    rt_set_errno(err_code);

return size;
}

static rt_err_t rt_tcp_serial_control (rt_device_t dev, rt_uint8_t cmd, void *args)
{
    struct stm32_serial_device* uart;

RT_ASSERT(dev != RT_NULL);

uart = (struct stm32_serial_device*)dev->user_data;
    switch (cmd)
    {
    case RT_DEVICE_CTRL_SUSPEND:
        /* suspend device */
        dev->flag |= RT_DEVICE_FLAG_SUSPENDED;
        break;

case RT_DEVICE_CTRL_RESUME:
        /* resume device */
        dev->flag &= ~RT_DEVICE_FLAG_SUSPENDED;
        break;
    }

return RT_EOK;
}

/*
 * serial register for STM32
 * support STM32F103VB and STM32F103ZE
 */
rt_err_t rt_hw_tcp_serial_register(rt_device_t device, const char* name, rt_uint32_t flag, struct stm32_serial_device *serial)
{
    RT_ASSERT(device != RT_NULL);

if ((flag & RT_DEVICE_FLAG_DMA_RX) ||
        (flag & RT_DEVICE_FLAG_INT_TX))
    {
        RT_ASSERT(0);
    }

device->type        = RT_Device_Class_Char;
    device->rx_indicate = RT_NULL;
    device->tx_complete = RT_NULL;
    device->init        = rt_tcp_serial_init;
    device->open        = rt_tcp_serial_open;
    device->close       = rt_tcp_serial_close;
    device->read        = rt_tcp_serial_read;
    device->write       = rt_tcp_serial_write;
    device->control     = rt_tcp_serial_control;
    device->user_data   = serial;

/* register a character device */
    return rt_device_register(device, name, RT_DEVICE_FLAG_RDWR | flag);
}

struct stm32_serial_int_rx rx_buff;
struct stm32_serial_device tcp_serial={0,&rx_buff,0};
struct rt_device tcp_serial_device;
char* old_shell;
void  tcp_serial_rev(void*arg)
{
	char buff[UART_RX_BUFFER_SIZE];
	int recv_len;
	while(1)
	{
	recv_len=lwip_recv(*(int*)arg,buff,UART_RX_BUFFER_SIZE-1,0);
	if(recv_len<=0)
	{
		int err,errsize=4;
		lwip_getsockopt(*(int*)arg,SOL_SOCKET,SO_ERROR,&err,&errsize);
		if(err== ENOTCONN)
		{
		lwip_close(*(int*)arg);
		if(old_shell)
		{
		rt_console_set_device(old_shell);	
		finsh_set_device(old_shell);//?è?????????? shell
		finsh_set_echo(1);
		}
		return ;
		}
	}
	{int i;
		if(buff[recv_len-2]=='
')
		{
		buff[recv_len-2]='
';
			recv_len--;
		}
	for(i=0;i<recv_len;i++)
		{
		tcp_serial.int_rx->rx_buffer[tcp_serial.int_rx->save_index++]=buff*;
			if(tcp_serial.int_rx->save_index>=UART_RX_BUFFER_SIZE)
		tcp_serial.int_rx->save_index=0;
		}
	}
	
	if (tcp_serial.int_rx->save_index == tcp_serial.int_rx->read_index)
     {
      tcp_serial.int_rx->read_index ++;
      if (tcp_serial.int_rx->read_index >= UART_RX_BUFFER_SIZE)
      tcp_serial.int_rx->read_index = 0;
     }
        /* invoke callback */
        if (tcp_serial_device.rx_indicate != RT_NULL)
        {
            rt_size_t rx_length;

/* get rx length */
            rx_length = tcp_serial.int_rx->read_index > tcp_serial.int_rx->save_index ?
                UART_RX_BUFFER_SIZE - tcp_serial.int_rx->read_index + tcp_serial.int_rx->save_index :
                tcp_serial.int_rx->save_index - tcp_serial.int_rx->read_index;

tcp_serial_device.rx_indicate(&tcp_serial_device, rx_length);
        }
		 
		}
}
void serial_init(void*arg)
{
	rt_thread_t serial_thread;
	struct sockaddr_in addr;
	err_t err;
	int sock=-1;
	rt_uint32_t sin_size;
	if ((sock = socket(AF_INET, SOCK_STREAM, 0)) == -1)
	{
		rt_kprintf("create socket error
");
		//goto _exit;
	}
	/* initialize server address */
	addr.sin_family = AF_INET;
	addr.sin_port = htons(23);
	addr.sin_addr.s_addr = INADDR_ANY;
	rt_memset(&(addr.sin_zero),8, sizeof(addr.sin_zero));
	/* bind to server address */
		if (lwip_bind(sock, (struct sockaddr *)&addr, sizeof(struct sockaddr)) == -1)
		{
		rt_kprintf("bind address failed
");
		//goto _exit;
		}
			/* listen */
			if (listen(sock, 1) == -1)
			{
				rt_kprintf("listen error
");
				//goto _exit;
			}
	sin_size = sizeof(struct sockaddr_in);
	for(;;)
	{
	 connected = lwip_accept(sock, (struct sockaddr *)&addr, &sin_size);
		{
			old_shell=(char*)finsh_get_device();
			rt_console_set_device("tcp_serial");	
			finsh_set_device("tcp_serial");
			finsh_set_echo(0);
			serial_thread=rt_thread_create("tcp_serial_rev",tcp_serial_rev,&connected,1024,10,5);
			if(serial_thread!=RT_NULL)
			rt_thread_startup(serial_thread);
		}
	}
}
void rt_hw_tcp_serial_init(void)
{
	rt_thread_t serial_init_thread;
  serial_init_thread=rt_thread_create("serial_init",serial_init,RT_NULL,512,15,5);
	if(serial_init_thread!=RT_NULL)
	rt_thread_startup(serial_init_thread);
	
	rt_hw_tcp_serial_register(&tcp_serial_device,"tcp_serial",RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_INT_RX | RT_DEVICE_FLAG_STREAM, &tcp_serial);
}
/*@}*/
```