找回密码
 立即注册

QQ登录

只需一步,快速开始

搜索
查看: 1945|回复: 13
收起左侧

如何读取电脑上软件发出的RS232指令

[复制链接]
ID:855733 发表于 2023-8-12 11:03 | 显示全部楼层 |阅读模式
手上有个CAN参数配置软件,是通过电脑连接DB9,电脑上操作配置相关参数通过DB9发送rs232信号到所需更改配置的板上,再经过板上CPU处理更改CAN的相关参数。
现在想不用这个软件去操作更改,因为每次都要通过电脑去操作比较麻烦。所以想直接做一块板,发送同样的232数据到板子上实现无电脑更改的目的。  现在的问题是不知道如何读取这个软件发出的指令,且不知是否正确。
2.png
回复

使用道具 举报

ID:883242 发表于 2023-8-12 16:57 | 显示全部楼层
你的意思是如何破解通讯协议。

看厂家给出的手册,如果有通讯协议就照着写呗,没有就别想了,你没能力破解。
回复

使用道具 举报

ID:855733 发表于 2023-8-12 17:16 | 显示全部楼层
居然没有一个回复
回复

使用道具 举报

ID:855733 发表于 2023-8-12 17:39 | 显示全部楼层
用虚拟串口接收到的数据不确定对不对,刚刚从电脑端的DB9将RXTX与GND引了出来接到另外一个串口上,讲道理,我通过软件发送数据时,我另外一个串口也能接收到同样的数据,但是串口调试助手上接收到的全都是FF。更改不同的参数也只是FF的位置不一样(上面3个下面4个或者上面2个下面5个这样)但是接收到的数据都是FF。
猜测:软件有自己的协议?或者是加密了?
回复

使用道具 举报

ID:855733 发表于 2023-8-12 17:41 | 显示全部楼层
有无大佬给个思路,或者有相关的源码?软件名字叫:canconfig
回复

使用道具 举报

ID:420836 发表于 2023-8-13 09:39 | 显示全部楼层
这应该是需要在 RS232 和 CAN 总线这两种协议之间进行转换的情况。
回复

使用道具 举报

ID:1079566 发表于 2023-8-13 12:52 | 显示全部楼层
工具, 逻辑分析仪,  便宜的几十元(X宝) , 贵的就是数字示波器带逻辑分析.

可能查看波物率, 来往数据. 细节要你自己来.
回复

使用道具 举报

ID:123289 发表于 2023-8-14 09:42 | 显示全部楼层
方案1:读通这个CAN件的手册。
方案2:挂一个示波器于串口RX,TX线上,截取并记录下你所需要的所以通讯数据。再用单片机按此协议,仿制。
回复

使用道具 举报

ID:855733 发表于 2023-8-14 10:19 | 显示全部楼层
TTQ001 发表于 2023-8-13 09:39
这应该是需要在 RS232 和 CAN 总线这两种协议之间进行转换的情况。

这个软件只发232数据,转换是后面的事情了
回复

使用道具 举报

ID:855733 发表于 2023-8-14 10:21 | 显示全部楼层
yzwzfyz 发表于 2023-8-14 09:42
方案1:读通这个CAN件的手册。
方案2:挂一个示波器于串口RX,TX线上,截取并记录下你所需要的所以通讯数 ...

没有手册  不过我已经找到方法了
回复

使用道具 举报

ID:855733 发表于 2023-8-14 10:31 | 显示全部楼层
已经解决啦。
理论上我那个方法是可行的:并一个串口到板子上,软件配置板子的时候,同时也会发送同样的数据到我的串口,我再用串口助手去监控他发出来的指令。不过这个方法较为麻烦——需要一步一步去试软件的波特率及他的校验方式以及停止位等等,不然收到的数据是错误的,而且不知道哪个是对,需要再多花时间去调试。
我用的方法是USB抓包软件(bus hound),第一次了解这个玩意,发现真的强,只要是USB的数据他都能实时的抓到,于是我主需要发指令就可以直接抓到软件发出来的数据,并且数据准确性非常高,自己再通过串口自己去测试两遍就能验证了。
51hei图片_20230814103057.png

评分

参与人数 1黑币 +50 收起 理由
admin + 50 回帖助人的奖励!

查看全部评分

回复

使用道具 举报

ID:855733 发表于 2023-8-14 10:31 | 显示全部楼层
大家有想要这个软件的,我再把他发出来吧。比较好用
回复

使用道具 举报

ID:855733 发表于 2023-8-14 10:33 | 显示全部楼层
Hephaestus 发表于 2023-8-12 16:57
你的意思是如何破解通讯协议。

看厂家给出的手册,如果有通讯协议就照着写呗,没有就别想了,你没能力破 ...

没有协议,只是发的串口数据而已。目前已解决
回复

使用道具 举报

ID:155507 发表于 2023-8-14 13:29 | 显示全部楼层
网上找到的。

  1. /*
  2. * canutils/canconfig.c

  3. */

  4. #include <errno.h>
  5. #include <fcntl.h>
  6. #include <limits.h>
  7. #include <stdio.h>
  8. #include <stdlib.h>
  9. #include <string.h>
  10. #include <unistd.h>

  11. #include <sys/socket.h>
  12. #include <sys/stat.h>
  13. #include <sys/types.h>

  14. #include <libsocketcan.h>


  15. #ifndef MIN
  16. #define MIN(a, b) ((a) < (b) ? (a) : (b))
  17. #endif

  18. const char *can_states[CAN_STATE_MAX] = {
  19.         "ERROR-ACTIVE",
  20.         "ERROR-WARNING",
  21.         "ERROR-PASSIVE",
  22.         "BUS-OFF",
  23.         "STOPPED",
  24.         "SLEEPING"
  25. };

  26. const char *config_keywords[] = {
  27.                 "baudrate", "bitrate", "bittiming", "ctrlmode", "restart",
  28.                 "start", "stop", "restart-ms", "state", "clockfreq",
  29.                 "bittiming-const", "berr-counter"};

  30. /* this is shamelessly stolen from iproute and slightly modified */
  31. #define NEXT_ARG() \
  32.         do { \
  33.                 argv++; \
  34.                 if (--argc < 0) { \
  35.                         fprintf(stderr, "missing parameter for %s\n", *argv); \
  36.                         exit(EXIT_FAILURE);\
  37.                 }\
  38.         } while(0)

  39. static inline int find_str(const char** haystack, unsigned int stack_size,
  40.                 const char* needle)
  41. {
  42.         int i, found = 0;

  43.         for (i = 0; i < stack_size; i++) {
  44.                 if (!strcmp(needle, haystack[i])) {
  45.                         found = 1;
  46.                         break;
  47.                 }
  48.         }

  49.         return found;
  50. }

  51. static void help(void)
  52. {
  53.         fprintf(stderr, "usage:\n\t"
  54.                 "canconfig <dev> bitrate { BR } [sample-point { SP }]\n\t\t"
  55.                 "BR := <bitrate in Hz>\n\t\t"
  56.                 "SP := <sample-point {0...0.999}> (optional)\n\t"
  57.                 "canconfig <dev> bittiming [ VALs ]\n\t\t"
  58.                 "VALs := <tq | prop-seg | phase-seg1 | phase-seg2 | sjw>\n\t\t"
  59.                 "tq <time quantum in ns>\n\t\t"
  60.                 "prop-seg <no. in tq>\n\t\t"
  61.                 "phase-seg1 <no. in tq>\n\t\t"
  62.                 "phase-seg2 <no. in tq\n\t\t"
  63.                 "sjw <no. in tq> (optional)\n\t"
  64.                 "canconfig <dev> restart-ms { RESTART-MS }\n\t\t"
  65.                 "RESTART-MS := <autorestart interval in ms>\n\t"
  66.                 "canconfig <dev> ctrlmode { CTRLMODE }\n\t\t"
  67.                 "CTRLMODE := <[loopback | listen-only | triple-sampling | berr-reporting] [on|off]>\n\t"
  68.                 "canconfig <dev> {ACTION}\n\t\t"
  69.                 "ACTION := <[start|stop|restart]>\n\t"
  70.                 "canconfig <dev> clockfreq\n\t"
  71.                 "canconfig <dev> bittiming-constants\n\t"
  72.                 "canconfig <dev> berr-counter\n"
  73.                 );

  74.         exit(EXIT_FAILURE);
  75. }

  76. static void do_show_bitrate(const char *name)
  77. {
  78.         struct can_bittiming bt;

  79.         if (can_get_bittiming(name, &bt) < 0) {
  80.                 fprintf(stderr, "%s: failed to get bitrate\n", name);
  81.                 exit(EXIT_FAILURE);
  82.         } else
  83.                 fprintf(stdout,
  84.                         "%s bitrate: %u, sample-point: %0.3f\n",
  85.                         name, bt.bitrate,
  86.                         (float)((float)bt.sample_point / 1000));
  87. }

  88. static void do_set_bitrate(int argc, char *argv[], const char *name)
  89. {
  90.         __u32 bitrate = 0;
  91.         __u32 sample_point = 0;
  92.         int err;

  93.         while (argc > 0) {
  94.                 if (!strcmp(*argv, "bitrate")) {
  95.                         NEXT_ARG();
  96.                         bitrate =  (__u32)strtoul(*argv, NULL, 0);
  97.                 } else if (!strcmp(*argv, "sample-point")) {
  98.                         NEXT_ARG();
  99.                         sample_point = (__u32)(strtod(*argv, NULL) * 1000);
  100.                 }
  101.                 argc--, argv++;
  102.         }

  103.         if (sample_point)
  104.                 err = can_set_bitrate_samplepoint(name, bitrate, sample_point);
  105.         else
  106.                 err = can_set_bitrate(name, bitrate);

  107.         if (err < 0) {
  108.                 fprintf(stderr, "failed to set bitrate of %s to %u\n",
  109.                         name, bitrate);
  110.                 exit(EXIT_FAILURE);
  111.         }
  112. }

  113. static void cmd_bitrate(int argc, char *argv[], const char *name)
  114. {
  115.         int show_only = 1;

  116.         if (argc > 0)
  117.                 show_only = find_str(config_keywords,
  118.                                 sizeof(config_keywords) / sizeof(char*),
  119.                                 argv[1]);

  120.         if (! show_only)
  121.                 do_set_bitrate(argc, argv, name);

  122.         do_show_bitrate(name);
  123. }

  124. static void do_set_bittiming(int argc, char *argv[], const char *name)
  125. {
  126.         struct can_bittiming bt;
  127.         int bt_par_count = 0;

  128.         memset(&bt, 0, sizeof(bt));

  129.         while (argc > 0) {
  130.                 if (!strcmp(*argv, "tq")) {
  131.                         NEXT_ARG();
  132.                         bt.tq = (__u32)strtoul(*argv, NULL, 0);
  133.                         bt_par_count++;
  134.                         continue;
  135.                 }
  136.                 if (!strcmp(*argv, "prop-seg")) {
  137.                         NEXT_ARG();
  138.                         bt.prop_seg = (__u32)strtoul(*argv, NULL, 0);
  139.                         bt_par_count++;
  140.                         continue;
  141.                 }
  142.                 if (!strcmp(*argv, "phase-seg1")) {
  143.                         NEXT_ARG();
  144.                         bt.phase_seg1 = (__u32)strtoul(*argv, NULL, 0);
  145.                         bt_par_count++;
  146.                         continue;
  147.                 }
  148.                 if (!strcmp(*argv, "phase-seg2")) {
  149.                         NEXT_ARG();
  150.                         bt.phase_seg2 =
  151.                                 (__u32)strtoul(*argv, NULL, 0);
  152.                         bt_par_count++;
  153.                         continue;
  154.                 }
  155.                 if (!strcmp(*argv, "sjw")) {
  156.                         NEXT_ARG();
  157.                         bt.sjw =
  158.                                 (__u32)strtoul(*argv, NULL, 0);
  159.                         continue;
  160.                 }
  161.                 argc--, argv++;
  162.         }
  163.         /* kernel will take a default sjw value if it's zero. all other
  164.          * parameters have to be set */
  165.         if (bt_par_count < 4) {
  166.                 fprintf(stderr, "%s: missing bittiming parameters, "
  167.                                 "try help to figure out the correct format\n",
  168.                                 name);
  169.                 exit(1);
  170.         }
  171.         if (can_set_bittiming(name, &bt) < 0) {
  172.                 fprintf(stderr, "%s: unable to set bittiming\n", name);
  173.                 exit(EXIT_FAILURE);
  174.         }
  175. }

  176. static void do_show_bittiming(const char *name)
  177. {
  178.         struct can_bittiming bt;

  179.         if (can_get_bittiming(name, &bt) < 0) {
  180.                 fprintf(stderr, "%s: failed to get bittiming\n", name);
  181.                 exit(EXIT_FAILURE);
  182.         } else
  183.                 fprintf(stdout, "%s bittiming:\n\t"
  184.                         "tq: %u, prop-seq: %u phase-seq1: %u phase-seq2: %u "
  185.                         "sjw: %u, brp: %u\n",
  186.                         name, bt.tq, bt.prop_seg, bt.phase_seg1, bt.phase_seg2,
  187.                         bt.sjw, bt.brp);
  188. }

  189. static void cmd_bittiming(int argc, char *argv[], const char *name)
  190. {
  191.         int show_only = 1;

  192.         if (argc > 0)
  193.                 show_only = find_str(config_keywords,
  194.                                 sizeof(config_keywords) / sizeof(char*),
  195.                                 argv[1]);

  196.         if (! show_only)
  197.                 do_set_bittiming(argc, argv, name);

  198.         do_show_bittiming(name);
  199.         do_show_bitrate(name);
  200. }

  201. static void do_show_bittiming_const(const char *name)
  202. {
  203.         struct can_bittiming_const btc;

  204.         if (can_get_bittiming_const(name, &btc) < 0) {
  205.                 fprintf(stderr, "%s: failed to get bittiming_const\n", name);
  206.                 exit(EXIT_FAILURE);
  207.         } else
  208.                 fprintf(stdout, "%s bittiming-constants: name %s,\n\t"
  209.                         "tseg1-min: %u, tseg1-max: %u, "
  210.                         "tseg2-min: %u, tseg2-max: %u,\n\t"
  211.                         "sjw-max %u, brp-min: %u, brp-max: %u, brp-inc: %u,\n",
  212.                         name, btc.name, btc.tseg1_min, btc.tseg1_max,
  213.                         btc.tseg2_min, btc.tseg2_max, btc.sjw_max,
  214.                         btc.brp_min, btc.brp_max, btc.brp_inc);
  215. }

  216. static void cmd_bittiming_const(int argc, char *argv[], const char *name)
  217. {
  218.         do_show_bittiming_const(name);
  219. }

  220. static void do_show_state(const char *name)
  221. {
  222.         int state;

  223.         if (can_get_state(name, &state) < 0) {
  224.                 fprintf(stderr, "%s: failed to get state \n", name);
  225.                 exit(EXIT_FAILURE);
  226.         }

  227.         if (state >= 0 && state < CAN_STATE_MAX)
  228.                 fprintf(stdout, "%s state: %s\n", name, can_states[state]);
  229.         else
  230.                 fprintf(stderr, "%s: unknown state\n", name);
  231. }

  232. static void cmd_state(int argc, char *argv[], const char *name)
  233. {
  234.         do_show_state(name);
  235. }

  236. static void do_show_clockfreq(const char *name)
  237. {
  238.         struct can_clock clock;

  239.         memset(&clock, 0, sizeof(struct can_clock));
  240.         if (can_get_clock(name, &clock) < 0) {
  241.                 fprintf(stderr, "%s: failed to get clock parameters\n",
  242.                                 name);
  243.                 exit(EXIT_FAILURE);
  244.         }

  245.         fprintf(stdout, "%s clock freq: %u\n", name, clock.freq);
  246. }

  247. static void cmd_clockfreq(int argc, char *argv[], const char *name)
  248. {
  249.         do_show_clockfreq(name);
  250. }

  251. static void do_restart(const char *name)
  252. {
  253.         if (can_do_restart(name) < 0) {
  254.                 fprintf(stderr, "%s: failed to restart\n", name);
  255.                 exit(EXIT_FAILURE);
  256.         } else {
  257.                 fprintf(stdout, "%s restarted\n", name);
  258.         }
  259. }

  260. static void cmd_restart(int argc, char *argv[], const char *name)
  261. {
  262.         do_restart(name);
  263. }

  264. static void do_start(const char *name)
  265. {
  266.         if (can_do_start(name) < 0) {
  267.                 fprintf(stderr, "%s: failed to start\n", name);
  268.                 exit(EXIT_FAILURE);
  269.         } else {
  270.                 do_show_state(name);
  271.         }
  272. }

  273. static void cmd_start(int argc, char *argv[], const char *name)
  274. {
  275.         do_start(name);
  276. }

  277. static void do_stop(const char *name)
  278. {
  279.         if (can_do_stop(name) < 0) {
  280.                 fprintf(stderr, "%s: failed to stop\n", name);
  281.                 exit(EXIT_FAILURE);
  282.         } else {
  283.                 do_show_state(name);
  284.         }
  285. }

  286. static void cmd_stop(int argc, char *argv[], const char *name)
  287. {
  288.         do_stop(name);
  289. }

  290. static inline void print_ctrlmode(__u32 cm_flags)
  291. {
  292.         fprintf(stdout,
  293.                 "loopback[%s], listen-only[%s], tripple-sampling[%s],"
  294.                 "one-shot[%s], berr-reporting[%s]\n",
  295.                 (cm_flags & CAN_CTRLMODE_LOOPBACK) ? "ON" : "OFF",
  296.                 (cm_flags & CAN_CTRLMODE_LISTENONLY) ? "ON" : "OFF",
  297.                 (cm_flags & CAN_CTRLMODE_3_SAMPLES) ? "ON" : "OFF",
  298.                 (cm_flags & CAN_CTRLMODE_ONE_SHOT) ? "ON" : "OFF",
  299.                 (cm_flags & CAN_CTRLMODE_BERR_REPORTING) ? "ON" : "OFF");
  300. }

  301. static void do_show_ctrlmode(const char *name)
  302. {
  303.         struct can_ctrlmode cm;

  304.         if (can_get_ctrlmode(name, &cm) < 0) {
  305.                 fprintf(stderr, "%s: failed to get controlmode\n", name);
  306.                 exit(EXIT_FAILURE);
  307.         } else {
  308.                 fprintf(stdout, "%s ctrlmode: ", name);
  309.                 print_ctrlmode(cm.flags);
  310.         }
  311. }

  312. /* this is shamelessly stolen from iproute and slightly modified */
  313. static inline void set_ctrlmode(char* name, char *arg,
  314.                          struct can_ctrlmode *cm, __u32 flags)
  315. {
  316.         if (strcmp(arg, "on") == 0) {
  317.                 cm->flags |= flags;
  318.         } else if (strcmp(arg, "off") != 0) {
  319.                 fprintf(stderr,
  320.                         "Error: argument of \"%s\" must be \"on\" or \"off\" %s\n",
  321.                         name, arg);
  322.                 exit(EXIT_FAILURE);
  323.         }
  324.         cm->mask |= flags;
  325. }

  326. static void do_set_ctrlmode(int argc, char* argv[], const char *name)
  327. {
  328.         struct can_ctrlmode cm;

  329.         memset(&cm, 0, sizeof(cm));

  330.         while (argc > 0) {
  331.                 if (!strcmp(*argv, "loopback")) {
  332.                         NEXT_ARG();
  333.                         set_ctrlmode("loopback", *argv, &cm,
  334.                                      CAN_CTRLMODE_LOOPBACK);
  335.                 } else if (!strcmp(*argv, "listen-only")) {
  336.                         NEXT_ARG();
  337.                         set_ctrlmode("listen-only", *argv, &cm,
  338.                                      CAN_CTRLMODE_LISTENONLY);
  339.                 } else if (!strcmp(*argv, "triple-sampling")) {
  340.                         NEXT_ARG();
  341.                         set_ctrlmode("triple-sampling", *argv, &cm,
  342.                                      CAN_CTRLMODE_3_SAMPLES);
  343.                 } else if (!strcmp(*argv, "one-shot")) {
  344.                         NEXT_ARG();
  345.                         set_ctrlmode("one-shot", *argv, &cm,
  346.                                      CAN_CTRLMODE_ONE_SHOT);
  347.                 } else if (!strcmp(*argv, "berr-reporting")) {
  348.                         NEXT_ARG();
  349.                         set_ctrlmode("berr-reporting", *argv, &cm,
  350.                                      CAN_CTRLMODE_BERR_REPORTING);
  351.                 }

  352.                 argc--, argv++;
  353.         }

  354.         if (can_set_ctrlmode(name, &cm) < 0) {
  355.                 fprintf(stderr, "%s: failed to set ctrlmode\n", name);
  356.                 exit(EXIT_FAILURE);
  357.         }
  358. }

  359. static void cmd_ctrlmode(int argc, char *argv[], const char *name)
  360. {
  361.         int show_only = 1;

  362.         if (argc > 0)
  363.                 show_only = find_str(config_keywords,
  364.                                 sizeof(config_keywords) / sizeof(char*),
  365.                                 argv[1]);

  366.         if (! show_only)
  367.                 do_set_ctrlmode(argc, argv, name);

  368.         do_show_ctrlmode(name);
  369. }

  370. static void do_show_restart_ms(const char *name)
  371. {
  372.         __u32 restart_ms;

  373.         if (can_get_restart_ms(name, &restart_ms) < 0) {
  374.                 fprintf(stderr, "%s: failed to get restart_ms\n", name);
  375.                 exit(EXIT_FAILURE);
  376.         } else
  377.                 fprintf(stdout,
  378.                         "%s restart-ms: %u\n", name, restart_ms);
  379. }

  380. static void do_set_restart_ms(int argc, char* argv[], const char *name)
  381. {
  382.         if (can_set_restart_ms(name,
  383.                                 (__u32)strtoul(argv[1], NULL, 10)) < 0) {
  384.                 fprintf(stderr, "failed to set restart_ms of %s to %lu\n",
  385.                                name, strtoul(argv[1], NULL, 10));
  386.                 exit(EXIT_FAILURE);
  387.         }
  388. }

  389. static void cmd_restart_ms(int argc, char *argv[], const char *name)
  390. {
  391.         int show_only = 1;

  392.         if (argc > 0)
  393.                 show_only = find_str(config_keywords,
  394.                                 sizeof(config_keywords) / sizeof(char*),
  395.                                 argv[1]);

  396.         if (! show_only)
  397.                 do_set_restart_ms(argc, argv, name);

  398.         do_show_restart_ms(name);
  399. }

  400. static void do_show_berr_counter(const char *name)
  401. {
  402.         struct can_berr_counter bc;
  403.         struct can_ctrlmode cm;

  404.         if (can_get_ctrlmode(name, &cm) < 0) {
  405.                 fprintf(stderr, "%s: failed to get controlmode\n", name);
  406.                 exit(EXIT_FAILURE);
  407.         }

  408.         if (cm.flags & CAN_CTRLMODE_BERR_REPORTING) {
  409.                 memset(&bc, 0, sizeof(struct can_berr_counter));

  410.                 if (can_get_berr_counter(name, &bc) < 0) {
  411.                         fprintf(stderr, "%s: failed to get berr counters\n",
  412.                                         name);
  413.                         exit(EXIT_FAILURE);
  414.                 }

  415.                 fprintf(stdout, "%s txerr: %u rxerr: %u\n",
  416.                                 name, bc.txerr, bc.rxerr);
  417.         }
  418. }

  419. static void cmd_berr_counter(int argc, char *argv[], const char *name)
  420. {
  421.         do_show_berr_counter(name);
  422. }

  423. static void cmd_baudrate(int argc, char *argv[], const char *name)
  424. {
  425.         fprintf(stderr, "%s: baudrate is deprecated, pleae use bitrate\n",
  426.                 name);

  427.         exit(EXIT_FAILURE);
  428. }

  429. static void cmd_show_interface(const char *name)
  430. {
  431.         do_show_bitrate(name);
  432.         do_show_bittiming(name);
  433.         do_show_state(name);
  434.         do_show_restart_ms(name);
  435.         do_show_ctrlmode(name);
  436.         do_show_clockfreq(name);
  437.         do_show_bittiming_const(name);
  438.         do_show_berr_counter(name);

  439.         exit(EXIT_SUCCESS);
  440. }

  441. int main(int argc, char *argv[])
  442. {
  443.         const char* name = argv[1];

  444.         if ((argc < 2) || !strcmp(argv[1], "--help"))
  445.                 help();

  446.         if (!strcmp(argv[1], "--version")) {
  447.                 printf("Version: %s\n", VERSION);
  448.                 exit(EXIT_SUCCESS);
  449.         }

  450.         if (argc < 3)
  451.                 cmd_show_interface(name);

  452.         while (argc-- > 0) {
  453.                 if (!strcmp(argv[0], "baudrate"))
  454.                         cmd_baudrate(argc, argv, name);
  455.                 if (!strcmp(argv[0], "bitrate"))
  456.                         cmd_bitrate(argc, argv, name);
  457.                 if (!strcmp(argv[0], "bittiming"))
  458.                         cmd_bittiming(argc, argv, name);
  459.                 if (!strcmp(argv[0], "ctrlmode"))
  460.                         cmd_ctrlmode(argc, argv, name);
  461.                 if (!strcmp(argv[0], "restart"))
  462.                         cmd_restart(argc, argv, name);
  463.                 if (!strcmp(argv[0], "start"))
  464.                         cmd_start(argc, argv, name);
  465.                 if (!strcmp(argv[0], "stop"))
  466.                         cmd_stop(argc, argv, name);
  467.                 if (!strcmp(argv[0], "restart-ms"))
  468.                         cmd_restart_ms(argc, argv, name);
  469.                 if (!strcmp(argv[0], "state"))
  470.                         cmd_state(argc, argv, name);
  471.                 if (!strcmp(argv[0], "clockfreq"))
  472.                         cmd_clockfreq(argc, argv, name);
  473.                 if (!strcmp(argv[0], "bittiming-constants"))
  474.                         cmd_bittiming_const(argc, argv, name);
  475.                 if (!strcmp(argv[0], "berr-counter"))
  476.                         cmd_berr_counter(argc, argv, name);
  477.                 argv++;
  478.         }

  479.         exit(EXIT_SUCCESS);
  480. }
复制代码



csrj-jk-V3.12.pdf

10.1 MB, 下载次数: 2

【数据手册】CAN测试软件与接口函数数据手册 V3.12

CANopen_easy_begin.pdf

3.32 MB, 下载次数: 1

【专家推荐】CANopen轻松入门

回复

使用道具 举报

您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

手机版|小黑屋|51黑电子论坛 |51黑电子论坛6群 QQ 管理员QQ:125739409;技术交流QQ群281945664

Powered by 单片机教程网

快速回复 返回顶部 返回列表