ReadFile reads from Hyperterminal window but not from external device

Question

I have this program that uses winapi functions for reading from a serial port:

#include <string>
#include <Windows.h>
using std::cin;
using std::cout;

DCB       blank_dcb = {0};

int main()
{
    int ierr, jsu, jcs, jto, jrf, nt;
    unsigned char readfile_chars[80];
    DWORD nr;
    std::string s;
    HANDLE port_h;
    COMMTIMEOUTS port_timeouts;
    DCB dcb;
    
    port_h = CreateFile("COM6", GENERIC_READ|GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
    if(INVALID_HANDLE_VALUE == port_h)
    {
        cout << "Failed to open COM6.\n";
        cout << "Press ENTER to exit.\n";
        getline(cin, s);
        return -1;
    }
    
    //
    // Call SetupComm().
    //
    jsu = SetupComm(port_h, 1024, 1024);
    if(0 == jsu)
    {
        cout << "Error while calling SetupComm(): ";
        ierr = GetLastError();
        cout << ierr << "\n";
        cout << "Press ENTER to exit.\n";
        getline(cin, s);
        return -1;
    }
    
    //
    // Set the comm state.
    //
    dcb = blank_dcb;
    dcb.DCBlength = sizeof(DCB);
    dcb.BaudRate = CBR_9600;
    dcb.ByteSize = 8;
    dcb.StopBits = ONESTOPBIT;
    dcb.Parity = NOPARITY;
    dcb.fBinary = TRUE;
    
    jcs = (int) SetCommState(port_h,&dcb);
    if(0 == jcs)
    {
        cout << "Error while setting comm state.\n";
        cout << "Press ENTER to exit.\n";
        getline(cin, s);
        return -1;
    }
    
    //
    // Set the port's timeouts.
    //
    port_timeouts.ReadIntervalTimeout = MAXDWORD;
    port_timeouts.ReadTotalTimeoutConstant = 0;
    port_timeouts.ReadTotalTimeoutMultiplier = 0;
    port_timeouts.WriteTotalTimeoutConstant = 0;
    port_timeouts.WriteTotalTimeoutMultiplier = 0;
    
    jto = SetCommTimeouts(port_h, &port_timeouts);
    if(0 == jto)
    {
        cout << "Error setting comm timeouts.\n";
        cout << "Press ENTER to exit.\n";
        getline(cin, s);
        return -1;
    }
    
    Sleep(5000);
    nt = 9;
    jrf = ReadFile(port_h, (LPVOID) &readfile_chars[0], nt, &nr, NULL);
    if(0 == jrf)
    {
        cout << "ReadFile() failed.\n";
    }
    
    cout << "Read " << nr << " characters.\n";
    readfile_chars[nr] = '\0';
    cout << "Characters read: " << readfile_chars << "\n";
    
    cout << "Press ENTER to exit.\n";
    getline(cin, s);
    return 1;
}

And this program that uses Boost.Asio:

#include <iostream>
#include <string>

#define _WIN32_WINNT 0x0601

#include <boost/asio.hpp>
using std::cin;
using std::cout;

int main()
{
    char message[80];
    std::string s;
    boost::asio::io_service io_svc;
    
    boost::asio::serial_port com6(io_svc, "COM6");
    com6.set_option(boost::asio::serial_port_base::baud_rate(9600));
    com6.set_option(boost::asio::serial_port_base::character_size(8));
    com6.set_option(boost::asio::serial_port_base::stop_bits(boost::asio::serial_port_base::stop_bits::one));
    com6.set_option(boost::asio::serial_port_base::parity(boost::asio::serial_port_base::parity::none));
    com6.set_option(boost::asio::serial_port_base::flow_control(boost::asio::serial_port_base::flow_control::none));
    
    boost::asio::read(com6, boost::asio::buffer(&message[0],9));
    
    message[9] = '\0';
    cout << "Characters received: " << message << "\n";
    
    cout << "Press ENTER to exit.\n";
    getline(cin, s);
}

I have a digital level that transmits ASCII characters through an RS232 port.

The digital level transmits characters successfully to a Putty window.

The boost program reads characters successfully from a Hyperterminal window on an external PC connected by a serial cable to COM6.

The boost program reads characters successfully from the digital level.

The winapi program reads characters successfully from the Hyperterminal window on the external PC.

The winapi program does NOT read characters from the digital level. The function ReadFile() returns successfully with the number of characters received set to zero, showing that it considers the digital level to be at end-of-file.

Why does the boost program read successfully from the digital level while the winapi program does not?