AVR Freaks

Your code is a little hard to follow, not helped out by the formatting, your use of magic numbers, and e.g. using for in place of while.

I've cleaned it up a bit, and added some comments:

#define F_CPU 1843200UL
#define BAUD 115200UL
#define MYUBRR ((F_CPU/(8*BAUD))-1)
#include <avr/io.h>
#include <util/delay.h>

int main(void)
{

  UBRR0H = (unsigned char)(MYUBRR >> 8);
  UBRR0L = (unsigned char)MYUBRR;
  UCSR0A = (1 << U2X0);
  UCSR0B = (1 << RXEN0) | (1 << TXEN0);

  while (1)
  {

    // When one or more bytes have been received.
    if (UCSR0A & (1 << RXC0))
    {

      char table[10];
      int8_t iii = 0;

      // Receive all bytes.
      while (UCSR0A & (1 << RXC0))
      {
        // Fill table in order with received bytes.
        table[iii] = UDR0;
        // Give another byte the chance to come in.
        _delay_us(150);
        // If there's another byte, prepare for it.
        if (UCSR0A & (1 << RXC0))
        {
          iii++;
        }
      }

      // Toggle PA3 <-- where do you make this an output?
      PORTA ^= 0x08;

      // Push out table[] in reverse order.
      for (int8_t kkk = iii; kkk >= 0; kkk--)
      {
        // Wait for room in TX.
        while ( !(UCSR0A & (1 << UDRE0)) );
        UDR0  = table[kkk];
      }

    }

  }

}

I see what you're doing, and it could work, but it's brittle (as you have found).

You are waiting 150 us for another byte, and if it doesn't show up then you consider the burst of bytes from the sender to have completed, after which you retransmit that burst in reverse order.

Here's where the trouble lies.  An 8-bit serial byte takes 10 serial bits to transfer (start + 8 + stop).  At 115200 baud, that will take 86.8 microseconds.

The RX hardware in the USART has a 2-deep buffer, plus the incoming shift register, for a total of three bytes.  So while you're waiting 150 us, nearly two full new bytes may have come in (about 14 of the 16 bits).  That's fine (at first), since the RX buffer + shift register can hold nearly three bytes.

Then you read the second byte, leaving not quite one unread byte in the shift register (about 6 bits), but then you wait another 150 us during which another 14 bits come in, with the buffer + shift register now totalling 20 bits.

See the pattern?  You're falling behind with every read and every delay of 150 us.  Eventually, and after not very many turns, the hardware buffer will overflow and you will lose incoming bytes.

You need to implement a timeout, not a delay.  There are lots of ways to do this.  One is to set up a hardware timer.  Then, in the loop in which you wait for an incoming byte, you also check for the timer to expire.  In this way you can respond immediately to an incoming byte instead of waiting a fixed amount of time during which new bytes might still be filling up the hardware buffer.

Another flaw in your code is that you don't do bounds checking on table[].  What happens if a burst of more than 10 bytes comes it?

I'm with east coast jim on this, use a ring buffer RX interrupt, where you store the char in a ring buffer, and reset a timer.

When the timer times out, your burst has ended, and then send the buffer contents out in reverse order.

Jim