my $Message = $_;

# Calculate Length of Message
my $MsgLgth = 18 + length $Message;

if ( $MsgLgth > 9 && $MsgLgth < 1_000_000 ) {
    $Message = sprintf "\x2%08d00000000%s\x3", $MsgLgth, $Message
    }
else{
    # Max length is 300_000
    # If hit here, too long ... by a LOT
    print "Formated Message exceeds MaxMessageLength\n\n";
    }
[download]

So why not just something like

Win8 Strawberry 5.8.9.5 (32)  Tue 07/19/2022  0:41:07
C:\@Work\Perl\monks
>perl

use strict;
use warnings;

use Data::Dump qw(dd);

use constant MaxMessageLength => 300_000;

my $Message = 'how now brown cow';
my $MsgLgth = length($Message)+18;

$MsgLgth <= MaxMessageLength
    or die sprintf 'Formatted Message len %ld exceeds MaxMessageLength
+ %ld',
                    $MsgLgth, MaxMessageLength
                    ;

$Message = sprintf "\x02%08d00000000%s\x03", $MsgLgth, $Message;
dd $Message;

^Z
"\x020000003500000000how now brown cow\3"
[download]

use constant MaxMessageLength => 300_000;

sub stx_encode {
  my ($Message, $max_length) = @_;
  my $MsgLgth = 18 + length $Message;
  die "Formatted message exceeds MaxMessageLength" if $MsgLgth >= $max
+_length;
  return sprintf "\x2%08d00000000%s\x3", $MsgLgth, $Message;
}

print stx_encode('hello', MaxMessageLength);
[download]

use strict;
use warnings;

sub myMessage {
    my $payload = shift;
    my $format
        = "\N{STX}"
        . '%08u'    # Byte count
        . '0' x 8   # Reserved
        . '%s'      # Pay load
        . "\N{ETX}"
    ;
    return sprintf $format, 18 + length($payload), $payload;
}

my $result = myMessage("<PAYLOAD>");

print $result, "\n";
print unpack 'H*', $result;
[download]

RESULT:

>perl CuriousMark.pl
.0000002700000000<PAYLOAD>.
02303030303030323730303030303030303c5041594c4f41443e03
>
[download]

Note: Non-printing characters replaced with '.' in forum only. Hex dump is accurate.

Hex encoding is very inefficient to handle because it's a non-contiguous part of the ASCII table. I usually use "cavcode"(*), because that's easy to implement in most programming languages, including in C for stuff like Arduinos. And of course it works very well with framing bytes.

sub frame2packet {
    my @frame = @_;

    my $packet = '';
    foreach my $byte (@frame) {
        my $lowbyte = ($byte & 0x0f) + 65;
        my $highbyte = ($byte >> 4) + 65;

        $packet .= chr($highbyte);
        $packet .= chr($lowbyte);
    }

    return $packet;
}

sub packet2frame {
    my $packet = shift;

    my @chars = split//, $packet;
    my @frame = ();

    # Decode to bytes
    while(@chars) {
        my $high = shift @chars;
        my $low = shift @chars;

        my $val = ((ord($high) - 65) << 4) + (ord($low) - 65);
        push @frame, $val;
    }

    return @frame;
}
[download]

Writing, for example, the counterpart encoder for Arduino is also quite easy. No need for a lookup table and stuff, this can be done with very low RAM usage:

      
highbyte = 0x02;
Serial.write(highbyte);
for(inoffs = 0; inoffs < PKT_LEN; inoffs++) {
    intmpbyte = inpacket[inoffs];
    highbyte = ((intmpbyte >> 4) & 0x0f) + 65;
    lowbyte = (intmpbyte & 0x0f) + 65;
    Serial.write(highbyte);
    Serial.write(lowbyte);
}
highbyte = 0x03;
Serial.write(highbyte);
[download]

(*) cavcode stands for "cavac encode". Yes, named it after myself, and nobody can stop me.

PerlMonks XP is useless? Not anymore: XPD - Do more with your PerlMonks XP

Note: There is absolutely no "hex encoding" in my solution. I added a hex dump of my result in order to display the control characters (and ASCII zero's) unambiguously in this forum.
Bill

If you are going to send this message across a serial link, you should consider adding a checksum or CRC-16. Also, if you send a preamble of SYN characters, the protocol can be made to recover from mangled messages. I've used this many times across serial links.

James