No reaction from the serial port - c++

Question

How should I send 9 binary into serial port?
Is there anything wrong with this? I get no reaction from the serial port. What should I do for the write file?
#include <iostream>
#include <windows.h>
using namespace std;
int main(){
unsigned char data[9];
data[0] = { 0x00 };
data[1] = { 0x5A };
data[2] = { 0x56 };
data[3] = { 0xFF };
data[4] = { 0x04 };
data[5] = { 0x00 };
data[6] = { 0x00 };
data[7] = { 0x00 };
data[8] = { 0xB3 };
DWORD buffer = 0;
HANDLE port;
DCB dcb = { 0 };
port = CreateFile("COM1",
GENERIC_READ | GENERIC_WRITE,0,0,OPEN_EXISTING,0,0);
//DCB dcb;
DWORD m_baudrate = 9600, m_bytesize = 8, m_parity = 0, m_stopbit = 1, ok, m_useRtsCts = 0;
dcb.DCBlength = sizeof(dcb);
GetCommState(port, &dcb);
dcb.BaudRate = m_baudrate;
dcb.ByteSize = (BYTE)m_bytesize;
dcb.Parity = m_parity;
dcb.StopBits = m_stopbit;
if (m_useRtsCts)
dcb.fRtsControl = RTS_CONTROL_HANDSHAKE;
dcb.fDtrControl = DTR_CONTROL_DISABLE;
dcb.fNull = FALSE;
dcb.fAbortOnError = FALSE;
ok = SetCommState(port, &dcb);
if (port){
BuildCommDCB("COM1:9600,n,8,1", &dcb);
cout << "Hello" << endl;
PurgeComm(port, PURGE_RXCLEAR | PURGE_TXCLEAR);
WriteFile(port, data, sizeof(data), &buffer, 0);
}
else{
cout << "World" << endl;
}
CloseHandle(port);
system("Pause");
return 0;
}
I can send the data but the binary cannot turn on the light. the hexadecimal code to turn everything on is
00 5A 56 FF 03 00 00 00 B2
how ever after i use CommUart asistant to open to port once then the things can function. Could anyone tell me what is the problem at the Open port there? Thank You!
can anyone tell me what is wrong?
However with this set of code i can run it normally? May i know where of my setting was wrong above there.
#include <iostream>
#include <corewindow.h>
using namespace std;
int main(){
//unsigned char data[9] = {0,90,86,255,3,0,0,0,178};
unsigned char data[9];
data[0] = { 0x00 };
data[1] = { 0x5A };
data[2] = { 0x56 };
data[3] = { 0xFF };
data[4] = { 0x03 };
data[5] = { 0x00 };
data[6] = { 0x00 };
data[7] = { 0x00 };
data[8] = { 0xB2 };
DWORD buffer = 0;
HANDLE port;
DCB dcb = { 0 };
port = CreateFile("COM1",
GENERIC_READ | GENERIC_WRITE,
0,
0,
OPEN_EXISTING,
0,
0);
if (port == (HANDLE)-1)
{
return 0;
}
SetupComm(port, 1024, 1024);
FillMemory(&dcb, sizeof(dcb), 0);
dcb.DCBlength = sizeof(dcb);
BuildCommDCB("9600,n,8,1", &dcb);
if (!SetCommState(port, &dcb))
{
return 0;
}
COMMTIMEOUTS to;
memset(&to, 0, sizeof(to));
to.ReadIntervalTimeout = 100;
to.ReadTotalTimeoutMultiplier = 10;
to.ReadTotalTimeoutConstant = 10;
SetCommTimeouts(port, &to);
PurgeComm(port, PURGE_TXCLEAR | PURGE_RXCLEAR);
if (port){
cout << "Hello" << endl;
WriteFile(port, data, sizeof(data), &buffer, 0);
system("pause");
data[0] = { 0x00 };
data[1] = { 0x5A };
data[2] = { 0x56 };
data[3] = { 0xFF };
data[4] = { 0x04 };
data[5] = { 0x00 };
data[6] = { 0x00 };
data[7] = { 0x00 };
data[8] = { 0xB3 };
WriteFile(port, data, sizeof(data), &buffer, 0);
}
else{
cout << "World" << endl;
}
CloseHandle(port);
system("pause");
return 0;
}

Answer 1

There is no way that code could work. It should not have compiled.
At a minimum, the first parameter to Writefile is the file handle, and the third parameter is the number of bytes to write.
WriteFile(
hcomm,
"the string",
strlen ("the string"),
Also, you probably need to set the serial port's characteristics. That can be done using the command line or control panel, but it is often useful for the program to handle the details itself, after opening the file:
DCB dcb;
dcb.DCBlength = sizeof(dcb);
GetCommState(m_hCom, &dcb); /* retrieve current settings */
dcb.BaudRate = m_baudrate; /* alter bits per second */
dcb.ByteSize = (BYTE)m_bytesize; /* bits per character */
dcb.Parity = m_parity;
dcb.StopBits = m_stopbit;
if (m_useRtsCts)
dcb.fRtsControl = RTS_CONTROL_HANDSHAKE;
dcb.fDtrControl = DTR_CONTROL_DISABLE; // no handshake
dcb.fNull = FALSE; /* don't strip NULs */
dcb.fAbortOnError = FALSE; /* keep going after errors */
ok=SetCommState(hcomm, &dcb);
Addendum
To write the nine binary values as character values, any of these techniques would work. All rely on expressing the binary numbers as bytes:
char data[] = "\000\132\124\000\003\000\000\000\261";
WriteFile(hcomm, data, sizeof data, NULL, NULL);
or
char data[] = {0, 0132, 0124, 0, 3, 0, 0, 0, 0261};
WriteFile(hcomm, data, sizeof data, NULL, NULL);
or
char data[] = {0, 0x5a, 0x54, 0, 3, 0, 0, 0, 0xb1};
WriteFile(hcomm, data, sizeof data, NULL, NULL);

Answer 2

Setting telepathy mode on, I'd assume that TS wants to send 9-bit data. A typical way to achieve it is to use parity as a 9th data bit. The main idea is to cause a parity error to signify the 9th bit set. The details depend on the available hardware ad drivers.
If uart supports MARK/SPACE parities, something like this would work:
send_9_bits(unsigned char data, bool ninth_bit) {
if(ninth_bit) set_parity_mark();
else set_parity_space();
uart_write(data);
}
with the receiving end to analyze parity error status:
unsigned short receive_9_bits() {
unsigned short data = uart_read();
bool ninth_bit;
if (even_parity(data & 0x00ff) {
ninth_bit = PARERR(data >> 8)? 1: 0;
} else {
ninth_bit = PARERR(data >> 8)? 0: 1;
}
return (data & 0x0ff) | (ninth_bit << 8);
}

Answer 3

The serial port cannot work with a baud rate of 0. The baud rate, byte size, parity and stop bits must all be set to match the settings used by the device you are communicating with. And only certain standard values are supported by the serial hardware.