单片机/MCU论坛
直播中

嵌入式小能手

1年用户 738经验值
擅长:嵌入式技术
私信 关注
[文章]

嵌入式学习-飞凌嵌入式ElfBoard ELF 1板卡-CAN编程示例之socket CAN例程

注意：学习资料可在ElfBoard官方网站“资料”专区获取。
本节用到的源码路径：ELF 1开发板资料包\03-例程源码\03-1 命令行例程源码\06_elf1_cmd_can
can.c
  1. #include
  2. #include
  3. #include
  4. #include
  5. #include
  6. #include
  7. #include
  8. #include
  9. #include
  10. #include
  11. #include
  12. #include
  13. #include  /*PPSIX 终端控制定义*/
  14. #include "mycan.h"
  16. /*
  17. * @description        : 字符串按格式输出
  18. * [url=home.php?mod=space&uid=3142012]@param[/url] - *destpoint : 字符串格式缓冲区
  19. * @param - *fmt       : 多个参数
  20. * @return                       : 按格式输出字符串缓冲区首指针
  21. */
  22. char func_dprintf(char *destpoint, char *fmt, ...)
  23. {
  24.     va_list arg_ptr;
  25.     char ulen, *tmpBuf;
  27.     tmpBuf = destpoint;
  28.     va_start(arg_ptr, fmt);
  29.     ulen = vsprintf(tmpBuf, fmt, arg_ptr);
  31.     va_end(arg_ptr);
  32.     return ulen;
  33. }
  35. /*
  36. * @description     : 打开can外设，设置波特率，创建文件描述符
  37. * @param - *device : 设备名称
  38. * @param - para    : can应用参数
  39. * @return                    : 打开设备执成功返回文件描述符，失败返回-1
  40. */
  41. int func_open_can(char *device, struct_can_param para)
  42. {
  43.     FILE *fstream = NULL;
  44.     char buff[300] = {0}, command[50] = {0};
  45.     int fd = -1;
  46.     struct sockaddr_can addr;
  47.     struct ifreq ifr;
  49.     /*关闭can设备 ifconfig can0 down*/
  50.     memset(buff, 0, sizeof(buff));
  51.     memset(command, 0, sizeof(command));
  52.     func_dprintf(command, "ifconfig %s down", device);
  53.     printf("%s \n", command);
  55.     if (NULL == (fstream = popen(command, "w")))
  56.     {
  57.         fprintf(stderr, "execute command failed: %s", strerror(errno));
  58.     }
  59.     while (NULL != fgets(buff, sizeof(buff), fstream))
  60.     {
  61.         printf("%s\n", buff);
  62.         if (strstr(buff, "No such device") || strstr(buff, "Cannot find device"))
  63.             return -1;
  64.     }
  65.     pclose(fstream);
  66.     sleep(1);
  68.     /*设置can波特率 ip link set can0 up type can bitrate 250000 triple-sampling on*/
  69.     memset(buff, 0, sizeof(buff));
  70.     memset(command, 0, sizeof(command));
  71.     if (para.loopback_mode == 1)
  72.     {
  73.         func_dprintf(command, "ip link set %s up type can bitrate %d triple-sampling on loopback on", device, para.baudrate);
  74.     }
  75.     else
  76.     {
  77.         func_dprintf(command, "ip link set %s up type can bitrate %d triple-sampling on loopback off", device, para.baudrate);
  78.     }
  79.     printf("%s \n", command);
  81.     if (NULL == (fstream = popen(command, "w")))
  82.     {
  83.         fprintf(stderr, "execute command failed: %s", strerror(errno));
  84.     }
  85.     while (NULL != fgets(buff, sizeof(buff), fstream))
  86.     {
  87.         printf("%s\n", buff);
  88.         if (strstr(buff, "No such device") || strstr(buff, "Cannot find device"))
  89.             return -1;
  90.     }
  91.     pclose(fstream);
  92.     sleep(1);
  94.     /*打开can设备 ifconfig can0 up*/
  95.     memset(buff, 0, sizeof(buff));
  96.     memset(command, 0, sizeof(command));
  97.     func_dprintf(command, "ifconfig %s up", device);
  98.     printf("%s \n", command);
  100.     if (NULL == (fstream = popen(command, "w")))
  101.     {
  102.         fprintf(stderr, "execute command failed: %s", strerror(errno));
  103.     }
  104.     while (NULL != fgets(buff, sizeof(buff), fstream))
  105.     {
  106.         printf("%s\n", buff);
  107.         if (strstr(buff, "No such device") || strstr(buff, "Cannot find device"))
  108.             return -1;
  109.     }
  110.     pclose(fstream);
  111.     sleep(3);
  113.     /* 创建 socket */
  114.     fd = socket(PF_CAN, SOCK_RAW, CAN_RAW);
  115.     if (fd < 0)
  116.     {
  117.         printf("socket:%s", strerror(errno));
  118.         return -1;
  119.     }
  120.     /* 设置接口设备名称 */
  121.     strcpy(ifr.ifr_name, device);
  122.     /* 确定接口 index */
  123.     if (ioctl(fd, SIOCGIFINDEX, &ifr) < 0)
  124.     {
  125.         printf("SIOCGIFINDEX:%s\n", strerror(errno));
  126.         return -1;
  127.     }
  129.     memset(&addr, 0, sizeof(addr));
  130.     addr.can_family = AF_CAN;
  131.     addr.can_ifindex = ifr.ifr_ifindex;
  132.     /* 绑定 socket到 CAN 接口 */
  133.     if (bind(fd, (struct sockaddr *)&addr, sizeof(addr)) < 0)
  134.     {
  135.         printf("bind:%s\n", strerror(errno));
  136.         return -1;
  137.     }
  139.     return fd;
  140. }
  142. /*
  143. * @description : 设置can回环模式和过滤规则
  144. * @param - fd  : 文件描述符
  145. * @param - para: can应用参数
  146. * @return                : 设置成功返回1，失败返回-1
  147. */
  148. int func_set_can(int fd, struct_can_param para)
  149. {
  150.     int loopback = 1;
  151.     int reciveown = 1;
  153.     if (para.loopback_mode == 1)
  154.     {
  155.         // 回环设置 0 关闭回环  1 打开回环
  156.         //  setsockopt(fd, SOL_CAN_RAW, CAN_RAW_LOOPBACK, &loopback, sizeof(loopback));
  157.         // 接收自己的帧 0 不接收自己帧 1 接收自己帧
  158.         //  setsockopt(fd, SOL_CAN_RAW, CAN_RAW_RECV_OWN_MSGS, &reciveown, sizeof(reciveown));
  159.     }
  161.     /* 设置过滤规则 */
  162.     if (setsockopt(fd, SOL_CAN_RAW, CAN_RAW_FILTER, ¶.filter, sizeof(para.filter)) < 0)
  163.     {
  164.         printf("error when set filter\n");
  165.         return -1;
  166.     }
  167.     return 1;
  168. }
  170. /*
  171. * @description    : can接收一个can帧
  172. * @param - fd     : 文件描述符
  173. * @param - *pframe: 一个can帧结构体指针
  174. * @return                   : 接收数据长度
  175. */
  176. int func_receive_can_frame(int fd, struct can_frame *pframe)
  177. {
  178.     int rx_count = 0;
  180.     rx_count = recv(fd, pframe, sizeof(*pframe), 0);
  181.     if (rx_count <= 0)
  182.     {
  183.         return rx_count;
  184.     }
  185.     else
  186.     {
  187.         if (pframe->can_id & CAN_EFF_FLAG) /*如果是扩展帧，清除扩展帧标识*/
  188.         {
  189.             pframe->can_id &= (~CAN_EFF_FLAG);
  190.         }
  191.         else
  192.         {
  193.             pframe->can_id &= (~CAN_SFF_MASK);
  194.         }
  195.     }
  197.     return pframe->can_dlc;
  198. }
  200. /*
  201. * @description  : can接收一组数据包
  202. * @param - fd   : 文件描述符
  203. * @param - *buff: 要接收can一组数据的缓冲区首指针
  204. * @param - len  : 接收到一组数据的长度
  205. * @return                 : 接收数据长度
  206. */
  207. int func_receive_can_buff(int fd, unsigned char *buff, int len)
  208. {
  209.     int receive_len = 0, total_receive_len = 0;
  210.     struct can_frame frame;
  211.     int i = 0;
  213.     while (1)
  214.     {
  215.         receive_len = func_receive_can_frame(fd, &frame);
  216.         for (i = 0; i < receive_len; i++)
  217.         {
  218.             *(buff + total_receive_len) = frame.data[i];
  219.             total_receive_len++;
  220.         }
  221.         if ((receive_len < 8) || (total_receive_len > (len - 8)))
  222.         {
  223.             return total_receive_len;
  224.         }
  225.     }
  226.     return total_receive_len;
  227. }
  229. /*
  230. * @description    : can发送一个can帧
  231. * @param - fd     : 文件描述符
  232. * @param - *pframe: 一个can帧结构体指针
  233. * @param - param  : can应用参数
  234. * @return                   : 发送数据长度，发送失败返回-1
  235. */
  236. int func_send_can_frame(int fd, struct can_frame *pframe, struct_can_param param)
  237. {
  238.     int result = 0;
  240.     if (param.extend == 1) /*扩展帧增加扩展帧标志*/
  241.     {
  242.         pframe->can_id &= CAN_EFF_MASK;
  243.         pframe->can_id |= CAN_EFF_FLAG;
  244.     }
  245.     else
  246.     {
  247.         pframe->can_id &= CAN_SFF_MASK;
  248.     }
  249.     result = send(fd, pframe, sizeof(struct can_frame), 0);
  250.     if (result == -1)
  251.     {
  252.         printf("send:%s\n", strerror(errno));
  253.         return -1;
  254.     }
  255.     return result;
  256. }
  258. /*
  259. * @description  : can发送一组数据包
  260. * @param - fd   : 文件描述符
  261. * @param - *buff: 要发送can一组数据的缓冲区首指针
  262. * @param - len  : 发送数据的长度
  263. * @param - param: can应用参数
  264. * @return                 : 实际发送数据长度
  265. */
  266. int func_send_can_buff(int fd, unsigned char *buff, int len, struct_can_param param)
  267. {
  268.     int remain_frame_len = 0, frame_numb = 0;
  269.     struct can_frame frame;
  270.     int i = 0;
  272.     remain_frame_len = len;
  273.     while (1)
  274.     {
  275.         if (remain_frame_len >= 8)
  276.         {
  277.             frame.can_dlc = 8;     /*填充发送长度*/
  278.             remain_frame_len -= 8; /*剩余数据长度*/
  279.         }
  280.         else
  281.         {
  282.             frame.can_dlc = remain_frame_len; /*填充发送长度*/
  283.             remain_frame_len = 0;             //
  284.         }
  286.         frame.can_id = param.id; /*填充发送id*/
  288.         for (i = 0; i < frame.can_dlc; i++)
  289.         {
  290.             frame.data[i] = buff[frame_numb * 8 + i]; /*填充发送数据*/
  291.         }
  292.         func_send_can_frame(fd, &frame, param);
  293.         frame_numb++;
  294.         if (remain_frame_len == 0)
  295.         {
  296.             return len;
  297.         }
  298.     }
  299.     return len;
  300. }

main.c
  1. #include
  2. #include
  3. #include
  4. #include
  5. #include
  6. #include
  7. #include  /*PPSIX 终端控制定义*/
  8. #include
  9. #include
  10. #include
  11. #include
  12. #include
  13. #include "mycan.h"
  15. char ver[20] = {"ver01.001"};
  17. int sock_fd;
  18. struct_can_param can_param = {250000, 0x103, {
  19.                                                  0x100,
  20.                                                  0x00,
  21.                                              },
  22.                               0,
  23.                               0,
  24.                               0,
  25.                               2000000};
  27. unsigned char send_buff[1024], receive_buff[1024];
  28. unsigned int send_num = 0, receive_num = 0;
  30. //数据收发应用
  31. char active_send_buff[500] = "test can";
  32. int active_send_mode = 0, active_send_num = 8, active_send_time = 1000, active_send_time_count = 0;
  33. int real_send_num = 0;
  34. int loopback_send_mode = 0;
  36. char dev[20];
  38. /*
  39. * @description : 自定义打印函数
  40. * @param - buff:  打印数据缓冲区
  41. * @param - lens:  打印数据长度
  42. * @param - mode:  打印格式
  43. * @return                : 无
  44. */
  45. void func_my_print(unsigned char *buff, unsigned int lens, unsigned char mode)
  46. {
  47.     int i = 0;
  49.     switch (mode)
  50.     {
  51.     case 'H': //按照16进制打印数据
  52.         for (i = 0; i < lens; i++)
  53.         {
  54.             printf("0X%02X  ", buff[i]);
  55.         }
  56.         break;
  57.     case 'h': //按照16进制打印数据
  58.         for (i = 0; i < lens; i++)
  59.         {
  60.             printf("0x%02x  ", buff[i]);
  61.         }
  62.         break;
  63.     case 'd': //按照10进制打印数据
  64.         for (i = 0; i < lens; i++)
  65.         {
  66.             printf("%02d  ", buff[i]);
  67.         }
  68.         break;
  69.     case 'c': //按照字符打印数据
  70.         for (i = 0; i < lens; i++)
  71.         {
  72.             printf("%c", buff[i]);
  73.         }
  74.         break;
  75.     default:
  76.         break;
  77.     }
  78.     printf("\n");
  79. }
  81. /*
  82. * @description  : 打印参数设置格式
  83. * @param - pname: 函数名
  84. * @return                 : 无
  85. */
  86. static void print_usage(const char *pname)
  87. {
  88.     printf("Usage: %s device [-b baudrate] [-id id_numb] [-filt id mask] [-e] [-fd dbaudrate] [-t data time] [-l] [-L] [-v]"
  89.            "\n\t'-b baudrate' for different baudrate, range 5k to 5M,unit is Kbps"
  90.            "\n\t'-id id_numb' for nonzero can send id"
  91.            "\n\t'-filt id mask' for receive can_id and can_mask"
  92.            "\n\t'-e' for extend id frame"
  93.            "\n\t'-fd dbaudrate' for can fd mode , dbaudrate range 250k to 5M,unit is Kbps"
  94.            "\n\t'-t data time'  for interval set time actively sends the data, unit is s"
  95.            "\n\t'-l' for can loopback mode"
  96.            "\n\t'-L' for app loopback receive data"
  97.            "\n\t'-rf path' save the data received by the serial port into the file, path for file to save"
  98.            "\n\t'-v' show version"
  99.            "\n\texample : can0 baudrate 250k id 123 filt_id 105 filt_mask 1f0 extend id string data was send every 2s--> ./can_demo can0 -b 250 -id 123 -filt 105 1f0 -e -t abcdef 2"
  100.            "\n\texample : can1 baudrate 250k id 105 filt_id 123 filt_mask 120 extend id --> ./can_demo can1 -b 250 -id 105 -filt 123 1f0"
  101.            "\n\texample : can0 canfd mode baudrate 250k id 123 filt_id 105 filt_mask 1f0 extend id string data was send every 2s--> ./can_demo can0 -b 250 -id 123 -filt 105 1f0 -e -t 12345678 2 -fd 4000"
  102.            "\n\texample : can1 canfd mode baudrate 250k id 105 filt_id 123 filt_mask 120 extend id --> ./can_demo can1 -b 250 -id 105 -filt 123 1f0 -e -fd 4000"
  103.            "\n\texample : can0 canfd mode baudrate 500k extend id dbaudrate 4000k loopback mode 19 data was send every 1s --> ./can_demo can0 -b 500 -filt 0 0 -fd 4000 -t abcdefg 1 -e -l\n ",
  104.            pname);
  105. }
  107. /*
  108. * @description : 解析函数带入参数
  109. * @param - numb: 参数个数
  110. * @param - *param: 带入参数数组指针
  111. * @param - *canparam: can应用参数
  112. * @return                : 无
  113. */
  114. void get_param(int numb, char *param[], struct_can_param *canparam)
  115. {
  116.     int i = 0, len = 0;
  117.     unsigned int baudrate = 0, id = 0, mask = 0, active_param = 0;
  119.     if (numb <= 2)
  120.         return;
  122.     for (i = 2; i < numb; i++)
  123.     {
  124.         if (!strcmp(param[i], "-b"))
  125.         {
  126.             i++;
  127.             baudrate = atoi(param[i]);
  128.             switch (baudrate)
  129.             {
  130.             case 5:
  131.             case 10:
  132.             case 20:
  133.             case 40:
  134.             case 50:
  135.             case 80:
  136.             case 100:
  137.             case 125:
  138.             case 200:
  139.             case 250:
  140.             case 400:
  141.             case 500:
  142.             case 666:
  143.             case 800:
  144.             case 1000:
  145.             case 2000:
  146.             case 4000:
  147.             case 5000:
  148.                 canparam->baudrate = baudrate * 1000;
  149.                 break;
  150.             }
  151.             continue;
  152.         }
  153.         if (!strcmp(param[i], "-id"))
  154.         {
  155.             i++;
  156.             id = strtoul(param[i], NULL, 16);
  157.             if (id)
  158.             {
  159.                 canparam->id = (unsigned int)id;
  160.             }
  161.             continue;
  162.         }
  163.         if (!strcmp(param[i], "-filt"))
  164.         {
  165.             i++;
  166.             id = 0;
  167.             id = strtoul(param[i], NULL, 16);
  168.             canparam->filter.can_id = (canid_t)id;
  169.             i++;
  170.             mask = strtoul(param[i], NULL, 16);
  171.             canparam->filter.can_mask = (canid_t)mask;
  172.             continue;
  173.         }
  174.         if (!strcmp(param[i], "-e"))
  175.         {
  176.             canparam->extend = 1;
  177.             continue;
  178.         }
  179.         if (!strcmp(param[i], "-fd"))
  180.         {
  181.             canparam->canfd_mode = CAN_FD_MODE;
  183.             i++;
  184.             baudrate = atoi(param[i]);
  185.             switch (baudrate)
  186.             {
  187.             case 250:
  188.             case 500:
  189.             case 1000:
  190.             case 2000:
  191.             case 4000:
  192.             case 5000:
  193.                 canparam->data_baudrate = baudrate * 1000;
  194.                 break;
  195.             }
  196.             continue;
  197.         }
  198.         if (!strcmp(param[i], "-t"))
  199.         {
  200.             active_send_mode = 1;
  202.             i++;
  203.             len = strlen(param[i]);
  204.             if (len > 0)
  205.             {
  206.                 active_send_num = len;
  207.                 memcpy(active_send_buff, param[i], len); //要发送的字符串
  209.                 i++;
  210.                 len = atoi(param[i]); //发送间隔
  211.                 if (len > 0)
  212.                 {
  213.                     active_send_time = len * 1000; //转换为ms单位
  214.                     active_send_time_count = active_send_time;
  215.                 }
  216.             }
  217.             continue;
  218.         }
  219.         if (!strcmp(param[i], "-l"))
  220.         {
  221.             canparam->loopback_mode = 1;
  222.             continue;
  223.         }
  224.         if (!strcmp(param[i], "-L"))
  225.         {
  226.             loopback_send_mode = 1;
  227.             continue;
  228.         }
  229.         if (!strcmp(param[i], "-v"))
  230.         {
  231.             printf("can_demo ver:  %s\n", ver);
  232.             continue;
  233.         }
  234.     }
  235. }
  237. /*
  238. * @description  : 主函数
  239. * @param - argc : 参数个数
  240. * @param - *argv: 带入参数数组指针
  241. * @return                 : 执行结果
  242. */
  243. int main(int argc, char *argv[])
  244. {
  245.     int i = 0, result = 0;
  247.     //检测是否有参数
  248.     if (argc < 2 || strncmp(argv[1], "can", 3))
  249.     {
  250.         print_usage(argv[0]);
  251.         exit(1);
  252.     }
  254.     //检测是否有--h或--help
  255.     if ((!strcmp(argv[1], "--h")) || (!strcmp(argv[1], "--help")))
  256.     {
  257.         print_usage(argv[0]);
  258.         exit(1);
  259.     }
  261.     strcpy(dev, argv[1]);
  263.     //从main函数带来的参数解析为CAN口参数
  264.     get_param(argc, argv, &can_param);
  266.     //当知道设备名称时可以直接赋值dev，例strcpy(dev, "can0");
  267.     //打开CAN口 创建socket 绑定socket
  268.     sock_fd = func_open_can(dev, can_param);
  269.     if (sock_fd < 0)
  270.     {
  271.         printf("Can't Open deveice %s \n", dev);
  272.         exit(0);
  273.     }
  274.     else
  275.     {
  276.         printf("baudrate = %ldK,can_id = 0x%x,can_filter_id = 0x%x,can_filter_mask = 0x%x,extend id = %d,loopback mode = %d,canfd mode = %d,dbaudrate = %ldK\n",
  277.                can_param.baudrate / 1000, can_param.id, can_param.filter.can_id, can_param.filter.can_mask,
  278.                can_param.extend, can_param.loopback_mode, can_param.canfd_mode, can_param.data_baudrate / 1000);
  279.         //设置CAN口过滤
  280.         result = func_set_can(sock_fd, can_param);
  281.         if (result < 0)
  282.         {
  283.             perror("set_opt error");
  284.             exit(0);
  285.         }
  286.         //设置CAN口为非阻塞方式
  287.         fcntl(sock_fd, F_SETFL, O_NONBLOCK); //非阻塞
  288.     }
  290.     while (1)
  291.     {
  292.         //接收数据
  293.         receive_num = func_receive_can_buff(sock_fd, receive_buff, sizeof(receive_buff));
  294.         if (receive_num > 0)
  295.         {
  296.             printf("[%s nread=%d]  ", dev, receive_num);
  297.             func_my_print(receive_buff, receive_num, 'c'); //将收到的数据打印出来
  298.         }
  300.         //组织发送数据
  301.         if ((1 == loopback_send_mode) && (receive_num > 0)) //数据回环处理
  302.         {
  303.             send_num = receive_num;
  304.             memcpy(send_buff, receive_buff, receive_num);
  305.         }
  306.         else if (1 == active_send_mode)
  307.         {
  308.             if (active_send_time_count >= active_send_time)
  309.             {
  310.                 active_send_time_count = 0;
  311.                 send_num = active_send_num;
  312.                 memcpy(send_buff, active_send_buff, active_send_num);
  313.             }
  314.             else
  315.             {
  316.                 active_send_time_count++;
  317.             }
  318.         }
  320.         //发送数据
  321.         if (send_num > 0)
  322.         {
  323.             real_send_num = func_send_can_buff(sock_fd, send_buff, send_num, can_param);
  324.             if (real_send_num > 0)
  325.             {
  326.                 printf("[%s nwrite=%d] ", dev, real_send_num);
  327.                 func_my_print(send_buff, real_send_num, 'c');
  328.             }
  329.             memset(send_buff, 0, send_num);
  330.             send_num = 0;
  331.         }
  332.         usleep(1000); // 1ms
  333.     }
  334.     close(sock_fd);
  335.     exit(0);
  336. }

进程名：elf1_cmd_can
使用方法：./elf1_cmd_can 设备名 [参数选项]… …
31-33.png

更多回帖

0 0 0

相关帖子

发帖
电子发烧友APP
|投诉反馈|电子发烧友网
© 2021 bbs.elecfans.com
湘ICP备2023018690号
×
20
完善资料，
赚取积分