Problema al escribir en puerto serie

[daaran]

Buenas , llegué a este código, y las funciones de lectura y escritura básicas van bien.
Lo que falla es al intentar enviar algo cuando detecta la entrada del teclado.
No acaba de enviar nada hasta que no cierro el programa.

Aunque creo que mas en el teclado, el problema esta en el Hilo.
Para hacer las pruebas tengo conectados dos ordenadores. EL que tiene este programa en Windows y otro con la terminal en Linux.

Espero que me puedan ayudar. Gracias

Código:

#include <iostream.h>
#include <string.h>
#include <assert.h>
#include <stdlib.h>
#include <windows.h>
#include <time.h>
#include <conio.h> //Para getch

//-------------------------------------funciones
void leeSerie();
void escribeSerie(char *paquete);
void cierraSerie();
void iniciaSerie();

//-------------------------------------variables
DWORD Hilo (LPDWORD lpdwParam);
HANDLE hHilo; 
HANDLE idComDev;
DCB dcb;
OVERLAPPED ov;

char buzon[512]; 
unsigned char buffer[512];  
bool ok,salir;
char teclado[512]; 
char algo[1024];

int main ()
{
      salir=false;  
      char tecla;
     
      iniciaSerie(); 
     
     
      strcpy (algo, "que tal estas?"); 
      escribeSerie(algo); 
     
      while (!salir)
      {
         //he probado con cin y getch() por si acaso...
        /*
             if(cin.getline (teclado, 80))
             {
                            if(!strcmp (teclado, "salir"))
                             {
                                         salir = true;
                                         cierraSerie();
                             } 
                                                   
                             if(!strcmp (teclado, "send"))
                             {
                                  cout << "has dicho send" << endl;
                                  strcpy (algo, "adios"); 
                                  escribeSerie(algo); 
                                           
                                          
                              }
            }
           */ 
            
            printf("Pulsa la tecla A para enviar: \n\r");
            tecla = getch();
            if(tecla==97)
            {
                         printf("--------------------------Has pulsado la A\n\r");
                         strcpy (algo, "bye bye"); 
                         escribeSerie(algo); 
                         salir=true;   
                 
            }
             
    
    }//cierro while
     
     system("PAUSE");
     return 0;
     
     
}//------------------------------------------------------- CIERRO MAIN

void iniciaSerie()
{
     DWORD param, id;  
     dcb.DCBlength = sizeof(DCB);
     
     //---------------------------------- APERTURA DEL PUERTO (indicar el puerto)
 
         idComDev = CreateFile ("COM4", GENERIC_READ | GENERIC_WRITE, 0, NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,NULL);
         
         // FILE_FLAG_OVERLAPPED  |  FILE_ATTRIBUTE_NORMAL
         
         if(idComDev == INVALID_HANDLE_VALUE)
         {
            cout << "ERROR al inicializar el puerto" << endl;
         }
         else
         {
              cout << "COM abierto" << endl;
         }

         //-------------- CONFIGURACION DEL PUERTO
         GetCommState (idComDev, &dcb);
         
         dcb.BaudRate = CBR_9600;
         dcb.ByteSize = 8;
         dcb.Parity   = NOPARITY  ;      // NOPARITY     EVENPARITY     ODDPARITY;
         dcb.fParity  = FALSE ;
         dcb.StopBits = ONESTOPBIT ;     // ONESTOPBIT    TWOSTOPBITS
         dcb.fBinary =  TRUE;
         
         ok = SetCommState (idComDev,&dcb);
         
         if(!ok)
         {
              cout << "ERROR al configurar el puerto" << endl;        
         }
         else
         {
             cout << "puerto configurado" << endl;
         }//-------------------------------- EVENTO
         
           ov.hEvent = CreateEvent(NULL, /* no security attributes */
                        FALSE, /* auto reset event */
                        FALSE, /* not signaled */
                        NULL /* no name */);
               assert(ov.hEvent);
               ov.Offset = NULL;
               ov.OffsetHigh = NULL;

         
        
          //------------------------------ HILO DE LECTURA     
        
        
       
         hHilo = CreateThread (NULL, 0, (LPTHREAD_START_ROUTINE)Hilo, &param, 0, NULL);
         
         if(!hHilo)
         {
                   cout << "ERROR al lanzar el hilo" << endl;       
         }
         else
         {
                   cout << "Hilo de lectura lanzado." << endl << endl;
        
         }
        
         
         SetCommMask (idComDev, EV_RXCHAR);
         
         
         
         
     
     return;     
}


void cierraSerie()
{
          CloseHandle (hHilo);
          CloseHandle(idComDev);
     return;     
}



void leeSerie()
{
    DWORD x;
    COMSTAT cs;
   
    ClearCommError (idComDev, &x, &cs);
    ReadFile (idComDev, buzon, cs.cbInQue, &x, &ov );  //&ov
    buzon[x] = 0;
    cout << buzon;
    
     if(!strcmp (buzon, "h"))
     {
            cout << "\r\n han enviado una H" << endl; 
            
     }
    return;
}


void escribeSerie(char *paquete) //----------------------------------------------ENVIO POR EL PUERTO
{
         
         unsigned long  enviat=0, enviando=0,total;    
         char palabra[1024];         
          
         //enviat   ->   numero de bytes enviados
         //enviando ->   bytes enviados en la instruccion
         //leidos   ->   total a enviar
         
          strcpy (palabra, paquete);
          strcat (palabra, "\r\n");
          total = strlen (palabra); 
         
         
         while(enviat <= total-1)
         {
                WriteFile (idComDev, &palabra[enviat], total-enviat, &enviando, &ov); //&ov
                enviat+=enviando;
         }
         
         return;
}


DWORD Hilo (LPDWORD lpdwParam) //-------------------------------------------------HILO DE LECTURA
{
    DWORD dwEvtMask;
    do
    {
        if(WaitCommEvent(idComDev, &dwEvtMask, &ov)){    //
     // if(WaitCommEvent(idComDev, &dwEvtMask, NULL)){  //
            if(dwEvtMask & EV_RXCHAR) 
            {
                 leeSerie();
            }
         }
    }
    while (true);
    return 0;
}