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

ID:855733 · 发表于 2023-8-12 11:03

手上有个CAN参数配置软件，是通过电脑连接DB9，电脑上操作配置相关参数通过DB9发送rs232信号到所需更改配置的板上，再经过板上CPU处理更改CAN的相关参数。
现在想不用这个软件去操作更改，因为每次都要通过电脑去操作比较麻烦。所以想直接做一块板，发送同样的232数据到板子上实现无电脑更改的目的。现在的问题是不知道如何读取这个软件发出的指令，且不知是否正确。

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的数据他都能实时的抓到，于是我主需要发指令就可以直接抓到软件发出来的数据，并且数据准确性非常高，自己再通过串口自己去测试两遍就能验证了。

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

网上找到的。

/*
* canutils/canconfig.c
*/
#include <errno.h>
#include <fcntl.h>
#include <limits.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <libsocketcan.h>
#ifndef MIN
#define MIN(a, b) ((a) < (b) ? (a) : (b))
#endif
const char *can_states[CAN_STATE_MAX] = {
"ERROR-ACTIVE",
"ERROR-WARNING",
"ERROR-PASSIVE",
"BUS-OFF",
"STOPPED",
"SLEEPING"
};
const char *config_keywords[] = {
"baudrate", "bitrate", "bittiming", "ctrlmode", "restart",
"start", "stop", "restart-ms", "state", "clockfreq",
"bittiming-const", "berr-counter"};
/* this is shamelessly stolen from iproute and slightly modified */
#define NEXT_ARG() \
do { \
argv++; \
if (--argc < 0) { \
fprintf(stderr, "missing parameter for %s\n", *argv); \
exit(EXIT_FAILURE);\
}\
} while(0)
static inline int find_str(const char** haystack, unsigned int stack_size,
const char* needle)
{
int i, found = 0;
for (i = 0; i < stack_size; i++) {
if (!strcmp(needle, haystack[i])) {
found = 1;
break;
}
}
return found;
}
static void help(void)
{
fprintf(stderr, "usage:\n\t"
"canconfig <dev> bitrate { BR } [sample-point { SP }]\n\t\t"
"BR := <bitrate in Hz>\n\t\t"
"SP := <sample-point {0...0.999}> (optional)\n\t"
"canconfig <dev> bittiming [ VALs ]\n\t\t"
"VALs := <tq | prop-seg | phase-seg1 | phase-seg2 | sjw>\n\t\t"
"tq <time quantum in ns>\n\t\t"
"prop-seg <no. in tq>\n\t\t"
"phase-seg1 <no. in tq>\n\t\t"
"phase-seg2 <no. in tq\n\t\t"
"sjw <no. in tq> (optional)\n\t"
"canconfig <dev> restart-ms { RESTART-MS }\n\t\t"
"RESTART-MS := <autorestart interval in ms>\n\t"
"canconfig <dev> ctrlmode { CTRLMODE }\n\t\t"
"CTRLMODE := <[loopback | listen-only | triple-sampling | berr-reporting] [on|off]>\n\t"
"canconfig <dev> {ACTION}\n\t\t"
"ACTION := <[start|stop|restart]>\n\t"
"canconfig <dev> clockfreq\n\t"
"canconfig <dev> bittiming-constants\n\t"
"canconfig <dev> berr-counter\n"
);
exit(EXIT_FAILURE);
}
static void do_show_bitrate(const char *name)
{
struct can_bittiming bt;
if (can_get_bittiming(name, &bt) < 0) {
fprintf(stderr, "%s: failed to get bitrate\n", name);
exit(EXIT_FAILURE);
} else
fprintf(stdout,
"%s bitrate: %u, sample-point: %0.3f\n",
name, bt.bitrate,
(float)((float)bt.sample_point / 1000));
}
static void do_set_bitrate(int argc, char *argv[], const char *name)
{
__u32 bitrate = 0;
__u32 sample_point = 0;
int err;
while (argc > 0) {
if (!strcmp(*argv, "bitrate")) {
NEXT_ARG();
bitrate = (__u32)strtoul(*argv, NULL, 0);
} else if (!strcmp(*argv, "sample-point")) {
NEXT_ARG();
sample_point = (__u32)(strtod(*argv, NULL) * 1000);
}
argc--, argv++;
}
if (sample_point)
err = can_set_bitrate_samplepoint(name, bitrate, sample_point);
else
err = can_set_bitrate(name, bitrate);
if (err < 0) {
fprintf(stderr, "failed to set bitrate of %s to %u\n",
name, bitrate);
exit(EXIT_FAILURE);
}
}
static void cmd_bitrate(int argc, char *argv[], const char *name)
{
int show_only = 1;
if (argc > 0)
show_only = find_str(config_keywords,
sizeof(config_keywords) / sizeof(char*),
argv[1]);
if (! show_only)
do_set_bitrate(argc, argv, name);
do_show_bitrate(name);
}
static void do_set_bittiming(int argc, char *argv[], const char *name)
{
struct can_bittiming bt;
int bt_par_count = 0;
memset(&bt, 0, sizeof(bt));
while (argc > 0) {
if (!strcmp(*argv, "tq")) {
NEXT_ARG();
bt.tq = (__u32)strtoul(*argv, NULL, 0);
bt_par_count++;
continue;
}
if (!strcmp(*argv, "prop-seg")) {
NEXT_ARG();
bt.prop_seg = (__u32)strtoul(*argv, NULL, 0);
bt_par_count++;
continue;
}
if (!strcmp(*argv, "phase-seg1")) {
NEXT_ARG();
bt.phase_seg1 = (__u32)strtoul(*argv, NULL, 0);
bt_par_count++;
continue;
}
if (!strcmp(*argv, "phase-seg2")) {
NEXT_ARG();
bt.phase_seg2 =
(__u32)strtoul(*argv, NULL, 0);
bt_par_count++;
continue;
}
if (!strcmp(*argv, "sjw")) {
NEXT_ARG();
bt.sjw =
(__u32)strtoul(*argv, NULL, 0);
continue;
}
argc--, argv++;
}
/* kernel will take a default sjw value if it's zero. all other
* parameters have to be set */
if (bt_par_count < 4) {
fprintf(stderr, "%s: missing bittiming parameters, "
"try help to figure out the correct format\n",
name);
exit(1);
}
if (can_set_bittiming(name, &bt) < 0) {
fprintf(stderr, "%s: unable to set bittiming\n", name);
exit(EXIT_FAILURE);
}
}
static void do_show_bittiming(const char *name)
{
struct can_bittiming bt;
if (can_get_bittiming(name, &bt) < 0) {
fprintf(stderr, "%s: failed to get bittiming\n", name);
exit(EXIT_FAILURE);
} else
fprintf(stdout, "%s bittiming:\n\t"
"tq: %u, prop-seq: %u phase-seq1: %u phase-seq2: %u "
"sjw: %u, brp: %u\n",
name, bt.tq, bt.prop_seg, bt.phase_seg1, bt.phase_seg2,
bt.sjw, bt.brp);
}
static void cmd_bittiming(int argc, char *argv[], const char *name)
{
int show_only = 1;
if (argc > 0)
show_only = find_str(config_keywords,
sizeof(config_keywords) / sizeof(char*),
argv[1]);
if (! show_only)
do_set_bittiming(argc, argv, name);
do_show_bittiming(name);
do_show_bitrate(name);
}
static void do_show_bittiming_const(const char *name)
{
struct can_bittiming_const btc;
if (can_get_bittiming_const(name, &btc) < 0) {
fprintf(stderr, "%s: failed to get bittiming_const\n", name);
exit(EXIT_FAILURE);
} else
fprintf(stdout, "%s bittiming-constants: name %s,\n\t"
"tseg1-min: %u, tseg1-max: %u, "
"tseg2-min: %u, tseg2-max: %u,\n\t"
"sjw-max %u, brp-min: %u, brp-max: %u, brp-inc: %u,\n",
name, btc.name, btc.tseg1_min, btc.tseg1_max,
btc.tseg2_min, btc.tseg2_max, btc.sjw_max,
btc.brp_min, btc.brp_max, btc.brp_inc);
}
static void cmd_bittiming_const(int argc, char *argv[], const char *name)
{
do_show_bittiming_const(name);
}
static void do_show_state(const char *name)
{
int state;
if (can_get_state(name, &state) < 0) {
fprintf(stderr, "%s: failed to get state \n", name);
exit(EXIT_FAILURE);
}
if (state >= 0 && state < CAN_STATE_MAX)
fprintf(stdout, "%s state: %s\n", name, can_states[state]);
else
fprintf(stderr, "%s: unknown state\n", name);
}
static void cmd_state(int argc, char *argv[], const char *name)
{
do_show_state(name);
}
static void do_show_clockfreq(const char *name)
{
struct can_clock clock;
memset(&clock, 0, sizeof(struct can_clock));
if (can_get_clock(name, &clock) < 0) {
fprintf(stderr, "%s: failed to get clock parameters\n",
name);
exit(EXIT_FAILURE);
}
fprintf(stdout, "%s clock freq: %u\n", name, clock.freq);
}
static void cmd_clockfreq(int argc, char *argv[], const char *name)
{
do_show_clockfreq(name);
}
static void do_restart(const char *name)
{
if (can_do_restart(name) < 0) {
fprintf(stderr, "%s: failed to restart\n", name);
exit(EXIT_FAILURE);
} else {
fprintf(stdout, "%s restarted\n", name);
}
}
static void cmd_restart(int argc, char *argv[], const char *name)
{
do_restart(name);
}
static void do_start(const char *name)
{
if (can_do_start(name) < 0) {
fprintf(stderr, "%s: failed to start\n", name);
exit(EXIT_FAILURE);
} else {
do_show_state(name);
}
}
static void cmd_start(int argc, char *argv[], const char *name)
{
do_start(name);
}
static void do_stop(const char *name)
{
if (can_do_stop(name) < 0) {
fprintf(stderr, "%s: failed to stop\n", name);
exit(EXIT_FAILURE);
} else {
do_show_state(name);
}
}
static void cmd_stop(int argc, char *argv[], const char *name)
{
do_stop(name);
}
static inline void print_ctrlmode(__u32 cm_flags)
{
fprintf(stdout,
"loopback[%s], listen-only[%s], tripple-sampling[%s],"
"one-shot[%s], berr-reporting[%s]\n",
(cm_flags & CAN_CTRLMODE_LOOPBACK) ? "ON" : "OFF",
(cm_flags & CAN_CTRLMODE_LISTENONLY) ? "ON" : "OFF",
(cm_flags & CAN_CTRLMODE_3_SAMPLES) ? "ON" : "OFF",
(cm_flags & CAN_CTRLMODE_ONE_SHOT) ? "ON" : "OFF",
(cm_flags & CAN_CTRLMODE_BERR_REPORTING) ? "ON" : "OFF");
}
static void do_show_ctrlmode(const char *name)
{
struct can_ctrlmode cm;
if (can_get_ctrlmode(name, &cm) < 0) {
fprintf(stderr, "%s: failed to get controlmode\n", name);
exit(EXIT_FAILURE);
} else {
fprintf(stdout, "%s ctrlmode: ", name);
print_ctrlmode(cm.flags);
}
}
/* this is shamelessly stolen from iproute and slightly modified */
static inline void set_ctrlmode(char* name, char *arg,
struct can_ctrlmode *cm, __u32 flags)
{
if (strcmp(arg, "on") == 0) {
cm->flags |= flags;
} else if (strcmp(arg, "off") != 0) {
fprintf(stderr,
"Error: argument of \"%s\" must be \"on\" or \"off\" %s\n",
name, arg);
exit(EXIT_FAILURE);
}
cm->mask |= flags;
}
static void do_set_ctrlmode(int argc, char* argv[], const char *name)
{
struct can_ctrlmode cm;
memset(&cm, 0, sizeof(cm));
while (argc > 0) {
if (!strcmp(*argv, "loopback")) {
NEXT_ARG();
set_ctrlmode("loopback", *argv, &cm,
CAN_CTRLMODE_LOOPBACK);
} else if (!strcmp(*argv, "listen-only")) {
NEXT_ARG();
set_ctrlmode("listen-only", *argv, &cm,
CAN_CTRLMODE_LISTENONLY);
} else if (!strcmp(*argv, "triple-sampling")) {
NEXT_ARG();
set_ctrlmode("triple-sampling", *argv, &cm,
CAN_CTRLMODE_3_SAMPLES);
} else if (!strcmp(*argv, "one-shot")) {
NEXT_ARG();
set_ctrlmode("one-shot", *argv, &cm,
CAN_CTRLMODE_ONE_SHOT);
} else if (!strcmp(*argv, "berr-reporting")) {
NEXT_ARG();
set_ctrlmode("berr-reporting", *argv, &cm,
CAN_CTRLMODE_BERR_REPORTING);
}
argc--, argv++;
}
if (can_set_ctrlmode(name, &cm) < 0) {
fprintf(stderr, "%s: failed to set ctrlmode\n", name);
exit(EXIT_FAILURE);
}
}
static void cmd_ctrlmode(int argc, char *argv[], const char *name)
{
int show_only = 1;
if (argc > 0)
show_only = find_str(config_keywords,
sizeof(config_keywords) / sizeof(char*),
argv[1]);
if (! show_only)
do_set_ctrlmode(argc, argv, name);
do_show_ctrlmode(name);
}
static void do_show_restart_ms(const char *name)
{
__u32 restart_ms;
if (can_get_restart_ms(name, &restart_ms) < 0) {
fprintf(stderr, "%s: failed to get restart_ms\n", name);
exit(EXIT_FAILURE);
} else
fprintf(stdout,
"%s restart-ms: %u\n", name, restart_ms);
}
static void do_set_restart_ms(int argc, char* argv[], const char *name)
{
if (can_set_restart_ms(name,
(__u32)strtoul(argv[1], NULL, 10)) < 0) {
fprintf(stderr, "failed to set restart_ms of %s to %lu\n",
name, strtoul(argv[1], NULL, 10));
exit(EXIT_FAILURE);
}
}
static void cmd_restart_ms(int argc, char *argv[], const char *name)
{
int show_only = 1;
if (argc > 0)
show_only = find_str(config_keywords,
sizeof(config_keywords) / sizeof(char*),
argv[1]);
if (! show_only)
do_set_restart_ms(argc, argv, name);
do_show_restart_ms(name);
}
static void do_show_berr_counter(const char *name)
{
struct can_berr_counter bc;
struct can_ctrlmode cm;
if (can_get_ctrlmode(name, &cm) < 0) {
fprintf(stderr, "%s: failed to get controlmode\n", name);
exit(EXIT_FAILURE);
}
if (cm.flags & CAN_CTRLMODE_BERR_REPORTING) {
memset(&bc, 0, sizeof(struct can_berr_counter));
if (can_get_berr_counter(name, &bc) < 0) {
fprintf(stderr, "%s: failed to get berr counters\n",
name);
exit(EXIT_FAILURE);
}
fprintf(stdout, "%s txerr: %u rxerr: %u\n",
name, bc.txerr, bc.rxerr);
}
}
static void cmd_berr_counter(int argc, char *argv[], const char *name)
{
do_show_berr_counter(name);
}
static void cmd_baudrate(int argc, char *argv[], const char *name)
{
fprintf(stderr, "%s: baudrate is deprecated, pleae use bitrate\n",
name);
exit(EXIT_FAILURE);
}
static void cmd_show_interface(const char *name)
{
do_show_bitrate(name);
do_show_bittiming(name);
do_show_state(name);
do_show_restart_ms(name);
do_show_ctrlmode(name);
do_show_clockfreq(name);
do_show_bittiming_const(name);
do_show_berr_counter(name);
exit(EXIT_SUCCESS);
}
int main(int argc, char *argv[])
{
const char* name = argv[1];
if ((argc < 2) || !strcmp(argv[1], "--help"))
help();
if (!strcmp(argv[1], "--version")) {
printf("Version: %s\n", VERSION);
exit(EXIT_SUCCESS);
}
if (argc < 3)
cmd_show_interface(name);
while (argc-- > 0) {
if (!strcmp(argv[0], "baudrate"))
cmd_baudrate(argc, argv, name);
if (!strcmp(argv[0], "bitrate"))
cmd_bitrate(argc, argv, name);
if (!strcmp(argv[0], "bittiming"))
cmd_bittiming(argc, argv, name);
if (!strcmp(argv[0], "ctrlmode"))
cmd_ctrlmode(argc, argv, name);
if (!strcmp(argv[0], "restart"))
cmd_restart(argc, argv, name);
if (!strcmp(argv[0], "start"))
cmd_start(argc, argv, name);
if (!strcmp(argv[0], "stop"))
cmd_stop(argc, argv, name);
if (!strcmp(argv[0], "restart-ms"))
cmd_restart_ms(argc, argv, name);
if (!strcmp(argv[0], "state"))
cmd_state(argc, argv, name);
if (!strcmp(argv[0], "clockfreq"))
cmd_clockfreq(argc, argv, name);
if (!strcmp(argv[0], "bittiming-constants"))
cmd_bittiming_const(argc, argv, name);
if (!strcmp(argv[0], "berr-counter"))
cmd_berr_counter(argc, argv, name);
argv++;
}
exit(EXIT_SUCCESS);
}

复制代码

帐号		自动登录	找回密码
密码			立即注册

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

评分