WhyCan Forum(哇酷开发者社区)

    if((sock=socket(AF_INET,SOCK_STREAM,0))==-1)
    {
        rt_kprintf("Socket  error\n");
        rt_free(tcp_recv_data);
        return;
    }

    while (1)
    {
        bytes_received=recv(sock,tcp_recv_data,BUFSZ-1,0);
        if (bytes_received<0)
        {
            closesocket(sock);
            rt_kprintf("\nreceived  error-1,  close   the socket.\r\n");
            rt_free(tcp_recv_data);
            break;
        }
        else    if(bytes_received==0)
        {
            closesocket(sock);
            rt_kprintf("\nreceived  error0,  close   the socket.\r\n");
            rt_free(tcp_recv_data);
            break;
        }
        tcp_recv_data[bytes_received]='\0';
        {
            rt_kprintf("thread1: recv msg from msg queue, the content:%c\n", tcp_recv_data[0]);
            can_msg.data[0]=tcp_recv_data[0];
            can_msg.data[1]=tcp_recv_data[1];
            can_msg.data[2]=tcp_recv_data[2];
            can_msg.data[3]=tcp_recv_data[3];
            can_msg.data[4]=tcp_recv_data[4];
            can_msg.data[5]=tcp_recv_data[5];
            can_msg.data[6]=tcp_recv_data[6];
            can_msg.data[7]=tcp_recv_data[7];
            can_size=rt_device_write(can_dev,0,&can_msg,sizeof(can_msg));
        }

        /* 从消息队列中接收消息 */
        if (rt_mq_recv(&can_rx_mq, &can_recv_data, 8, 1000) == RT_EOK)
        {
            rt_kprintf("thread1: recv msg from msg queue, the content:%c\n", can_recv_data[0]);
            send(sock,&can_recv_data,8,0);
            // send(sock,"hahahaha",8,0);
        }

        /* 延时 50ms */
        rt_thread_mdelay(50);
    }
    rt_kprintf("thread1: detach mq \n");
    rt_mq_detach(&can_rx_mq);

bytes_received=recv(sock,tcp_recv_data,BUFSZ-1,MSG_DONTWAIT)

    maxfdp1 =   sock+1;
    tim.tv_sec=0;
    tim.tv_usec=100000;

    while (1)
    {
        FD_ZERO(&readset);
        FD_SET(sock,&readset);
        i=select(maxfdp1,&readset,0,0,&tim);
        if(i==0)
            continue;
        if(FD_ISSET(sock,&readset))
        {
            bytes_received=recv(sock,tcp_recv_data,BUFSZ-1,MSG_DONTWAIT);
            if(bytes_received==-1)
            {...}
            else if (bytes_received<0)
            {...}
            else    if(bytes_received==0)
            {...}
            tcp_recv_data[bytes_received]='\0';
            {...}
        }

        /* 从消息队列中接收消息 */
        if (rt_mq_recv(&can_rx_mq, &can_recv_data, 8, 100) == RT_EOK)
        {
            rt_kprintf("thread1: recv msg from msg queue, the content:%c\n", can_recv_data[0]);
            send(sock,&can_recv_data,8,0);
        }

(rt_object_get_type(&mb->parent.parent) == RT_Object_Class_MailBox) assertion failed at function:rt_mb_send_wait, line number:

#include <rtthread.h>
#include "rtdevice.h"

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

// #include    <sys/select.h>
// #include    <sys/socket.h>
// #include    <netdb.h>
#include    <string.h>
#include    <finsh.h>


#define BUFSZ   1024

#define CAN_DEV_NAME    "can1"

static  int sock;

ALIGN(RT_ALIGN_SIZE)
static char thread1_stack[1024];
static struct rt_thread thread1;

static  struct rt_semaphore rx_sem;
static  rt_device_t can_dev;

static  rt_err_t    can_rx_call(rt_device_t dev,    rt_size_t   size)
{
    rt_sem_release(&rx_sem);
    return  RT_EOK;
}

static  void    can_rx_thread(void  *parameter)
{
    int i;
    rt_err_t    res;
    struct rt_can_msg   rxmsg={0};
    char    tcp_send_data[]="hahaha\r\n";
    
    rt_device_set_rx_indicate(can_dev,  can_rx_call);
    while(1)
    {
        rt_sem_take(&rx_sem,RT_WAITING_FOREVER);
        rt_device_read(can_dev,0,&rxmsg,sizeof(rxmsg));
        rt_kprintf("ID:%x",rxmsg.id);
        for(i=0;i<8;i++)
        {
            rt_kprintf("%2x",rxmsg.data[i]);
        }
        rt_kprintf("\n");

        res = send(sock, rxmsg.data, rxmsg.len, 0);

        rt_kprintf("can_rx_thread: send message - %c\n", rxmsg.data[0]);

        /* 延时 50ms */
        rt_thread_mdelay(50);
    }
}

/* 线程 1 入口函数 */
void can2tcp(int  argc,char *argv[])
{
    int i;
    struct rt_can_msg can_msg = {0};
    rt_err_t    res;
    rt_size_t   can_size;
    rt_thread_t thread_can_rx;
    char    can_name[RT_NAME_MAX];

    char    *tcp_recv_data;
    struct  hostent *host;
    // int sock,   bytes_received;
    int bytes_received;
    struct sockaddr_in  server_addr;
    const   char    *url;
    int port;
    int maxfdp1;
    fd_set readset;
    struct timeval   tim;

    uint8_t can_recv_data[8];
    char sendData[]="hahahaha";

    url =  "192.168.1.143";
    port   =    5000;

/*-------------初始化tcp client---------------------*/

    host    =   gethostbyname(url);
    tcp_recv_data    =   rt_malloc(BUFSZ);
    if(tcp_recv_data==RT_NULL)
    {
        rt_kprintf("No  memory\n");
        return;
    }
    
    // if((sock=socket(AF_INET,SOCK_STREAM,0))==-1)
    // {
    //     rt_kprintf("Socket  error\n");
    //     rt_free(tcp_recv_data);
    //     return;
    // }

    // server_addr.sin_family=AF_INET;
    // server_addr.sin_port=htons(port);
    // server_addr.sin_addr=*((struct  in_addr*)host->h_addr);
    // rt_memset(&(server_addr.sin_zero),0,sizeof(server_addr.sin_zero));

    // if (connect(sock,(struct sockaddr*)&server_addr,sizeof(struct    sockaddr))==-1)
    // {
    //     rt_kprintf("Connect fail!\n");
    //     closesocket(sock);
    //     rt_free(tcp_recv_data);
    //     return;
    // }
    // else
    // {
    //     rt_kprintf("Connect successful\n");
    // }

/*-------------打开can线程----------------*/

    rt_strncpy(can_name,CAN_DEV_NAME,RT_NAME_MAX);

    can_dev =   rt_device_find(can_name);
    if(!can_dev)
    {
        rt_kprintf("find    %s  failed!\n",can_name);
        return;
    }

    rt_sem_init(&rx_sem,"rx_sem",0,RT_IPC_FLAG_FIFO);

    can_msg.id=0x78;
    can_msg.ide=RT_CAN_STDID;
    can_msg.rtr=RT_CAN_DTR;
    can_msg.len=8;

    res=rt_device_open(can_dev,RT_DEVICE_FLAG_INT_TX|RT_DEVICE_FLAG_INT_RX);
    RT_ASSERT(res==RT_EOK);

    thread_can_rx=rt_thread_create("can_rx",can_rx_thread,RT_NULL,1024,25,10);
    if(thread_can_rx!=RT_NULL)
    {
        rt_thread_startup(thread_can_rx);
    }
    else
    {
        rt_kprintf("creat can_rx thread failed!\n");
    }

/*-------------tcp client主循环-------------------*/

    uint8_t buf[8] = {0,0,0,0,0,0,0,0};
    rt_uint8_t cnt = 0;

    maxfdp1 =   sock+1;
    tim.tv_sec=0;
    tim.tv_usec=100;

    while(1)
    {
    sock=-1;
    while(sock==-1)
    {
        sock=socket(AF_INET,SOCK_STREAM,0);
        int mode = 0;  //阻塞模式
		ioctlsocket(sock, FIONBIO, &mode);
    }
    rt_kprintf("socket is created.\r\n");

    server_addr.sin_family=AF_INET;
    server_addr.sin_port=htons(port);
    server_addr.sin_addr=*((struct  in_addr*)host->h_addr);
    rt_memset(&(server_addr.sin_zero),0,sizeof(server_addr.sin_zero));

    // i=-1;
    // while(i==-1)
    // {
    //     i=connect(sock,(struct sockaddr*)&server_addr,sizeof(struct    sockaddr));
    // }
    // rt_kprintf("tcp is connected.\r\n");
    if (connect(sock, (struct sockaddr*)&server_addr, sizeof(struct sockaddr))==-1)
    {
        rt_kprintf("Connect fail!\n");
        closesocket(sock);
        // rt_free(tcp_recv_data);
        // return;
        continue;
    }
    else
    {
        rt_kprintf("Connect successful\n");
    }

    while (1)
    {
        FD_ZERO(&readset);
        FD_SET(sock,&readset);
        i=select(maxfdp1,&readset,0,0,&tim);
        if(i==0)
            continue;
        if(FD_ISSET(sock,&readset))
        {
            bytes_received=recv(sock,tcp_recv_data,BUFSZ-1,MSG_DONTWAIT);
            if (bytes_received<0)
            {
                closesocket(sock);
                rt_kprintf("\nreceived  error-1,  close   the socket.\r\n");
                rt_free(tcp_recv_data);
                break;
            }
            else    if(bytes_received==0)
            {
                closesocket(sock);
                rt_kprintf("\nreceived  error0,  close   the socket.\r\n");
                rt_free(tcp_recv_data);
                break;
            }
            tcp_recv_data[bytes_received]='\0';
            {
                // rt_kprintf("thread1: recv msg from msg queue, the content:%c\n", tcp_recv_data[0]);
                rt_kprintf("tcp_thread: recv data = %s\n", tcp_recv_data);
                can_msg.data[0]=tcp_recv_data[0];
                can_msg.data[1]=tcp_recv_data[1];
                can_msg.data[2]=tcp_recv_data[2];
                can_msg.data[3]=tcp_recv_data[3];
                can_msg.data[4]=tcp_recv_data[4];
                can_msg.data[5]=tcp_recv_data[5];
                can_msg.data[6]=tcp_recv_data[6];
                can_msg.data[7]=tcp_recv_data[7];
                can_size=rt_device_write(can_dev,0,&can_msg,sizeof(can_msg));
            }
        }


        /* 延时 50ms */
        rt_thread_mdelay(50);
    }
    }
}

/*--------------------------------------*/

/* 导出到 msh 命令列表中 */
MSH_CMD_EXPORT(can2tcp, can to tcp client sample);

    const char chOpt=1;   
    int   nErr=setsockopt(   m_socket,   IPPROTO_TCP,   TCP_NODELAY,   &chOpt,   sizeof(char));