Can't read from serial port properly in linux

Question

I programmed a board (ERC 32 processor) to return a character every time I send one character from the serial port. When I send a character through GTKterm everything works fine and the boards returns properly. I'm writing a code in C to send and get back characters; however, it either fails in some fashion or works for some executions and suddenly it doesn't work anymore. I read a lot of questions on serial ports and couldn't figure out what is happening.

I tried 3 approaches:

1) Blocking read/write code
Problem: It worked for a while then the read function blocked and didn't take any byte. code below

#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <termios.h>
#include <errno.h>
#include <sys/ioctl.h>
#include <sys/signal.h>
#include <sys/types.h>

//Test chars
char d='a',a;

int main()

{
    struct          termios tio;
    struct          termios old_tio;

    //Open serial port
    tty_fd=open("/dev/ttyS1",O_RDWR | O_NOCTTY);

    //Just to check, ir returs 3 always
    printf("fd: %d\n",tty_fd);

    //Get previous configurations
    tcgetattr(tty_fd,&old_tio);

    cfsetospeed(&tio,B19200);            // 19200 baud
    cfsetispeed(&tio,B19200);

     /*CS8     : 8n1 (8bit,no parity,1 stopbit)
     CLOCAL  : local connection, no modem contol
     CREAD   : enable receiving characters*/

    tio.c_iflag &= ~(IXON | IXOFF | IXANY);
    tio.c_oflag = 0;

    tio.c_cflag &= ~PARENB;   /* Disables the Parity Enable bit(PARENB),So No Parity   */
    tio.c_cflag &= ~CSTOPB;   /* CSTOPB = 2 Stop bits,here it is cleared so 1 Stop bit */
    tio.c_cflag &= ~CSIZE;   /* Clears the mask for setting the data size             */
    tio.c_cflag |=  CS8|CREAD|CLOCAL;
    tio.c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG); //non-cannonical

    tio.c_cc[VMIN]=1;
    tio.c_cc[VTIME]=0;

    tcsetattr(tty_fd,TCSANOW,&tio);
    tcflush(tty_fd, TCIFLUSH);
    tcflush(tty_fd, TCOFLUSH);

    //Write a char and waits for a return char immediately after
    bytes_written=write(tty_fd,&d,1);
    printf("bytes written:%d\n",bytes_written);
    read(tty_fd,&a,1);
    printf(" bytes read:%d\n",bytes_read);

    tcsetattr(tty_fd,TCSANOW,&old_tio);
    close(tty_fd);
    return 0;

}

2) Threaded Blocking read/write code
Problem: the read function blocks and don't take any byte.
Note: I programmed in a way that the read thread is iniatialized first to ensure that it starts to "observe" the port regardless of any write call. Code below

#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <termios.h>
#include <errno.h>
#include <sys/ioctl.h>
#include <sys/signal.h>
#include <sys/types.h>
#include <pthread.h>

char a='z';
char read_char='?';

void *read_thread(void *arg)
{

     int *tty_fd_ptr= (int*) arg;
    int tty_fd = *tty_fd_ptr;

    unsigned int bytes_read=0;

    //Read until it gets at leats one byte
    while(bytes_read<=0)
    {
        bytes_read=read(tty_fd,&read_char,1);
    }

    printf("char: %c\n",read_char);

    pthread_exit(0);

}


void *test_thread(void *arg)
{

    int *tty_fd_ptr= (int*) arg;
    int tty_fd = *tty_fd_ptr;
    unsigned int bytes_written;

    bytes_written=write(tty_fd,&a,1);
    printf("Bytes written: %d\n",bytes_written);

    pthread_exit(0);

}

int main ()

{

    int count;
    int tty_fd;

    //The port oppening routine and configurations is exactly the same of the
    //previous code

     //Thread ID
     pthread_t tid,tid_2;

     //Create attributes
     pthread_attr_t attr,attr_2;

     pthread_attr_init(&attr);
     pthread_create(&tid, &attr,read_thread,&tty_fd);

     pthread_attr_init(&attr_2);
     pthread_create(&tid_2, &attr_2,test_thread,&tty_fd);


     pthread_join(tid,NULL);
     pthread_join(tid_2,NULL);


    tcsetattr(tty_fd,TCSANOW,&old_tio);
    close(tty_fd);
    return 0;

}

3) Non-blocking read/write code with Signal handler
Problem: As you can see in the code I put a write call before the main loop (port watcher loop). Also the signal handler to the port is already set. It writes but don't read anything. Code below

#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <termios.h>
#include <errno.h>
#include <sys/ioctl.h>
#include <sys/signal.h>
#include <sys/types.h>

volatile int STOP=FALSE;
int tty_fd;
int bytes_written=0,bytes_read;
char a='z',c='b';

void signal_handler_IO (int status)
     {
        printf("Interrupt\n");
        wait_flag = FALSE;
     }

int main ()

{

    struct sigaction saio;           /* definition of signal action */

    struct termios tio;
    struct termios old_tio;

    tty_fd=open("/dev/ttyS1",O_RDWR | O_NOCTTY | O_NONBLOCK);
    printf("fd: %d\n",tty_fd);

    /* install the signal handler before making the device asynchronous */
     saio.sa_handler = signal_handler_IO;
     sigemptyset(&saio.sa_mask);
     saio.sa_flags = 0;
     saio.sa_restorer = NULL;
     sigaction(SIGIO,&saio,NULL);

     /* allow the process to receive SIGIO */
    fcntl_status=fcntl(tty_fd, F_SETOWN, getpid());

    fcntl_status=fcntl(tty_fd, F_SETFL, FASYNC);

    tcgetattr(tty_fd,&old_tio);

    cfsetospeed(&tio,B19200);            // 19200 baud
    cfsetispeed(&tio,B19200);
    //cfmakeraw(&tio);

     /*CS8     : 8n1 (8bit,no parity,1 stopbit)
     CLOCAL  : local connection, no modem contol
     CREAD   : enable receiving characters*/

    tio.c_iflag &= ~(IXON | IXOFF | IXANY);

    tio.c_oflag=0;

    //tio.c_cflag=CS8|CREAD|CLOCAL;
    tio.c_cflag &= ~PARENB;   /* Disables the Parity Enable bit(PARENB),So No Parity   */
    tio.c_cflag &= ~CSTOPB;   /* CSTOPB = 2 Stop bits,here it is cleared so 1 Stop bit */
    tio.c_cflag &= ~CSIZE;   /* Clears the mask for setting the data size             */
    tio.c_cflag |=  CS8|CREAD|CLOCAL;
    tio.c_lflag=0;


    tio.c_cc[VMIN]=1;
    tio.c_cc[VTIME]=0;

    tcsetattr(tty_fd,TCSANOW,&tio);
    tcflush(tty_fd, TCIFLUSH);
    tcflush(tty_fd, TCOFLUSH);

     bytes_written=write(tty_fd,&c,1);
     printf("bytes written: %d\n",bytes_written);


     while (STOP==FALSE)
      {
              usleep(10000);

              /* after receiving SIGIO, wait_flag = FALSE, input is available
                 and can be read */
         if (wait_flag==FALSE)
         {


            bytes_read=read(tty_fd,&a,1);

            printf("bytes read:%d \n",bytes_read);
             wait_flag = TRUE;      /* wait for new input */
         }
       }

    tcsetattr(tty_fd,TCSANOW,&old_tio);
    close(tty_fd);
    return 0;

}

My goal is to make a hardware in the loop system where the data to be transfered begins in the linux side, goes through the uart to the board, the board takes the data, process and return it to the computer and then the loop runs over again until some stop condition is met. I wrote a simple code for the board just to test a single character loop before I increase the complexity.

It is worth to note that:
-> if I write a simple code that just call a single write function with one character and executes GTKterm at the same time I can see the board response in the GTKterm console.
-> for the blocking versions of code, when the code blocks in the read function, If I reset the board it takes the first character of the board welcome message.It is expected but I don't know why for write calls programmed in the board it doesn't take but GTkterm does.
-> I also tried some of the codes in a direct linux machine and have the same issues and GTKterm working fine.

I'm not sure if there is a trickier setting that I'm not seeing. Any help will be appreciated.

The board: ERC32 chip (TSC695F) being programmed with RTEMS real time operating system. The chip UART is full duplex.

The computer: Mandriva linux on a VMware virtual machine over a Windows 7.

$ uname -a
Linux localhost.localdomain 2.6.36.2-desktop586-2mnb #1 SMP Wed Dec 22 17:11:08 UTC 2010 i686 i686 i386 GNU/Linux

$ cat /etc/*-release
Mandriva Linux release 2010.2 (Official) for i586