I am writing an application in C++ that sends large packets out the /dev/ttyS0 serial port of a PC using the write function.

The problem is for writing packets larger than 4096 bytes.

I would like my program to be able to transmit packets larger than 4096 bytes without being blocked.

I've looked in the kernel code (linux\drivers\char\serial.c) and there is a #define called SERIAL_XMIT_SIZE. At first I tought maybe I could change that but it seems that the trasmit buffer is actially fixed to be a memory page (4k).

Any ideas on how I can change this?

I could create a seperate serial transmit thread or create a secondary buffer that gets polled but this seems like a lot of bother when the kernel already provides the mechanism.

Thanks

I suppose you could change the size to two pages by editing include/kernel/serial.h and setting SERIAL_XMIT_SIZE to page*2. You'd certainly have to go through and see where it is used and make sure they don't do anything that depends on the size being exactly one page. Is there a particular reason why blocking is hurting you?

I writing out the serial port in a real time application. I can't tolerate being blocked.

I didn't want to have to modify the Kernel just as I don'y what to have to add handling of large blocks into the code that transmits the data.

The Kernel seems to handle serial comms very simply. It would just have been nice if it was possible to configure the size of the transmit buffer.

I always open the serial port like this
then its impossible to block. You see no matter what buffer size the kernel has, it won't be big enough for someone somewhere in their application... so the answer is you just accept the fact that the write() function may returns with less bytes written than you requested.
This is the normal behavior and the way you deal with it is you call select() and wait for write access to be available again, just like any other fd.

I realise that this won't block.

If want to transmit a 3k block of data, I can open the port as you suggest, and just write it out using write().
It will add the data to the kernel serial transmit buffer, return straight away so I can continue to do important things.

The problem is if I want to write a block greater than 4k. If I want to return stright away, I need to have a secondary buffer that other transmitters also access.
I then need to make sure that something somewhere in the code (a thread or polled task) checks my secondary buffer to see if more data should be written.

This isn't that hard to do but I didn't want to bother with it. I guess I will have to.

hello everyone!!!

i have a similar kind of problem.
i am writing an application in C that receives large packets from the /dev/ttyS0 serial port of a PC using the read function.

The problem is for reading packets larger than 4096 bytes.

i have created a buffer in which i save the incoming packets but i cant seem to increase its size more than 4096 bytes.

please help me in this regard, i would really appreciate an urgent reply
thanks in advance.

regards

I think its better not to think of the data coming from a serial port as packets. Its really not packets, but a byte stream. You application layer software decides where a boundary exist if there are any, but its purely arbitrary.
I'm not exactly sure what problem you're describing, but if you're trying to call read() with a buffer size larger than 4096 and you're never receiving more than 4096, then that is normal behavior for a serial port. Keep calling read() until you receive all the data you expect, it may take several calls.

here is my part of the code where m reading data from serial port into a buffer n thn from buffer m writing the data into a file.
this pgm is workin fine, it reads data from serial port, n creates and writes that data in to a file also, but the problem is jus that i want to recieve files greater than 4096bytes, even if i increase the BUFFSIZE, and sends a file greater than 4096bytes from the other pc , it does not receive more than 4096bytes.
please help me that where i am going wrong, n how can i do this.
thanks

# define BUFFSIZE 4096
char buf[BUFFSIZE];
char *bufptr;
bufptr=buf;
//fp is a pointer to a file
while( (nbytes = read(fd,bufptr,512)) > 0 )
{

while( (*bufptr!='\0') && fputc( *(bufptr++), fp) !=EOF );


tbytes+=nbytes; // ttbytes keeps track of the totel bytes read
if(tbytes > 0)
{
if(tbytes % BUFFSIZE == 0)
bufptr=buf;
}


} //while ends

I'm still not understanding your code, so here is my example
for reading forever, or at least until the buffer is completely full.
You can add your own test in the loop to break out when the
entire file has been transferred, however big that may be.

Does anyone know the answer to my original question?

I want a non-blocking serial transmit that can take more that 4k without having to create a secondary buffer or a seperate transmitter thread?

hello!!

thnx for ur reply !!
well yah now my program is working fine, and the serial port is able to recieve a file greater than 4K.
but i have observed another problem that the serial port is not reading the complete file being sent to it. that is if a file of size 22K is sent to it ,thn it only reieves till 20K. n the size of the datanot being read is not constant, it varies.
am not being able to figure out that what isthe problem, maybe it hasto do with flushing.
here is my code...

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
#include <termios.h>
#include <stdlib.h>
#define bufsize 1000000

int main(void)
{
int n,i;
int fd;
struct termios options;
int used;
int nbytes;
char *buf;
int offsetvar;
int count;
FILE *fp;

//opening the file

fp=fopen("/rcvdfile.txt", "w");
if(fp==NULL)
{
printf("cant open rcvdfile.txt");
}


//openingthe serial port AM2

fd=open("/dev/ttyAM2", O_RDWR | O_NOCTTY | O_NDELAY);

if(fd== -1)
{
perror("open_port:unable toopen /dev/ttyAM2");
}
else
fcntl(fd, F_SETFL, 0);

//setting baud rate

tcgetattr(fd, &options);
cfsetispeed(&options, B19200);
cfsetospeed(&options, B19200);

options.c_cflag |= (CLOCAL | CREAD);
tcsetattr(fd, TCSANOW, &options);

//reading from the port

buf=malloc(bufsize);
offsetvar=0;
used=0;

while( used<bufsize)
{
nbytes=read ( fd, buf, bufsize-used ); //data being read into a buffer 'buf' from serial port
while( (*buf!='\0') && fputc( *(buf++),fp ) !=EOF); // this saves data being read from the buffer into a file.
used+=nbytes;

}

//closin the port and files

fclose(fp);
close(fd);

} // main ends


please reply soon.
thnx in advance
cheers...

I'm thinking this is not quite right.
*buf!='\0' can't be used because your data is not null terminated.
I'd use write(fileno(stdout),buf,used) instead of that loop.

hello!!!
am having the same problem, even after makin an amendment tht u suggested.
there's no problem of the file size anymore, but last 1 to 2 Kbytes are not saved.
pls reply soon
thanks in advance

Has anyone found a solution to this?