linux SOCKCAN 编程

1、首先进行CAN的波特率设置、过滤规则的设置、read()和write()函数设置为非堵塞方式发送和 接收（注意波特率的设置需要先关闭，再设置、然后打开 。

#define ip_cmd_open            "ifconfig can0 up"     /* 打开CAN0 */
#define ip_cmd_close           "ifconfig can0 down"   /* 关闭CAN0 */    
#define ip_cmd_set_５0k           "/usr/bin/ip link set can0 up type can bitrate ５００0000 loopback off"

int CAN_Set_Controller( void )
{    
    /*************************************************************/
    int sock_fd;
    struct sockaddr_can addr;
    struct ifreq ifr;

    /*************************************************************/
    /* 通过system调用ip命令设置CAN波特率 */
    system(ip_cmd_close);               
    system(ip_cmd_set_50k);
    system(ip_cmd_open);
    
    /*************************************************************/
    /* 创建套接口 sock_fd */
    sock_fd = socket(AF_CAN, SOCK_RAW, CAN_RAW);
    if(sock_fd < 0) {
        perror("socket create error!\n");
        return -1;
    }
    
    /*************************************************************/
    //将套接字与 can0 绑定
    strcpy(ifr.ifr_name, "can0");
    ioctl(sock_fd, SIOCGIFINDEX,&ifr); // can0 device

    ifr.ifr_ifindex = if_nametoindex(ifr.ifr_name);
    DBGT_printf("ifr_name:%s \n",ifr.ifr_name);
    DBGT_printf("can_ifindex:%d \n",ifr.ifr_ifindex);

    addr.can_family = AF_CAN;
    addr.can_ifindex = ifr.ifr_ifindex;
        
    if(bind(sock_fd, (struct sockaddr *)&addr, sizeof(addr)) < 0 )
    {
        perror("bind error!\n");
        return -1;
    }
    
    /*******************************设置过滤规则，根据需要选择过滤接收和发送设置******************************/
    // 定义接收规则，只接收表示符等于 0x201 的报文
    // struct can_filter rfilter[1];
    // rfilter[0].can_id = 0x201;
    // rfilter[0].can_mask = CAN_SFF_MASK;
    // setsockopt(sock_fd, SOL_CAN_RAW, CAN_RAW_FILTER, &rfilter, sizeof(rfilter));

    // 定义过滤器（3个）
    // struct can_filter rfilter[3];
    // rfilter[0].can_id = 0x201;
    // rfilter[0].can_mask = CAN_SFF_MASK;

    // rfilter[1].can_id = 0x401;
    // rfilter[1].can_mask = CAN_SFF_MASK;

    // rfilter[2].can_id = 0x601;
    // rfilter[2].can_mask = CAN_SFF_MASK;
    // setsockopt(s, SOL_CAN_RAW, CAN_RAW_FILTER, &rfilter, sizeof(rfilter));

    // 禁用过滤规则，本进程不接收报文，只负责发送
    // setsockopt(sock_fd, SOL_CAN_RAW, CAN_RAW_FILTER, NULL, 0);

    

    /*************************************************************/
    //设置read()和write()函数设置为非堵塞方式
    int flags;
    flags = fcntl(sock_fd, F_GETFL);
    flags |= O_NONBLOCK;
    fcntl(sock_fd, F_SETFL, flags);  
        
    /*************************************************************/
    /*返回套接口*/
    return sock_fd;  
    /*************************************************************/
}

/**********************************************************************

* 函数名称： void CAN_Write(int can_port, CanTxMsg send_msg)

* 功能描述： CAN报文发送接口

* 输入参数： can_port,端口号    

* 输出参数： send_msg：发送报文

***********************************************************************/

void CAN_Write(int can_port, CanTxMsg send_msg)

{

    unsigned char i;

    static unsigned int txcounter=0;

    int nbytes;

   

    struct can_frame txframe;

   

    txframe.can_id = send_msg.StdId;

    txframe.can_dlc = send_msg.DLC;

    memcpy(&txframe.data[0], &send_msg.Data[0], txframe.can_dlc);

    nbytes = write(can_port, &txframe, sizeof(struct can_frame)); //发送 frame[0]

   

    if(nbytes == sizeof(txframe))

    {

        DBGT_printf("txcounter=%d, ID=%03X, DLC=%d, data=%02X %02X %02X %02X %02X %02X %02X %02X \n", \

            txframe.can_id, txframe.can_dlc,  \

            txframe.data[0],\

            txframe.data[1],\

            txframe.data[2],\

            txframe.data[3],\

            txframe.data[4],\

            txframe.data[5],\

            txframe.data[6],\

            txframe.data[7] );

    }

    else

    {

        printf("Send Error frame[0], nbytes=%d\n!",nbytes);

    }

    return ;

}

void CAN_Read(int can_port, CanRxMsg* recv_msg)
{ 
    unsigned char i;
    static unsigned int rxcounter =0;
    
    int nbytes;
    struct can_frame rxframe;
        nbytes = read(can_port, &rxframe, sizeof(struct can_frame));
        if(nbytes>0)
        {
            //sysUsecTime();
            recv_msg->StdId = rxframe.can_id;
            recv_msg->DLC = rxframe.can_dlc;
            memcpy( recv_msg->Data, &rxframe.data[0], rxframe.can_dlc);
            DBGT_printf("接收 ID=%03X, DLC=%d, data=%02X %02X %02X %02X %02X %02X %02X %02X \n",  \
                rxframe.can_id, rxframe.can_dlc,  \
                rxframe.data[0],\
                rxframe.data[1],\
                rxframe.data[2],\
                rxframe.data[3],\
                rxframe.data[4],\
                rxframe.data[5],\
                rxframe.data[6],\
                rxframe.data[7] );
        }

    return ;
}

/************************************************************
* CAN发送报文结构定义
************************************************************/
typedef struct
{
  unsigned int StdId;  /* CAN标准帧ID，占11bit，范围：0~0x7FF */ 
  unsigned char DLC;     /* CAN报文数据长度， 范围：0~8  */ 
  unsigned char Data[8]; /* CAN报文数据内容，每个字节范围：0~0xFF*/
} CanTxMsg;

/** 
* CAN接收报文结构定义
*/
typedef struct
{
  unsigned int StdId;  /* CAN标准帧ID，范围：0~0x7FF */ 
  unsigned char DLC;     /* CAN报文数据长度， 范围：0~8  */ 
  unsigned char Data[8]; /* CAN报文数据内容，每个字节范围：0~0xFF*/
} CanRxMsg;
 

int main(int argc, char **argv)

{

int Can_Port = 0;

  CanTxMsg TxMessage;//发送报文
  CanRxMsg RxMessage; //接收报文 

Can_Port = CAN_Set_Controller();

while(1)

    {

        CAN_Read(Can_Port, &RxMessage);//接收到CAN数据

　　memcpy(TxMessage.Data,RxMessage.Data,RxMessage.DLC);
   　　　TxMessage.DLC=RxMessage.DLC;

 　　　　TxMessage.StdId=RxMessage.StdId;／／将接收到的ID以同样的ID发送出去

       CAN_Write(Can_Port, TxMessage);//将接收到的数据用CAN发送出去

        sleep(1);

    }

}