Numbers are numbers. Their format is determined on output. See sprintf.

If you want to use strings, then use strings.

$SM = "0xFE";

print $SM;
[download]

Of course, for strings, there is no numeric addition. Maybe you want to tell us more about your use case.

keep the hexnumbers as strings ...

  DB<121> $SM = 0xFE;
 => 254
 
  DB<122> $SM = "0xFE";
 => "0xFE"
 
  DB<123> print $SM
 => 1
0xFE
[download]

...or write a subroutine printhex() which automatically fulfills your wishes by converting any numeric scalar to a hexstring before printing.

I need to use hex numbers for something but when I assign hex number to something

Your point is...?

If you want to print as hex you need to use the format string as you show in your second example...

printf("0x%02X",$SM);
[download]

If you don't want to do that "everywhere" you can always create a sub such that:

| hand waving here...

my $n = 0x85;
printf "and the majic number is: %s\n",as_hex($n);


| more handwaving
exit(0);


sub as_hex{
    my $x=shift;
    sprintf "%X",$x;
}

[download]

#!/usr/bin/perl
use warnings;
use strict;


{
    package DecHex;
    use Scalar::Util qw(dualvar);

    sub create {
        my $num    = shift;
        my $string = sprintf '%X', $num;
        my $self   = dualvar($num, $string);
    }
}

my $x = DecHex::create 0xFE;
print "$x, ", 0+$x, "\n";
[download]

That is really nice, I think this is what I wanted, thank you.

Thanks for the replies, but how is it useful that using a number as string? Because I'm not sure about the results yet. The thing is, I'm trying to learn a new protocol that I should use it to give orders to a machine remotely. Also I need to calculate a variable so I need numeric values instead of strings.

#!/usr/bin/perl
use warnings;
use strict;
use IO::Socket;

my ($SM,@ADRDSTN,@ADRSRC,$MID,$MDLH,$MDLL,$SUBMID,@CHreq,@Pity,@Flags,
+@Timeout,@Level,$NumOfSrcEl,@SrcEl,$NumOfDstnEl,@DstnEl,$Rsvd,@messag
+e,$CHECKSUM,$EM);

$SM = 0xfe;
@ADRDSTN= (0x00, 0x09, 0x01, 0x00);
@ADRSRC= (0x00, 0x08, 0x01, 0x00);
$MID= 0x01;
$MDLH= 0x00;
$MDLL= 0x18;
$SUBMID= 0x00;
@CHreq= (0x00, 0x61);
@Pity= (0xFF, 0x05);
@Flags= (0x00, 0x20);
@Timeout= (0x00, 0x00);
@Level= (0x00, 0x00);
$NumOfSrcEl= 0x01;
@SrcEl= (0x00, 0xFF, 0x00, 0x84, 0x10, 0x00);
$NumOfDstnEl= 0x01;
@DstnEl= (0x08, 0x10, 0x00, 0x01, 0x01);
$Rsvd= 0x00;
@message= (@ADRDSTN,@ADRSRC,$MID,$MDLH,$MDLL,$SUBMID,@CHreq,@Pity,@Fla
+gs,@Timeout,@Level,$NumOfSrcEl,@SrcEl,$NumOfDstnEl,@DstnEl,$Rsvd);
$EM= 0xFD;


my $count=0;
$count += $message[$_] for 0..@message-1 ;
$count = 256 - ($count % 256);
$CHECKSUM=$count;
my @VPAP=($SM,@message,$CHECKSUM,$EM);

my $sock = new IO::Socket::INET (
                                        PeerAddr => 'localhost',
                                        PeerPort => '7070',
                                        Proto => 'tcp',
                                );
die "Could not create socket: $!\n" unless $sock;

print $sock @VPAP; 
close($sock);


[download]

I think there's a misunderstanding here. When you write the number 0xFF or 255 (which is really the same), you probably want the byte with the number 255 to be written. If that's the case, you need chr or pack (see perlpacktut), not a string representation.

Perl 6 - the future is here, just unevenly distributed

Try this, and when it works, think about why it works:

#!/usr/bin/perl
use warnings;
use strict;
use IO::Socket;


my $SM = "\xfe";
my $ADRDSTN= "\x00\x09\x01\x00";
my $ADRSRC= "\x00\x08\x01\x00";
my $MID= "\x01";
my $MDLH= "\x00";
my $MDLL= "\x18";
my $SUBMID= "\x00";
my $CHreq= "\x00\x61";
my $Pity= "\xFF\x05";
my $Flags= "\x00\x20";
my $Timeout= "\x00\x00");
my $Level= "\x00\x00";
my $NumOfSrcEl= "\x01";
my $SrcEl= "\x00\xFF\x00\x84\x10\x00";
my $NumOfDstnEl= "\x01";
my $DstnEl= "\x08\x10\x00\x01\x01";
my $Rsvd= "\x00";
my $message= $ADRDSTN . $ADRSRC . $MID .$MDLH . $MDLL
           . $SUBMID . $CHreq . $Pity .$Flags . $Timeout
           . $Level . $NumOfSrcEl . $SrcEl . $NumOfDstnEl
           . $DstnEl . $Rsvd;
my $EM= "\xFD";


my $count=0;
$count += $message[$_] for 0..@message-1 ;
$count = 256 - ($count % 256);
$CHECKSUM= chr( $count );
my $VPAP= $SM . $message . $CHECKSUM . $EM;

my $sock = new IO::Socket::INET(
    PeerAddr => 'localhost',
    PeerPort => '7070',
    Proto => 'tcp',
) or die "Could not create socket: $!\n";

print $sock $@VPAP; 
close($sock);

[download]

---

With the rise and rise of 'Social' network sites: 'Computers are making people easier to use everyday'

Examine what is said, not who speaks -- Silence betokens consent -- Love the truth but pardon error.

"Science is about questioning the status quo. Questioning authority".

In the absence of evidence, opinion is indistinguishable from prejudice.

Thanks for the help but when I run the code, it cannot calculate addition of members of @message

Argument "\0^I^A\0\0^H^A\0^A\0^X\0\0aM-^?^E\0 \0\0\0\0^A\0M-^?\0M-^D..
+." isn't numeric in addition (+) at VPAP_test.pl line 32.
Wide character in print at VPAP_test.pl line 37.
þ1Äý

[download]

To be able to run it, I fixed some errors

#!/usr/bin/perl
use warnings;
use strict;
use IO::Socket;


my $SM = "\xfe";
my $ADRDSTN= "\x00\x09\x01\x00";
my $ADRSRC= "\x00\x08\x01\x00";
my $MID= "\x01";
my $MDLH= "\x00";
my $MDLL= "\x18";
my $SUBMID= "\x00";
my $CHreq= "\x00\x61";
my $Pity= "\xFF\x05";
my $Flags= "\x00\x20";
my $Timeout= "\x00\x00";
my $Level= "\x00\x00";
my $NumOfSrcEl= "\x01";
my $SrcEl= "\x00\xFF\x00\x84\x10\x00";
my $NumOfDstnEl= "\x01";
my $DstnEl= "\x08\x10\x00\x01\x01";
my $Rsvd= "\x00";
my @message= $ADRDSTN . $ADRSRC . $MID .$MDLH . $MDLL
           . $SUBMID . $CHreq . $Pity .$Flags . $Timeout
           . $Level . $NumOfSrcEl . $SrcEl . $NumOfDstnEl
           . $DstnEl . $Rsvd;
my $EM= "\xfd";


my $count=0;
$count += $message[$_] for 0..@message-1 ;
$count = 256 - ($count % 256);
my $CHECKSUM= chr( $count );
my @VPAP= $SM . @message . $CHECKSUM . $EM;

print  @VPAP,"\n";
[download]

This works, but it will give you a slight performance hit. Unless you're doing serious number crunching it'll probably be acceptable...

use strict;
use warnings;

sub hexnum {
    package HexNum;
    use base 'Math::BigInt';
    use overload q[""] => 'as_hex';
    __PACKAGE__->new(@_);
}

my $var = hexnum 0x2F;
$var += 3;
$var += hexnum 0x02;

print "$var\n";
[download]

Wow, that is cool. Btw, is there a way to ignore 0x prefix without substr, or anything ?

use strict;
use warnings;

sub hexnum {
    package HexNum;
    use base 'Math::BigInt';
    use overload q[""] => 'as_hex_without_0x';
    __PACKAGE__->new(@_);
}

sub HexNum::as_hex_without_0x {
    substr($_[0]->as_hex, 2);
}

my $var = hexnum 0x2F;
$var += 3;
$var += hexnum 0x02;

print "$var\n";
[download]

perl -E'sub Monkey::do{say$_,for@_,do{($monkey=[caller(0)]->[3])=~s{::}{ }and$monkey}}"Monkey say"->Monkey::do'

Here's a cut-down example of a pack approach to building a socket message. I leave you to fiddle with the checksum until it comes out right; I can never seem to get this sort of thing first-try.

>perl -wMstrict -le
"my $SM      = 0xfe;
 my @ADRDSTN = (0x00, 0x09, 0x01, 0x00);
 my $MID     = 0x01;
 my $MDLH    = 0x00;
 my $MDLL    = 0x18;
 my $EM      = 0xFD;
 ;;
 my @message = (@ADRDSTN, $MID, $MDLH, $MDLL);
 ;;
 my $packed_message = pack 'C*', @message;
 ;;
 my $checksum = 256 - unpack '%8C*', $packed_message;
 ;;
 my $msg_for_socket = pack 'C a* C C', $SM, $packed_message, $checksum
+, $EM;
 ;;
 my $msg_for_debug = unpack 'H*', $msg_for_socket;
 print qq{'$msg_for_debug'};
"
'fe00090100010018ddfd'
[download]

Thank you for your message but I'll continue with the methods above for now