diff --git a/src/eeprom_common.cpp b/src/eeprom_common.cpp
index 5f4d1cda6..33380a321 100644
--- a/src/eeprom_common.cpp
+++ b/src/eeprom_common.cpp
@@ -49,20 +49,11 @@ void eeDirty(uint8_t msk)
 }
 
 #if defined(CPUARM)
-
-char modelNames[MAX_MODELS][sizeof(g_model.name)];
-
-#if defined(PXX)
-uint8_t modelIds[MAX_MODELS];
-#endif
-
-void eeLoadModelNames()
+ModelHeader modelHeaders[MAX_MODELS];
+void eeLoadModelHeaders()
 {
   for (uint32_t i=0; i<MAX_MODELS; i++) {
-    eeLoadModelName(i, modelNames[i]);
-#if defined(PXX)
-    modelIds[i] = eeLoadModelId(i);
-#endif
+    eeLoadModelHeader(i, &modelHeaders[i]);
   }
 }
 #endif
diff --git a/src/eeprom_common.h b/src/eeprom_common.h
index e6b82ae03..2658d096a 100644
--- a/src/eeprom_common.h
+++ b/src/eeprom_common.h
@@ -57,16 +57,9 @@ void eeLoadModelName(uint8_t id, char *name);
 void eeLoadModel(uint8_t id);
 
 #if defined(CPUARM)
-
-extern char modelNames[MAX_MODELS][sizeof(g_model.name)];
-void eeLoadModelNames();
-
-#if defined(PXX)
-extern uint8_t modelIds[MAX_MODELS];
-#endif
-
-#else // defined(CPUARM)
-
-#define eeLoadModelNames()
-
+  extern ModelHeader modelHeaders[MAX_MODELS];
+  void eeLoadModelHeader(uint8_t id, ModelHeader *header);
+  void eeLoadModelHeaders();
+#else
+  #define eeLoadModelHeaders()
 #endif
diff --git a/src/eeprom_conversions.cpp b/src/eeprom_conversions.cpp
index a73413a20..3e3e23004 100644
--- a/src/eeprom_conversions.cpp
+++ b/src/eeprom_conversions.cpp
@@ -155,7 +155,7 @@ bool eeConvert()
         }
         read32_eeprom_data((File_system[id+1].block_no << 12) + sizeof(struct t_eeprom_header), (uint8_t *)&oldModel, size);
 
-        memcpy(g_model.name, oldModel.name, 10);
+        memcpy(g_model.header.name, oldModel.name, 10);
         for (uint8_t i=0; i<2; i++) {
           g_model.timers[i].mode = oldModel.timers[i].mode;
           g_model.timers[i].start = oldModel.timers[i].val;
@@ -220,7 +220,7 @@ bool eeConvert()
         }
         g_model.ppmFrameLength = oldModel.ppmFrameLength;
         g_model.thrTraceSrc = oldModel.thrTraceSrc;
-        g_model.modelId = oldModel.modelId;
+        g_model.header.modelId = oldModel.modelId;
         g_model.switchWarningStates = oldModel.switchWarningStates;
         g_model.frsky.usrProto = oldModel.frsky.usrProto;
         g_model.frsky.voltsSource = oldModel.frsky.voltsSource;
diff --git a/src/eeprom_raw.cpp b/src/eeprom_raw.cpp
index 28b90d921..06365a7a9 100644
--- a/src/eeprom_raw.cpp
+++ b/src/eeprom_raw.cpp
@@ -105,7 +105,7 @@ void eeDeleteModel(uint8_t id)
 {
   eeCheck(true);
 
-  memset(modelNames[id], 0, sizeof(g_model.name));
+  memset(modelHeaders[id].name, 0, sizeof(g_model.header.name));
 
   Eeprom32_source_address = (uint8_t *)&g_model ;   // Get data from here
   Eeprom32_data_size = 0 ;                          // This much
@@ -121,10 +121,10 @@ bool eeCopyModel(uint8_t dst, uint8_t src)
   uint16_t size = File_system[src+1].size ;
   read32_eeprom_data( (File_system[src+1].block_no << 12) + sizeof( struct t_eeprom_header), ( uint8_t *)&Eeprom_buffer.data.model_data, size) ;
 
-  if (size > sizeof(g_model.name))
-    memcpy(modelNames[dst], Eeprom_buffer.data.model_data.name, sizeof(g_model.name));
+  if (size > sizeof(g_model.header.name))
+    memcpy(modelHeaders[dst].name, Eeprom_buffer.data.model_data.header.name, sizeof(g_model.header.name));
   else
-    memset(modelNames[dst], 0, sizeof(g_model.name));
+    memset(modelHeaders[dst].name, 0, sizeof(g_model.header.name));
 
   Eeprom32_source_address = (uint8_t *)&Eeprom_buffer.data.model_data;    // Get data from here
   Eeprom32_data_size = sizeof(g_model) ;                                  // This much
@@ -146,12 +146,12 @@ void eeSwapModels(uint8_t id1, uint8_t id2)
   // block_no(id1) has been shifted now, but we have the size
 
   // TODO flash saving with function above ...
-  if (id2_size > sizeof(g_model.name)) {
+  if (id2_size > sizeof(g_model.header.name)) {
     read32_eeprom_data( (id2_block_no << 12) + sizeof( struct t_eeprom_header), ( uint8_t *)&Eeprom_buffer.data.model_data, id2_size);
-    memcpy(modelNames[id1], Eeprom_buffer.data.model_data.name, sizeof(g_model.name));
+    memcpy(modelHeaders[id1].name, Eeprom_buffer.data.model_data.header.name, sizeof(g_model.header.name));
   }
   else {
-    memset(modelNames[id1], 0, sizeof(g_model.name));
+    memset(modelHeaders[id1].name, 0, sizeof(g_model.header.name));
   }
 
   Eeprom32_source_address = (uint8_t *)&Eeprom_buffer.data.model_data;    // Get data from here
@@ -427,26 +427,25 @@ bool eeModelExists(uint8_t id)
 
 void eeLoadModelName(uint8_t id, char *name)
 {
-  memclear(name, sizeof(g_model.name));
+  memclear(name, sizeof(g_model.header.name));
   if (id < MAX_MODELS) {
     id += 1;
-    if (File_system[id].size > sizeof(g_model.name) ) {
-      read32_eeprom_data( ( File_system[id].block_no << 12) + 8, ( uint8_t *)name, sizeof(g_model.name));
+    if (File_system[id].size > sizeof(g_model.header.name) ) {
+      read32_eeprom_data((File_system[id].block_no << 12)+8, (uint8_t *)name, sizeof(g_model.header.name));
     }
   }
 }
 
-#if defined(PXX)
-uint8_t eeLoadModelId(uint8_t id)
+#if defined(CPUARM)
+void eeLoadModelHeader(uint8_t id, ModelHeader *header)
 {
-  uint8_t modelId = 0;
+  memclear(header, sizeof(ModelHeader));
   if (id < MAX_MODELS) {
     id += 1;
-    if (File_system[id].size > sizeof(g_model.name) + 1) {
-      read32_eeprom_data( ( File_system[id].block_no << 12) + 8 + sizeof(g_model.name), &modelId, 1);
+    if (File_system[id].size > sizeof(ModelHeader)) {
+      read32_eeprom_data((File_system[id].block_no << 12)+8, (uint8_t *)header, sizeof(ModelHeader));
     }
   }
-  return modelId;
 }
 #endif
 
@@ -484,7 +483,7 @@ void eeReadAll()
     STORE_MODELVARS;
   }
   else {
-    eeLoadModelNames() ;
+    eeLoadModelHeaders() ;
   }
 
   stickMode = g_eeGeneral.stickMode; // TODO common!
@@ -689,7 +688,7 @@ void ee32_process()
 #if defined(SDCARD)
 const pm_char * eeBackupModel(uint8_t i_fileSrc)
 {
-  char *buf = reusableBuffer.models.mainname;
+  char *buf = reusableBuffer.modelsel.mainname;
   FIL archiveFile;
   DIR archiveFolder;
   UINT written;
@@ -746,7 +745,7 @@ const pm_char * eeBackupModel(uint8_t i_fileSrc)
 
 const pm_char * eeRestoreModel(uint8_t i_fileDst, char *model_name)
 {
-  char *buf = reusableBuffer.models.mainname;
+  char *buf = reusableBuffer.modelsel.mainname;
   FIL restoreFile;
   UINT read;
 
@@ -795,10 +794,10 @@ const pm_char * eeRestoreModel(uint8_t i_fileDst, char *model_name)
   }
 
   // TODO flash saving ...
-  if (read > sizeof(g_model.name))
-    memcpy(modelNames[i_fileDst], Eeprom_buffer.data.model_data.name, sizeof(g_model.name));
+  if (read > sizeof(g_model.header.name))
+    memcpy(modelHeaders[i_fileDst].name, Eeprom_buffer.data.model_data.header.name, sizeof(g_model.header.name));
   else
-    memset(modelNames[i_fileDst], 0, sizeof(g_model.name));
+    memset(modelHeaders[i_fileDst].name, 0, sizeof(g_model.header.name));
 
   Eeprom32_source_address = (uint8_t *)&Eeprom_buffer.data.model_data;    // Get data from here
   Eeprom32_data_size = sizeof(g_model);                                   // This much
diff --git a/src/eeprom_raw.h b/src/eeprom_raw.h
index 6c09f3d80..0a49bef62 100644
--- a/src/eeprom_raw.h
+++ b/src/eeprom_raw.h
@@ -66,10 +66,6 @@ extern bool eeModelExists(uint8_t id) ;
 extern bool eeCopyModel(uint8_t dst, uint8_t src);
 extern void eeSwapModels(uint8_t id1, uint8_t id2);
 
-#if defined(PXX)
-uint8_t eeLoadModelId(uint8_t id);
-#endif
-
 #define DISPLAY_PROGRESS_BAR(x)
 
 struct t_file_entry
diff --git a/src/eeprom_rlc.cpp b/src/eeprom_rlc.cpp
index bcc8a0744..fbe0cc736 100644
--- a/src/eeprom_rlc.cpp
+++ b/src/eeprom_rlc.cpp
@@ -40,9 +40,12 @@
 #include "string.h"
 
 uint8_t   s_write_err = 0;    // error reasons
+RlcFile   theFile;  //used for any file operation
+EeFs      eeFs;
+#if defined(PCBTARANIS)
+blkid_t   freeBlocks = 0;
+#endif
 
-RlcFile  theFile;  //used for any file operation
-EeFs     eeFs;
 
 #if !defined(CPUARM)
 uint8_t  s_sync_write = false;
@@ -163,15 +166,15 @@ static void EeFsFlush()
 uint16_t EeFsGetFree()
 {
 #if defined(CPUARM)
-  int32_t ret = 0;
+  int32_t ret = freeBlocks * (BS-sizeof(blkid_t));
 #else
   int16_t ret = 0;
-#endif
   blkid_t i = eeFs.freeList;
   while (i) {
-    ret += BS-1;
+    ret += BS-sizeof(blkid_t);
     i = EeFsGetLink(i);
   }
+#endif
   ret += eeFs.files[FILE_TMP].size;
   ret -= eeFs.files[FILE_MODEL(g_eeGeneral.currModel)].size;
   return (ret > 0 ? ret : 0);
@@ -182,7 +185,18 @@ static void EeFsFree(blkid_t blk)
 {
   blkid_t i = blk;
   blkid_t tmp;
-  while ((tmp=EeFsGetLink(i))) i = tmp;
+
+#if defined(PCBTARANIS)
+  freeBlocks++;
+#endif
+
+  while ((tmp=EeFsGetLink(i))) {
+    i = tmp;
+#if defined(PCBTARANIS)
+    freeBlocks++;
+#endif
+  }
+
   EeFsSetLink(i, eeFs.freeList);
   eeFs.freeList = blk; //chain in front
   EeFsFlushFreelist();
@@ -192,17 +206,23 @@ int8_t EeFsck()
 {
   ENABLE_SYNC_WRITE(true);
 
-  uint8_t *bufp = reusableBuffer.eefs_buffer;
+  uint8_t *bufp = (uint8_t *)&g_model;
   memclear(bufp, BLOCKS);
   blkid_t blk ;
 
+#if defined(PCBTARANIS)
+  blkid_t blocksCount;
+#endif
   for (uint8_t i=0; i<=MAXFILES; i++) {
+#if defined(PCBTARANIS)
+    blocksCount = 0;
+#endif
     blkid_t *startP = (i==MAXFILES ? &eeFs.freeList : &eeFs.files[i].startBlk);
     blkid_t lastBlk = 0;
     blk = *startP;
     while (blk) {
       if (blk < FIRSTBLK || // bad blk index
-          blk >= BLOCKS  || // bad blk index
+          blk >= BLOCKS  || // bad blk indexchan
           bufp[blk])        // blk double usage
       {
         if (lastBlk) {
@@ -215,14 +235,25 @@ int8_t EeFsck()
         blk = 0; // abort
       }
       else {
+#if defined(PCBTARANIS)
+        blocksCount++;
+#endif
         bufp[blk] = i+1;
         lastBlk   = blk;
         blk       = EeFsGetLink(blk);
       }
     }
   }
+
+#if defined(PCBTARANIS)
+  freeBlocks = blocksCount;
+#endif
+
   for (blk=FIRSTBLK; blk<BLOCKS; blk++) {
     if (!bufp[blk]) { // unused block
+#if defined(PCBTARANIS)
+      freeBlocks++;
+#endif
       EeFsSetLink(blk, eeFs.freeList);
       eeFs.freeList = blk; // chain in front
       EeFsFlushFreelist();
@@ -248,6 +279,9 @@ void EeFsFormat()
   }
   EeFsSetLink(BLOCKS-1, 0);
   eeFs.freeList = FIRSTBLK;
+#if defined(PCBTARANIS)
+  freeBlocks = BLOCKS;
+#endif
   EeFsFlush();
 
   ENABLE_SYNC_WRITE(false);
@@ -399,6 +433,9 @@ void RlcFile::nextWriteStep()
   if (!m_currBlk && m_pos==0) {
     eeFs.files[FILE_TMP].startBlk = m_currBlk = eeFs.freeList;
     if (m_currBlk) {
+#if defined(PCBTARANIS)
+      freeBlocks--;
+#endif
       eeFs.freeList = EeFsGetLink(m_currBlk);
       m_write_step |= WRITE_FIRST_LINK;
       EeFsFlushFreelist();
@@ -427,6 +464,7 @@ void RlcFile::nextWriteStep()
         }
         m_write_step += WRITE_NEXT_LINK_1;
         EeFsSetLink(m_currBlk, eeFs.freeList);
+        // TODO not good
         return;
       }
       m_currBlk = nextBlk;
@@ -434,6 +472,9 @@ void RlcFile::nextWriteStep()
     switch (m_write_step & 0x0f) {
       case WRITE_NEXT_LINK_1:
         m_currBlk = eeFs.freeList;
+#if defined(PCBTARANIS)
+        freeBlocks--;
+#endif
         eeFs.freeList = EeFsGetLink(eeFs.freeList);
         m_write_step += 1;
         EeFsFlushFreelist();
@@ -513,7 +554,7 @@ bool RlcFile::copy(uint8_t i_fileDst, uint8_t i_fileSrc)
 extern FIL g_oLogFile;
 const pm_char * eeBackupModel(uint8_t i_fileSrc)
 {
-  char *buf = reusableBuffer.models.mainname;
+  char *buf = reusableBuffer.modelsel.mainname;
   DIR archiveFolder;
   UINT written;
 
@@ -532,9 +573,9 @@ const pm_char * eeBackupModel(uint8_t i_fileSrc)
 
   buf[sizeof(MODELS_PATH)-1] = '/';
   eeLoadModelName(i_fileSrc, &buf[sizeof(MODELS_PATH)]);
-  buf[sizeof(MODELS_PATH)+sizeof(g_model.name)] = '\0';
+  buf[sizeof(MODELS_PATH)+sizeof(g_model.header.name)] = '\0';
 
-  uint8_t i = sizeof(MODELS_PATH)+sizeof(g_model.name)-1;
+  uint8_t i = sizeof(MODELS_PATH)+sizeof(g_model.header.name)-1;
   uint8_t len = 0;
   while (i>sizeof(MODELS_PATH)-1) {
     if (!len && buf[i])
@@ -595,7 +636,7 @@ const pm_char * eeBackupModel(uint8_t i_fileSrc)
 
 const pm_char * eeRestoreModel(uint8_t i_fileDst, char *model_name)
 {
-  char *buf = reusableBuffer.models.mainname;
+  char *buf = reusableBuffer.modelsel.mainname;
   UINT read;
 
   // we must close the logs as we reuse the same FIL structure
@@ -742,9 +783,18 @@ void RlcFile::nextRlcWriteStep()
        blkid_t fri=0;
 
        if (m_currBlk && (fri=EeFsGetLink(m_currBlk))) {
+         // TODO reuse EeFsFree!!!
          blkid_t prev_freeList = eeFs.freeList;
          eeFs.freeList = fri;
-         while( EeFsGetLink(fri)) fri = EeFsGetLink(fri);
+#if defined(PCBTARANIS)
+         freeBlocks++;
+#endif
+         while( EeFsGetLink(fri)) {
+           fri = EeFsGetLink(fri);
+#if defined(PCBTARANIS)
+           freeBlocks++;
+#endif
+         }
          m_write_step = WRITE_FREE_UNUSED_BLOCKS_STEP1;
          EeFsSetLink(fri, prev_freeList);
          return;
@@ -835,20 +885,21 @@ bool eeLoadGeneral()
 
 void eeLoadModelName(uint8_t id, char *name)
 {
-  memclear(name, sizeof(g_model.name));
+  memclear(name, sizeof(g_model.header.name));
   if (id < MAX_MODELS) {
     theFile.openRlc(FILE_MODEL(id));
-    theFile.readRlc((uint8_t*)name, sizeof(g_model.name));
+    theFile.readRlc((uint8_t*)name, sizeof(g_model.header.name));
   }
 }
 
-#if defined(PXX)
-// must be called just after eeLoadModelName!
-uint8_t eeLoadModelIdAfterName()
+#if defined(CPUARM)
+void eeLoadModelHeader(uint8_t id, ModelHeader *header)
 {
-  uint8_t modelId = 0;
-  theFile.readRlc(&modelId, sizeof(modelId));
-  return modelId;
+  memclear(header, sizeof(ModelHeader));
+  if (id < MAX_MODELS) {
+    theFile.openRlc(FILE_MODEL(id));
+    theFile.readRlc((uint8_t*)header, sizeof(ModelHeader));
+  }
 }
 #endif
 
@@ -950,7 +1001,7 @@ void eeReadAll()
     theFile.writeRlc(FILE_MODEL(0), FILE_TYP_MODEL, (uint8_t*)&g_model, sizeof(g_model), true);
   }
   else {
-    eeLoadModelNames();
+    eeLoadModelHeaders();
   }
 
   stickMode = g_eeGeneral.stickMode;
@@ -985,7 +1036,7 @@ void eeCheck(bool immediately)
 bool eeCopyModel(uint8_t dst, uint8_t src)
 {
   if (theFile.copy(FILE_MODEL(dst), FILE_MODEL(src))) {
-    memcpy(modelNames[dst], modelNames[src], sizeof(g_model.name));
+    memcpy(modelHeaders[dst].name, modelHeaders[src].name, sizeof(g_model.header.name));
     return true;
   }
   else {
@@ -997,9 +1048,9 @@ void eeSwapModels(uint8_t id1, uint8_t id2)
 {
   EFile::swap(FILE_MODEL(id1), FILE_MODEL(id2));
 
-  char tmp[sizeof(g_model.name)];
-  memcpy(tmp, modelNames[id1], sizeof(g_model.name));
-  memcpy(modelNames[id1], modelNames[id2], sizeof(g_model.name));
-  memcpy(modelNames[id2], tmp, sizeof(g_model.name));
+  char tmp[sizeof(g_model.header.name)];
+  memcpy(tmp, modelHeaders[id1].name, sizeof(g_model.header.name));
+  memcpy(modelHeaders[id1].name, modelHeaders[id2].name, sizeof(g_model.header.name));
+  memcpy(modelHeaders[id2].name, tmp, sizeof(g_model.header.name));
 }
 #endif
diff --git a/src/eeprom_rlc.h b/src/eeprom_rlc.h
index a777a6df7..9299ecb9c 100644
--- a/src/eeprom_rlc.h
+++ b/src/eeprom_rlc.h
@@ -144,11 +144,6 @@ class EFile
 #define eeFileSize(f)   eeFs.files[f].size
 #define eeModelSize(id) eeFileSize(FILE_MODEL(id))
 
-#if defined(PXX)
-uint8_t eeLoadModelIdAfterName();
-#define eeLoadModelId(id) eeLoadModelIdAfterName()
-#endif
-
 #define ERR_NONE 0
 #define ERR_FULL 1
 extern uint8_t  s_write_err;    // error reasons
diff --git a/src/lcd.cpp b/src/lcd.cpp
index c21403058..52c6538d6 100644
--- a/src/lcd.cpp
+++ b/src/lcd.cpp
@@ -681,7 +681,7 @@ void lcd_invert_line(int8_t y)
 #if !defined(PCBTARANIS) // TODO test inversion
 void lcdDrawTelemetryTopBar()
 {
-  putsModelName(0, 0, g_model.name, g_eeGeneral.currModel, 0);
+  putsModelName(0, 0, g_model.header.name, g_eeGeneral.currModel, 0);
   uint8_t att = (g_vbat100mV < g_eeGeneral.vBatWarn ? BLINK : 0);
   putsVBat(14*FW,0,att);
   if (g_model.timers[0].mode) {
@@ -693,7 +693,7 @@ void lcdDrawTelemetryTopBar()
 #else
 void lcdDrawTelemetryTopBar()
 {
-  putsModelName(0, 0, g_model.name, g_eeGeneral.currModel, 0);
+  putsModelName(0, 0, g_model.header.name, g_eeGeneral.currModel, 0);
   uint8_t att = (g_vbat100mV < g_eeGeneral.vBatWarn ? BLINK : 0);
   putsVBat(16*FW+2,0,att);
   if (g_model.timers[0].mode) {
@@ -828,13 +828,13 @@ void putsChnLetter(xcoord_t x, uint8_t y, uint8_t idx, LcdFlags attr)
 
 void putsModelName(xcoord_t x, uint8_t y, char *name, uint8_t id, LcdFlags att)
 {
-  uint8_t len = sizeof(g_model.name);
+  uint8_t len = sizeof(g_model.header.name);
   while (len>0 && !name[len-1]) --len;
   if (len==0) {
     putsStrIdx(x, y, STR_MODEL, id+1, att|LEADING0);
   }
   else {
-    lcd_putsnAtt(x, y, name, sizeof(g_model.name), ZCHAR|att);
+    lcd_putsnAtt(x, y, name, sizeof(g_model.header.name), ZCHAR|att);
   }
 }
 
diff --git a/src/logs.cpp b/src/logs.cpp
index 417c96451..0e0917781 100644
--- a/src/logs.cpp
+++ b/src/logs.cpp
@@ -62,10 +62,10 @@ const pm_char * openLogs()
   }
 
   filename[sizeof(LOGS_PATH)-1] = '/';
-  memcpy(&filename[sizeof(LOGS_PATH)], g_model.name, sizeof(g_model.name));
-  filename[sizeof(LOGS_PATH)+sizeof(g_model.name)] = '\0';
+  memcpy(&filename[sizeof(LOGS_PATH)], g_model.header.name, sizeof(g_model.header.name));
+  filename[sizeof(LOGS_PATH)+sizeof(g_model.header.name)] = '\0';
 
-  uint8_t i = sizeof(LOGS_PATH)+sizeof(g_model.name)-1;
+  uint8_t i = sizeof(LOGS_PATH)+sizeof(g_model.header.name)-1;
   uint8_t len = 0;
   while (i>sizeof(LOGS_PATH)-1) {
     if (!len && filename[i])
diff --git a/src/menu_general.cpp b/src/menu_general.cpp
index bfc7e8576..9e769ce57 100644
--- a/src/menu_general.cpp
+++ b/src/menu_general.cpp
@@ -571,7 +571,7 @@ void onSdManagerMenu(const char *result)
 #endif
     if (f_mkfs(0, 1, 0) == FR_OK) {
       f_chdir("/");
-      reusableBuffer.sd.offset = -1;
+      reusableBuffer.sdmanager.offset = -1;
     }
     else {
       s_warning = STR_SDCARD_ERROR;
@@ -580,25 +580,25 @@ void onSdManagerMenu(const char *result)
   else if (result == STR_DELETE_FILE) {
     f_getcwd(lfn, SD_SCREEN_FILE_LENGTH);
     strcat_P(lfn, PSTR("/"));
-    strcat(lfn, reusableBuffer.sd.lines[index]);
+    strcat(lfn, reusableBuffer.sdmanager.lines[index]);
     f_unlink(lfn);
-    strncpy(statusLineMsg, reusableBuffer.sd.lines[index], 13);
+    strncpy(statusLineMsg, reusableBuffer.sdmanager.lines[index], 13);
     strcpy_P(statusLineMsg+min((uint8_t)strlen(statusLineMsg), (uint8_t)13), STR_REMOVED);
     showStatusLine();
-    if ((uint16_t)m_posVert == reusableBuffer.sd.count) m_posVert--;
-    reusableBuffer.sd.offset = s_pgOfs-1;
+    if ((uint16_t)m_posVert == reusableBuffer.sdmanager.count) m_posVert--;
+    reusableBuffer.sdmanager.offset = s_pgOfs-1;
   }
 #if defined(CPUARM)
   /* TODO else if (result == STR_LOAD_FILE) {
     f_getcwd(lfn, SD_SCREEN_FILE_LENGTH);
     strcat(lfn, "/");
-    strcat(lfn, reusableBuffer.sd.lines[index]);
+    strcat(lfn, reusableBuffer.sdmanager.lines[index]);
     s_warning = eeLoadModelSD(lfn);
   } */
   else if (result == STR_PLAY_FILE) {
     f_getcwd(lfn, SD_SCREEN_FILE_LENGTH);
     strcat(lfn, "/");
-    strcat(lfn, reusableBuffer.sd.lines[index]);
+    strcat(lfn, reusableBuffer.sdmanager.lines[index]);
     audioQueue.playFile(lfn, PLAY_NOW);
   }
 #endif
@@ -617,7 +617,7 @@ void menuGeneralSdManager(uint8_t event)
   char lfn[SD_SCREEN_FILE_LENGTH];
 #endif
 
-  SIMPLE_MENU(SD_IS_HC() ? STR_SDHC_CARD : STR_SD_CARD, menuTabDiag, e_Sd, 1+reusableBuffer.sd.count);
+  SIMPLE_MENU(SD_IS_HC() ? STR_SDHC_CARD : STR_SD_CARD, menuTabDiag, e_Sd, 1+reusableBuffer.sdmanager.count);
 
   if (s_editMode > 0)
     s_editMode = 0;
@@ -625,7 +625,7 @@ void menuGeneralSdManager(uint8_t event)
   switch(event) {
     case EVT_ENTRY:
       f_chdir(ROOT_PATH);
-      reusableBuffer.sd.offset = 65535;
+      reusableBuffer.sdmanager.offset = 65535;
       break;
 
 #if defined(PCBTARANIS)
@@ -638,11 +638,11 @@ void menuGeneralSdManager(uint8_t event)
     {
       if (m_posVert > 0) {
         uint8_t index = m_posVert-1-s_pgOfs;
-        if (!reusableBuffer.sd.lines[index][SD_SCREEN_FILE_LENGTH+1]) {
-          f_chdir(reusableBuffer.sd.lines[index]);
+        if (!reusableBuffer.sdmanager.lines[index][SD_SCREEN_FILE_LENGTH+1]) {
+          f_chdir(reusableBuffer.sdmanager.lines[index]);
           s_pgOfs = 0;
           m_posVert = 1;
-          reusableBuffer.sd.offset = 65535;
+          reusableBuffer.sdmanager.offset = 65535;
           break;
         }
       }
@@ -660,7 +660,7 @@ void menuGeneralSdManager(uint8_t event)
       else {
 #if defined(CPUARM)
         uint8_t index = m_posVert-1-s_pgOfs;
-        char * ext = reusableBuffer.sd.lines[index];
+        char * ext = reusableBuffer.sdmanager.lines[index];
         ext += strlen(ext) - 4;
         /* TODO if (!strcmp(ext, MODELS_EXT)) {
           s_menu[s_menu_count++] = STR_LOAD_FILE;
@@ -677,26 +677,26 @@ void menuGeneralSdManager(uint8_t event)
       break;
   }
 
-  if (reusableBuffer.sd.offset != s_pgOfs) {
+  if (reusableBuffer.sdmanager.offset != s_pgOfs) {
     if (s_pgOfs == 0) {
-      reusableBuffer.sd.offset = 0;
-      memset(reusableBuffer.sd.lines, 0, sizeof(reusableBuffer.sd.lines));
+      reusableBuffer.sdmanager.offset = 0;
+      memset(reusableBuffer.sdmanager.lines, 0, sizeof(reusableBuffer.sdmanager.lines));
     }
-    else if (s_pgOfs == reusableBuffer.sd.count-7) {
-      reusableBuffer.sd.offset = s_pgOfs;
-      memset(reusableBuffer.sd.lines, 0, sizeof(reusableBuffer.sd.lines));
+    else if (s_pgOfs == reusableBuffer.sdmanager.count-7) {
+      reusableBuffer.sdmanager.offset = s_pgOfs;
+      memset(reusableBuffer.sdmanager.lines, 0, sizeof(reusableBuffer.sdmanager.lines));
     }
-    else if (s_pgOfs > reusableBuffer.sd.offset) {
-      memmove(reusableBuffer.sd.lines[0], reusableBuffer.sd.lines[1], 6*sizeof(reusableBuffer.sd.lines[0]));
-      memset(reusableBuffer.sd.lines[6], 0xff, SD_SCREEN_FILE_LENGTH);
-      reusableBuffer.sd.lines[6][SD_SCREEN_FILE_LENGTH+1] = 1;
+    else if (s_pgOfs > reusableBuffer.sdmanager.offset) {
+      memmove(reusableBuffer.sdmanager.lines[0], reusableBuffer.sdmanager.lines[1], 6*sizeof(reusableBuffer.sdmanager.lines[0]));
+      memset(reusableBuffer.sdmanager.lines[6], 0xff, SD_SCREEN_FILE_LENGTH);
+      reusableBuffer.sdmanager.lines[6][SD_SCREEN_FILE_LENGTH+1] = 1;
     }
     else {
-      memmove(reusableBuffer.sd.lines[1], reusableBuffer.sd.lines[0], 6*sizeof(reusableBuffer.sd.lines[0]));
-      memset(reusableBuffer.sd.lines[0], 0, sizeof(reusableBuffer.sd.lines[0]));
+      memmove(reusableBuffer.sdmanager.lines[1], reusableBuffer.sdmanager.lines[0], 6*sizeof(reusableBuffer.sdmanager.lines[0]));
+      memset(reusableBuffer.sdmanager.lines[0], 0, sizeof(reusableBuffer.sdmanager.lines[0]));
     }
 
-    reusableBuffer.sd.count = 0;
+    reusableBuffer.sdmanager.count = 0;
 
     FRESULT res = f_opendir(&dir, ".");        /* Open the directory */
     if (res == FR_OK) {
@@ -711,62 +711,62 @@ void menuGeneralSdManager(uint8_t event)
 #endif
         if (strlen(fn) > SD_SCREEN_FILE_LENGTH) continue;
 
-        reusableBuffer.sd.count++;
+        reusableBuffer.sdmanager.count++;
 
         bool isfile = !(fno.fattrib & AM_DIR);
 
         if (s_pgOfs == 0) {
           for (uint8_t i=0; i<LCD_LINES-1; i++) {
-            char *line = reusableBuffer.sd.lines[i];
+            char *line = reusableBuffer.sdmanager.lines[i];
             if (line[0] == '\0' || isFilenameLower(isfile, fn, line)) {
-              if (i < 6) memmove(reusableBuffer.sd.lines[i+1], line, sizeof(reusableBuffer.sd.lines[i]) * (6-i));
-              memset(line, 0, sizeof(reusableBuffer.sd.lines[i]));
+              if (i < 6) memmove(reusableBuffer.sdmanager.lines[i+1], line, sizeof(reusableBuffer.sdmanager.lines[i]) * (6-i));
+              memset(line, 0, sizeof(reusableBuffer.sdmanager.lines[i]));
               strcpy(line, fn);
               line[SD_SCREEN_FILE_LENGTH+1] = isfile;
               break;
             }
           }
         }
-        else if (reusableBuffer.sd.offset == s_pgOfs) {
+        else if (reusableBuffer.sdmanager.offset == s_pgOfs) {
           for (int8_t i=6; i>=0; i--) {
-            char *line = reusableBuffer.sd.lines[i];
+            char *line = reusableBuffer.sdmanager.lines[i];
             if (line[0] == '\0' || isFilenameGreater(isfile, fn, line)) {
-              if (i > 0) memmove(reusableBuffer.sd.lines[0], reusableBuffer.sd.lines[1], sizeof(reusableBuffer.sd.lines[0]) * i);
-              memset(line, 0, sizeof(reusableBuffer.sd.lines[i]));
+              if (i > 0) memmove(reusableBuffer.sdmanager.lines[0], reusableBuffer.sdmanager.lines[1], sizeof(reusableBuffer.sdmanager.lines[0]) * i);
+              memset(line, 0, sizeof(reusableBuffer.sdmanager.lines[i]));
               strcpy(line, fn);
               line[SD_SCREEN_FILE_LENGTH+1] = isfile;
               break;
             }
           }
         }
-        else if (s_pgOfs > reusableBuffer.sd.offset) {
-          if (isFilenameGreater(isfile, fn, reusableBuffer.sd.lines[5]) && isFilenameLower(isfile, fn, reusableBuffer.sd.lines[6])) {
-            memset(reusableBuffer.sd.lines[6], 0, sizeof(reusableBuffer.sd.lines[0]));
-            strcpy(reusableBuffer.sd.lines[6], fn);
-            reusableBuffer.sd.lines[6][SD_SCREEN_FILE_LENGTH+1] = isfile;
+        else if (s_pgOfs > reusableBuffer.sdmanager.offset) {
+          if (isFilenameGreater(isfile, fn, reusableBuffer.sdmanager.lines[5]) && isFilenameLower(isfile, fn, reusableBuffer.sdmanager.lines[6])) {
+            memset(reusableBuffer.sdmanager.lines[6], 0, sizeof(reusableBuffer.sdmanager.lines[0]));
+            strcpy(reusableBuffer.sdmanager.lines[6], fn);
+            reusableBuffer.sdmanager.lines[6][SD_SCREEN_FILE_LENGTH+1] = isfile;
           }
         }
         else {
-          if (isFilenameLower(isfile, fn, reusableBuffer.sd.lines[1]) && isFilenameGreater(isfile, fn, reusableBuffer.sd.lines[0])) {
-            memset(reusableBuffer.sd.lines[0], 0, sizeof(reusableBuffer.sd.lines[0]));
-            strcpy(reusableBuffer.sd.lines[0], fn);
-            reusableBuffer.sd.lines[0][SD_SCREEN_FILE_LENGTH+1] = isfile;
+          if (isFilenameLower(isfile, fn, reusableBuffer.sdmanager.lines[1]) && isFilenameGreater(isfile, fn, reusableBuffer.sdmanager.lines[0])) {
+            memset(reusableBuffer.sdmanager.lines[0], 0, sizeof(reusableBuffer.sdmanager.lines[0]));
+            strcpy(reusableBuffer.sdmanager.lines[0], fn);
+            reusableBuffer.sdmanager.lines[0][SD_SCREEN_FILE_LENGTH+1] = isfile;
           }
         }
       }
     }
   }
 
-  reusableBuffer.sd.offset = s_pgOfs;
+  reusableBuffer.sdmanager.offset = s_pgOfs;
 
   for (uint8_t i=0; i<LCD_LINES-1; i++) {
     uint8_t y = 1 + FH + i*FH;
     uint8_t x = 0;
     uint8_t attr = (m_posVert-1-s_pgOfs == i ? BSS|INVERS : BSS);
-    if (reusableBuffer.sd.lines[i][0]) {
-      if (!reusableBuffer.sd.lines[i][SD_SCREEN_FILE_LENGTH+1]) { lcd_putcAtt(0, y, '[', attr); x += FW; }
-      lcd_putsAtt(x, y, reusableBuffer.sd.lines[i], attr);
-      if (!reusableBuffer.sd.lines[i][SD_SCREEN_FILE_LENGTH+1]) { lcd_putcAtt(lcdLastPos, y, ']', attr); }
+    if (reusableBuffer.sdmanager.lines[i][0]) {
+      if (!reusableBuffer.sdmanager.lines[i][SD_SCREEN_FILE_LENGTH+1]) { lcd_putcAtt(0, y, '[', attr); x += FW; }
+      lcd_putsAtt(x, y, reusableBuffer.sdmanager.lines[i], attr);
+      if (!reusableBuffer.sdmanager.lines[i][SD_SCREEN_FILE_LENGTH+1]) { lcd_putcAtt(lcdLastPos, y, ']', attr); }
     }
   }
 }
diff --git a/src/menu_model.cpp b/src/menu_model.cpp
index d5149dc03..f990037ee 100644
--- a/src/menu_model.cpp
+++ b/src/menu_model.cpp
@@ -128,12 +128,12 @@ bool listSdFiles(const char *path, const char *extension, const uint8_t maxlen,
 
   if (selection) {
     s_last_flags = flags;
-    memset(reusableBuffer.models.menu_bss, 0, sizeof(reusableBuffer.models.menu_bss));
-    strcpy(reusableBuffer.models.menu_bss[0], path);
-    strcat(reusableBuffer.models.menu_bss[0], "/");
-    strncat(reusableBuffer.models.menu_bss[0], selection, maxlen);
-    strcat(reusableBuffer.models.menu_bss[0], extension);
-    if (f_stat(reusableBuffer.models.menu_bss[0], &fno) != FR_OK) {
+    memset(reusableBuffer.modelsel.menu_bss, 0, sizeof(reusableBuffer.modelsel.menu_bss));
+    strcpy(reusableBuffer.modelsel.menu_bss[0], path);
+    strcat(reusableBuffer.modelsel.menu_bss[0], "/");
+    strncat(reusableBuffer.modelsel.menu_bss[0], selection, maxlen);
+    strcat(reusableBuffer.modelsel.menu_bss[0], extension);
+    if (f_stat(reusableBuffer.modelsel.menu_bss[0], &fno) != FR_OK) {
       selection = NULL;
     }
   }
@@ -144,19 +144,19 @@ bool listSdFiles(const char *path, const char *extension, const uint8_t maxlen,
 
   if (s_menu_offset == 0) {
     s_last_menu_offset = 0;
-    memset(reusableBuffer.models.menu_bss, 0, sizeof(reusableBuffer.models.menu_bss));
+    memset(reusableBuffer.modelsel.menu_bss, 0, sizeof(reusableBuffer.modelsel.menu_bss));
   }
   else if (s_menu_offset == s_last_menu_offset) {
     // should not happen, only there because of Murphy's law
     return true;
   }
   else if (s_menu_offset > s_last_menu_offset) {
-    memmove(reusableBuffer.models.menu_bss[0], reusableBuffer.models.menu_bss[1], (MENU_MAX_LINES-1)*MENU_LINE_LENGTH);
-    memset(reusableBuffer.models.menu_bss[MENU_MAX_LINES-1], 0xff, MENU_LINE_LENGTH);
+    memmove(reusableBuffer.modelsel.menu_bss[0], reusableBuffer.modelsel.menu_bss[1], (MENU_MAX_LINES-1)*MENU_LINE_LENGTH);
+    memset(reusableBuffer.modelsel.menu_bss[MENU_MAX_LINES-1], 0xff, MENU_LINE_LENGTH);
   }
   else {
-    memmove(reusableBuffer.models.menu_bss[1], reusableBuffer.models.menu_bss[0], (MENU_MAX_LINES-1)*MENU_LINE_LENGTH);
-    memset(reusableBuffer.models.menu_bss[0], 0, MENU_LINE_LENGTH);
+    memmove(reusableBuffer.modelsel.menu_bss[1], reusableBuffer.modelsel.menu_bss[0], (MENU_MAX_LINES-1)*MENU_LINE_LENGTH);
+    memset(reusableBuffer.modelsel.menu_bss[0], 0, MENU_LINE_LENGTH);
   }
 
   s_menu_count = 0;
@@ -171,7 +171,7 @@ bool listSdFiles(const char *path, const char *extension, const uint8_t maxlen,
         s_last_menu_offset++;
       }
       else if (s_menu_offset==0 || s_menu_offset < s_last_menu_offset) {
-        char *line = reusableBuffer.models.menu_bss[0];
+        char *line = reusableBuffer.modelsel.menu_bss[0];
         memset(line, 0, MENU_LINE_LENGTH);
         strcpy(line, "---");
         s_menu[0] = line;
@@ -200,9 +200,9 @@ bool listSdFiles(const char *path, const char *extension, const uint8_t maxlen,
         }
         else {
           for (uint8_t i=0; i<MENU_MAX_LINES; i++) {
-            char *line = reusableBuffer.models.menu_bss[i];
+            char *line = reusableBuffer.modelsel.menu_bss[i];
             if (line[0] == '\0' || strcmp(fn, line) < 0) {
-              if (i < MENU_MAX_LINES-1) memmove(reusableBuffer.models.menu_bss[i+1], line, sizeof(reusableBuffer.models.menu_bss[i]) * (MENU_MAX_LINES-1-i));
+              if (i < MENU_MAX_LINES-1) memmove(reusableBuffer.modelsel.menu_bss[i+1], line, sizeof(reusableBuffer.modelsel.menu_bss[i]) * (MENU_MAX_LINES-1-i));
               memset(line, 0, MENU_LINE_LENGTH);
               strcpy(line, fn);
               break;
@@ -210,18 +210,18 @@ bool listSdFiles(const char *path, const char *extension, const uint8_t maxlen,
           }
         }
         for (uint8_t i=0; i<min(s_menu_count, (uint16_t)MENU_MAX_LINES); i++)
-          s_menu[i] = reusableBuffer.models.menu_bss[i];
+          s_menu[i] = reusableBuffer.modelsel.menu_bss[i];
       }
       else if (s_menu_offset > s_last_menu_offset) {
-        if (strcmp(fn, reusableBuffer.models.menu_bss[MENU_MAX_LINES-2]) > 0 && strcmp(fn, reusableBuffer.models.menu_bss[MENU_MAX_LINES-1]) < 0) {
-          memset(reusableBuffer.models.menu_bss[MENU_MAX_LINES-1], 0, MENU_LINE_LENGTH);
-          strcpy(reusableBuffer.models.menu_bss[MENU_MAX_LINES-1], fn);
+        if (strcmp(fn, reusableBuffer.modelsel.menu_bss[MENU_MAX_LINES-2]) > 0 && strcmp(fn, reusableBuffer.modelsel.menu_bss[MENU_MAX_LINES-1]) < 0) {
+          memset(reusableBuffer.modelsel.menu_bss[MENU_MAX_LINES-1], 0, MENU_LINE_LENGTH);
+          strcpy(reusableBuffer.modelsel.menu_bss[MENU_MAX_LINES-1], fn);
         }
       }
       else {
-        if (strcmp(fn, reusableBuffer.models.menu_bss[1]) < 0 && strcmp(fn, reusableBuffer.models.menu_bss[0]) > 0) {
-          memset(reusableBuffer.models.menu_bss[0], 0, MENU_LINE_LENGTH);
-          strcpy(reusableBuffer.models.menu_bss[0], fn);
+        if (strcmp(fn, reusableBuffer.modelsel.menu_bss[1]) < 0 && strcmp(fn, reusableBuffer.modelsel.menu_bss[0]) > 0) {
+          memset(reusableBuffer.modelsel.menu_bss[0], 0, MENU_LINE_LENGTH);
+          strcpy(reusableBuffer.modelsel.menu_bss[0], fn);
         }
       }
     }
@@ -267,7 +267,7 @@ void onModelSelectMenu(const char *result)
     s_warning = eeBackupModel(sub);
   }
   else if (result == STR_RESTORE_MODEL || result == STR_UPDATE_LIST) {
-    if (!listSdFiles(MODELS_PATH, MODELS_EXT, sizeof(g_model.name), NULL)) {
+    if (!listSdFiles(MODELS_PATH, MODELS_EXT, sizeof(g_model.header.name), NULL)) {
       s_warning = STR_NO_MODELS_ON_SD;
       s_menu_flags = 0;
     }
@@ -277,13 +277,13 @@ void onModelSelectMenu(const char *result)
     s_warning = STR_DELETEMODEL;
     s_warning_type = WARNING_TYPE_CONFIRM;
 #if defined(CPUARM)
-    s_warning_info = modelNames[sub];
+    s_warning_info = modelHeaders[sub].name;
 #else
-    char * name = reusableBuffer.models.mainname;
+    char * name = reusableBuffer.modelsel.mainname;
     eeLoadModelName(sub, name);
     s_warning_info = name;
 #endif
-    s_warning_info_len = sizeof(g_model.name);
+    s_warning_info_len = sizeof(g_model.header.name);
   }
 #if defined(SDCARD)
   else {
@@ -333,6 +333,11 @@ void menuModelSelect(uint8_t event)
   }
 #endif
 
+#if defined(PCBTARANIS)
+  static int8_t modelselBitmapIdx = -1;
+  static uint8_t modelselBitmap[MODEL_BITMAP_SIZE];
+#endif
+
   int8_t sub = m_posVert;
 
   switch (event)
@@ -348,13 +353,13 @@ void menuModelSelect(uint8_t event)
           s_warning = STR_DELETEMODEL;
           s_warning_type = WARNING_TYPE_CONFIRM;
 #if defined(CPUARM)
-          s_warning_info = modelNames[sub];
+          s_warning_info = modelHeaders[sub].name;
 #else
-          char * name = reusableBuffer.models.mainname;
+          char * name = reusableBuffer.modelsel.mainname;
           eeLoadModelName(sub, name);
           s_warning_info = name;
 #endif
-          s_warning_info_len = sizeof(g_model.name);
+          s_warning_info_len = sizeof(g_model.header.name);
           killEvents(event);
           break;
         }
@@ -542,18 +547,17 @@ void menuModelSelect(uint8_t event)
           s_copyTgtOfs = next_ofs;
         }
         break;
-
   }
 
 #if defined(PCBTARANIS)
   lcd_puts(27*FW-(LEN_FREE-4)*FW, 0, STR_FREE);
-  if (event) reusableBuffer.models.eepromfree = EeFsGetFree();
-  lcd_outdezAtt(20*FW, 0, reusableBuffer.models.eepromfree, 0);
+  if (event) reusableBuffer.modelsel.eepromfree = EeFsGetFree();
+  lcd_outdezAtt(20*FW, 0, reusableBuffer.modelsel.eepromfree, 0);
   lcd_puts(21*FW, 0, STR_BYTES);
 #elif !defined(PCBSKY9X)
   lcd_puts(9*FW-(LEN_FREE-4)*FW, 0, STR_FREE);
-  if (event) reusableBuffer.models.eepromfree = EeFsGetFree();
-  lcd_outdezAtt(17*FW, 0, reusableBuffer.models.eepromfree, 0);
+  if (event) reusableBuffer.modelsel.eepromfree = EeFsGetFree();
+  lcd_outdezAtt(17*FW, 0, reusableBuffer.modelsel.eepromfree, 0);
 #endif
 
 #if defined(ROTARY_ENCODER_NAVIGATION)
@@ -592,12 +596,12 @@ void menuModelSelect(uint8_t event)
 
     if (eeModelExists(k)) {
 #if defined(PCBSKY9X)
-      putsModelName(4*FW, y, modelNames[k], k, 0);
+      putsModelName(4*FW, y, modelHeaders[k].name, k, 0);
 #elif defined(CPUARM)
-      putsModelName(4*FW, y, modelNames[k], k, 0);
+      putsModelName(4*FW, y, modelHeaders[k].name, k, 0);
       lcd_outdezAtt(20*FW, y, eeModelSize(k), 0);
 #else
-      char * name = reusableBuffer.models.listnames[i];
+      char * name = reusableBuffer.modelsel.listnames[i];
       if (event) eeLoadModelName(k, name);
       putsModelName(4*FW, y, name, k, 0);
       lcd_outdezAtt(20*FW, y, eeModelSize(k), 0);
@@ -610,6 +614,17 @@ void menuModelSelect(uint8_t event)
       lcd_rect(8, y-1, LCD_W-1-7, 9, s_copyMode == COPY_MODE ? SOLID : DOTTED);
     }
   }
+
+#if defined(PCBTARANIS)
+  if (modelselBitmapIdx != m_posVert) {
+    modelselBitmapIdx = m_posVert;
+    if (modelselBitmapIdx == g_eeGeneral.currModel)
+      memcpy(modelselBitmap, modelBitmap, MODEL_BITMAP_SIZE);
+    else
+      loadModelBitmap(modelHeaders[sub].bitmap, modelselBitmap);
+  }
+  lcd_bmp(22*FW+2, 2*FH+FH/2, modelselBitmap);
+#endif
 }
 
 #if defined(PCBTARANIS)
@@ -858,14 +873,14 @@ enum menuModelSetupItems {
 void onModelSetupMenu(const char *result)
 {
   if (result == STR_UPDATE_LIST) {
-    if (!listSdFiles(BITMAPS_PATH, BITMAPS_EXT, sizeof(g_model.bitmap), NULL)) {
+    if (!listSdFiles(BITMAPS_PATH, BITMAPS_EXT, sizeof(g_model.header.bitmap), NULL)) {
       s_warning = STR_NO_BITMAPS_ON_SD;
       s_menu_flags = 0;
     }
   }
   else {
     // The user choosed a bmp file in the list
-    memcpy(g_model.bitmap, result, sizeof(g_model.bitmap));
+    memcpy(g_model.header.bitmap, result, sizeof(g_model.header.bitmap));
     LOAD_MODEL_BITMAP();
     eeDirty(EE_MODEL);
   }
@@ -927,22 +942,22 @@ void menuModelSetup(uint8_t event)
 
     switch(k) {
       case ITEM_MODEL_NAME:
-        editSingleName(MODEL_SETUP_2ND_COLUMN, y, STR_MODELNAME, g_model.name, sizeof(g_model.name), event, attr);
+        editSingleName(MODEL_SETUP_2ND_COLUMN, y, STR_MODELNAME, g_model.header.name, sizeof(g_model.header.name), event, attr);
 #if defined(CPUARM)
-        memcpy(modelNames[g_eeGeneral.currModel], g_model.name, sizeof(g_model.name));
+        memcpy(modelHeaders[g_eeGeneral.currModel].name, g_model.header.name, sizeof(g_model.header.name));
 #endif
         break;
 
 #if defined(PCBTARANIS) && defined(SDCARD)
       case ITEM_MODEL_BITMAP:
         lcd_putsLeft(y, STR_BITMAP);
-        if (ZLEN(g_model.bitmap) > 0)
-          lcd_putsnAtt(MODEL_SETUP_2ND_COLUMN, y, g_model.bitmap, sizeof(g_model.bitmap), attr);
+        if (ZLEN(g_model.header.bitmap) > 0)
+          lcd_putsnAtt(MODEL_SETUP_2ND_COLUMN, y, g_model.header.bitmap, sizeof(g_model.header.bitmap), attr);
         else
           lcd_putsiAtt(MODEL_SETUP_2ND_COLUMN, y, STR_VCSWFUNC, 0, attr);
         if (attr && event==EVT_KEY_BREAK(KEY_ENTER)) {
           s_editMode = 0;
-          if (listSdFiles(BITMAPS_PATH, BITMAPS_EXT, sizeof(g_model.bitmap), g_model.bitmap, LIST_NONE_SD_FILE)) {
+          if (listSdFiles(BITMAPS_PATH, BITMAPS_EXT, sizeof(g_model.header.bitmap), g_model.header.bitmap, LIST_NONE_SD_FILE)) {
             menuHandler = onModelSetupMenu;
           }
           else {
@@ -1222,12 +1237,12 @@ void menuModelSetup(uint8_t event)
         else {
           lcd_putsLeft(y, STR_RXNUM);
           if (IS_MODULE_XJT(moduleIdx)) {
-            lcd_outdezNAtt(MODEL_SETUP_2ND_COLUMN, y, g_model.modelId, (m_posHorz==0 ? attr : 0) | LEADING0|LEFT, 2);
+            lcd_outdezNAtt(MODEL_SETUP_2ND_COLUMN, y, g_model.header.modelId, (m_posHorz==0 ? attr : 0) | LEADING0|LEFT, 2);
             if (attr && m_posHorz==0) {
               if (editMode>0 || p1valdiff) {
-                CHECK_INCDEC_MODELVAR_ZERO(event, g_model.modelId, 63);
+                CHECK_INCDEC_MODELVAR_ZERO(event, g_model.header.modelId, 63);
                 if (checkIncDec_Ret)
-                  modelIds[g_eeGeneral.currModel] = g_model.modelId;
+                  modelHeaders[g_eeGeneral.currModel].modelId = g_model.header.modelId;
               }
               if (editMode==0 && event==EVT_KEY_BREAK(KEY_ENTER))
                 checkModelIdUnique(g_eeGeneral.currModel);
@@ -1396,12 +1411,12 @@ void menuModelSetup(uint8_t event)
           }
 
           lcd_putsLeft(y, STR_RXNUM);
-          lcd_outdezNAtt(MODEL_SETUP_2ND_COLUMN-3*FW, y, g_model.modelId, (m_posHorz<=0 ? attr : 0) | LEADING0|LEFT, 2);
+          lcd_outdezNAtt(MODEL_SETUP_2ND_COLUMN-3*FW, y, g_model.header.modelId, (m_posHorz<=0 ? attr : 0) | LEADING0|LEFT, 2);
           if (attr && (m_posHorz==0 && (editMode>0 || p1valdiff))) {
-            CHECK_INCDEC_MODELVAR_ZERO(event, g_model.modelId, 99);
+            CHECK_INCDEC_MODELVAR_ZERO(event, g_model.header.modelId, 99);
 #if defined(CPUARM)
             if (checkIncDec_Ret)
-              modelIds[g_eeGeneral.currModel] = g_model.modelId;
+              modelHeaders[g_eeGeneral.currModel].modelId = g_model.header.modelId;
 #endif
           }
 
@@ -1990,7 +2005,7 @@ typedef int16_t (*FnFuncP) (int16_t x);
 int16_t expoFn(int16_t x)
 {
   ExpoData *ed = expoaddress(s_currIdx);
-  int16_t anas[NUM_STICKS] = {0};
+  int16_t anas[NUM_INPUTS] = {0};
   anas[ed->chn] = x;
   applyExpos(anas);
   return anas[ed->chn];
@@ -2981,7 +2996,7 @@ void menuModelExpoMix(uint8_t expo, uint8_t event)
   uint8_t cur = 1;
   uint8_t i = 0;
 
-  for (uint8_t ch=1; ch<=(expo ? NUM_STICKS : NUM_CHNOUT); ch++) {
+  for (uint8_t ch=1; ch<=(expo ? NUM_INPUTS : NUM_CHNOUT); ch++) {
     void *pointer = NULL; MixData * &md = (MixData * &)pointer; ExpoData * &ed = (ExpoData * &)pointer;
     uint8_t y = 1+(cur-s_pgOfs)*FH;
     if (expo ? (i<MAX_EXPOS && (ed=expoaddress(i))->chn+1 == ch && ed->mode) : (i<MAX_MIXERS && (md=mixaddress(i))->srcRaw && md->destCh+1 == ch)) {
diff --git a/src/myeeprom.h b/src/myeeprom.h
index 543ab133b..7d0d23c26 100644
--- a/src/myeeprom.h
+++ b/src/myeeprom.h
@@ -52,9 +52,9 @@
 #define BEEP_VAL     ( (g_eeGeneral.warnOpts & WARN_BVAL_BIT) >>3 )
 
 #if defined(PCBTARANIS)
-  #define EEPROM_VER       214
+  #define EEPROM_VER       215
 #elif defined(PCBSKY9X)
-  #define EEPROM_VER       214
+  #define EEPROM_VER       215
 #elif defined(PCBGRUVIN9X)
   #define EEPROM_VER       214
 #elif defined(CPUM2561)
@@ -225,14 +225,17 @@ PACK(typedef struct t_ModuleData {
 }) ModuleData;
 
 #if defined(PCBTARANIS)
-#define MODELDATA_EXTRA   char bitmap[10]; uint8_t externalModule; ModuleData moduleData[NUM_MODULES]; uint8_t trainerMode; char curveNames[MAX_CURVES][6];
+#define MODELDATA_BITMAP  char bitmap[LEN_BITMAP_NAME];
+#define MODELDATA_EXTRA   uint8_t externalModule; ModuleData moduleData[NUM_MODULES]; uint8_t trainerMode; char curveNames[MAX_CURVES][6];
 #define LIMITDATA_EXTRA   char name[6];
 #define swstate_t         uint16_t
 #elif defined(PCBSKY9X)
+#define MODELDATA_BITMAP
 #define MODELDATA_EXTRA   uint8_t ppmSCH; int8_t ppm2SCH; int8_t ppm2NCH; ModuleData moduleData[NUM_MODULES];
 #define LIMITDATA_EXTRA
 #define swstate_t         uint8_t
 #else
+#define MODELDATA_BITMAP
 #define MODELDATA_EXTRA
 #define LIMITDATA_EXTRA
 #define swstate_t         uint8_t
@@ -302,6 +305,7 @@ PACK(typedef struct t_EEGeneral {
 
 #if defined(PCBTARANIS)
 #define LEN_MODEL_NAME     12
+#define LEN_BITMAP_NAME    10
 #define LEN_EXPOMIX_NAME   10
 #define LEN_FP_NAME        10
 #elif defined(PCBSKY9X)
@@ -315,14 +319,14 @@ PACK(typedef struct t_EEGeneral {
 
 #if defined(CPUARM)
 PACK(typedef struct t_ExpoData {
-  uint8_t mode;         // 0=end, 1=pos, 2=neg, 3=both
-  uint8_t chn;
-  int8_t  swtch;
+  uint8_t  mode;         // 0=end, 1=pos, 2=neg, 3=both
+  uint8_t  chn;
+  int8_t   swtch;
   uint16_t phases;
-  int8_t  weight;
-  uint8_t curveMode;
-  char    name[LEN_EXPOMIX_NAME];
-  int8_t  curveParam;
+  int8_t   weight;
+  uint8_t  curveMode;
+  char     name[LEN_EXPOMIX_NAME];
+  int8_t   curveParam;
 }) ExpoData;
 #elif defined(PCBGRUVIN9X) || defined(CPUM2561)
 PACK(typedef struct t_ExpoData {
@@ -509,8 +513,8 @@ PACK( union u_int8int16_t {
 #define MAX_CSW_DELAY    120 /*60s*/
 #define MAX_CSW_ANDSW    MAX_SWITCH
 PACK(typedef struct t_CustomSwData { // Custom Switches data
-  int8_t  v1;
-  int8_t  v2;      // TODO EEPROM change
+  int16_t v1;
+  int16_t v2;
   uint8_t func;
   uint8_t delay;
   uint8_t duration;
@@ -1198,13 +1202,18 @@ enum FailsafeModes {
 #define BeepANACenter uint8_t
 #endif
 
-PACK(typedef struct t_ModelData {
+PACK(typedef struct t_ModelHeader {
   char      name[LEN_MODEL_NAME]; // must be first for eeLoadModelName
   uint8_t   modelId;
+  MODELDATA_BITMAP
+}) ModelHeader;
+
+PACK(typedef struct t_ModelData {
+  ModelHeader header;
   TimerData timers[MAX_TIMERS];
   uint8_t   protocol:3;
   uint8_t   thrTrim:1;            // Enable Throttle Trim
-  int8_t    ppmNCH:4;             /* TODO EEPROM change */
+  int8_t    ppmNCH:4;
   uint8_t   trimInc:3;            // Trim Increments
   uint8_t   disableThrottleWarning:1;
   uint8_t   pulsePol:1;
diff --git a/src/opentx.cpp b/src/opentx.cpp
index 8854139af..eac4236dd 100644
--- a/src/opentx.cpp
+++ b/src/opentx.cpp
@@ -94,14 +94,15 @@ ModelData  g_model;
 
 #if defined(PCBTARANIS) && defined(SDCARD)
 uint8_t modelBitmap[MODEL_BITMAP_SIZE];
-pm_char * modelBitmapLoaded = NULL;
-void loadModelBitmap()
+void loadModelBitmap(char *name, uint8_t *bitmap)
 {
   char lfn[] = BITMAPS_PATH "/xxxxxxxxxx.bmp";
-  strncpy(lfn+sizeof(BITMAPS_PATH), g_model.bitmap, sizeof(g_model.bitmap));
-  lfn[sizeof(BITMAPS_PATH)+sizeof(g_model.bitmap)] = '\0';
+  strncpy(lfn+sizeof(BITMAPS_PATH), name, LEN_BITMAP_NAME);
+  lfn[sizeof(BITMAPS_PATH)+LEN_BITMAP_NAME] = '\0';
   strcat(lfn+sizeof(BITMAPS_PATH), BITMAPS_EXT);
-  modelBitmapLoaded = bmpLoad(modelBitmap, lfn, MODEL_BITMAP_WIDTH, MODEL_BITMAP_HEIGHT);
+  if (bmpLoad(bitmap, lfn, MODEL_BITMAP_WIDTH, MODEL_BITMAP_HEIGHT)) {
+    memcpy(bitmap, logo_taranis, MODEL_BITMAP_SIZE);
+  }
 }
 #endif
 
@@ -405,7 +406,7 @@ inline void applyDefaultTemplate()
 void checkModelIdUnique(uint8_t id)
 {
   for (uint8_t i=0; i<MAX_MODELS; i++) {
-    if (i != id && g_model.modelId!=0 && g_model.modelId == modelIds[i]) {
+    if (i!=id && g_model.header.modelId!=0 && g_model.header.modelId==modelHeaders[i].modelId) {
       s_warning = PSTR("Model ID already used");
       s_warning_type = WARNING_TYPE_ASTERISK;
     }
@@ -419,7 +420,7 @@ void modelDefault(uint8_t id)
   applyDefaultTemplate();
 
 #if defined(PXX) && defined(CPUARM)
-  modelIds[id] = g_model.modelId = id+1;
+  modelHeaders[id].modelId = g_model.header.modelId = id+1;
   checkModelIdUnique(id);
 #endif
 
@@ -641,7 +642,7 @@ ACTIVE_EXPOS_TYPE activeExpos;
 
 void applyExpos(int16_t *anas)
 {
-  int16_t anas2[NUM_STICKS]; // values before expo, to ensure same expo base when multiple expo lines are used
+  int16_t anas2[NUM_INPUTS]; // values before expo, to ensure same expo base when multiple expo lines are used
   memcpy(anas2, anas, sizeof(anas2));
 
   int8_t cur_chn = -1;
@@ -2133,8 +2134,8 @@ uint16_t isqrt32(uint32_t n)
 
 // static variables used in perOut - moved here so they don't interfere with the stack
 // It's also easier to initialize them here.
-int16_t  rawAnas [NUM_STICKS] = {0};
-int16_t  anas [NUM_STICKS] = {0};
+int16_t  rawAnas [NUM_INPUTS] = {0};
+int16_t  anas [NUM_INPUTS] = {0};
 int16_t  trims[NUM_STICKS] = {0};
 int32_t  chans[NUM_CHNOUT] = {0};
 uint8_t inacPrescale;
diff --git a/src/opentx.h b/src/opentx.h
index e54fa4b8c..70e6bc6cc 100644
--- a/src/opentx.h
+++ b/src/opentx.h
@@ -419,9 +419,8 @@ enum EnumKeys {
   #define MODEL_BITMAP_HEIGHT 32
   #define MODEL_BITMAP_SIZE   (2+4*(MODEL_BITMAP_WIDTH*MODEL_BITMAP_HEIGHT/8))
   extern uint8_t modelBitmap[MODEL_BITMAP_SIZE];
-  extern pm_char * modelBitmapLoaded;
-  void loadModelBitmap();
-  #define LOAD_MODEL_BITMAP() loadModelBitmap()
+  void loadModelBitmap(char *name, uint8_t *bitmap);
+  #define LOAD_MODEL_BITMAP() loadModelBitmap(g_model.header.bitmap, modelBitmap)
 #else
   #define LOAD_MODEL_BITMAP()
 #endif
@@ -1056,6 +1055,12 @@ extern int16_t            ex_chans[NUM_CHNOUT]; // Outputs (before LIMITS) of th
 extern int16_t            channelOutputs[NUM_CHNOUT];
 extern uint16_t           BandGap;
 
+#if defined(CPUARM)
+  #define NUM_INPUTS      (NUM_STICKS)
+#else
+  #define NUM_INPUTS      (NUM_STICKS)
+#endif
+
 extern int16_t expo(int16_t x, int16_t k);
 extern int16_t intpol(int16_t, uint8_t);
 extern int16_t applyCurve(int16_t, int8_t);
@@ -1273,30 +1278,25 @@ extern uint8_t requiredSpeakerVolume;
 #define SD_SCREEN_FILE_LENGTH (32)
 union ReusableBuffer
 {
-    /* 128 bytes on stock */
-
-#if !defined(PCBSKY9X)
-    uint8_t eefs_buffer[BLOCKS];           // 128bytes used by EeFsck
-#endif
-
     struct
     {
-        char mainname[42];
         char listnames[LCD_LINES-1][LEN_MODEL_NAME];
         uint16_t eepromfree;
-
 #if defined(SDCARD)
         char menu_bss[MENU_MAX_LINES][MENU_LINE_LENGTH];
+        char mainname[42]; // because reused for SD backup / restore
+#else
+        char mainname[LEN_MODEL_NAME];
 #endif
 
-    } models;                                     // 128bytes used by menuModelSelect (mainname reused for SD card archive / restore)
+    } modelsel;
 
     struct
     {
         int16_t midVals[NUM_STICKS+NUM_POTS];
         int16_t loVals[NUM_STICKS+NUM_POTS];
         int16_t hiVals[NUM_STICKS+NUM_POTS];
-    } calib;                                      // 42 bytes used by menuGeneralCalib
+    } calib;
 
 #if defined(SDCARD)
     struct
@@ -1305,7 +1305,7 @@ union ReusableBuffer
         uint32_t available;
         uint16_t offset;
         uint16_t count;
-    } sd;
+    } sdmanager;
 #endif
 };
 
@@ -1323,7 +1323,7 @@ void putsTelemetryValue(xcoord_t x, uint8_t y, lcdint_t val, uint8_t unit, uint8
 #if defined(CPUARM)
 uint8_t zlen(const char *str, uint8_t size);
 char * strcat_zchar(char * dest, char * name, uint8_t size, const char *defaultName, uint8_t defaultNameSize, uint8_t defaultIdx);
-#define strcat_modelname(dest, idx) strcat_zchar(dest, modelNames[idx], LEN_MODEL_NAME, STR_MODEL, PSIZE(TR_MODEL), idx+1)
+#define strcat_modelname(dest, idx) strcat_zchar(dest, modelHeaders[idx].name, LEN_MODEL_NAME, STR_MODEL, PSIZE(TR_MODEL), idx+1)
 #define strcat_phasename(dest, idx) strcat_zchar(dest, g_model.phaseData[idx].name, LEN_FP_NAME, NULL, 0, 0)
 #define strcat_mixername(dest, idx) strcat_zchar(dest, g_model.mixData[idx].name, LEN_EXPOMIX_NAME, NULL, 0, 0)
 #define ZLEN(s) zlen(s, sizeof(s))
@@ -1410,4 +1410,8 @@ void varioWakeup();
   #define IS_USR_PROTO_WS_HOW_HIGH() (g_model.frsky.usrProto == USR_PROTO_WS_HOW_HIGH)
 #endif
 
+#if defined(PCBTARANIS)
+  extern const pm_uchar logo_taranis[];
+#endif
+
 #endif
diff --git a/src/pulses_arm.cpp b/src/pulses_arm.cpp
index fc4e38217..8ac1f432d 100644
--- a/src/pulses_arm.cpp
+++ b/src/pulses_arm.cpp
@@ -407,7 +407,7 @@ void setupPulsesPXX(MODULE_INDEX_PARAM)
   putPcmHead(module_index);
 
   /* Rx Number */
-  putPcmByte(g_model.modelId, module_index);
+  putPcmByte(g_model.header.modelId, module_index);
 #else
   PcmCrc = 0;
   PcmOnesCount = 0;
@@ -416,7 +416,7 @@ void setupPulsesPXX(MODULE_INDEX_PARAM)
   putPcmHead();
 
   /* Rx Number */
-  putPcmByte(g_model.modelId);
+  putPcmByte(g_model.header.modelId);
 #endif
 
   /* FLAG1 */
diff --git a/src/pulses_avr.cpp b/src/pulses_avr.cpp
index 5db5389e5..61d130ac9 100644
--- a/src/pulses_avr.cpp
+++ b/src/pulses_avr.cpp
@@ -319,7 +319,7 @@ void setupPulsesPXX()
     PcmBitCount = PcmByte = 0 ;
     PcmOnesCount = 0 ;
     putPcmHead() ;
-    putPcmByte( g_model.modelId ) ;     // putPcmByte( g_model.rxnum ) ;  //
+    putPcmByte( g_model.header.modelId ) ;     // putPcmByte( g_model.rxnum ) ;  //
     putPcmByte( pxxFlag[0] ) ;     // First byte of flags
     putPcmByte( 0 ) ;     // Second byte of flags
     pxxFlag[0] = 0;          // reset flag after send
@@ -403,7 +403,7 @@ FORCEINLINE void setupPulsesDsm2()
     s_bind_mode = false;
   ++ptr;
 
-  *ptr++ = g_model.modelId;
+  *ptr++ = g_model.header.modelId;
   for (uint8_t i=0; i<DSM2_CHANS; i++) 
   {
     uint16_t pulse = limit(0, ((channelOutputs[i]*13)>>5)+512,1023);
@@ -531,7 +531,7 @@ void setupPulsesDsm2()
   else
     s_bind_mode = false;
 
-  dsmDat[1] = g_model.modelId; // DSM2 Header second byte for model match
+  dsmDat[1] = g_model.header.modelId; // DSM2 Header second byte for model match
   for (uint8_t i=0; i<DSM2_CHANS; i++)
   {
     uint16_t pulse = limit(0, ((channelOutputs[i]*13)>>5)+512,1023);
diff --git a/src/simu.cpp b/src/simu.cpp
index 1f37e7c59..3afe043b3 100644
--- a/src/simu.cpp
+++ b/src/simu.cpp
@@ -385,6 +385,8 @@ int main(int argc,char **argv)
   frskyStreaming = 1;
 #endif
 
+  printf("Model size = %d\n", sizeof(g_model));
+
   StartEepromThread(argc >= 2 ? argv[1] : "eeprom.bin");
   StartMainThread();
 
diff --git a/src/sky9x/board_sky9x.cpp b/src/sky9x/board_sky9x.cpp
index d94d502db..fa46e6c89 100644
--- a/src/sky9x/board_sky9x.cpp
+++ b/src/sky9x/board_sky9x.cpp
@@ -533,7 +533,7 @@ void boardInit()
 {
   register Pio *pioptr ;
 
-  ResetReason = RSTC->RSTC_MR ;
+  ResetReason = RSTC->RSTC_SR;
 
   MATRIX->CCFG_SYSIO |= 0x000000F0L ;             // Disable syspins, enable B4,5,6,7
 
diff --git a/src/view_main.cpp b/src/view_main.cpp
index 6de3bf0e7..45c1f41eb 100644
--- a/src/view_main.cpp
+++ b/src/view_main.cpp
@@ -606,7 +606,7 @@ void menuMainView(uint8_t event)
     lcd_putsnAtt(PHASE_X, PHASE_Y, g_model.phaseData[phase].name, sizeof(g_model.phaseData[phase].name), ZCHAR|PHASE_FLAGS);
 
     // Model Name
-    putsModelName(MODELNAME_X, MODELNAME_Y, g_model.name, g_eeGeneral.currModel, BIGSIZE);
+    putsModelName(MODELNAME_X, MODELNAME_Y, g_model.header.name, g_eeGeneral.currModel, BIGSIZE);
 
 #if !defined(PCBTARANIS)
     // Main Voltage (or alarm if any)
@@ -627,10 +627,7 @@ void menuMainView(uint8_t event)
   // Sliders (Pots / Sliders)
   displaySliders();
 
-  if (modelBitmapLoaded == NULL)
-    lcd_bmp(BITMAP_X, BITMAP_Y, modelBitmap);
-  else
-    lcd_bmp(BITMAP_X, BITMAP_Y, logo_taranis);
+  lcd_bmp(BITMAP_X, BITMAP_Y, modelBitmap);
 
   // Switches
   for (uint8_t i=0; i<8; i++) {