perluniintro shows a function nice_string() which essentially does what you want (i.e. render special characters as \x... escapes), and can easily be adapted to your likings.  For example, here in slightly modified form:

#!/usr/local/bin/perl -l

sub nice_string {
    join(" ",
      map { $_ > 255 ?                  # if wide character...
            sprintf("\\x{%04X}", $_) :  # \x{...}
            chr($_) =~ /[[:cntrl:]]/ ?  # else if control character ..
+.
            sprintf("\\x%02X", $_) :    # \x..
            chr($_)                     # else as themselves
      } unpack("U*", $_[0]));           # unpack Unicode characters
}

my $var = "Some random text.\nMore\nEven More\n";
print nice_string($var);

__END__
S o m e   r a n d o m   t e x t . \x0A M o r e \x0A E v e n   M o r e 
+\x0A
[download]

(It expects a decoded character string.)

# With LF<->CRLF conversion
open(my $fh, '<:raw:perlio:encoding(UTF-16le):crlf', $fn)
[download]

# Without LF<->CRLF conversion
open(my $fh, '<:raw:perlio:encoding(UTF-16le)', $fn)
[download]

Just out of curiosity, I tried the Linux od utility and the ppt od utility. I created a file called "text":

Some random text.\nMore\nEven More\n
[download]

Then for the Linux utility:

od -N 36 -c /root/Desktop/text
[download]

Then for the ppt version of od:

/usr/local/ppt/bin/od -c /root/Desktop/text
[download]

The Linux od let me control the number of bytes that were dumped; however, with the ppt od, there is no -N option.

(: https://rt.cpan.org/Public/Dist/Display.html?Name=ppt :)

Thanks for all the help everyone! With this od utility and a better regex I was able to cobble together a solution. Sorry I only have 4 votes to give ;)

use warnings;
use strict;

my $var = "Some random text.\nMore\nEven More\n";
print process_text($var),"\n";

sub process_text {
    my $input = shift;

    # Get a space between each char
    my @text = split //,$input;
    local $" = ' ';
    my $text = "@text";
    
    # Table of special characters
    my %trans = ("\n" => '\n',
                 "\t" => '\t',
                 "\b" => '\b',
                 "\r" => '\r',
                 "\f" => '\f');

    my $pattern = join ('|', keys %trans);
    
    # substitute special characters
    $text =~ s/($pattern)/$trans{$1}/g;
    return $text;
}
[download]

S o m e   r a n d o m   t e x t . \n M o r e \n E v e n   M o r e \n
[download]

In Perl regex'es the \s stands for any whitespace character (space,\n,\r,\f,\t). \s* would mean zero or more of these and \s+ would mean at least one of these and possibly more of them. \s is an easy "short hand" for any of these "non-printable" space characters.

It could very well be that as other posters have suggested that the problem lies with 16 bit vs 8 bit chars. But then again, perhaps not if the issue is just "blank space" characters vs some other character.

Consider the following code. Common function names are: isprint() or isprintable() for a yes/no value. Below my sub get_printable() always returns something.

#!/usr/bin/perl -w
use strict;

my $var = "Some random text.\n\tMore\n\tEven More.\n\r\t  And yet More
+.";

print "VAR is:$var\n";

print "Output of loop:\n";
foreach my $char (split//,$var)
{
   print get_printable($char);
}
print "\n";

sub get_printable
{
   my $char = shift;
   return $char if ($char =~ tr/A-Za-z0-9. //);
   return sprintf ("[hex%.2X]",ord($char));
}

__END__
Prints:
VAR is:Some random text.
    More
    Even More.

      And yet More.
Output of loop:
Some random text.[hex0A][hex09]More[hex0A][hex09]Even More.[hex0A][hex
+0D][hex09]  And yet More.
[download]