Welcome to the monastery.

What do you expect the line @marcos=<,$protein>; to do? Perl will read that as a glob, but is fixed content, so it equivalent to @marcos=",$protein";, which will always yield a single value. If I run your code with $DNA equal to AGAAGAAGA, I get the output

La secuencia 0 es: ,RRR

La secuencia 1 es: ,RRREExx

La secuencia 2 es: ,RRREExxKKx
[download]

La secuencia 0 es: RRR

La secuencia 1 es: EExx

La secuencia 2 es: KKx
[download]

use strict;
use warnings;

chomp(my $DNA = <>);

my %acid_map = (
    TTT => 'F',
    TTC => 'F',
    GGT => 'G',
    GGC => 'G',
    GGA => 'G',
    GGG => 'G',
    GCT => 'A',
    GCC => 'A',
    GCA => 'A',
    GCG => 'A',
    TTA => 'L',
    TTG => 'L',
    CTT => 'L',
    CTC => 'L',
    CTG => 'L',
    CTA => 'L',
    GTT => 'V',
    GTC => 'V',
    GTA => 'V',
    GTG => 'V',
    ATT => 'I',
    ATC => 'I',
    ATA => 'I',
    CCT => 'P',
    CCC => 'P',
    CCA => 'P',
    CCG => 'P',
    TCT => 'S',
    TCC => 'S',
    TCA => 'S',
    TCG => 'S',
    ACT => 'T',
    ACC => 'T',
    ACA => 'T',
    ACG => 'T',
    TGT => 'C',
    TGC => 'C',
    TAT => 'Y',
    TAC => 'Y',
    AAT => 'N',
    AAC => 'N',
    CAA => 'Q',
    CAG => 'Q',
    GAT => 'D',
    GAC => 'D',
    GAA => 'E',
    GAG => 'E',
    CGT => 'R',
    CGC => 'R',
    CGA => 'R',
    CGG => 'R',
    AGA => 'R',
    AGG => 'R',
    AAA => 'K',
    AAG => 'K',
    CAT => 'H',
    CAC => 'H',
    TGG => 'W',
    TGA => 'W',
    ATG => 'M',
    TAA => '8',
    TAG => '8',
);

foreach my $c (0 .. 2){
    my $protein = '';
    my $position=$c;
    while ($position < length $DNA) {
        my $codon=substr($DNA, $position, 3);
        if ($acid_map{$codon}) {
            $position += 3;
            $protein .= $acid_map{$codon};
        } else {
            $position++;
            $protein .= 'x';
        }
    }
    print "La secuencia $c es: $protein\n\n";
}
[download]

1. I added strict and warnings; see Use strict warnings and diagnostics or die for some reasons why

2. Instead of a long list of if-elsif-elses, I've used a hash. It makes the algorithm more immediately legible and will run faster (O(N) vs. O(N^2) for the original).

3. I used a foreach loop instead of a C-style for loop for $c since you have a fixed series of numbers, and thus no need for complex logic.

4. I swapped the inner loop to a while loop, since you have variable strides. I also used the opportunity to centralize the strides, so that $position is only changed once per iteration, hopefully improving clarity of intent.

5. I swapped to compound assignment operators (Assignment Operators) since you always had duplicate variables. Less typing means fewer opportunities for typos, and again makes reading the code more obvious.

6. Since you were already using interpolating quotes (Quote and Quote like Operators), I removed the unnecessary splits into a list for your output. I also removed the no-op associated with the glob.

7. Lastly, I removed the loop from around your print. You could also express this as a push to an array scoped outside the foreach loop, and then printing outside the loop.

I had to do some translation from DNA/RNA to amino acids and grabbed this codon table. I found, however, that there are a couple missing amino acids and one or two mistakes. Just want to drop a fixed version here in case people come looking in the future:

my %codon_table = (
    AAA => 'K',
    AAC => 'N',
    AAG => 'K',
    AAT => 'N',
    ACA => 'T',
    ACC => 'T',
    ACG => 'T',
    ACT => 'T',
    AGA => 'R',
    AGC => 'S',
    AGG => 'R',
    AGT => 'S',
    ATA => 'I',
    ATC => 'I',
    ATG => 'M',
    ATT => 'I',
    CAA => 'Q',
    CAC => 'H',
    CAG => 'Q',
    CAT => 'H',
    CCA => 'P',
    CCC => 'P',
    CCG => 'P',
    CCT => 'P',
    CGA => 'R',
    CGC => 'R',
    CGG => 'R',
    CGT => 'R',
    CTA => 'L',
    CTC => 'L',
    CTG => 'L',
    CTT => 'L',
    GAA => 'E',
    GAC => 'D',
    GAG => 'E',
    GAT => 'D',
    GCA => 'A',
    GCC => 'A',
    GCG => 'A',
    GCT => 'A',
    GGA => 'G',
    GGC => 'G',
    GGG => 'G',
    GGT => 'G',
    GTA => 'V',
    GTC => 'V',
    GTG => 'V',
    GTT => 'V',
    TAA => '-',
    TAC => 'Y',
    TAG => '-',
    TAT => 'Y',
    TCA => 'S',
    TCC => 'S',
    TCG => 'S',
    TCT => 'S',
    TGA => '-',
    TGC => 'C',
    TGG => 'W',
    TGT => 'C',
    TTA => 'L',
    TTC => 'F',
    TTG => 'L',
    TTT => 'F',
);
[download]

EDIT: Here is one I made that I like more. It is structured like you normally see codon tables in books.

my %codon_table = (
    TTT => 'F', TCT => 'S', TAT => 'Y', TGT => 'C',
    TTC => 'F', TCC => 'S', TAC => 'Y', TGC => 'C',
    TTA => 'L', TCA => 'S', TAA => '-', TGA => '-',
    TTG => 'L', TCG => 'S', TAG => '-', TGG => 'W',
    CTT => 'L', CCT => 'P', CAT => 'H', CGT => 'R',
    CTC => 'L', CCC => 'P', CAC => 'H', CGC => 'R',
    CTA => 'L', CCA => 'P', CAA => 'Q', CGA => 'R',
    CTG => 'L', CCG => 'P', CAG => 'Q', CGG => 'R',
    ATT => 'I', ACT => 'T', AAT => 'N', AGT => 'S',
    ATC => 'I', ACC => 'T', AAC => 'N', AGC => 'S',
    ATA => 'I', ACA => 'T', AAA => 'K', AGA => 'R',
    ATG => 'M', ACG => 'T', AAG => 'K', AGG => 'R',
    GTT => 'V', GCT => 'A', GAT => 'D', GGT => 'G',
    GTC => 'V', GCC => 'A', GAC => 'D', GGC => 'G',
    GTA => 'V', GCA => 'A', GAA => 'E', GGA => 'G',
    GTG => 'V', GCG => 'A', GAG => 'E', GGG => 'G',
);
[download]

Edit: Looks like kennethk also rewrote your code in almost the same way as I was adding my last part, so it must be the right way to do it! :P

Edit2: kennethk pointed out to me that my code is incrementing by three positions when there is an unknown codon, but yours only increments by one position. Is this by design? It seems to me like you would want to move on to the next codon regardless of there being a match or mismatch.

First, your code would be much more simple if you had your codon table in a hash and just looked up the codon in the hash to get the amino acid. Before you entered the loop, you would define the table:

my %codon_table = (
    'TTT' => 'F', 
    'TTC' => 'F', 
    'TTA' => 'L', 
    'TTG' => 'L', 
    'CTT' => 'L', 
    'CTC' => 'L', 
    'CTA' => 'L', 
    'CTG' => 'L', 
    # AND SO ON
);
[download]

Second, I'm not really familiar with this usage:

I think what you want instead of this line is:

Then if you move your last little loop outside of the main loop, I think it should behave the way you expect. Here is a simplified version of that last loop:

Third, I suspect that you aren't using use strict; use warnings;... Use these!

I've combined all of these suggestions and made a few more changes to rewrite your code as:

my %codon_table = (
    'TTT' => 'F',
    'TTC' => 'F',
    'TTA' => 'L',
    'TTG' => 'L',
    'CTT' => 'L',
    'CTC' => 'L',
    'CTA' => 'L',
    'CTG' => 'L',
    # AND SO ON
);

my @marcos;
for my $reading_frame ( 0 .. 2 ) {
    my $position = $reading_frame;
    while ( $position < length($DNA) - 2 ) {
        my $codon = substr( $DNA, $position, 3 );
        my $amino_acid = $codon_table{$codon};
        if ( defined $amino_acid ) {
            $protein  = $protein . $amino_acid;
        }
        else {
            $protein .= "x";
        }
        $position += 3;
    }
    push @marcos, $protein;
}
print "La secuencia $reading_frame es: $_\n\n" for @marcos;
[download]