diff --git a/radio/src/bitmaps/Horus/asterisk.png b/radio/src/bitmaps/Horus/asterisk.png
index 00c24413d..1e12a2492 100644
Binary files a/radio/src/bitmaps/Horus/asterisk.png and b/radio/src/bitmaps/Horus/asterisk.png differ
diff --git a/radio/src/bmp.cpp b/radio/src/bmp.cpp
index 05bd94a22..7dc7edc54 100644
--- a/radio/src/bmp.cpp
+++ b/radio/src/bmp.cpp
@@ -330,7 +330,7 @@ const char * bmpLoad(uint8_t * bmp, const char * filename, uint16_t width, uint1
   switch (depth) {
     case 32:
       for (int i=h-1; i>=0; i--) {
-        uint8_t * dst = ((uint8_t *)dest) + i*w*3;
+        uint8_t * dst = ((uint8_t *)dest) + i*w*2;
         for (unsigned int j=0; j<w; j++) {
           uint32_t pixel;
           result = f_read(&bmpFile, (uint8_t *)&pixel, 4, &read);
@@ -340,10 +340,10 @@ const char * bmpLoad(uint8_t * bmp, const char * filename, uint16_t width, uint1
           }
           *((uint16_t *)dst) = RGB((pixel>>24) & 0xff, (pixel>>16) & 0xff, (pixel>>8) & 0xff);
           dst += 2;
-          *dst++ = 0x0F;
         }
       }
       break;
+
     case 1:
       break;
 
@@ -355,13 +355,13 @@ const char * bmpLoad(uint8_t * bmp, const char * filename, uint16_t width, uint1
           f_close(&bmpFile);
           return SDCARD_ERROR(result);
         }
-        uint8_t * dst = ((uint8_t *)dest) + i*w*3;
+        uint8_t * dst = ((uint8_t *)dest) + i*w*2;
         for (uint32_t j=0; j<w; j++) {
           uint8_t index = (buf[j/2] >> ((j & 1) ? 0 : 4)) & 0x0F;
           uint8_t val = palette[index];
           *((uint16_t *)dst) = RGB(val, val, val);
           dst += 2;
-          *dst++ = 0x0F;
+          // *dst++ = 0x0F;
         }
       }
       break;
diff --git a/radio/src/gui/Horus/lcd.cpp b/radio/src/gui/Horus/lcd.cpp
index 09a6a4a09..a9c675251 100644
--- a/radio/src/gui/Horus/lcd.cpp
+++ b/radio/src/gui/Horus/lcd.cpp
@@ -400,14 +400,13 @@ void lcdDrawSolidFilledRect(coord_t x, scoord_t y, coord_t w, coord_t h, LcdFlag
 #endif
 
 #if !defined(BOOT)
-void lcdDrawFilledRect(coord_t x, scoord_t y, coord_t w, coord_t h, uint8_t pat, LcdFlags att)
+void lcdDrawFilledRect(coord_t x, scoord_t y, coord_t w, coord_t h, LcdFlags att)
 {
   for (scoord_t i=y; i<y+h; i++) {
     if ((att&ROUND) && (i==y || i==y+h-1))
-      lcdDrawHorizontalLine(x+1, i, w-2, pat, att);
+      lcdDrawHorizontalLine(x+1, i, w-2, SOLID, att);
     else
-      lcdDrawHorizontalLine(x, i, w, pat, att);
-    pat = (pat >> 1) + ((pat & 1) << 7);
+      lcdDrawHorizontalLine(x, i, w, SOLID, att);
   }
 }
 #endif
@@ -847,15 +846,23 @@ void lcdDrawHorizontalLine(coord_t x, coord_t y, coord_t w, uint8_t pat, LcdFlag
   display_t color = lcdColorTable[COLOR_IDX(att)];
   uint8_t opacity = 0x0F - (att >> 24);
 
-  while (w--) {
-    if (pat & 1) {
+  if (pat == SOLID) {
+    while (w--) {
       lcdDrawTransparentPixel(p, opacity, color);
-      pat = (pat >> 1) | 0x80;
+      p++;
     }
-    else {
-      pat = pat >> 1;
+  }
+  else {
+    while (w--) {
+      if (pat & 1) {
+        lcdDrawTransparentPixel(p, opacity, color);
+        pat = (pat >> 1) | 0x80;
+      }
+      else {
+        pat = pat >> 1;
+      }
+      p++;
     }
-    p++;
   }
 }
 
@@ -883,6 +890,13 @@ void lcdDrawVerticalLine(coord_t x, coord_t y, coord_t h, uint8_t pat, LcdFlags
   }
 }
 
+#if defined(SIMU)
+inline void lcdDrawBitmapDMA(coord_t x, coord_t y, coord_t width, coord_t height, const uint8_t * img)
+{
+  lcdDrawBitmap(x, y, img-4, 0, 0, -1);
+}
+#endif
+
 #if !defined(BOOT)
 void lcdDrawBitmap(coord_t x, coord_t y, const uint8_t * bmp, coord_t offset, coord_t width, int scale)
 {
@@ -898,16 +912,15 @@ void lcdDrawBitmap(coord_t x, coord_t y, const uint8_t * bmp, coord_t offset, co
   }
 
   if (scale == 0) {
-    scale = -1;
+    lcdDrawBitmapDMA(x, y, width, height, bmp+4);
   }
-
-  if (scale < 0) {
+  else if (scale < 0) {
     for (coord_t i=0, row=0; row<height; i+=1, row-=scale) {
       display_t * p = &displayBuf[(y+i)*LCD_W + x];
-      const uint8_t * q = bmp + 4 + (row*w + offset) * 3;
+      const uint8_t * q = bmp + 4 + (row*w + offset) * 2;
       for (coord_t col=0; col<width; col-=scale) {
-        lcdDrawTransparentPixel(p, *(q+2), *((uint16_t *)q));
-        p++; q-=3*scale;
+        lcdDrawPixel(p, *((uint16_t *)q));
+        p++; q-=2*scale;
       }
     }
   }
@@ -915,13 +928,13 @@ void lcdDrawBitmap(coord_t x, coord_t y, const uint8_t * bmp, coord_t offset, co
     for (coord_t row=0; row<height; row++) {
       for (int i=0; i<scale; i++) {
         display_t * p = &displayBuf[(y+scale*row+i)*LCD_W + x];
-        const uint8_t * q = bmp + 4 + (row*w + offset) * 3;
+        const uint8_t * q = bmp + 4 + (row*w + offset) * 2;
         for (coord_t col=0; col<width; col++) {
           for (int j=0; j<scale; j++) {
-            lcdDrawTransparentPixel(p, *(q+2), *((uint16_t *)q));
+            lcdDrawPixel(p, *((uint16_t *)q));
             p++;
           }
-          q+=3;
+          q+=2;
         }
       }
     }
@@ -931,7 +944,7 @@ void lcdDrawBitmap(coord_t x, coord_t y, const uint8_t * bmp, coord_t offset, co
 
 void lcdDrawBlackOverlay()
 {
-  lcdDrawFilledRect(0, 0, LCD_W, LCD_H, SOLID, TEXT_COLOR | (8<<24));
+  lcdDrawFilledRect(0, 0, LCD_W, LCD_H, TEXT_COLOR | (8<<24));
 }
 
 void lcdDrawCircle(int x0, int y0, int radius)
diff --git a/radio/src/gui/Horus/lcd.h b/radio/src/gui/Horus/lcd.h
index baac76fb0..7864964f1 100644
--- a/radio/src/gui/Horus/lcd.h
+++ b/radio/src/gui/Horus/lcd.h
@@ -265,7 +265,7 @@ inline void lcdDrawSolidRect(coord_t x, scoord_t y, coord_t w, coord_t h, LcdFla
   lcdDrawSolidHorizontalLine(x, y+h-1, w, att);
 }
 
-void lcdDrawFilledRect(coord_t x, scoord_t y, coord_t w, coord_t h, uint8_t pat, LcdFlags att);
+void lcdDrawFilledRect(coord_t x, scoord_t y, coord_t w, coord_t h, LcdFlags att);
 void lcdDrawBlackOverlay();
 void lcdDrawRect(coord_t x, coord_t y, coord_t w, coord_t h, uint8_t pat=SOLID, LcdFlags att=0);
 void lcdDrawCircle(int x0, int y0, int radius);
diff --git a/radio/src/gui/Horus/view_main.cpp b/radio/src/gui/Horus/view_main.cpp
index d199e2bc7..38b811eb6 100644
--- a/radio/src/gui/Horus/view_main.cpp
+++ b/radio/src/gui/Horus/view_main.cpp
@@ -347,6 +347,7 @@ bool menuMainView(evt_t event)
 
   // 23ms if 24bits per pixel (with transparency) 5/6/5/8
   // 6ms if 16bits per pixel 5/6/5 no DMA
+  // 1.2ms with the DMA
   TIME_MEASURE_START(backgroundbitmap);
   lcdDrawBitmap(0, 0, LBM_MAINVIEW_BACKGROUND);
   TIME_MEASURE_STOP(backgroundbitmap);
@@ -383,7 +384,7 @@ bool menuMainView(evt_t event)
 
   // Model panel
   TIME_MEASURE_START(filledRect);
-  lcdDrawFilledRect(MODELPANEL_LEFT, MODELPANEL_TOP, MODELPANEL_WIDTH, MODELPANEL_HEIGHT, SOLID, TEXT_BGCOLOR | OPACITY(5));
+  lcdDrawFilledRect(MODELPANEL_LEFT, MODELPANEL_TOP, MODELPANEL_WIDTH, MODELPANEL_HEIGHT, TEXT_BGCOLOR | OPACITY(5));
   TIME_MEASURE_STOP(filledRect); // 9ms !
 
   lcdDrawBitmapPattern(MODELPANEL_LEFT+6, MODELPANEL_TOP+4, LBM_MODEL_ICON, TITLE_BGCOLOR);
diff --git a/radio/src/main_arm.cpp b/radio/src/main_arm.cpp
index b75527095..fe9684d41 100644
--- a/radio/src/main_arm.cpp
+++ b/radio/src/main_arm.cpp
@@ -160,7 +160,9 @@ void guiMain(evt_t evt)
         if (popupDisplayed == false) {
           g_menuStack[g_menuStackPtr](EVT_REFRESH);
           lcdDrawBlackOverlay();
+          TIME_MEASURE_START(storebackup);
           lcdStoreBackupBuffer();
+          TIME_MEASURE_STOP(storebackup);
         }
         if (popupDisplayed == false || evt) {
           lcdRestoreBackupBuffer();
diff --git a/radio/src/targets/Horus/board_horus.h b/radio/src/targets/Horus/board_horus.h
index 12e5ec6f8..867b293a9 100644
--- a/radio/src/targets/Horus/board_horus.h
+++ b/radio/src/targets/Horus/board_horus.h
@@ -248,6 +248,7 @@ void ledBlue(void);
 void lcdInit(void);
 void lcdRefresh(void);
 void lcdDrawSolidFilledRectDMA(uint16_t x, uint16_t y, uint16_t w, uint16_t h, uint16_t color);
+void lcdDrawBitmapDMA(uint16_t x, uint16_t y, uint16_t w, uint16_t h, const uint8_t * bitmap);
 void lcdStoreBackupBuffer(void);
 void lcdRestoreBackupBuffer(void);
 
diff --git a/radio/src/targets/Horus/lcd_driver.cpp b/radio/src/targets/Horus/lcd_driver.cpp
index 51483af09..ab73605e5 100644
--- a/radio/src/targets/Horus/lcd_driver.cpp
+++ b/radio/src/targets/Horus/lcd_driver.cpp
@@ -424,13 +424,13 @@ void lcdInit(void)
 void lcdDrawSolidFilledRectDMA(uint16_t x, uint16_t y, uint16_t w, uint16_t h, uint16_t color)
 {
   uint32_t addr = CurrentFrameBuffer + 2*(LCD_W*y + x);
-  uint16_t red = (0xF800 & color) >> 11;
-  uint16_t blue = 0x001F & color;
-  uint16_t green = (0x07E0 & color) >> 5;
+  uint8_t red = (0xF800 & color) >> 11;
+  uint8_t blue = 0x001F & color;
+  uint8_t green = (0x07E0 & color) >> 5;
 
-  /* configure DMA2D */
-  DMA2D_InitTypeDef DMA2D_InitStruct;
   DMA2D_DeInit();
+
+  DMA2D_InitTypeDef DMA2D_InitStruct;
   DMA2D_InitStruct.DMA2D_Mode = DMA2D_R2M;
   DMA2D_InitStruct.DMA2D_CMode = DMA2D_RGB565;
   DMA2D_InitStruct.DMA2D_OutputGreen = green;
@@ -450,18 +450,84 @@ void lcdDrawSolidFilledRectDMA(uint16_t x, uint16_t y, uint16_t w, uint16_t h, u
   while (DMA2D_GetFlagStatus(DMA2D_FLAG_TC) == RESET);
 }
 
+void lcdDrawBitmapDMA(uint16_t x, uint16_t y, uint16_t w, uint16_t h, const uint8_t * bitmap)
+{
+  uint32_t addr = CurrentFrameBuffer + 2*(LCD_W*y + x);
+
+  DMA2D_DeInit();
+
+  DMA2D_InitTypeDef DMA2D_InitStruct;
+  DMA2D_InitStruct.DMA2D_Mode = DMA2D_M2M;
+  DMA2D_InitStruct.DMA2D_CMode = DMA2D_RGB565;
+  DMA2D_InitStruct.DMA2D_OutputMemoryAdd = addr;
+  DMA2D_InitStruct.DMA2D_OutputGreen = 0;
+  DMA2D_InitStruct.DMA2D_OutputBlue = 0;
+  DMA2D_InitStruct.DMA2D_OutputRed = 0;
+  DMA2D_InitStruct.DMA2D_OutputAlpha = 0;
+  DMA2D_InitStruct.DMA2D_OutputOffset = (LCD_W - w);
+  DMA2D_InitStruct.DMA2D_NumberOfLine = h;
+  DMA2D_InitStruct.DMA2D_PixelPerLine = w;
+  DMA2D_Init(&DMA2D_InitStruct);
+
+  DMA2D_FG_InitTypeDef DMA2D_FG_InitStruct;
+  DMA2D_FG_StructInit(&DMA2D_FG_InitStruct);
+  DMA2D_FG_InitStruct.DMA2D_FGMA = CONVERT_PTR_UINT(bitmap);
+  DMA2D_FG_InitStruct.DMA2D_FGO = 0;
+  DMA2D_FG_InitStruct.DMA2D_FGCM = CM_RGB565;
+  DMA2D_FG_InitStruct.DMA2D_FGPFC_ALPHA_MODE = NO_MODIF_ALPHA_VALUE;
+  DMA2D_FG_InitStruct.DMA2D_FGPFC_ALPHA_VALUE = 0;
+  DMA2D_FGConfig(&DMA2D_FG_InitStruct);
+
+  /* Start Transfer */
+  DMA2D_StartTransfer();
+
+  /* Wait for CTC Flag activation */
+  while (DMA2D_GetFlagStatus(DMA2D_FLAG_TC) == RESET);
+}
+
+void DMAcopy(void * src, void * dest, int len)
+{
+  DMA2D_DeInit();
+
+    DMA2D_InitTypeDef DMA2D_InitStruct;
+    DMA2D_InitStruct.DMA2D_Mode = DMA2D_M2M;
+    DMA2D_InitStruct.DMA2D_CMode = DMA2D_RGB565;
+    DMA2D_InitStruct.DMA2D_OutputMemoryAdd = CONVERT_PTR_UINT(dest);
+    DMA2D_InitStruct.DMA2D_OutputGreen = 0;
+    DMA2D_InitStruct.DMA2D_OutputBlue = 0;
+    DMA2D_InitStruct.DMA2D_OutputRed = 0;
+    DMA2D_InitStruct.DMA2D_OutputAlpha = 0;
+    DMA2D_InitStruct.DMA2D_OutputOffset = 0;
+    DMA2D_InitStruct.DMA2D_NumberOfLine = LCD_H;
+    DMA2D_InitStruct.DMA2D_PixelPerLine = LCD_W;
+    DMA2D_Init(&DMA2D_InitStruct);
+
+    DMA2D_FG_InitTypeDef DMA2D_FG_InitStruct;
+    DMA2D_FG_StructInit(&DMA2D_FG_InitStruct);
+    DMA2D_FG_InitStruct.DMA2D_FGMA = CONVERT_PTR_UINT(src);
+    DMA2D_FG_InitStruct.DMA2D_FGO = 0;
+    DMA2D_FG_InitStruct.DMA2D_FGCM = CM_RGB565;
+    DMA2D_FG_InitStruct.DMA2D_FGPFC_ALPHA_MODE = NO_MODIF_ALPHA_VALUE;
+    DMA2D_FG_InitStruct.DMA2D_FGPFC_ALPHA_VALUE = 0;
+    DMA2D_FGConfig(&DMA2D_FG_InitStruct);
+
+    /* Start Transfer */
+    DMA2D_StartTransfer();
+
+    /* Wait for CTC Flag activation */
+    while (DMA2D_GetFlagStatus(DMA2D_FLAG_TC) == RESET);
+}
+
 void lcdStoreBackupBuffer()
 {
-  for (uint16_t * src = (uint16_t *)CurrentFrameBuffer, * dest = (uint16_t *)LCD_BACKUP_FRAME_BUFFER; src < (uint16_t *)(CurrentFrameBuffer+DISPLAY_BUFFER_SIZE); src++, dest++) {
-    *dest = *src;
-  }
+  uint16_t * src = (uint16_t *)CurrentFrameBuffer, * dest = (uint16_t *)LCD_BACKUP_FRAME_BUFFER;
+  DMAcopy(src, dest, DISPLAY_BUFFER_SIZE);
 }
 
 void lcdRestoreBackupBuffer()
 {
-  for (uint16_t * dest = (uint16_t *)CurrentFrameBuffer, * src = (uint16_t *)LCD_BACKUP_FRAME_BUFFER; dest < (uint16_t *)(CurrentFrameBuffer+DISPLAY_BUFFER_SIZE); src++, dest++) {
-    *dest = *src;
-  }
+  uint16_t * dest = (uint16_t *)CurrentFrameBuffer, * src = (uint16_t *)LCD_BACKUP_FRAME_BUFFER;
+  DMAcopy(src, dest, DISPLAY_BUFFER_SIZE);
 }
 
 void lcdRefresh()
diff --git a/radio/util/img2lbm.py b/radio/util/img2lbm.py
index 7d8a152c2..e02ac7a25 100755
--- a/radio/util/img2lbm.py
+++ b/radio/util/img2lbm.py
@@ -51,7 +51,8 @@ elif what == "5/6/5/8":
         for x in range(width):
             pixel = image.pixel(x, y)
             val = ((Qt.qRed(pixel) >> 3) << 11) + ((Qt.qGreen(pixel) >> 2) << 5) + ((Qt.qBlue(pixel) >> 3) << 0)
-            f.write("%d,%d,%d," % (val%256, val/256, Qt.qAlpha(pixel) >> 4))
+            # f.write("%d,%d,%d," % (val%256, val/256, Qt.qAlpha(pixel) >> 4))
+            f.write("%d,%d," % (val%256, val/256))
         f.write("\n")
 elif what == "4bits":
     colors = []