Arduino.ru

DetSimen  Осёлллл....

А накуйты ты код какой-то левый подтянул? ;) без него него не встает7 ;

DetSimen  давай не кашляй ;)

DetSimen   Ты  вообще разобрался о том что я писал ранее??? Ну ты разберись сперва :))))

Так это ж твоё г.  Не узнаёшь? 

// 
//Программа: Система Жизнеобеспечивания "Сорока" 
//Система, на данный момент состоит из 2-х климатических датчиков, для измерения температуры и влажности снаружи и внутри помещения. И двух кнопок,
//для переключения режима "Дома","Вне дома" и ручного включения проветривания с помощью вытяжных вентиляторов. 
//
//1. Режим "Дома" включает в себя:  
//    а) 5ти минутное проветривание примерно каждые пол часа (с появлением датчика уровня CO2 режим будет опираться на его показания).
//    б) Контроль температуры +21 градус Цельсия, путем включения обогревателя или проветривания.
//    в) Проветривание помещения, если влажность поднялась значительно (более 20%) выше уличной. Данный пункт возможно будет актуален после пользованием душем и/или парной.
//    г) Ручное включение проветривания кнопкой.
//
//2. Режим "Вне Дома" включает в себя:
//    а) Система выдерживает как можно более низкую влажность в помещении, насколько это позволяет погода (пока отсутствует осушитель воздуха). 
//       В диапазоне уличных температуры от +5 до +27 градусов. Чтобы не вымораживать и не перегревать помещение.
//    
//3. Прочие функции:
//    а) В случае обрыва одного из датчиков, система не выполняет никаких функций кроме 5-ти минутного проветривания каждые пол часа и ручного включения вентиляторов.
//
//
// Программа включат в себя свободно распространяемые библиотеки: (UTFT для работы с дисплеем) и  (iarduino_RTC.h для работы с часами реального времени) 
// 
// Программа распространяется бесплатно. Автор: Nord_Air

 #define pin_SW_SDA 53                                    // Назначение любого вывода Arduino для работы в качестве линии SDA программной шины I2C.
 #define pin_SW_SCL 51 

//библиотека для работы с дисплеем
#include <UTFT.h>

#include <iarduino_RTC.h>                                 // Подключаем библиотеку часов реального времени


// создаём объект класса UTFT
// и передаём идентификатор модели дисплея и номера пинов
// к которым подключаются линии SCK, SDI (MOSI), D/C, RESET, CS

//  UTFT myGLCD(TFT01_22SP, SDI (MOSI),SCK, CS, RESET, D/C);
    UTFT myGLCD(TFT01_22SP, 8,         9,   10, 11,    12 );

iarduino_RTC watch(RTC_DS3231);                           // Объявляем объект watch для модуля на базе чипа DS1307 (часы реального времени)
  

// объявления встроенных шрифтов библиотеки UTFT
extern uint8_t SmallFont[];
extern uint8_t BigFont[];

uint8_t D, M, Y, h, m, s; // W;   // Объявляем переменные для получения следующих значений: D-день, M-месяц, Y-год, h-часы, m-минуты, s-секунды, W-день недели.


//---Кнопочный блок-------------------------------------------*
const byte    RESET_ALL_BUTTONS = 22;  
const boolean IRQ = 24;  
      //----- Контакты 8 битного регистра (КР1533ИР9)  кнопочного блока
        const int REGISTR_CONTROL = 30;  // (L) Высокий уровень - чтение, низкий - запись в регистр. (SEMO)
        const int SYNC = 26;             // (С) Пин синхронизации (SYN)
        const int DO = 28;               // (D0) Последовательное чтение из регистра (D_Output)
          boolean button_data[]{false,false,false,false,false,false,false,false};        //  значение из регистра
     //-------------------------------- 
//-------------------------------------------------------------*


//----Пины реле------------
const int Rele_Cooler = 5;           //Управляющи пин на включение вентилятора
const int Rele_Heater = 4;           //Управляющи пин на включение розетки (отопителя)
//-------------------------

byte tact;
int  act=0;
int  Global_act=1;

byte page=10;                // Нумерация экранных страниц.
int page_level=0;          // Уровень страниц
int page_level_z=0;          

boolean Home;               // переменная режима (дома/вне дома)
boolean Home_z;

boolean cooler_button=0;      //Кнопка принудительного включения вентилятора
boolean cooler_button_z;      //Переменная для хранения состояния кнопки
                              //принудительного включения вентилятора.
boolean heater_1_button;
boolean heater_1_button_z;

boolean heater_2_button;
boolean heater_2_button_z;

boolean cooler;              //Переменная текущего состояния вентилятора
boolean cooler_z;             //Переменная сохранения статуса вентилятора

boolean heater=0;             //Переменная текущего состояния отопителя
boolean heater_z;             //Переменная сохранения статуса отопителя
boolean heater_1;
boolean heater_2;
boolean heater_1_z;
boolean heater_2_z;

    
   const int DHT22_1 = 2;

   //------Данные с датчиков---------------------------------------
   int day_T [25];           //Массив для хранения часовых значений температуры
   int day_t [25];
   int day_T_30min[25];
   int day_t_30min[25];

   int8_t T=18;               //Забортная температура воздуха
   int8_t W=68;               //Забортная влажность
   int t;                     //Температура воздуха внутри помещения
   byte w;                     //Влажность внутри помещения
   int8_t t_floor=18;         //Температура пола
   int8_t w_floor=40;         //Влажность пола

   int8_t T2;                 //Единицы счетчика забортной температуры.
   int8_t T1;                 //Десятки счетчика забортной температуры.
   int8_t T2_z;               //Временная переменная для сохранения значения счетчика.
   int8_t T1_z;

   int8_t t2;                 //Единицы счетчика внутренней температуры.
   int8_t t1;                 //Десятки счетчика внутренней температуры.
   int8_t t1_z;
   int8_t t2_z;   

   int8_t W2;                 //Единицы счетчика забортной влажности.
   int8_t W1;                 //Десятки счетчика забортной влажности.
   int8_t W1_z;
   int8_t W2_z;
                              
   int8_t w2;                 //Единицы счетчика забортной влажности.
   int8_t w1;                 //Единицы счетчика забортной влажности. 
   int8_t w1_z;
   int8_t w2_z;

   int8_t t_floor2; 
   int8_t t_floor1;
   int8_t t_floor2_z; 
   int8_t t_floor1_z;

   int8_t w_floor1;
   int8_t w_floor2;  
   int8_t w_floor1_z;
   int8_t w_floor2_z;

   byte set_temp=22;         //переменная для установки температуры
 //int8_t set_temp_z;

   byte  *pointerToBYTE_1;
   int   *pointerToINT_2;
   //---------------------------------------------------------------------





  
       
//----Объявление функций опущенных ниже тела программы-----
int Write_15px (char, int, int);
int Write_8px (char, int, int);
int counter (int x, int y, byte count_number);
int draw_cooler_icon (int x, int y, boolean cool, boolean heat, boolean Button, byte id);
int draw_cooler_off_icon ( int x, int y);
int draw_home_icon(); 
int draw_environment(); 
int light_counter (int x, int y, byte count_number, boolean i);
int small_counter (int x, int y, byte count_number, boolean i, int a,int b,int c);
int symbol_temperature(int x, int y);
int hour_minus ();
int graphic ( int x, int y, int resolution_grid_x, int resolution_grid_y, int step_X, int step_Y, int zoom_Y, int l, int type, int data_1[], int data_2[] );
int draw_graphic ();
int clearScreen ();
int draw_magnifying_glass(int x, int y);
int draw_up_arrow (int x, int y, boolean type);
int draw_down_arrow (int x, int y, boolean type);
int set_temperature (int flag);
int reset_all_buttons (int d);
//----Описание в самих функциях---------------------------

void(* resetFunc) (void) = 0;  //Функция софтварного рестарта

void save_sensor()  // Функция сохраняет текущие значения датчиков в переменные _z.
  {   
   T1_z=T1;
   T2_z=T2;
   W1_z=W1;
   W2_z=W2;
   
   t1_z=t1; 
   t2_z=t2;
   w1_z=w1;
   w2_z=w2;    
   
   t_floor1_z=t_floor1;
   t_floor2_z=t_floor2;
   w_floor1_z=w_floor1;
   w_floor2_z=w_floor2;   
  }
  
  int DHT22_read(int pin)   
    { 
       byte   data[5];    //Массив для хранения результатов.
       int k=0;
       int temp;
      
       data[0]=data[1]=data[2]=data[3]=data[4]=0; //обнуляем массив
       pinMode(pin,OUTPUT); 
       digitalWrite(pin,LOW);              
       delay(2);   
       pinMode(pin,INPUT);
          
         k=pulseIn(pin,LOW, 600);   
        
          for(int i=0; i<40; i++)             
            { 
               k=pulseIn(pin,HIGH,600);   
            
              if(k){
                data[i/8] <<= 1; 
                data[i/8]+= k>50?1:0;                                
                   }    
                  else {
                    //Обработка ошибки 1.
                  }
                                            
             }  

               *pointerToBYTE_1 = ((data[1]+(data[0] <<8)) * (0.1));                 
                
             
              if ( (data[2]== 1) || (data[2]== 0)) { 
                                  temp=(data[3]+(data[2] <<8)) * (0.1 );};
                    
              if(data[2]==128)   {temp=data[3];
                                        temp=temp *(-0.1);};

              //-----Теоретическая строчка (для температур ниже -25.5 градусов)
              if(data[2]==255)   {temp=data[3]+(1 <<8 );
                                        temp=temp *(-0.1);};
              //--------------------------------------------------------------
                  
                   *pointerToINT_2 = temp;  
                          
    }             
 

 void state_sensor() // Функция сравнивает текущие значения датчиков, со значениями из
                     // прошлого цикла, сохраненные функцией save_sensor.
                     // Если значения изменилиcь, запускает соответствующий счетчик.
                     // Перерисовываются только те разряды счетков, которые изменились
                     // в сравнении с сохраненным значением. 
  {    

    if (page==10)
    {          
     if (T1!=T1_z)              {counter (175,176,T1);} //Температура забортом (десятки)
     if (T2!=T2_z)              {counter (188,176,T2);} //Температура забортом (единицы)
      
       if (T<0)                  { myGLCD.setColor(VGA_WHITE);
                                   myGLCD.fillRect (165,183,170,185);};  // Знак "минус" для отрицательного значения забортной температуры. 
       if (T>0)                  { myGLCD.setColor(VGA_BLACK);
                                   myGLCD.fillRect (165,183,170,185);};  // Закрашивание знака минус для положительтного значения забортной температуры.
     
  
     if (W1_z!=W1)              {counter (175,201,W1);} //Влажность забортом (десятки) 
     if (W2_z!=W2)              {counter (188,201,W2);} //Влажность забортом (единицы) 
   
     if (t1_z!=t1)              {counter (175,21,t1); } //Температура в кабине (десятки)
     if (t2_z!=t2)              {counter (188,21,t2); } //Температура в кабине (еденицы)

        if (t<0)                 { myGLCD.setColor(VGA_WHITE);
                                   myGLCD.fillRect (165,28,170,30);};  // Знак "минус" для отрицательного значения внутренней температуры. 
        if (t>0)                 { myGLCD.setColor(VGA_BLACK);
                                   myGLCD.fillRect (165,28,170,30);};  // Закрашивание знака минус для положительтного значения внутренней температуры.
   
     if (w1_z!=w1)              {counter (175,45,w1); } //Влажность в кабине (десятки)
     if (w2_z!=w2)              {counter (188,45,w2); } //Влажность в кабине (еденицы)
   
     if (w_floor1_z!=w_floor1)  {counter (175,118,w_floor1);}  // Влажность пола (десятки)
     if (w_floor2_z!=w_floor2)  {counter (188,118,w_floor2);}  // Влажность пола (еденицы) 
 
     if (t_floor1_z!=t_floor1)  {counter (175,94,t_floor1);}  // Температура пола (десятки)
     if (t_floor2_z!=t_floor2)  {counter (188,94,t_floor2);}  // Температура пола (еденицы) 

        if (t_floor<0)           { myGLCD.setColor(VGA_WHITE);
                                   myGLCD.fillRect (165,101,170,104);};  // Знак "минус" для отрицательного значения температуры пола. 
        if (t_floor>0)           { myGLCD.setColor(VGA_BLACK);
                                   myGLCD.fillRect (165,101,170,104);};  //  Закрашивание знака минус для положительтного значения температуры пола.     
   }
 } 
 

void check_sensor()  //Процедура считывет показания сенсоров и раскидывает значения по переменным. 
{    
        //----указываем указателю на область памяти переменных температуры и влажности.--
        pointerToINT_2=&t;
        pointerToBYTE_1 =&w;      
        DHT22_read(DHT22_1);
        //--------------------------------------------------------------------------------     
        
  
         // Расчитываем значения разрядов текущей темпереатуры забортом и заносим в переменные.
   char T_=T; // Перевод в положительное число, если значение температуры отрицательное.
   if (T<0){T_=T*(-1);};    
  T2 = T_ % 10 ;               //Единицы счетчика.
  T1 = (T_ /10) % 10 ;         //Десятки счетчика.

    // Расчитываем значения разрядов текущей темпереатуры в кабине и заносим в переменные.
   int t_=t;
   if (t<0){t_=t*(-1);}; 
  t2 = t_ % 10;                 //Единицы счетчика.
  t1 = (t_ /10) % 10;           //Десятки счетчика.

        // Расчитываем значения разрядов текущей влажности забортом и заносим в переменные.
       
  W2 = W % 10;                 //Единицы счетчика.
  W1 = (W /10) % 10 ;          //Десятки счетчика.

    // Расчитываем значения разрядов текущей влажности в кабине и заносим в переменные.
  w2 = w % 10;                 //Единицы счетчика.
  w1 = (w /10) % 10;           //Десятки счетчика.  
  
        // Расчитываем значения разрядов текущей влажности и температуры пола и заносим в переменные.
  w_floor2 = w_floor % 10;      //Единицы счетчика.
  w_floor1 = (w_floor /10) % 10;//Десятки счетчика.

   int t_floor_ = t_floor;
   if (t_floor < 0){
    t_floor_ = t_floor*(-1);};
    t_floor2 = t_floor_ % 10;       //Единицы счетчика.
    t_floor1 = (t_floor_ /10) % 10; //Десятки счетчика.

   
   //------ Часы реального времени---(RTC)----
        watch.gettime();    // Считываем текущее время из модуля.
         // D = watch.day;                                                    // Получаем из буфера библиотеки текущий день месяца 1-31.
         // M = watch.month;                                                  // Получаем из буфера библиотеки текущий месяц       1-12.
         // Y = watch.year;                                                   // Получаем из буфера библиотеки текущий год         0-99.
         // h = watch.Hours;                                                  // Получаем из буфера библиотеки текущие часы        0-23.
         // m = watch.minutes;                                                // Получаем из буфера библиотеки текущие минуты      0-59.
         // s = watch.seconds;                                                // Получаем из буфера библиотеки текущие секунды     0-59.
         // W = watch.weekday;
      
      //--Заполнение массивов для построения графиков    
             //-- Данные температуры на начало часа
        if ( 1 < watch.minutes < 2){  
              day_T [watch.Hours] = T;
              day_t [watch.Hours] = t;   
        }
           //-- Данные температуры на середину часа
        if (29 < watch.minutes < 30) {
               day_T_30min[watch.Hours]=T;
               day_t_30min[watch.Hours]=t;
        };                                    
       //---------------------------------------
  



}

void draw_act_counter (int i) //Функция рисует счетчик актов.
 {
    int a,b,c,d;
    
    a = i % 10;                 //Единицы счетчика.
    b = (i /10) % 10;
    c = (i /100) % 10;
    d = (i /1000) % 10;
    
                        light_counter (300,3,a,1);
 if (((act)%10)==0)    {light_counter (295,3,b,1);};  
 if (((act)%100)==0)   {light_counter (290,3,c,1);};   
 if (((act)%1000)==0)  {light_counter (285,3,d,1);};
 }

  //Функция проверки остатков ОЗУ, найдена на просторах инета.
    int freeRam () {
      extern int __heap_start, *__brkval; 
      int v; 
      return (int) &v - (__brkval == 0 ? (int) &__heap_start : (int) __brkval); 
                     }
  //мини-функция для нужд наполнения массива суточной температуры.                   
 int  hour_minus (int a){
   int h;
    if (a>4){h = a-4;};
    if (a<4){h = 20+a;};
    if (a==4){h = 0;};
    return (h);
  };                    

  int reset_all_buttons (int d){
                                  digitalWrite(RESET_ALL_BUTTONS, LOW);
                                  delay(d);  //Задержка, чтобы исключить двойное срабатывание кнопки
                                  digitalWrite(RESET_ALL_BUTTONS, HIGH); 
                                  //Сброс триггера должен происходить в любом случае, после нажатия кнопки, 
                                  //вне зависимости от остальных действий
                               };
   
void read_register (){
  digitalWrite(REGISTR_CONTROL, HIGH);
   digitalWrite(SYNC, HIGH);
   
    for (int i=0; i<8; i++)
    {
       digitalWrite(SYNC, LOW);
        button_data[i]=digitalRead (DO);
       digitalWrite(SYNC, HIGH);
    }
   digitalWrite(REGISTR_CONTROL, LOW);
   };

int set_temperature ( int flag )
    {
      read_register ();                          
       
      if (button_data[0]==false) {set_temp=set_temp+1;                                  
                                 reset_all_buttons (250);
                                 set_temperature(0);};
                                  
      if (button_data[5]==false) {set_temp=set_temp-1;                                  
                                  reset_all_buttons (250);
                                  set_temperature(0);};
      
     if (button_data[4]==false) {
                                 reset_all_buttons (150);
                                 return (0);};                          

        
        if (set_temp > 25) {set_temp=25; }; 
        if (set_temp < 18) {set_temp=18; };                        


           //----Установка температуры-------------------
           int a, b;

          a = set_temp % 10;                 //Единицы счетчика.
          b = (set_temp /10) % 10;           //Десятки счетчика.

            counter (272,159,b);
            counter (284,159,a);
          //------------------------------------------- 
       
           
     //---Ожидание повторного нажатия кнопки----
     switch ( flag ) {
       case 0 : {delay (800);
          set_temperature (1);};  
         break;
       case 1:  {delay (800);
          set_temperature (2);};  
        break;
        case 2:  {delay (800);
          set_temperature (3);};  
        break;
        case 3:  {delay (800);
          set_temperature (4);};  
        break;
    
       default:  
       break; 
        }
    //-------------------------------------   
    
}

 void draw_triangle (int x1, int y1, int x2, int y2, int x3, int y3 )
    
      {
        myGLCD.drawLine (x1,y1,x2,y2);
        myGLCD.drawLine (x2,y2,x3,y3);
        myGLCD.drawLine (x3,y3,x1,y1);                           
      }


 void page_control () //функция управления страницами.
  {
    if (button_data[0]==false ) { page_level++;  
                                  act=2;     // Статичные страницы начинаются с act 2, динамичные с act 1 
                                             // В статичных страницах page_level, меняет всю страницу и отрисовка её начинается полностью.
                                             // В динамичных страцицах, фон рисуется в первом акте, а page_lelel меняет элемент интерфейса,
                                             // act при этом всё время сбрасывается на 2.
                                //------------Сброс кнопочных триггеров------
                                 digitalWrite(RESET_ALL_BUTTONS, LOW);
                                 delay(150);  //Задержка, чтобы исключить двойное срабатывание кнопки
                                 digitalWrite(RESET_ALL_BUTTONS, HIGH); 
                                 
                                //------------------------------------------- 
                                }; 
  if (button_data[5]==false ) { page_level--; 
                                 act=2;      
                                //------------Сброс кнопочных триггеров-------
                                 digitalWrite(RESET_ALL_BUTTONS, LOW);
                                  delay(150);  //Задержка, чтобы исключить двойное срабатывание кнопки
                                 digitalWrite(RESET_ALL_BUTTONS, HIGH); 
                                
                                //------------------------------------------- 
                                };  
  if (page==10)
       {         
                if (page_level != page_level_z) // Отработка случая выхода за край экрана
                   {   
                       if (page_level > 4) {page_level = 0;};  
                       if (page_level < 0) {page_level = 4;};  
                                                //-------Затираем все рамки иконок при изменении уровня
                                                 myGLCD.setColor(VGA_BLACK);
                                                 myGLCD.drawRect(260, 0, 310, 48 );
                                                 myGLCD.drawRect(260, 48, 310, 96 );
                                                 myGLCD.drawRect(260, 96, 310, 144 );
                                                 myGLCD.drawRect(260, 144, 310, 192 );
                                                 myGLCD.drawRect(260, 192, 310, 240 );
                   };  
      
               int Lv=page_level*48;
      
          myGLCD.setColor(250,250,250);
          myGLCD.drawLine(260, 0+Lv, 260+8, 0+Lv);
          myGLCD.drawLine(310, 0+Lv, 310-8, 0+Lv);
          myGLCD.drawLine(260, 48+Lv, 260+8, 48+Lv);
          myGLCD.drawLine(310, 48+Lv, 310-8, 48+Lv);

          myGLCD.drawLine(260, 0+Lv, 260, 0+Lv+8);
          myGLCD.drawLine(310, 0+Lv, 310, 0+Lv+8);
          myGLCD.drawLine(260, 48+Lv, 260, 48+Lv-8);
          myGLCD.drawLine(310, 48+Lv, 310, 48+Lv-8);

             if (button_data[4]==false)
                  {
              if (page_level == 0 ) 
                  {
                               reset_all_buttons (250);
                               
                                if (Home)
                                {
                       if (cooler_button_z==0){cooler_button=1;};
                       if (cooler_button_z==1){cooler_button=0;};
             
                                
                              myGLCD.setColor(255,255,255);
                              myGLCD.drawRect(260,0,310,48); 
                                };   
                  }
              if (page_level == 1 ) 
             {
                     
                   reset_all_buttons (250);

                            if (Home)
                              {
                       if (heater_1_button_z==false){heater_1_button=true;};
                       if (heater_1_button_z){heater_1_button=false;};
             
                   
                   myGLCD.setColor(255,255,255);
                   myGLCD.drawRect(260,48,310,96); 
                              };     
             }
              if (page_level == 2) 
             {
                     
                   reset_all_buttons (250);

                      if (Home)
                              {
                       if (heater_2_button_z==false){heater_2_button=true;};
                       if (heater_2_button_z){heater_2_button=false;};
                   
                   myGLCD.setColor(255,255,255);
                   myGLCD.drawRect(260,96,310,144); 
                               };
             }
              if (page_level == 3 ) 
             {
                   reset_all_buttons (250);
                   
                   myGLCD.setColor(0,0,0);
                   myGLCD.drawRect(260, 144, 310, 192 );
                   page=11;
                   myGLCD.setColor(200,200,200);
                   myGLCD.drawRoundRect(262, 147, 311, 157+31);

                   myGLCD.setColor(0,0,0);
                   myGLCD.drawVLine (262, 155, 26);
                   
                   myGLCD.setColor(200,200,200);
                   draw_triangle ( 257, 163, 262, 158, 267, 163 );
                   draw_triangle ( 257, 173, 262, 178, 267, 173 );

                   //myGLCD.setColor(255,0,0);                  
                   //myGLCD.drawHLine (259, 162, 6);
                   //myGLCD.drawHLine (260, 161, 4);
                   //myGLCD.drawHLine (261, 160, 2);

                   set_temperature(0);
                   
                   page=10;
                   myGLCD.setColor(0,0,0);
                   myGLCD.drawRoundRect(262, 147, 311, 157+31);
                   myGLCD.setColor(0,0,0);
                   draw_triangle ( 257, 163, 262, 158, 267, 163 );
                   draw_triangle ( 257, 173, 262, 178, 267, 173 );
                   
             };
             if (page_level == 4 ) 
             {
                       if (Home_z==false){Home=true;};
                       if (Home_z){Home=false;};

                   reset_all_buttons (250);
                   myGLCD.setColor(255,255,255);
                   myGLCD.drawRect(260,192,310,239); 
             };
        }
     }
    if (page == 20)
     {
       
     }


     if (page == 30)
     {
        //- Запрет перехода на несуществующие пока страницы --     
        if (page_level > 1) {page_level = 1;}
        if (page_level < 0) {page_level = 0;}
        //- Доступна страница 0 и 1  -------------------------
         
           
     }

     if (tact==5)
        {  //-----------Опрос нижних кнопок на пролистывание страниц------
         if (button_data[1]==false ) {page=page+10; act = 0; page_level=0;};
         if (button_data[3]==false ) {page=page-10; act = 0; page_level=0;}; 
         if (button_data[2]==false ) {page=10;      act = 0; page_level=0;}; 
        } //--------------------------------------------------------------
        //Возможные иные действия этих кнопок будут располагаться выше в этой функции.
  }



void setup()
{ 
 
  //----Кнопочный модуль ----------------
  
  pinMode(RESET_ALL_BUTTONS, OUTPUT);
  digitalWrite(RESET_ALL_BUTTONS, HIGH);

     //---Пины сдвигового регистра-----------
        pinMode(REGISTR_CONTROL, OUTPUT);
        digitalWrite(REGISTR_CONTROL, LOW);

        pinMode(SYNC, OUTPUT);
        digitalWrite(SYNC, LOW);

        pinMode(DO, INPUT );
        pinMode(IRQ, INPUT );

  //--------------------------------------
  
  //-----Пины реле----------------
  pinMode(Rele_Cooler, OUTPUT);
  digitalWrite(Rele_Cooler, HIGH);

  pinMode(Rele_Heater, OUTPUT);
  digitalWrite(Rele_Heater, HIGH);
  //------------------------------
  
 
  //dht.begin();

  //pinMode(6, INPUT);
  //digitalWrite(6, HIGH);
  
  myGLCD.InitLCD(1); // инициализируем дисплей с горизонтальной ориентацией
  Serial.begin(9600); 

  watch.begin();       // Инициируем RTC модуль
               // сек, мин, час, день, месяц, год, день недели
  //watch.settime   (0,   57,  16,  13,   10,    20,  1);  //Устанавливаем текущее время. 
                                                           //Прошивается один раз, после чего строку нужно закоментить
}                                        

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////----Начало программы------//////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

void loop()
{   

   if (tact==9) {tact=5;};                       //Сброс счетчика// Такты 6,7,8 для анимации, 5 для функций, (1,2,3,4 зарезервировано, загрузочные такты)
   if (act==2400) {act=0;                        //Сброс счетчика
                   page=10;                      //Возврат на начальную страницу
                   Global_act++;};  
   if (Global_act==65) {Global_act=1;};          //Сброс счетчика   
   
   if (page > 49 || page < 10) {page=10; act=0;};        //Возврат на первую страницу, при перелистывании на страницу больше последней, или меньше первой. 
   if (page !=10 && act > 240) {page=10; act=0;};        //Возврат на первую страницу, с любой другой по прошествии примерно 3х минут.

 
//----------Режим работы реле--------------------------
                                                     
if (cooler==1) {digitalWrite(Rele_Cooler, LOW);};    
if (cooler==0) {digitalWrite(Rele_Cooler, HIGH);};

if (heater_1 == 1) {digitalWrite(Rele_Heater, LOW);};
if (heater_1 == 0) {digitalWrite(Rele_Heater, HIGH);};                
//-----------------------------------------------------     
  
 if (tact==5)          //На пятом такте отправляем дежурные или проверочные данные в серийный порт.
  {                      
    Serial.println("\n[memCheck]");  
    Serial.println((freeRam()) );
    
    Serial.println("\n[act] - ");
    Serial.print(act);

    Serial.println("\n[Button state] - ");
    //Serial.print( button_data);
    //Serial.print(button_data[0]);
   // Serial.print(button_data[1]);
   // Serial.print(button_data[2]);
   // Serial.print(button_data[3]);
   // Serial.print(button_data[4]);
   // Serial.print(button_data[5]);
   // Serial.print(button_data[6]);
   // Serial.print(button_data[7]);
      Serial.println(watch.gettime("d-m-Y, H:i:s, D"));  
   // Serial.println("\n[Registr_INPUT] - ");
    //  Serial.print( digitalRead (IRQ));

      Serial.println("\n[page_level] - ");
      Serial.print( page_level);

      Serial.println("\n[Hours] - ");
     Serial.print(watch.Hours);

      Serial.println("\n[heater_2_button] - ");
      Serial.print( heater_2_button);
    /*Serial.println("\n[heater] - ");
    Serial.print(heater); 
    Serial.println("\n[Rele_Heater] - ");
    Serial.print(digitalRead(Rele_Heater));  
 */
    Serial.println("\n[t] - ");
    Serial.print(t); 
  
           
  };  
  
   read_register();
   page_control ();
   page_level_z = page_level; 
 
 // -----------------------------//  Первая страница--------------------------------------------------------------------------
  
 if (page==10) // Элементы, первой, основной страницы.
 
   {                                          
     if (act==1)
       {
      
      myGLCD.InitLCD(1);  // инициализируем дисплей с горизонтальной ориентацией     
   // myGLCD.clrScr();   // очищаем экран
     clearScreen (); 
     reset_all_buttons (20);     
     draw_environment(); //Рисуем всё статичное изоражение 

        {  //----Установка температуры-------------------
         int a, b;

          a = set_temp % 10;                 //Единицы счетчика.
          b = (set_temp /10) % 10;           //Десятки счетчика.

             myGLCD.setColor (255,255,255);
            counter (272,159,b);
            counter (284,159,a);
        }  //-------------------------------------------
     }

      //--------------Отрисовка вентеляторов-----------------------   
        draw_cooler_icon ( 270,9, cooler, false, cooler_button,1); 
        draw_cooler_icon ( 270,57, false, heater_1, heater_1_button,2);   
        draw_cooler_icon ( 270,105, false, heater_2, heater_2_button,3);
     //-----------------------------------------------------------  

                                   
    if (Home != Home_z) {draw_home_icon (270, 201, Home);};          //Рисуем иконку дома, если состояние кнопки изменилось,
                                                                     //серую или светлую - решит сама функция.    
                                                               
 

   //-------------Сохранение некоторых значений,--   
   Home_z=Home;  //отдельно от функции save, для сохранения каждый такт на первой странице.
   cooler_z=cooler;   
   
   cooler_button_z = cooler_button;   
   
   heater_1_button_z = heater_1_button;
   heater_2_button_z = heater_2_button;
  
   heater_1_z=heater_1;
   heater_2_z=heater_2;
   //---------------------------------------------
  }; 

  
 // -----------------------------//  Вторая страница-----------------------------------------------------------------------------------------------
if (page == 20)
       {
  if (act==2 && page_level==0) 
    {             
      clearScreen ();
      reset_all_buttons (20); 

      myGLCD.setColor(VGA_WHITE);
      Write_15px ("ABVGDE~JZIKLMNOP0", 20, 20);
      Write_15px ("RSTUFHQcwWjbeuY0", 20, 45);              


      Write_8px ("ABVGDE~JZIKLMNOP0",20, 75);
      Write_8px ("RSTUFHQcwWjbeuY0",20, 85);
     

      Write_8px ("VTORAY0",100, 140);
      Write_8px ("STRANIQA0",180, 140); 

      Write_8px ("PROBNyi0",100, 155);
      Write_8px ("TEKST0",180, 155);        

         //  A - A;   J - Ж;   N - Н;   F - Ф;  y - Ы;    
//  B - Б;   Z - З;   О - О;   H - Х;  b - Ь; 
//  V - В;   I - И;   P - П;   Q - Ц;  e - Э; 
//  G - Г;   i - Й;   R - Р;   с - Ч;  u - Ю;
//  D - Д;   K - K;   S - С;   w - Ш;  Y - Я.        
//  E - E;   L - Л;   Т - Т;   W - Щ;        
//  ~ - Ё;   M - M;   U - У;   j - Ъ;
    }
  };

//------------------------------// Третья страница (График суточной температуры)----------------------------------------
 
  if (page == 30)
   {   
     if (page_level==0  && act==2)  
    {
      clearScreen ();
      reset_all_buttons (20); 

   int day_T_for_graphic[25];  // массивы для передачи в функцию рисования графика
   int day_t_for_graphic[25];  //   
     
      //-----Подготовка массивов с данными для передачи в функцию отрисовки графика
      for (int i=0; i<(watch.Hours+1); i++)
           {
            day_T_for_graphic[23-i] = day_T[(watch.Hours)-i];
            day_t_for_graphic[23-i] = day_t[(watch.Hours)-i];
           };
              
      for (int i=0; i<(23-watch.Hours); i++)
           {
           day_T_for_graphic[i] =  day_T[(watch.Hours)+i+1];
           day_t_for_graphic[i] =  day_t[(watch.Hours)+i+1];                        
           };
   
           day_T_for_graphic[23] = day_T[watch.Hours];
           day_T_for_graphic[24] = day_T[watch.Hours]; 
           
           day_t_for_graphic[23] = day_t[watch.Hours];
           day_t_for_graphic[24] = day_t[watch.Hours];   
       //---------------------------------------------------------------------------          
      
  graphic ( 20, 15, 240, 200, 10, 10, 2, 25, 1, day_t_for_graphic, day_T_for_graphic ); 

   myGLCD.setColor(240, 230, 140);
   Write_8px ("SUTOcNAY0", 30, 7);
   Write_8px ("TEMPERATURA0", 110, 7); 
   small_counter ( 220, 7, watch.day, 0, 255, 255, 255); //(int x, int y, byte count_number, boolean i, int l,int m, int n)
   small_counter ( 237, 7, watch.month, 0, 255, 255, 255);
   myGLCD.setColor(255, 255, 255);
   myGLCD.drawPixel (229, 14);

 
  //-----  отметки оси Х  (рисуются вручную для каждого графика) 
    small_counter ( 257, 120, (watch.Hours)+1, 0, 211, 211, 211);
    small_counter ( 217, 120, hour_minus((watch.Hours)+1), 0, 211, 211, 211);
    small_counter ( 177, 120, hour_minus((watch.Hours)-3), 0, 211, 211, 211);
    small_counter ( 137, 120, hour_minus((watch.Hours)-7), 0, 211, 211, 211);
    small_counter ( 97, 120, hour_minus((watch.Hours)-11), 0, 211, 211, 211); 
    small_counter ( 57, 120, hour_minus((watch.Hours)-15), 0, 211, 211, 211);

   //-----отметки оси Y
  
    small_counter ( 10, 110, 0, 0, 255, 255, 255);
    small_counter ( 10, 90, 10, 0, 255, 215, 0);  
    small_counter ( 10, 70, 20, 0, 255, 140, 0); 
    small_counter ( 10, 50, 30, 0, 255, 140, 0);
    small_counter ( 10, 30, 40, 0, 255, 140, 0); 
   
    small_counter (10, 130, 10, 0, 100, 149, 237);  
    small_counter (10, 150, 20, 0, 0, 0, 255); 
    small_counter (10, 170, 30, 0, 0, 0, 255);
    small_counter (10, 190, 40, 0, 0, 0, 255); 

    draw_magnifying_glass(278, 100);                      //отрисовка лупы.
    draw_up_arrow (278, 55, 0);                           //отрисовка стрелки вверх
    draw_down_arrow (278, 145, 0);                        //отрисовка стрелки вниз
    }
///------------------ Страница 3-1  График 12 часов----------------------------------------

       if (page_level == 1 && act==2 )
            {
              clearScreen ();
              reset_all_buttons (100); 

              int day_T_for_graphic[25] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};  // массивы для передачи в функцию рисования графика
              int day_t_for_graphic[25] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};  //   
              int day_T_30min_for_graphic[25];
              int day_t_30min_for_graphic[25];
              int day_T_for_graphic_2[25] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
              int day_t_for_graphic_2[25] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};

                //-----Подготовка массивов с данными для передачи в функцию отрисовки графика
                   for (int i=0; i<(watch.Hours+1); i++)
                     {
                      day_T_for_graphic[23-i] = day_T[(watch.Hours)-i];
                      day_t_for_graphic[23-i] = day_t[(watch.Hours)-i];
                      };
              
                   for (int i=0; i<(23-watch.Hours); i++)
                      {
                       day_T_for_graphic[i] =  day_T[(watch.Hours)+i+1];
                       day_t_for_graphic[i] =  day_t[(watch.Hours)+i+1];                        
                       };
   
                       day_T_for_graphic[23] = day_T[watch.Hours];
                       day_T_for_graphic[24] = day_T[watch.Hours]; 
           
                       day_t_for_graphic[23] = day_t[watch.Hours];
                       day_t_for_graphic[24] = day_t[watch.Hours]; 
                    //---------------------------------------
                        
                        for (int i=0; i<(watch.Hours+1); i++)
                     {
                      day_T_30min_for_graphic[23-i] = day_T_30min[(watch.Hours)-i];
                      day_t_30min_for_graphic[23-i] = day_t_30min[(watch.Hours)-i];
                      };
              
                   for (int i=0; i<(23-watch.Hours); i++)
                      {
                       day_T_30min_for_graphic[i] =  day_T_30min[(watch.Hours)+i+1];
                       day_t_30min_for_graphic[i] =  day_t_30min[(watch.Hours)+i+1];                        
                       };
   
                       day_T_30min_for_graphic[23] = day_T_30min[watch.Hours];
                       day_T_30min_for_graphic[24] = day_T_30min[watch.Hours]; 
           
                       day_t_30min_for_graphic[23] = day_t_30min[watch.Hours];
                       day_t_30min_for_graphic[24] = day_t_30min[watch.Hours]; 

           //int I=2; 
            if ((watch.minutes) >=  30)
                 {  
                   day_t_for_graphic_2[0]  = day_t_30min_for_graphic[11];
                   day_T_for_graphic_2[0]  = day_T_30min_for_graphic[11];
                   
                  for (int k=0,m=0; k<12; k++)
                     {
                          day_t_for_graphic_2[24-m] =  day_t_30min_for_graphic[24 - k];  
                          day_T_for_graphic_2[24-m] =  day_T_30min_for_graphic[24 - k];      
                          m++;                              
                          day_t_for_graphic_2[24-m] =  day_t_for_graphic[24 - k];  
                          day_T_for_graphic_2[24-m] =  day_T_for_graphic[24 - k];  
                          m++;
                       }
                     }  
           
                     
            if ((watch.minutes) < 30)
                 {     
                       day_t_for_graphic_2[0] =  day_t_for_graphic[11];
                       day_T_for_graphic_2[0] =  day_T_for_graphic[11];
                      // Переменная m возрастает на 2 ед. за такт счетчика. Чтобы счетчик не вывел указатель адреса
                      // в отрицательное значение и не выходить за пределы массива. Значение для [0] укзаны отдельно. 
                  for (int k=0, m=0; k<12; k++)
                     {    
                          day_t_for_graphic_2[24-m] =  day_t_for_graphic[24 - k];
                          day_T_for_graphic_2[24-m] =  day_T_for_graphic[24 - k];             
                          m++; 
                          day_t_for_graphic_2[24-m] =  day_t_30min_for_graphic[24 - k]; 
                          day_T_for_graphic_2[24-m] =  day_T_30min_for_graphic[24 - k];      
                          m++;   
                       }
                       
                     }  
  
   graphic ( 20, 15, 240, 200, 10, 10, 2, 25, 1, day_t_for_graphic_2, day_T_for_graphic_2 ); 
   
             
              //-----  отметки оси Х  (рисуются вручную для каждого графика) 
                 small_counter ( 257, 120, (watch.Hours)+1, 0, 211, 211, 211);
                 small_counter ( 217, 120, hour_minus((watch.Hours)+3), 0, 211, 211, 211);
                 small_counter ( 177, 120, hour_minus((watch.Hours)+1), 0, 211, 211, 211);
                 small_counter ( 137, 120, hour_minus((watch.Hours)-1), 0, 211, 211, 211);
                 small_counter ( 97, 120, hour_minus((watch.Hours)-3), 0, 211, 211, 211); 
                 small_counter ( 57, 120, hour_minus((watch.Hours)-5), 0, 211, 211, 211);

              //-----отметки оси Y
  
                 small_counter ( 10, 110, 0, 0, 255, 255, 255);
                 small_counter ( 10, 90, 10, 0, 255, 215, 0);  
                 small_counter ( 10, 70, 20, 0, 255, 140, 0); 
                 small_counter ( 10, 50, 30, 0, 255, 140, 0);
                 small_counter ( 10, 30, 40, 0, 255, 140, 0); 
   
                 small_counter (10, 130, 10, 0, 100, 149, 237);  
                 small_counter (10, 150, 20, 0, 0, 0, 255); 
                 small_counter (10, 170, 30, 0, 0, 0, 255);
                 small_counter (10, 190, 40, 0, 0, 0, 255); 



              myGLCD.setColor(240, 230, 140);              
              Write_8px ("TEMPERATURA0", 80, 7); 
              small_counter ( 60, 7, 12, 0, 255, 255, 255);
              Write_8px ("c0", 68, 7);


               draw_magnifying_glass(278, 100);                      //отрисовка лупы.
               draw_up_arrow (278, 55, 0);                           //отрисовка стрелки вверх
               draw_down_arrow (278, 145, 0);                        //отрисовка стрелки вниз
            }
    
  };




  
 //------------------------------// Четвертая страница (Суточный график)----------------------------------------

 if (page == 40)
    {
     if (act==2 && page_level==0)  
     {
      clearScreen ();
      reset_all_buttons (20);   

    //Тестовый, произвольный суточный график со значениями по Y от 0 до 190 едениц.   
      int day_graphic_1[25] = {0,15,26,30,45,55,80,81,89,50,23,5,6,77,8,18,23,25,35,40,45,50,72,80,86};  //подготовленные массивы для передачи в функцию рисования графика
      int day_graphic_2[25] = {10,25,24,55,59,60,83,89,96,55,28,45,49,150,159,160,168,180,190,100,45,55,76,89,99};  //   

// graphic( int x, int y, int resolution_grid_x, int resolution_grid_y, int step_X, int step_Y, int zoom_Y, int l, int type, int data_1[], int data_2[] )
graphic (   20,    15,    240,                   200,                   10,         20,         1,          25,    2,        day_graphic_1, day_graphic_2 ); 

 //-----  отметки оси Х  (рисуются вручную для каждого графика) 
    small_counter ( 257, 220, watch.Hours+1, 0, 211, 211, 211);
    small_counter ( 217, 220, hour_minus(watch.Hours+1), 0, 211, 211, 211);
    small_counter ( 177, 220, hour_minus(watch.Hours-3), 0, 211, 211, 211);
    small_counter ( 137, 220, hour_minus(watch.Hours-7), 0, 211, 211, 211);
    small_counter ( 97, 220, hour_minus(watch.Hours-11), 0, 211, 211, 211); 
    small_counter ( 57, 220, hour_minus(watch.Hours-15), 0, 211, 211, 211);
       
       myGLCD.setColor(240, 230, 140);
  Write_8px ("SUTOcNyi0", 80, 6);
  Write_8px ("GRAFIK0", 160, 6); 


 draw_magnifying_glass(278, 100);   //отрисовка лупы.
 draw_up_arrow (278, 55, 0);        //отрисовка стрелки вверх
 draw_down_arrow (278, 145, 0);     //отрисовка стрелки вниз
 
 // ----Надпись "Время, Ч"------------------
 //      myGLCD.setColor(0, 0, 0);
 // myGLCD.fillRect (230,190,290,208);

 //      myGLCD.setColor(VGA_WHITE); 
 // Write_8px ("VREMY0", 235, 195);
 // Write_8px ("c0", 285, 195);
 // myGLCD.setFont(SmallFont);
 // myGLCD.print(",", 277, 195, 0);
 //-----------------------------------------   
    }
  };
     
     if (cooler_button == 1){cooler = 1;};
     if (heater_1_button==1){heater_1 = 1;};
     if (heater_2_button==1){heater_2 = 1;}; 
     
     if (heater_1_button==0){heater_1 = 0;};
     if (heater_2_button==0){heater_2 = 0;};
     if (cooler_button == 0){cooler = 0;};  
     

/*  
   
 *   //////-----Основные функции программы--------------------------------------------------------------------------------------------------------------------------------------                                   
//---------1.Климатические Режимы------------------------------------------------------------------------------------------------------------------------------------------
    if (cooler_button == 1){cooler = 1;};
    
                                                                                            //Включается при +20 выключается при 22
    // if (Home==0 && t<set_temp )  {heater=1;} ;                                              //Подогрев воздуха если температура в помещении ниже +21 градуса.
    // if (Home==0 && t>set_temp)   {heater=0;};                                               //А на улице еще холоднее. Выключение обогрева при t>21 градусов
    // if (Home==0 && sensor_inside_fail==1 || Home==1) {heater=0;};                     //Запрет на запуск, при потере внутреннего датчика или выключенной кнопки "Дома".
           //else {heater=0;}; 
     if (heater_1_button==1){heater_1 = 1;};
     if (heater_2_button==1){heater_2 = 1;}; 
     
     if (heater_1_button==0){heater_1 = 0;};
     if (heater_2_button==0){heater_2 = 0;};                                                                     
           

   if (Home==0 && cooler_button==0 && act>2300) 
                    {cooler=1;};                                                             //5-ти минутное проветривание каждые пол часа, вне зависимости 
                                                                                            //от забортной температуры. (пока нет датчика уровня CO2)
     
      if (Home==0 && cooler_button==0 && (w-W)>20 && sensor_outside_fail==0 && sensor_inside_fail==0)
                    {cooler=1;};                                                            //Проветривание, если влажность в помещении значительно выше уличной.
      
       if (Home==0 && cooler_button==0 && t<21 && T>t && sensor_outside_fail==0 && sensor_inside_fail==0) 
                    {cooler=1;};                                                             //Если уличная температура выше домашней (теплое утро после холодно ночи),
                                                                                            //то прогреваем помещение забортным воздухом.
      
        if (Home==0 && cooler_button==0 && t>25 && T<20 && sensor_outside_fail==0 && sensor_inside_fail==0) {cooler=1;};
        if (Home==0 && cooler_button==0 && t<25 && act<2300) {cooler=0;};             
                                                                                            //Если в помещении стало слишком жарко ( < +24), от дровянной печи, а на улице 
                                                                                            // более прохладно ( > 20),то включаем проветривание.
         if (Home==0 && cooler_button==1) 
                    {cooler=1;};                                                            // Включаем вентеляцию, если включена кнопа принудительной вентиляции.
                                                                                            //Запрет на запуск, в случае оборванного датчика, кроме ручного включения
                                                                                            //вентеляции и 5ти минутного проветривания каждые пол часа.
 
                         
 //--------------------------- Режим "Вне дома"----------------------------------------------------       
        
       // if (Home==1 && T>5 && T<27 && W<(w-2) && sensor_outside_fail==0  && sensor_inside_fail==0) 
       //              {cooler=1;};
                                                                                            // Летнее проветривание, при температурах от +5 до 27,
                                                                                            // и влажности на улице меньше чем дома.
                                                                                            // Вентилятор работает пока влажность дома не будет ниже уличной.
                                                                                            // При первом включении гистерезис влажности 0%, при попытке следующего в течении
                                                                                            // текущего акта,  -5% влажности,
                                                                                            // для внутреннего датчика.
             //else   cooler=0;};     

       // if (Home==1) {cooler=0; cooler_button=0;};                                                               
//----------------------------------------------------------------------------------------------------------------------------------------------------------------
*/ 

 //------Счетчик актов и тактов в углу экрана------------
 //  if (act==1) {light_counter (277,3,Global_act,0);};
 //  draw_act_counter (act);
 //  light_counter (310,3,tact,1);   
 //------------------------------------------------------

   if (tact != 5){delay(600);} // Задержка, влияюющая на скорость анимации, для всех тактов кроме пятого. 
                             
 
   if (tact==5)  //На пятом такте
    {   
     
      check_sensor(); //Считываем показания климатических датчиков.  
      state_sensor(); //Если значения изменились по сравнению с предыдущим сохранением,
                      //то перерисовываем разряд счетчика с новым значением. 
      save_sensor();  //Сохраняем текущее значение разрядов всех датчиков. 

                                                    
    }; 

 
   tact++;
   act++;
  
}


////-----Расход ОЗУ----////

// 1. check_sensor();   |
//    state_sensor();   |      - 30 byte
//    save_sensor();    |
//    counter();        |
//    iarduino_DHT sensor1(6); - 16 byte
//    iarduino_DHT sensor(3);  - 16 byte
//    iarduino_DHT sensor2(2); - 16 byte
//--------------------------------------
//    78 byte (78 byte)
//
// 2. draw_environment();      - 0 byte
//-------------------------------------
//
// 3. coller();                - 2  byte
//    draw_home_icon();        - 1  byte
//    light_counter();         - 2  byte
//   (Write_15px();            - 36 byte - 1 вызов)    (9100 byte)
//    Write_15px();            - 46 byte - 7 вызовов
//-------------------------------------
//    51 byte  (129 byte)
//
//


///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 
 
            //Функции
 
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 
   int draw_up_arrow (int x, int y, boolean type)
   {
  
    myGLCD.setColor(20,20,20); //фон
    myGLCD.fillRect(x-4,y-4,x+34,y+34);
  
    myGLCD.setColor(0,0,0);
    myGLCD.drawPixel (x-4, y-4);
    myGLCD.drawPixel (x-4, y+34);
    myGLCD.drawPixel (x+34, y-4);
    myGLCD.drawPixel (x+34, y+34);
  
    myGLCD.setColor(80,80,80);  // внешний контур иконки
    myGLCD.drawRoundRect(x-4,y-4,x+34,y+34);

    //----Внешний контур стрелки------
    myGLCD.setColor(170, 170, 170);

    myGLCD.drawLine (x+1,y+15,x+15,y+1);
    myGLCD.drawLine (x+16,y+1,x+30,y+15);  

    myGLCD.drawHLine (x+2,y+17,5);
    myGLCD.drawHLine (x+24,y+17,5);
    myGLCD.drawHLine (x+11,y+30,9);
   
    myGLCD.drawVLine (x+9,y+19,9);
    myGLCD.drawVLine (x+22,y+19,9);
  
    myGLCD.drawPixel (x+1, y+16);
    myGLCD.drawPixel (x+30, y+16);
    myGLCD.drawPixel (x+8, y+18);
    myGLCD.drawPixel (x+23, y+18);
    myGLCD.drawPixel (x+10, y+29);
    myGLCD.drawPixel (x+21, y+29);
    //--------------------------   
  
   //------ Внутренний контур стрелки----
    myGLCD.setColor(40,40,40);
    myGLCD.drawLine (x+5,y+14,x+15,y+4);
    myGLCD.drawLine (x+16,y+4,x+26,y+14);
    myGLCD.drawVLine (x+11,y+18,8);
    myGLCD.drawVLine (x+20,y+18,8);
    myGLCD.drawHLine (x+6,y+15,2);
    myGLCD.drawHLine (x+23,y+15,2);
    myGLCD.drawHLine (x+13,y+28,5);
    myGLCD.drawPixel (x+9, y+16);
    myGLCD.drawPixel (x+10, y+17);
    myGLCD.drawPixel (x+22, y+16);   
    myGLCD.drawPixel (x+21, y+17);
    myGLCD.drawPixel (x+12, y+27);
    myGLCD.drawPixel (x+19, y+27);
    //--------------------------  
   
    myGLCD.setColor(210, 210, 210); //Знак "плюс"
    myGLCD.fillRect(12+x,12+y,19+x,13+y);    
    myGLCD.fillRect(15+x,16+y,16+x,9+y);
   }

  int draw_down_arrow (int x, int y, boolean type)
  {
     myGLCD.setColor  (20,20,20);  //  фон
     myGLCD.fillRect  (x-4,y-4,x+34,y+34);
  
     myGLCD.setColor  (0,0,0);
     myGLCD.drawPixel (x-4, y-4);
     myGLCD.drawPixel (x-4, y+34);
     myGLCD.drawPixel (x+34, y-4);
     myGLCD.drawPixel (x+34, y+34);
  
     myGLCD.setColor  (80, 80, 80); // внешний контур иконки
     myGLCD.drawRoundRect(x-4,y-4,x+34,y+34);
  
      //----Внешний контур стрелки------
     myGLCD.setColor  (170, 170, 170);

     myGLCD.drawLine  (x+1, y+16, x+15, y+30);
     myGLCD.drawLine  (x+16, y+30, x+30, y+16);

     myGLCD.drawVLine (x+9,y+3,9);
     myGLCD.drawVLine (x+22,y+3,9);

     myGLCD.drawHLine (x+11,y+1,9);
     myGLCD.drawHLine (x+24,y+14,5);
     myGLCD.drawHLine (x+2,y+14,5);

     myGLCD.drawPixel (x+10, y+2);
     myGLCD.drawPixel (x+21, y+2);
     myGLCD.drawPixel (x+8, y+13);
     myGLCD.drawPixel (x+23, y+13);
     myGLCD.drawPixel (x+1, y+15);
     myGLCD.drawPixel (x+30, y+15);
      //----------------------------    

     //------ Внутренний контур стрелки------
     myGLCD.setColor  (40,40,40);
   
     myGLCD.drawLine  (x+5, y+17, x+15, y+27);
     myGLCD.drawLine  (x+16, y+27, x+26, y+17);

     myGLCD.drawHLine (x+13,y+3,5);
     myGLCD.drawHLine (x+6,y+16,2);
     myGLCD.drawHLine (x+23,y+16,2);

     myGLCD.drawVLine (x+11,y+5,8);
     myGLCD.drawVLine (x+20,y+5,8);

     myGLCD.drawPixel (x+12, y+4);
     myGLCD.drawPixel (x+19, y+4);
     myGLCD.drawPixel (x+10, y+14);
     myGLCD.drawPixel (x+9, y+15);
     myGLCD.drawPixel (x+21, y+14);
     myGLCD.drawPixel (x+22, y+15);
     //-------------------------------------
   
     myGLCD.setColor  (210, 210, 210);  // Знак "минус"
     myGLCD.fillRect  (12+x,18+y,19+x,19+y); 
     
  }


  int draw_magnifying_glass(int x, int y)
    {
     
     myGLCD.setColor(192,192,192);

     myGLCD.drawVLine (x+8,y+9,4);
     myGLCD.drawVLine (x+9,y+14,1);
     myGLCD.drawVLine (x+22,y+5,1);
     myGLCD.drawVLine (x+23,y+7,1);
     myGLCD.drawVLine (x+24,y+9,3);
     myGLCD.drawVLine (x+23,y+13,1);
     myGLCD.drawVLine (x+14,y+20,3);
     myGLCD.drawVLine (x+13,y+24,1);
     myGLCD.drawVLine (x+6,y+26,2);

     myGLCD.drawHLine (x+14,y+3,5);
     myGLCD.drawHLine (x+14,y+18,4);   
     myGLCD.drawHLine (x+19,y+17,1);
     myGLCD.drawHLine (x+20,y+4,1);
     myGLCD.drawHLine (x+11,y+17,1);

     myGLCD.drawLine (x+9, y+7, x+13, y+3);
     myGLCD.drawLine (x+7, y+24, x+13, y+18);
     myGLCD.drawLine (x+9, y+30, x+12, y+27);

     myGLCD.drawPixel (x+7, y+25);
     myGLCD.drawPixel (x+7, y+29);
     myGLCD.drawPixel (x+8, y+30);
     myGLCD.drawPixel (x+15, y+19);
     myGLCD.drawPixel (x+10, y+16);   
     myGLCD.drawPixel (x+21, y+16);
     myGLCD.drawPixel (x+22, y+15);  
     myGLCD.drawPixel (x+9, y+8);
     myGLCD.drawPixel (x+10, y+16);
     myGLCD.drawPixel (x+12, y+26);

     //---
     myGLCD.setColor(140,140,140);
     myGLCD.drawVLine (x+27,y+9,3);
     myGLCD.drawLine (x+23, y+4, x+26, y+7);
     myGLCD.drawPixel (x+21, y+19);
     myGLCD.drawPixel (x+24, y+17);
     myGLCD.drawPixel (x+26, y+8);
     myGLCD.drawVLine (x+26,y+13,1);
     myGLCD.drawVLine (x+25,y+15,1); 
     myGLCD.drawHLine (x+16,y+20,4);
     myGLCD.drawPixel (x+23, y+18);
     myGLCD.drawPixel (x+22, y+19);
    
     //-----
     myGLCD.setColor(0,0,255);
     myGLCD.drawVLine (x+12,y+10,2);
     myGLCD.drawLine (x+12, y+9, x+14, y+7);
     myGLCD.drawPixel (x+13, y+13);
    
  }



//-------------------------------------------------------------------------График-------------------------------------------------------------------------

int graphic ( int x, int y, int resolution_grid_x, int resolution_grid_y, int step_X, int step_Y, int zoom_Y, int l, int type, int data_1[], int data_2[] )

{
  //graphic ( 20, 15, 240, 200, 10, 10, 2, 25, 1, day_T_for_graphic, day_t_for_graphic );
  //int l = 25; //длинна графика в вершинах из массива. 
               //Одна точка, одна ячейка массива.            
  //int step_X = 10; //шаг вершин графика по оси Х, сетка по оси х в 2 раза больше этого значения.
  //int step_Y = 10; //шаг по оси Y
  //int zoom_Y = 2;  //масштабирование графика по оси Y. (умножение значения Y)
  //int x=20; //начальные координаты графика. 
  //int y=15; //левый верхний угол
  //int type=1; //тип графика     Тип 1: положительные и отрицательные значения по оси Y. Тип 2: только положительные по Y.
  //int resolution_grid_x=240; // (размер (разрешение) графика)  
  //int resolution_grid_y=200;

  resolution_grid_y=resolution_grid_y/2;
      
    myGLCD.setColor(70,70,70);
        for (int i=1; i<l/2; i++ )  //рисуем фоновую сетку по вертикали.
        {         
          myGLCD.drawLine ( ((x)+step_X*i*2), y+resolution_grid_y, ((x)+step_X*i*2),  y+10);  
          myGLCD.drawLine ( ((x)+step_X*i*2), y+resolution_grid_y, ((x)+step_X*i*2),  y+resolution_grid_y*2);  
        }

        if (type==1){
        for (int i=0; i<(step_Y/zoom_Y); i++ ) //рисуем фоновую сетку по горизонтали          
        {
          myGLCD.drawLine (x, (resolution_grid_y-(step_Y)*i*zoom_Y)+y, x+resolution_grid_x, (resolution_grid_y-(step_Y)*i*zoom_Y)+y );
          myGLCD.drawLine (x, (resolution_grid_y+(step_Y)*i*zoom_Y)+y, x+resolution_grid_x, (resolution_grid_y+(step_Y)*i*zoom_Y)+y );
        }; 
                   };
        
        if (type==2){

        for (int i=0; i<(resolution_grid_y/step_Y); i++ ) //рисуем фоновую сетку по горизонтали          
        {
          myGLCD.drawLine (x, (resolution_grid_y-(step_Y)*i*zoom_Y)+y, x+resolution_grid_x, (resolution_grid_y-(step_Y)*i*zoom_Y)+y );
          myGLCD.drawLine (x, (resolution_grid_y+(step_Y)*i*zoom_Y)+y, x+resolution_grid_x, (resolution_grid_y+(step_Y)*i*zoom_Y)+y );
        }; 
                   };           
                       
        for (int i=1; i<=l/4; i++ ) //рисуем вертикальные риски оси х  
        {
          myGLCD.setColor(VGA_WHITE);
          myGLCD.drawLine ( ((x)+step_X*i*4), (y+resolution_grid_y*type), ((x)+step_X*i*4),  (y+resolution_grid_y*type)-7); 
        };

        if (type==1){  
        for (int i=0; i<(step_Y/zoom_Y); i++ ) //рисуем горизонтальные риски оси y
        {
          myGLCD.drawLine (x, resolution_grid_y+(step_Y*zoom_Y)*i+y, x+5, resolution_grid_y+(step_Y*zoom_Y)*i+y );
          myGLCD.drawLine (x, resolution_grid_y-(step_Y*zoom_Y)*i+y, x+5, resolution_grid_y-(step_Y*zoom_Y)*i+y );
         }; 
                  }; 

         if (type==2){  
        for (int i=0; i<(resolution_grid_y/step_Y); i++ ) //рисуем горизонтальные риски оси y
        {
          myGLCD.drawLine (x, resolution_grid_y+(step_Y*zoom_Y)*i+y, x+5, resolution_grid_y+(step_Y*zoom_Y)*i+y );
          myGLCD.drawLine (x, resolution_grid_y-(step_Y*zoom_Y)*i+y, x+5, resolution_grid_y-(step_Y*zoom_Y)*i+y );
         }; 
                  }; 
                          
       
        if (type==1){
          myGLCD.drawLine (x, y+resolution_grid_y, x+resolution_grid_x, y+resolution_grid_y);         //основная ось х, тип 1          
                   };
        if (type==2){
          myGLCD.drawLine (x, (y+resolution_grid_y*2), x+resolution_grid_x, (y+resolution_grid_y*2));  //основная ось х, тип 2
                    };
          myGLCD.drawLine (x, y+10,  x,  resolution_grid_y*2+y);                                       //основная ось y          


   draw_graphic (x, y, step_X, zoom_Y, l, resolution_grid_y, 255, 140, 0, data_1, type );
   draw_graphic (x, y, step_X, zoom_Y, l, resolution_grid_y, 0, 0, 255, data_2, type );  
};


void draw_graphic (int x, int y, int step_X, int zoom_Y, int l, int resolution_grid_y, int a, int b, int c, int data[], int type )
 {
   int Ax,  Ay,  Bx,  By, Cx, Cy;              // основные точки для построения графика
   int A2x, A2y, B1x, B1y, B2x, B2y, C1x, C1y; // вспомогательные точки, для сглаживания вершин
   int r1, r2;                                 // направление прямой графика.
 
   
 for (int i=1; i<l; i=i+2)
    {
      Ax=x+(step_X*(i-1));      
      Ay=y+(resolution_grid_y*type)-(data[i-1]*zoom_Y);       
       
      Bx=x+(step_X*i);      
      By=y+(resolution_grid_y*type)-(data[i]*zoom_Y);
       
      Cx=x+(step_X*(i+1));      
      Cy=y+(resolution_grid_y*type)-(data[i+1]*zoom_Y);
       
      myGLCD.setColor(a,b,c);  
 
 /// --- Проверка на движение графика и расчет доп. точек для сглаживания вершин --- 
  if        (Ay>By && (Ay-By)>5){r1=1;}   // возростание 1й линии графика
   else if  (Ay<By && (By-Ay)>5){r1=2;}   // снижение 1й линии графика
     else                      {r1=0;};   // без сглаживания

 
  if        (By>Cy && (By-Cy)>5){r2=1;}   // возростание 2й линии графика
   else if  (By<Cy && (Cy-By)>5){r2=2;}   // снижение 2й линии графика
     else                      {r2=0;};   // без сглаживания 
 //--сглаживание вершин происходит если расcтояние между соседними вершинами по оси Y более 5px
 
    if (r1==1) {A2x=Ax+2;
                A2y=Ay-1;
                B1x=Bx-2;
                B1y=By+1;};
   
    if (r1==2) {A2x=Ax+2;
                A2y=Ay+1; 
                B1x=Bx-2;
                B1y=By-1;};
 
    if (r1==0) {A2x=Ax;
                A2y=Ay;
                B1x=Bx;
                B1y=By;};

    if (r2==1) {B2x=Bx+2;
                B2y=By-1;
                C1x=Cx-2;
                C1y=Cy+1;};

    if (r2==2) {B2x=Bx+2;
                B2y=By+1; 
                C1x=Cx-2;
                C1y=Cy-1;};

    if (r2==0) {B2x=Bx;
                B2y=By;
                C1x=Cx;
                C1y=Cy;};  
  
    //---- 1.   График со сглаженными вершинами
     myGLCD.drawLine (Ax, Ay, A2x, A2y);
     myGLCD.drawLine (A2x, A2y, B1x, B1y);
     myGLCD.drawLine (B1x, B1y, Bx, By);
     myGLCD.drawLine (Bx, By, B2x, B2y);
     myGLCD.drawLine (B2x, B2y, C1x, C1y);
     myGLCD.drawLine (C1x, C1y, Cx, Cy);
      
   //---- 2.  График без сглаживания вершин        
   //myGLCD.drawLine (Ax,Ay,Bx,By);
   //myGLCD.drawLine (Bx,By, Cx,Cy); 
  };
 };

int clearScreen ()  //Функция очистки экрана вертикальными прямоугольниками
      {
       myGLCD.setColor(0,0,0);
       myGLCD.fillRect(0,0,40,240);
       myGLCD.fillRect(41,0,80,240);
       myGLCD.fillRect(81,0,120,240);
       myGLCD.fillRect(121,0,160,240);
       myGLCD.fillRect(161,0,200,240);
       myGLCD.fillRect(201,0,240,240);
       myGLCD.fillRect(241,0,280,240);
       myGLCD.fillRect(281,0,320,240); 
      };


 void draw_home_icon(int x, int y, boolean Home_)  //Функция отрисовки иконки "Дома"
  {
    if (Home_)    {   myGLCD.setColor(255,100,0);
                      myGLCD.drawLine(x+6,y+13,x+15,y+4);
                      myGLCD.drawLine(x+16,y+5,x+24,y+13);  
                      myGLCD.setColor(224,252,151);
                      myGLCD.drawRoundRect(x-4,y-4,x+34,y+34);
                      myGLCD.setColor(80,80,80);
                      myGLCD.drawRoundRect(x-2,y-2,x+32,y+32);
                      myGLCD.setColor(VGA_WHITE);
                  }
       else       {
                       myGLCD.setColor(50,50,50);
                       myGLCD.drawRoundRect(x-4,y-4,x+34,y+34);
                       myGLCD.drawLine(x+6,y+13,x+15,y+4);
                       myGLCD.drawLine(x+16,y+5,x+24,y+13);
                  }   
     
     myGLCD.drawLine(x+3,y+14,x+15,y+2); 
     myGLCD.drawLine(x+4,y+14,x+14,y+4);
     myGLCD.drawLine(x+16,y+3,x+27,y+14);
     myGLCD.drawLine(x+15,y+3,x+26,y+14);
     
     myGLCD.drawVLine(x+6,y+14,13);
     myGLCD.drawVLine(x+24,y+14,13);
     myGLCD.drawVLine(x+12,y+17,4);
     myGLCD.drawVLine(x+18,y+17,4);
     myGLCD.drawVLine(x+7,y+27,1);
     myGLCD.drawVLine(x+23,y+27,1);
     
     myGLCD.drawHLine(x+13,y+16,4);
     myGLCD.drawHLine(x+13,y+22,4);
     myGLCD.drawHLine(x+8,y+29,14);
         
     myGLCD.drawPixel(x+5, y+14);
     myGLCD.drawPixel(x+25, y+14);
     myGLCD.drawPixel(x+8, y+28);
     myGLCD.drawPixel(x+22, y+28);         
  }  
 
 int draw_environment ()   // Функция стандартными средствами библиотеки UTFT рисует рамки и
                           // всё статичное изображение.  
  {
    // выбираем большой шрифт
  myGLCD.setFont(BigFont);
  myGLCD.setColor(VGA_WHITE); 
  
  myGLCD.print("%", 199, 43, 0);
  myGLCD.print("%", 199, 200, 0);
  myGLCD.print("%", 199, 117, 0);
  myGLCD.print("C", 207, 20, 0);
  myGLCD.print("C", 207, 177, 0);
  myGLCD.print("C", 207, 93, 0);
  myGLCD.print(".", 86, 120, 0);

  
 
  myGLCD.setFont(SmallFont);
  myGLCD.print("o", 202, 16, 0);
  myGLCD.print("o", 202, 172, 0);
  myGLCD.print("o", 202, 90, 0);
  myGLCD.print("2", 150, 78, 0);  

    //--- выбор температуры-------
    myGLCD.print("o", 296, 154, 0);
    myGLCD.print("C", 303, 158, 0);
   //-----------------------------
  
  symbol_temperature (25, 22);  
  Write_15px ("VOZDUHA0", 50, 22);
  
  symbol_temperature (25, 177);
  Write_15px ("VOZDUHA0", 50, 177);  
  
  Write_15px ("VLAJNOSTb0", 25, 46);  
  
  Write_15px ("VLAJNOSTb0", 25, 202);  
  
  Write_15px("UROVENb0",25, 71);
  Write_15px("SO0",125, 71);  
  
  symbol_temperature (25, 95);
  Write_15px ("POLA0", 50, 95);
  
  Write_15px ("VLAJN0", 25, 119);
  Write_15px ("POLA0", 105, 119);
    
  draw_home_icon (270, 201, Home);      //Иконка "Дома"  
 
    
   // myGLCD.setColor(100,100,100);      //Рамка для тактов и актов в углу экрана.
   // myGLCD.drawRoundRect(270,1,316,12);
  
  
  
  //------Счетчики датчиков----------------------------------------
       //-------Внутренний датчик--------------------------//
       counter (175,21,t1);//Температура в кабине (десятки)
       counter (188,21,t2); //Температура в кабине (еденицы)
  
       counter (175,45,w1); //Влажность в кабине (десятки)
       counter (188,45,w2); //Влажность в кабине (еденицы)
  
       //---------Забортные счетчики -----------------------//
       counter (175,176,T1); //Температура забортом (десятки)
       counter (188,176,T2); //Температура забортом (единицы)
  
       counter (175,201,W1); //Влажность забортом (десятки)
       counter (188,201,W2); //Влажность забортом (единицы)   
  
      //------Влажность и температура пола ---------------//
      counter (175,118,w_floor1); //Влажность пола (десятки)
      counter (188,118,w_floor2); //Влажность пола (еденицы)
 
      counter (175,94,t_floor1); //Температура пола (десятки) 
      counter (188,94,t_floor2); //Температура пола (единицы)
 //---------------------------------------------------------------     
      
  
 /////////----Верхняя рамка---------------
 
  myGLCD.setColor(255,100,0);
  //myGLCD.drawPixel(10, 10);
  
  myGLCD.drawLine(9,6,232,6);
  myGLCD.drawLine(11,5,230,5);//Верхняя горизонтальная
  myGLCD.drawLine(7,8,10,7);
    
  myGLCD.drawLine(5,11,5,145);
  myGLCD.drawLine(6,9,6,147);//Верхняя вертикальная (левая)
  myGLCD.drawLine(7,8,7,10);
  myGLCD.drawPixel(8, 8);
    
  myGLCD.drawLine(7,146,7,148);
  myGLCD.drawLine(8,149,10,149);
  myGLCD.drawLine(9,150,232,150);
  myGLCD.drawLine(11,151,230,151);
  myGLCD.drawPixel(8, 148);  

  myGLCD.drawLine(231,7,233,7);
  myGLCD.drawLine(231,7,233,7);
  myGLCD.drawLine(234,8,234,10);
  myGLCD.drawLine(235,9,235,147);  
  myGLCD.drawLine(236,11,236,145); 
  myGLCD.drawPixel(233, 8);
    
  myGLCD.drawLine(234,146,234,148); 
  myGLCD.drawLine(233,149,231,149); 
  myGLCD.drawPixel(233, 148); 
  
  //////////////////////////////////////////////////////////  
  
  myGLCD.setColor(255,100,0);
  myGLCD.drawLine(16,12,50,12); //горизон. верх.
  
  myGLCD.setColor(VGA_YELLOW);
  
  myGLCD.drawLine(15,13,48,13);
  myGLCD.setColor(255,100,0);
  myGLCD.drawLine(13,15,13,50);
  myGLCD.setColor(VGA_YELLOW);
  myGLCD.drawLine(14,14,14,48);
  myGLCD.drawPixel(15, 14); 
  ////////////////////////////////////////////////////////////
   
 //------Внутрений уголок (левый нижний) 
  myGLCD.setColor(VGA_YELLOW);
  myGLCD.drawLine(14,141,14,112);
  myGLCD.drawLine(15,142,48,142);
  myGLCD.drawPixel(15, 141);  
  
  myGLCD.setColor(255,100,0);
  myGLCD.drawLine(13,140,13,111);
  myGLCD.drawLine(16,143,50,143);
  //////////////////////////////////////////////////////
  
   //--------- Внутренний уголок (правый нижний)
  myGLCD.setColor(255,100,0);
  myGLCD.drawHLine (224,143,-30);
  myGLCD.drawVLine (227,140,-30);
  
  
  myGLCD.setColor(VGA_YELLOW);
  
  myGLCD.drawHLine (225,142,-30);
  myGLCD.drawVLine (226,141,-30);
  myGLCD.drawPixel(225, 141);
  
  /////////////////////////////////////////////////////
  
  
  
  //------Внутренний уголок (правый верхний)
    
  myGLCD.setColor(VGA_YELLOW);
  myGLCD.drawHLine (225,13,-30);
  myGLCD.drawVLine (226,14,28);
  myGLCD.drawPixel(225, 14);
  
  myGLCD.setColor(255,100,0);
  
  myGLCD.drawVLine (227,15,30);
  myGLCD.drawHLine (224,12,-30);
  
  //////////////////////////////////////////////////////// 
  
  //myGLCD.setColor(VGA_TEAL); //бирюзовый
  
  //myGLCD.setColor(VGA_OLIVE); //светло-коричневый, ближе к зеленому
  
  //myGLCD.setColor(VGA_MAROON);  //бордовый 
  
  //myGLCD.setColor(VGA_FUCHSIA);   //pink  !!!
  
  //myGLCD.setColor(VGA_PURPLE);      // тусклый pink
 
  //myGLCD.setColor(VGA_LIME);       // Светло-зеленый!!!
  
  // myGLCD.setColor(VGA_AQUA);       // голубой !!!
  
  //myGLCD.setColor(255,100,0);      //оранжевый
  
  //myGLCD.setColor(VGA_BLUE);  // яркий синий !!! 
 
 /////----Нижняя внутреняя рамка-------/////////// 
   
   myGLCD.setColor(70,10,163);
   myGLCD.drawLine(14,166,224,166);
   
   myGLCD.drawLine(13,167,225,167);
   myGLCD.drawPixel(225, 168);
   
   myGLCD.drawLine(226,168,226,224);
   myGLCD.drawLine(227,169,227,223);
   myGLCD.drawPixel(225, 224);
   
   myGLCD.drawLine(224,226,14,226);
   myGLCD.drawLine(225,225,13,225);
   
   myGLCD.drawLine(11,223,11,169);
   myGLCD.drawLine(12,224,12,168);
   myGLCD.drawPixel(13, 224);
   myGLCD.drawPixel(13, 168);
 
 ////////////////////////////////////////////////////////
 //----Внутрении рамки, темные пропуски---
  myGLCD.setColor(0,0,0);
  //---Верхний-------
  myGLCD.drawHLine (80,166,70);
  myGLCD.drawHLine (77,167,74);
  
  myGLCD.drawHLine (80,225,74);
  myGLCD.drawHLine (77,226,70);
  
  myGLCD.drawVLine (11,190,10);
  myGLCD.drawVLine (12,189,12);
  
  myGLCD.drawVLine (227,190,10);
  myGLCD.drawVLine (226,189,12);
  
  //////---- Нижняя рамка,уголки (левый верхний)
  
  myGLCD.setColor(VGA_GRAY);
  
  myGLCD.drawHLine (11,160,25);
  myGLCD.drawHLine (9,161,25); 
  myGLCD.drawHLine (8,162,2);
  
  myGLCD.drawVLine (5,166,15);
  myGLCD.drawVLine (6,164,15);
  myGLCD.drawVLine (7,163,2);
  myGLCD.drawPixel(8, 163);  
  
 /////////---- Нижняя рамка,уголки (левый нижний)  
    
  myGLCD.drawHLine (11,234,25);
  myGLCD.drawHLine (9,233,25); 
  myGLCD.drawHLine (8,232,2);
  
  myGLCD.drawVLine (5,228,-15);
  myGLCD.drawVLine (6,230,-15);
  myGLCD.drawVLine (7,231,-2);
  myGLCD.drawPixel(8, 231);
  
 //////////////---- Нижняя рамка,уголки (правый верхний) 
 
  myGLCD.drawHLine (227,160,-25); 
  myGLCD.drawHLine (229,161,-25);
  myGLCD.drawHLine (230,162,-2);  
  
  myGLCD.drawVLine (233,166,15);
  myGLCD.drawVLine (232,164,15);
  myGLCD.drawVLine (231,163,2);
  myGLCD.drawPixel(230, 163);
  
 ////////////////////////////////
 
  myGLCD.drawHLine (226,233,-25); 
  myGLCD.drawHLine (228,232,-25);
  myGLCD.drawHLine (229,231,-2);  
  
  myGLCD.drawVLine (232,227,-15);
  myGLCD.drawVLine (231,229,-15);
  myGLCD.drawVLine (230,230,-2);
  myGLCD.drawPixel(229, 230);
   
  }  
  

  int draw_cooler_icon (int x, int y, boolean cool, boolean heat, boolean Button, byte id)
                    // Функция, по линиям рисует вентилятор.
                    // a,b,c - RGB цвет;
                    // x,y - координаты левого верхнего угла (-4px) 
                    // id - уникальный номер для возможности отрисовки
                    // нескольких вентиляторов на одном экране.
                    // Button Переменная ручного включения
 {                  
     
     int a=0; int b=0; int c=0;                   
                      
                   // Анимация происходит по 1 кадру за каждый цикл программы 
    
    if (cool || heat)
  {
       if (cool) {c=255;};  // Выбор цвета для вентилятора. 
       if (heat) {a=255;};  // Выбор цвета для отопителя.
                                        
   if (tact == 6 )  
    {     
    myGLCD.setColor(a,b,c); 
    myGLCD.drawRoundRect(x-4,y-4,x+34,y+34);
    myGLCD.drawCircle(x+15,y+15,16); 
    
    myGLCD.setColor(0,0,0);
    myGLCD.fillCircle(x+15,y+15,15);
  
    myGLCD.setColor(a,b,c);
    myGLCD.drawCircle(x+15,y+15,4);    
  
    myGLCD.fillRect (x+1,y+17,x+8,y+13);
    myGLCD.fillRect (x+13,y+8,x+17,y+1);
    myGLCD.fillRect (x+22,y+17,x+29,y+13);  
    myGLCD.fillRect (x+13,y+29,x+17,y+22);  
 
    myGLCD.drawHLine (x+1,y+12,5);
    myGLCD.drawHLine (x+2,y+11,2);
    myGLCD.drawHLine (x+1,y+18,5);
    myGLCD.drawHLine (x+2,y+19,2);
    myGLCD.drawVLine (x+9,y+14,2);
  
    myGLCD.drawVLine (x+12,y+6,-5);
    myGLCD.drawVLine (x+18,y+6,-5);
    myGLCD.drawVLine (x+11,y+4,-2);
    myGLCD.drawVLine (x+19,y+4,-2);
    myGLCD.drawHLine (x+14,y+9, 2);
  
    myGLCD.drawHLine (x+24,y+12,5);
    myGLCD.drawHLine (x+26,y+11,2);
    myGLCD.drawHLine (x+24,y+18,5);
    myGLCD.drawHLine (x+26,y+19,2);
    myGLCD.drawVLine (x+21,y+14,2);
  
    myGLCD.drawVLine (x+12,y+29,-5);
    myGLCD.drawVLine (x+18,y+29,-5);
    myGLCD.drawVLine (x+11,y+28,-2);
    myGLCD.drawVLine (x+19,y+28,-2);
    myGLCD.drawHLine (x+14,y+21, 2);

    ///----------Бегающая рамка при включенном вручную вентиляторе---------------
     if (Button) {            
                                     myGLCD.setColor(0,0,0);
                                     myGLCD.drawRoundRect(x-8,y-8,x+38,38+y);
                                     myGLCD.setColor(a,b,c);                    
                                     myGLCD.drawRoundRect(x-6,y-6,x+36,36+y);}
     
      };
  

   if (tact == 7)
   {
    myGLCD.setColor(a,b,c);  
    myGLCD.drawRoundRect(x-4,y-4,x+34,y+34);
    myGLCD.drawCircle(x+15,y+15,16); 
    
    myGLCD.setColor(0,0,0);
    myGLCD.fillCircle(x+15,y+15,15);
  
    myGLCD.setColor(a,b,c);     
    myGLCD.fillRect (x+4,y+11,x+8,y+6);
    myGLCD.fillRect (x+20,y+5,x+25,y+9);
    myGLCD.fillRect (x+22,y+24,x+26,y+19);
    myGLCD.fillRect (x+6,y+22,x+11,y+26);
  
    myGLCD.drawCircle(x+15,y+15,4);  
  
    myGLCD.drawHLine (x+6,y+12,4);
    myGLCD.drawHLine (x+5,y+5,2);
    myGLCD.drawVLine (x+3,y+11,-4);
    myGLCD.drawVLine (x+2,y+10,-1);
    myGLCD.drawVLine (x+9,y+13,-4);
    myGLCD.drawPixel (x+8, y+13); 
    myGLCD.drawPixel (x+10, y+11);  
  
    myGLCD.drawVLine (x+19,y+11,-4);
    myGLCD.drawVLine (x+26,y+8,-2);
    myGLCD.drawHLine (x+18,y+10,4);
    myGLCD.drawHLine (x+20,y+4,4);
    myGLCD.drawHLine (x+21,y+3,1);  
    myGLCD.drawPixel (x+18, y+9); 
    myGLCD.drawPixel (x+20, y+11);  
  
    myGLCD.drawHLine (x+20,y+18,4);
    myGLCD.drawHLine (x+23,y+25,2);
    myGLCD.drawVLine (x+21,y+21,-4);
    myGLCD.drawVLine (x+27,y+23,-4);
    myGLCD.drawVLine (x+28,y+21,-1); 
    myGLCD.drawPixel (x+20, y+19); 
    myGLCD.drawPixel (x+22, y+17);
  
    myGLCD.drawHLine (x+9,y+28,1);
    myGLCD.drawHLine (x+9,y+21,4);
    myGLCD.drawHLine (x+7,y+27,4);
    myGLCD.drawVLine (x+12,y+24,-4);
    myGLCD.drawVLine (x+5,y+25,-2);
    myGLCD.drawPixel (x+11, y+20);
    myGLCD.drawPixel (x+13, y+22);
  
  ///----------Бегающая рамка при включенном вручную вентиляторе---------------
     if (Button)    { 
                                     myGLCD.setColor(0,0,0);                                                                   
                                     myGLCD.drawRoundRect(x-6,y-6,x+36,y+36);
                                     myGLCD.setColor(a,b,c);             
                                     myGLCD.drawRoundRect(x-7,y-7,x+37,y+37);}
     
                    }; 

   
    if (tact == 8)
   {
    myGLCD.setColor(a,b,c);  
    myGLCD.drawRoundRect(x-4,y-4,x+34,y+34);
    myGLCD.drawCircle(x+15,y+15,16);  
   
    myGLCD.setColor(0,0,0);
    myGLCD.fillCircle(x+15,y+15,15);
  
    myGLCD.setColor(a,b,c);   
  
    myGLCD.fillRect (x+7,y+8,x+12,y+4);
    myGLCD.fillRect (x+23,y+8,x+27,y+13);
    myGLCD.fillRect (x+19,y+26,x+24,y+22);
    myGLCD.fillRect (x+4,y+19,x+8,y+24);  
  
    myGLCD.drawCircle(x+15,y+15,4);  
  
    myGLCD.drawVLine (x+6,y+7,-2);
    myGLCD.drawVLine (x+13,y+10,-4);
    myGLCD.drawHLine (x+9,y+2,2);
    myGLCD.drawHLine (x+8,y+3,4);
    myGLCD.drawHLine (x+10,y+9,4);
    myGLCD.drawPixel (x+12, y+10); 
    myGLCD.drawPixel (x+14, y+8);
  
    myGLCD.drawVLine (x+22,y+15,-4);
    myGLCD.drawVLine (x+28,y+13,-4);
    myGLCD.drawHLine (x+21,y+14,4);
    myGLCD.drawHLine (x+24,y+7,2);
    myGLCD.drawPixel (x+21, y+13); 
    myGLCD.drawPixel (x+23, y+15);
  
    myGLCD.drawVLine (x+18,y+24,-4);
    myGLCD.drawVLine (x+25,y+25,-2);
    myGLCD.drawHLine (x+17,y+21,4);
    myGLCD.drawHLine (x+19,y+27,4);
    myGLCD.drawHLine (x+20,y+28,2); 
    myGLCD.drawPixel (x+17, y+22); 
    myGLCD.drawPixel (x+19, y+20);
  
    myGLCD.drawVLine (x+2,y+21,-1);
    myGLCD.drawVLine (x+3,y+23,-4);
    myGLCD.drawVLine (x+9,y+21,-4);
    myGLCD.drawHLine (x+6,y+18,4);
    myGLCD.drawHLine (x+5,y+25,2);
    myGLCD.drawPixel (x+8, y+17); 
    myGLCD.drawPixel (x+10, y+19);
    
    ///----------Бегающая рамка при включенном вручную вентиляторе--------------
      if (Button) { 
                                     myGLCD.setColor(0,0,0);
                                     myGLCD.drawRoundRect(x-7,y-7,x+37,y+37);
                                     myGLCD.setColor(a,b,c);
                                     myGLCD.drawRoundRect(x-8,y-8,x+38,y+38);} 
    
                   };                             
  }

   if (Button== false)
     {
  
      if (tact==6)                     {myGLCD.setColor(0,0,0);                    
                                        myGLCD.drawRoundRect(x-6,y-6,x+36,36+y);}; 
  
      if (tact==7)                     {myGLCD.setColor(0,0,0);             
                                        myGLCD.drawRoundRect(x-7,y-7,x+37,37+y);};  
   
      if (tact == 8)                   {myGLCD.setColor(0,0,0);
                                        myGLCD.drawRoundRect(x-8,y-8,x+38,38+y);};   
     };                                  
       
       //-------  Отрисовка не активной иконки.  Функция запускается один раз, при изменении состояния объекта. 

    
       if  ((cooler_z != cooler)     && (cool == false && id==1) || act==1 )        {draw_cooler_off_icon (x,y);};
    
       if  ((heater_1_z != heater_1) && (heat == false && id==2) || act==1 )        {draw_cooler_off_icon (x,y);};
    
       if  ((heater_2_z != heater_2) && (heat == false && id==3) || act==1 )        {draw_cooler_off_icon (x,y);};                           
 }


 int draw_cooler_off_icon (int x, int y) // Дополнение к функции draw_cooler_icon
                                         // Отрисовка не активного вентилятора.
{
  
    myGLCD.setColor(0,0,0); 
    myGLCD.drawRoundRect(x-4,y-4,x+34,y+34);
    myGLCD.fillCircle(x+15,y+15,16);
  
    myGLCD.setColor(50,50,50);
    myGLCD.drawRoundRect(x-4,y-4,x+34,y+34);
    myGLCD.drawCircle(x+15,y+15,16);   
    myGLCD.drawCircle(x+15,y+15,4); 
  
    myGLCD.fillRect (x+1,y+17,x+8,y+13);
    myGLCD.fillRect (x+13,y+8,x+17,y+1);
    myGLCD.fillRect (x+22,y+17,x+29,y+13);  
    myGLCD.fillRect (x+13,y+29,x+17,y+22);  
 
    myGLCD.drawHLine (x+1,y+12,5);
    myGLCD.drawHLine (x+2,y+11,2);
    myGLCD.drawHLine (x+1,y+18,5);
    myGLCD.drawHLine (x+2,y+19,2);
    myGLCD.drawVLine (x+9,y+14,2);
  
    myGLCD.drawVLine (x+12,y+6,-5);
    myGLCD.drawVLine (x+18,y+6,-5);
    myGLCD.drawVLine (x+11,y+4,-2);
    myGLCD.drawVLine (x+19,y+4,-2);
    myGLCD.drawHLine (x+14,y+9, 2);
  
    myGLCD.drawHLine (x+24,y+12,5);
    myGLCD.drawHLine (x+26,y+11,2);
    myGLCD.drawHLine (x+24,y+18,5);
    myGLCD.drawHLine (x+26,y+19,2);
    myGLCD.drawVLine (x+21,y+14,2);
  
    myGLCD.drawVLine (x+12,y+29,-5);
    myGLCD.drawVLine (x+18,y+29,-5);
    myGLCD.drawVLine (x+11,y+28,-2);
    myGLCD.drawVLine (x+19,y+28,-2);
    myGLCD.drawHLine (x+14,y+21, 2);
  
  }

  
void Write_15px (char latters[40], int x1, int y1) 

//  Функция для рисования заглавных русских букв.
//  Функция принимает заглавные латинские буквы, без пробелов и прочих знаков,
//  Оканчивается слово добавлением символа "ноль". 
//  х1 и y1 - начальное положение 
//  Пример: Write_15px ("TEKST0", 180, 135);
//  Цвет шрифта устанавливается функцией myGLCD.setColor, перед вызовом функции.

//  A - A;   J - Ж;   N - Н;   F - Ф;  y - Ы;    
//  B - Б;   Z - З;   О - О;   H - Х;  b - Ь; 
//  V - В;   I - И;   P - П;   Q - Ц;  e - Э; 
//  G - Г;   i - Й;   R - Р;   с - Ч;  u - Ю;
//  D - Д;   K - K;   S - С;   w - Ш;  Y - Я.        
//  E - E;   L - Л;   Т - Т;   W - Щ;        
//  ~ - Ё;   M - M;   U - У;   j - Ъ;     

{ 
  int p=-13;  // Межбуквенный интервал (Начинаем с -13,так как первый же цикл прибавит 13px)
  byte a;      // Переменная для подсчета количества переданных в функцию символов. 
  byte z=0;    
  
{for (a=0;latters[a]!='0';a++);} //Подсчитываем символы в массиве, перебирая значения, 
                                 //пока не доходим до стоп-символа '0'
     
    for (z=0; z<a; z++) //Основной блок и счетик. Переберает буквы в массиве аргументе функции. 
  {
       if (latters[z] == 'A')         
    {p=p+13;                         // Переменная для сдвига следующего символа вправо по оси Х. 
                                     // В некоторых буквах подстроена вручную.
                                     
      myGLCD.fillRect  (x1+4+p,y1+10,x1+7+p,y1+11);
      myGLCD.fillRect  (x1+5+p,y1+1,x1+6+p,y1+5);      
      myGLCD.drawVLine (x1+p,y1+13,1); 
      myGLCD.drawVLine (x1+1+p,y1+11,3);  
      myGLCD.drawVLine (x1+2+p,y1+8,6);
      myGLCD.drawVLine (x1+3+p,y1+5,6);
      myGLCD.drawVLine (x1+4+p,y1+3,4);      
      myGLCD.drawVLine (x1+7+p,y1+3,4);
      myGLCD.drawVLine (x1+8+p,y1+5,6);
      myGLCD.drawVLine (x1+9+p,y1+8,6);
      myGLCD.drawVLine (x1+10+p,y1+11,3);
      myGLCD.drawVLine (x1+11+p,y1+13,1);        
      }
       
    if (latters[z] == 'B')         
     { 
      p=p+13;
      myGLCD.fillRect  (x1+2+p,y1+2,x1+3+p,y1+14);
      myGLCD.fillRect  (x1+10+p,y1+11,x1+11+p,y1+10);
      myGLCD.drawHLine (x1+3+p,y1+1,6);
      myGLCD.drawHLine (x1+4+p,y1+2,6);
      myGLCD.drawHLine (x1+4+p,y1+7,5);
      myGLCD.drawHLine (x1+4+p,y1+8,6);
      myGLCD.drawHLine (x1+9+p,y1+9,2);
      myGLCD.drawHLine (x1+9+p,y1+12,2);
      myGLCD.drawHLine (x1+4+p,y1+13,6);
      myGLCD.drawHLine (x1+4+p,y1+14,4);      
      }
    
     if (latters[z] == 'V')         
      { 
      p=p+13;
      myGLCD.fillRect  (x1+1+p,y1+2,x1+2+p,y1+14);
      myGLCD.fillRect  (x1+9+p,y1+3,x1+10+p,y1+5);
      myGLCD.fillRect  (x1+8+p,y1+9,x1+9+p,y1+8);
      myGLCD.fillRect  (x1+9+p,y1+12,x1+8+p,y1+13);
      myGLCD.fillRect  (x1+3+p,y1+14,x1+7+p,y1+13);
      myGLCD.fillRect  (x1+3+p,y1+8,x1+7+p,y1+7);
      myGLCD.drawHLine (x1+2+p,y1+1,5);
      myGLCD.drawHLine (x1+3+p,y1+2,6);
      myGLCD.drawHLine (x1+8+p,y1+6,1);
      myGLCD.drawVLine (x1+9+p,y1+10,1);
      myGLCD.drawVLine (x1+10+p,y1+9,3);
      myGLCD.drawPixel (x1+8+p, y1+3);
      }
    
     if (latters[z] == 'G')         
      { 
      p=p+12;
      myGLCD.fillRect  (x1+2+p,y1+2,x1+3+p,y1+14);
      myGLCD.drawHLine (x1+3+p,y1+1,6);
      myGLCD.drawHLine (x1+4+p,y1+2,6);
      }
    
     if (latters[z] == 'D')         
      { 
      p=p+13;
      myGLCD.fillRect  (x1+2+p,y1+13,x1+8+p,y1+12);
      myGLCD.fillRect  (x1+3+p,y1+10,x1+2+p,y1+11);
      myGLCD.fillRect  (x1+3+p,y1+9,x1+4+p,y1+7);
      myGLCD.fillRect  (x1+4+p,y1+6,x1+5+p,y1+4);
      myGLCD.fillRect  (x1+5+p,y1+3,x1+6+p,y1+1);
      myGLCD.fillRect  (x1+7+p,y1+2,x1+10+p,y1+1);
      myGLCD.fillRect  (x1+9+p,y1+3,x1+10+p,y1+13); 
      myGLCD.drawVLine (x1+p,y1+12,3);
      myGLCD.drawVLine (x1+1+p,y1+12,2);
      myGLCD.drawVLine (x1+11+p,y1+12,3);        
      }
    
     if (latters[z] == 'E')         
      { 
      p=p+12;
      myGLCD.fillRect  (x1+2+p,y1+2,x1+3+p,y1+13);
      myGLCD.drawHLine (x1+3+p,y1+1,5);
      myGLCD.drawHLine (x1+4+p,y1+2,5);
      myGLCD.drawHLine (x1+4+p,y1+7,4);
      myGLCD.drawHLine (x1+4+p,y1+8,3);
      myGLCD.drawHLine (x1+4+p,y1+13,7);
      myGLCD.drawHLine (x1+3+p,y1+14,7);
      }
    
     if (latters[z] == '~')         
      { 
      p=p+12;
      myGLCD.fillRect  (x1+2+p,y1+2,x1+3+p,y1+13);
      myGLCD.drawHLine (x1+3+p,y1+1,5);
      myGLCD.drawHLine (x1+4+p,y1+2,5);
      myGLCD.drawHLine (x1+4+p,y1+7,4);
      myGLCD.drawHLine (x1+4+p,y1+8,3);
      myGLCD.drawHLine (x1+4+p,y1+13,7);
      myGLCD.drawHLine (x1+3+p,y1+14,7);
      myGLCD.drawPixel (x1+4+p, y1-1);
      myGLCD.drawPixel (x1+7+p, y1-1);  
      }    
    
     if (latters[z] == 'J')         
      { 
      p=p+13;     
      myGLCD.fillRect  (x1+6+p,y1+1,x1+7+p,y1+14);    
      myGLCD.drawLine  (x1+2+p,y1+1,x1+5+p,y1+4); 
      myGLCD.drawLine  (x1+2+p,y1+2,x1+5+p,y1+5);
      myGLCD.drawLine  (x1+8+p,y1+4,x1+11+p,y1+1); 
      myGLCD.drawLine  (x1+8+p,y1+5,x1+11+p,y1+2);      
      myGLCD.drawVLine (x1+1+p,y1+12,2);
      myGLCD.drawVLine (x1+2+p,y1+11,2);
      myGLCD.drawVLine (x1+3+p,y1+10,2);
      myGLCD.drawVLine (x1+4+p,y1+9,2);
      myGLCD.drawVLine (x1+5+p,y1+8,1);
      myGLCD.drawVLine (x1+8+p,y1+8,1);
      myGLCD.drawVLine (x1+9+p,y1+9,2);
      myGLCD.drawVLine (x1+10+p,y1+10,2);
      myGLCD.drawVLine (x1+11+p,y1+11,2);
      myGLCD.drawVLine (x1+12+p,y1+12,2);        
      }
    
     if (latters[z] == 'Z')         
      { 
      p=p+14;
      myGLCD.fillRect  (x1+6+p,y1+7,x1+7+p,y1+8);
      myGLCD.drawHLine (x1+1+p,y1+4,1);
      myGLCD.drawHLine (x1+1+p,y1+3,2);
      myGLCD.drawHLine (x1+2+p,y1+2,7);
      myGLCD.drawHLine (x1+4+p,y1+1,4);
      myGLCD.drawHLine (x1+7+p,y1+3,1);
      myGLCD.drawHLine (x1+7+p,y1+12,1);
      myGLCD.drawHLine (x1+4+p,y1+14,4);
      myGLCD.drawHLine (x1+2+p,y1+13,6);
      myGLCD.drawHLine (x1+1+p,y1+12,2);
      myGLCD.drawHLine (x1+1+p,y1+11,1);
      myGLCD.drawVLine (x1+9+p,y1+3,10);
      myGLCD.drawVLine (x1+10+p,y1+3,2);
      myGLCD.drawVLine (x1+8+p,y1+6,3);
      myGLCD.drawVLine (x1+10+p,y1+10,2);
      }
    
     if (latters[z] == 'I')         
      { 
      p=p+13;
      myGLCD.fillRect (x1+1+p,y1+1,x1+2+p,y1+14);
      myGLCD.fillRect (x1+9+p,y1+1,x1+10+p,y1+14);
      myGLCD.drawLine (x1+3+p,y1+9,x1+8+p,y1+4);
      myGLCD.drawLine (x1+3+p,y1+10,x1+8+p,y1+5); 
      }
    
     if (latters[z] == 'i')         
      { 
      p=p+13;
      myGLCD.fillRect  (x1+1+p,y1+1,x1+2+p,y1+14);
      myGLCD.fillRect  (x1+9+p,y1+1,x1+10+p,y1+14);
      myGLCD.drawLine  (x1+3+p,y1+9,x1+8+p,y1+4);
      myGLCD.drawLine  (x1+3+p,y1+10,x1+8+p,y1+5);
      myGLCD.drawHLine (x1+5+p,y1+1,1);
      myGLCD.drawPixel (x1+4+p,y1);
      myGLCD.drawPixel (x1+7+p,y1); 
      }
    
     if (latters[z] == 'K')         
      { 
      p=p+13;        
      myGLCD.fillRect  (x1+1+p,y1+2,x1+2+p,y1+14);
      myGLCD.drawVLine (x1+7+p,y1+6,3);
      myGLCD.drawVLine (x1+8+p,y1+8,3);
      myGLCD.drawVLine (x1+9+p,y1+10,4);
      myGLCD.drawVLine (x1+10+p,y1+13,1);
      myGLCD.drawLine  (x1+3+p,y1+8,x1+10+p,y1+1);
      myGLCD.drawLine  (x1+3+p,y1+9,x1+10+p,y1+2);
      myGLCD.drawPixel (x1+6+p, y1+7);            
      }
    
     if (latters[z] == 'L')         
      { 
      p=p+14;
      myGLCD.fillRect  (x1+2+p,y1+5,x1+3+p,y1+13);
      myGLCD.fillRect  (x1+9+p,y1+2,x1+10+p,y1+14);
      myGLCD.drawHLine (x1+0+p,y1+14,2);
      myGLCD.drawHLine (x1+3+p,y1+4,1);
      myGLCD.drawHLine (x1+4+p,y1+3,1);
      myGLCD.drawHLine (x1+4+p,y1+2,4);
      myGLCD.drawHLine (x1+6+p,y1+1,3);
      myGLCD.drawPixel (x1+1+p, y1+13);     
      }
    
     if (latters[z] == 'M')         
      { 
      p=p+14;     
      myGLCD.fillRect  (x1+5+p,y1+5,x1+6+p,y1+6);
      myGLCD.drawVLine (x1+0+p,y1+2,12);
      myGLCD.drawVLine (x1+1+p,y1+1,13);
      myGLCD.drawVLine (x1+2+p,y1+2,2);
      myGLCD.drawVLine (x1+3+p,y1+3,1);
      myGLCD.drawVLine (x1+4+p,y1+4,1);
      myGLCD.drawVLine (x1+7+p,y1+4,1);
      myGLCD.drawVLine (x1+8+p,y1+3,1);
      myGLCD.drawVLine (x1+9+p,y1+2,2);
      myGLCD.drawVLine (x1+10+p,y1+1,13);
      myGLCD.drawVLine (x1+11+p,y1+2,12);      
      }
    
     if (latters[z] == 'N')         
      { 
      p=p+13;      
      myGLCD.fillRect  (x1+2+p,y1+1,x1+3+p,y1+14);
      myGLCD.fillRect  (x1+4+p,y1+7,x1+8+p,y1+8);
      myGLCD.fillRect  (x1+9+p,y1+1,x1+10+p,y1+14);
      }
    
     if (latters[z] == 'O')         
      { 
      p=p+10;
      myGLCD.fillRect  (x1+3+p,y1+3,x1+4+p,y1+12);
      myGLCD.fillRect  (x1+10+p,y1+3,x1+11+p,y1+12);
      myGLCD.drawHLine (x1+5+p,y1+1,4);
      myGLCD.drawHLine (x1+4+p,y1+2,6);
      myGLCD.drawHLine (x1+4+p,y1+13,6);
      myGLCD.drawHLine (x1+5+p,y1+14,4);
      myGLCD.drawPixel (x1+5+p, y1+3);
      myGLCD.drawPixel (x1+9+p, y1+3);
      myGLCD.drawPixel (x1+5+p, y1+12);
      myGLCD.drawPixel (x1+9+p, y1+12);
      }
    
    if (latters[z] == 'P')         
     { 
      p=p+15;
      myGLCD.fillRect (x1+p,y1+1,x1+1+p,y1+14);
      myGLCD.fillRect (x1+2+p,y1+1,x1+7+p,y1+2);
      myGLCD.fillRect (x1+8+p,y1+1,x1+9+p,y1+14);
     }
    
    if (latters[z] == 'R')         
     { 
     p=p+13;
     myGLCD.fillRect  (x1+9+p,y1+4,x1+10+p,y1+5);
     myGLCD.drawVLine (x1+1+p,y1+2,12);
     myGLCD.drawVLine (x1+2+p,y1+1,13);
     myGLCD.drawHLine (x1+3+p,y1+1,5);
     myGLCD.drawHLine (x1+3+p,y1+2,6);
     myGLCD.drawHLine (x1+8+p,y1+3,2);
     myGLCD.drawHLine (x1+8+p,y1+6,2);
     myGLCD.drawHLine (x1+3+p,y1+7,7);
     myGLCD.drawHLine (x1+3+p,y1+8,6);      
     }
    
    if (latters[z] == 'S')         
     { 
     p=p+13;     
     myGLCD.fillRect  (x1+5+p,y1+1,x1+8+p,y1+2);
     myGLCD.fillRect  (x1+5+p,y1+13,x1+8+p,y1+14);
     myGLCD.fillRect  (x1+9+p,y1+2,x1+10+p,y1+3);
     myGLCD.fillRect  (x1+9+p,y1+12,x1+10+p,y1+13);
     myGLCD.drawVLine (x1+2+p,y1+3,9);
     myGLCD.drawVLine (x1+3+p,y1+2,11);
     myGLCD.drawVLine (x1+4+p,y1+1,2);
     myGLCD.drawVLine (x1+4+p,y1+12,2);
     myGLCD.drawPixel (x1+10+p,y1+4);
     myGLCD.drawPixel (x1+10+p,y1+11);      
     }
    
    if (latters[z] == 'T')         
     {  
     p=p+13;     
     myGLCD.fillRect  (x1+5+p,y1+3,x1+6+p,y1+14);
     myGLCD.drawHLine (x1+p,y1+1,11);
     myGLCD.drawHLine (x1+1+p,y1+2,9);       
     }
    
    if (latters[z] == 'U')         
     { 
     p=p+13;     
     myGLCD.fillRect  (x1+3+p,y1+13,x1+5+p,y1+14);
     myGLCD.drawVLine (x1+2+p,y1+1,3);
     myGLCD.drawVLine (x1+3+p,y1+1,4);
     myGLCD.drawVLine (x1+4+p,y1+4,2);
     myGLCD.drawVLine (x1+5+p,y1+5,2);
     myGLCD.drawVLine (x1+6+p,y1+7,1);
     myGLCD.drawVLine (x1+7+p,y1+7,6);
     myGLCD.drawVLine (x1+6+p,y1+11,3);
     myGLCD.drawVLine (x1+8+p,y1+5,6);
     myGLCD.drawVLine (x1+9+p,y1+3,5);
     myGLCD.drawVLine (x1+10+p,y1+1,4);
     myGLCD.drawVLine (x1+11+p,y1+1,1);  
     }
    
    if (latters[z] == 'F')         
     { 
     p=p+13;     
     myGLCD.drawVLine (x1+1+p,y1+6,3);
     myGLCD.drawVLine (x1+2+p,y1+4,7);
     myGLCD.drawVLine (x1+6+p,y1+1,13);
     myGLCD.drawVLine (x1+7+p,y1+1,13);
     myGLCD.drawVLine (x1+11+p,y1+5,6);
     myGLCD.drawVLine (x1+12+p,y1+6,3);     
     myGLCD.drawHLine (x1+3+p,y1+4,8);
     myGLCD.drawHLine (x1+4+p,y1+3,5);
     myGLCD.drawHLine (x1+3+p,y1+11,8);
     myGLCD.drawHLine (x1+4+p,y1+12,5);  
     }
    
    if (latters[z] == 'H')         
     { 
     p=p+13;     
     myGLCD.drawVLine (x1+2+p,y1+1,1);
     myGLCD.drawVLine (x1+3+p,y1+1,3);
     myGLCD.drawVLine (x1+4+p,y1+3,3);
     myGLCD.drawVLine (x1+5+p,y1+5,5);
     myGLCD.drawVLine (x1+4+p,y1+9,3);
     myGLCD.drawVLine (x1+3+p,y1+11,3);
     myGLCD.drawVLine (x1+2+p,y1+13,1);
     myGLCD.drawVLine (x1+6+p,y1+6,3);
     myGLCD.drawVLine (x1+7+p,y1+5,5);
     myGLCD.drawVLine (x1+8+p,y1+3,3);
     myGLCD.drawVLine (x1+9+p,y1+1,3);
     myGLCD.drawVLine (x1+10+p,y1+1,1);
     myGLCD.drawVLine (x1+8+p,y1+9,3);
     myGLCD.drawVLine (x1+9+p,y1+11,3);
     myGLCD.drawVLine (x1+10+p,y1+13,1);  
     }
    
    if (latters[z] == 'Q')         
     { 
     p=p+14;
     myGLCD.fillRect  (x1+2+p,y1+1,x1+1+p,y1+11);
     myGLCD.fillRect  (x1+8+p,y1+11,x1+9+p,y1+1);
     myGLCD.fillRect  (x1+10+p,y1+15,x1+11+p,y1+14);
     myGLCD.drawHLine (x1+1+p,y1+12,9);
     myGLCD.drawHLine (x1+2+p,y1+13,9);
     }
    
    if (latters[z] == 'c')         
    { 
     p=p+13;     
     myGLCD.fillRect  (x1+3+p,y1+6,x1+7+p,y1+7);
     myGLCD.fillRect  (x1+8+p,y1+1,x1+9+p,y1+14);
     myGLCD.drawVLine (x1+1+p,y1+1,4);
     myGLCD.drawVLine (x1+2+p,y1+1,5);
    }
    
    if (latters[z] == 'w')         
     { 
     p=p+14;     
     myGLCD.fillRect  (x1+p,y1+1,x1+1+p,y1+13); 
     myGLCD.fillRect  (x1+5+p,y1+1,x1+6+p,y1+12);
     myGLCD.fillRect  (x1+10+p,y1+1,x1+11+p,y1+13);
     myGLCD.fillRect  (x1+1+p,y1+13,x1+10+p,y1+14);
     }
    
    if (latters[z] == 'W')         
     { 
     p=p+15;
     myGLCD.fillRect  (x1+p,y1+1,x1+1+p,y1+12);
     myGLCD.fillRect  (x1+5+p,y1+1,x1+6+p,y1+11);
     myGLCD.fillRect  (x1+10+p,y1+1,x1+11+p,y1+11);
     myGLCD.fillRect  (x1+1+p,y1+12,x1+12+p,y1+13);
     myGLCD.fillRect  (x1+11+p,y1+14,x1+12+p,y1+15); 
     }
    
    if (latters[z] == 'j')         
     { 
     p=p+14;
     myGLCD.fillRect  (x1+3+p,y1+1,x1+4+p,y1+13);
     myGLCD.fillRect  (x1+5+p,y1+6,x1+9+p,y1+7);
     myGLCD.fillRect  (x1+4+p,y1+13,x1+9+p,y1+14);
     myGLCD.fillRect  (x1+1+p,y1+1,x1+2+p,y1+2);
     myGLCD.drawVLine (x1+10+p,y1+7,6);
     myGLCD.drawVLine (x1+11+p,y1+8,4);
     myGLCD.drawPixel (x1+9+p, y1+8);
     myGLCD.drawPixel (x1+9+p, y1+12);
     }
    
    if (latters[z] == 'y')         
     { 
     p=p+17;
     myGLCD.fillRect  (x1-1+p,y1+1,x1+p,y1+13);
     myGLCD.fillRect  (x1+10+p,y1+1,x1+11+p,y1+14);
     myGLCD.fillRect  (x1+p,y1+13,x1+4+p,y1+14);
     myGLCD.fillRect  (x1+1+p,y1+6,x1+4+p,y1+7);
     myGLCD.drawVLine (x1+5+p,y1+7,6);
     myGLCD.drawVLine (x1+6+p,y1+8,4);
     myGLCD.drawPixel (x1+4+p, y1+8);
     myGLCD.drawPixel (x1+4+p, y1+12);
     }
    
    if (latters[z] == 'b')         
     {
     p=p+13; 
     myGLCD.fillRect  (x1+2+p,y1+1,x1+3+p,y1+13);
     myGLCD.fillRect  (x1+4+p,y1+6,x1+8+p,y1+7);
     myGLCD.fillRect  (x1+3+p,y1+13,x1+8+p,y1+14);
     myGLCD.drawVLine (x1+9+p,y1+7,6);
     myGLCD.drawVLine (x1+10+p,y1+8,4);
     myGLCD.drawPixel (x1+8+p, y1+8);
     myGLCD.drawPixel (x1+8+p, y1+12);  
     }
    
    if (latters[z] == 'e')         
     { 
     p=p+13;
     myGLCD.fillRect  (x1+2+p,y1+4,x1+3+p,y1+3);
     myGLCD.fillRect  (x1+3+p,y1+2,x1+5+p,y1+3);
     myGLCD.fillRect  (x1+5+p,y1+1,x1+8+p,y1+2);
     myGLCD.fillRect  (x1+8+p,y1+2,x1+10+p,y1+3);
     myGLCD.fillRect  (x1+6+p,y1+7,x1+9+p,y1+8);
     myGLCD.fillRect  (x1+9+p,y1+11,x1+10+p,y1+13);
     myGLCD.fillRect  (x1+5+p,y1+13,x1+8+p,y1+14);
     myGLCD.fillRect  (x1+3+p,y1+12,x1+5+p,y1+13);
     myGLCD.fillRect  (x1+2+p,y1+11,x1+3+p,y1+12);
     myGLCD.drawVLine (x1+10+p,y1+5,5);
     myGLCD.drawVLine (x1+11+p,y1+4,7);
     myGLCD.drawHLine (x1+9+p,y1+4,1);
     myGLCD.drawPixel (x1+8+p, y1+12);      
     }
    
    if (latters[z] == 'u')         
     { 
     p=p+15;
     myGLCD.fillRect  (x1+1+p,y1+1,x1+2+p,y1+14);
     myGLCD.fillRect  (x1+3+p,y1+7,x1+4+p,y1+8);
     myGLCD.fillRect  (x1+8+p,y1+1,x1+10+p,y1+2);
     myGLCD.fillRect  (x1+8+p,y1+13,x1+10+p,y1+14);
     myGLCD.drawVLine (x1+5+p,y1+5,5);
     myGLCD.drawVLine (x1+6+p,y1+3,9);
     myGLCD.drawVLine (x1+7+p,y1+2,2);
     myGLCD.drawVLine (x1+11+p,y1+2,2);
     myGLCD.drawVLine (x1+12+p,y1+3,9);
     myGLCD.drawVLine (x1+13+p,y1+5,5);
     myGLCD.drawVLine (x1+7+p,y1+11,2);
     myGLCD.drawVLine (x1+11+p,y1+11,2);     
     }
    
    if (latters[z] == 'Y')         
     { 
     p=p+13;
     myGLCD.fillRect  (x1+5+p,y1+1,x1+8+p,y1+2);      
     myGLCD.drawVLine (x1+9+p,y1+1,13);
     myGLCD.drawVLine (x1+10+p,y1+2,12);
     myGLCD.drawVLine (x1+4+p,y1+2,6);
     myGLCD.drawVLine (x1+3+p,y1+3,4);
     myGLCD.drawHLine (x1+5+p,y1+8,3);
     myGLCD.drawHLine (x1+6+p,y1+9,2);
     myGLCD.drawLine  (x1+2+p,y1+14,x1+6+p,y1+10);
     myGLCD.drawLine  (x1+3+p,y1+14,x1+7+p,y1+10); 
     myGLCD.drawPixel (x1+5+p, y1+3);
     myGLCD.drawPixel (x1+5+p, y1+7); 
    }    
  }    
} 

void Write_8px (char latters[40], int x1, int y1) 

// Функция для рисования заглавных русских букв. Высотой 8px.
// Функция принимает заглавные латинские буквы, без пробелов и прочих знаков,
// Оканчивается слово добавлением символа "ноль". 
// Пример: Write_8px ("TEKST0", 180, 135);

// A - A;   J - Ж;   N - Н;   F - Ф;  y - Ы;    
// B - Б;   Z - З;   О - О;   H - Х;  b - Ь; 
// V - В;   I - И;   P - П;   Q - Ц;  e - Э; 
// G - Г;   i - Й;   R - Р;   с - Ч;  u - Ю;
// D - Д;   K - K;   S - С;   w - Ш;  Y - Я.        
// E - E;   L - Л;   Т - Т;   W - Щ;        
// ~ - Ё;   M - M;   U - У;   j - Ъ;     

{ 
  int p=-8; //Межбуквенный интервал (Начинаем с -8,так как первый же цикл прибавит 9px)
  byte a;    //Переменная для подсчета количества переданных в функцию символов. 
  byte z=0;    
  
{for (a=0;latters[a]!='0';a++);} //Подсчитываем символы в массиве, перебирая значения, 
                                 // пока не доходим до стоп-символа '0'
     
    for (z=0; z<a; z++) //Основной блок и счетик. 
                        //Переберает буквы в массиве аргументе функции. 
    {
    if (latters[z] == 'A')         
    {p=p+8;                  // Переменная для сдвига следующего символа вправо по оси Х. 
                             // В некоторых буквах подстроена вручную. 
                                          
     myGLCD.drawVLine (x1+1+p,y1+3,4); 
     myGLCD.drawVLine (x1+6+p,y1+3,4);
     myGLCD.drawHLine (x1+2+p,y1+5,3);
     myGLCD.drawHLine (x1+3+p,y1+1,1);
     myGLCD.drawPixel (x1+p+2, y1+2);
     myGLCD.drawPixel (x1+p+5, y1+2);             
    }
    
    if (latters[z] == 'B')         
    {p=p+8;                                           
     myGLCD.drawVLine (x1+1+p,y1+1,6); 
     myGLCD.drawVLine (x1+5+p,y1+5,1);
     myGLCD.drawHLine (x1+2+p,y1+1,3);
     myGLCD.drawHLine (x1+2+p,y1+4,2);
     myGLCD.drawHLine (x1+2+p,y1+7,2);               
    }
    
    if (latters[z] == 'V')         
    {p=p+7;                                           
     myGLCD.drawVLine (x1+1+p,y1+1,6); 
     myGLCD.drawVLine (x1+4+p,y1+2,1);
     myGLCD.drawVLine (x1+4+p,y1+5,1);
     myGLCD.drawHLine (x1+2+p,y1+1,1);
     myGLCD.drawHLine (x1+2+p,y1+4,1);
     myGLCD.drawHLine (x1+2+p,y1+7,1);                    
    }
    
    if (latters[z] == 'G')         
    {p=p+6;                                           
     myGLCD.drawVLine (x1+1+p,y1+1,6); 
     myGLCD.drawHLine (x1+2+p,y1+1,2);
    }
    
    if (latters[z] == 'D')         
    {p=p+7;                                           
     myGLCD.drawHLine (x1+1+p,y1+6,5); 
     myGLCD.drawVLine (x1+1+p,y1+7,1);
     myGLCD.drawVLine (x1+6+p,y1+7,1);
     myGLCD.drawVLine (x1+2+p,y1+2,3); 
     myGLCD.drawVLine (x1+5+p,y1+2,3);      
     myGLCD.fillRect (x1+3+p,y1+1,x1+4+p,y1+2);              
    }
    
    if (latters[z] == 'E')         
    {p=p+8;                                           
     myGLCD.drawVLine (x1+1+p,y1+1,6); 
     myGLCD.drawHLine (x1+2+p,y1+1,2);
     myGLCD.drawHLine (x1+2+p,y1+4,1);
     myGLCD.drawHLine (x1+2+p,y1+7,3);                   
    }
    
    if (latters[z] == '~')         
    {p=p+8;                                           
     myGLCD.drawVLine (x1+1+p,y1+1,6); 
     myGLCD.drawHLine (x1+2+p,y1+1,2);
     myGLCD.drawHLine (x1+2+p,y1+4,1);
     myGLCD.drawHLine (x1+2+p,y1+7,3);
     myGLCD.drawPixel (x1+2+p, y1-1);
     myGLCD.drawPixel (x1+4+p, y1-1);                   
    }
    
    if (latters[z] == 'J')         
    {p=p+9;                                           
     myGLCD.drawVLine (x1+3+p,y1+1,6); 
     myGLCD.drawVLine (x1+0+p,y1+6,1);
     myGLCD.drawVLine (x1+6+p,y1+6,1);    
     myGLCD.drawPixel (x1+0+p, y1+1);
     myGLCD.drawPixel (x1+1+p, y1+2);
     myGLCD.drawPixel (x1+6+p, y1+1);
     myGLCD.drawPixel (x1+5+p, y1+2); 
     myGLCD.drawPixel (x1+1+p, y1+5);
     myGLCD.drawPixel (x1+5+p, y1+5);
     myGLCD.fillRect (x1+2+p,y1+4,x1+4+p,y1+3); 
    }
    
    if (latters[z] == 'Z')         
    {p=p+8;                                           
     myGLCD.drawVLine (x1+5+p,y1+2,1); 
     myGLCD.drawVLine (x1+5+p,y1+5,1);
     myGLCD.drawHLine (x1+3+p,y1+1,1);
     myGLCD.drawHLine (x1+2+p,y1+7,2);    
     myGLCD.drawPixel (x1+2+p, y1+2);
     myGLCD.drawPixel (x1+4+p, y1+4); 
     myGLCD.drawPixel (x1+1+p, y1+6);                         
    }

    if (latters[z] == 'I')         
    {p=p+8;                                           
     myGLCD.drawVLine (x1+1+p,y1+1,6); 
     myGLCD.drawVLine (x1+5+p,y1+1,6);         
     myGLCD.drawPixel (x1+2+p, y1+5);
     myGLCD.drawPixel (x1+3+p, y1+4); 
     myGLCD.drawPixel (x1+4+p, y1+3);                         
    }

    if (latters[z] == 'i')         
    {p=p+8;                                           
     myGLCD.drawVLine (x1+2+p,y1+1,6); 
     myGLCD.drawVLine (x1+6+p,y1+1,6);         
     myGLCD.drawPixel (x1+3+p, y1+5);
     myGLCD.drawPixel (x1+4+p, y1+4); 
     myGLCD.drawPixel (x1+5+p, y1+3); 
     myGLCD.drawPixel (x1+4+p, y1+0);                         
    }
    
    if (latters[z] == 'K')         
    {p=p+8;                                           
     myGLCD.drawVLine (x1+1+p,y1+1,6);         
     myGLCD.drawPixel (x1+2+p, y1+4);
     myGLCD.drawPixel (x1+3+p, y1+3); 
     myGLCD.drawPixel (x1+4+p, y1+2);
     myGLCD.drawPixel (x1+5+p, y1+1);
     myGLCD.drawPixel (x1+3+p, y1+5); 
     myGLCD.drawPixel (x1+4+p, y1+6);
     myGLCD.drawPixel (x1+5+p, y1+7);                         
    }

    if (latters[z] == 'L')         
    {p=p+8;                                           
     myGLCD.drawVLine (x1+6+p,y1+1,6);         
     myGLCD.drawVLine (x1+3+p,y1+2,2);
     myGLCD.drawVLine (x1+2+p,y1+4,3);
     myGLCD.drawHLine (x1+4+p,y1+1,1);     
     myGLCD.drawPixel (x1+1+p, y1+7);                         
    }

    if (latters[z] == 'M')         
    {p=p+9;                                           
     myGLCD.drawVLine (x1+0+p,y1+4,3);         
     myGLCD.drawVLine (x1+6+p,y1+4,3);
     myGLCD.drawVLine (x1+1+p,y1+1,2);     
     myGLCD.drawVLine (x1+3+p,y1+3,1);
     myGLCD.drawVLine (x1+5+p,y1+1,2);
     myGLCD.drawPixel (x1+2+p, y1+2);
     myGLCD.drawPixel (x1+4+p, y1+2);                          
    }

    if (latters[z] == 'N')         
    {p=p+8;                                           
     myGLCD.drawVLine (x1+1+p,y1+1,6);         
     myGLCD.drawVLine (x1+5+p,y1+1,6);
     myGLCD.drawHLine (x1+2+p,y1+4,2);                               
    }

    if (latters[z] == 'O')         
    {p=p+8;                                           
     myGLCD.drawVLine (x1+1+p,y1+2,4);         
     myGLCD.drawVLine (x1+5+p,y1+2,4);
     myGLCD.drawHLine (x1+2+p,y1+1,2);
     myGLCD.drawHLine (x1+2+p,y1+7,2);
    }

    if (latters[z] == 'P')         
    {p=p+7;                                           
     myGLCD.drawVLine (x1+2+p,y1+1,6);         
     myGLCD.drawVLine (x1+6+p,y1+1,6);
     myGLCD.drawHLine (x1+3+p,y1+1,2);                          
    }

    if (latters[z] == 'R')         
    {p=p+8;                                           
     myGLCD.drawVLine (x1+1+p,y1+1,6); 
     myGLCD.drawVLine (x1+5+p,y1+2,1);
     myGLCD.drawHLine (x1+2+p,y1+1,2);
     myGLCD.drawHLine (x1+2+p,y1+4,2);     
    }

    if (latters[z] == 'S')         
    {p=p+8;                                           
     myGLCD.drawVLine (x1+1+p,y1+2,4);         
     myGLCD.drawHLine (x1+2+p,y1+1,2);
     myGLCD.drawHLine (x1+2+p,y1+7,2);    
     myGLCD.drawPixel (x1+5+p, y1+2);
     myGLCD.drawPixel (x1+5+p, y1+6);                          
    }

    if (latters[z] == 'T')         
    {p=p+7;                                            
     myGLCD.drawVLine (x1+3+p,y1+2,5);    
     myGLCD.drawHLine (x1+1+p,y1+1,4);                          
    }

    if (latters[z] == 'U')         
    {p=p+8;                                           
     myGLCD.drawVLine (x1+1+p,y1+1,1); 
     myGLCD.drawVLine (x1+5+p,y1+1,2);
     myGLCD.drawVLine (x1+4+p,y1+4,1);
     myGLCD.drawHLine (x1+1+p,y1+7,1);     
     myGLCD.drawPixel (x1+2+p, y1+3);
     myGLCD.drawPixel (x1+3+p, y1+4); 
     myGLCD.drawPixel (x1+3+p, y1+6);  
    }

    if (latters[z] == 'F')         
    {p=p+9;                                           
     myGLCD.drawVLine (x1+0+p,y1+3,2); 
     myGLCD.drawVLine (x1+6+p,y1+3,2);
     myGLCD.drawVLine (x1+3+p,y1+1,6);
     myGLCD.drawHLine (x1+1+p,y1+2,4);     
     myGLCD.drawHLine (x1+1+p,y1+6,4);   
    }

    if (latters[z] == 'H')         
    {p=p+7;                                           
     myGLCD.drawVLine (x1+2+p,y1+1,1); 
     myGLCD.drawVLine (x1+6+p,y1+1,1);
     myGLCD.drawVLine (x1+2+p,y1+6,1);
     myGLCD.drawVLine (x1+6+p,y1+6,1);     
     myGLCD.drawPixel (x1+3+p, y1+3);
     myGLCD.drawPixel (x1+5+p, y1+3);
     myGLCD.drawPixel (x1+4+p, y1+4);
     myGLCD.drawPixel (x1+3+p, y1+5);
     myGLCD.drawPixel (x1+5+p, y1+5);   
    }

    if (latters[z] == 'Q')         
    {p=p+8;                                           
     myGLCD.drawVLine (x1+1+p,y1+1,6); 
     myGLCD.drawVLine (x1+5+p,y1+1,5);     
     myGLCD.drawHLine (x1+2+p,y1+7,4);     
     myGLCD.drawPixel (x1+6+p, y1+8);       
    }

    if (latters[z] == 'b')         
    {p=p+8;                                           
     myGLCD.drawVLine (x1+2+p,y1+1,6); 
     myGLCD.drawVLine (x1+6+p,y1+5,1);     
     myGLCD.drawHLine (x1+3+p,y1+4,2);
     myGLCD.drawHLine (x1+3+p,y1+7,2);              
    }

    if (latters[z] == 'y')         
    {p=p+9;                                           
     myGLCD.drawVLine (x1+0+p,y1+1,6); 
     myGLCD.drawVLine (x1+4+p,y1+5,1);     
     myGLCD.drawVLine (x1+6+p,y1+1,6);
     myGLCD.drawHLine (x1+1+p,y1+4,2);
     myGLCD.drawHLine (x1+1+p,y1+7,2);          
    }

    if (latters[z] == 'j')         
    {p=p+9;                                           
     myGLCD.drawVLine (x1+2+p,y1+1,6); 
     myGLCD.drawVLine (x1+6+p,y1+5,1);     
     myGLCD.drawHLine (x1+3+p,y1+4,2);
     myGLCD.drawHLine (x1+3+p,y1+7,2);
     myGLCD.drawPixel (x1+1+p, y1+1);
     myGLCD.drawPixel (x1+0+p, y1+1);                
    }

    if (latters[z] == 'c')         
    {p=p+8;                                           
     myGLCD.drawVLine (x1+1+p,y1+1,2); 
     myGLCD.drawVLine (x1+5+p,y1+1,6);     
     myGLCD.drawHLine (x1+2+p,y1+4,2);           
    }

    if (latters[z] == 'w')         
    {p=p+8;                                           
     myGLCD.drawVLine (x1+1+p,y1+1,5); 
     myGLCD.drawVLine (x1+5+p,y1+1,5);
     myGLCD.drawVLine (x1+3+p,y1+2,4);     
     myGLCD.drawHLine (x1+1+p,y1+7,4);            
    }

    if (latters[z] == 'W')         
    {p=p+8;                                           
     myGLCD.drawVLine (x1+1+p,y1+1,5); 
     myGLCD.drawVLine (x1+3+p,y1+2,4);
     myGLCD.drawVLine (x1+5+p,y1+1,5);     
     myGLCD.drawHLine (x1+1+p,y1+7,5);     
     myGLCD.drawPixel (x1+6+p, y1+8);       
    }

    if (latters[z] == 'e')         
    {p=p+8;                                           
     myGLCD.drawVLine (x1+5+p,y1+2,4); 
     myGLCD.drawHLine (x1+2+p,y1+1,2);
     myGLCD.drawHLine (x1+2+p,y1+7,2);     
     myGLCD.drawHLine (x1+3+p,y1+4,1);     
     myGLCD.drawPixel (x1+1+p, y1+2);
     myGLCD.drawPixel (x1+1+p, y1+6);       
    }

    if (latters[z] == 'u')         
    {p=p+8;                                           
     myGLCD.drawVLine (x1+1+p,y1+1,6); 
     myGLCD.drawVLine (x1+3+p,y1+2,4);
     myGLCD.drawVLine (x1+6+p,y1+2,4);          
     myGLCD.drawHLine (x1+4+p,y1+1,1);
     myGLCD.drawHLine (x1+4+p,y1+7,1);
     myGLCD.drawPixel (x1+2+p, y1+4);        
    }

    if (latters[z] == 'Y')         
    {p=p+8;                                           
     myGLCD.drawVLine (x1+6+p,y1+1,6); 
     myGLCD.drawVLine (x1+2+p,y1+2,1);
     myGLCD.drawHLine (x1+3+p,y1+1,2);
     myGLCD.drawHLine (x1+3+p,y1+4,2);           
     myGLCD.drawPixel (x1+4+p, y1+5);
     myGLCD.drawPixel (x1+3+p, y1+6);
     myGLCD.drawPixel (x1+2+p, y1+7);        
    }
 }
};
  
  int counter (int x, int y, byte count_number) //Функция счетчик. Один разряд. 10 x 15 px
  {                                             // x,y - начальные координаты счетчика
    myGLCD.setColor(VGA_BLACK);                 // Выбираем черный (цвет фона)
    myGLCD.fillRect(x,y,x+10,y+15);             // Закрашиваем место будующей цифры 
    myGLCD.setColor(VGA_WHITE);                 // Выбираем цвет цифры.

    if (count_number == 1)
   {
    myGLCD.fillRect (x+2,y+14,x+10,y+15);
    myGLCD.fillRect (x+6,y+13,x+8,y+1);
    myGLCD.fillRect (x+2,y+4,x+5,y+3);
    myGLCD.drawHLine (x+4,y+2,1);
    myGLCD.drawPixel (x+1, y+4);     
   } 
    if (count_number == 2)
   {
    myGLCD.fillRect (x+1,y+5,x+3,y+2);
    myGLCD.fillRect (x+8,y+6,x+10,y+3); 
    myGLCD.fillRect (x+1,y+15,x+10,y+14); 
    myGLCD.drawHLine (x+3,y+1,5);
    myGLCD.drawHLine (x+4,y+2,6);
    myGLCD.drawHLine (x+8,y+13,2);
    myGLCD.drawLine(x+1,y+12,x+7,y+6);
    myGLCD.drawLine(x+1,y+13,x+7,y+7);
    myGLCD.drawLine(x+2,y+13,x+8,y+7);
    myGLCD.drawLine(x+3,y+13,x+9,y+7);
   } 
    if (count_number == 3)
   {
    myGLCD.fillRect (x+7,y+5,x+10,y+3);
    myGLCD.fillRect (x+4,y+8,x+7,y+7);
    myGLCD.fillRect (x+7,y+13,x+10,y+10); 
    myGLCD.drawHLine (x+3,y+1,5);
    myGLCD.drawHLine (x+2,y+2,7);
    myGLCD.drawHLine (x+1,y+3,2);
    myGLCD.drawHLine (x+6,y+6,3);
    myGLCD.drawHLine (x+6,y+9,3);
    myGLCD.drawHLine (x+1,y+13,2);
    myGLCD.drawHLine (x+2,y+14,7);
    myGLCD.drawHLine (x+3,y+15,5);  
   } 
    if (count_number == 4)
   {
    myGLCD.fillRect (x+7,y+1,x+9,y+7);
    myGLCD.fillRect (x+1,y+9,x+10,y+8);
    myGLCD.fillRect (x+6,y+13,x+9,y+10);
    myGLCD.fillRect (x+3,y+15,x+10,y+14);
    myGLCD.drawLine (x+1,y+6,x+6,y+1);
    myGLCD.drawLine (x+1,y+7,x+6,y+2);
    myGLCD.drawLine (x+2,y+7,x+6,y+3);
   } 
    if (count_number == 5)
   {
    myGLCD.fillRect (x+1,y+2,x+10,y+1); 
    myGLCD.fillRect (x+1,y+6,x+4,y+3);
    myGLCD.fillRect (x+8,y+14,x+10,y+8);
    myGLCD.fillRect (x+1,y+13,x+3,y+12);
    myGLCD.drawHLine(x+2,y+7,8);
    myGLCD.drawHLine(x+5,y+6,4);  
    myGLCD.drawHLine(x+2,y+14,5);
    myGLCD.drawHLine(x+4,y+15,4);   
   } 
    if (count_number == 6)
   {
    myGLCD.fillRect (x+1,y+13,x+3,y+3);
    myGLCD.fillRect (x+8,y+4,x+10,y+2);
    myGLCD.fillRect (x+8,y+14,x+10,y+10);
    myGLCD.drawHLine(x+3,y+1,5);
    myGLCD.drawHLine(x+2,y+2,5);
    myGLCD.drawHLine(x+4,y+8,5);
    myGLCD.drawHLine(x+4,y+9,6);
    myGLCD.drawHLine(x+2,y+14,5);
    myGLCD.drawHLine(x+3,y+15,5);   
   } 
    if (count_number == 7)
   {
    myGLCD.fillRect (x+1,y+4,x+3,y+1);
    myGLCD.fillRect (x+4,y+2,x+10,y+1);
    myGLCD.fillRect (x+8,y+5,x+10,y+3);
    myGLCD.fillRect (x+7,y+7,x+9,y+6);
    myGLCD.fillRect (x+6,y+10,x+8,y+8);
    myGLCD.fillRect (x+4,y+15,x+7,y+11);
    myGLCD.drawPixel (x+5, y+10);  
   } 
    if (count_number == 8)
   {
    myGLCD.fillRect (x+3,y+1,x+8,y+2);
    myGLCD.fillRect (x+2,y+6,x+3,y+2);
    myGLCD.fillRect (x+8,y+2,x+9,y+6);
    myGLCD.fillRect (x+4,y+7,x+7,y+6);
    myGLCD.fillRect (x+1,y+14,x+3,y+9);
    myGLCD.fillRect (x+8,y+14,x+10,y+9);
    myGLCD.fillRect (x+3,y+15,x+8,y+14);
    myGLCD.drawHLine(x+2,y+8,7);
    myGLCD.drawVLine(x+1,y+3,2);
    myGLCD.drawVLine(x+10,y+3,2);
   }
    if (count_number == 9)
   {
    myGLCD.fillRect (x+1,y+7,x+3,y+2);
    myGLCD.fillRect (x+3,y+1,x+8,y+2);
    myGLCD.fillRect (x+8,y+2,x+10,y+13);
    myGLCD.fillRect (x+3,y+8,x+7,y+7);
    myGLCD.fillRect (x+1,y+14,x+3,y+12);
    myGLCD.drawHLine(x+4,y+14,5);
    myGLCD.drawHLine(x+3,y+15,5);   
   } 
    if (count_number == 0)
   {
    myGLCD.fillRect (x+1,y+13,x+3,y+3);
    myGLCD.fillRect (x+8,y+13,x+10,y+3);
    myGLCD.drawHLine(x+3,y+1,5); 
    myGLCD.drawHLine(x+2,y+2,7);
    myGLCD.drawHLine(x+2,y+14,7);
    myGLCD.drawHLine(x+3,y+15,5);    
   } 
  }

int small_counter (int x, int y, byte count_number, boolean i, int r,int g, int b)// Счетчик 2х разрядных чисел 4х7 px.
 {                                                                                // При вызове функции i=0
   byte a,c;                                                                      // r,g,b цвет цифр счетчика 
   
   a = count_number % 10 ;                  //Единицы счетчика.
   c = (count_number /10) % 10 ;            //Десятки счетчик
   
  myGLCD.setColor(VGA_BLACK);               // Выбираем черный (цвет фона)
  myGLCD.fillRect(x,y-1,x+4,y+9);           // Закрашиваем место будующей цифры, с запасом по 1 px сверху и снизу. 
  myGLCD.setColor(r,g,b);                   // Выбираем цвет цифры.
  {
    if (a == 1)
 { 
  myGLCD.drawVLine (x+3,y+1,6);
  myGLCD.drawPixel (x+2, y+2);
  myGLCD.drawPixel (x+1, y+3);   
 } 
    if (a == 2)
 { 
  myGLCD.drawVLine (x+4,y+2,2);
  myGLCD.drawHLine (x+2,y+1,1);
  myGLCD.drawHLine (x+2,y+5,1);
  myGLCD.drawHLine (x+1,y+7,3);
  myGLCD.drawPixel (x+1, y+2);
  myGLCD.drawPixel (x+1, y+6);   
 } 
    if (a == 3)
 { 
  myGLCD.drawVLine (x+4,y+2,1);
  myGLCD.drawVLine (x+4,y+5,1);
  myGLCD.drawHLine (x+2,y+1,1);
  myGLCD.drawHLine (x+2,y+7,1);
  myGLCD.drawPixel (x+1, y+2);
  myGLCD.drawPixel (x+3, y+4);
  myGLCD.drawPixel (x+1, y+6);   
 }
 if (a == 4)
 { 
  myGLCD.drawVLine (x+3,y+1,6);
  myGLCD.drawVLine (x+2,y+2,1);
  myGLCD.drawHLine (x+1,y+5,3);
  myGLCD.drawPixel (x+1, y+4);
 }
   if (a == 5)
 { 
  myGLCD.drawVLine (x+4,y+4,2);
  myGLCD.drawHLine (x+1,y+1,3);
  myGLCD.drawHLine (x+1,y+3,2);
  myGLCD.drawHLine (x+2,y+7,1);
  myGLCD.drawPixel (x+1, y+6);
  myGLCD.drawPixel (x+1, y+2);   
 }
   if (a == 6)
 { 
  myGLCD.drawVLine (x+1,y+2,4);
  myGLCD.drawVLine (x+4,y+5,1);
  myGLCD.drawHLine (x+2,y+1,1);
  myGLCD.drawHLine (x+2,y+4,1);
  myGLCD.drawHLine (x+2,y+7,1);
  myGLCD.drawPixel (x+4, y+2);   
 }
   if (a == 7)
 { 
  myGLCD.drawVLine (x+4,y+2,1);
  myGLCD.drawVLine (x+3,y+3,2);
  myGLCD.drawVLine (x+2,y+5,2);
  myGLCD.drawHLine (x+1,y+1,3);     
 }
 if (a == 8)
 { 
  myGLCD.drawVLine (x+1,y+2,1);
  myGLCD.drawVLine (x+4,y+2,1);
  myGLCD.drawVLine (x+1,y+5,1);
  myGLCD.drawVLine (x+4,y+5,1);
  myGLCD.drawHLine (x+2,y+1,1);
  myGLCD.drawHLine (x+2,y+4,1);
  myGLCD.drawHLine (x+2,y+7,1);   
 }
  if (a == 9)
 { 
  myGLCD.drawVLine (x+4,y+2,4);
  myGLCD.drawVLine (x+1,y+2,1);
  myGLCD.drawHLine (x+2,y+1,1);
  myGLCD.drawHLine (x+2,y+4,1);
  myGLCD.drawHLine (x+2,y+7,1);
  myGLCD.drawPixel (x+1, y+6);   
 }
 if (a == 0)
 { 
  myGLCD.drawVLine (x+1,y+2,4);
  myGLCD.drawVLine (x+4,y+2,4);
  myGLCD.drawHLine (x+2,y+1,1);
  myGLCD.drawHLine (x+2,y+7,1);
 }

  if (i==1){return 0;};  
  if (c==0){return 0;}; 
  }
  
   small_counter (x-6, y, c+10, 1, r,g,b);   
  }

 int light_counter (int x, int y, byte count_number, boolean i)// Счетчик 2х разрядных чисел 2х6 px.
   {                                                            // При вызове функции i=0
     byte a,b;    
   
     a = count_number % 10 ;                 // Единицы счетчика.
     b = (count_number /10) % 10 ;           // Десятки счетчик
   
    myGLCD.setColor(VGA_BLACK);              // Выбираем черный (цвет фона)
    myGLCD.fillRect(x,y,x+3,y+6);            // Закрашиваем место будующей цифры 
    myGLCD.setColor(200,200,200);            // Выбираем цвет цифры.

    if (a == 1)
   { 
    myGLCD.drawVLine (x+3,y+1,5);
   } 
    if (a == 2)
   {
    myGLCD.drawVLine (x+3,y+1,3);
    myGLCD.drawVLine (x+1,y+4,2);
    myGLCD.drawHLine (x+1,y+1,1);
    myGLCD.drawHLine (x+2,y+6,1);
    myGLCD.drawPixel (x+2, y+4);   
   } 
    if (a == 3)
   { 
    myGLCD.drawVLine (x+3,y+2,4);
    myGLCD.drawHLine (x+1,y+1,2);
    myGLCD.drawHLine (x+1,y+6,1);
    myGLCD.drawPixel (x+2, y+3);  
   } 
   if (a == 4)
   {
    myGLCD.drawVLine (x+1,y+1,2);
    myGLCD.drawVLine (x+3,y+1,5);
    myGLCD.drawPixel (x+2, y+3);  
   } 
    if (a == 5)
   {  
    myGLCD.drawVLine(x+3,y+4,1);
    myGLCD.drawHLine(x+1,y+1,2);
    myGLCD.drawHLine(x+1,y+3,2);
    myGLCD.drawHLine(x+1,y+6,2);
    myGLCD.drawPixel (x+1, y+2);  
   } 
    if (a == 6)
   {  
    myGLCD.drawVLine(x+1,y+3,3);
    myGLCD.drawVLine(x+3,y+4,2);
    myGLCD.drawPixel (x+3, y+1);
    myGLCD.drawPixel (x+2, y+2);
    myGLCD.drawPixel (x+2, y+4);
    myGLCD.drawPixel (x+2, y+6);   
   } 
    if (a == 7)
   {
    myGLCD.drawVLine(x+2,y+3,1);
    myGLCD.drawVLine(x+1,y+5,1);
    myGLCD.drawHLine(x+1,y+1,2);
    myGLCD.drawPixel (x+3, y+2);   
   } 
    if (a == 8)
   {  
    myGLCD.drawVLine(x+1,y+1,5);
    myGLCD.drawVLine(x+3,y+1,5);
    myGLCD.drawPixel (x+2, y+1);
    myGLCD.drawPixel (x+2, y+3);
    myGLCD.drawPixel (x+2, y+6);  
   }
    if (a == 9)
   {
    myGLCD.drawVLine(x+1,y+1,2);
    myGLCD.drawVLine(x+3,y+1,3);
    myGLCD.drawPixel (x+2, y+1);
    myGLCD.drawPixel (x+2, y+3);
    myGLCD.drawPixel (x+2, y+5);
    myGLCD.drawPixel (x+1, y+6);    
   } 
    if (a == 0)
   {
    myGLCD.drawVLine(x+1,y+2,3); 
    myGLCD.drawVLine(x+3,y+2,3);
    myGLCD.drawPixel (x+2, y+1); 
    myGLCD.drawPixel (x+2, y+6);     
   } 
  
    if (i==1){return 0;};  
    if (b==0){return 0;}; 
 
  
     light_counter (x-5, y, b+10, 1);   
   
 };  
 
int  symbol_temperature (int x1, int y1)
  {
    const boolean tem [15][13]={{0,0,0,1,1,0,0,0,0,0,0,0,0},
                          {0,0,0,1,1,0,0,0,0,0,1,1,0},
                          {0,0,0,1,1,0,0,0,0,1,0,0,1},
                          {0,0,0,1,1,0,0,0,0,1,0,0,1},
                          {0,1,1,1,1,1,1,0,0,0,1,1,0},
                          {0,1,1,1,1,1,1,0,0,0,0,0,0},
                          {0,0,0,1,1,0,0,0,0,0,0,0,0},
                          {0,0,0,1,1,0,0,0,0,0,0,0,0},
                          {0,0,0,1,1,0,0,0,0,0,0,0,0},
                          {0,0,0,1,1,0,0,0,0,0,0,0,0},
                          {0,0,0,1,1,0,0,0,0,0,1,1,0},
                          {0,0,0,1,1,1,0,0,0,0,1,1,0},
                          {0,0,0,0,1,1,1,1,1,1,1,0,0},
                          {0,0,0,0,0,1,1,1,1,1,0,0,0},
                          {0,0,0,0,0,0,0,0,0,0,0,0,0}};
    for (byte k=0; k<13; k++)
    {
    for (byte n=0; n<15; n++)
     {
      if  (tem[n][k] == true)   {
        myGLCD.drawPixel(x1+k, y1+n);
      }  
     }
    }
 } 
  

строки 342-353

Великолепный, пряматаки, образец индусско-китайского кода.  То, что можно уложить в 500 строк, размножаем в 32хх. 

 Я благодарен тебе за код...  Но счёл бы правильным проверить....  Ото оно каг-то таг :))))

 DetSimen  ты чё татам хотел сказать????

Спросить хотел, нахуа ты распространяешь свою парнографию? Корона жмёть, или муж заставил? 

DetSimen с битовыми операциами я надеюсь ты разобрался? ;)

 Если хотел, то я отвечаю.  Я ничего не распространю, ни порнографию, ни иные формы.... :))))

Да, в 1990-м году.  Ты?

 А меня не отпускает осозниене, что ты тупое и непроходимое дно :))) не подскажешь что мне с этим делать? )

Отойди от зеркала. 

Кто о чём, а хромой о костылях :)))))

 Смотри-ка заработала функция отправки изображений :))))

 Зачем похерили ответы?

 Я могу повторить ссылку на видео  :) https://www.youtube.com/watch?v=q-qrTxvqV-Y&list=RDq-qrTxvqV-Y&index=1

Я думал какой-то конструктивный ответ будет...   А вы как тупое дно просто удаляете ответы :))))

под своим именем пости сколько угодно. 

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

 А я оп, чета меняю, и катинки рисуются, понятно я надеюсь, да?   Вот и ебитесь на этом вашем форуме, ребята като колом сами ;) Творческих успехов ;)

 DetSimen Я не знаю, один ты там или вас там  много..  По-факту...  Очень долго соображаешь. Еще бы чуть-чуть дольше, и я бы рекомендовал тебя на стройку, кирпич с поддона по этажам разносить.
 Так что я не знаю, как-то может... математические викторины... Или, сканворды может нужно разгадывать... Там..  или судоку на телефон поставить???

 Не дожидаясь того, когда я реально начну рекомендации раздовать ;)
 

ЗЫ. в какой-то момен возможно решил: Забанить!!! :) Но видимо успела проскочить мысль: "Щас забаню самого себя " :))))))))))  Потешно конечно :)))