How to insert hex value and send to serial port?

Question

Below is my code. I want to send hex values and get the output as hex in the hyper terminal. I am not sure how to send it.

I am getting some garbage values in the hyperterminal output. It is reading but not sending the hex output.

#include "stdafx.h"
#include <Windows.h>
#include <stdio.h>
#include <string.h>
#include <conio.h>
#include <stdint.h>
#define    BUFFERLENGTH 256


int main(void)
{
    HANDLE hComm;                          // Handle to the Serial port
    char ComPortName[] = "\\\\.\\COM6"; // Name of the Serial port(May Change) to be opened,
    BOOL   Status;
    DWORD dwEventMask;                     // Event mask to trigger
    unsigned char TempChar;             // Temperory Character
    char  SerialBuffer[256];               // Buffer Containing Rxed Data
    DWORD NoBytesRead;                     // Bytes read by ReadFile()
    int i = 0;


    printf("\n\n +==========================================+");
    printf("\n |  Serial Communication (Win32 API)         |");
    printf("\n +==========================================+\n");
    /*----------------------------------- Opening the Serial Port --------------------------------------------*/

    hComm = CreateFile(ComPortName,                       // Name of the Port to be Opened
        GENERIC_READ | GENERIC_WRITE,      // Read/Write Access
        0,                                 // No Sharing, ports cant be shared
        NULL,                              // No Security
        OPEN_EXISTING,                     // Open existing port only
        0,                                 // Non Overlapped I/O
        NULL);                             // Null for Comm Devices

    if (hComm == INVALID_HANDLE_VALUE)
        printf("\n   Error! - Port %s can't be opened", ComPortName);
    else
        printf("\n   Port %s Opened\n ", ComPortName);


    /*------------------------------- Setting the Parameters for the SerialPort ------------------------------*/

    DCB dcbSerialParams = { 0 };                        // Initializing DCB structure
    dcbSerialParams.DCBlength = sizeof(dcbSerialParams);

    Status = GetCommState(hComm, &dcbSerialParams);     //retreives  the current settings

    if (Status == FALSE)
        printf("\n   Error! in GetCommState()");

    dcbSerialParams.BaudRate = CBR_9600;      // Setting BaudRate = 9600
    dcbSerialParams.ByteSize = 8;             // Setting ByteSize = 8
    dcbSerialParams.StopBits = ONESTOPBIT;    // Setting StopBits = 1
    dcbSerialParams.Parity = EVENPARITY;      // Setting Parity = None 

    Status = SetCommState(hComm, &dcbSerialParams);  //Configuring the port according to settings in DCB 

    if (Status == FALSE)
    {
        printf("\n   Error! in Setting DCB Structure");
    }
    else
    {
        printf("\n   Setting DCB Structure Successfull\n");
        printf("\n       Baudrate = %d", dcbSerialParams.BaudRate);
        printf("\n       ByteSize = %d", dcbSerialParams.ByteSize);
        printf("\n       StopBits = %d", dcbSerialParams.StopBits);
        printf("\n       Parity   = %d", dcbSerialParams.Parity);
    }

    /*------------------------------------ Setting Timeouts --------------------------------------------------*/

    while (1)
    {

        COMMTIMEOUTS timeouts = { 0 };

        timeouts.ReadIntervalTimeout = 5000;
        timeouts.ReadTotalTimeoutConstant = 5000;
        timeouts.ReadTotalTimeoutMultiplier = 1000;
        timeouts.WriteTotalTimeoutConstant = 5000;
        timeouts.WriteTotalTimeoutMultiplier = 1000;

        if (SetCommTimeouts(hComm, &timeouts) == FALSE)
            printf("\n   Error! in Setting Time Outs");
        else
            printf("\n\n   Setting Serial Port Timeouts Successfull");

        printf("\n |---------  Serial Communication (Win32 API) --------|");

        printf("Starting to write......");

        //char   lpBuffer[] = "ABC";               // lpBuffer should be  char or byte array, otherwise write wil fail

        uint8_t message[15];
        message[0] = 0x16;
        message[1] = 0x16;
        message[2] = 0x02;
        message[3] = 0x01;
        message[4] = 0x07;
        message[5] = 0x08;
        message[6] = 0x00;
        message[7] = 0xFF;
        message[8] = 0xFF;
        message[9] = 0x01;
        message[10] = 0x00;
        message[11] = 0x01;
        message[12] = 0x00;
        message[13] = 0xFF;
        message[14] = 0xFF;

        //byte(bytestosend)[15] = { message[0], message[1], message[2], message[3], message[4], message[5], message[6], message[7], message[8], message[9],message[10], message[11],message[12], message[13], message[14] };

        DWORD  dNoOFBytestoWrite;              // No of bytes to write into the port
        DWORD  dNoOfBytesWritten = 0;          // No of bytes written to the port

        dNoOFBytestoWrite = sizeof(message); // Calculating the no of bytes to write into the port
        Status = WriteFile(hComm,               // Handle to the Serialport
            message,            // Data to be written to the port 
            dNoOFBytestoWrite,   // No of bytes to write into the port
            &dNoOfBytesWritten,  // No of bytes written to the port
            NULL);

        if (Status == TRUE)
            printf("\n\n    %X %X %X %X %X %X %X %X %X %X %X %X %X %X %X- Written to %s", message[0], int(message[1]), int(message[2]), int(message[3]), int(message[4]), int(message[5]), int(message[6]), int(message[7]), int(message[8]), int(message[9]), int(message[10]), int(message[11]), int(message[12]), int(message[13]), int(message[14]), ComPortName);
        else
            printf("\n\n   Error %d in Writing to Serial Port", GetLastError());


        int k;
        for (k = 0; k < 50; k++)
        {
            printf("");
        }


        /*-----------------------------------Read --------------------------------------------*/


        int l;
        for (l = 0; l < 50; l++)
        {
            printf("");
        }


        printf("\n\n    Waiting for Data Reception");
        dwEventMask = 1;

        //Status = WaitCommEvent(hComm, &dwEventMask, NULL); //Wait for the character to be received

        /*-------------------------- Program will Wait here till a Character is received ------------------------*/

        if (Status == FALSE)
        {
            printf("\n    Error! in Setting WaitCommEvent()");
        }
        else //If  WaitCommEvent()==True Read the RXed data using ReadFile();
        {
            printf("\n\n    Characters Received");

            do
            {
                //byte(TempChar)[15] = { message[0], message[1], message[2], message[3], message[4], message[5], message[6], message[7], message[8], message[9],message[10], message[11],message[12], message[13], message[14] };
                //if(! ReadFile(hComm, &TempChar, sizeof(TempChar), &NoBytesRead, NULL))
                if (!ReadFile(hComm, &TempChar, sizeof(TempChar), &NoBytesRead, NULL))
                ///*    ReadFile(
                //      _In_ HANDLE hFile,
                //      _Out_writes_bytes_to_opt_(nNumberOfBytesToRead, *lpNumberOfBytesRead) __out_data_source(FILE) LPVOID lpBuffer,
                //      _In_ DWORD nNumberOfBytesToRead,
                //      _Out_opt_ LPDWORD lpNumberOfBytesRead,
                //      _Inout_opt_ LPOVERLAPPED lpOverlapped
                //  );*/
                //if (!ReadFile(hComm, SerialBuffer, BUFFERLENGTH, &NoBytesRead, NULL))
                {
                    printf("wrong character" );
                }

                //printf("/n /n %X %X %X %X %X %X %X %X %X %X %X %X %X %X %X", int(TempChar[0]), int(TempChar[1]), int(TempChar[2]), int(TempChar[3]), int(TempChar[4]), int(TempChar[5]), int(TempChar[6]), int(TempChar[7]), int(TempChar[8]), int(TempChar[9]), int(TempChar[10]), int(TempChar[11]), int(TempChar[12]), int(TempChar[13]), int(TempChar[14]));
                SerialBuffer[i] = TempChar;
                //printf("%X is the read", SerialBuffer[i]);
                i++;
            } while (NoBytesRead > 0);

            /*------------Printing the RXed String to Console----------------------*/

            printf("\n\n    ");
            int j = 0;
            for (j = 0; j < i - 1; j++)     // j < i-1 to remove the dupliated last character
                printf("%X are the values read", SerialBuffer[j]);

        }
    }

    CloseHandle(hComm);//Closing the Serial Port
    printf("\n ==========================================\n");
    _getch();

}

I am giving this as input 16 16 02 01 07 08 FF FF 01 00 01 00 FF FF values, and I want the same to be read in hyperterminal. But I am getting some garbage values. I want the same hex values to be in the hyperterminal.

Answer 1

At very first: What you send is just data. There is no such thing as decimal or hexadecimal data, all that you have is binary data, i. e. the bits stored in groups of (typically) 8 for your bytes. Decimal or hexadecimal literals are just different representations for one and the same (binary) values:

char a[] = { 0x61, 0x62, 0x63, 0 };
char b[] = {   97,   98,   99, 0 };

a and b will now contain exactly the same values, which happen, if interpreted as ASCII characters, to represent the string "abc"...

If, however, your intention is to represent arbitrary binary data in a human readable format (as Intel HEX files do), then you would need to represent each data byte by two chars, e. g. convert the data byte containing 'N', having ASCII value of 78, into a byte sequence of '4', 'e' or alternatively '4', 'E'.

However, this will double your communication overhead, so I'd do the conversion only after receiving the data:

std::vector<char> received = readFromSerial();
// assuming arbitrary data..

for(auto c : received)
    std::cout << std::setfill('0') << std::hex << std::setw(2)
        << static_cast<unsigned int>(static_cast<unsigned char>(c)) << std::endl;

Side note: you need the double cast to prevent sign extension for negative characters (at least if char is signed).

If you should prefer signed or unsigned char depends on if you want to represent data in the range of [-128;127] or of [0;255] respectively...