Arduino.ru

код контроллера по даташиту должен лежать в 96 регистре и равен 1710.

хотя судя по по 10-12 регистрам у тебя читается разрешение экрана 240х400.

В общем геморно все это. Пробуй инициализацию от этого контроллера.

Либо пиши свой скетч для чтения регистров контроллера в 8 битном режиме.

Это я в курсе. Но он там не "лежит".

Про это тоже в курсе. Если не секрет как это вычисляется по коду в логе?

Почему геморно? Инит пробывал - глухо. Читалка 5.2 зажигала экран белым цветом только.

Они уже написаны до этого. Если  точно знать какой контроллер стоит (могут быть разные варианты), многие вопросы отпали бы.

0F = 240  0190 = 400 похоже на разрешение стекла.

тогда бы числа и по другой координате рядом встретилось
240   239   00 EF
320   319   01 3F
360   359   01 67
400   399   01 8F
432   431   01 AF
480   479   01 DF
640   639   02 7F
800   799   03 1F

еще один из вариантов , принудительно повыбиратьь иниты в библиотеках UTFT, adafruit , adafruit LG4535 , .... MCUfriend_kvb . 
в UTFT и так вручную выбирать надо, предварительно в memorysaver.h закоментить все disable (для ардуины меги памяти хватит на все активированные иниты) , пробовать и старые и новые версии (в новых вырезана поддержка уже старых и редких контроллерв)

// попробуйте в читалке с поста #comment-410547   увеличить цикл с 255 до 600 , лог можно не выкладывать , просто посмотрите если что там дальше интересного , к примеру в регистрах около регистров 0x0200  ... 0x0213 

что-то пока сомневаюсь что там UPD161710 , уж много чего не сходится.

По даташиту в 10 и 11 регистре лежат maxX и maxY. 

Думаю нужно поискать готовый инит от контроллера, а не самому по даташиту

писать.

В MCUFRIEND_kbv есть UPD161704. Он правда 240х320. Но вдруг.

Сегодня не могу уже посмотреть, только завтра вечером. Ткните мне в каком файле он в с писке, а то я с ардуино пока на ВЫ.

Есть версия что там может стоять контроллер D54E4PA7551, но на него не могу найти даташит. Да и в читалках ничего похожего нет.

скачал прошивку на телефон. UPD161710 там упоминается. А рядом Toshiba LS030B. Что это не нашел.

Возможно тоже контроллер дисплея.

croc19 , можете глянуть прошивку LG gm360 i ? Что там за контроллер . Нашел у себя такой дисплей . по фоткам в инете вроде похожи , мож и взаимозаменяемые . Только подпаять провода не легко будет , к такому мелкому разьему. Валерон , покажите фотку как вы подпаяли . У gm360i прямоугольный разъем с мелким шагом.

здесь https://radiokot.ru/forum/viewtopic.php?f=61&t=44185&start=1100 у кого-то получилось запустить LS030B3UX05 с чипом uPD161710 и D54E4PA7551 на 16бит , на 8бит проблемы с цветом (где-то тож в теме выкладывал подобный случай)

///  в Service Manual LG GM360i 

LCD LS030B3UX05    SHARP     8bit access 2 time transmission 

дисплей тож 16бит , подключен по 8бит 
В гугле  за LS030B3UX05 находится D54E4PA7551   ,
контроллер MagnaChip D54E4PA7551 , типа есть в библиотеках 
SEGGER    от EmWIN  . https://github.com/Arie001/cortex-m3-applications.ssdglcddriver/blob/master/LCDConf.c 
и у Micrium  https://www.micrium.com/rtos/gui/

Даташиты находится , но не скачиваются 
http://www.panelook.com/LS030B3UX05_SHARP_3.0_LCM_overview_18719.html
http://www.2ic.cc/datasheet/pdf/D54E4PA7551.html  
https://datasheet.datasheetarchive.com/originals/library/Datasheets-SW13/DSASW00248681.pdf (рекламка походу)

вот файлы из библиотеки Segger: (искать в них  D54E4PA7551 и 66706 )
https://arm-stm.blogspot.com/2017/04/guidrvcompactcolor16c-h.html

вроде бы сам инит init code D54E4PA7551
http://read.pudn.com/downloads119/sourcecode/embed/504841/Sample/Tutorial/MULTILAYER_ScreenRotationS/LCDConf.h__.htm

www.pudn.com > emwintrial_v410_16bpp.zip > LCDConf.h, change:2007-05-10,size:10558b

 
  

/********************************************************************* 
*                SEGGER MICROCONTROLLER SYSTEME GmbH                 * 
*        Solutions for real time microcontroller applications        * 
********************************************************************** 
*                                                                    * 
*        (c) 1996 - 2007  SEGGER Microcontroller Systeme GmbH        * 
*                                                                    * 
*        Internet: www.segger.com    Support:  support@segger.com    * 
*                                                                    * 
********************************************************************** 
 
** emWin V4.10 - Graphical user interface for embedded applications ** 
emWin is protected by international copyright laws.   Knowledge of the 
source code may not be used to write a similar product.  This file may 
only be used in accordance with a license and should not be re- 
distributed in any way. We appreciate your understanding and fairness. 
---------------------------------------------------------------------- 
File        : LCDConf.h 
Purpose     : sAMPLE configuration file 
---------------------------------------------------------------------- 
*/ 
 
#ifndef LCDCONF_H 
#define LCDCONF_H 
 
#define LCD_ALLOW_NON_OPTIMIZED_MODE 1 
 
/********************************************************************* 
* 
*       Equal for all layers 
*/ 
#define _CONTROLLER          66706 
#define _BITSPERPIXEL           16 
#define _SWAP_RB                 1 
#define _XSIZE                 240 
#define _YSIZE                 400 
 
/********************************************************************* 
* 
*       Layer 0 
*/ 
#define LCD_CONTROLLER_0          _CONTROLLER 
#define LCD_BITSPERPIXEL_0        _BITSPERPIXEL 
#define LCD_SWAP_RB_0             _SWAP_RB 
#define LCD_XSIZE_0               _XSIZE 
#define LCD_YSIZE_0               _YSIZE 
#define LCD_MIRROR_X_0           1 
#define LCD_MIRROR_Y_0           0 
#define LCD_SWAP_XY_0            0 
 
/********************************************************************* 
* 
*       Layer 1 
*/ 
#define LCD_CONTROLLER_1          _CONTROLLER 
#define LCD_BITSPERPIXEL_1        _BITSPERPIXEL 
#define LCD_SWAP_RB_1             _SWAP_RB 
#define LCD_XSIZE_1               _YSIZE 
#define LCD_YSIZE_1               _XSIZE 
#define LCD_MIRROR_X_1           0 
#define LCD_MIRROR_Y_1           0 
#define LCD_SWAP_XY_1            1 
 
/********************************************************************* 
* 
*       Layer 2 
*/ 
#define LCD_CONTROLLER_2          _CONTROLLER 
#define LCD_BITSPERPIXEL_2        _BITSPERPIXEL 
#define LCD_SWAP_RB_2             _SWAP_RB 
#define LCD_XSIZE_2               _XSIZE 
#define LCD_YSIZE_2               _YSIZE 
#define LCD_MIRROR_X_2           0 
#define LCD_MIRROR_Y_2           1 
#define LCD_SWAP_XY_2            0 
 
/********************************************************************* 
* 
*       Layer 3 
*/ 
#define LCD_CONTROLLER_3          _CONTROLLER 
#define LCD_BITSPERPIXEL_3        _BITSPERPIXEL 
#define LCD_SWAP_RB_3             _SWAP_RB 
#define LCD_XSIZE_3               _YSIZE 
#define LCD_YSIZE_3               _XSIZE 
#define LCD_MIRROR_X_3           1 
#define LCD_MIRROR_Y_3           1 
#define LCD_SWAP_XY_3            1 
 
/********************************************************************* 
* 
*       Prototypes of interface routines 
*/ 
void LCD_X_Write01(char c); 
void LCD_X_Write00(char c); 
void LCD_X_WriteM01(char * pData, int NumBytes); 
void LCD_X_WriteM00(char * pData, int NumBytes); 
char LCD_X_Read00(void); 
char LCD_X_Read01(void); 
void LCD_X_ReadM01 (char * pData, int NumBytes); 
 
/********************************************************************* 
* 
*       Use the same interface routines for all layers 
*/ 
#define LCD_WRITE_A0_0(Byte)            LCD_X_Write00(Byte) 
#define LCD_WRITE_A1_0(Byte)            LCD_X_Write01(Byte) 
#define LCD_WRITEM_A0_0(Byte, NumBytes) LCD_X_WriteM00(Byte, NumBytes) 
#define LCD_WRITEM_A1_0(Byte, NumBytes) LCD_X_WriteM01(Byte, NumBytes) 
#define LCD_READ_A0_0(Byte)             Byte = LCD_X_Read00() 
#define LCD_READ_A1_0(Byte)             Byte = LCD_X_Read01() 
#define LCD_READM_A1_0(Byte, NumBytes)  LCD_X_ReadM01(Byte, NumBytes) 
 
#define LCD_WRITE_A0_1(Byte)            LCD_X_Write00(Byte) 
#define LCD_WRITE_A1_1(Byte)            LCD_X_Write01(Byte) 
#define LCD_WRITEM_A0_1(Byte, NumBytes) LCD_X_WriteM00(Byte, NumBytes) 
#define LCD_WRITEM_A1_1(Byte, NumBytes) LCD_X_WriteM01(Byte, NumBytes) 
#define LCD_READ_A0_1(Byte)             Byte = LCD_X_Read00() 
#define LCD_READ_A1_1(Byte)             Byte = LCD_X_Read01() 
#define LCD_READM_A1_1(Byte, NumBytes)  LCD_X_ReadM01(Byte, NumBytes) 
 
#define LCD_WRITE_A0_2(Byte)            LCD_X_Write00(Byte) 
#define LCD_WRITE_A1_2(Byte)            LCD_X_Write01(Byte) 
#define LCD_WRITEM_A0_2(Byte, NumBytes) LCD_X_WriteM00(Byte, NumBytes) 
#define LCD_WRITEM_A1_2(Byte, NumBytes) LCD_X_WriteM01(Byte, NumBytes) 
#define LCD_READ_A0_2(Byte)             Byte = LCD_X_Read00() 
#define LCD_READ_A1_2(Byte)             Byte = LCD_X_Read01() 
#define LCD_READM_A1_2(Byte, NumBytes)  LCD_X_ReadM01(Byte, NumBytes) 
 
#define LCD_WRITE_A0_3(Byte)            LCD_X_Write00(Byte) 
#define LCD_WRITE_A1_3(Byte)            LCD_X_Write01(Byte) 
#define LCD_WRITEM_A0_3(Byte, NumBytes) LCD_X_WriteM00(Byte, NumBytes) 
#define LCD_WRITEM_A1_3(Byte, NumBytes) LCD_X_WriteM01(Byte, NumBytes) 
#define LCD_READ_A0_3(Byte)             Byte = LCD_X_Read00() 
#define LCD_READ_A1_3(Byte)             Byte = LCD_X_Read01() 
#define LCD_READM_A1_3(Byte, NumBytes)  LCD_X_ReadM01(Byte, NumBytes) 
 
/********************************************************************* 
* 
*       Initialization 
*/ 
#define DELAY(Cnt) { volatile U32 i, j; j = Cnt << 8; for (i = 0; i < j; i++); } 
 
#define INIT_CONTROLLER() \ 
  DELAY(10);                                                                             \ 
  LCD_X_Init();                                                                          \ 
  DELAY(10);                                                                             \ 
  LCD_WRITE_A0(0xC0); LCD_WRITE_A1(0x00); /* Internal EEPROM */                          \ 
  LCD_WRITE_A0(0xC0); LCD_WRITE_A1(0x02); /* Internal EEPROM */                          \ 
  DELAY(10);                                                                             \ 
  LCD_WRITE_A0(0xC0); LCD_WRITE_A1(0x00); /* Internal EEPROM */                          \ 
  LCD_WRITE_A0(0x68); LCD_WRITE_A1(0x41); /* COM-pp */                                   \ 
  LCD_WRITE_A0(0x69); LCD_WRITE_A1(0x7D); /* COM-center */                               \ 
  LCD_WRITE_A0(0x01); LCD_WRITE_A1(0x02); /* 8bit 8/8 transfer */                        \ 
  LCD_WRITE_A0(0x08); LCD_WRITE_A1(0x00); /* Normally black */                           \ 
  LCD_WRITE_A0(0x10); LCD_WRITE_A1(0xF0); /* Panel X-size=240 */                         \ 
  LCD_WRITE_A0(0x11); LCD_WRITE_A1(0x90); /* Panel Y-size=400 */                         \ 
  LCD_WRITE_A0(0x12); LCD_WRITE_A1(0x01); /* Panel Y-size=400 */                         \ 
  LCD_WRITE_A0(0x1E); LCD_WRITE_A1(0x50); /* Number of vertical line=400 */              \ 
  LCD_WRITE_A0(0x1D); LCD_WRITE_A1(0x07); /* RAM write direction :landscape */           \ 
  LCD_WRITE_A0(0x1A); LCD_WRITE_A1(0xEF); /* RAM pointer X */                            \ 
  LCD_WRITE_A0(0x1B); LCD_WRITE_A1(0x8F); /* RAM pointer Y */                            \ 
  LCD_WRITE_A0(0x1C); LCD_WRITE_A1(0x01); /* RAM pointer Y */                            \ 
  LCD_WRITE_A0(0x30); LCD_WRITE_A1(0x81); /* Select the display-RAM data */              \ 
  LCD_WRITE_A0(0x33); LCD_WRITE_A1(0x02); /* Non-display data color */                   \ 
  LCD_WRITE_A0(0x42); LCD_WRITE_A1(0x70); /* Vertical front poach=112h */                \ 
  LCD_WRITE_A0(0x43); LCD_WRITE_A1(0x01); /* Vertical back poach=1h */                   \ 
  LCD_WRITE_A0(0x44); LCD_WRITE_A1(0x3F); /* H scan interval=96clock */                  \ 
  LCD_WRITE_A0(0x45); LCD_WRITE_A1(0x14); /* GSP start position=10clock */               \ 
  LCD_WRITE_A0(0x46); LCD_WRITE_A1(0x0F); /* GCK start position=15clock */               \ 
  LCD_WRITE_A0(0x48); LCD_WRITE_A1(0x03); /* COM inversion position=3clock */            \ 
  LCD_WRITE_A0(0x4A); LCD_WRITE_A1(0x01); /* Signal setting */                           \ 
  LCD_WRITE_A0(0x4B); LCD_WRITE_A1(0xA8); /* SSD setting */                              \ 
  LCD_WRITE_A0(0x4C); LCD_WRITE_A1(0x12); /* ASW start position=18clock */               \ 
  LCD_WRITE_A0(0x5A); LCD_WRITE_A1(0x00); /* Battery pull-out detection off */           \ 
  LCD_WRITE_A0(0x62); LCD_WRITE_A1(0x52); /* ASW width10, interval2clock */              \ 
  LCD_WRITE_A0(0x65); LCD_WRITE_A1(0x02); /* AMP bias current setting */                 \ 
  LCD_WRITE_A0(0x66); LCD_WRITE_A1(0x06); /* VGM5.2V */                                  \ 
  LCD_WRITE_A0(0x6A); LCD_WRITE_A1(0x02); /* VCOM output */                              \ 
  LCD_WRITE_A0(0x81); LCD_WRITE_A1(0x44); /* VR,VS boost clock setting */                \ 
  LCD_WRITE_A0(0x82); LCD_WRITE_A1(0x2D); /* DCK,DCKB timing setting */                  \ 
  LCD_WRITE_A0(0x83); LCD_WRITE_A1(0x25); /* DCDC Dual, AVR,5.2V,DCDC drivability=min */ \ 
  LCD_WRITE_A0(0x84); LCD_WRITE_A1(0x17); /* VR setting */                               \ 
  LCD_WRITE_A0(0x85); LCD_WRITE_A1(0x27); /* DCDC Dual, AVS5.4V,DCDC drivability=min */  \ 
  LCD_WRITE_A0(0x86); LCD_WRITE_A1(0x17); /* VS setting */                               \ 
  LCD_WRITE_A0(0x90); LCD_WRITE_A1(0x25); /* Auto ON timing setting */                   \ 
  LCD_WRITE_A0(0x91); LCD_WRITE_A1(0x05); /* Auto ON/OFF setting(1V) */                  \ 
  LCD_WRITE_A0(0x92); LCD_WRITE_A1(0x15); /* Auto OFF timing setting */                  \ 
  LCD_WRITE_A0(0x31); LCD_WRITE_A1(0x01); /* VAL */                                      \ 
  LCD_WRITE_A0(0x19); LCD_WRITE_A1(0x01); /* Window access mode */                       \ 
  LCD_WRITE_A0(0x3E); LCD_WRITE_A1(0x01); /* Auto ON sequence */                         \ 
  DELAY(120) 
 
#define LCD_INIT_CONTROLLER_0()   INIT_CONTROLLER() 
#define LCD_INIT_CONTROLLER_1()   INIT_CONTROLLER() 
#define LCD_INIT_CONTROLLER_2()   INIT_CONTROLLER() 
#define LCD_INIT_CONTROLLER_3()   INIT_CONTROLLER() 
 
#endif /* LCDCONF_H */ 
 

в верхнем файле либы можно подсмотреть через какие регистры и как осуществляется рисование:
рисуется через регистры  0x1A  0x1B  0x1C  , запись - 0x03
 

#elif (LCD_CONTROLLER == 66706)    /* MagnaChip D54E4PA7551 */
  /* Register definitions */
  #define REG_INC_MODE      0x1D   /* - Entry mode */                        
  #define REG_SET_HRAM_S    0x13   /* - Horizontal start address */          
  #define REG_SET_HRAM_E    0x16   /* - Horizontal end   address */          
  #define REG_SET_VRAM_S_LB 0x14   /* - Vertical   start address, low  byte */
  #define REG_SET_VRAM_S_HB 0x15   /* - Vertical   start address, high byte */
  #define REG_SET_VRAM_E_LB 0x17   /* - Vertical   end   address, low  byte */
  #define REG_SET_VRAM_E_HB 0x18   /* - Vertical   end   address, high byte */
  #define REG_RAM_ADDR_H    0x1A   /* - Horizontal RAM address */            
  #define REG_RAM_ADDR_V_LB 0x1B   /* - Vertical   RAM address, low  byte */ 
  #define REG_RAM_ADDR_V_HB 0x1C   /* - Vertical   RAM address, high byte */ 
  #define REG_RAM_ACCESS    0x03   /* - RAM access mode */ 

вот так: (можно поискать  аналогичные в UTFT , adafruit , MCUfriend)
 

/*********************************************************************
*
*       _SetPhysRAMAddr and _SetRect for the following display controllers:
*
*       - Sharp LCY-A06003
*       - MagnaChip D54E4PA7551
*/
/*********************************************************************
*
*       _SetPhysRAMAddr
*/
#elif (LCD_CONTROLLER == 66704) || /* Sharp LCY-A06003 */ \
      (LCD_CONTROLLER == 66706)    /* MagnaChip D54E4PA7551 */
static void _SetPhysRAMAddr(int x, int y) {
  x -= _x0;
  y -= _y0;
  LCD_WRITE_A0(REG_RAM_ADDR_H);
  LCD_WRITE_A1(x);
  LCD_WRITE_A0(REG_RAM_ADDR_V_LB);
  LCD_WRITE_A1(y & 0xff);
  LCD_WRITE_A0(REG_RAM_ADDR_V_HB);
  LCD_WRITE_A1(y >> 8);
  LCD_WRITE_A0(REG_RAM_ACCESS);
}

описалово на русском работы либы
 https://arm-stm.blogspot.com/2014/09/     
https://arm-stm.blogspot.com/2014/09/emwin-display-driver.html 
и на англ. 
http://read.pudn.com/downloads153/ebook/676859/UM030021_emWin.pdf

 // пробовал поискать в инете у кого еще Horizontal RAM address 0x1A  - не особо .  
возможно надо подставлять у распростаненных контроллеров вместо 0x2A  0x2B  0x2C

Slider, спасибо за предоставленную инфу, многое уже видел. Т.к. я не программист, только как говорится балуюсь (опыта еще мало) я не смог для себя там что-то найти полезного. Сейчас уже вижу что-то есть.

У меня дисп от GS-290, но тоже такая хрень. Разъем я отпаял с мамки сотика и делал переходную плату. На плату заодно поставил контроллер подсветки, LDO на 2.9В и всякую мелочь. Фотку показать сейчас не могу - на работе. Если очень интересно то скину после 19.30.

LG gm360 i все тоже самое, что и на GS-290. D54 в прошивках не находится.

Начало прошивок один в один.

Похоже контроллер PD161710.  

Из форума на радиокоте: "...LS030B3UX05 с чипом uPD161710, название дисплея у меня на самой железной крышке, 3-й вывод соединен с землей...". На крышке дисплея надпись соответствует?

Так и есть. Надпись есть какая-то, сейчас не помню. Вечером посмотрю.

У меня на крышке надпись  033h026829aqh. Инет по этому номеру молчит.

Тогда строчкой выше из того-же форума: "...IM300IBN1A с чипом R61509, название дисплея на шлейфе под железной крышкой, 3-й вывод соединен с шиной питания..." Есть возможность заглянуть под крышку?

Я уже заглядывал под крышку. На шлейфе какой-то номер и интернет по нему тоже молчит. 3-вывод соединен с землей железно! Чип R61509 отпадает.

Соглано определению выводов на фото  выходы располагаются так:

Контроллер оказался D54E4PA7551. Инит прошел тот, который дал Slider. Спасибо ему. На экране появился шум, а вот залить его каким-нибудь цветом у меня не получается.

#elif (LCD_CONTROLLER == 66706)    /* MagnaChip D54E4PA7551 */

  /* Register definitions */

  #define REG_INC_MODE      0x1D   /* - Entry mode */                        

  #define REG_SET_HRAM_S    0x13   /* - Horizontal start address */          

  #define REG_SET_HRAM_E    0x16   /* - Horizontal end   address */          

  #define REG_SET_VRAM_S_LB 0x14   /* - Vertical   start address, low  byte */

  #define REG_SET_VRAM_S_HB 0x15   /* - Vertical   start address, high byte */

  #define REG_SET_VRAM_E_LB 0x17   /* - Vertical   end   address, low  byte */

  #define REG_SET_VRAM_E_HB 0x18   /* - Vertical   end   address, high byte */

  #define REG_RAM_ADDR_H    0x1A   /* - Horizontal RAM address */            

  #define REG_RAM_ADDR_V_LB 0x1B   /* - Vertical   RAM address, low  byte */ 

  #define REG_RAM_ADDR_V_HB 0x1C   /* - Vertical   RAM address, high byte */ 

  #define REG_RAM_ACCESS    0x03   /* - RAM access mode */        

Спасибо croc19, это я видел из предыдущего поста. Так как опыта в програмировании у меня мало, то пока не получается. Вроде алгоритм рисовании линии понимаю, но в какой регистр что запмсывать пока не въезжаю. Если не трудно подскажи.

сначала закрасить прямоугольник.  

Попробуй так. Запиши последовательно в регистры

сом 0x1а 

data 0x0

com 0x1b

data 0x0

com 0x1c

data 0x0 

com 0x13

data 0x0

com 0x16

data 0x66

com 0x14

data 0x0

com 0x15

data 0x0

com 0x17

data 0x63

com 0x18

data 0x0

com 0x03

цикл на 10000 повторений внутри которого пишешь

data 0x0

data 0xf8

На экране должен появиться красный квадрат 100х100 точек.

croc19 спасибо, получилось.

Уважаемые, подскажите кто в курсе, почему при заливке диспа одним цветом появляются другие цвета? Заливаю красным, появляется синия полоса во весь экран. Может быть в одном месте, может быть в нескольких местах, может быть на половину экрана. С другими цветами также. только с черным нормально.

Выложи программу и фото. 

Кто-нибудь работал с либой GLCD или имел дело с монохромными дисплеями на SED1520 ?

Отзовитесь пожалуйста .

/*********************************************************************
*
* LCD_ID_Reader
*
* This sketch is meant only to attempt to read the driver ID code
* from inexpensive touchscreen LCDs found on eBay without needing to
* load any additional libraries.  The hope is to identify the most 
* common varieties and choose the best library for the screen you have.
*
* This has been successfully tested so far on 992X and 778X variety
* screens.
*
* Usage: 
*
* Compile the sketch and run it on your board with the screen
* attached.  In the serial monitor, you should see a message containing
* the driver code.  The tricky thing is that if it does not work, the
* results may be undetermined.  However, if we can compile a list,
* the difference between working and not may become more evident.
*
* Please visit http://misc.ws/lcd_information for more information.
*
* Version 1.2 - January 29th, 2015
* 
*********************************************************************/



/*********************************************************************
*
* PIN ASSIGNMENTS
*
* You can alter the pin assignments to reflect any configuration you
* wish.  I've provided the default shield configuration, which works
* on both the Arduino UNO and Mega 2560.
* 
*********************************************************************/
//-- Arduino UNO or Mega 2560 Plugged as shield
#define LCD_RST 41//4
#define LCD_CS 40//A3
#define LCD_RS 38//A2
#define LCD_WR 39//A1
#define LCD_RD 45//A0

#define LCD_D0 22//8
#define LCD_D1 23//9
#define LCD_D2 24//2
#define LCD_D3 25//3
#define LCD_D4 26//4
#define LCD_D5 27//
#define LCD_D6 28//6
#define LCD_D7 29//7


#define BLACK   0x0000
#define BLUE    0x001F
#define RED     0xF800
#define GREEN   0x07E0
#define CYAN    0x07FF
#define MAGENTA 0xF81F
#define YELLOW  0xFFE0
#define WHITE   0xFFFF

/*********************************************************************
*
* Attempt to initialize and reset LCD, then read its Driver Code
* at register index 0.
* 
*********************************************************************/
void setup() {
  
  char hexString[7];
  uint16_t id;
  
  Serial.begin(9600);
  Serial.println("Initializing LCD...");
  lcdInit();
  delay(100);

  lcdReset();
 
  delay(500);

  Serial.print("Reading ID...");
  id = lcdReadID();
  sprintf(hexString, "0x%0.4X", id); 
  Serial.println( hexString );

lcdRegisterOther(); // инит
lcd_clr(RED);  // заливка всего экрана
 //print_all_regs();
}


void print_all_regs() {
  
  char str[600];
  uint16_t i, val;

  for(i=0; i < 256; i++ )
  {
    delay(20);
    val = lcdReadRegister(i);
    sprintf(str, "Register 0x%0.4X : 0x%0.4X", i, val);
    Serial.println( str );
  }  
}

void loop() {
 lcdFillScreen_1(MAGENTA);
 delay(500);
 lcdFillScreen_1(GREEN);
 delay(500);
}

/*********************************************************************
*
*   LCD Functions - Inefficient but should be good enough 
*                   to read the ID.
*
*********************************************************************/


void lcdRegisterOther() {
  Serial.println("Loading LCD registers...");
lcdWriteRegister(0xC0, 0x00); // 
lcdWriteRegister(0xC0, 0x02);
delay(10);
lcdWriteRegister(0xC0, 0x00); //
lcdWriteRegister(0x68, 0x41);// 
lcdWriteRegister(0x69, 0x7D);
lcdWriteRegister(0x01, 0x02);
lcdWriteRegister(0x08, 0x00); // черный
lcdWriteRegister(0x10, 0xF0);
lcdWriteRegister(0x11, 0x90);
lcdWriteRegister(0x12, 0x01);
lcdWriteRegister(0x1E, 0x50);
lcdWriteRegister(0x1D, 0x07);
lcdWriteRegister(0x1A, 0xEF);
lcdWriteRegister(0x1B, 0x8E);
lcdWriteRegister(0x1C, 0x01);
lcdWriteRegister(0x30, 0x81);
lcdWriteRegister(0x33, 0x02);
lcdWriteRegister(0x42, 0x70);
lcdWriteRegister(0x43, 0x01);
lcdWriteRegister(0x44, 0x3F);
lcdWriteRegister(0x45, 0x14);
lcdWriteRegister(0x46, 0x0F);
lcdWriteRegister(0x4A, 0x01);
lcdWriteRegister(0x4B, 0xA8);
lcdWriteRegister(0x4C, 0x12);
lcdWriteRegister(0x5A, 0x00);
lcdWriteRegister(0x62, 0x52);
lcdWriteRegister(0x65, 0x02);
lcdWriteRegister(0x66, 0x06);
lcdWriteRegister(0x6A, 0x02);
lcdWriteRegister(0x81, 0x44);
lcdWriteRegister(0x82, 0x2D);
lcdWriteRegister(0x83, 0x25);
lcdWriteRegister(0x84, 0x17);
lcdWriteRegister(0x85, 0x27);
lcdWriteRegister(0x86, 0x17);
lcdWriteRegister(0x90, 0x25);
lcdWriteRegister(0x91, 0x05);
lcdWriteRegister(0x92, 0x15);
lcdWriteRegister(0x31, 0x01);
lcdWriteRegister(0x19, 0x01);
lcdWriteRegister(0x3E, 0x01);
delay(120);
}

  void lcdInit() {
  pinMode(LCD_CS, OUTPUT);
  digitalWrite(LCD_CS, HIGH);
  pinMode(LCD_RS, OUTPUT);
  digitalWrite(LCD_RS, HIGH);
  pinMode(LCD_WR, OUTPUT);
  digitalWrite(LCD_WR, HIGH);
  pinMode(LCD_RD, OUTPUT);
  digitalWrite(LCD_RD, HIGH);
  pinMode(LCD_RST, OUTPUT);
  digitalWrite(LCD_RST, HIGH);  
}

void lcdReset() {
  digitalWrite(LCD_RST, LOW);
  delay(50); 
  digitalWrite(LCD_RST, HIGH);
 
  delay(50); 
//lcdWriteRegister(0x00,0x01);

//delay(500);
   
}

void lcdWrite8(uint8_t data) {// было uint16_t
  digitalWrite(LCD_D0, data & 1);
  digitalWrite(LCD_D1, (data & 2) >> 1);
  digitalWrite(LCD_D2, (data & 4) >> 2);
  digitalWrite(LCD_D3, (data & 8) >> 3);
  digitalWrite(LCD_D4, (data & 16) >> 4); 
  digitalWrite(LCD_D5, (data & 32) >> 5);
  digitalWrite(LCD_D6, (data & 64) >> 6);
  digitalWrite(LCD_D7, (data & 128) >> 7);  
}

uint16_t lcdRead8() {
  uint8_t result = digitalRead(LCD_D7);// было uint16_t
  result <<= 1;
  result |= digitalRead(LCD_D6);
  result <<= 1;
  result |= digitalRead(LCD_D5);
  result <<= 1; 
  result |= digitalRead(LCD_D4); 
  result <<= 1;
  result |= digitalRead(LCD_D3);
  result <<= 1;
  result |= digitalRead(LCD_D2); 
  result <<= 1;
  result |= digitalRead(LCD_D1);
  result <<= 1;
  result |= digitalRead(LCD_D0); 
  
  return result;
}

void lcdSetWriteDir() {
  pinMode(LCD_D0, OUTPUT);
  pinMode(LCD_D1, OUTPUT);
  pinMode(LCD_D2, OUTPUT);
  pinMode(LCD_D3, OUTPUT);  
  pinMode(LCD_D4, OUTPUT);  
  pinMode(LCD_D5, OUTPUT);
  pinMode(LCD_D6, OUTPUT);
  pinMode(LCD_D7, OUTPUT);  
}
void lcdSetReadDir() {
  pinMode(LCD_D0, INPUT);
  pinMode(LCD_D1, INPUT);
  pinMode(LCD_D2, INPUT);
  pinMode(LCD_D3, INPUT);  
  pinMode(LCD_D4, INPUT);  
  pinMode(LCD_D5, INPUT);
  pinMode(LCD_D6, INPUT);
  pinMode(LCD_D7, INPUT);    
}

void lcdWriteData(uint8_t data) {// было uint16_t
  
  lcdSetWriteDir();
 digitalWrite(LCD_CS, LOW);
  digitalWrite(LCD_RS, HIGH);
  digitalWrite(LCD_RD, HIGH);
  digitalWrite(LCD_WR, HIGH);
    
/*  lcdWrite8(data >> 8);
digitalWrite(LCD_WR, LOW);
  delayMicroseconds(10);
  digitalWrite(LCD_WR, HIGH);
 */
// delayMicroseconds(2);
 
  lcdWrite8(data);
  digitalWrite(LCD_WR, LOW);
  delayMicroseconds(2);
  digitalWrite(LCD_WR, HIGH);
  digitalWrite(LCD_CS, HIGH);  
}


void lcdWriteCommand(uint8_t command) {// было uint16_t
  lcdSetWriteDir(); 
  digitalWrite(LCD_CS, LOW);
  digitalWrite(LCD_RS, LOW);
  digitalWrite(LCD_RD, HIGH);
  digitalWrite(LCD_WR, HIGH);  
  
/*  lcdWrite8(command >> 8);
  digitalWrite(LCD_WR, LOW);
  delayMicroseconds(10);
  digitalWrite(LCD_WR, HIGH);
   delayMicroseconds(10);///////////////////////////
*/
  lcdWrite8(command);
  digitalWrite(LCD_WR, LOW);
 delayMicroseconds(2);
  digitalWrite(LCD_WR, HIGH);

  
  digitalWrite(LCD_CS, HIGH); 
 digitalWrite(LCD_RS, HIGH);/////////////// 
}


int lcdReadData() {
  uint8_t result;// было uint16_t
  lcdSetReadDir();

 
  digitalWrite(LCD_RS, HIGH);
  digitalWrite(LCD_RD, HIGH);
  digitalWrite(LCD_WR, HIGH);
   digitalWrite(LCD_CS, LOW);
  
 //digitalWrite(LCD_RD, LOW); 
 // result = lcdRead8() << 8; 
 // digitalWrite(LCD_RD, HIGH);
 //delayMicroseconds(10);
 
 digitalWrite(LCD_RD, LOW);
 
  result = lcdRead8(); // было result |= lcdRead8();
 delayMicroseconds(10);
  digitalWrite(LCD_CS, HIGH);
   digitalWrite(LCD_RD, HIGH);
  return result;
}


void lcdWriteRegister(uint8_t addr, uint8_t data){// было {uint16_t addr, uint16_t data}
  lcdWriteCommand(addr);
  lcdWriteData(data);
}

uint8_t lcdReadRegister(uint8_t reg) { // было uint16_t lcdReadRegister(uint16_t reg)
  lcdWriteCommand(reg);
  return lcdReadData();
}

/*uint16_t lcdReadID() {          
  uint16_t number;
  number = (lcdReadRegister(0)<< 8);
  delayMicroseconds(10);
   number |= lcdReadData();
  return number;
}
*/
uint16_t lcdReadID() { 
  return lcdReadRegister(0);
}

void lcd_clr(uint16_t color) { //заливка цветом
  
  Serial.println("Filling the screen...");
//lcdWriteRegister(0x1D, 0x07);  /* - Entry mode */ 
// lcdWriteRegister(0x1A, 0x00); /* - Horizontal RAM address */ 
//lcdWriteRegister(0x1B, 0x00); /* - Vertical   RAM address, low  byte */
//lcdWriteRegister(0x1C, 0x00); /* - Vertical   RAM address, high byte */
lcdWriteRegister(0x13, 0x00); /* - Horizontal start address */   
lcdWriteRegister(0x16, 0xEF); /* - Horizontal end   address F0 конец*/ 
lcdWriteRegister(0x14, 0x00); /* - Vertical   start address, low  byte */
lcdWriteRegister(0x15, 0x00); /* - Vertical   start address, high byte */
lcdWriteRegister(0x17, 0x8F); /* - Vertical   end   address, low  byte 90 конец*/
lcdWriteRegister(0x18, 0x01); /* - Vertical   end   address, high byte  01 конец*/   
 lcdWriteCommand (0x03);       /* - RAM access mode */


  uint32_t i = 400;
  i *=240;
do   {
lcdWriteData (color >> 8);
//delayMicroseconds(10);
lcdWriteData (color);
//delayMicroseconds(10);
    
 /*   lcdWrite8(color >> 8);
digitalWrite(LCD_WR, LOW);
    delayMicroseconds(10);
    digitalWrite(LCD_WR, HIGH); 

 
    lcdWrite8(color);
    digitalWrite(LCD_WR, LOW);
    delayMicroseconds(10);
    digitalWrite(LCD_WR, HIGH); 
 */  
  }while( i-- );
 
 // digitalWrite(LCD_CS, HIGH); 
  Serial.println("Done filling...");
  
}


void lcdFillScreen_1(uint16_t color){ //заливка квадрата
lcdWriteRegister(0x13, 0x50); /* - Horizontal start address */   
lcdWriteRegister(0x16, 0xAA); /* - Horizontal end   address F0 конец*/ 
lcdWriteRegister(0x14, 0x50); /* - Vertical   start address, low  byte */
lcdWriteRegister(0x15, 0x00); /* - Vertical   start address, high byte */
lcdWriteRegister(0x17, 0x50); /* - Vertical   end   address, low  byte 90 конец*/
lcdWriteRegister(0x18, 0x01); /* - Vertical   end   address, high byte  01 конец*/   
 lcdWriteCommand (0x03);       /* - RAM access mode */
 
 uint32_t i = 100;
  i *=240;
do   {
lcdWriteData (color >> 8);
//delayMicroseconds(10);
lcdWriteData (color);
//delayMicroseconds(10);
  }while( i-- );
}

фотка при заливе красным цветом

ZEL, попробуй библиотеку u8g2

Неужели хоть кто - то отозвался!!! Спасибо попробую.. гдето вроде уже скачана ...

Полное описание проблеммы здесь:

http://arduino.ru/forum/apparatnye-voprosy/arduino-i-displei-ot-sotikov-mobilnykh-telefonov?page=41#comment-411100

Валерон. 

Я не пишу для ардуины.  Поэтому почитай как пишутся скетчи. Там все доступно.

Теперь попробую описать примерный алгоритм. 

Сначала в SETUP обозначаешь, какие ноги как будут называться ( у тебя это в define) и в каком режиме будут работать --  pinMode(LCD_D0, OUTPUT);  В принципе все ноги на цифровой выход.

Далее инициализация дисплея. 

Дальше в LOOP .  Пишешь координаты прямоугольника в регистры. Если весь экран, то начало по Х=0, конец Х=239 ,

начало по Y=0, конец по Y=399. И команду 0х03 . Затем цикл на 240*400=96000 , внутри  которого пишешь

цвет ( это у тебя в программе есть ) .

Ну а дальше что душа пожелает.

Все подпрограммы с Read в урну, читать ничего не нужно. Контроллер ты знаешь.

Да, на будущее. Экран может работать в разных режимах. Развертка может быть слева направо и наоборот,

снизу вверх и наоборот. По вертикали или по горизонтали. цвет может выводиться в RGB или в BGR.  Все это задается в 

регистрах определенными битами. 

В какой режим устанавливает дисплей эта инициализация неизвестно. Без даташита не подскажу.

croc19 я тоже не пишу для ардуино и не планирую. Програмированием занимаюсь от случая к случаю. В даный момент я просто хочу понять алгоритм програмирования диспов. Да и ардуино досталась на халяву, вот решил заюзать первый попавшийся дисп. Я в основном работаю с пиками. Ладно это все лирика.

Алгоритм понял, буду пробывать, спасибо.

Ксати функция чтения не мешает. Этот скетч рабочий вариант, правленный для моего диспа.

Не мешает, это да. Но лишнее в программе не камильфо.

Можешь покопать библиотеку из которой инициализация. В ней может быть поворот экрана.

С выводом прямоугольников понятно. В них можно выводить и картинки.

А регистры 1А, 1В, 1С установка вывода в нужную стартовую точку.

croc19, разве у меня заливка не првильно релизована?

Мне кажется они устанавливают размер экрана.

Все правильно. Делеи можешь убрать. Дисплей гораздо быстрее, чем ардуина.

Просто у тебя в программе большая мешанина. А я не спец в скетчах. Я напрямую с АВР дружу.

Блин, заливка правильная. Почему же полосы появляются другого цвета. Даже когда квадрат рисую на фоне, тоже полосы другого цвета в квадрате появляются.

Лишнее убери и выложи прогу.

/*********************************************************************
*
* PIN ASSIGNMENTS
*
* You can alter the pin assignments to reflect any configuration you
* wish.  I've provided the default shield configuration, which works
* on both the Arduino UNO and Mega 2560.
* 
*********************************************************************/
//-- Arduino UNO or Mega 2560 Plugged as shield
#define LCD_RST 41//4
#define LCD_CS 40//A3
#define LCD_RS 38//A2
#define LCD_WR 39//A1
#define LCD_RD 45//A0

#define LCD_D0 22//8
#define LCD_D1 23//9
#define LCD_D2 24//2
#define LCD_D3 25//3
#define LCD_D4 26//4
#define LCD_D5 27//
#define LCD_D6 28//6
#define LCD_D7 29//7


#define BLACK   0x0000
#define BLUE    0x001F
#define RED     0xF800
#define GREEN   0x07E0
#define CYAN    0x07FF
#define MAGENTA 0xF81F
#define YELLOW  0xFFE0
#define WHITE   0xFFFF

/*********************************************************************
*
* Attempt to initialize and reset LCD, then read its Driver Code
* at register index 0.
* 
*********************************************************************/
void setup() {
  lcdInit();
  delay(100);
  lcdReset();
  delay(500);
  lcdRegisterOther(); // инит
}

void loop() {
  lcd_clr(RED);  // заливка всего экрана
  delay(500);
  lcd_clr(GREEN);
  delay(500);
}

void lcdRegisterOther() {
lcdWriteRegister(0xC0, 0x00);
lcdWriteRegister(0xC0, 0x02);
delay(10);
lcdWriteRegister(0xC0, 0x00);
lcdWriteRegister(0x68, 0x41);
lcdWriteRegister(0x69, 0x7D);
lcdWriteRegister(0x01, 0x02);
lcdWriteRegister(0x08, 0x00);
lcdWriteRegister(0x10, 0xF0);
lcdWriteRegister(0x11, 0x90);
lcdWriteRegister(0x12, 0x01);
lcdWriteRegister(0x1E, 0x50);
lcdWriteRegister(0x1D, 0x07);
lcdWriteRegister(0x1A, 0xEF);
lcdWriteRegister(0x1B, 0x8E);
lcdWriteRegister(0x1C, 0x01);
lcdWriteRegister(0x30, 0x81);
lcdWriteRegister(0x33, 0x02);
lcdWriteRegister(0x42, 0x70);
lcdWriteRegister(0x43, 0x01);
lcdWriteRegister(0x44, 0x3F);
lcdWriteRegister(0x45, 0x14);
lcdWriteRegister(0x46, 0x0F);
lcdWriteRegister(0x4A, 0x01);
lcdWriteRegister(0x4B, 0xA8);
lcdWriteRegister(0x4C, 0x12);
lcdWriteRegister(0x5A, 0x00);
lcdWriteRegister(0x62, 0x52);
lcdWriteRegister(0x65, 0x02);
lcdWriteRegister(0x66, 0x06);
lcdWriteRegister(0x6A, 0x02);
lcdWriteRegister(0x81, 0x44);
lcdWriteRegister(0x82, 0x2D);
lcdWriteRegister(0x83, 0x25);
lcdWriteRegister(0x84, 0x17);
lcdWriteRegister(0x85, 0x27);
lcdWriteRegister(0x86, 0x17);
lcdWriteRegister(0x90, 0x25);
lcdWriteRegister(0x91, 0x05);
lcdWriteRegister(0x92, 0x15);
lcdWriteRegister(0x31, 0x01);
lcdWriteRegister(0x19, 0x01);
lcdWriteRegister(0x3E, 0x01);
delay(120);
}

  void lcdInit() {
  pinMode(LCD_CS, OUTPUT);
  digitalWrite(LCD_CS, HIGH);
  pinMode(LCD_RS, OUTPUT);
  digitalWrite(LCD_RS, HIGH);
  pinMode(LCD_WR, OUTPUT);
  digitalWrite(LCD_WR, HIGH);
  pinMode(LCD_RD, OUTPUT);
  digitalWrite(LCD_RD, HIGH);
  pinMode(LCD_RST, OUTPUT);
  digitalWrite(LCD_RST, HIGH);  
}

void lcdReset() {
  digitalWrite(LCD_RST, LOW);
  delay(50); 
  digitalWrite(LCD_RST, HIGH);
  delay(50); 
}

void lcdWrite8(uint8_t data) {// было uint16_t
  digitalWrite(LCD_D0, data & 1);
  digitalWrite(LCD_D1, (data & 2) >> 1);
  digitalWrite(LCD_D2, (data & 4) >> 2);
  digitalWrite(LCD_D3, (data & 8) >> 3);
  digitalWrite(LCD_D4, (data & 16) >> 4); 
  digitalWrite(LCD_D5, (data & 32) >> 5);
  digitalWrite(LCD_D6, (data & 64) >> 6);
  digitalWrite(LCD_D7, (data & 128) >> 7);  
}

uint16_t lcdRead8() {
  uint8_t result = digitalRead(LCD_D7);// было uint16_t
  result <<= 1;
  result |= digitalRead(LCD_D6);
  result <<= 1;
  result |= digitalRead(LCD_D5);
  result <<= 1; 
  result |= digitalRead(LCD_D4); 
  result <<= 1;
  result |= digitalRead(LCD_D3);
  result <<= 1;
  result |= digitalRead(LCD_D2); 
  result <<= 1;
  result |= digitalRead(LCD_D1);
  result <<= 1;
  result |= digitalRead(LCD_D0); 
  
  return result;
}

void lcdSetWriteDir() {
  pinMode(LCD_D0, OUTPUT);
  pinMode(LCD_D1, OUTPUT);
  pinMode(LCD_D2, OUTPUT);
  pinMode(LCD_D3, OUTPUT);  
  pinMode(LCD_D4, OUTPUT);  
  pinMode(LCD_D5, OUTPUT);
  pinMode(LCD_D6, OUTPUT);
  pinMode(LCD_D7, OUTPUT);  
}
void lcdSetReadDir() {
  pinMode(LCD_D0, INPUT);
  pinMode(LCD_D1, INPUT);
  pinMode(LCD_D2, INPUT);
  pinMode(LCD_D3, INPUT);  
  pinMode(LCD_D4, INPUT);  
  pinMode(LCD_D5, INPUT);
  pinMode(LCD_D6, INPUT);
  pinMode(LCD_D7, INPUT);    
}

void lcdWriteData(uint8_t data) {
  
  lcdSetWriteDir();
  digitalWrite(LCD_CS, LOW);
  digitalWrite(LCD_RS, HIGH);
  digitalWrite(LCD_RD, HIGH);
  digitalWrite(LCD_WR, HIGH);
    
  lcdWrite8(data);
  digitalWrite(LCD_WR, LOW);
  delayMicroseconds(2);
  digitalWrite(LCD_WR, HIGH);
  digitalWrite(LCD_CS, HIGH);  
}


void lcdWriteCommand(uint8_t command) {
  lcdSetWriteDir(); 
  digitalWrite(LCD_CS, LOW);
  digitalWrite(LCD_RS, LOW);
  digitalWrite(LCD_RD, HIGH);
  digitalWrite(LCD_WR, HIGH);  
  
  lcdWrite8(command);
  digitalWrite(LCD_WR, LOW);
  delayMicroseconds(2);
  digitalWrite(LCD_WR, HIGH);
  
  digitalWrite(LCD_CS, HIGH); 
  digitalWrite(LCD_RS, HIGH);
}

void lcdWriteRegister(uint8_t addr, uint8_t data){
  lcdWriteCommand(addr);
  lcdWriteData(data);
}

void lcd_clr(uint16_t color) { //заливка цветом
  
  lcdWriteRegister(0x13, 0x00); /* - Horizontal start address */   
  lcdWriteRegister(0x16, 0xEF); /* - Horizontal end   address F0 конец*/ 
  lcdWriteRegister(0x14, 0x00); /* - Vertical   start address, low  byte */
  lcdWriteRegister(0x15, 0x00); /* - Vertical   start address, high byte */
  lcdWriteRegister(0x17, 0x8F); /* - Vertical   end   address, low  byte 90 конец*/
  lcdWriteRegister(0x18, 0x01); /* - Vertical   end   address, high byte  01 конец*/   
  lcdWriteCommand (0x03);       /* - RAM access mode */

  uint32_t i = 400; 
  i *=240;// 96000
  do{
  lcdWriteData (color >> 8);
  lcdWriteData (color);
  }while( i-- );
}

 Без второго подопытного диспа, скетч кажется норм.
Собрал за ночь эксперимент на макетке , дисплей от LG GM360i .
Да хорошо эта заливка работает , и это на 10ком резисторах. 

Дисплей работает гораздо быстрее ардуины , поэтому попробовал ускорить этот код. 
Заливка цветом:
22сек - изначально заливает
14сек - заменил на выдачу байта сразу в порт PORTA , а не по  каждому пину.
10сек - убрал CS, RD
8сек - заменил медленные digitalWrite на быстрые битовые ( ускорение может быть до 20раз . из либы CyberLib.h ) 

// можно  ускорить через  cbi sbi http://arduino.ru/forum/proekty/miniatyurnyi-komnatnyi-termometr-na-attiny85-c-oled#comment-32533 .

#ifndef cbi
#define cbi(sfr, bit) (_SFR_BYTE(sfr) &= ~_BV(bit))
#endif
#ifndef sbi
#define sbi(sfr, bit) (_SFR_BYTE(sfr) |= _BV(bit))
#endif

#define RS_High sbi(PORTD,7)  // PD 7 D38
#define RS_Low  cbi(PORTD,7)  // PD 7 D38

#define WR_High sbi(PORTG,2) // PG 2 D39
#define WR_Low  cbi(PORTG,2) // PG 2 D39

или конструкциями из любой библиотек (adafruit, UTFT, ...) 
  Чтоб не использовать счетчик, заменил delayMicroseconds(2); после WR_Low; на еще один WR_Low; , чтоб добавить небольшую задержку , возможно это сказался завал импульса через 10ком резистор, надо пробовать как будет на преобразователях уровнях или 3.3в логике. 

11 и 19 пины диспа (IF_mode IF1 IF0) пока ниуда не подключал, не экспериментировал с битностью, работает и так . 

ваш скетч не требующий либ, немного ускоренный:

/*********************************************************************
*
* PIN ASSIGNMENTS
*
* You can alter the pin assignments to reflect any configuration you
* wish.  I've provided the default shield configuration, which works
* on both the Arduino UNO and Mega 2560.
* 
*********************************************************************/
//-- Arduino UNO or Mega 2560 Plugged as shield
#define LCD_RST 41//4
#define LCD_CS 40//A3
#define LCD_RS 38//A2
    #define RS_High PORTD|=B10000000	// PD 7 D38
    #define RS_Low PORTD&=B01111111	// PD 7 D38
#define LCD_WR 39//A1
    #define WR_High PORTG|=B00000100	// PG 2 D39
    #define WR_Low PORTG&=B11111011	// PG 2 D39
#define LCD_RD 42//45 A0  

#define LCD_D0 22//8
#define LCD_D1 23//9
#define LCD_D2 24//2
#define LCD_D3 25//3
#define LCD_D4 26//4
#define LCD_D5 27//
#define LCD_D6 28//6
#define LCD_D7 29//7


#define BLACK   0x0000
#define BLUE    0x001F
#define RED     0xF800
#define GREEN   0x07E0
#define CYAN    0x07FF
#define MAGENTA 0xF81F
#define YELLOW  0xFFE0
#define WHITE   0xFFFF




/*********************************************************************
*
* Attempt to initialize and reset LCD, then read its Driver Code
* at register index 0.
* 
*********************************************************************/
void setup() {
  lcdInit();
  delay(100);
  lcdReset();
  delay(500);
  lcdRegisterOther(); // инит
}

void loop() {
  lcd_clr(RED);  // заливка всего экрана
  delay(500);
  lcd_clr(GREEN);
  delay(500);
}

void lcdRegisterOther() {
lcdWriteRegister(0xC0, 0x00);
lcdWriteRegister(0xC0, 0x02);
delay(10);
lcdWriteRegister(0xC0, 0x00);
lcdWriteRegister(0x68, 0x41);
lcdWriteRegister(0x69, 0x7D);
lcdWriteRegister(0x01, 0x02);
lcdWriteRegister(0x08, 0x00);
lcdWriteRegister(0x10, 0xF0);
lcdWriteRegister(0x11, 0x90);
lcdWriteRegister(0x12, 0x01);
lcdWriteRegister(0x1E, 0x50);
lcdWriteRegister(0x1D, 0x07);
lcdWriteRegister(0x1A, 0xEF);
lcdWriteRegister(0x1B, 0x8E);
lcdWriteRegister(0x1C, 0x01);
lcdWriteRegister(0x30, 0x81);
lcdWriteRegister(0x33, 0x02);
lcdWriteRegister(0x42, 0x70);
lcdWriteRegister(0x43, 0x01);
lcdWriteRegister(0x44, 0x3F);
lcdWriteRegister(0x45, 0x14);
lcdWriteRegister(0x46, 0x0F);
lcdWriteRegister(0x4A, 0x01);
lcdWriteRegister(0x4B, 0xA8);
lcdWriteRegister(0x4C, 0x12);
lcdWriteRegister(0x5A, 0x00);
lcdWriteRegister(0x62, 0x52);
lcdWriteRegister(0x65, 0x02);
lcdWriteRegister(0x66, 0x06);
lcdWriteRegister(0x6A, 0x02);
lcdWriteRegister(0x81, 0x44);
lcdWriteRegister(0x82, 0x2D);
lcdWriteRegister(0x83, 0x25);
lcdWriteRegister(0x84, 0x17);
lcdWriteRegister(0x85, 0x27);
lcdWriteRegister(0x86, 0x17);
lcdWriteRegister(0x90, 0x25);
lcdWriteRegister(0x91, 0x05);
lcdWriteRegister(0x92, 0x15);
lcdWriteRegister(0x31, 0x01);
lcdWriteRegister(0x19, 0x01);
lcdWriteRegister(0x3E, 0x01);
delay(120);
}

  void lcdInit() {
  pinMode(LCD_CS, OUTPUT);
    // digitalWrite(LCD_CS, HIGH);
       digitalWrite(LCD_CS, LOW);
  pinMode(LCD_RS, OUTPUT);
  digitalWrite(LCD_RS, HIGH);
  pinMode(LCD_WR, OUTPUT);
  digitalWrite(LCD_WR, HIGH);
  pinMode(LCD_RD, OUTPUT);
  digitalWrite(LCD_RD, HIGH);
  pinMode(LCD_RST, OUTPUT);
  digitalWrite(LCD_RST, HIGH);  
}

void lcdReset() {
  digitalWrite(LCD_RST, LOW);
  delay(50); 
  digitalWrite(LCD_RST, HIGH);
  delay(50); 
}

void lcdWrite8(uint8_t data) {// было uint16_t
/*
  digitalWrite(LCD_D0, data & 1);
  digitalWrite(LCD_D1, (data & 2) >> 1);
  digitalWrite(LCD_D2, (data & 4) >> 2);
  digitalWrite(LCD_D3, (data & 8) >> 3);
  digitalWrite(LCD_D4, (data & 16) >> 4); 
  digitalWrite(LCD_D5, (data & 32) >> 5);
  digitalWrite(LCD_D6, (data & 64) >> 6);
  digitalWrite(LCD_D7, (data & 128) >> 7);  
  */
 PORTA=data; 
}

uint16_t lcdRead8() {
  uint8_t result = digitalRead(LCD_D7);// было uint16_t
  result <<= 1;
  result |= digitalRead(LCD_D6);
  result <<= 1;
  result |= digitalRead(LCD_D5);
  result <<= 1; 
  result |= digitalRead(LCD_D4); 
  result <<= 1;
  result |= digitalRead(LCD_D3);
  result <<= 1;
  result |= digitalRead(LCD_D2); 
  result <<= 1;
  result |= digitalRead(LCD_D1);
  result <<= 1;
  result |= digitalRead(LCD_D0); 
  
  return result;
}

void lcdSetWriteDir() {
  pinMode(LCD_D0, OUTPUT);
  pinMode(LCD_D1, OUTPUT);
  pinMode(LCD_D2, OUTPUT);
  pinMode(LCD_D3, OUTPUT);  
  pinMode(LCD_D4, OUTPUT);  
  pinMode(LCD_D5, OUTPUT);
  pinMode(LCD_D6, OUTPUT);
  pinMode(LCD_D7, OUTPUT);  
}
void lcdSetReadDir() {
  pinMode(LCD_D0, INPUT);
  pinMode(LCD_D1, INPUT);
  pinMode(LCD_D2, INPUT);
  pinMode(LCD_D3, INPUT);  
  pinMode(LCD_D4, INPUT);  
  pinMode(LCD_D5, INPUT);
  pinMode(LCD_D6, INPUT);
  pinMode(LCD_D7, INPUT);    
}

void lcdWriteData(uint8_t data) {
  
  lcdSetWriteDir();
 // digitalWrite(LCD_CS, LOW);
 RS_High; //  digitalWrite(LCD_RS, HIGH);
 //  digitalWrite(LCD_RD, HIGH);
 WR_High; //  digitalWrite(LCD_WR, HIGH);
    
  lcdWrite8(data);
 WR_Low; WR_Low; // digitalWrite(LCD_WR, LOW);
// delayMicroseconds(2);
 WR_High; // digitalWrite(LCD_WR, HIGH);
//  digitalWrite(LCD_CS, HIGH);  
}


void lcdWriteCommand(uint8_t command) {
  lcdSetWriteDir(); 
//  digitalWrite(LCD_CS, LOW);
RS_Low; //  digitalWrite(LCD_RS, LOW);
//  digitalWrite(LCD_RD, HIGH);
WR_High; //digitalWrite(LCD_WR, HIGH);  
  
  lcdWrite8(command);
 WR_Low; WR_Low; // digitalWrite(LCD_WR, LOW);
 // delayMicroseconds(2);
 WR_High; //  digitalWrite(LCD_WR, HIGH);  
 //  digitalWrite(LCD_CS, HIGH); 
 RS_High; // digitalWrite(LCD_RS, HIGH);
}

void lcdWriteRegister(uint8_t addr, uint8_t data){
  lcdWriteCommand(addr);
  lcdWriteData(data);
}

void lcd_clr(uint16_t color) { //заливка цветом
  
  lcdWriteRegister(0x13, 0x00); /* - Horizontal start address */   
  lcdWriteRegister(0x16, 0xEF); /* - Horizontal end   address F0 конец*/ 
  lcdWriteRegister(0x14, 0x00); /* - Vertical   start address, low  byte */
  lcdWriteRegister(0x15, 0x00); /* - Vertical   start address, high byte */
  lcdWriteRegister(0x17, 0x8F); /* - Vertical   end   address, low  byte 90 конец*/
  lcdWriteRegister(0x18, 0x01); /* - Vertical   end   address, high byte  01 конец*/   
  lcdWriteCommand (0x03);       /* - RAM access mode */

  uint32_t i = 400; // uint32_t 
  i *=240;// 96000
  do{
  lcdWriteData (color >> 8);
  lcdWriteData (color);
  }while( i-- );
}

// да проскакивала синяя заливка, но это при попытках чрезмерно ускорить через заваливающие фронты 10ком резисторы. Возможно где то у вас не контакт в схеме или "залипуха" с припоя или флюса. М.б. из-за питания.  Дисп от LG 360i запитал от 3.3в через 33 0м резистор и белый светодиод + светодиоды подсветки, в итоге на питание диспа идет 2,7в .

//// надо бы закинуть этот инит в либу ( adafruit, utft , mcufrieng_kvb ), и регистры рисования подменить. Тогда и проще рисовать будет. B библиотеках заливка должна осуществляться еще быстрее, т.к. изпользуется автоинкримент средствами контроллера дисплея, при ненадобности заново вводить цвет и координаты последующегося пикселя в строке.

slider с твоим скетчем что-то у меня заливается только четверть экрана, хотя заливка написана на весь экран. Может где небольшой косячок есть, найти не могу.

У себя в скетче переделал:

Экран стал заливаться за 3 сек. Но проблема с полосами осталась.

подправил на обратно 

на вид около 0.5сек бешенная заливка !!! для arduino mega2560 , и это  еще на 8 бит , а  не 16.
потестируйте

#define LCD_RST 41//4
#define LCD_CS 40//A3
#define LCD_RS 38//A2
    #define RS_High PORTD|=B10000000	// PD 7 D38
    #define RS_Low PORTD&=B01111111	// PD 7 D38
#define LCD_WR 39//A1
    #define WR_High PORTG|=B00000100	// PG 2 D39
    #define WR_Low PORTG&=B11111011	// PG 2 D39
#define LCD_RD 42//45 A0  

#define LCD_D0 22//8
#define LCD_D1 23//9
#define LCD_D2 24//2
#define LCD_D3 25//3
#define LCD_D4 26//4
#define LCD_D5 27//
#define LCD_D6 28//6
#define LCD_D7 29//7


#define BLACK   0x0000
#define BLUE    0x001F
#define RED     0xF800
#define GREEN   0x07E0
#define CYAN    0x07FF
#define MAGENTA 0xF81F
#define YELLOW  0xFFE0
#define WHITE   0xFFFF

/*********************************************************************
*
* Attempt to initialize and reset LCD, then read its Driver Code
* at register index 0.
* 
*********************************************************************/
void setup() {
  lcdSetWriteDir(); // конфиг . пинов на выход
  lcdInit();
  delay(100);
  lcdReset();
  delay(500);
  lcdRegisterOther(); // инит
}

void loop() {
  lcd_clr(RED);  // заливка всего экрана
  delay(500);
  lcd_clr(GREEN);
  delay(500);
}

void lcdRegisterOther() {
lcdWriteRegister(0xC0, 0x00);
lcdWriteRegister(0xC0, 0x02);
delay(10);
lcdWriteRegister(0xC0, 0x00);
lcdWriteRegister(0x68, 0x41);
lcdWriteRegister(0x69, 0x7D);
lcdWriteRegister(0x01, 0x02);
lcdWriteRegister(0x08, 0x00);
lcdWriteRegister(0x10, 0xF0);
lcdWriteRegister(0x11, 0x90);
lcdWriteRegister(0x12, 0x01);
lcdWriteRegister(0x1E, 0x50);
lcdWriteRegister(0x1D, 0x07);
lcdWriteRegister(0x1A, 0xEF);
lcdWriteRegister(0x1B, 0x8E);
lcdWriteRegister(0x1C, 0x01);
lcdWriteRegister(0x30, 0x81);
lcdWriteRegister(0x33, 0x02);
lcdWriteRegister(0x42, 0x70);
lcdWriteRegister(0x43, 0x01);
lcdWriteRegister(0x44, 0x3F);
lcdWriteRegister(0x45, 0x14);
lcdWriteRegister(0x46, 0x0F);
lcdWriteRegister(0x4A, 0x01);
lcdWriteRegister(0x4B, 0xA8);
lcdWriteRegister(0x4C, 0x12);
lcdWriteRegister(0x5A, 0x00);
lcdWriteRegister(0x62, 0x52);
lcdWriteRegister(0x65, 0x02);
lcdWriteRegister(0x66, 0x06);
lcdWriteRegister(0x6A, 0x02);
lcdWriteRegister(0x81, 0x44);
lcdWriteRegister(0x82, 0x2D);
lcdWriteRegister(0x83, 0x25);
lcdWriteRegister(0x84, 0x17);
lcdWriteRegister(0x85, 0x27);
lcdWriteRegister(0x86, 0x17);
lcdWriteRegister(0x90, 0x25);
lcdWriteRegister(0x91, 0x05);
lcdWriteRegister(0x92, 0x15);
lcdWriteRegister(0x31, 0x01);
lcdWriteRegister(0x19, 0x01);

  lcdWriteRegister(0x13, 0x00); /* - Horizontal start address */   
  lcdWriteRegister(0x16, 0xEF); /* - Horizontal end   address F0 конец*/ 
  lcdWriteRegister(0x14, 0x00); /* - Vertical   start address, low  byte */
  lcdWriteRegister(0x15, 0x00); /* - Vertical   start address, high byte */
  lcdWriteRegister(0x17, 0x8F); /* - Vertical   end   address, low  byte 90 конец*/
  lcdWriteRegister(0x18, 0x01); /* - Vertical   end   address, high byte  01 конец*/ 
  lcdWriteCommand (0x03);  
 
lcdWriteRegister(0x3E, 0x01);
delay(120);
}

void lcdInit() {
  pinMode(LCD_CS, OUTPUT);   digitalWrite(LCD_CS, LOW);
  pinMode(LCD_RS, OUTPUT);   digitalWrite(LCD_RS, HIGH);
  pinMode(LCD_WR, OUTPUT);   digitalWrite(LCD_WR, HIGH);
  pinMode(LCD_RD, OUTPUT);   digitalWrite(LCD_RD, HIGH);
  pinMode(LCD_RST, OUTPUT);  digitalWrite(LCD_RST, HIGH);  
}

void lcdReset() {
  digitalWrite(LCD_RST, LOW);
  delay(50); 
  digitalWrite(LCD_RST, HIGH);
  delay(50); 
}

void lcdWrite8(uint8_t data) {// было uint16_t
 PORTA=data; 
}



void lcdSetWriteDir() {
  pinMode(LCD_D0, OUTPUT);
  pinMode(LCD_D1, OUTPUT);
  pinMode(LCD_D2, OUTPUT);
  pinMode(LCD_D3, OUTPUT);  
  pinMode(LCD_D4, OUTPUT);  
  pinMode(LCD_D5, OUTPUT);
  pinMode(LCD_D6, OUTPUT);
  pinMode(LCD_D7, OUTPUT);  
}


void lcdWriteData(uint8_t data) {
  
                                                   // digitalWrite(LCD_CS, LOW);
 RS_High;                                          //  digitalWrite(LCD_RS, HIGH);
                                                  //  digitalWrite(LCD_RD, HIGH);
 WR_High;                                        //  digitalWrite(LCD_WR, HIGH);
    
 lcdWrite8(data);
 
 WR_Low; WR_Low;                                    // digitalWrite(LCD_WR, LOW);
                                                    // delayMicroseconds(2);
 WR_High;                                         // digitalWrite(LCD_WR, HIGH);
                                                  //  digitalWrite(LCD_CS, HIGH);  
}


void lcdWriteCommand(uint8_t command) {
                                                 //  digitalWrite(LCD_CS, LOW);
 RS_Low;                                          //  digitalWrite(LCD_RS, LOW);
                                                //  digitalWrite(LCD_RD, HIGH);
 WR_High;                                        //digitalWrite(LCD_WR, HIGH);  
  
 lcdWrite8(command);
 
 WR_Low; WR_Low;                                // digitalWrite(LCD_WR, LOW);
                                                //delayMicroseconds(2);
 WR_High;                                       //  digitalWrite(LCD_WR, HIGH);  
                                                //  digitalWrite(LCD_CS, HIGH); 
 RS_High;   
}                                             

void lcdWriteRegister(uint8_t addr, uint8_t data){
  lcdWriteCommand(addr);
  lcdWriteData(data);
}

void lcd_clr(uint16_t color) { //заливка цветом
  
   lcdWriteRegister(0x13, 0x00); /* - Horizontal start address */   
   lcdWriteRegister(0x16, 0xEF); /* - Horizontal end   address F0 конец*/ 
   lcdWriteRegister(0x14, 0x00); /* - Vertical   start address, low  byte */
   lcdWriteRegister(0x15, 0x00); /* - Vertical   start address, high byte */
   lcdWriteRegister(0x17, 0x8F); /* - Vertical   end   address, low  byte 90 конец*/
   lcdWriteRegister(0x18, 0x01); /* - Vertical   end   address, high byte  01 конец*/   
 lcdWriteCommand (0x03);       /* - RAM access mode */

                                                       // digitalWrite(LCD_CS, LOW);
 RS_High;                                           //  digitalWrite(LCD_RS, HIGH);
                                                    //  digitalWrite(LCD_RD, HIGH);
 WR_High;                                         // digitalWrite(LCD_WR, HIGH);

  uint32_t i = 400; //432
  i *=240;
  do   {
  lcdWrite8 (color >> 8);
   WR_Low; WR_Low;          // digitalWrite(LCD_WR, LOW); 
   WR_High;                   // digitalWrite(LCD_WR, HIGH); 
  lcdWrite8 (color);
  WR_Low; WR_Low;          // digitalWrite(LCD_WR, LOW); 
  WR_High;                    // digitalWrite(LCD_WR, HIGH);
  } while( i-- );
                                //  digitalWrite(LCD_CS, HIGH);
  RS_High;                            // digitalWrite(LCD_RS, HIGH);
}

RD 42 на свой 45вспомните поменять .

лог читалки тож по 00 регистру лежит id  0x0A0A

// читалка ID дисплеев V3.1beta только для 8ми битных дисплеев,
      
               1p 2p 3p 4p 5p 6p 7p 8parameter(byte)
      
register 00    0A 0A 0A 0A 0A 0A 0A 0A  ***
      
register 00    0A 0A 0A 0A 0A 0A 0A 0A  ***
register 01    00 00 00 00 00 00 00 00
register 02    01 01 01 01 01 01 01 01
register 03    04 23 0F 29 07 2C 3B 22
register 04    01 01 01 01 01 01 01 01  ***
register 05    01 01 01 01 01 01 01 01
register 06    01 01 01 01 01 01 01 01
register 07    01 01 01 01 01 01 01 01
register 08    02 02 02 02 02 02 02 02
register 09    01 01 01 01 01 01 01 01
register 0A    01 01 01 01 01 01 01 01
register 0B    01 01 01 01 01 01 01 01
register 0C    01 01 01 01 01 01 01 01
register 0D    01 01 01 01 01 01 01 01
register 0E    01 01 01 01 01 01 01 01
register 0F    01 01 01 01 01 01 01 01
register 10    F0 F0 F0 F0 F0 F0 F0 F0
register 11    90 90 90 90 90 90 90 90
register 12    01 01 01 01 01 01 01 01
register 13    00 00 00 00 00 00 00 00
register 14    00 00 00 00 00 00 00 00
register 15    00 00 00 00 00 00 00 00
register 16    00 00 00 00 00 00 00 00
register 17    00 00 00 00 00 00 00 00
register 18    00 00 00 00 00 00 00 00
register 19    00 00 00 00 00 00 00 00
register 1A    00 00 00 00 00 00 00 00
register 1B    00 00 00 00 00 00 00 00
register 1C    00 00 00 00 00 00 00 00
register 1D    00 00 00 00 00 00 00 00
register 1E    50 50 50 50 50 50 50 50
register 1F    01 01 01 01 01 01 01 01
register 20    00 00 00 00 00 00 00 00
register 21    00 00 00 00 00 00 00 00
register 22    00 00 00 00 00 00 00 00
register 23    00 00 00 00 00 00 00 00
register 24    00 00 00 00 00 00 00 00
register 25    00 00 00 00 00 00 00 00
register 26    01 01 01 01 01 01 01 01
register 27    01 01 01 01 01 01 01 01
register 28    01 01 01 01 01 01 01 01
register 29    01 01 01 01 01 01 01 01
register 2A    01 01 01 01 01 01 01 01
register 2B    01 01 01 01 01 01 01 01
register 2C    01 01 01 01 01 01 01 01
register 2D    01 01 01 01 01 01 01 01
register 2E    01 01 01 01 01 01 01 01
register 2F    01 01 01 01 01 01 01 01
register 30    80 80 80 80 80 80 80 80
register 31    00 00 00 00 00 00 00 00
register 32    01 01 01 01 01 01 01 01
register 33    00 00 00 00 00 00 00 00
register 34    00 00 00 00 00 00 00 00
register 35    00 00 00 00 00 00 00 00
register 36    00 00 00 00 00 00 00 00
register 37    00 00 00 00 00 00 00 00
register 38    00 00 00 00 00 00 00 00
register 39    00 00 00 00 00 00 00 00
register 3A    00 00 00 00 00 00 00 00
register 3B    00 00 00 00 00 00 00 00
register 3C    00 00 00 00 00 00 00 00
register 3D    00 00 00 00 00 00 00 00
register 3E    00 00 00 00 00 00 00 00
register 3F    00 00 00 00 00 00 00 00
register 40    00 00 00 00 00 00 00 00
register 41    01 01 01 01 01 01 01 01
register 42    33 33 33 33 33 33 33 33
register 43    01 01 01 01 01 01 01 01
register 44    09 09 09 09 09 09 09 09
register 45    02 02 02 02 02 02 02 02
register 46    05 05 05 05 05 05 05 05
register 47    01 01 01 01 01 01 01 01
register 48    01 01 01 01 01 01 01 01
register 49    01 01 01 01 01 01 01 01
register 4A    00 00 00 00 00 00 00 00
register 4B    00 00 00 00 00 00 00 00
register 4C    06 06 06 06 06 06 06 06
register 4D    01 01 01 01 01 01 01 01
register 4E    01 01 01 01 01 01 01 01
register 4F    00 00 00 00 00 00 00 00
register 50    00 00 00 00 00 00 00 00
register 51    00 00 00 00 00 00 00 00
register 52    01 01 01 01 01 01 01 01
register 53    01 01 01 01 01 01 01 01
register 54    02 02 02 02 02 02 02 02
register 55    01 01 01 01 01 01 01 01
register 56    01 01 01 01 01 01 01 01
register 57    01 01 01 01 01 01 01 01
register 58    01 01 01 01 01 01 01 01
register 59    01 01 01 01 01 01 01 01
register 5A    00 00 00 00 00 00 00 00
register 5B    00 00 00 00 00 00 00 00
register 5C    00 00 00 00 00 00 00 00
register 5D    01 01 01 01 01 01 01 01
register 5E    01 01 01 01 01 01 01 01
register 5F    01 01 01 01 01 01 01 01
register 60    00 00 00 00 00 00 00 00
register 61    00 00 00 00 00 00 00 00
register 62    29 29 29 29 29 29 29 29
register 63    00 00 00 00 00 00 00 00
register 64    00 00 00 00 00 00 00 00
register 65    02 02 02 02 02 02 02 02
register 66    03 03 03 03 03 03 03 03
register 67    01 01 01 01 01 01 01 01
register 68    07 07 07 07 07 07 07 07
register 69    07 07 07 07 07 07 07 07
register 6A    02 02 02 02 02 02 02 02
register 6B    02 02 02 02 02 02 02 02
register 6C    01 01 01 01 01 01 01 01
register 6D    01 01 01 01 01 01 01 01
register 6E    01 01 01 01 01 01 01 01
register 6F    01 01 01 01 01 01 01 01
register 70    00 00 00 00 00 00 00 00
register 71    00 00 00 00 00 00 00 00
register 72    29 29 29 29 29 29 29 29
register 73    00 00 00 00 00 00 00 00
register 74    00 00 00 00 00 00 00 00
register 75    02 02 02 02 02 02 02 02
register 76    03 03 03 03 03 03 03 03
register 77    01 01 01 01 01 01 01 01
register 78    01 01 01 01 01 01 01 01
register 79    01 01 01 01 01 01 01 01
register 7A    01 01 01 01 01 01 01 01
register 7B    01 01 01 01 01 01 01 01
register 7C    01 01 01 01 01 01 01 01
register 7D    01 01 01 01 01 01 01 01
register 7E    01 01 01 01 01 01 01 01
register 7F    01 01 01 01 01 01 01 01
register 80    81 81 81 81 81 81 81 81
register 81    44 44 44 44 44 44 44 44
register 82    15 15 15 15 15 15 15 15
register 83    3C 3C 3C 3C 3C 3C 3C 3C
register 84    17 17 17 17 17 17 17 17
register 85    20 20 20 20 20 20 20 20
register 86    17 17 17 17 17 17 17 17
register 87    01 01 01 01 01 01 01 01
register 88    01 01 01 01 01 01 01 01
register 89    01 01 01 01 01 01 01 01
register 8A    01 01 01 01 01 01 01 01
register 8B    01 01 01 01 01 01 01 01
register 8C    01 01 01 01 01 01 01 01
register 8D    01 01 01 01 01 01 01 01
register 8E    01 01 01 01 01 01 01 01
register 8F    01 01 01 01 01 01 01 01
register 90    15 15 15 15 15 15 15 15
register 91    01 01 01 01 01 01 01 01
register 92    15 15 15 15 15 15 15 15
register 93    01 01 01 01 01 01 01 01
register 94    01 01 01 01 01 01 01 01
register 95    01 01 01 01 01 01 01 01
register 96    01 01 01 01 01 01 01 01
register 97    01 01 01 01 01 01 01 01
register 98    01 01 01 01 01 01 01 01
register 99    01 01 01 01 01 01 01 01
register 9A    01 01 01 01 01 01 01 01
register 9B    01 01 01 01 01 01 01 01
register 9C    01 01 01 01 01 01 01 01
register 9D    01 01 01 01 01 01 01 01
register 9E    01 01 01 01 01 01 01 01
register 9F    01 01 01 01 01 01 01 01
register A0    00 00 00 00 00 00 00 00
register A1    00 00 00 00 00 00 00 00
register A2    00 00 00 00 00 00 00 00
register A3    00 00 00 00 00 00 00 00
register A4    00 00 00 00 00 00 00 00
register A5    00 00 00 00 00 00 00 00
register A6    00 00 00 00 00 00 00 00
register A7    00 00 00 00 00 00 00 00
register A8    01 01 01 01 01 01 01 01
register A9    01 01 01 01 01 01 01 01
register AA    01 01 01 01 01 01 01 01
register AB    01 01 01 01 01 01 01 01
register AC    01 01 01 01 01 01 01 01
register AD    01 01 01 01 01 01 01 01
register AE    01 01 01 01 01 01 01 01
register AF    01 01 01 01 01 01 01 01
register B0    01 01 01 01 01 01 01 01
register B1    01 01 01 01 01 01 01 01
register B2    01 01 01 01 01 01 01 01
register B3    01 01 01 01 01 01 01 01
register B4    01 01 01 01 01 01 01 01
register B5    01 01 01 01 01 01 01 01
register B6    01 01 01 01 01 01 01 01
register B7    01 01 01 01 01 01 01 01
register B8    01 01 01 01 01 01 01 01
register B9    01 01 01 01 01 01 01 01
register BA    01 01 01 01 01 01 01 01
register BB    01 01 01 01 01 01 01 01
register BC    01 01 01 01 01 01 01 01
register BD    01 01 01 01 01 01 01 01
register BE    01 01 01 01 01 01 01 01
register BF    01 01 01 01 01 01 01 01  ***
register C0    02 02 02 02 02 02 02 02
register C1    08 08 08 08 08 08 08 08
register C2    08 08 08 08 08 08 08 08
register C3    01 01 01 01 01 01 01 01
register C4    00 00 00 00 00 00 00 00
register C5    00 00 00 00 00 00 00 00
register C6    00 00 00 00 00 00 00 00
register C7    00 00 00 00 00 00 00 00
register C8    01 01 01 01 01 01 01 01
register C9    FF FF FF FF FF FF FF FF
register CA    01 01 01 01 01 01 01 01
register CB    FF FF FF FF FF FF FF FF
register CC    01 01 01 01 01 01 01 01
register CD    FF FF FF FF FF FF FF FF
register CE    01 01 01 01 01 01 01 01
register CF    FF FF FF FF FF FF FF FF
register D0    6F 6F 6F 6F 6F 6F 6F 6F
register D1    76 76 76 76 76 76 76 76
register D2    00 00 00 00 00 00 00 00
register D3    08 08 08 08 08 08 08 08  ***
register D4    08 08 08 08 08 08 08 08
register D5    01 01 01 01 01 01 01 01
register D6    FF FF FF FF FF FF FF FF
register D7    01 01 01 01 01 01 01 01
register D8    FF FF FF FF FF FF FF FF
register D9    01 01 01 01 01 01 01 01
register DA    FF FF FF FF FF FF FF FF  ***
register DB    01 01 01 01 01 01 01 01  ***
register DC    FF FF FF FF FF FF FF FF  ***
register DD    01 01 01 01 01 01 01 01
register DE    01 01 01 01 01 01 01 01
register DF    01 01 01 01 01 01 01 01
register E0    01 01 01 01 01 01 01 01
register E1    00 00 00 00 00 00 00 00
register E2    00 00 00 00 00 00 00 00
register E3    01 01 01 01 01 01 01 01
register E4    01 01 01 01 01 01 01 01
register E5    01 01 01 01 01 01 01 01
register E6    01 01 01 01 01 01 01 01
register E7    01 01 01 01 01 01 01 01
register E8    01 01 01 01 01 01 01 01
register E9    01 01 01 01 01 01 01 01
register EA    01 01 01 01 01 01 01 01
register EB    01 01 01 01 01 01 01 01
register EC    01 01 01 01 01 01 01 01
register ED    01 01 01 01 01 01 01 01
register EE    01 01 01 01 01 01 01 01
register EF    01 01 01 01 01 01 01 01  ***
register F0    01 01 01 01 01 01 01 01
register F1    01 01 01 01 01 01 01 01
register F2    01 01 01 01 01 01 01 01
register F3    01 01 01 01 01 01 01 01
register F4    01 01 01 01 01 01 01 01
register F5    01 01 01 01 01 01 01 01
register F6    01 01 01 01 01 01 01 01
register F7    01 01 01 01 01 01 01 01
register F8    01 01 01 01 01 01 01 01
register F9    01 01 01 01 01 01 01 01
register FA    01 01 01 01 01 01 01 01
register FB    01 01 01 01 01 01 01 01
register FC    01 01 01 01 01 01 01 01
register FD    01 01 01 01 01 01 01 01
register FE    01 01 01 01 01 01 01 01
register FF    01 01 01 01 01 01 01 01

slider работает отлично. 

Сделаю другой преобразователь на шине управления, стоят резисторы 6,8к и 10к. Уж шибко фронты завалены. Может и проблема с заливкой цвета уйдет.

Что-то ID странный.

slider у тебя размах сигнала на пинах диспа какой?

Народ помогите или наставьте на путь.

Д-цать постов назад запускали монохромный экран 640х240.

Есть аналог sharp lm089hb1t03, есть желание выводить на него показания с датчиков (ет если осилю управление им)

скетч от Слайдера для вывода 2-х строк выводится только на половину экрана

 // вывод 2х строчек шрифтов на монохромный дисп 640x240
 //#include "CyberLib.h"
// если менять пины , то подсмотреть либу CyberLib.h  , как их заменить на высокоскоростное переключение
 #define  Cp1 36  // строки , дернуть после передачи строки из 80 байт  - это = 640 пикселей в строчке
 #define  Cp2 35  // data  , дергать чтобы передался байт = 8 пикселям в строке      
 #define  S   37  // отработать кадры совместно с CP1 , дергать совместно с CP1 - перед началом каждого кадра  


/*
LP - линейный импульсный сигнал для фиксации буфера сегмента к драйверу сегмента.
CP - сигнал тактового импульса, для смещения данных (d0-d3) в сегментный буфер
FLP - метка первой линии
DISPOFF - дсплей ON/OFF   0-off  1-on
*/


int i,j,ii=0;
byte mass[80][16];  // видео ОЗУ  , 80байт(640пикселей) на 16строк из640  
byte mass8[8]; // вспомогательный массивчик 8х8 бит для переворачивания баита шрифта из вдоль на поперек (с роризонтали на вертикаль)
//byte a;
//int b;

// the setup function runs once when you press reset or power the board
void setup() {
  // initialize digital pin 13 as an output.
  pinMode(Cp1, OUTPUT); digitalWrite(Cp1, LOW);
  pinMode(Cp2, OUTPUT); digitalWrite(Cp2, LOW);
  pinMode(S, OUTPUT);   digitalWrite(S, LOW);
  DDRA=0xFF;  // конф. порт на выход  (ардуиновские пины D0-D7)
  PORTA=0x00;  // уст. в 0

// set up the LCD's number of columns and rows:
//  lcd.begin(16, 2);
  // Print a message to the LCD.
//  lcd.print("hello, world!");

// очистка массива видео ОЗУ
 for (j=0; j<16; j++) // 16
{ 
 for (i=0; i<80; i++) {  // 80
                       mass[i][j]=0;
                      } 
}

// шрифты из библиотеки  Adafruit_GFX_Library pcd8544 nokia 5510  , UTFT , U8Glib
 
static const byte lcd_font[][5] PROGMEM =   //   
{
   { 0x00, 0x00 },
  { 0x00, 0x00, 0x00, 0x00, 0x00 },  // sp
  {  0x00,0x00, 0x00 },
  { 0x00, 0x00, 0x2f, 0x00, 0x00 },  // !
   {0x00, 0x00, 0x00 },
  { 0x00, 0x07, 0x00, 0x07, 0x00 },  // "
   { 0x00, 0x00, 0x00 },
  { 0x14, 0x7f, 0x14, 0x7f, 0x14 },  // #
   { 0x00 ,0x00, 0x00 },
  { 0x24, 0x2a, 0x7f, 0x2a, 0x12 },  // $
   { 0x00,0x00, 0x00 },
  { 0x23, 0x13, 0x08, 0x64, 0x62 },  // %  
/*
  { 0x14, 0x7f, 0x14, 0x7f, 0x14 },
  { 0x00, 0x00, 0x00, 0x00,  },
  { 0x00, 0x00, 0x00, 0x01,  },
  { 0xff, 0x00, 0xff, 0x00, 0x00 },
  { 0x00, 0xff, 0x00, 0xff, 0xff },
  { 0xff, 0x00, 0xff, 0x00, 0x00 },
  { 0xff, 0xff, 0xff, 0xff, 0xff },
  { 0x00, 0x00, 0x00, 0x00, 0x00 },
  { 0x00, 0x00, 0x00, 0x01, 0x01 }, 
  { 0x14, 0x7f, 0x14, 0x7f, 0x14 },    
*/
 { 0x00, 0x00, 0x00, 0x00, 0x00 },
  { 0x36, 0x49, 0x55, 0x22, 0x50 },  // &
   { 0x00, 0x00, 0x00, 0x00, 0x00 },
  { 0x00, 0x05, 0x03, 0x00, 0x00 },  // '
   { 0x00, 0x00, 0x00, 0x00, 0x00 },
  { 0x00, 0x1c, 0x22, 0x41, 0x00 },  // (
   { 0x00, 0x00, 0x00, 0x00, 0x00 },
  { 0x00, 0x41, 0x22, 0x1c, 0x00 },  // )
   { 0x00, 0x00, 0x00, 0x00, 0x00 },
  { 0x14, 0x08, 0x3E, 0x08, 0x14 },  // *
  { 0x08, 0x08, 0x3E, 0x08, 0x08 },  // +
  { 0x00, 0x00, 0x50, 0x30, 0x00 },  // ,
  { 0x10, 0x10, 0x10, 0x10, 0x10 },  // -
  { 0x00, 0x60, 0x60, 0x00, 0x00 },  // .
  { 0x20, 0x10, 0x08, 0x04, 0x02 },  // /
  { 0x3E, 0x51, 0x49, 0x45, 0x3E },  // 0
  { 0x00, 0x42, 0x7F, 0x40, 0x00 },  // 1
  { 0x42, 0x61, 0x51, 0x49, 0x46 },  // 2
  { 0x21, 0x41, 0x45, 0x4B, 0x31 },  // 3
  { 0x18, 0x14, 0x12, 0x7F, 0x10 },  // 4
  { 0x27, 0x45, 0x45, 0x45, 0x39 },  // 5
  { 0x3C, 0x4A, 0x49, 0x49, 0x30 },  // 6
  { 0x01, 0x71, 0x09, 0x05, 0x03 },  // 7
  { 0x36, 0x49, 0x49, 0x49, 0x36 },  // 8
  { 0x06, 0x49, 0x49, 0x29, 0x1E },  // 9

  
  { 0x00, 0x36, 0x36, 0x00, 0x00 },  // :
  { 0x00, 0x56, 0x36, 0x00, 0x00 },  // ;
  { 0x08, 0x14, 0x22, 0x41, 0x00 },  // <
  { 0x14, 0x14, 0x14, 0x14, 0x14 },  // =
  { 0x00, 0x41, 0x22, 0x14, 0x08 },  // >
  { 0x02, 0x01, 0x51, 0x09, 0x06 },  // ?
  { 0x32, 0x49, 0x59, 0x51, 0x3E },  // @
  { 0x7E, 0x11, 0x11, 0x11, 0x7E },  // A
  { 0x7F, 0x49, 0x49, 0x49, 0x36 },  // B
  { 0x3E, 0x41, 0x41, 0x41, 0x22 },  // C
  { 0x7F, 0x41, 0x41, 0x22, 0x1C },  // D
  { 0x7F, 0x49, 0x49, 0x49, 0x41 },  // E
  { 0x7F, 0x09, 0x09, 0x09, 0x01 },  // F
  { 0x3E, 0x41, 0x49, 0x49, 0x7A },  // G
  { 0x7F, 0x08, 0x08, 0x08, 0x7F },  // H
  { 0x00, 0x41, 0x7F, 0x41, 0x00 },  // I
  { 0x20, 0x40, 0x41, 0x3F, 0x01 },  // J
  { 0x7F, 0x08, 0x14, 0x22, 0x41 },  // K
  { 0x7F, 0x40, 0x40, 0x40, 0x40 },  // L
  { 0x7F, 0x02, 0x0C, 0x02, 0x7F },  // M
  { 0x7F, 0x04, 0x08, 0x10, 0x7F },  // N
  { 0x3E, 0x41, 0x41, 0x41, 0x3E },  // O
  { 0x7F, 0x09, 0x09, 0x09, 0x06 },  // P
  { 0x3E, 0x41, 0x51, 0x21, 0x5E },  // Q
  { 0x7F, 0x09, 0x19, 0x29, 0x46 },  // R
  { 0x46, 0x49, 0x49, 0x49, 0x31 },  // S
  { 0x01, 0x01, 0x7F, 0x01, 0x01 },  // T
  { 0x3F, 0x40, 0x40, 0x40, 0x3F },  // U
  { 0x1F, 0x20, 0x40, 0x20, 0x1F },  // V
  { 0x3F, 0x40, 0x38, 0x40, 0x3F },  // W
  { 0x63, 0x14, 0x08, 0x14, 0x63 },  // X
  { 0x07, 0x08, 0x70, 0x08, 0x07 },  // Y
  { 0x61, 0x51, 0x49, 0x45, 0x43 },  // Z
  { 0x00, 0x7F, 0x41, 0x41, 0x00 },  // [
  { 0x55, 0x2A, 0x55, 0x2A, 0x55 },  // 55
  { 0x00, 0x41, 0x41, 0x7F, 0x00 },  // ]
  { 0x04, 0x02, 0x01, 0x02, 0x04 },  // ^
  { 0x40, 0x40, 0x40, 0x40, 0x40 },  // _
  { 0x00, 0x01, 0x02, 0x04, 0x00 },  // '
  { 0x20, 0x54, 0x54, 0x54, 0x78 },  // a
  { 0x7F, 0x48, 0x44, 0x44, 0x38 },  // b
  { 0x38, 0x44, 0x44, 0x44, 0x20 },  // c
  { 0x38, 0x44, 0x44, 0x48, 0x7F },  // d
  { 0x38, 0x54, 0x54, 0x54, 0x18 },  // e
  { 0x08, 0x7E, 0x09, 0x01, 0x02 },  // f
  { 0x0C, 0x52, 0x52, 0x52, 0x3E },  // g
  { 0x7F, 0x08, 0x04, 0x04, 0x78 },  // h
  { 0x00, 0x44, 0x7D, 0x40, 0x00 },  // i
  { 0x20, 0x40, 0x44, 0x3D, 0x00 },  // j
  { 0x7F, 0x10, 0x28, 0x44, 0x00 },  // k
  { 0x00, 0x41, 0x7F, 0x40, 0x00 },  // l
  { 0x7C, 0x04, 0x18, 0x04, 0x78 },  // m
  { 0x7C, 0x08, 0x04, 0x04, 0x78 },  // n
  { 0x38, 0x44, 0x44, 0x44, 0x38 },  // o
  { 0x7C, 0x14, 0x14, 0x14, 0x08 },  // p
  { 0x08, 0x14, 0x14, 0x18, 0x7C },  // q
  { 0x7C, 0x08, 0x04, 0x04, 0x08 },  // r
  { 0x48, 0x54, 0x54, 0x54, 0x20 },  // s
  { 0x04, 0x3F, 0x44, 0x40, 0x20 },  // t
  { 0x3C, 0x40, 0x40, 0x20, 0x7C },  // u
  { 0x1C, 0x20, 0x40, 0x20, 0x1C },  // v
  { 0x3C, 0x40, 0x30, 0x40, 0x3C },  // w
  { 0x44, 0x28, 0x10, 0x28, 0x44 },  // x
  { 0x0C, 0x50, 0x50, 0x50, 0x3C },  // y
  { 0x44, 0x64, 0x54, 0x4C, 0x44 },  // z

  { 0x08, 0x08, 0x36, 0x41, 0x41 },  // {
  { 0x00, 0x00, 0x7F, 0x00, 0x00 },  // |
  { 0x41, 0x41, 0x36, 0x08, 0x08 },   // }
  { 0x02, 0x01, 0x02, 0x02, 0x01 },   // ~
   
  { 0x7E, 0x11, 0x11, 0x11 },  // А
  { 0x7E, 0x00, 0x7F, 0x49,  },//aб
  { 0x49, 0x49, 0x33, 0x00, },  // Б
  { 0x7F, 0x49, 0x49, 0x49,  },
  { 0x36, 0x00, 0x7F, 0x01, },  // В
  
  {  0x01, 0x01, 0x03 },  // Г
  { 0x00, 0x00, 0x00, 0x00, 0x00 },
  { 0xE0, 0x51, 0x4F, 0x41, 0xFF },  // Д
  { 0x7F, 0x49, 0x49, 0x49, 0x49 },  // Е
  { 0x77, 0x08, 0x7F, 0x08, 0x77 },  // Ж
  { 0x49, 0x49, 0x49, 0x49, 0x36 },  // З
  { 0x7F, 0x10, 0x08, 0x04, 0x7F },  // И
  { 0x7C, 0x21, 0x12, 0x09, 0x7C },  // Й
  { 0x7F, 0x08, 0x14, 0x22, 0x41 },  // К
  { 0x20, 0x41, 0x3F, 0x01, 0x7F },  // Л
  { 0x7F, 0x02, 0x0C, 0x02, 0x7F },  // М
  { 0x7F, 0x08, 0x08, 0x08, 0x7F },  // Н
  { 0x3E, 0x41, 0x41, 0x41, 0x3E },  // О
  { 0x7F, 0x01, 0x01, 0x01, 0x7F },  // П
  { 0x7F, 0x09, 0x09, 0x09, 0x06 },  // Р
  { 0x3E, 0x41, 0x41, 0x41, 0x22 },  // С
  { 0x01, 0x01, 0x7F, 0x01, 0x01 },  // Т
  { 0x27, 0x48, 0x48, 0x48, 0x3F },  // У
  { 0x1C, 0x22, 0x7F, 0x22, 0x1C },  // Ф
  { 0x63, 0x14, 0x08, 0x14, 0x63 },  // Х
  { 0x7F, 0x40, 0x40, 0x40, 0xFF },  // Ц
  { 0x07, 0x08, 0x08, 0x08, 0x7F },  // Ч
  { 0x7F, 0x40, 0x7F, 0x40, 0x7F },  // Ш
  { 0x7F, 0x40, 0x7F, 0x40, 0xFF },  // Щ
  { 0x01, 0x7F, 0x48, 0x48, 0x30 },  // Ъ
  { 0x7F, 0x48, 0x30, 0x00, 0x7F },  // Ы
  { 0x7F, 0x48, 0x48, 0x30, 0x00 },  // Ь
  { 0x22, 0x41, 0x49, 0x49, 0x3E },  // Э
  { 0x7F, 0x08, 0x3E, 0x41, 0x3E },  // Ю
  { 0x46, 0x29, 0x19, 0x09, 0x7F },  // Я
  { 0x20, 0x54, 0x54, 0x54, 0x78 },  // а
  { 0x3C, 0x4A, 0x4A, 0x49, 0x31 },  // б
  { 0x7C, 0x54, 0x54, 0x28, 0x00 },  // в
  { 0x7C, 0x04, 0x04, 0x04, 0x0C },  // г
  { 0xE0, 0x54, 0x4C, 0x44, 0xFC },  // д
  { 0x38, 0x54, 0x54, 0x54, 0x08 },  // е
  { 0x6C, 0x10, 0x7C, 0x10, 0x6C },  // ж
  { 0x44, 0x44, 0x54, 0x54, 0x28 },  // з
  { 0x7C, 0x20, 0x10, 0x08, 0x7C },  // и
  { 0x78, 0x42, 0x24, 0x12, 0x78 },  // й
  { 0x7C, 0x10, 0x28, 0x44, 0x00 },  // к
  { 0x20, 0x44, 0x3C, 0x04, 0x7C },  // л
  { 0x7C, 0x08, 0x10, 0x08, 0x7C },  // м
  { 0x7C, 0x10, 0x10, 0x10, 0x7C },  // н
  { 0x38, 0x44, 0x44, 0x44, 0x38 },  // о
  { 0x7C, 0x04, 0x04, 0x04, 0x7C },  // п
  { 0x7C, 0x14, 0x14, 0x14, 0x08 },  // р
  { 0x38, 0x44, 0x44, 0x44, 0x44 },  // с
  { 0x04, 0x04, 0x7C, 0x04, 0x04 },  // т
  { 0x0C, 0x50, 0x50, 0x50, 0x3C },  // у
  { 0x18, 0x24, 0x7E, 0x24, 0x18 },  // ф
  { 0x44, 0x28, 0x10, 0x28, 0x44 },  // х
  { 0x7C, 0x40, 0x40, 0x40, 0xFC },  // ц
  { 0x0C, 0x10, 0x10, 0x10, 0x7C },  // ч
  { 0x7C, 0x40, 0x7C, 0x40, 0x7C },  // ш
  { 0x7C, 0x40, 0x7C, 0x40, 0xFC },  // щ
  { 0x04, 0x7C, 0x50, 0x50, 0x20 },  // ъ
  { 0x7C, 0x50, 0x20, 0x00, 0x7C },  // ы
  { 0x7C, 0x50, 0x50, 0x20, 0x00 },  // ь
  { 0x28, 0x44, 0x54, 0x54, 0x38 },  // э

 
  { 0x7C, 0x10, 0x38, 0x44, 0x38 },  // ю
  { 0x08, 0x54, 0x34, 0x14, 0x7C }  // я
};


/*
 for (i=0; i<80; i++) // шрифт как есть, повернут на 90 град.
 { 
   // mass[80][16]=lcd_font[150][5];
mass[i][0]=0;
mass[i][1]=pgm_read_byte( &lcd_font[i][0] );
mass[i][2]=pgm_read_byte( &lcd_font[i][1] );
mass[i][3]=pgm_read_byte( &lcd_font[i][2] );
mass[i][4]=pgm_read_byte( &lcd_font[i][3] );
mass[i][5]=pgm_read_byte( &lcd_font[i][4] );
mass[i][6]=0;
mass[i][7]=0;
 } 
*/

// первые 8 линий  на дисплее с переворотом букв шрифта
 for (i=0; i<80; i++) 
 { 
   // размерности mass[80][16] lcd_font[150][5];
mass8[0]=pgm_read_byte( &lcd_font[i][0] );
mass8[1]=pgm_read_byte( &lcd_font[i][1] );
mass8[2]=pgm_read_byte( &lcd_font[i][2] );
mass8[3]=pgm_read_byte( &lcd_font[i][3] );
mass8[4]=pgm_read_byte( &lcd_font[i][4] );
mass8[5]=0;
mass8[6]=0;
mass8[7]=0;
    for( ii=0; ii<8; ii++ ) 
    {
     bitWrite( mass[i][0],ii,bitRead(mass8[7-ii],0) );  /////
     bitWrite( mass[i][1],ii,bitRead(mass8[7-ii],1) );
     bitWrite( mass[i][2],ii,bitRead(mass8[7-ii],2) );
     bitWrite( mass[i][3],ii,bitRead(mass8[7-ii],3) );
     bitWrite( mass[i][4],ii,bitRead(mass8[7-ii],4) );
     bitWrite( mass[i][5],ii,bitRead(mass8[7-ii],5) );
     bitWrite( mass[i][6],ii,bitRead(mass8[7-ii],6) );
    } 
    mass[i][15]=0;
 }



// следующие 8 линий на дисплее с переворотом букв шрифта
 for (i=0; i<80; i++) 
 { 
   // размерности mass[80][16] lcd_font[150][5];
mass8[0]=pgm_read_byte( &lcd_font[i+80][0] );
mass8[1]=pgm_read_byte( &lcd_font[i+80][1] );
mass8[2]=pgm_read_byte( &lcd_font[i+80][2] );
mass8[3]=pgm_read_byte( &lcd_font[i+80][3] );
mass8[4]=pgm_read_byte( &lcd_font[i+80][4] );
mass8[5]=0;
mass8[6]=0;
mass8[7]=0;

    for( ii=0; ii<8; ii++ ) 
    {
     bitWrite( mass[i][8],ii,bitRead(mass8[7-ii],0) );  /////
     bitWrite( mass[i][9],ii,bitRead(mass8[7-ii],1) );
     bitWrite( mass[i][10],ii,bitRead(mass8[7-ii],2) );
     bitWrite( mass[i][11],ii,bitRead(mass8[7-ii],3) );
     bitWrite( mass[i][12],ii,bitRead(mass8[7-ii],4) );
     bitWrite( mass[i][13],ii,bitRead(mass8[7-ii],5) );
     bitWrite( mass[i][14],ii,bitRead(mass8[7-ii],6) );
    } 
    mass[i][15]=0;
 }


}  //end Void 



// the loop function runs over and over again forever
void loop() {
  
  PORTC|=B00000001 ; // digitalWrite(S, 1);
  cp1();  // вызов кадрового импульса
  PORTC&=B11111110 ; // digitalWrite(S, 0);
  
//первая строчка 

for (j=0; j<16; j++)  //20-видать будет какойто счетчик, в оперативке  j<16
{ 
 for (i=0; i<80; i++) { // 80->160
                       PORTA=mass[i][j];
                       //if (i==j) PORTD=0xFF; else PORTD=0x00; 
                       cp2(); 
                      } 
cp1(); // перевод строки (вызов кадрового импульса)
}


// все остальные строчки 
PORTA=0;
for (j=0; j<224; j++) {   // 224     240-16строк=224пустые
                        //for (i=0; i<80; i++) {  cp2(); } // можно и убрать это заполнение пустышками оставшейся площади 
                        // но из-за значительно увеличившейся скорости , надо будет настроить контрастность
                        cp1();
                      }



// глянем скока FPS
//if (iii==25) { PORTB|=B00100000 ; }             //  D13_High;    
//if (iii==26) { PORTB &=B11011111 ;  iii=0;  }    //  D13_Low 
//iii++; 
   
}



void cp1()
{ 
//digitalWrite(CP1, 1);  digitalWrite(CP1, 0);  - это оооочень медленно  
  PORTC|=B00000010;  // D9_High;  - это быстрее в 20раз!!!!
  PORTC&=B11111101;  // D9_Low;
}

void cp2()
{
    PORTC |=B00000100; // D10_High;
    PORTC &=B11111011;  // D10_Low; 
//digitalWrite(CP2, 1); digitalWrite(CP2, 0); 
}

у меня 4-х битный экран, выходы управления подправил под мегу. немогу понять как заставить печатать во второй полвине экрана

шлейф:

lcd-adj # lcd +24v # ld3 # ld2 # ld1 # ld0 # lcd +24v # gnd # +5v # cp # lp # flm # nc # dsp-off

я правильно понимаю, шрифтов в нём нет всё придётся как в скетче побайтно рисовать?

slider,  в крайнем скетче что ты скинул можно убрать  двойные WR_Low; WR_Low; и оствить один и будет нормально работать.

Я поменял резисторы в преобразователе уровней. Поставил 680 и 1к и работает на ура.

Можно ли к скетчу как-нибудь прилепить шрифты из какой-нибудь библиотеки?

ID такой же как у вас 0A0A , в чем странность? 

вот лог с LCD_ID_Reader33.ino #comment-410547
 

Read Registers on MCUFRIEND UNO shield
controllers either read as single 16-bit
e.g. the ID is at readReg(0)
or as a sequence of 8-bit values
in special locations (first is dummy)

reg(0x0000) 0A 0A 0A 0A 0A 0A 0A	f.k
reg(0x0001) 00 00 00 00 00 00 00	f.k
reg(0x0002) 01 01 01 01 01 01 01	f.k
reg(0x0003) F8 3F F8 3F F8 3F F8	f.k
reg(0x0004) 01 01 01 01 01 01 01	f.k
reg(0x0005) 01 01 01 01 01 01 01	f.k
reg(0x0006) 01 01 01 01 01 01 01	f.k
reg(0x0007) 01 01 01 01 01 01 01	f.k
reg(0x0008) 02 02 02 02 02 02 02	f.k
reg(0x0009) 01 01 01 01 01 01 01	f.k
reg(0x000A) 01 01 01 01 01 01 01	f.k
reg(0x000B) 01 01 01 01 01 01 01	f.k
reg(0x000C) 01 01 01 01 01 01 01	f.k
reg(0x000D) 01 01 01 01 01 01 01	f.k
reg(0x000E) 01 01 01 01 01 01 01	f.k
reg(0x000F) 01 01 01 01 01 01 01	f.k
reg(0x0010) F0 F0 F0 F0 F0 F0 F0	f.k
reg(0x0011) 90 90 90 90 90 90 90	f.k
reg(0x0012) 01 01 01 01 01 01 01	f.k
reg(0x0013) 00 00 00 00 00 00 00	f.k
reg(0x0014) 00 00 00 00 00 00 00	f.k
reg(0x0015) 00 00 00 00 00 00 00	f.k
reg(0x0016) 00 00 00 00 00 00 00	f.k
reg(0x0017) 00 00 00 00 00 00 00	f.k
reg(0x0018) 00 00 00 00 00 00 00	f.k
reg(0x0019) 00 00 00 00 00 00 00	f.k
reg(0x001A) 00 00 00 00 00 00 00	f.k
reg(0x001B) 00 00 00 00 00 00 00	f.k
reg(0x001C) 00 00 00 00 00 00 00	f.k
reg(0x001D) 00 00 00 00 00 00 00	f.k
reg(0x001E) 50 50 50 50 50 50 50	f.k
reg(0x001F) 01 01 01 01 01 01 01	f.k
reg(0x0020) 00 00 00 00 00 00 00	f.k
reg(0x0021) 00 00 00 00 00 00 00	f.k
reg(0x0022) 00 00 00 00 00 00 00	f.k
reg(0x0023) 00 00 00 00 00 00 00	f.k
reg(0x0024) 00 00 00 00 00 00 00	f.k
reg(0x0025) 00 00 00 00 00 00 00	f.k
reg(0x0026) 01 01 01 01 01 01 01	f.k
reg(0x0027) 01 01 01 01 01 01 01	f.k
reg(0x0028) 01 01 01 01 01 01 01	f.k
reg(0x0029) 01 01 01 01 01 01 01	f.k
reg(0x002A) 01 01 01 01 01 01 01	f.k
reg(0x002B) 01 01 01 01 01 01 01	f.k
reg(0x002C) 01 01 01 01 01 01 01	f.k
reg(0x002D) 01 01 01 01 01 01 01	f.k
reg(0x002E) 01 01 01 01 01 01 01	f.k
reg(0x002F) 01 01 01 01 01 01 01	f.k
reg(0x0030) 80 80 80 80 80 80 80	f.k
reg(0x0031) 00 00 00 00 00 00 00	f.k
reg(0x0032) 01 01 01 01 01 01 01	f.k
reg(0x0033) 00 00 00 00 00 00 00	f.k
reg(0x0034) 00 00 00 00 00 00 00	f.k
reg(0x0035) 00 00 00 00 00 00 00	f.k
reg(0x0036) 00 00 00 00 00 00 00	f.k
reg(0x0037) 00 00 00 00 00 00 00	f.k
reg(0x0038) 00 00 00 00 00 00 00	f.k
reg(0x0039) 00 00 00 00 00 00 00	f.k
reg(0x003A) 00 00 00 00 00 00 00	f.k
reg(0x003B) 00 00 00 00 00 00 00	f.k
reg(0x003C) 00 00 00 00 00 00 00	f.k
reg(0x003D) 00 00 00 00 00 00 00	f.k
reg(0x003E) 00 00 00 00 00 00 00	f.k
reg(0x003F) 00 00 00 00 00 00 00	f.k
reg(0x0040) 00 00 00 00 00 00 00	f.k
reg(0x0041) 01 01 01 01 01 01 01	f.k
reg(0x0042) 33 33 33 33 33 33 33	f.k
reg(0x0043) 01 01 01 01 01 01 01	f.k
reg(0x0044) 09 09 09 09 09 09 09	f.k
reg(0x0045) 02 02 02 02 02 02 02	f.k
reg(0x0046) 05 05 05 05 05 05 05	f.k
reg(0x0047) 01 01 01 01 01 01 01	f.k
reg(0x0048) 01 01 01 01 01 01 01	f.k
reg(0x0049) 01 01 01 01 01 01 01	f.k
reg(0x004A) 00 00 00 00 00 00 00	f.k
reg(0x004B) 00 00 00 00 00 00 00	f.k
reg(0x004C) 06 06 06 06 06 06 06	f.k
reg(0x004D) 01 01 01 01 01 01 01	f.k
reg(0x004E) 01 01 01 01 01 01 01	f.k
reg(0x004F) 00 00 00 00 00 00 00	f.k
reg(0x0050) 00 00 00 00 00 00 00	f.k
reg(0x0051) 00 00 00 00 00 00 00	f.k
reg(0x0052) 01 01 01 01 01 01 01	f.k
reg(0x0053) 01 01 01 01 01 01 01	f.k
reg(0x0054) 02 02 02 02 02 02 02	f.k
reg(0x0055) 01 01 01 01 01 01 01	f.k
reg(0x0056) 01 01 01 01 01 01 01	f.k
reg(0x0057) 01 01 01 01 01 01 01	f.k
reg(0x0058) 01 01 01 01 01 01 01	f.k
reg(0x0059) 01 01 01 01 01 01 01	f.k
reg(0x005A) 00 00 00 00 00 00 00	f.k
reg(0x005B) 00 00 00 00 00 00 00	f.k
reg(0x005C) 00 00 00 00 00 00 00	f.k
reg(0x005D) 01 01 01 01 01 01 01	f.k
reg(0x005E) 01 01 01 01 01 01 01	f.k
reg(0x005F) 01 01 01 01 01 01 01	f.k
reg(0x0060) 00 00 00 00 00 00 00	f.k
reg(0x0061) 00 00 00 00 00 00 00	f.k
reg(0x0062) 29 29 29 29 29 29 29	f.k
reg(0x0063) 00 00 00 00 00 00 00	f.k
reg(0x0064) 00 00 00 00 00 00 00	f.k
reg(0x0065) 02 02 02 02 02 02 02	f.k
reg(0x0066) 03 03 03 03 03 03 03	f.k
reg(0x0067) 01 01 01 01 01 01 01	f.k
reg(0x0068) 07 07 07 07 07 07 07	f.k
reg(0x0069) 07 07 07 07 07 07 07	f.k
reg(0x006A) 02 02 02 02 02 02 02	f.k
reg(0x006B) 02 02 02 02 02 02 02	f.k
reg(0x006C) 01 01 01 01 01 01 01	f.k
reg(0x006D) 01 01 01 01 01 01 01	f.k
reg(0x006E) 01 01 01 01 01 01 01	f.k
reg(0x006F) 01 01 01 01 01 01 01	f.k
reg(0x0070) 00 00 00 00 00 00 00	f.k
reg(0x0071) 00 00 00 00 00 00 00	f.k
reg(0x0072) 29 29 29 29 29 29 29	f.k
reg(0x0073) 00 00 00 00 00 00 00	f.k
reg(0x0074) 00 00 00 00 00 00 00	f.k
reg(0x0075) 02 02 02 02 02 02 02	f.k
reg(0x0076) 03 03 03 03 03 03 03	f.k
reg(0x0077) 01 01 01 01 01 01 01	f.k
reg(0x0078) 01 01 01 01 01 01 01	f.k
reg(0x0079) 01 01 01 01 01 01 01	f.k
reg(0x007A) 01 01 01 01 01 01 01	f.k
reg(0x007B) 01 01 01 01 01 01 01	f.k
reg(0x007C) 01 01 01 01 01 01 01	f.k
reg(0x007D) 01 01 01 01 01 01 01	f.k
reg(0x007E) 01 01 01 01 01 01 01	f.k
reg(0x007F) 01 01 01 01 01 01 01	f.k
reg(0x0080) 81 81 81 81 81 81 81	f.k
reg(0x0081) 44 44 44 44 44 44 44	f.k
reg(0x0082) 15 15 15 15 15 15 15	f.k
reg(0x0083) 3C 3C 3C 3C 3C 3C 3C	f.k
reg(0x0084) 17 17 17 17 17 17 17	f.k
reg(0x0085) 20 20 20 20 20 20 20	f.k
reg(0x0086) 17 17 17 17 17 17 17	f.k
reg(0x0087) 01 01 01 01 01 01 01	f.k
reg(0x0088) 01 01 01 01 01 01 01	f.k
reg(0x0089) 01 01 01 01 01 01 01	f.k
reg(0x008A) 01 01 01 01 01 01 01	f.k
reg(0x008B) 01 01 01 01 01 01 01	f.k
reg(0x008C) 01 01 01 01 01 01 01	f.k
reg(0x008D) 01 01 01 01 01 01 01	f.k
reg(0x008E) 01 01 01 01 01 01 01	f.k
reg(0x008F) 01 01 01 01 01 01 01	f.k
reg(0x0090) 15 15 15 15 15 15 15	f.k
reg(0x0091) 01 01 01 01 01 01 01	f.k
reg(0x0092) 15 15 15 15 15 15 15	f.k
reg(0x0093) 01 01 01 01 01 01 01	f.k
reg(0x0094) 01 01 01 01 01 01 01	f.k
reg(0x0095) 01 01 01 01 01 01 01	f.k
reg(0x0096) 01 01 01 01 01 01 01	f.k
reg(0x0097) 01 01 01 01 01 01 01	f.k
reg(0x0098) 01 01 01 01 01 01 01	f.k
reg(0x0099) 01 01 01 01 01 01 01	f.k
reg(0x009A) 01 01 01 01 01 01 01	f.k
reg(0x009B) 01 01 01 01 01 01 01	f.k
reg(0x009C) 01 01 01 01 01 01 01	f.k
reg(0x009D) 01 01 01 01 01 01 01	f.k
reg(0x009E) 01 01 01 01 01 01 01	f.k
reg(0x009F) 01 01 01 01 01 01 01	f.k
reg(0x00A0) 00 00 00 00 00 00 00	f.k
reg(0x00A1) 00 00 00 00 00 00 00	f.k
reg(0x00A2) 00 00 00 00 00 00 00	f.k
reg(0x00A3) 00 00 00 00 00 00 00	f.k
reg(0x00A4) 00 00 00 00 00 00 00	f.k
reg(0x00A5) 00 00 00 00 00 00 00	f.k
reg(0x00A6) 00 00 00 00 00 00 00	f.k
reg(0x00A7) 00 00 00 00 00 00 00	f.k
reg(0x00A8) 01 01 01 01 01 01 01	f.k
reg(0x00A9) 01 01 01 01 01 01 01	f.k
reg(0x00AA) 01 01 01 01 01 01 01	f.k
reg(0x00AB) 01 01 01 01 01 01 01	f.k
reg(0x00AC) 01 01 01 01 01 01 01	f.k
reg(0x00AD) 01 01 01 01 01 01 01	f.k
reg(0x00AE) 01 01 01 01 01 01 01	f.k
reg(0x00AF) 01 01 01 01 01 01 01	f.k
reg(0x00B0) 01 01 01 01 01 01 01	f.k
reg(0x00B1) 01 01 01 01 01 01 01	f.k
reg(0x00B2) 01 01 01 01 01 01 01	f.k
reg(0x00B3) 01 01 01 01 01 01 01	f.k
reg(0x00B4) 01 01 01 01 01 01 01	f.k
reg(0x00B5) 01 01 01 01 01 01 01	f.k
reg(0x00B6) 01 01 01 01 01 01 01	f.k
reg(0x00B7) 01 01 01 01 01 01 01	f.k
reg(0x00B8) 01 01 01 01 01 01 01	f.k
reg(0x00B9) 01 01 01 01 01 01 01	f.k
reg(0x00BA) 01 01 01 01 01 01 01	f.k
reg(0x00BB) 01 01 01 01 01 01 01	f.k
reg(0x00BC) 01 01 01 01 01 01 01	f.k
reg(0x00BD) 01 01 01 01 01 01 01	f.k
reg(0x00BE) 01 01 01 01 01 01 01	f.k
reg(0x00BF) 01 01 01 01 01 01 01	f.k
reg(0x00C0) 02 02 02 02 02 02 02	f.k
reg(0x00C1) 08 08 08 08 08 08 08	f.k
reg(0x00C2) 08 08 08 08 08 08 08	f.k
reg(0x00C3) 01 01 01 01 01 01 01	f.k
reg(0x00C4) 00 00 00 00 00 00 00	f.k
reg(0x00C5) 00 00 00 00 00 00 00	f.k
reg(0x00C6) 00 00 00 00 00 00 00	f.k
reg(0x00C7) 00 00 00 00 00 00 00	f.k
reg(0x00C8) 01 01 01 01 01 01 01	f.k
reg(0x00C9) FF FF FF FF FF FF FF	f.k
reg(0x00CA) 01 01 01 01 01 01 01	f.k
reg(0x00CB) FF FF FF FF FF FF FF	f.k
reg(0x00CC) 01 01 01 01 01 01 01	f.k
reg(0x00CD) FF FF FF FF FF FF FF	f.k
reg(0x00CE) 01 01 01 01 01 01 01	f.k
reg(0x00CF) FF FF FF FF FF FF FF	f.k
reg(0x00D0) 6F 6F 6F 6F 6F 6F 6F	f.k
reg(0x00D1) 76 76 76 76 76 76 76	f.k
reg(0x00D2) 00 00 00 00 00 00 00	f.k
reg(0x00D3) 08 08 08 08 08 08 08	f.k
reg(0x00D4) 08 08 08 08 08 08 08	f.k
reg(0x00D5) 01 01 01 01 01 01 01	f.k
reg(0x00D6) FF FF FF FF FF FF FF	f.k
reg(0x00D7) 01 01 01 01 01 01 01	f.k
reg(0x00D8) FF FF FF FF FF FF FF	f.k
reg(0x00D9) 01 01 01 01 01 01 01	f.k
reg(0x00DA) FF FF FF FF FF FF FF	f.k
reg(0x00DB) 01 01 01 01 01 01 01	f.k
reg(0x00DC) FF FF FF FF FF FF FF	f.k
reg(0x00DD) 01 01 01 01 01 01 01	f.k
reg(0x00DE) 01 01 01 01 01 01 01	f.k
reg(0x00DF) 01 01 01 01 01 01 01	f.k
reg(0x00E0) 01 01 01 01 01 01 01	f.k
reg(0x00E1) 00 00 00 00 00 00 00	f.k
reg(0x00E2) 00 00 00 00 00 00 00	f.k
reg(0x00E3) 01 01 01 01 01 01 01	f.k
reg(0x00E4) 01 01 01 01 01 01 01	f.k
reg(0x00E5) 01 01 01 01 01 01 01	f.k
reg(0x00E6) 01 01 01 01 01 01 01	f.k
reg(0x00E7) 01 01 01 01 01 01 01	f.k
reg(0x00E8) 01 01 01 01 01 01 01	f.k
reg(0x00E9) 01 01 01 01 01 01 01	f.k
reg(0x00EA) 01 01 01 01 01 01 01	f.k
reg(0x00EB) 01 01 01 01 01 01 01	f.k
reg(0x00EC) 01 01 01 01 01 01 01	f.k
reg(0x00ED) 01 01 01 01 01 01 01	f.k
reg(0x00EE) 01 01 01 01 01 01 01	f.k
reg(0x00EF) 01 01 01 01 01 01 01	f.k
reg(0x00F0) 01 01 01 01 01 01 01	f.k
reg(0x00F1) 01 01 01 01 01 01 01	f.k
reg(0x00F2) 01 01 01 01 01 01 01	f.k
reg(0x00F3) 01 01 01 01 01 01 01	f.k
reg(0x00F4) 01 01 01 01 01 01 01	f.k
reg(0x00F5) 01 01 01 01 01 01 01	f.k
reg(0x00F6) 01 01 01 01 01 01 01	f.k
reg(0x00F7) 01 01 01 01 01 01 01	f.k
reg(0x00F8) 01 01 01 01 01 01 01	f.k
reg(0x00F9) 01 01 01 01 01 01 01	f.k
reg(0x00FA) 01 01 01 01 01 01 01	f.k
reg(0x00FB) 01 01 01 01 01 01 01	f.k
reg(0x00FC) 01 01 01 01 01 01 01	f.k
reg(0x00FD) 01 01 01 01 01 01 01	f.k
reg(0x00FE) 01 01 01 01 01 01 01	f.k
reg(0x00FF) 01 01 01 01 01 01 01	f.k

Если предположить что не так с чтением , то надо подключать по 16бит - дело верняк, чтение будет 100%.

Размах , и осцил не надо, достаточно померить мультиметром куда постоянно подается лог.1  Reset , RD .
питание ардуины 5.00в , на стабе 3.30в , через 10 Ом на белых светодиодах (1+~5подсветки)  2.80в , на пинах  Reset , RD 3.40в  (вольтметр высокоточный)   , оно и понятно , в микросхемах же ставят защитные диоды на вывода, к + и - питания.   Лог.1   5.0в  идет через   10ком   , на защитном диоде осело 0.6в , ушло на питание. (при наргеве и морозе будут немного другое напряжение на "стабилитроне") .
     Если бы не поставил параллельно питанию диспа , белые светодиоды ограничивающие напряжение как стабилитроны, то питание 3.3в взятое с ардуины , взлетело бы выше 4.5 и спалило бы дисп, из-за много лог.1 через 10ком , пересиливающие потребности контроллера диспа на старте , когда еще инит ему не скормлен и внутренние преобразователи не запущены.

   В даташитах иногда пишут , что напряжения на входах не должно превышать напряжение питания на 0.6в , оно и понятно , иначе пересилится питание контроллера и он скончается.

ну если  680 и 1к то хорошо тока хватит, а через 10к он слабый, даже если тыкнуться мультиметром или осциллографом после них ( WR, RS(CD) ) , уже дисп косячит , то другие цвета покажет , то типа битые пиксели. Вот и приходится ставить задержки. 

Зачем лепить шрифты из либы? проще подменить в понравившейся либе,  инит на свой , и номера регистров посредством которых идет рисование.

К примеру UTFT   C:\Users\.....\Documents\Arduino\libraries\UTFT\tft_drivers\ili9325c 
по аналогии с ILI9325 , названия регистров в setxy.h  посмотреть с его даташита или в initlcd.h они расписаны. x1 x2 y1 y2 оставляем (либа заносит в них координаты, цвет, сдвигает для 8бит ) 
В initlcd.h забить данные со своего инита.
  Ну а дальше как обычно.

Да хрен там! Не получается у меня. Надо в других файлах что-то менять?

Может пины по другому подключать?

ну, млин...
оставить подключение такое же.
вот заготовил как получилось ,  : UTFT v2.82  MagnaChip D54E4PA7551 дисп от LG .rar 

https://yadi.sk/d/BnFmbOp-Oaybzw

распаковать в Arduino\libraries . Пример запустить UTFT\examples\Arduino (AVR)\UTFT_Demo_400x240

даташиты UPD161710.pdf  UPD161704A.pdf (он по красивше цветастей про регистры, стр122)  на всяк случай закинул их в UTFT\tft_drivers\ili9325c 

 setxy.h составил методом тыка , что то наобум , надо сильно вдумываться и экспериментировать чтоб сделать поуму , иногда от очередности очень сильно зависит. От старшего байта по Y(X)  м.б. избавиться , поэспериментировать закомментить , ибо 240 не больше 255 . (это в другой координате 400пикс больше 255 , и используется старший байт) , как получилось здесь избавиться
#comment-93736

Надо еще отзеркалить  , для этого надо экспериментировать в initlcd.h , не все там регистры , смотреть  даташиты , искать (scan , mirror ) хоть какие-то сходства в "родственниках" попавшегося контроллера.    Увеличить частоту обновления экрана, еще бы.

!!! LCD_Write_COM_DATA(0x30,0x01); /* 0x81 Select the display-RAM data */   // 0x01 Зеркалит по горизонтали !!!
но буквы по прежнему наоборот , хотя уже на своих местах.

Есть подозрения , что это надо  setxy.h  правильно сделать. мож что croc19 подскажет. Как будто библиотека рисует букву наоборот.  

и помнить , что в даташитах UPD... ,  регистры написали в десятичной системе , надо помнить переводить.

// на крайняк , попробуйте инит в старый Adafruit внедрить к похожему по рисованию ili9320 контроллеру. В споследних Adafruit , MCUfriend_kvb м.б. будет трудно разобраться.

croc19  как правильно рисовать ? и почему в ориг. либе рисуется через  1A 1B 1C 
 

Рисование из либы SEGGER от EmWIN  , под STM32:
static void _SetPhysRAMAddr(int x, int y) {
x -= _x0;
y -= _y0;
LCD_WRITE_A0(REG_RAM_ADDR_H);     LCD_WRITE_A1(x);         // 0x1A,x         - Horizontal RAM address  
LCD_WRITE_A0(REG_RAM_ADDR_V_LB);  LCD_WRITE_A1(y & 0xff);  // 0x1B,y&0xff    - Vertical   RAM address, low  byte 
LCD_WRITE_A0(REG_RAM_ADDR_V_HB);  LCD_WRITE_A1(y >> 8);    // 0x1C,y>>8      - Vertical   RAM address, high byte 
LCD_WRITE_A0(REG_RAM_ACCESS);  

, иль что я не усмотрел.
 

вот собрал как что у других контроллеров в setxy.h :

case ILI9325C:

//        названия регистров из найденного инита  D54E4PA7551                      названия регистров ILI9320       
 //  предположительно:
 //  LCD_Write_COM_DATA(0x1A,x1); /* - Horizontal RAM address */                // 0x20,x1; GRAM horizontal Address 
 //  LCD_Write_COM_DATA(0x1B,y1); /* - Vertical   RAM address, low  byte */    //  0x21,y1; GRAM Vertical Address  
 //  LCD_Write_COM_DATA(0x1C,y2); /* - Vertical   RAM address, high byte */

// как получилось:
	LCD_Write_COM_DATA(0x13,x1); /* - Horizontal start address */               // 0x50,x1  Horizontal GRAM Start Address  
	LCD_Write_COM_DATA(0x14,y1); /* - Vertical   start address, low  byte */    // 0x52,y1  Vertical GRAM Start Address  

	LCD_Write_COM_DATA(0x16,x2); /* - Horizontal end   address */               // 0x51,x2  Horizontal GRAM End Address 
	LCD_Write_COM_DATA(0x17,y2); /* - Vertical   end   address, low  byte */    // 0x53,y2  Vertical GRAM Start Address 

	LCD_Write_COM_DATA(0x15,y1>>8);/* - Vertical   start address, high byte */
	LCD_Write_COM_DATA(0x18,y2>>8);/* - Vertical   end   address, high byte */

    LCD_Write_COM(0x03);

	break;

/*
 рисование ILI9320 у Adafruit:
    writeRegister16(0x0050, x1);  Set address window
    writeRegister16(0x0051, x2);      согласно даташиту ili9320 использование H(старшего) L(младшего) байтов:
    writeRegister16(0x0052, y1);      R50,R51-8бит   R52,R53-16бит(9) (9бит - т.к. 320пикс , а это немного больше 255 8бит)   
    writeRegister16(0x0053, y2);
    writeRegister16(0x0020, x );  Set address counter to top left
    writeRegister16(0x0021, y );     R20-8бит используются   R21-16бит(9) используются   
	
	
рисование ILI9325C в UTFT:
	LCD_Write_COM_DATA(0x20,x1);   GRAM horizontal Address 
	LCD_Write_COM_DATA(0x21,y1);   GRAM Vertical Address
	LCD_Write_COM_DATA(0x50,x1);   Horizontal GRAM Start Address 
	LCD_Write_COM_DATA(0x52,y1);   Vertical GRAM Start Address
	LCD_Write_COM_DATA(0x51,x2);   Horizontal GRAM End Address
	LCD_Write_COM_DATA(0x53,y2);   Vertical GRAM Start Address
	LCD_Write_COM(0x22); 


Рисование из либы SEGGER от EmWIN  , под STM32:
static void _SetPhysRAMAddr(int x, int y) {
x -= _x0;
y -= _y0;
LCD_WRITE_A0(REG_RAM_ADDR_H);     LCD_WRITE_A1(x);         // 0x1A,x         - Horizontal RAM address  
LCD_WRITE_A0(REG_RAM_ADDR_V_LB);  LCD_WRITE_A1(y & 0xff);  // 0x1B,y&0xff    - Vertical   RAM address, low  byte 
LCD_WRITE_A0(REG_RAM_ADDR_V_HB);  LCD_WRITE_A1(y >> 8);    // 0x1C,y>>8      - Vertical   RAM address, high byte 
LCD_WRITE_A0(REG_RAM_ACCESS);                              // 0x03           - RAM access mode 


рисование  ILI9327
	LCD_Write_COM(0x2a);
  	LCD_Write_DATA(0x00,x1>>8);
  	LCD_Write_DATA(0x00,x1);
  	LCD_Write_DATA(0x00,x2>>8);
  	LCD_Write_DATA(0x00,x2);
  	LCD_Write_COM(0x2b);
  	LCD_Write_DATA(0x00,y1>>8);
  	LCD_Write_DATA(0x00,y1);
  	LCD_Write_DATA(0x00,y2>>8);
  	LCD_Write_DATA(0x00,y2);
  	LCD_Write_COM(0x2c); 


рисование  SPFD5420A при заброске 16бит для 16бит дисп.:
LCD_Write_COM16_DATA16(0x0200,x1); // GRAM Address Set (Horizontal Address) (R20h)
LCD_Write_COM16_DATA16(0x0201,y1); // GRAM Address Set (Vertical Address) (R21h)
LCD_Write_COM16_DATA16(0x0210,x1);   // Window Horizontal RAM Address Start (R210h)
LCD_Write_COM16_DATA16(0x0212,y1);   // Window Vertical RAM Address Start (R212h)
LCD_Write_COM16_DATA16(0x0211,x2);   // Window Horziontal RAM Address End (R211h)
LCD_Write_COM16_DATA16(0x0213,y2);   // Window Vertical RAM Address End (R213h)
LCD_Write_COM16(0x0202);

// функция для 16ти битнной адресации к регистрам + передача 16ти битных данных :
void UTFT::LCD_Write_COM16_DATA16(int com16,int dat16)  // *********** добавил  ************
{
		cbi(P_RS, B_RS);  // передаём команду в дисплей 
		LCD_Writ_Bus(com16>>8);
		LCD_Writ_Bus(com16);
		sbi(P_RS, B_RS); // предаём данные в дисплей
		LCD_Writ_Bus(dat16>>8);
        LCD_Writ_Bus(dat16);
}

void UTFT::LCD_Write_COM16(int com16)        // *********** добавил ****************
{    		
        cbi(P_RS, B_RS);   
		LCD_Writ_Bus(com16>>8);
		LCD_Writ_Bus(com16);
}


рисование  ili9326  8bit:
LCD_Write_COM16_DATA16(0x0200,x1); // GRAM Address Set (Horizontal Address) (R0200h)
LCD_Write_COM16_DATA16(0x0201,y1); // GRAM Address Set (Vertical Address) (R0201h)
LCD_Write_COM16_DATA16(0x0210,x1);   // Window Horizontal RAM Address Start (R210h)
LCD_Write_COM16_DATA16(0x0212,y1);   // Window Vertical RAM Address Start (R212h)
LCD_Write_COM16_DATA16(0x0211,x2);   // Window Horziontal RAM Address End (R211h)
LCD_Write_COM16_DATA16(0x0213,y2);   // Window Vertical RAM Address End (R213h)
LCD_Write_COM16(0x0202); 


рисование  HX8352A  8bit  только такая последовательность:
//  	LCD_Write_COM_DATA(0x02,x1>>8); 
LCD_Write_COM_DATA(0x03,x1);	
//  	LCD_Write_COM_DATA(0x04,x2>>8); 
LCD_Write_COM_DATA(0x05,x2);
LCD_Write_COM_DATA(0x06,y1>>8);
LCD_Write_COM_DATA(0x07,y1);
//  	LCD_Write_COM_DATA(0x08,y2>>8); 
//   	LCD_Write_COM_DATA(0x09,y2);    
LCD_Write_COM(0x22);

	
*/

черкнул скетч который рисует квадратики , используя рисование только через регистры 1A 1B 1C

#define LCD_RST 41//4
#define LCD_CS 40//A3
#define LCD_RS 38//A2
    #define RS_High PORTD|=B10000000  // PD 7 D38
    #define RS_Low PORTD&=B01111111 // PD 7 D38
#define LCD_WR 39//A1
    #define WR_High PORTG|=B00000100  // PG 2 D39
    #define WR_Low PORTG&=B11111011 // PG 2 D39
#define LCD_RD 42//45 A0  

#define LCD_D0 22//8
#define LCD_D1 23//9
#define LCD_D2 24//2
#define LCD_D3 25//3
#define LCD_D4 26//4
#define LCD_D5 27//
#define LCD_D6 28//6
#define LCD_D7 29//7

#define BLACK   0x0000
#define BLUE    0x001F
#define RED     0xF800
#define GREEN   0x07E0
#define CYAN    0x07FF
#define MAGENTA 0xF81F
#define YELLOW  0xFFE0
#define WHITE   0xFFFF

uint16_t x,y,x0,y0, ii ;
uint16_t color0;

void setup() {
  lcdInit();  // настройка пинов
  delay(100);
  lcdReset();
  delay(500);
  lcdRegisterOther(); // инит
}

// **************************************************************************************************
void loop() {

lcd_clr(BLACK); // заливка всего экрана
delay(500);

 for (ii=0; ii<50; ii++) // количество квадратов , а потом стереть
 { 
 x0=random(349); //349  с учетом длины квадрата 50 399макс
 y0=random(189); //189  с учетом длины квадрата 50 239макс
// x0=20; y0=10; // глянуть где начало координат , оно вверху слева
 color0=random(65534);

   for (y=y0; y<y0+50; y++) 
   {
    // зададим начальные координаты
    //if (y>239) y=239; 
    //if (x>399) x=399;
    lcdWriteRegister(0x1A,y);   /* - Horizontal RAM address */ 
    lcdWriteRegister(0x1B,x);    /* - Vertical   RAM address, low  byte */
    lcdWriteRegister(0x1C,x>>8 ); /* - Vertical   RAM address, high byte */
    lcdWriteCommand (0x03); 

       // нарисуем горизонтальную линию
       for (x=x0; x<x0+50; x++) 
       {
       // if (x>399) break;
       lcdWriteData (color0 >> 8);
       lcdWriteData (color0); 
       }      
    }   
 delay(500);
 }
 
}


void lcdRegisterOther() {
lcdWriteRegister(0xC0, 0x00); /* Internal EEPROM */ 
lcdWriteRegister(0xC0, 0x02); /* Internal EEPROM */ 
delay(10);
lcdWriteRegister(0xC0,0x00); /* Internal EEPROM */               
lcdWriteRegister(0x68,0x41); /* COM-pp */                                   
lcdWriteRegister(0x69,0x7D); /* COM-center */                                
lcdWriteRegister(0x01,0x02); /* 8bit 8/8 transfer */                         
lcdWriteRegister(0x08,0x00); /* Normally black */                           
lcdWriteRegister(0x10,0xF0); /* Panel X-size=240 */                          
lcdWriteRegister(0x11,0x90); /* Panel Y-size=400 */                          
lcdWriteRegister(0x12,0x01); /* Panel Y-size=400 */                         
lcdWriteRegister(0x1E,0x50); /* Number of vertical line=400 */              
lcdWriteRegister(0x1D,0x07); /* RAM write direction :landscape */           
lcdWriteRegister(0x1A,0xEF); /* RAM pointer X */                             
lcdWriteRegister(0x1B,0x8F); /* RAM pointer Y */                            
lcdWriteRegister(0x1C,0x01); /* RAM pointer Y */                            
lcdWriteRegister(0x30,0x81); /* Select the display-RAM data */    

 //    lcdWriteRegister(0x32,0x01);       // R50=0x32     Scan   - нифига не влияет
 //    lcdWriteRegister(0x01,0x01);     // тож не зеркалит , надо для него как-то переключать регистовую память в Register MODE 3,4 
// А вообще надо искать родной даташит  , или подобный , или  его соседний

lcdWriteRegister(0x33,0x02); /* Non-display data color */                   
lcdWriteRegister(0x42,0x70); /* Vertical front poach=112h */                
lcdWriteRegister(0x43,0x01); /* Vertical back poach=1h */                    
lcdWriteRegister(0x44,0x3F); /* =3F H scan interval=96clock */                   
lcdWriteRegister(0x45,0x14); /* GSP start position=10clock */                
lcdWriteRegister(0x46,0x0F); /* GCK start position=15clock */                
lcdWriteRegister(0x48,0x03); /* COM inversion position=3clock */             
lcdWriteRegister(0x4A,0x01); /* Signal setting */                            
lcdWriteRegister(0x4B,0xA8); /* SSD setting */                               
lcdWriteRegister(0x4C,0x12); /* ASW start position=18clock */                
lcdWriteRegister(0x5A,0x00); /* Battery pull-out detection off */            
lcdWriteRegister(0x62,0x52); /* ASW width10, interval2clock */               
lcdWriteRegister(0x65,0x02); /* AMP bias current setting */                 
lcdWriteRegister(0x66,0x06); /* VGM5.2V */                                   
lcdWriteRegister(0x6A,0x02); /* VCOM output */                               
lcdWriteRegister(0x81,0x44); /* VR,VS boost clock setting */                
lcdWriteRegister(0x82,0x2D); /* DCK,DCKB timing setting */                   
lcdWriteRegister(0x83,0x25); /* DCDC Dual, AVR,5.2V,DCDC drivability=min */  
lcdWriteRegister(0x84,0x17); /* VR setting */                                
lcdWriteRegister(0x85,0x27); /* DCDC Dual, AVS5.4V,DCDC drivability=min */  
lcdWriteRegister(0x86,0x17); /* VS setting */                                
lcdWriteRegister(0x90,0x25); /* Auto ON timing setting */                   
lcdWriteRegister(0x91,0x05); /* Auto ON/OFF setting(1V) */                  
lcdWriteRegister(0x92,0x15); /* Auto OFF timing setting */                  
lcdWriteRegister(0x31,0x01); /* VAL */                                       
lcdWriteRegister(0x19,0x01); /* Window access mode */  

   // зададим пределы  Y
   lcdWriteRegister(0x13, 0x00); /* - Horizontal start address */   
   lcdWriteRegister(0x16, 0xEF); /* - Horizontal end   address F0 конец*/
   // зададим пределы  X
   lcdWriteRegister(0x14, 0x00); /* - Vertical   start address, low  byte */
   lcdWriteRegister(0x15, 0x00); /* - Vertical   start address, high byte */
   lcdWriteRegister(0x17, 0x8F); /* - Vertical   end   address, low  byte  018F конец*/
   lcdWriteRegister(0x18, 0x01); /* - Vertical   end   address, high byte  01 конец*/
   // начальные координаты (необязательно)
   lcdWriteRegister(0x1A,0x00);  /* - Horizontal RAM address */    
   lcdWriteRegister(0x1B,0x00);  /* - Vertical   RAM address, low  byte */
   lcdWriteRegister(0x1C,0x00);  /* - Vertical   RAM address, high byte */

lcdWriteRegister(0x3E, 0x01);
delay(120);
}

void lcdInit() {
  pinMode(LCD_CS, OUTPUT);
  digitalWrite(LCD_CS, LOW);
  pinMode(LCD_RS, OUTPUT);
  digitalWrite(LCD_RS, HIGH);
  pinMode(LCD_WR, OUTPUT);
  digitalWrite(LCD_WR, HIGH);
  pinMode(LCD_RD, OUTPUT);
  digitalWrite(LCD_RD, HIGH);
  pinMode(LCD_RST, OUTPUT);
  digitalWrite(LCD_RST, HIGH); 
  lcdSetWriteDir(); 
}

void lcdReset() {
  digitalWrite(LCD_RST, LOW);
  delay(50); 
  digitalWrite(LCD_RST, HIGH);
  delay(50); 
}

void lcdWrite8(uint8_t data) {// было uint16_t
 PORTA=data; 
}

void lcdSetWriteDir() {
  pinMode(LCD_D0, OUTPUT);
  pinMode(LCD_D1, OUTPUT);
  pinMode(LCD_D2, OUTPUT);
  pinMode(LCD_D3, OUTPUT);  
  pinMode(LCD_D4, OUTPUT);  
  pinMode(LCD_D5, OUTPUT);
  pinMode(LCD_D6, OUTPUT);
  pinMode(LCD_D7, OUTPUT);  
}

void lcdWriteData(uint8_t data) { 
 RS_High; 
 WR_High; 
 lcdWrite8(data);
 WR_Low; WR_Low; 
 WR_High;  
}

void lcdWriteCommand(uint8_t command) {
 RS_Low; 
 WR_High; 
 lcdWrite8(command);
 WR_Low; WR_Low; 
 WR_High; 
 RS_High; 
}

void lcdWriteRegister(uint8_t addr, uint8_t data){
  lcdWriteCommand(addr);
  lcdWriteData(data);
}

void lcd_clr(uint16_t color) { //заливка цветом весь экран
//   lcdWriteRegister(0x13, 0x00); /* - Horizontal start address */   
//   lcdWriteRegister(0x16, 0xEF); /* - Horizontal end   address F0 конец*/ 
//   lcdWriteRegister(0x14, 0x00); /* - Vertical   start address, low  byte */
//   lcdWriteRegister(0x15, 0x00); /* - Vertical   start address, high byte */
//   lcdWriteRegister(0x17, 0x8F); /* - Vertical   end   address, low  byte 90 конец*/
//   lcdWriteRegister(0x18, 0x01); /* - Vertical   end   address, high byte  01 конец*/

// зададим начальные координаты
lcdWriteRegister(0x1A,0x00);
lcdWriteRegister(0x1B,0x00);
lcdWriteRegister(0x1C,0x00);
lcdWriteCommand (0x03);  //принять координаты и быть готовым принимать данные о цвете, 
// автоинкремент координат пикселя происходит сам собой (благодаря настройкам в ините)

  uint32_t i = 400; 
  i *=240;//  = 96000
  do{
   // color=random(65534);
  lcdWriteData (color >> 8);
  lcdWriteData (color);
  }while( i-- );
  
}

Generik, не понятно не видать что у вас и как , попробуйте с аналогией с 1602 (там  8бит посылается как 2раза по 4бита)