问题描述
过去一周，我一直在尝试用C实现原始的串行文件传输协议，但遇到了一个非常奇怪的问题，我似乎无法在网上找到解决方案.我设法通过串行端口传输二进制数据并接收它，但是在此过程中，所有的"0D"都是字节被转换为"0A".以下是我的代码.
I have been trying to implement a primitive serial file transfer protocol in C this past week and I've come across a really weird problem which I can't seem to find the solution for online. I've managed to transfer binary data over the serial port and receive it but in the process, all the "0D" bytes are converted to "0A". The following is my code.
#include <stdlib.h>
#include <stdio.h> /* Standard input/output definitions */
#include <string.h> /* String function definitions */
#include <unistd.h> /* UNIX standard function definitions */
#include <fcntl.h> /* File control definitions */
#include <errno.h> /* Error number definitions */
#include <signal.h>
#include <sys/ioctl.h>
#include <termios.h>
//eventually plan to set up a proper communication protocol
#define ACK 0x01
#define NAK 0x00
int setAttribs (int fd, int speed, int parity);
unsigned char* readFile(char* filename, int* file_size);
int main(void){
//set up ports
int fd = 0, r = 0, i = 0;
fd = open("/dev/ttyUSB0", O_RDWR | O_NOCTTY | O_NDELAY);//sending port
if(fd<0){
perror("open port ttyUSB0 failed");
return -1;
}
setAttribs(fd,1500000,0);
int rd =0, file_size=0, bytes=0;
rd = open("/dev/ttyUSB1", O_RDWR | O_NOCTTY | O_NDELAY);//receiving port
setAttribs(rd,1500000,0);
//create file to which the binary data will be written
FILE *newFile;
newFile = fopen("t.bin","wb");
if(newFile<0){
printf("open file failed\n");
return -1;
}
//This character array will hold the file to be transferred
unsigned char* data = '\0';
data = readFile("t.odt", &file_size);
ioctl(rd, TCFLSH, &bytes);//port flush which does not seem to work
do{
//write data in 1024 byte chunks
write(fd,data+i,1024);
//wait for write to finish
usleep(8500);
//buffer to hold received bytes
unsigned char buffer[1024];
//ensure buffer is empty
memset(buffer,0,1024);
//read in 1024 byte chunks
read(rd, buffer, 1024);
//printing bytes in the buffer to check for errors
for(r=0;r<1024;r++){
if(r%16==0)
printf("\n");
printf("%02X ", buffer[r]);
}
//write to file in 1024 byte chunks
fwrite(buffer, 1,1024,newFile);
//increase counter
i+=1024;
}while(i<8197);//its an 8088 byte file
printf("Done!\n");
return 0;
}
unsigned char* readFile(char* filename, int* file_size){
unsigned char *buffer = NULL;
int string_size, i;
FILE *handler = fopen(filename, "rb");
if (handler)
{
// Seek the last byte of the file
fseek(handler, 0, SEEK_END);
// Offset from the first to the last byte, or in other words, filesize
string_size = ftell(handler);
printf("File length: %d\n",string_size);
*file_size = string_size;
// go back to the start of the file
rewind(handler);
// Allocate a string that can hold it all
buffer = (unsigned char*) malloc(sizeof(unsigned char) * (string_size + 1) );
// Read it all in one operation
for(i=0;i<string_size;i++){
fread(buffer+i, sizeof(unsigned char),1, handler);
if(i%16==0)
printf("\n");
printf("%02X ",*(buffer+i));
}
// fread doesn't set it so put a \0 in the last position
// and buffer is now officially a string
// buffer[string_size] = '\0';
printf("Finished read\n");
// Always remember to close the file
fclose(handler);
}
return buffer;
}
int setAttribs (int fd, int speed, int parity)
{
struct termios tty;
memset (&tty, 0, sizeof tty);
if (tcgetattr (fd, &tty) != 0)
{
fputs("error %d from tcgetattr", stderr);
}
cfsetospeed (&tty, speed);
cfsetispeed (&tty, speed);
tty.c_cflag = (tty.c_cflag & ~CSIZE) | CS8; // 8-bit chars
// disable IGNBRK for mismatched speed tests; otherwise receive break
// as \000 chars
tty.c_iflag &= ~IGNBRK; // disable break processing
tty.c_lflag = 0; // no signaling chars, no echo,
// no canonical processing
tty.c_oflag = 0; // no remapping, no delays
tty.c_cc[VMIN] = 0; // read doesn't block
tty.c_cc[VTIME] = 5; // 0.5 seconds read timeout
tty.c_iflag &= ~(IXON | IXOFF | IXANY); // shut off xon/xoff ctrl
tty.c_cflag |= (CLOCAL | CREAD);// ignore modem controls,
// enable reading
tty.c_cflag &= ~(PARENB | PARODD); // shut off parity
tty.c_cflag |= parity;
tty.c_cflag &= ~CSTOPB;
tty.c_cflag &= ~CRTSCTS;
if (tcsetattr (fd, TCSANOW, &tty) != 0)
{
fputs("error %d from tcsetattr", stderr);
}
return 1;
}
它所做的只是在一个端口中写入USB-Serial转换器，而在另一个端口中读取一个.我只是用8088字节(Hello World)的ODT文件进行了测试，并尝试了不同的波特率和写入块大小.经过反复试验，我发现此配置(1500000 bps和1024字节块)既快速又相对可靠.唯一的错误如下所示.
All it does is write to a USB-Serial converter in one port and read through the one in the other. I was just testing it with an ODT file which is 8088 bytes (Hello World) and was trying out different baudrates and write block sizes. After some trial and error, I found that this configuration (1500000 bps and 1024 byte blocks) was both fast and relatively more reliable. The only errors are as shown below.
接收的字节:70 6E 67 89 50 4E 47 0A 0A 1A 0A 00 00 00 0A 49
Received bytes: 70 6E 67 89 50 4E 47 0A 0A 1A 0A 00 00 00 0A 49
您可以看到所有的"0D"字节被改变为"0A".我尝试使用较低的波特率和较小的块大小，但问题仍然存在.我知道它们分别是回车符和换行符的值，并且换行符用作Linux中异步通信的控制值.但是我不明白为什么这会影响回车的值.在串行通信中，回车有什么特殊意义吗?有没有办法发送"0D"消息?那样的字节?
As you can see all the "0D" bytes are changed to "0A". I've tried lower baudrates and smaller block sizes and the problem persists. I understand that they are the carriage return and line feed values respectively and that line feed is used as a control value for asynchronous communication in Linux; but I don't get why that would affect the carriage return values. Is there some special significance for carriage return in serial communication? Is there a way to send "0D" byte across in that case?
TL; DR::原始串行通信的结果为"0D"，字节被替换为"0A".知道为什么吗?有什么办法解决吗?
TL;DR: Raw serial communication results in "0D" bytes being replaced with "0A". Any idea why? Any way to solve?
推荐答案
非常感谢！我从来不知道有ICRNL选项将换行符转换为回车符.一旦我用其他方式设置
Thank you so much it worked!! I never knew that there was the ICRNL option which translates line feeds to carriage returns. Once I set that and others off with
tty.c_iflag &= ~(IGNBRK | BRKINT | PARMRK | ISTRIP | INLCR | IGNCR | ICRNL | IXON); //tty is the name of the struct termios
那是金色的.
这篇关于串口二进制传输更改回车的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持！