RS232 Communication Port Sending ASCII data

Question

I have a console application that is communicating with a custom machine through RS232 Comm port. According to documentation of the machine there are commands such as

1. Start machine Command:DC1
   Complete Command:'STX' STN 'DC1' 'ETX' BCC
   hex codes(02 31 11 03 47)
2. Stop machine Command:DC2
   Complete Command:'STX' STN 'DC2' 'ETX' BCC
   hex codes(02 31 12 03 48)

I am able to start and stop machine with this:

byte[] _startMachine = new byte[] { 0x02, 0x31, 0x11, 0x03, 0x47 };  
        _serialPort.Write(_startMachine, 0, _startMachine.Length);

    byte[] _stopMachine = new byte[] { 0x02, 0x31, 0x12, 0x03, 0x48 };   
    _serialPort.Write(_stopMachine, 0, _stopMachine.Length);

However I am stuck on this command 4. Read out batch total Command: DC4
Complete command:'STX' STN 'DC4' 'ETX' BCC
hex codes(02 31 14 03 4A)

Following the previous logic I am assuming that this should work.

byte[] _getBatchTotal = new byte[] { 0x02, 0x31, 0x14, 0x03, 0x4A };  
   _serialPort.Write(_getBatchTotal, 0, _getBatchTotal.Length);

I am following the same logic but I think the tricky part is the end of the command, am I translating the hex correctly?

Not sure if thats mistake in the documentation but it is also written that the everywhere used BCC (= Block Check Character) is calculated as sum of all bytes already read (incl. STX and ETX) . So for example starting machine command is simply Example： STX STN DC1 ETX BCC HEX: 02+31+11+03 == 47

Why is the BCC of the read batch command in this weird format then '4A'. Thank you.

Answer 1

Here's how I would do it. First I'd set up the message formats as simple strings:

private const string StartMachineMessage = "\x02{0}\x11\x03";
private const string StopMachineMessage = "\x02{0}\x12\x03";
private const string ReadBatchMachineMessage = "\x02{0}\x14\x03";

Note that the {0} placeholder to hold the station number (it's always 1 in your case (which is what 0x31 represents), but it could be variable). Since it's always one here:

private const int StationNumber = 1;

Then I'd need a way to calculate the BCC of a bunch of bytes. This will do it for any array of bytes (which may be useful if you have longer messages):

private static byte GetBccOfBytes (byte[] bytes)
{
    var bcc = 0;
    foreach (var byt in bytes)
    {
        bcc += byt;
    }
    return (byte)(bcc & 0xff);
}

I'm assuming that the BCC is the lower 8 bits of the sum, so I use 0xff as a mask.

Now comes the meat of the problem, formatting the message and converting it to a byte array with a BCC:

public static byte[] GetMessageWithBcc (string format, int stationNumber)
{
    var messageWithStation = string.Format(format, stationNumber);  //mix the station number into the format string
    var noBccBytes = Encoding.ASCII.GetBytes(messageWithStation);   //convert the string to an array of ASCII bytes
    var result = new byte[noBccBytes.Length + 1];                   //allocate a buffer to hold the result, note room for BCC
    for (var i = 0; i < noBccBytes.Length; ++i)                     //copy the first byte array to the result byte array
    {
        result[i] = noBccBytes[i];
    }
    result[noBccBytes.Length] = GetBccOfBytes(noBccBytes);          //calculate and append the BCC
    return result;
}    

Then I need a way of seeing what these byte arrays look like, so convert them to a string with a space between each byte hex representation:

private static string BytesAsHexString (byte[] bytes)
{
    bool started = false;
    var buffer = new StringBuilder(bytes.Length * 3 - 1);
    foreach (var byt in bytes)
    {
        if (started)
        {
            buffer.Append(" ");
        }
        started = true;
        buffer.Append($"{byt:x02}");
    }
    return buffer.ToString();
}

If you want to see other, more efficient ways of doing this, How do you convert a byte array to a hexadecimal string, and vice versa?

Finally, some test code:

public static void Test()
{
    var messages = new Dictionary<string, string>
    {
        {nameof(StartMachineMessage), StartMachineMessage },
        {nameof(StopMachineMessage), StopMachineMessage },
        {nameof(ReadBatchMachineMessage), ReadBatchMachineMessage },
    };

    foreach (var msgPair in messages)
    {
        var result = GetMessageWithBcc(msgPair.Value, StationNumber);
        Console.WriteLine($"{msgPair.Key}: {BytesAsHexString(result)}");
    }
}

The output of this looks like:

StartMachineMessage: 02 31 11 03 47
StopMachineMessage: 02 31 12 03 48
ReadBatchMachineMessage: 02 31 14 03 4a