c - 带有标记和空间奇偶校验的串行通信

在how to open, read, and write from serial port in C中通过@wallyk回答后，我编写了一个程序通过USB端口发送数据。我需要发送一个6字节的数据，其第一个字节应为标记奇偶校验，其余的应为空间奇偶校验。这就是我声明2个变量msg1和msg2的原因

#include<stdio.h>
#include <errno.h>
#include <termios.h>
#include <unistd.h>
#include<fcntl.h>// used for opening ttys0
#include<sys/ioctl.h>
#include<sched.h>
#include<string.h> // for memset
#include<time.h>

int set_interface_attribs (int fd, int speed, int parity)
{
        struct termios tty;
        memset (&tty, 0, sizeof tty); // initialize all in struct tty with 0
        if (tcgetattr (fd, &tty) != 0)// gets parameters from fd and stores them in tty struct
        {
                perror("error from tcgetattr");
                return -1;
        }

        cfsetospeed (&tty, speed);
        cfsetispeed (&tty, speed);

        tty.c_cflag = (tty.c_cflag & ~CSIZE) | CS8;     // 8-bit chars, CSIZE -> character size mask
        // disable IGNBRK for mismatched speed tests; otherwise receive break
        // as \000 chars
        tty.c_iflag &= ~IGNBRK;         // ignore break signal
        tty.c_lflag = 0;                // no signaling chars, no echo,
                                        // no canonical processing
        tty.c_oflag = 0;                // no remapping, no delays
        tty.c_cflag &= ~(PARENB | PARODD);      // shut off parity
        tty.c_cflag |= parity;
        tty.c_cflag &= ~CSTOPB;// 1 stop bit
        tty.c_cflag &= ~CRTSCTS;

        if (tcsetattr (fd, TCSANOW, &tty) != 0) // TCSANOW -> the change takes place immediately
        {
                perror("error from tcsetattr");
                return -1;
        }
        return 0;
}

int main()
{
char *portname = "/dev/ttyUSB0";
int fd = open (portname, O_RDWR | O_NOCTTY | O_SYNC);
if (fd < 0)
{
        perror("error opening");
        return;
}
char msg1[1]={0x01};
char msg2[5]={0x02,0x08,0x00,0xff,0xf5};
set_interface_attribs (fd, B115200,PARENB|PARODD|CMSPAR);  // set speed to 115200, bps,mark parity
                // set no blocking
write (fd, msg1, sizeof msg1);
set_interface_attribs (fd, B115200,PARENB|CMSPAR); // set speed to 115200 bps, space parity
write (fd,msg2,sizeof msg2);
close(fd);
return 0;
}

但是现在我发送的所有数据似乎都是在空间奇偶校验中，而不是标记奇偶校验。即，如果我已经配置了第一个字节以标记奇偶校验发送，其余字节以空间奇偶校验发送，那么所有字节都将以空间奇偶校验发送。现在，如果我将第一个字节配置为以空间奇偶校验发送，其余字节以标记奇偶校验发送，那么所有字节都将以标记奇偶校验发送。

最佳答案

我遇到了类似的问题，尝试发送奇偶校验为“mark”的第一个字节，其余所有奇偶校验为“space”和我忽略了“Mark/Space”选项的USB到串行驱动程序，我注意到了一个协议(protocol)分析器，它使用的是“奇/偶”。
因此，我最终创建了一个查找表，该表具有发送每个字节之前需要使用的奇偶校验(奇/偶)，以便模拟“标记/空格”奇偶校验，并且在发送每个字节之前我将相应地更改奇偶校验。
显然，每次奇偶校验交换都会引入许多毫秒的延迟，因此，由于这仅适用于以单一波特率运行的单一用途嵌入式设备，因此修改了USB to Serial驱动程序以删除一些它正在执行(例如更改波特率)，并使奇偶校验的切换速度快两倍。
我不建议更改驱动程序(如果该驱动程序用于一般用途)，但是如果您能够承受每次奇偶校验更改之前将引入的字符间延迟，那么这可能会有所帮助。

查找表是这样的:

static const char parity[256]= {

0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0,
1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1,
1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1,
0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0,
1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1,
0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0,
0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0,
1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1,
1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1,
0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0,
0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0,
1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1,
0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0,
1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1,
1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1,
0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0
};

要发送带有奇偶校验“mark”的第一个字节，我使用的是:

if (parity[buff[0]]==1)
    SetParity (fd,EVEN_PARITY);
else
    SetParity (fd,ODD_PARITY);

这是“SetParity()”函数

int SetParity(int fd, int parity) {

struct termios options,options1;
string strToLog;

bzero (&options, sizeof (options));
bzero (&options1, sizeof (options1));

if (tcgetattr (fd, &options) ==-1) {
    usleep (500);
    int aa=tcgetattr (fd, &options);
    ostringstream osString (" ");
    osString<<std::dec<<fd<<"FD error! Get A";
    if (aa==-1)
        osString<<std::dec<<fd<< "FD error! Get B";
    strToLog.append (osString.str());
      Log(LOG_ALERT,strToLog.c_str());
    if (aa==-1)
        return -1;
}
options.c_cflag |= (CLOCAL | CREAD);

switch (parity) {
    case NO_PARITY:
        options.c_cflag &= ~PARENB;
        options.c_cflag &= ~CSTOPB;
        options.c_cflag &= ~CSIZE;
        options.c_cflag |= CS8;
        break;
    case ODD_PARITY:
        options.c_cflag|=PARODD;
        options.c_cflag|=PARENB;
        options.c_cflag&=~CMSPAR;
        break;

    case EVEN_PARITY:
        options.c_cflag&=~PARODD;
        options.c_cflag|=PARENB;
        options.c_cflag&=~CMSPAR;
        break;

    case MARK_PARITY:
        options.c_cflag|=PARODD;
        options.c_cflag|=PARENB;
        options.c_cflag|=CMSPAR;
        break;

    case SPACE_PARITY:
        options.c_cflag&=~PARODD;
        options.c_cflag|=PARENB;
        options.c_cflag|=CMSPAR;
        break;
    default:
        return (-1);
}

if (-1 == tcsetattr (fd, TCSADRAIN, & (options))) {
    printf ("ERROR--------------------------------setParity\n");
    ostringstream osString (" ");
    osString<<std::dec<<fd<<"FD error! Set A";
    usleep (500);
    int aa= tcsetattr (fd, TCSADRAIN, & (options));
    if (aa==-1)
        osString<<std::dec<<fd<<" FD error! Set B";
    strToLog.append (osString.str());

    printf(strToLog.c_str());
    if (aa==-1)
        return -1;
}

return 1;
}