... some other defines ...

#define DEVICE "/dev/tts/0"
#define BAUDRATE B9600

/* Global filediscriptor */
int fd=0;

int initport(void) {
    struct termios options;
    // Get the current options for the port...
    tcgetattr(fd, &options);
    // Enable the receiver and set local mode...
    options.c_cflag = BAUDRATE | CS8 | CLOCAL | CREAD; // 8N1
    options.c_iflag = ICRNL;
    options.c_oflag = 0;
    options.c_lflag = ICANON;
    tcflush(fd, TCIFLUSH);
    // Set the new options for the port...
    tcsetattr(fd, TCSANOW, &options);
    return 1;
}

int write_char(char *chars, int len) {
    chars[len] = 0x0d; // stick a <CR> after the command
    chars[len+1] = 0x00; // terminate the string properly
    int n = write(fd, chars, strlen(chars));
    if (n < 0) {
        fputs("write failed!\n", stderr);
        return 0;
    }
    printf("written:%s\n", chars);
    return 1;
}

int read_char(char *result) {
    int n = read(fd, result, 254);
    result[n-1] = 0x00;
    if (n<0) {
        if (errno==EAGAIN) {
            printf("SERIAL EAGAIN ERROR\n");
            return 0;
        }
        else {
            printf("SERIAL read error %d %s\n", errno, strerror(errno));
            return 0;
        }
    }
    return 1;
}

... some other functions ...

int main(int argc, char **argv) {
    
    /* Open device port with corresponding options */
    fd = open(DEVICE, O_RDWR | O_NOCTTY | O_NDELAY);
    if (fd==-1) {
        perror("Port: Unable to open\n");
        return 1;
    }
    else {
        fcntl(fd, F_SETFL, 0);
    }

    /* Initialize the serial port */
    initport();

    // Send things

    // Receive things

    // etc...

    return 0;

}

int n = read(fd, result, 254);

fcntl(fd, F_SETFL, FNDELAY);

#include <stdlib.h>
#include <stdio.h>
#include <sys/io.h>
#include <sys/types.h>
#include <sys/ioctl.h>
#include <sys/timeb.h>
#include <time.h>
// these make the serial port work!
#include <sys/stat.h>
#include <fcntl.h>
#include <termios.h>

int serport;    //the device for I/O
int mybuff ='?';   //the input character from serial port

//setup serial port for character I/O
int initport (char *deviceName){
int fd;
    struct termios options;
    serport = open(deviceName, O_RDWR | O_NOCTTY | O_NDELAY);
#ifdef DESKTOP
    if (serport == -1) {
        perror("open_port fail: ");
        perror(DEVICE_NAME);
        return -1;
    }
#endif
    //Next line not liked by  gcc so we get existing one 
    //bzero(&options,sizeof(options));
    fd = serport;
    tcgetattr(fd,&options);
    options.c_cflag = (B2400 |CRTSCTS |CS8| CLOCAL |CREAD);
    // options.c_cflag &= ~PARENB;
    // options.c_cflag &= ~CSTOPB;
    // options.c_cflag &= ~CSIZE ;
    options.c_iflag |= IGNPAR ;
    options.c_oflag = 0;
    //options.c_oflag = options.c_iflag;
    options.c_lflag = 0 ;    //no echo, no buffer till ENTER key
    options.c_cc[VMIN] = 0;  // don't wait for any characters
    options.c_cc[VTIME] = 0; // no intercharacter delay
    tcflush(fd,TCIFLUSH);
    tcsetattr(fd,TCSANOW,&options);
    fcntl(fd,F_SETFL,FNDELAY);    //nonblocking
    cfsetispeed(&options, B2400);
    cfsetospeed(&options, B2400);
    return serport;
}    
// End initport

//readsch reads none, or one waiting characters
int readsch(int fd){
    int readError = 0;
    char portbuff[200];
     
    readError = read(fd,portbuff,1);
    readError-- ;    // so we can have nulls
    if (readError >= 0) 
        readError = portbuff[0];
    return readError;
}
// End readsch

int writesch(int fd, char chtosend){
    int writeError = 0;
    char portbuff[200]; 
    portbuff[0] = chtosend;
    writeError = write(fd,&portbuff,1);
    return writeError;
}
// End writesch

int writesstr(int fd, char * strtosend){
    int writeError = 0;
    int sendLen = strlen(strtosend); 
    if (strtosend[sendLen-1] =='\0')
        sendLen--;
    writeError = write(fd,strtosend,sendLen);
    return writeError;
}
// End writesstr


//now use the readsch in a timed loop somehow...

                 // Continue user entry
                mybuff = readsch(serport);
                if (mybuff < 0){
                    
                 // do whatever happens when there is nothing to read    
                } else {
                //some user entry
                    
                        // do stuff with contents of mybuff

                                  }