Arduino.ru

Нашёл следующий комментарий:

По просьбе в коментариях в ютубе выкладываю скетч( в общем-то, заготовки).

/*     В общем-то готовая программа стрелочных часиков. Переделал скетч из интернета
 *    http://arduino-project.net/analog-clock-arduino-mega/    
 */






//Подключение библиотек
#include <SPI.h>
#include <Adafruit_GFX.h>
#include <TFT_ILI9163C.h>
#include <DS3231.h>//
#include <Wire.h>//

DS3231  rtc(SDA, SCL);//Что-то про часики
Time  t;

// Color definitions
#define  BLACK   0x0000
#define BLUE    0x001F
#define RED     0xF800
#define GREEN   0x07E0
#define CYAN    0x07FF
#define MAGENTA 0xF81F
#define YELLOW  0xFFE0
#define MARENGO 0x4C5866//Это я добавил цвет маренго.Ни че так фончик.
#define WHITE   0xFFFF

#define __CS 10
#define __DC 8
TFT_ILI9163C tft = TFT_ILI9163C(__CS, __DC);


//Центральные координаты для рисования стрелочных часов
int clockCenterX=64;//Центр экрана (поправил по своему размеру)
int clockCenterY=64;//Центр экрана (поправил по своему размеру)
int oldsec=0;
byte cradius=64;
 
void setup(){

  tft.begin();
  //tft.setRotation(1);//Поворачиваем экран на 90 град.
  rtc.begin();//Инициализируем часики
  tft.setTextSize(2);//Пока этор размер шрифта
  pinMode(12, OUTPUT);
  pinMode(7, OUTPUT);
  digitalWrite(12, HIGH);
     
  /*Для установки времени, введите ваши параметры и 
  раскомментируйте 3 строки ниже и загрузите скетч
  на ардуино,а потом назад закомментируйте обратно*/
  
  //rtc.setTime(22, 25,0);     
  //rtc.setDate(19,10, 2015);
  //rtc.setDOW(MONDAY); 
}
 
void drawDisplay()//Функция как понимаю рисует дисплей
{
  // Очистка дисплея
  tft.clearScreen(BLACK);//Пока не знаю зачем, видимо очищает весь экран и делает его черным
  //ДАЛЕЕ ЗАКОМЕНТИРОВАННЫЙ КУСОК, ПОКА НЕ ИСПОЛЬЗОВАЛ
  //Отображение текущей даты
//tft.setCursor(0,0);
//tft.setTextColor(CYAN);//Пробуем задать цвет текста 
//tft.print(String(rtc.getDateStr()));//Пишем дату


  
  //Отображение дня недели
//tft.setCursor(0,0);
//tft.setTextColor(RED);
//tft.print(rtc.getDOWStr());

  
  // Рисуем циферблат
    
      tft.fillCircle(clockCenterX, clockCenterY, cradius, GREEN);//Рисуем сплошной
                                       // круг зеленого цвета радиусом cradius
      tft.fillCircle(clockCenterX, clockCenterY, cradius-2, MARENGO);//Рисуем сплошной
                                      //круг цветом фона. Получаем окружность
    tft.fillCircle(clockCenterX, clockCenterY, 4, GREEN);//Рисуем внутренний кружочек
    tft.fillCircle(clockCenterX, clockCenterY, 2, BLACK);//Рисуем в в нем дырочку
    tft.fillCircle(clockCenterX, clockCenterY, 1, GREEN);//Рисуем ось
  
  //Отображаем числа на циферблате
  tft.setTextColor(YELLOW);
  tft.setCursor(clockCenterX+52,clockCenterY-6);
  tft.print("3");
  tft.setCursor(clockCenterX-5,clockCenterY+48);
  tft.print("6");
  tft.setCursor(clockCenterX-60,clockCenterY-6);
  tft.print("9");
  tft.setCursor(clockCenterX-12,clockCenterY-61);
  tft.print("12");//Кружочек с цифирками нарисовали!!!!
  
  //Рисуем метки часов в виде рысочек
  for (int i=0; i<12; i++)
  {
    if ((i % 3)!=0)//исключаем рисочки где стоят циферки
      drawMark(i);//Идем на функцию, которая рисует рисочки между цифрами
  }  
  t = rtc.getTime();//Получаем время с RTC
  drawMin(t.min);//Идем на функцию рисовки стрелки минут
  drawHour(t.hour, t.min);//Идем на функцию рисовки стрелки часов
  drawSec(t.sec);
  oldsec=t.sec;
}
 
void drawMark(int h)//Отрисовка меток, рисочек между цифрами
{
  float x1, y1, x2, y2;
  
  h=h*30;
  h=h+270;
  //Дальше в формулах были цифры 55,55,50,50.....было красиво
  x1=59*cos(h*0.0175);//Если сделать первую цифру, например, 55, то рисочки не будут 
  y1=59*sin(h*0.0175);//доставать до окружности циферблата....красиво
  x2=52*cos(h*0.0175);//Здесь можно поиграть с длиной
  y2=52*sin(h*0.0175);// рисочек
  
  tft.drawLine(int (x1)+clockCenterX, int (y1)+clockCenterY, int (x2)+clockCenterX, int (y2)+clockCenterY,YELLOW);
      Serial.println("str 110");
}
 
void drawSec(int s)//отрисовка секундной стрелки
{
  float x1, y1, x2, y2;
  int ps = s-1;
  
  if (ps==-1)
    ps=59;
  ps=ps*6;
  ps=ps+270;
  
  x1=45*cos(ps*0.0175);//Параметры для секундной стрелки
  y1=45*sin(ps*0.0175);//вроде бы оптимальные
  x2=6*cos(ps*0.0175);//может только посмотреть
  y2=6*sin(ps*0.0175);//не портит ли внутренний кружочек
  
  tft.drawLine(int (x1+clockCenterX), int (y1+clockCenterY), int (x2+clockCenterX), int (y2+clockCenterY),MARENGO);
 
  s=s*6;
  s=s+270;
  
  x1=45*cos(s*0.0175);
  y1=45*sin(s*0.0175);
  x2=6*cos(s*0.0175);
  y2=6*sin(s*0.0175);
  
  tft.drawLine(int (x1+clockCenterX), int (y1+clockCenterY), int (x2+clockCenterX), int (y2+clockCenterY),YELLOW);
  digitalWrite(7, HIGH);
  delayMicroseconds(1);
  digitalWrite(7, LOW);
  
}
 
void drawMin(int m)//отрисовка минутной стрелки
{
  float x1, y1, x2, y2, x3, y3, x4, y4;
  int pm = m-1;//Вычисляем прошлую минуту
  
//tft.setColor(0, 0, 0);
  if (pm==-1)//Приводим к нормальному виду, если надо
    pm=59;
  pm=pm*6;
  pm=pm+270;
  
  x1=47*cos(pm*0.0175);//Длина стрелки 48 вроде 48 лучше
  y1=47*sin(pm*0.0175);//Длина стрелки 48
  x2=6*cos(pm*0.0175);//было 5
  y2=6*sin(pm*0.0175);//было 5
  x3=30*cos((pm+8)*0.0175);//было 28 4 8
  y3=30*sin((pm+8)*0.0175);//было 28 4 8
  x4=30*cos((pm-8)*0.0175);//было 28 4 8
  y4=30*sin((pm-8)*0.0175);//было 28 4 
  
  tft.drawLine(int (x1+clockCenterX), int (y1+clockCenterY), int (x3+clockCenterX), int (y3+clockCenterY),MARENGO);
  tft.drawLine(int (x3+clockCenterX), int (y3+clockCenterY), int (x2+clockCenterX), int (y2+clockCenterY),MARENGO);
  tft.drawLine(int (x2+clockCenterX), int (y2+clockCenterY), int (x4+clockCenterX), int (y4+clockCenterY),MARENGO);
  tft.drawLine(int (x4+clockCenterX), int (y4+clockCenterY), int (x1+clockCenterX), int (y1+clockCenterY),MARENGO);
 

  m=m*6;
  m=m+270;
  
  x1=47*cos(m*0.0175);//48 РАЗОБРАТЬСЯ С ФОРМОЙ СТРЕЛОК
  y1=47*sin(m*0.0175);//48
  x2=6*cos(m*0.0175);
  y2=6*sin(m*0.0175);
  x3=30*cos((m+8)*0.0175);//28 4 Это вроде как толщину определяет
  y3=30*sin((m+8)*0.0175);//28 4
  x4=30*cos((m-8)*0.0175);//28 4
  y4=30*sin((m-8)*0.0175);//28 4
  
  tft.drawLine(int (x1+clockCenterX), int (y1+clockCenterY), int (x3+clockCenterX), int (y3+clockCenterY),YELLOW);
  tft.drawLine(int (x3+clockCenterX), int (y3+clockCenterY), int (x2+clockCenterX), int (y2+clockCenterY),YELLOW);
  tft.drawLine(int (x2+clockCenterX), int (y2+clockCenterY), int (x4+clockCenterX), int (y4+clockCenterY),YELLOW);
  tft.drawLine(int (x4+clockCenterX), int (y4+clockCenterY), int (x1+clockCenterX), int (y1+clockCenterY),YELLOW);
}
 
void drawHour(int h, int m)//отрисовка часовой стрелки
{
  float x1, y1, x2, y2, x3, y3, x4, y4;
  int ph = h;
  

  if (m==0)
  {
    ph=((ph-1)*30)+((m+59)/2);
  }
  else
  {
    ph=(ph*30)+((m-1)/2);
  }
  ph=ph+270;
  
  x1=36*cos(ph*0.0175);//38
  y1=36*sin(ph*0.0175);
  x2=6*cos(ph*0.0175);
  y2=6*sin(ph*0.0175);
  x3=20*cos((ph+12)*0.0175);//5 Вроде как толщина стрелок
  y3=20*sin((ph+12)*0.0175);//5
  x4=20*cos((ph-12)*0.0175);//5
  y4=20*sin((ph-12)*0.0175);//5
  
  tft.drawLine(int (x1+clockCenterX), int (y1+clockCenterY), int (x3+clockCenterX), int (y3+clockCenterY),MARENGO);
  tft.drawLine(int (x3+clockCenterX), int (y3+clockCenterY), int (x2+clockCenterX), int (y2+clockCenterY),MARENGO);
  tft.drawLine(int (x2+clockCenterX), int (y2+clockCenterY), int (x4+clockCenterX), int (y4+clockCenterY),MARENGO);
  tft.drawLine(int (x4+clockCenterX), int (y4+clockCenterY), int (x1+clockCenterX), int (y1+clockCenterY),MARENGO);
 

  h=(h*30)+(m/2);
  h=h+270;
  
  x1=36*cos(h*0.0175);
  y1=36*sin(h*0.0175);
  x2=6*cos(h*0.0175);
  y2=6*sin(h*0.0175);
  x3=20*cos((h+12)*0.0175);//20 5 10
  y3=20*sin((h+12)*0.0175);//20 5 10
  x4=20*cos((h-12)*0.0175);//20 5 10
  y4=20*sin((h-12)*0.0175);//20 5 10
  
  tft.drawLine(int (x1+clockCenterX), int (y1+clockCenterY), int (x3+clockCenterX), int (y3+clockCenterY),YELLOW);
  tft.drawLine(int (x3+clockCenterX), int (y3+clockCenterY), int (x2+clockCenterX), int (y2+clockCenterY),YELLOW);
  tft.drawLine(int (x2+clockCenterX), int (y2+clockCenterY), int (x4+clockCenterX), int (y4+clockCenterY),YELLOW);
  tft.drawLine(int (x4+clockCenterX), int (y4+clockCenterY), int (x1+clockCenterX), int (y1+clockCenterY),YELLOW);
}
 
void loop()//основной цикл работы стрелочных часов
{
  int x, y;
  t = rtc.getTime();
  drawDisplay();//Вызываем функцию 
  while (true)
  {
    if (oldsec!=t.sec)
    {
      int t1=0; 
      int t2=0;
      int t3=0;
      if(t.hour>=12){
         t1=(t.hour-12)*5;
       }
       else
       {
         t1=t.hour*5;
       }
       t2=t.min/12;
       t3=t1+t2;
       int a=t.min+1;
       int b=t.min+2;
       int c=t.min+3;
       int d=t3+1;
       int e=t3+2;
       int f=t3+3;
       int g=t3+4;
       if ((t.sec==d)||(t.sec==e)||(t.sec==f)||(t.sec==g))
      {
        drawHour(t.hour, t.min);
      }
       if ((t.sec==a)||(t.sec==b)||(t.sec==c))
      {
        drawMin(t.min);
      }
      if (t.sec==0)
      {
        drawMin(t.min);
        drawHour(t.hour, t.min);
      }
      drawSec(t.sec);
      oldsec=t.sec;
    }
    delay(10);
    t = rtc.getTime();  
  }
}

Может еще кому-то пригодится. Ссылка на видео с часиками выше в этой теме.

Впрочем даю еще разок https://www.youtube.com/watch?v=MjywhTycwVk&feature=youtu.be

Joiner, а со шрифтами не поможешь?

Извини, я в этом не "копенгаген". Сам бы хотел разобраться, но пока не получается :(

Ребят, на днях могу вам подогнать шрифт с Кирилицей, но для этого вам нужно будет перебраться на новую версию библиотеки

https://github.com/sumotoy/TFT_ILI9163C/tree/Pre-Release-1.0r5

На 1.0r4 не советую сидеть, есть некоторые проблемы.

там же есть и шрифты, я себе сделал необходимый для себя, могу сбросить. Выглядит относительно нормально (Arial, 18 пикселей в высоту против 9 у стандартного)

Так же не советовал бы использовать функцию setFont(), так как при использовании данной функции загружаются в память стандартный и ваш шрифт +ещё неизвестно куда исчезает куча памяти. Лучшими вариантом я посчитал заменить в папке fonts файл с шрифтом и использовать так. Шрифт 18 пикселей в высоту у меня занял в двое меньше места чем подключенный отдельно 8px.

Если кому интересно могу поподробнее описать как подключаются шрифты и как можно заменить стандартный.

SpearMint, напиши, пожалуйста, поподробней как другой шрифт включить взамен "класического".

Для начала необходима версия библиотеки не ниже 1.0r4, ниже - не поддерживают этой функции.

В папке с библиотекой ILI9163C есть папка __fonts в которой находится пара-тройка шрифтов от автора библиотеки. Там находим название шрифта которого мы ходим и копируем название. В данном случае это unborn_small

#include <SPI.h>
#include <TFT_ILI9163C.h>
#include "_fonts/unborn_small.c"//Устанавливаем адрес шрифта, полагаясь на то что ILI9163C - наша коренная папка

#define __CS  10
#define __DC  6
#define __RST 8

TFT_ILI9163C tft = TFT_ILI9163C(__CS, __DC, __RST);

void setup() {
tft.begin();
  //Перед названием шрифта прописываем обязательно &
  tft.setFont(&unborn_small);//Установка шрифта, единоразово в setup
  tft.println("Hello world!");
}

void loop() {
}

Но я бы советовал делать несколько иначе. Зайти в папку __fonts удалить шрифт arial_x2.c открыть любой другой шрифт и заменить все названия шрифта, допустим square_small на arial_x2.

То есть вместо

static const uint8_t image_data_square_small_0x21[2] __PRGMTAG_  = {
    0x2a, 0x88
};////character: '!'

Мы получим

static const uint8_t image_data_arial_x2_0x21[2] __PRGMTAG_  = {
    0x2a, 0x88
};////character: '!'

Так у нас выйдет сэкономить ценную память для программы.

Если вдруг кому нужен шрифт более красивый, даю ссылку на dropbox

https://www.dropbox.com/s/wyz9w5tgl6lfpsd/arial_x2.c?dl=0

Просто замените старый файл arial_x2.c на новый в папке __fonts в папке с библиотекой.

Шрифт немного урезал, доступны следующие символы:

!./\?0123456789:ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz

На днях добавлю шрифт с кириллицей. Если правда получится его сделать.

Очень интересно. Напиши, ждем с нетерпением. У меня 5 штук таких дисплеев, хотелось бы освоить в полной мере.

SpearMint, огромннейшее человеческое спасибо!!!

В папке с библиотекой ILI9163C есть папка __fonts в которой находится пара-тройка шрифтов от автора библиотеки. Там находим название шрифта которого мы ходим и копируем название. В данном случае это unborn_small 

в общем то тоже так и делал...вот с памятью точно беда, половину библиотеки просто закомментил, чтоб в рамки разумного влезть, но всеровно много жрет...

Я конечно не углублялся, но вроде как память используется только когда вызывается функция, могу ошибаться. Если у вас изменилось количество памяти, напишите пожалуйста.

Я дальше в своём посте написал как можно сократить размер путём замены шрифта вместо подключения, и попробуйте ещё вырезать лишние символы.

в предыдущей версии мне удалось сэкономить 2.5 килобайта, так как совсем впритык было....я в общем то убрал те функции, которые не использую...

Короче я смог подключить и шрифты из Adafruit_GFX, но с библиотекой Release 1.0r5 они сработали. Запустил вот с этой 

https://github.com/sumotoy/TFT_ILI9163C

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

Возможно проблема в кодировке. Можно соорудить костыль, шрифт оставить английским, но нарисовать русские символы и на php или js сверстать страницу которая будет переводить текст из нормального в костыльный.

Подскажите пожалуйста, никак не допру, а как назначить SCK и SDA ?

т.е. чтобы не на 11 и 13 пине были а на других?

Можно в библиотеке поменять. Но тогда SPI у Вас будет программный, а не аппаратный, что значительно медленнее. 

В библиотеке исправьте тип платы в файле .h : тип платы black и red выберите свой

Что в итоге-то вы нашли способ обновляться дисплей нормально? у меня пины по дефолту, а обновляется секунду целую...

У меня обновлялся заметно и еще моргала подсветка из-за wifi и я просто забил на дисплей. Но не секунду.
В библиотеке я spi менял, но видимо не там, так как он все равно работал на стандартных пинах.... хм или может я не перезапустил оболочку....
Вобщем дисплей нормальный, но обновление действительно заметно происходит.

А можно переделанный код глянуть у вас?)

class TFT_ILI9163C : public Adafruit_GFX {

 public:

	#if defined(__MK20DX128__) || defined(__MK20DX256__)
		TFT_ILI9163C(uint8_t cspin,uint8_t dcpin,uint8_t rstpin=255,uint8_t mosi=6,uint8_t sclk=7);
	#elif defined(__MKL26Z64__)
		TFT_ILI9163C(uint8_t cspin,uint8_t dcpin,uint8_t rstpin=255,uint8_t mosi=6,uint8_t sclk=7);
	#else
		TFT_ILI9163C(uint8_t cspin,uint8_t dcpin,uint8_t rstpin=255);
	#endif
	//TFT_ILI9163C(uint8_t CS, uint8_t DC);//connect rst pin to VDD

поменял на 6 и 7 пин  в этом куске

Ребят, если кому интересно, я нашёл способ выводить динамическую индикацию, не обновляя дисплей.

Конечно же интересно. Как получить информацию? Пиши.

Суть до смеха проста! мне нужно обновлять секунды каждую секунду) однако если обновлять каждую секунду, ни для кого не секрет, что видны сильные моргания дисплея. Так как фон экрана у меня черный, я рисую закрашенный черным цветом квадрат :    

if (second != oldTimeSec)

Я пробывал почти также. При выводе вольтметра. Рисовал цифры, потом рисовал их же чёрным, потом рисовал новые. Так вот экран заметно мерцал. Как сделать, чтобы вообще без бликов?

Ну вот по примеру, который я показал, нет бликов вообще

Возможно блики - именно блики подсветки, от просадки по питанию. У меня блики были когда вайфай модули и дисплей от ардуино питались. Вай фай давал помехи.

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

Попробовал с квадратом. Тоже самое.

Вот такая штука выходит https://vk.com/video19348861_171793895

Как убрать мерцание?

Так ты покажи что ты за код то написал, как подсказать?? для начала обнови библиотеку до ревизии хотябы 4-5

Код вот

попробуй добавить задержку между итерациями еще

Библиотека дисплея у меня последняя от sumotoy. Суть проблемы в том, что цифры отресовывает построчно, с ощутимой задержкой.

Как сделать, чтобы рисовал всю цифру сразу?

Не у кого такой проблемы нет?

тут уже было написано выше, что предыдущая версия библиотеки работает быстрее, чем последняя

Попробовал 2 библиотеки TFT_ILI9163C-Pre-Release-1.0r5 и r4

Ситуация та же, вдобавок не хочет работать со шрифтами из Adafruit_GFX и мерцает весь экран, ане только текст.

Если использовать встроенный шрифт, то мерцание гораздо быстрее, но всё равно заметно глазу.

Вы не думали о том что квадрат это чересчур кошерно? Можно же прошлую секунду отрисовывать, тоесть цифру

Думал, сперва так и делал. У меня не секунды, у меня вольты. Проблема в том, что цифры рисует медленно, фактически построчно. Как заставить выводить число разом? Выше на видео очень чётко видно как это выглядит.

Кстати разницы между квадратом и числом не заметил.

Попробую как нибудь заснять в слоу-моу, там думаю хорошо будет видно.
А так, это проблемы ардуины и атмега328. Юзайте teensy 3.0/3.2, там все мгновенно

А у меня отличие было, потому квадрат. И не понимаю что тут кошерного? Делается одной командой, функцию свою выполняет, занимает места ровно столько же сколько само число.

ребят не ломайте голову себе и людям, все на много проще, чем рисование квадратов и тд, я использую функцию 

tft.setTextColor(цвет фона, цвет фона);

tft.println(old_text);

а вообще чтоб было проще выводить все параметры сразу, одной строкой, написал функцию

//====================================================
//             Работа с текстом
//====================================================
//void Write_Text(старый текст,новый текст,заменять текст , координата "x" текста , координата "y" текста , цвет старого текста , цвет нового текста , размер текста , изменять фон текста , цвет фона старого текста , цвет фона нового текста)
void Write_Text(String old_text, String new_text, bool replace_text, byte x_text, byte y_text, uint16_t color_old_text, uint16_t color_new_text, uint8_t TextSize_x, uint8_t TextSize_y , bool replace_bckgnd_text, uint16_t old_color_bckgnd_text, uint16_t color_bckgnd_text )
{
  //if (TextSize_x != 0 &&  TextSize_y != 0)
  tft.setTextSize(TextSize_x, TextSize_y);
  if (replace_text == true) {
    tft.setTextColor(color_old_text, old_color_bckgnd_text);
    tft.println(old_text);
    if (replace_bckgnd_text == true) tft.setTextColor(color_new_text, color_bckgnd_text);
    else  tft.setTextColor(color_new_text);
    tft.setCursor(x_text, y_text);
    tft.println(new_text);
  } else {
    if (replace_bckgnd_text == true)  tft.setTextColor(color_new_text, color_bckgnd_text);
    else  tft.setTextColor(color_new_text);
    tft.setCursor(x_text, y_text);
    tft.println(new_text);
  }
}
//====================================================

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

cannibal66670, а можно по подробней? Или кусок живого примера? 

Функции конечно хорошо, но я не вижу смысла ради этого использовать функцию, столько писанины ради этого-шкурка выделки не стоит. Отрисовывать старый текст проще инвертированный, но его нужно хранить в переменной дополнительной... а вот одной командой отрисовать квадрат самое простое, мне для отображения секунд большего не надо.

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


//#include <SPI.h>
#include <TFT_ILI9163C.h>
#include <DallasTemperature.h>
//#include <util/delay.h>
//#include <EEPROM.h>

#include <DS1307RTC.h>
#include <Time.h>
#include <Wire.h>
//====================================================
// Color definitions
#define	BLACK      0x0000//color1
#define	BLUE       0x001F//color2
#define	RED        0xF800//color3
#define	GREEN      0x07E0//color4
//#define CYAN    0x07FF//color5
#define MAGENTA    0xF81F//color6
//#define YELLOW  0xFFE0//color7
#define WHITE      0xFFFF//color8
#define WHITEGREEN 0x8F8F//color9
//====================================================
//byte     Gl_x_text, Gl_y_text ;
//uint16_t Gl_color_new_text, Gl_color_old_text, Gl_old_color_bckgnd_text, Gl_color_bckgnd_text;
//uint8_t  Gl_TextSize_x, Gl_TextSize_y;
//====================================================
//  Для измерения VCC
uint16_t raw_bandgap  = 0.0;//addr1      // значение внутреннего bandgap
float    volt_battery = 0.0;//addr2
//====================================================
/*
  Printed    What I    Arduino
  Name    Think it is Connection

  LED    (BACKLIGHT) 3.3v
  SCK    (SCLK)      pin 13
  SDA    (MOSI)      pin 11
  A0     (DC)        pin 9
  RESET  (RESET)     pin 8
  CS     (CS)        pin 7
  GND    (GND)       GND
  VCC    (VCC)       3.3v
*/
//#define    __CS 23
//#define    __DC 25
//#define   __RST 24

#define    __CS 7
#define    __DC 9
#define   __RST 8
//#define LED_PIN 5
TFT_ILI9163C tft = TFT_ILI9163C(__CS, __DC, __RST);
//====================================================
byte  bat;
float temp1, temp2, temp_min = 100, temp_max = 0, volt1,    volt2,    MaxVoltage = 0.0, Vcc = 0.0;
bool  temp_first,   ClearDisplay,   MenuVol,      Signal_1, Signal_2, Signal_3;
byte  volt_incr;
bool a ;
int  n = 0;
//====================================================
//#define float typVbg  1.092; // 1.0 -- 1.2   эту константу (typVbg) необходимо откалибровать индивидуально
#define typVbg        1.092 // 1.0 -- 1.2
//#define typVbg        1.1 // 1.0 -- 1.2
#define volt_norm     3.40
#define volt_low      3.10
#define volt_critical 2.90
//====================================================
// Data wire is plugged into pin 2 on the Arduino
#define ONE_WIRE_BUS 2
//#define ONE_WIRE_BUS 18
// Setup a oneWire instance to communicate with any OneWire devices (not just Maxim/Dallas temperature ICs)
OneWire oneWire(ONE_WIRE_BUS);
// Pass our oneWire reference to Dallas Temperature.
DallasTemperature sensors(&oneWire);
#define temp_hight     27
#define temp_critical  30
//====================================================
//====================================================
//         Установки
//====================================================
void setup() {
  //====================================================
  // start serial port
  //Serial.begin(9600);
  //====================================================
  // Запуск датчика температуры
  sensors.begin(); // IC Default 9 bit. If you have troubles consider upping it 12. Ups the delay giving the IC more time to process the temperature measurement
  //====================================================
  tft.begin();//Запуск экрана
  tft.setRotation(0);//поворот экрана
  tft.fillScreen(BLACK);//фон экрана
  //pinMode(LED_PIN, OUTPUT);//питание экрана(опционально)
  //analogWrite(LED_PIN, 255);//значение питания экрана
  //====================================================
  // Write_Text("", "MENU",    false, 5,  114, 0, WHITE, 1, 1 , false, 0, 0 ); //Меню
  //Write_Text("", "SELECT",  false, 90, 114, 0, WHITE, 1, 1 , false, 0, 0 ); //Выбор
  //====================================================
  Ant_1(1);//Антенна1 (показание на дисплее)
  Ant_2(1);//Антенна2 (показание на дисплее)
  //Ant_3(0);//Антенна3 (показание на дисплее)

  tft.fillRect(0, 20, 128, 90, WHITEGREEN);
  tft.drawRect(5, 25, 118, 37, BLACK);
  //pinMode(3, INPUT); //конфигурируем пин как выход ( к нему подключен светодиод)
  digitalWrite(3, HIGH); //включаем внутренний pull-up резистор
}
//====================================================
//====================================================
//              Главный цикл
//====================================================
void loop(void) {

  if (digitalRead(3) == 0) {
    a = 1;
    n = 0;
    delay(100);      // ждем 100 миллисекунд
  }

  if (a == 1) {
    tft.sleepMode(false);
    analogWrite(A2, 255);
    n++;
    delay(1);      // ждем 1 миллисекунд
    if (n == 60) {
      a = 0;
      n = 0;
      tft.sleepMode(true);
      analogWrite(A2, 0);
    }
  }


  //Alarm(true, true, true);
  //====================================================
  NOW_VCC();
  //ZaryadBat(1, 15);
  //====================================================
  TEMP_NOW(true);
  //TEMP_NOW(false);
  //====================================================
  tmElements_t tm;
  if (RTC.read(tm)) {

    Write_Text("",  "Date " + print2digits(tm.Day)  + "/" + print2digits(tm.Month)  + "/" + tmYearToCalendar(tm.Year) + " " + dayShortStr(weekday(now())), false, 10, 28, 0, BLUE, 1, 1 , true, 0, WHITEGREEN );
    Write_Text("",            print2digits(tm.Hour) + ":" + print2digits(tm.Minute) + ":" + print2digits(tm.Second) + " ",                                 false, 15,  40, 0, BLUE, 2, 2 , true, 0, WHITEGREEN );
  }
}
//====================================================
//====================================================
//               Получение времени
//====================================================
String print2digits(int number) {
  String str_number;
  if (number >= 0 && number < 10) {
    str_number = "0" + String(number);
  }
  else {
    str_number = String(number);
  }
  return str_number;
}
//====================================================
//====================================================
//               Батарея (показание на дисплее)
//====================================================
void ZaryadBat(bool zaryadka, int bat_zaryad) {
  if (zaryadka == 1) {
    bat++;
    //delay(10);
  }
  else {
    bat = bat_zaryad;
  }
  if (bat == 5) {
    Draw_Bat(BLACK, BLACK,  RED,    RED,    RED   );
  }
  else if (bat == 10) {
    Draw_Bat(BLACK, YELLOW, YELLOW, YELLOW, YELLOW);
  }
  else if (bat == 15) {
    Draw_Bat(GREEN, GREEN,  GREEN,  GREEN,  GREEN );
  }
  else if (bat == 20) {
    Draw_Bat(BLACK, BLACK,  BLACK,  RED,    RED   );
  }
  else if (bat == 25) {
    bat = 0;
  }
}
//====================================================
//====================================================
//               Антенна1 (показание на дисплее)
//====================================================
void Ant_1(bool Signal_1) {

  //               Есть сигнал
  if (Signal_1 == 1) {
    Draw_Ant(GREEN, "1", 15, WHITE, 32, 29, 26, 23, 0);
  }
  //               Нет сигнала
  else {
    Draw_Ant(BLACK, "1", 15, RED, 32, 29, 26, 23, 27);
  }
}
//====================================================
//====================================================
//               Антенна2 (показание на дисплее)
//====================================================
void Ant_2(bool Signal_2) {

  //               Есть сигнал
  if (Signal_2 == 1) {
    Draw_Ant(GREEN, "2", 42, WHITE, 60, 57, 54, 51, 0);
  }
  //               Нет сигнала
  else {
    Draw_Ant(BLACK, "2", 42, RED, 60, 57, 54, 51, 55);
  }
}
//====================================================
//====================================================
//               Антенна3 (показание на дисплее)
//====================================================
void Ant_3(bool Signal_3) {

  //               Есть сигнал
  if (Signal_3 == 1) {
    Draw_Ant(GREEN, "3", 72, WHITE, 90, 87, 84, 81, 0);
  }
  //               Нет сигнала
  else {
    Draw_Ant(BLACK, "3", 72, RED, 90, 87, 84, 81, 85);
  }
}
//====================================================
//====================================================
//             Работа с текстом
//====================================================
//void Write_Text(старый текст,новый текст,заменять текст , координата "x" текста , координата "y" текста , цвет старого текста , цвет нового текста , размер текста , изменять фон текста , цвет фона старого текста , цвет фона нового текста)
void Write_Text(String old_text, String new_text, bool replace_text, byte x_text, byte y_text, uint16_t color_old_text, uint16_t color_new_text, uint8_t TextSize_x, uint8_t TextSize_y , bool replace_bckgnd_text, uint16_t old_color_bckgnd_text, uint16_t color_bckgnd_text )
{
  //if (TextSize_x != 0 &&  TextSize_y != 0)
  tft.setTextSize(TextSize_x, TextSize_y);
  if (replace_text == true) {
    tft.setTextColor(color_old_text, old_color_bckgnd_text);
    tft.println(old_text);
    if (replace_bckgnd_text == true) tft.setTextColor(color_new_text, color_bckgnd_text);
    else  tft.setTextColor(color_new_text);
    tft.setCursor(x_text, y_text);
    tft.println(new_text);
  } else {
    if (replace_bckgnd_text == true)  tft.setTextColor(color_new_text, color_bckgnd_text);
    else  tft.setTextColor(color_new_text);
    tft.setCursor(x_text, y_text);
    tft.println(new_text);
  }
}
//====================================================
//====================================================
//            Измерение температуры
//====================================================
void TEMP_NOW(bool t_min_tmax) {
  temp2 = temp1;
  sensors.requestTemperatures(); // Send the command to get temperatures
  temp1 = (sensors.getTempCByIndex(0));
  //Write_Text("", "Temp", false, 5,  77, 0 , BLUE, 2, 1 , false, 0, 0 );
  Write_Text("", "°C",   false, 106, 77, 0 , BLUE, 2, 1 , false, 0, 0 );
  //====================================================
  if (temp1 == 85.00 || temp1 == -127) { //если произошла ошибка датчика, то возвращаемся
    Write_Text("", " Error ", false, 53, 77, MAGENTA , BLUE, 2, 1 , true, MAGENTA, MAGENTA );
    if  (t_min_tmax == true) {
      Write_Text("", " Error ", false, 53, 87, MAGENTA , BLUE, 2, 1 , true, MAGENTA, MAGENTA );
      Write_Text("", " Error ", false, 53, 97, MAGENTA , BLUE, 2, 1 , true, MAGENTA, MAGENTA );
      temp_min = 100;
      temp_max = 0;
    }
    return;
  }
  //====================================================
  if (temp1 != temp2 || temp_first == 0 )  {
    if (t_min_tmax == false) {
      if (temp1 < temp2)  Write_Text("", "Temp", false, 3,  77, 0 , WHITE, 2, 1 , true, 0, BLUE );
      if (temp1 > temp2)  Write_Text("", "Temp", false, 3,  77, 0 , WHITE, 2, 1 , true, 0, RED  );
    }
    //====================================================
    if (temp1 >= temp_critical)         Write_Text(String(temp2),    String(temp1),    false,  53, 77, RED ,        WHITE, 2, 1 , true, RED,        RED        );
    //====================================================
    else if (temp1 >= temp_hight)      Write_Text(String(temp2),    String(temp1),    false,  53, 77, MAGENTA ,    WHITE, 2, 1 , true, MAGENTA,    MAGENTA    );
    //====================================================
    else if (temp1 < temp_hight )       Write_Text(String(temp2),    String(temp1),    false,  53, 77, WHITEGREEN , BLUE, 2, 1 , true, WHITEGREEN, WHITEGREEN );
    //====================================================
    if (t_min_tmax == true) {
      Write_Text("", "Temp", false, 3,  77, 0 , BLUE, 2, 1 , false, 0, 0 );
      //====================================================
      if (temp_first == 0) {
        Write_Text("", "Tmax", false, 3, 87, 0 , BLUE, 2, 1 , true, 0, WHITEGREEN );
        Write_Text("", "Tmin", false, 3, 97, 0 , BLUE, 2, 1 , true, 0, WHITEGREEN );
      }
      //====================================================
      if (temp1 < temp_min) {
        temp_min = temp1;
        Write_Text(String(temp_min), String(temp1),    false, 53, 97, WHITEGREEN , BLUE, 2, 1 , true, WHITEGREEN, WHITEGREEN );
      }
      //====================================================
      if (temp1 > temp_max)  {
        temp_max = temp1;
        Write_Text(String(temp_max), String(temp1),    false, 53, 87, WHITEGREEN , BLUE, 2, 1 , true, WHITEGREEN, WHITEGREEN );
      }
      //====================================================
      if      (temp_max >= temp_critical) Write_Text(String(temp_max), String(temp_max), false, 53, 87, RED ,        WHITE, 2, 1 , true, RED,        RED        );
      //====================================================
      else if (temp_max >= temp_hight)    Write_Text(String(temp_max), String(temp_max), false, 53, 87, MAGENTA ,    WHITE, 2, 1 , true, MAGENTA,    MAGENTA    );
      //====================================================
      else if (temp_max < temp_hight)     Write_Text(String(temp_max), String(temp_max), false, 53, 87, WHITEGREEN , BLUE, 2, 1 , true, WHITEGREEN, WHITEGREEN );

      //====================================================
      if (temp1 > temp2) {
        Write_Text("",             "Tmax",           false, 3,  87, 0 ,           WHITE, 2, 1 , true,  0,          RED    );
        Write_Text("",             "Tmin",           false, 3,  97, 0 ,           BLUE, 2, 1 , true,  0,          WHITEGREEN );
      }
      //====================================================
      else if (temp1 < temp2) {
        Write_Text("",             "Tmin",           false, 3,  97, 0 ,           WHITE, 2, 1 , true,  0,          BLUE    );
        Write_Text("",             "Tmax",           false, 3,  87, 0 ,           BLUE, 2, 1 , true,  0,          WHITEGREEN );
        //====================================================
      }
      Write_Text("",               "°C",             false, 106, 87, 0 ,          BLUE, 2, 1 , false, 0,          0          );
      Write_Text("",               "°C",             false, 106, 97, 0 ,          BLUE, 2, 1 , false, 0,          0          );
      //====================================================
    }
    temp_first = 1;
  }
}
//====================================================
//====================================================
//             Рисование батареи
//====================================================
void Draw_Bat(uint16_t bat_1, uint16_t bat_2, uint16_t bat_3, uint16_t bat_4, uint16_t bat_5) {
  tft.drawRect(100, 4, 20, 11, bat_5); //батарея рисование
  tft.fillRect(98,  8, 2,  3,  bat_4);    //батарея рисование
  tft.fillRect(113, 6, 5,  7,  bat_3);   //3_я банка стирание
  tft.fillRect(108, 6, 5,  7,  bat_2);   //2_я банка стирание
  tft.fillRect(103, 6, 5,  7,  bat_1);   //1_я банка стирание
}
//====================================================
//====================================================
//            Рисование антенн
//====================================================
void Draw_Ant(uint16_t color_rect, String ant_text, byte x_pos, uint16_t color_Text, byte a, byte b, byte c, byte d, byte circle_pos ) {
  Write_Text("", ant_text, false, x_pos, 8, 0, color_Text, 1, 1 , false, 0, 0 );
  tft.fillRect(a, 4,  3, 11, color_rect); //4
  tft.fillRect(b, 6,  3, 9,  color_rect); //3
  tft.fillRect(c, 8,  3, 7,  color_rect); //2
  tft.fillRect(d, 10, 3, 5,  color_rect); //1
  //====================================================
  if (color_rect == BLACK) {
    tft.drawCircle(circle_pos, 10, 5, WHITE);
    tft.fillCircle(circle_pos, 10, 3, RED);
  }
  //====================================================
}
//====================================================
//====================================================
//            Измерение напряжения батареи
//====================================================
float readVcc() {
  byte i;
  float result = 0.0;
  float tmp = 0.0;

  for (i = 0; i < 5; i++) {
    // Read 1.1V reference against AVcc
    // set the reference to Vcc and the measurement to the internal 1.1V reference
    //#if defined(__AVR_ATmega32U4__) || defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
    //  ADMUX = _BV(REFS0) | _BV(MUX4) | _BV(MUX3) | _BV(MUX2) | _BV(MUX1);
    //#elif defined (__AVR_ATtiny24__) || defined(__AVR_ATtiny44__) || defined(__AVR_ATtiny84__)
    //  ADMUX = _BV(MUX5) | _BV(MUX0);
    //#elif defined (__AVR_ATtiny25__) || defined(__AVR_ATtiny45__) || defined(__AVR_ATtiny85__)
    //  ADMUX = _BV(MUX3) | _BV(MUX2);
    //#else
    // works on an Arduino 168 or 328
    ADMUX = _BV(REFS0) | _BV(MUX3) | _BV(MUX2) | _BV(MUX1);
    //#endif
    delay(3); // Wait for Vref to settle
    ADCSRA |= _BV(ADSC); // Start conversion
    while (bit_is_set(ADCSRA, ADSC)); // measuring

    uint8_t low  = ADCL; // must read ADCL first - it then locks ADCH
    uint8_t high = ADCH; // unlocks both

    tmp = (high << 8) | low;
    tmp = (typVbg * 1023.0) / tmp;
    result = result + tmp;
    delay(5);
  }

  result = result / 5;
  return result;
}
//====================================================
/*
  long readVcc() {
  // Read 1.1V reference against AVcc
  // set the reference to Vcc and the measurement to the internal 1.1V reference
  #if defined(__AVR_ATmega32U4__) || defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
  ADMUX = _BV(REFS0) | _BV(MUX4) | _BV(MUX3) | _BV(MUX2) | _BV(MUX1);
  #elif defined (__AVR_ATtiny24__) || defined(__AVR_ATtiny44__) || defined(__AVR_ATtiny84__)
  ADMUX = _BV(MUX5) | _BV(MUX0);
  #elif defined (__AVR_ATtiny25__) || defined(__AVR_ATtiny45__) || defined(__AVR_ATtiny85__)
  ADMUX = _BV(MUX3) | _BV(MUX2);
  #else
  ADMUX = _BV(REFS0) | _BV(MUX3) | _BV(MUX2) | _BV(MUX1);
  #endif

  delay(75); // Wait for Vref to settle
  ADCSRA |= _BV(ADSC); // Start conversion
  while (bit_is_set(ADCSRA, ADSC)); // measuring

  uint8_t low  = ADCL; // must read ADCL first - it then locks ADCH
  uint8_t high = ADCH; // unlocks both

  long result = (high << 8) | low;

  result = 1117116 / result; // Calculate Vcc (in mV); 1125300 = 1.1*1023*1000
  return result; // Vcc in millivolts
  } */
//====================================================
//          Чтение напряжения батареи
//====================================================
void NOW_VCC() {
  //Write_Text("", "Ubat",  false, 5,   66, 0, BLUE, 2, 1 , false, 0, 0 );
  Write_Text("", "V",     false, 113, 66, 0, BLUE, 2, 1 , false, 0, 0 );
  volt_incr++;
  if (volt_incr == 3) {
    volt2 = volt1;
    //volt1 = ((float) readVcc() / 1000);
    volt1 = readVcc() ;
    volt_incr = 0;
    if   (volt1 != volt2) {
      if (volt1 >  volt2) Write_Text("", "Ubat",  false, 5,   66, 0, WHITE, 2, 1 , true, 0, RED );
      if (volt1 <  volt2) Write_Text("", "Ubat",  false, 5,   66, 0, WHITE, 2, 1 , true, 0, BLUE );

      // if (volt1 >  volt2) Write_Text("", " " + String(volt1) + " " , false, 55, 66, RED,  WHITE, 2, 1 , true, WHITEGREEN, RED  );
      // if (volt1 <  volt2) Write_Text("", " " + String(volt1) + " " , false, 55, 66, BLUE, WHITE, 2, 1 , true, WHITEGREEN, BLUE );
      Write_Text("", " " + String(volt1) + " " , false, 55, 66, 0, BLUE, 2, 1 , true, 0, WHITEGREEN );
    }
  }
  if      (  volt1 >   volt_norm     )                        ZaryadBat(0, 15 );//Батарея (показание на дисплее) >  3.40v
  else if (( volt1 <=  volt_norm) && (volt1 > volt_low))      ZaryadBat(0, 10 ); //Батарея (показание на дисплее) <= 3.40v
  else if (( volt1 <=  volt_low ) && (volt1 > volt_critical)) ZaryadBat(0, 5  ); //Батарея (показание на дисплее) <= 3.10v
  else if (  volt1 <=  volt_critical )                        ZaryadBat(0, 20 );//Батарея (показание на дисплее) <= 2.90v
}
//====================================================
//            Отображение будильников
//====================================================
void Alarm(bool AL_1, bool Al_2, bool AL_3) {

  if (AL_1 == true) Write_Text("", "AL1",     false, 102, 27, 0, WHITE,      1, 1 , true, 0, RED        );
  else              Write_Text("", "AL1",     false, 102, 27, 0, WHITEGREEN, 1, 1 , true, 0, WHITEGREEN );

  if (Al_2 == true) Write_Text("", "AL2",     false, 102, 39, 0, WHITE,      1, 1 , true, 0, RED        );
  else              Write_Text("", "AL2",     false, 102, 39, 0, WHITEGREEN, 1, 1 , true, 0, WHITEGREEN );

  if (AL_3 == true) Write_Text("", "AL3",     false, 102, 51, 0, WHITE,      1, 1 , true, 0, RED        );
  else              Write_Text("", "AL3",     false, 102, 51, 0, WHITEGREEN, 1, 1 , true, 0, WHITEGREEN );


}
//====================================================

Наткнулся на интересный обзор по этому экрану. Может кому интересно будет

https://www.youtube.com/watch?v=1GEdd-N3GR0

nasol kak praviljno dinamiceskij tekst vivoditj!!! osibka v tom sto nado zakrasivatj kvadrat neposredstvenno pered komandoj (print),togda mercaet ele zametno toljko esli cifri stojat na meste!!!!!! i osibka v podkljuceniji

Здраствуйте, сижу голову ломаю, как картинку с флешки вывести на экран, есть файл bmp парамерты 24 бита, как и требуется,

библиотека TFT_ILI9163C-Pre-Release-1.0r5

дисплей такой :#define __144_BLACK_PCB__//128x128 , черный короче

ардуина mega2560

скетч:

/*
An SD bmp image load example. (extracted and modded by Adafruit old library http://www.adafruit.com )
 This use NOT the adafruit SD library (or the standard arduino SD!)
 but SdFat created by bill greiman https://github.com/greiman/SdFat much better to me!!!
 Note about SPI Transactions <-------------------------------------------
 To enable compatibility for SPI Transactions please open
 SfFatCinfig.h in SdFat libary and set
 #define ENABLE_SPI_TRANSACTION 0
 to
 #define ENABLE_SPI_TRANSACTION 1
 */

#include <SPI.h>
#include <SdFat.h>
#include <TFT_ILI9163C.h>

//PINS
#define __CS 10
#define __DC 9
#define __SDCS 53

// This function opens a Windows Bitmap (BMP) file and
// displays it at the given coordinates.  It's sped up
// by reading many pixels worth of data at a time
// (rather than pixel by pixel).  Increasing the buffer
// size takes more of the Arduino's precious RAM but
// makes loading a little faster.  20 pixels seems a
// good balance.
#define BUFFPIXEL 20

boolean SDInited = true;

TFT_ILI9163C tft = TFT_ILI9163C(__CS, __DC, 8);
SdFat SD;
SdFile myFile;

void setup(void) {
  Serial.begin(38400);
  long unsigned debug_start = millis ();
  while (!Serial && ((millis () - debug_start) <= 5000)) ;

  tft.begin();
  //tft.setRotation(2);

  //I have a crappy chinese SD card holder that it's not compatible
  //with hi speeds SPI (SPI_FULL_SPEED). If you have better luck set it to
  //SPI_FULL_SPEED
  if (!SD.begin(__SDCS,SPI_HALF_SPEED)) {
    tft.setCursor(0,0);
    tft.print("sd failed!");
    SDInited = false;
  }
  Serial.println("OK!");
  //your image here!
  bmpDraw("1.bmp", 0, 0);
}

void loop() {
}



void bmpDraw(const char *filename, uint8_t x, uint16_t y) {
  if (SDInited){

    File     bmpFile;
    uint16_t bmpWidth, bmpHeight;   // W+H in pixels
    uint8_t  bmpDepth;              // Bit depth (currently must be 24)
    uint32_t bmpImageoffset;        // Start of image data in file
    uint32_t rowSize;               // Not always = bmpWidth; may have padding
    uint8_t  sdbufferLen = BUFFPIXEL * 3;
    uint8_t  sdbuffer[sdbufferLen]; // pixel buffer (R+G+B per pixel)
    uint8_t  buffidx = sdbufferLen; // Current position in sdbuffer
    boolean  goodBmp = false;       // Set to true on valid header parse
    boolean  flip    = true;        // BMP is stored bottom-to-top
    uint16_t w, h, row, col;
    uint8_t  r, g, b;
    uint32_t pos = 0;

    if((x >= tft.width()) || (y >= tft.height())) return;

    // Open requested file on SD card
    if ((bmpFile = SD.open(filename)) == NULL) {
      tft.setCursor(0,0);
      tft.print("file not found!");
      return;
    }

    // Parse BMP header
    if(read16(bmpFile) == 0x4D42) { // BMP signature
      read32(bmpFile);
      (void)read32(bmpFile); // Read & ignore creator bytes
      bmpImageoffset = read32(bmpFile); // Start of image data
      // Read DIB header
      read32(bmpFile);
      bmpWidth  = read32(bmpFile);
      bmpHeight = read32(bmpFile);
      if(read16(bmpFile) == 1) { // # planes -- must be '1'
        bmpDepth = read16(bmpFile); // bits per pixel
        if((bmpDepth == 24) && (read32(bmpFile) == 0)) { // 0 = uncompressed
          goodBmp = true; // Supported BMP format -- proceed!
          rowSize = (bmpWidth * 3 + 3) & ~3;// BMP rows are padded (if needed) to 4-byte boundary
          if (bmpHeight < 0) {
            bmpHeight = -bmpHeight;
            flip      = false;
          }
          // Crop area to be loaded
          w = bmpWidth;
          h = bmpHeight;
          if((x+w-1) >= tft.width())  w = tft.width()  - x;
          if((y+h-1) >= tft.height()) h = tft.height() - y;
          tft.startPushData(x, y, x+w-1, y+h-1);
          for (row=0; row<h; row++) { // For each scanline...
            if (flip){ // Bitmap is stored bottom-to-top order (normal BMP)
              pos = bmpImageoffset + (bmpHeight - 1 - row) * rowSize;
            } 
            else {     // Bitmap is stored top-to-bottom
              pos = bmpImageoffset + row * rowSize;
            }
            if (bmpFile.position() != pos) { // Need seek?
              bmpFile.seek(pos);
              buffidx = sdbufferLen; // Force buffer reload
            }
            for (col=0; col<w; col++) { // For each pixel...
              // Time to read more pixel data?
              if (buffidx >= sdbufferLen) { // Indeed
                bmpFile.read(sdbuffer, sdbufferLen);
                buffidx = 0; // Set index to beginning
              }
              // Convert pixel from BMP to TFT format, push to display
              b = sdbuffer[buffidx++];
              g = sdbuffer[buffidx++];
              r = sdbuffer[buffidx++];
              tft.pushData(tft.Color565(r,g,b));
            } // end pixel
          } // end scanline
          tft.endPushData();
        } // end goodBmp
      }
    }

    bmpFile.close();
    if(!goodBmp) {
      tft.setCursor(0,0);
      tft.print("file unrecognized!");
    }
  }
}


uint16_t read16(File &f) {
  uint16_t result;
  ((uint8_t *)&result)[0] = f.read(); // LSB
  ((uint8_t *)&result)[1] = f.read(); // MSB
  return result;
}

uint32_t read32(File &f) {
  uint32_t result;
  ((uint8_t *)&result)[0] = f.read(); // LSB
  ((uint8_t *)&result)[1] = f.read();
  ((uint8_t *)&result)[2] = f.read();
  ((uint8_t *)&result)[3] = f.read(); // MSB
  return result;
}

ничего особенного, из примеров библиотеки.

Получается вот это((( 

Кто пробовал выводить на экран картинки?? или это библиотека кривая или руки неоттуда растут))

Сама флешка работает с ардуиной, пробовал писать и считывать файлы, нормально все...

Я уже раз 10 отвечал на вопрос в разных форумах , Почему часть дисплея не видна. Ответ: скорее всего у вас дисплей на черной плате, зайдите в файлы библиотеки и в settings укажите, что плата черная. И никаких rotation не нужно и все прекрасно работает

причем сдесь "часть дисплея невидна?", настройки либы сделаны нормально, текст, графику и т.д. показывает нормально, у меня только вопрос по отображению картинок с флешки!

И еще раз, примеры, графика, текст показывает нормально! в полный экран без косяков!