Можно ли загружать и запускать код из EEPROM во время загрузки?

У меня возникли проблемы при написании пользовательского загрузчика, так что он загружает код из EEPROM (на данный момент внутренний, поскольку у меня нет внешней памяти в моих руках) и записывает во флэш-память. После ~ 2 недель борьбы я столкнулся с этими вопросами и ответами. После этого я понял, что совершил ошибку, не проверив возможность этого. Тем не менее, я все еще в замешательстве по поводу нескольких вещей:

1. Если Гарвардская архитектура ограничивает то, что я хочу, почему optiboot может прошивать память из входящих данных UART, которые даже не являются памятью?

2. Если UART считывает и прошивает память соответствующим образом, не могу ли я сделать то же самое с EEPROM? Считывание байтов, стирание флэш-памяти, запись байтов.

3. Если это невозможно, учитывая два ответа в приведенной выше ссылке, то как это работает? Я предполагаю, что это та же логика, что и я, используя внешнюю память и перезаписывая flash. Означает ли это, что Гарвардская архитектура ограничивает только обмен внутренней памятью?

ОБНОВЛЕНИЕ: Вот что я сделал на данный момент:

В отдельном скетче EEPROM заполняется двоичным кодом. Загрузчик (отредактированный optiboot v8):

  // Настройка сторожевого таймера для запуска после желаемого тайм-аута
  watchdogConfig(WDTPERIOD);
#if BIGBOOT

  if ((eeprom_read(0x000) == 0x0C) && (eeprom_read(0x001) == 0x94))
  {
    //while (EECR & (1 << EEPE)); //подождите, если предыдущие данные все еще записываются
    uint8_t i, j;

    for (i = 0; i < 8; ++i) // всего 8 страниц
    {
      uint8_t *code;
      code = buff.bptr;
      address.word = (i * 128);

      for (j = 0; j < 128; ++j)  // 128 слов за раз
      {     
        if (j % 64 == 0)     
          LED_PORT ^= _BV(LED);

        *code++ = eeprom_read(address.word + j);
      }

#ifdef VIRTUAL_BOOT_PARTITION
      virtualBootPartition(buff, address);
#endif 

      writebuffer(0x46, buff, address, 128);
    }

    while(1); // дождитесь WDT
  }
#endif


#if (LED_START_FLASHES > 0) || LED_DATA_FLASH || LED_START_ON
  /* Set LED pin as output */
  LED_DDR |= _BV(LED);
#endif

в то время как моя функция выглядит следующим образом:

#if BIGBOOT 
static uint8_t eeprom_read(uint16_t addr)
{
  EEAR = addr; //считывать с этого адреса
  EECR |= (1 << EERE); //включить чтение

  return EEDR;
}
#endif

Я использую make atmega328 BIGBOOT=1 для создания шестнадцатеричного файла. Это не работает + загрузка UART также завершается неудачей. Если я установлю для BIGBOOT значение 0 и сгенерирую, загрузка UART будет работать нормально.

P.S. virtualBootPartition - это функция, которая вызывается в случае STK_PROG_PAGE. Чтобы не повторять один и тот же фрагмент кода, я собрал эту часть в функцию.

#ifdef VIRTUAL_BOOT_PARTITION
/*
 * Как работает виртуальный загрузочный раздел:
 * В начале обычной программы AVR находится набор векторов, которые
 * реализовать механизм прерывания.  Каждый вектор обычно представляет собой один
 * инструкция, которая отправляется в соответствующий ISR.
 * Инструкция обычно представляет собой rjmp (на AVR с 8k или менее флэш-памяти)
 * или jmp-инструкция, и 0-й вектор выполняется при сбросе и переходит
 * к запуску пользовательской программы:
 * векторы: запуск jmp
 * jmp ISR1
 * jmp ISR2
 * : ;; и т.д
 * jmp lastvector
 * Для реализации "Виртуального загрузочного раздела" Optiboot определяет, когда
программируется страница * flash, содержащая векторы, и заменяет
вектор * startup переходом к началу Optiboot.  Тогда это спасает
 * вектор запуска приложения в другом (должен быть неиспользуем приложением
*) и, наконец, программирует страницу с измененными векторами.
 * После этого, при сбросе, вектор будет отправлен в начало
 * Optiboot.  Когда Optiboot решит, что он запустит пользовательское приложение,
 * он извлекает сохраненный начальный адрес из неиспользуемого вектора и переходит
 * там.
 * Логика зависит от размера flash и от того, находится ли вектор сброса
* на той же странице flash, что и сохраненный начальный адрес.
 */

#if FLASHEND > 8192
/*
 * AVR с 4-байтовыми векторами ISR и "jmp"
 * ПРЕДУПРЕЖДЕНИЕ: это работает только до 128 КБ флэш-памяти!
 */
#if FLASHEND > (128*1024)
#error "Can't use VIRTUAL_BOOT_PARTITION with more than 128k of Flash"
#endif
  if (address.word == RSTVEC_ADDRESS) {
    // Это страница сброса вектора. Нам нужно обновить код
    //, чтобы загрузчик запускался первым.
    //
    // Сохранить цели jmp (для "Проверки")
    rstVect0_sav = buff.bptr[rstVect0];
    rstVect1_sav = buff.bptr[rstVect1];

        // Добавить "перейти к Optiboot" при СБРОСЕ вектора
        // ПРЕДУПРЕЖДЕНИЕ: это работает до тех пор, пока "main" находится в первом разделе
    buff.bptr[rstVect0] = ((uint16_t)pre_main) & 0xFF;
    buff.bptr[rstVect1] = ((uint16_t)pre_main) >> 8;

#if (SAVVEC_ADDRESS != RSTVEC_ADDRESS)
// save_vector необязательно находится на той же флэш-странице, что и сброс
// вектор.  Если это не так, то мы ждем, чтобы действительно написать это.
  } 
  else if (address.word == SAVVEC_ADDRESS) {
      // Сохранить старые значения для проверки
      saveVect0_sav = buff.bptr[saveVect0 - SAVVEC_ADDRESS];
      saveVect1_sav = buff.bptr[saveVect1 - SAVVEC_ADDRESS];

      // Переместить цель СБРОСА jmp в вектор "сохранения"
      buff.bptr[saveVect0 - SAVVEC_ADDRESS] = rstVect0_sav;
      buff.bptr[saveVect1 - SAVVEC_ADDRESS] = rstVect1_sav;
  }
#else 
        // Сохранить старые значения для проверки
        saveVect0_sav = buff.bptr[saveVect0];
    saveVect1_sav = buff.bptr[saveVect1];

        // Переместить цель СБРОСА jmp в вектор "сохранения"
        buff.bptr[saveVect0] = rstVect0_sav;
        buff.bptr[saveVect1] = rstVect1_sav;
}
#endif

#else
/*
 * AVR with 2-byte ISR Vectors and rjmp
 */
  if (address.word == rstVect0) {
    // Это страница сброса вектора. Нам нужно жить-исправлять
    // код, чтобы загрузчик запускался первым.
    //
    // Переместить вектор СБРОСА в вектор "сохранения"
      // Сохранить цели jmp (для "Проверки")
    rstVect0_sav = buff.bptr[rstVect0];
    rstVect1_sav = buff.bptr[rstVect1];
    addr16_t vect;
    vect.word = ((uint16_t)pre_main-1);
    // Инструкция - это относительный переход (rjmp), поэтому пересчитайте.
    // инструкция RJMP равна 0b1100xxxx xxxxxxxx, поэтому мы должны иметь возможность
    // выполнять математические вычисления для смещений, не маскируя их сначала.
    // Обратите внимание, что rjmp относится к уже увеличенному ПК, поэтому смещение
    // на единицу меньше, чем вы могли бы ожидать.
    buff.bptr[0] = vect.bytes[0]; // rjmp для запуска загрузчика
    buff.bptr[1] = vect.bytes[1] | 0xC0;  // создать "rjmp"
#if (SAVVEC_ADDRESS != RSTVEC_ADDRESS)
  } 
  else if (address.word == SAVVEC_ADDRESS) {
    addr16_t vect;
    vect.bytes[0] = rstVect0_sav;
    vect.bytes[1] = rstVect1_sav;
    // Сохранить старые значения для проверки
    saveVect0_sav = buff.bptr[saveVect0 - SAVVEC_ADDRESS];
    saveVect1_sav = buff.bptr[saveVect1 - SAVVEC_ADDRESS];

    vect.word = (vect.word-save_vect_num); //вычтите позицию прерывания 'save'
  // Переместить цель СБРОСА jmp в вектор "сохранения"
  buff.bptr[saveVect0 - SAVVEC_ADDRESS] = vect.bytes[0];
  buff.bptr[saveVect1 - SAVVEC_ADDRESS] = (vect.bytes[1] & 0x0F)| 0xC0;  // создать "rjmp"
  }
#else

  // Сохранить старые значения для проверки
  saveVect0_sav = buff.bptr[saveVect0];
  saveVect1_sav = buff.bptr[saveVect1];

  vect.bytes[0] = rstVect0_sav;
  vect.bytes[1] = rstVect1_sav;
  vect.word = (vect.word-save_vect_num); //вычтите позицию прерывания 'save'
  // Переместить цель СБРОСА jmp в вектор "сохранения"
  buff.bptr[saveVect0] = vect.bytes[0];
  buff.bptr[saveVect1] = (vect.bytes[1] & 0x0F)| 0xC0;  // создать "rjmp"
  // Добавьте rjmp в загрузчик при СБРОСЕ вектора
  vect.word = ((uint16_t)pre_main-1); // (main) всегда <= 0x0FFF; маскировка не требуется.
  buff.bptr[0] = vect.bytes[0]; // инструкция rjmp 0x1c00
}
  
#endif
#endif // ПРОШИВКА
#endif // VBP