Arduino.ru

Вроде разобрался...

В новой IDE нужно задавать массив: 

int tled[96];

А старая съедала

byte tled[96];

И нормально работало...

Может ты сказать что то хотел или так, пришел покурить? В чем проблема то?

Хочешь, конечно, можешь поменять byte на int, только проблема может возникнуть снова, если её не понять.

В чем проблема и как это проявляется?

И да, о каких прерываниях речь, если здесь прерываниями и не пахнет.

Может неправильно сформулировал.

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

Как выяснилось она не связана с EEPROM. Тему можно закрыть.

Почему это выплыло только в IDE версии 1.6.х, ???

Бред. Во всём скечте tled присваиваеются значения типа byte и никак потом не используются. Или нам пудрят мозги и показазывают не весь скетч, или здесь byte или int ни на что не влияет и влиять не может.  

ЕвгенийП, Так автор сказал, что выложил нарезку кода, а не весь код. Как обычно, ошибки в коде, который не приложили, потому что даже не подозревают, что там и есть ошибка.

Не вопрос...

Вот, Вам код, изучайте

На Arduino IDE 1.x.x нет проблем, на 1.6.x проблемы...

#include <UTFT.h>
#include <UTouch.h>
#include <DS1307new.h>
#include <Wire.h>
#include <EEPROM.h>

UTFT myGLCD(ITDB32S, 38, 39, 40, 41);
UTouch myTouch(6, 5, 4, 3, 2);

////////////////////
// --- Шрифты --- //
////////////////////

extern uint8_t BigFont[];
extern uint8_t SmallFont[];

#define LARGE true
#define SMALL false

//////////////////////
// --- Картинки --- //
//////////////////////

//extern unsigned int loadsmall[0x1D4C];
//extern unsigned int logo[0x2649];

////////////////////
// --- Выводы --- //
////////////////////

const byte ledPinCh1 = 8;
const byte ledPinCh2 = 9;
const byte ledPinCh3 = 10;
const byte ledPinCh4 = 11;
const byte ledPinCh5 = 12;

///////////////////////
// --- Настройки --- //
///////////////////////

const byte numberOfCh = 5;
const char *namesCh[] = {"  ", "ROYAL", "WHITE", "UV", "CYAN", "RED"};
const char *namesChMix[] = {"  ", "Ch 1", "Ch 2", "Ch 3", "Ch 4", "Ch 5"};
const byte rgbCh1[] = {0, 0, 255};
const byte rgbCh2[] = {255, 255, 255};
const byte rgbCh3[] = {238, 130, 238};
const byte rgbCh4[] = {0, 255, 255};
const byte rgbCh5[] = {255, 0, 0};

const boolean BUCKPUCK  = true;
const boolean readEEonStart = 1;

byte ch1led[96], ch2led[96], ch3led[96], ch4led[96], ch5led[96];

////////////////////////
// --- Переменные --- //
////////////////////////

byte dispScreen = 0; // Номер Экрана
int x, y; // Координаты Touch

/// --- Счётчики
unsigned long prevMillis5 = 0;
unsigned long prevMillis600 = 0;

int LedChangTime = 0;
int selectChannel;
char tChar30[30];
int min_cnt;
byte tled[96];
byte *LEDval_arr[] = {ch1led, ch2led, ch3led, ch4led, ch5led};
byte LEDch_out[5];
byte prevLEDch_out[5];
byte LEDpin[] = {ledPinCh1, ledPinCh2, ledPinCh3, ledPinCh4, ledPinCh5};
char ch1Descr[15],  ch2Descr[15], ch3Descr[15], ch4Descr[15], ch5Descr[15];
const byte *rgbChann[] = {rgbCh1, rgbCh2, rgbCh3, rgbCh4, rgbCh5};

char *Day[] = {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};
char *Mon[] = {"", "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};

struct RTC_T
{
  int tHour;
  int tMinute;
  int tDow;
  int tDay;
  int tMonth;
  int tYear;
}
tmpRTC, prevRTC;

////////////////////
// --- Кнопки --- //
////////////////////

/// --- Кнопки уст. часов ---
const int HourUp[] = {130, 22 - 2};            //hour up
const int HourDown[] = {130, 71 - 2};            //hour down
const int MinUp[] = {190, 22 - 2};            //minute up
const int MinDown[] = {190, 71 - 2};            //minute down

const int DayUp[] = {120, 111 - 6};           //day up
const int DayDown[] = {120, 160 - 6};           //day down
const int MonthUp[] = {179, 111 - 6};           //month up
const int MonthDown[] = {179, 160 - 6};           //month down
const int YearUp[] = {250, 111 - 6};           //year up
const int YearDown[] = {250, 160 - 6};           //year down

// --- Кнопки menu ---
const int KeySetTime[] = {4, 125, 158, 170};
const int KeyLedValue[] = {4, 175, 158, 220};
const int KeyMixer[] = {161, 125, 315, 170};
const int KeyAbout[] = {161, 175, 315, 220};

// --- LEDs menu ---
const int ch1L[] = {4, 21, 158, 59};       //channel 1 light output
const int ch2L[] = {161, 21, 315, 59};     //channel 2 light output
const int ch3L[] = {4, 61, 158, 99};       //channel 3 light output
const int ch4L[] = {161, 61, 315, 99};     //channel 4 light output
const int ch5L[] = {4, 101, 158, 139};     //channel 5 light output

// --- Основные ---
const int KeyCancel[] = {161, 195, 315, 221};   //standard cancel
const int KeyOK[] = {4, 195, 158, 221};     //standard ok

//////////////
// *** Функции
//////////////

void initSettings()
{
  strcat(ch1Descr, namesChMix[1]);
  strcat(ch1Descr, "(" );
  strcat(ch1Descr, namesCh[1]);
  strcat(ch1Descr, ")" );
  strcat(ch2Descr, namesChMix[2]);
  strcat(ch2Descr, "(" );
  strcat(ch2Descr, namesCh[2]);
  strcat(ch2Descr, ")" );
  strcat(ch3Descr, namesChMix[3]);
  strcat(ch3Descr, "(" );
  strcat(ch3Descr, namesCh[3]);
  strcat(ch3Descr, ")" );
  strcat(ch4Descr, namesChMix[4]);
  strcat(ch4Descr, "(" );
  strcat(ch4Descr, namesCh[4]);
  strcat(ch4Descr, ")" );
  strcat(ch5Descr, namesChMix[5]);
  strcat(ch5Descr, "(" );
  strcat(ch5Descr, namesCh[5]);
  strcat(ch5Descr, ")" );
}

////////////////////////////
// --- Очистка экрана --- //
////////////////////////////

void clearScreen()
{
  myGLCD.setColor(0, 0, 0);
  myGLCD.fillRect(1, 1, 318, 225);
}

///////////////////
// --- Шапка --- //
///////////////////

void printHeader(char* headline)
{
  changeFont(SMALL, 255, 255, 255, 255, 255, 255);
  myGLCD.fillRect (1, 1, 318, 15);
  myGLCD.setColor(0, 0, 0);
  myGLCD.print(headline, CENTER, 2);
}

////////////////////
// --- EEPROM --- //
////////////////////

void SaveToEEPROM(int what)
{
  switch (what) {
    case 1:
      EEPROM.write(0, 121);
      delay(5);
      for (int i = 0; i < 96; i++)  {
        EEPROM.write(i + 1, ch1led[i]);
        delay(5);
      }
      break;
    case 2:
      EEPROM.write(97, 122);
      delay(5);
      for (int i = 0; i < 96; i++)  {
        EEPROM.write(i + 98, ch2led[i]);
        delay(5);
      }
      break;
    case 3:
      EEPROM.write(194, 123);
      delay(5);
      for (int i = 0; i < 96; i++)  {
        EEPROM.write(i + 195, ch3led[i]);
        delay(5);
      }
      break;
    case 4:
      EEPROM.write(291, 124);
      delay(5);
      for (int i = 0; i < 96; i++)  {
        EEPROM.write(i + 292, ch4led[i]);
        delay(5);
      }
      break;
    case 5:
      EEPROM.write(388, 125);
      delay(5);
      for (int i = 0; i < 96; i++)  {
        EEPROM.write(i + 389, ch5led[i]);
        delay(5);
      }
      break;
  }
}

void ReadFromEEPROM()
{
  float t1;
  int k;

  k = EEPROM.read(0);
  delay(5);
  if (k == 121)
  {
    for (int i = 0; i < 96; i++)
    {
      ch1led[i] = EEPROM.read(i + 1);
      delay(5);
    }
  }

  k = EEPROM.read(97);
  delay(5);
  if (k == 122)
  {
    for (int i = 0; i < 96; i++)
    {
      ch2led[i] = EEPROM.read(i + 98);
      delay(5);
    }
  }

  k = EEPROM.read(194);
  delay(5);
  if (k == 123)
  {
    for (int i = 0; i < 96; i++)
    {
      ch3led[i] = EEPROM.read(i + 195);
      delay(5);
    }
  }

  k = EEPROM.read(291);
  delay(5);
  if (k == 124)
  {
    for (int i = 0; i < 96; i++)
    {
      ch4led[i] = EEPROM.read(i + 292);
      delay(5);
    }
  }

  k = EEPROM.read(388);
  delay(5);
  if (k == 125)
  {
    for (int i = 0; i < 96; i++)
    {
      ch5led[i] = EEPROM.read(i + 389);
      delay(5);
      if(i == EEPROM.length())
    i = 0;
    }
  }
}

/////////////////////////////
// --- сохранить время --- //
/////////////////////////////

void SaveRTC()
{
  RTC.stopClock();
  RTC.fillByYMD(tmpRTC.tYear, tmpRTC.tMonth, tmpRTC.tDay);
  RTC.fillByHMS(tmpRTC.tHour, tmpRTC.tMinute, 0);
  RTC.setTime();
  delay(10);
  RTC.startClock();
  delay(10);
}

////////////////////
/// --- Шрифт --- //
////////////////////

void changeFont(int font, byte cr, byte cg, byte cb, byte br, byte bg, byte bb)
{
  myGLCD.setBackColor(br, bg, bb);    //font background
  myGLCD.setColor(cr, cg, cb);        //font colour
  if (font == LARGE)
    myGLCD.setFont(BigFont);          //font size
  else if (font == SMALL)
    myGLCD.setFont(SmallFont);
}

/////////////////////////////
// --- Печатает Кнопки --- //
/////////////////////////////

void printUpButton(int x, int y)           //size 29x23px
{
  myGLCD.setColor(255, 255, 255);
  myGLCD.fillRect(x, y + 22, x + 29, y + 23);
  myGLCD.setColor(255, 255, 255);
  for (int i = 0; i < 15; i++)
    myGLCD.drawLine(x + 4 + (i / 1.5), y + 17 - i, x + 25 - (i / 1.5), y + 17 - i);
}

void printDownButton(int x, int y)           //size 29x23px
{
  myGLCD.setColor(255, 255, 255);
  myGLCD.fillRect(x, y, x + 29, y + 1);
  myGLCD.setColor(255, 255, 255);
  for (int i = 0; i < 15; i++)
    myGLCD.drawLine(x + 4 + (i / 1.5), y + 7 + i, x + 25 - (i / 1.5), y + 7 + i);
}

void hlightUpButton(int x, int y) // UP
{
  myGLCD.setColor(0, 200, 0);
  for (int i = 0; i < 15; i++)
    myGLCD.drawLine(x + 4 + (i / 1.5), y + 17 - i, x + 25 - (i / 1.5), y + 17 - i);
  while (myTouch.dataAvailable()) {
    myTouch.read();
  }
  myGLCD.setColor(255, 255, 255);
  for (int i = 0; i < 15; i++)
    myGLCD.drawLine(x + 4 + (i / 1.5), y + 17 - i, x + 25 - (i / 1.5), y + 17 - i);
}

void hlightDownButton(int x, int y) // DOWN
{
  myGLCD.setColor(0, 200, 0);
  for (int i = 0; i < 15; i++)
    myGLCD.drawLine(x + 4 + (i / 1.5), y + 7 + i, x + 25 - (i / 1.5), y + 7 + i);
  while (myTouch.dataAvailable()) {
    myTouch.read();
  }
  myGLCD.setColor(255, 255, 255);
  for (int i = 0; i < 15; i++)
    myGLCD.drawLine(x + 4 + (i / 1.5), y + 7 + i, x + 25 - (i / 1.5), y + 7 + i);
}

void hlightButton(char* text, int x1, int y1, int x2, int y2)
{
  int stl = strlen(text);
  int fx, fy;

  fx = x1 + (((x2 - x1) - (stl * 8)) / 2);
  fy = y1 + (((y2 - y1 - 1) - 8) / 2);

  myGLCD.setColor(0, 200, 0);
  myGLCD.fillRect (x1 + 4, y1 + 4, x2 - 4, y2 - 4);
  changeFont(SMALL, 255, 255, 255, 0, 200, 0);
  myGLCD.print(text, fx, fy);
  while (myTouch.dataAvailable()) {
    myTouch.read();
  }
  myGLCD.setColor(0, 0, 0);
  myGLCD.fillRect (x1 + 4, y1 + 4, x2 - 4, y2 - 4);
  changeFont(SMALL, 255, 255, 255, 0, 0, 0);
  myGLCD.print(text, fx, fy);
}

// --- Кнопки меню
void drawLedMenuButton()
{
  for (y = 0; y < 4; y++)
  {
    myGLCD.setColor(255, 255, 255);
    myGLCD.drawRect(4, 21 + (y * 40), 158, 59 + (y * 40));
    myGLCD.drawRect(161, 21 + (y * 40), 315, 59 + (y * 40));
  }
}

void drawMenuButton()
{
  for (y = 0; y < 2; y++)
  {
    myGLCD.setColor(255, 255, 255);
    myGLCD.drawRect(4, 125 + (y * 50), 158, 170 + (y * 50));
    myGLCD.drawRect(161, 125 + (y * 50), 315, 170 + (y * 50));
  }
}

void drawRegButton()
{
  myGLCD.setColor(255, 255, 255);
  myGLCD.drawRoundRect(4, 195, 158, 221);
  myGLCD.drawRoundRect(161, 195, 315, 221);
}

void printButton(char* text, int x1, int y1, int x2, int y2)
{
  int stl = strlen(text);
  int fx, fy;

  fx = x1 + (((x2 - x1) - (stl * 8)) / 2);
  fy = y1 + (((y2 - y1 - 1) - 8) / 2);

  changeFont(SMALL, 255, 255, 255, 0, 0, 0);
  myGLCD.print(text, fx, fy);
}

///////////////////////////////////
// --- Печатает LEDs область --- //
///////////////////////////////////

void drawLedBar(int bary, byte ch)
{
  float barLength; /// int !!!!
  char barLevel[7];

  itoa(LEDch_out[ch - 1], barLevel, 10);
  strcat(barLevel, "%");
  barLength = LEDch_out[ch - 1] * 1;
  //barLength = 170;
  myGLCD.setColor(0, 0, 0);
  myGLCD.fillRect(46, bary, 189, (bary + 12));
  changeFont(SMALL, rgbChann[ch - 1][0], rgbChann[ch - 1][1], rgbChann[ch - 1][2], 0, 0, 0);
  myGLCD.print(namesCh[ch], 5, bary);
  myGLCD.drawLine(47, (bary + 1), 47, (bary + 11));
  myGLCD.fillRect(49, (bary + 2), (barLength + 49), (bary + 10));
  myGLCD.print(barLevel, (barLength + 51), bary);
}

void printVBar(int val, int x1, int y1, const byte rgb[])
{
  myGLCD.setColor(255, 255, 255);
  myGLCD.drawRect (x1, y1 + 22, x1 + 29, y1 + 124);
  myGLCD.setColor(rgb[0], rgb[1], rgb[2]);
  myGLCD.fillRect (x1 + 1, y1 + (124 - val), x1 + 28, y1 + 124);
  myGLCD.setColor(0, 0, 0);
  myGLCD.fillRect (x1 + 1, y1 + 22, x1 + 28, y1 + (124 - val));
  printUpButton(x1, y1);
  printDownButton(x1, y1 + 124);
  changeFont(SMALL, 255, 255, 255, 0, 0, 0);
  if (val > -1)
    myGLCD.printNumI(val, x1 + 16 - (intlen(val) * 4), y1 + 66);
}

////////////////////////
// --- Print TIME --- //
////////////////////////

void printTime(int thour, int tminute, int posx, int posy)
{
  char tmpTime[6], charT[3];
  tmpTime[0] = '\0';

  if (thour >= 0 && thour <= 9)
  {
    strcat(tmpTime, "0");
    itoa(thour, charT, 10);
    strcat(tmpTime, charT);
  }
  else
    itoa(thour, tmpTime, 10);

  strcat(tmpTime, ":");

  if (tminute >= 0 && tminute <= 9)
  {
    strcat(tmpTime, "0");
    itoa(tminute, charT, 10);
    strcat(tmpTime, charT);
  }
  else
  {
    itoa(tminute, charT, 10);
    strcat(tmpTime, charT);
  }
  myGLCD.print(tmpTime, posx, posy);
}

////////////////////////
// --- Print DATE --- //
////////////////////////

void printDate(int x, int y)
{
  char  chDate[25], tmpChar[5];
  strcat(chDate, "  ");
  chDate[0] = '\0';
  strcat(chDate, Day[RTC.dow]);
  strcat(chDate, ",");
  itoa(RTC.day, tmpChar, 10);
  strcat(chDate, tmpChar);
  strcat(chDate, " ");
  strcat(chDate, Mon[RTC.month]);
  strcat(chDate, " ");
  itoa(RTC.year, tmpChar, 10);
  strcat(chDate, tmpChar);
  //strcat(chDate, " ");
  myGLCD.print(chDate, x, y);            //Display date
}

int intlen(int number)               //number of digits
{
  int length;
  char tmpChar[7];

  itoa(number, tmpChar, 10);
  length = strlen(tmpChar);

  return length;
}

int stringCenter (char *myString, boolean font = false)
{
  int chLen;

  if (font)                                   //large font
    chLen = (strlen(myString) * 8) - 1;
  else                                         //small font
    chLen = (strlen(myString) * 4) - 1;
  return chLen;
}

//---------------------------LED levels---------------------------
void LED_levels_output()
{
  int sector, sstep, t1, t2 ;
  int l_out;
  //  if (LEDtestFlag==0)
  min_cnt = (RTC.hour * 60) + RTC.minute;
  if (min_cnt >= 1440)
  {
    min_cnt = 1;
  }
  sector = min_cnt / 15;            // divided by gives sector -- 15 minutes
  sstep = min_cnt % 15;             // remainder gives add on to sector value
  t1 = sector;
  if (t1 == 95)
  {
    t2 = 0;
  }
  else
  {
    t2 = t1 + 1;
  }

  for (int i = 0; i < numberOfCh; i++)
  {
    if (sstep == 0)
      LEDch_out[i] = LEDval_arr[i][t1];
    else
      LEDch_out[i] = check(&LEDval_arr[i][t1], &LEDval_arr[i][t2], sstep);
    //LEDch_out[i] = LEDch_out[i];

    if (BUCKPUCK)
      l_out = LEDch_out[i];
    else
      l_out = 100 - LEDch_out[i]; // !!! если обратное питание драйвера
    l_out = map(l_out, 0, 100, 0, 255);
    analogWrite(LEDpin[i], l_out);
  }
}
int check( byte *pt1, byte *pt2, int lstep)
{
  int result;
  float fresult;

  if (*pt1 == *pt2) {
    result = *pt1;
  }      // No change
  else if (*pt1 < *pt2)               //Increasing brightness
  {
    fresult = ((float(*pt2 - *pt1) / 15.0) * float(lstep)) + float(*pt1);
    result = int(fresult);
  }
  //Decreasing brightness
  else
  {
    fresult = -((float(*pt1 - *pt2) / 15.0) * float(lstep)) + float(*pt1);
    result = int(fresult);
  }
  return result;
}

void printChangeLED()
{
  myGLCD.setColor(255, 0, 0);
  myGLCD.fillRect((LedChangTime * 26) + 5, 20, (LedChangTime * 26) + 29, 42);
  changeFont(SMALL, 255, 255, 255, 255, 0, 0);
  myGLCD.printNumI((LedChangTime * 2), (LedChangTime * 26) + 19 - (intlen(LedChangTime * 2) * 4), 20);
  myGLCD.printNumI(((LedChangTime * 2) + 1), (LedChangTime * 26) + 19 - (intlen(LedChangTime * 2) * 4), 31);

  for (int i = 0; i < 8; i++) // print led values for highlighted time
  {
    int k = (LedChangTime * 8) + i;
    printVBar( tled[k], (i * 38) + 10, 44, rgbChann[selectChannel - 1]);
  }
}

//////////////////////////////
// ----   *** Экран *** --- //
//////////////////////////////

/// --- Главный --- dispScreen=0 --- //
void mainScreen(boolean refreshAll = false)
{
  int h1, t1, by, bary;
  char tmpChar[8], charTmp[3];
  by = 118;

  if ( refreshAll)
  {
    myGLCD.setColor(255, 255, 255);
    myGLCD.drawRect(6, 17, 313, 18);         //top line
    myGLCD.drawRect(6, by, 313, by + 1);     //middle line
    myGLCD.drawLine(190, 18 + 4, 190, by - 4);
   // myGLCD.drawBitmap(205, 19, 99, 99, logo);
    drawMenuButton();
    printButton("SET TIME", KeySetTime[0], KeySetTime[1], KeySetTime[2], KeySetTime[3]);
    printButton("ABOUT", KeyAbout[0], KeyAbout[1], KeyAbout[2], KeyAbout[3]);
    printButton("LEDs OUTPUT", KeyLedValue[0], KeyLedValue[1], KeyLedValue[2], KeyLedValue[3]);
    printButton("COLOR MIXER", KeyMixer[0], KeyMixer[1], KeyMixer[2], KeyMixer[3]);
  }

  changeFont(LARGE, 0, 255, 0, 0, 0, 0);
  if ((RTC.hour != prevRTC.tHour) || (RTC.minute != prevRTC.tMinute) || refreshAll)
  { //time
    prevRTC.tHour = RTC.hour;
    prevRTC.tMinute = RTC.minute;
    printTime(RTC.hour, RTC.minute, 220, 1);
  }

  changeFont(SMALL, 0, 255, 0, 0, 0, 0);
  if ((RTC.day != prevRTC.tDay) || (RTC.month != prevRTC.tMonth) || (RTC.year != prevRTC.tYear) || refreshAll)
  { //date
    prevRTC.tDay = RTC.day;
    prevRTC.tMonth = RTC.month;
    prevRTC.tYear = RTC.year;
    printDate(15, 5);
  }

  for (int i = 0; i < numberOfCh; i++)
  { //led bars
    if ((prevLEDch_out[i] != LEDch_out[i]) || refreshAll)
    {
      bary = 8 + 12 + ((by - 11) / (numberOfCh + 1)) * (i + 1) - 12;
      drawLedBar(bary, i + 1);
      prevLEDch_out[i] = LEDch_out[i];
    }
  }
}

///////////////////////////////////////////////
// --- set clock screen --- dispScreen=1 --- //
///////////////////////////////////////////////

void clockScreen(boolean refreshAll = false)
{
  char char1[4], tmp[3];

  if (refreshAll)
  {
    tmpRTC.tHour = RTC.hour;
    tmpRTC.tMinute = RTC.minute;
    tmpRTC.tDow = RTC.dow;
    tmpRTC.tDay = RTC.day;
    tmpRTC.tMonth = RTC.month;
    tmpRTC.tYear = RTC.year;

    printHeader("Time and Date settings");

    myGLCD.setColor(255, 255, 255);
    myGLCD.drawLine(6, 98, 313, 98);

    changeFont(LARGE, 255, 255, 0, 0, 0, 0);
    myGLCD.print("Time:", 20, 51 - 2);
    myGLCD.print("Date:", 20, 140 - 6);

    printUpButton(HourUp[0], HourUp[1]);
    printDownButton(HourDown[0], HourDown[1]);
    printUpButton(MinUp[0], MinUp[1]);
    printDownButton(MinDown[0], MinDown[1]);

    printUpButton(DayUp[0], DayUp[1]);
    printDownButton(DayDown[0], DayDown[1]);
    printUpButton(MonthUp[0], MonthUp[1]);
    printDownButton(MonthDown[0], MonthDown[1]);
    printUpButton(YearUp[0], YearUp[1]);
    printDownButton(YearDown[0], YearDown[1]);

    drawRegButton();
    printButton("SAVE", KeyOK[0], KeyOK[1], KeyOK[2], KeyOK[3]);
    printButton("CANCEL", KeyCancel[0], KeyCancel[1], KeyCancel[2], KeyCancel[3]);
  }

  changeFont(LARGE, 255, 255, 255, 0, 0, 0);

  char1[0] = '\0';
  if (tmpRTC.tHour <= 9)
  {
    strcat(char1, "0");
    itoa(tmpRTC.tHour, tmp, 10);
    strcat(char1, tmp);
  }
  else
    itoa(tmpRTC.tHour, char1, 10);     //print hour
  myGLCD.print("0", HourUp[0], 51 - 2);
  myGLCD.print(char1, HourUp[0] + 14 - stringCenter(char1, LARGE), 51 - 2);
  myGLCD.print(":", 168, 51 - 2);

  char1[0] = '\0';
  if (tmpRTC.tMinute <= 9)
  { //print minutes
    strcat(char1, "0");
    itoa(tmpRTC.tMinute, tmp, 10);
    strcat(char1, tmp);
  }
  else
    itoa(tmpRTC.tMinute, char1, 10);
  myGLCD.print("0", MinUp[0], 51 - 2);
  myGLCD.print(char1, MinUp[0] + 14 - stringCenter(char1, LARGE), 51 - 2);

  char1[0] = '\0';
  if (tmpRTC.tDay <= 9)
  {
    strcat(char1, "0");
    itoa(tmpRTC.tDay, tmp, 10);
    strcat(char1, tmp);
  }
  else
    itoa(tmpRTC.tDay, char1, 10);                        //print day
  myGLCD.print("0", DayUp[0], 140 - 6);
  myGLCD.print(char1, DayUp[0] + 14 - stringCenter(char1, LARGE), 140 - 6);

  myGLCD.print(Mon[tmpRTC.tMonth], MonthUp[0] + 14 - stringCenter(Mon[tmpRTC.tMonth], LARGE), 140 - 6); //print month

  char1[0] = '\0';
  itoa(tmpRTC.tYear, char1, 10);                                                 //print year
  myGLCD.printNumI(tmpRTC.tYear, YearUp[0] + 14 - stringCenter(char1, LARGE), 140 - 6);
}

///////////////////////////////////////////////
// --- LEDs menu screen --- dispScreen=2 --- //
///////////////////////////////////////////////

void LEDmenuScreen()
{
  printHeader("Select LED channel:");

  printButton(ch1Descr, ch1L[0], ch1L[1], ch1L[2], ch1L[3]);
  printButton(ch2Descr, ch2L[0], ch2L[1], ch2L[2], ch2L[3]);

  if (numberOfCh > 2)
    printButton(ch3Descr, ch3L[0], ch3L[1], ch3L[2], ch3L[3]);

  if (numberOfCh > 3)
    printButton(ch4Descr, ch4L[0], ch4L[1], ch4L[2], ch4L[3]);

  if (numberOfCh > 4)
    printButton(ch5Descr, ch5L[0], ch5L[1], ch5L[2], ch5L[3]);

  drawLedMenuButton();
  drawRegButton();

  printButton("CANCEL", KeyCancel[0], KeyCancel[1], KeyCancel[2], KeyCancel[3]);
}

/////////////////////////////////////////////////
// --- Color Mixer screen --- dispScreen=3 --- //
/////////////////////////////////////////////////

void colorMixerScreen(boolean refreshAll = false)
{
  int posx;
  byte currentLedLevels[5];

  if (refreshAll) {
    for (int i = 0; i < 5; i++)
      currentLedLevels[i] = LEDch_out[i];

    printHeader("LEDs Color Mixer");

    drawRegButton();
    printButton("CANCEL", KeyCancel[0], KeyCancel[1], KeyCancel[2], KeyCancel[3]);
  }

  for (int i = 0; i < numberOfCh; i++)
  {
    posx = i * (289 / numberOfCh) + ((319 / numberOfCh) / 2 + 1);
    printVBar(currentLedLevels[i], posx, 18, rgbChann[i]);
    changeFont(SMALL, rgbChann[i][0], rgbChann[i][1], rgbChann[i][2], 0, 0, 0);
    myGLCD.print(namesChMix[i + 1], posx, 167);
  }
}

/////////////////////////////////////////////////////////
// --- show all led values screen --- dispScreen=4 --- //
/////////////////////////////////////////////////////////

void ledSetScreen()
{
  int a;

  tChar30[0] = '\0';

  switch (selectChannel) 
  {
    case 1:
      for (int i = 0; i < 96; i++)
        tled[i] = ch1led[i];
      strcat(tChar30, ch1Descr);
      strcat(tChar30, " output values %" );
      printHeader(tChar30);
      break;
    case 2:
      for (int i; i < 96; i++)
        tled[i] = ch2led[i];
      strcat(tChar30, ch2Descr);
      strcat(tChar30, " output values %" );
      printHeader(tChar30);
      break;
    case 3:
      for (int i; i < 96; i++)
        tled[i] = ch3led[i];
      strcat(tChar30, ch3Descr);
      strcat(tChar30, " output values %" );
      printHeader(tChar30);
      break;
    case 4:
      for (int i; i < 96; i++)
        tled[i] = ch4led[i];
      strcat(tChar30, ch4Descr);
      strcat(tChar30, " output values %" );
      printHeader(tChar30);
      break;
    case 5:
      for (int i; i < 96; i++)
        tled[i] = ch5led[i];
      strcat(tChar30, ch5Descr);
      strcat(tChar30, " output values %" );
      printHeader(tChar30);
      break;
  }

  changeFont(SMALL, 255, 255, 255, 0, 0, 0);
  for (int i = 0; i < 12; i++)
  {
    myGLCD.setColor(255, 255, 0);
    myGLCD.printNumI((i * 2), (i * 26) + 19 - (intlen(i * 2) * 4), 21);
    myGLCD.printNumI(((i * 2) + 1), (i * 26) + 19 - (intlen(i * 2) * 4), 32);
    for (int j = 0; j < 8; j++)
    {
      a = (i * 8) + j;
      myGLCD.setColor(255, 255, 255);
      myGLCD.printNumI(tled[a], (i * 26) + 19 - (intlen(tled[a]) * 4), (j * 16) + 49);
      myGLCD.setColor(100, 100, 100);
      myGLCD.drawRect((i * 26) + 4, (j * 16) + 47, (i * 26) + 30, (j * 16) + 63);
    }
  }

  drawRegButton();
  printButton("CHANGE", KeyOK[0], KeyOK[1], KeyOK[2], KeyOK[3]);
  printButton("BACK", KeyCancel[0], KeyCancel[1], KeyCancel[2], KeyCancel[3]);
}

///////////////////////////////////////////////////////
// --- change led values screen --- dispScreen=5 --- //
///////////////////////////////////////////////////////

void ledChangeScreen()
{
  printHeader(tChar30);

  changeFont(SMALL, 0, 255, 255, 0, 0, 0);
  for (int i = 0; i < 12; i++)
  {
    myGLCD.setColor(255, 255, 0);
    myGLCD.printNumI((i * 2), (i * 26) + 19 - (intlen(i * 2) * 4), 20);
    myGLCD.printNumI(((i * 2) + 1), (i * 26) + 19 - (intlen(i * 2) * 4), 31);
    myGLCD.setColor(100, 100, 100);
    myGLCD.drawRect((i * 26) + 4, 19 , (i * 26) + 30, 43);
  }
  printChangeLED();

  drawRegButton();
  printButton("SAVE", KeyOK[0], KeyOK[1], KeyOK[2], KeyOK[3]);
  printButton("CANCEL", KeyCancel[0], KeyCancel[1], KeyCancel[2], KeyCancel[3]);
}

/////////////////////////////////////
// --- ABOUT --- Dispscreen=50 --- //
/////////////////////////////////////
void AboutScreen(boolean refreshAll = false)
{
  printHeader("SoftAquaMatic 5-Channel");
  if (refreshAll)
  {
    changeFont(SMALL, 0, 255, 0, 0, 0, 0);
    myGLCD.print("Release Date: May 2014", CENTER, 20);
    myGLCD.print("Written by Ruslan Kuchma", CENTER, 32);

    myGLCD.print("Main code based on Stilo", 5, 50);
    myGLCD.print("http://code.google.com/p/stilo/", 5, 62);

    myGLCD.print("LED controlling algorithm based on", 5, 80);
    myGLCD.print("Krusduino by Hugh Dangerfield", 5, 92);
    myGLCD.print("and Dave Rosser", 5, 104);
    myGLCD.print("http://code.google.com/p/dangerduino/", 5, 116);

    myGLCD.print("Special Thanks: Andrej Gontarenko", 5, 134);
    myGLCD.print("", 5, 146);

    changeFont(SMALL, 255, 255, 0, 0, 0, 0);
    myGLCD.print("http://softaquamatic.ru/", CENTER, 164);
    myGLCD.print("E-mail: RUSLAN.KUCHMA.7@GMAIL.COM", CENTER, 176);
    drawRegButton();
    printButton("CANCEL", KeyCancel[0], KeyCancel[1], KeyCancel[2], KeyCancel[3]);
  }
}

///////////////////////////////////
// ***   ---   TOUCH   ---   *** //
///////////////////////////////////

void processMyTouch()
{
  myTouch.read();
  x = myTouch.getX();
  y = myTouch.getY();

  prevMillis600 = millis();
  delay(100);
  if ((x >= KeyCancel[0]) && (x <= KeyCancel[2]) && (y >= KeyCancel[1]) && (y <= KeyCancel[3]) && (dispScreen != 0) && (dispScreen != 4) && (dispScreen != 5)) //press cancel
  {
    hlightButton("CANCEL", KeyCancel[0], KeyCancel[1], KeyCancel[2], KeyCancel[3]);
    dispScreen = 0;
    clearScreen();
    mainScreen(true);
  }
  else
  {
    switch (dispScreen)
    {
      case 0:

        if ((x >= KeySetTime[0]) && (x <= KeySetTime[2]))
        {
          if ((y >= KeySetTime[1]) && (y <= KeySetTime[3]))
          {
            hlightButton("SET TIME", KeySetTime[0], KeySetTime[1], KeySetTime[2], KeySetTime[3]);
            dispScreen = 1;
            clearScreen();
            clockScreen(true);
          }
          if ((y >= KeyLedValue[1]) && (y <= KeyLedValue[3]))
          {
            hlightButton("LEDs OUTPUT", KeyLedValue[0], KeyLedValue[1], KeyLedValue[2], KeyLedValue[3]);
            dispScreen = 2;
            clearScreen();
            LEDmenuScreen();
          }
        }
        if ((x >= KeyMixer[0]) && (x <= KeyMixer[2]))
        {
          if ((y >= KeyMixer[1]) && (y <= KeyMixer[3]))
          {
            hlightButton("COLOR MIXER", KeyMixer[0], KeyMixer[1], KeyMixer[2], KeyMixer[3]);
            dispScreen = 3;
            clearScreen();
            colorMixerScreen(true);
          }
          if ((y >= KeyAbout[1]) && (y <= KeyAbout[3]))
          {
            hlightButton("ABOUT", KeyAbout[0], KeyAbout[1], KeyAbout[2], KeyAbout[3]);
            dispScreen = 50;
            clearScreen();
            AboutScreen(true);
          }
        }
        break;

      case 1:                      //-------------------------------------clock setup--------------------------
        if ((x >= KeyOK[0]) && (x <= KeyOK[2]) && (y >= KeyOK[1]) && (y <= KeyOK[3]))
        {
          hlightButton("SAVE", KeyOK[0], KeyOK[1], KeyOK[2], KeyOK[3]);
          SaveRTC();
          dispScreen = 0;
          clearScreen();
          mainScreen(true);
        }
        else {
          if ((y >= HourUp[1]) && (y <= HourUp[1] + 23)) {              //first row
            if ((x >= HourUp[0]) && (x <= HourUp[0] + 29)) {           //hour plus
              hlightUpButton(HourUp[0], HourUp[1]);
              tmpRTC.tHour++;
              if (tmpRTC.tHour >= 24) {
                tmpRTC.tHour = 0;
              }
            }
            if ((x >= MinUp[0]) && (x <= MinUp[0] + 29)) {           //minute plus
              hlightUpButton(MinUp[0], MinUp[1]);
              tmpRTC.tMinute++;
              if (tmpRTC.tMinute >= 60) {
                tmpRTC.tMinute = 0;
              }
            }
          }
          else if ((y >= HourDown[1]) && (y <= HourDown[1] + 23))
          {
            if ((x >= HourDown[0]) && (x <= HourDown[0] + 29))
            {
              hlightDownButton(HourDown[0], HourDown[1]);
              tmpRTC.tHour--;
              if (tmpRTC.tHour < 0)
              {
                tmpRTC.tHour = 23;
              }
            }
            if ((x >= MinDown[0]) && (x <= MinDown[0] + 29))
            {
              hlightDownButton(MinDown[0], MinDown[1]);
              tmpRTC.tMinute--;
              if (tmpRTC.tMinute < 0)
              {
                tmpRTC.tMinute = 59;
              }
            }
          }
          else if ((y >= DayUp[1]) && (y <= DayUp[1] + 23))
          {
            if ((x >= DayUp[0]) && (x <= DayUp[0] + 29))
            {
              hlightUpButton(DayUp[0], DayUp[1]);
              tmpRTC.tDay++;
              if (tmpRTC.tDay > 31)
              {
                tmpRTC.tDay = 1;
              }
            }
            if ((x >= MonthUp[0]) && (x <= MonthUp[0] + 29))
            {
              hlightUpButton(MonthUp[0], MonthUp[1]);
              tmpRTC.tMonth++;
              if (tmpRTC.tMonth > 12)
              {
                tmpRTC.tMonth = 1;
              }
            }
            if ((x >= YearUp[0]) && (x <= YearUp[0] + 29))
            {
              hlightUpButton(YearUp[0], YearUp[1]);
              if (tmpRTC.tYear < 2100)
                tmpRTC.tYear++;
            }
          }
          else if ((y >= DayDown[1]) && (y <= DayDown[1] + 23))
          {
            if ((x >= DayDown[0]) && (x <= DayDown[0] + 29))
            {
              hlightDownButton(DayDown[0], DayDown[1]);
              tmpRTC.tDay--;
              if (tmpRTC.tDay <= 0)
              {
                tmpRTC.tDay = 31;
              }
            }
            if ((x >= MonthDown[0]) && (x <= MonthDown[0] + 29))
            {
              hlightDownButton(MonthDown[0], MonthDown[1]);
              tmpRTC.tMonth--;
              if (tmpRTC.tMonth <= 0)
              {
                tmpRTC.tMonth = 12;
              }
            }
            if ((x >= YearDown[0]) && (x <= YearDown[0] + 29))
            {
              hlightDownButton(YearDown[0], YearDown[1]);
              if (tmpRTC.tYear > 2000)
                tmpRTC.tYear--;
            }
          }
          clockScreen(false);
        }
        break;

      // --- menu select LED channel
      case 2:
        if ((x >= ch1L[0]) && (x <= ch1L[2]))
        { //first column
          if ((y >= ch1L[1]) && (y <= ch1L[3])) //press channel 1
          {
            hlightButton(ch1Descr, ch1L[0], ch1L[1], ch1L[2], ch1L[3]);
            selectChannel = 1;
            dispScreen = 4;
            clearScreen();
            ledSetScreen();
          }
          if ((y >= ch3L[1]) && (y <= ch3L[3]) && (numberOfCh > 2)) //press channel 3
          {
            hlightButton(ch3Descr, ch3L[0], ch3L[1], ch3L[2], ch3L[3]);
            selectChannel = 3;
            dispScreen = 4;
            clearScreen();
            ledSetScreen();
          }
          if ((y >= ch5L[1]) && (y <= ch5L[3]) && (numberOfCh > 4)) //press channel 5
          {
            hlightButton(ch5Descr, ch5L[0], ch5L[1], ch5L[2], ch5L[3]);
            selectChannel = 5;
            dispScreen = 4;
            clearScreen();
            ledSetScreen();
          }
        }
        if ((x >= ch2L[0]) && (x <= ch2L[2]))           //second column
        {
          if ((y >= ch2L[1]) && (y <= ch2L[3]))         //press channel 2
          {
            hlightButton(ch2Descr, ch2L[0], ch2L[1], ch2L[2], ch2L[3]);
            selectChannel = 2;
            dispScreen = 4;
            clearScreen();
            ledSetScreen();
          }
          if ((y >= ch4L[1]) && (y <= ch4L[3]) && (numberOfCh > 3)) //press channel 4
          {
            hlightButton(ch4Descr, ch4L[0], ch4L[1], ch4L[2], ch4L[3]);
            selectChannel = 4;
            dispScreen = 4;
            clearScreen();
            ledSetScreen();
          }
        }
        break;

      // --- Color Mixer
      case 3:
        int px, out;

        for (int i = 0; i < numberOfCh; i++)
        {
          px = i * (289 / numberOfCh) + ((319 / numberOfCh) / 2 + 1);
          if ((x >= px) && (x <= px + 29))
          {
            if ((y >= 22) && (y <= 43))
            { //plus buttons were touched
              if (LEDch_out[i] < 100)
                LEDch_out[i]++;
            }
            else if ((y >= 45) && (y <= 144))
            { //the bar has been touched
              LEDch_out[i] = 144 - y;
            }
            else if ((y >= 146) && (y <= 167))
            { //minus buttons were touched
              if (LEDch_out[i] > 0)
                LEDch_out[i]--;
            }

            printVBar( LEDch_out[i], px, 18, rgbChann[i]);
            if (BUCKPUCK)
              out = LEDch_out[i];
            else
              out = 100 - LEDch_out[i]; // !!! если обратное питание драйвера
            out = map(out, 0, 100, 0, 255);
            analogWrite(LEDpin[i], out);
          }
        }
        break;

      // --- show leds values table
      case 4:
        if ((x >= KeyOK[0]) && (x <= KeyOK[2]) && (y >= KeyOK[1]) && (y <= KeyOK[3])) //press change
        {
          hlightButton("CHANGE", KeyOK[0], KeyOK[1], KeyOK[2], KeyOK[3]);
          dispScreen = 5;
          clearScreen();
          ledChangeScreen();
        }
        else if ((x >= KeyCancel[0]) && (x <= KeyCancel[2]) && (y >= KeyCancel[1]) && (y <= KeyCancel[3])) //press BACK
        {
          hlightButton("BACK", KeyCancel[0], KeyCancel[1], KeyCancel[2], KeyCancel[3]);
          dispScreen = 2;
          clearScreen();
          LEDmenuScreen();
        }
        break;

      // --- change leds values
      case 5:
        if ((x >= KeyCancel[0]) && (x <= KeyCancel[2]) && (y >= KeyCancel[1]) && (y <= KeyCancel[3])) //press CANCEL
        {
          hlightButton("CANCEL", KeyCancel[0], KeyCancel[1], KeyCancel[2], KeyCancel[3]);
          dispScreen = 4;
          clearScreen();
          ledSetScreen();
        }
        if ((x >= KeyOK[0]) && (x <= KeyOK[2]) && (y >= KeyOK[1]) && (y <= KeyOK[3])) //press SAVE
        {
          hlightButton("SAVE", KeyOK[0], KeyOK[1], KeyOK[2], KeyOK[3]);

          switch (selectChannel)
          {
            case 1:
              for (int i = 0; i < 96; i++)
                ch1led[i] = tled[i];
              SaveToEEPROM(1);
              break;
            case 2:
              for (int i = 0; i < 96; i++)
                ch2led[i] = tled[i];
              SaveToEEPROM(2);
              break;
            case 3:
              for (int i = 0; i < 96; i++)
                ch3led[i] = tled[i];
              SaveToEEPROM(3);
              break;
            case 4:
              for (int i = 0; i < 96; i++)
                ch4led[i] = tled[i];
              SaveToEEPROM(4);
              break;
            case 5:
              for (int i = 0; i < 96; i++)
                ch5led[i] = tled[i];
              SaveToEEPROM(5);
              break;
          }
          dispScreen = 4;
          clearScreen();
          ledSetScreen();
        }

        else if ((y >= 15) && (y <= 35)) //top row with times was touched
        {
          if ((x >= 4) && (x <= 316))
          {
            int oldLCT = LedChangTime;
            LedChangTime = map(x, 4, 316, 0, 12);
            if (oldLCT != LedChangTime) //highlight touched time
            {
              printChangeLED();
              myGLCD.setColor(0, 0, 0);
              myGLCD.fillRect((oldLCT * 26) + 5, 20, (oldLCT * 26) + 29, 42);
              changeFont(SMALL, 255, 255, 0, 0, 0, 0);
              myGLCD.printNumI((oldLCT * 2), (oldLCT * 26) + 19 - (intlen(oldLCT * 2) * 4), 20);
              myGLCD.printNumI(((oldLCT * 2) + 1), (oldLCT * 26) + 19 - (intlen(oldLCT * 2) * 4), 31);
              /*myGLCD.setColor(255, 0, 0);
               myGLCD.fillRect((LedChangTime*26)+5, 20, (LedChangTime*26)+29, 42);
               changeFont(SMALL, 255, 255, 255, 255, 0, 0);
               myGLCD.printNumI((LedChangTime*2), (LedChangTime*26)+19-(intlen(LedChangTime*2)*4), 20);
               myGLCD.printNumI(((LedChangTime*2)+1), (LedChangTime*26)+19-(intlen(LedChangTime*2)*4), 31);

               for (int i=0; i<8; i++)                          //print led values for highlighted time
               {
               int k=(LedChangTime*8)+i;
               printVBar( tled[k], (i*38)+10, 44, rgbChann[selectChannel-1]);
               }*/
            }
          }
        }
        else if ((y >= 44) && (y <= 65))   //plus buttons were touched
        {
          for (int i = 0; i < 8; i++)
          {
            if ((x >= (i * 38) + 10) && (x <= (i * 38) + 29 + 10))
            {
              int k = (LedChangTime * 8) + i;
              if (tled[k] < 100)
                tled[k]++;
              printVBar( tled[k], (i * 38) + 10, 44, rgbChann[selectChannel - 1]);
            }
          }
        }
        else if ((y >= 67) && (y <= 166))
          //else if ((y>=67) && (y<=166))
        { //the bar has been touched
          for (int i = 0; i < 8; i++)
          {
            if ((x >= (i * 38) + 10) && (x <= (i * 38) + 29 + 10))
            {
              int k = (LedChangTime * 8) + i;
              tled[k] = 166 - y;
              printVBar( tled[k], (i * 38) + 10, 44, rgbChann[selectChannel - 1]);
            }
          }
        }
        else if ((y >= 168) && (y <= 190)) //minus buttons were touched
        {
          for (int i = 0; i < 8; i++)
          {
            if ((x >= (i * 38) + 10) && (x <= (i * 38) + 29 + 10))
            {
              int k = (LedChangTime * 8) + i;
              if (tled[k] > 0)
                tled[k]--;
              printVBar( tled[k], (i * 38) + 10, 44, rgbChann[selectChannel - 1]);
            }
          }
        }
        break;
    }
  }
}



void setup()
{
  initSettings();

  pinMode(ledPinCh1, OUTPUT);
  digitalWrite(ledPinCh1, LOW);
  pinMode(ledPinCh2, OUTPUT);
  digitalWrite(ledPinCh2, LOW);
  pinMode(ledPinCh3, OUTPUT);
  digitalWrite(ledPinCh3, LOW);
  pinMode(ledPinCh4, OUTPUT);
  digitalWrite(ledPinCh4, LOW);

  myGLCD.InitLCD(LANDSCAPE);
  myGLCD.clrScr();

  myTouch.InitTouch(LANDSCAPE);
  myTouch.setPrecision(PREC_MEDIUM);

  //myGLCD.drawBitmap (110, 85, 100, 75, loadsmall);
  RTC.getTime();
  if (readEEonStart)
  {
    ReadFromEEPROM();
  }

  delay(1000);

  myGLCD.setColor(255, 255, 255);
  myGLCD.drawRect(0, 0, 319, 239);
  myGLCD.fillRect(0, 226, 319, 239);
  changeFont(SMALL, 0, 0, 0, 255, 255, 255);
  myGLCD.print("Aquarium Controller", CENTER, 227);
  changeFont(SMALL, 0, 0, 0, 255, 255, 255);
  myGLCD.print("v.1.0", RIGHT, 227);
  LED_levels_output();
  clearScreen();

  mainScreen(true);
}

void loop()
{
  unsigned long currentMillis = millis();

  if (myTouch.dataAvailable())
  {
    processMyTouch();
  }

  else if (currentMillis - prevMillis5 > 5000)    //check time, temp and LED levels every 5s
  {
    prevMillis5 = currentMillis;

    RTC.getTime();
    if (dispScreen != 3)
      LED_levels_output();

    if (dispScreen == 0)
      mainScreen();
  }
  else if (currentMillis - prevMillis600 > 600000)    //back to stand by screen after 10 min
  {
    if (dispScreen != 0)
    {
      prevMillis600 = currentMillis;
      dispScreen = 0;
      clearScreen();
      mainScreen(true);
    }
  }
}

Во-первых, если код большой, надо ставить "скрыть".

Во-вторых, мне Ваш код не нужен. Помощь нужна была Вам, а не мне, но Вы не соизволили даже показать код, когда за ней обращались. А теперь просто хамите.

Обращайтесь ещё.

Странно, в чём хамство?

Вообще-то проблемный участок кода был, но Вам показалось мало...

*ну, почему они такие упоротые? ...и мстительные!

теперь возьми этот код распечатай и съешь.

Ок, исходник есть, а где описание проблемы? Да, это мой последний вопрос. Фразу "Проблема в преобразовании типа данных" можно понять как угодно, вот варианты:

1. Ошибка компиляции. Но текста ошибки компилятора не приложено, предположим не оно.

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

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

printVBar первым параметром хочет знаковое число, а byte == unsigned char, т.е. беззнаковое. Чем это может быть плохо? Тем, что в printVBar это значение сравнивается на > -1, т.е. это условие будет ВСЕГДА срабатывать, потому что на входе было беззнаковое число, т.е. число >= 0. Важно ли, что этот код будет вызываться всегда, потому что val не может быть меньше 0:

  if (val > -1)
    myGLCD.printNumI(val, x1 + 16 - (intlen(val) * 4), y1 + 66);

можно только догадываться, но как то не хочется.

PS Вместо копирования 96 байт, проще хранить указатель на массив, это не будет занимать лишних 96 байт.

  if (val > -1)
    myGLCD.printNumI(val, x1 + 16 - (intlen(val) * 4), y1 + 66);

Я так понимаю Вы поняли о чём речь и собрали 

Компиляция без ошибок.

Проблема в функции - void ledSetScreen()

Если указываю массив как

int tled[96];

 то всё нормально, если

byte tled[96];

то выдаёт всякую ерунду... Вот в этой части кода (5строка)

for (int j = 0; j < 8; j++)
    {
      a = (i * 8) + j;
      myGLCD.setColor(255, 255, 255);
      myGLCD.printNumI(tled[a], (i * 26) + 19 - (intlen(tled[a]) * 4), (j * 16) + 49);
      myGLCD.setColor(100, 100, 100);
      myGLCD.drawRect((i * 26) + 4, (j * 16) + 47, (i * 26) + 30, (j * 16) + 63);
    }

Это можно увидеть когда задаёшь значения по каналам, к примеру "Сh 1" --> "CHANGE" --> задаём значения --> SAVE -- > (значения изменились) --> BACK --> "Ch 3" --> (и вот на этом экране видим значения от предыдущего канала, а должны быть от 3-го канала)