//---------------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop

#include "Main.h"               // переменные для работы с главной формой
#include "LogFunctions.h"       // переменные для отправки сообщений в лог
#include "PortFunctions.h"      // переменные для функций работы с портом
#include "FormFunctions.h"      // переменные для работы с формой
#include "About.h"              // для использования окна About
#include "ProgressBar.h"        // для использования прогресс-бара
#include "LockFuses.h"          // для использования окна LockFusesForm
#include "ChipFunctions.h"      // переменные для работы с чипом
#include "AVRFunctions.h"       // переменные для работы с чипами AVR
#include "ATtiny2313.h"         // переменные для работы с ATtiny2313
#include "AT90S1200.h"          // переменные для работы с AT90S1200
#include "AT90S2313.h"          // переменные для работы с AT90S2313
#include "AT90S2323.h"          // переменные для работы с AT90S2323
#include "AT90S2343.h"          // переменные для работы с AT90S2343
#include "AT90S2333.h"          // переменные для работы с AT90S2333 / AT90S4433
#include "AT90S4414.h"          // переменные для работы с AT90S4414 / AT90S8515
#include "AT90S4434.h"          // переменные для работы с AT90S4434 / AT90S8535
#include "AT90CAN32.h"          // переменные для работы с чипами AT90CAN32 / AT90CAN64 / AT90CAN128
#include "ATtiny12.h"           // переменные для работы с чипами ATtiny12
#include "ATtiny13.h"           // переменные для работы с чипами ATtiny13
#include "ATtiny15.h"           // переменные для работы с чипами ATtiny15
#include "ATtiny22.h"           // переменные для работы с ATtiny22
#include "ATtiny25.h"           // переменные для работы с чипами ATtiny25 / ATtiny45 / ATtiny85
#include "ATtiny26.h"           // переменные для работы с чипами ATtiny26
#include "ATtiny261.h"          // переменные для работы с чипами ATtiny261 / ATtiny461 / ATtiny861
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
//---------------------------------------------------------------------------
//--- ГЛОБАЛЬНЫЕ ПЕРЕМЕННЫЕ -------------------------------------------------
//---------------------------------------------------------------------------
TForm1 *Form1;                  // главная форма
unsigned int Delays;            // здесь будем хранить величину задержек для замедления обмена
//---------------------------------------------------------------------------
//--- ОТКРЫТИЕ ВЫБРАННОГО COM-ПОРТА -----------------------------------------
//---------------------------------------------------------------------------
void OpenPort()
{ //откроем выбранный порт. Чтобы открыть порт на nt-платформе надо указывать
  // "\\.\PortName", в СИ для печати символа \ надо его указывать 2 раза
  char PortName[100]="\\\\.\\";
  strcat(PortName,Form1->ComboBox1->Text.c_str());
  OpenCom(PortName);                            // само открытие порта происходит здесь
  if(Port!=INVALID_HANDLE_VALUE)
  { EnableButtons();                            // включаем кнопки управления, выключаем кнопку Connect
    SendMsgToLog(1,AnsiString(PortName));       // открыт COM-порт
  }
}
//---------------------------------------------------------------------------
//--- ЗАКРЫТИЕ ВЫБРАННОГО COM-ПОРТА -----------------------------------------
//---------------------------------------------------------------------------
void ClosePort()
{ CloseHandle(Port);
  Port=INVALID_HANDLE_VALUE;
  DisableButtons();                     // выключаем кнопки управления, включаем кнопку Connect
  SendMsgToLog(3,"");                   // COM-порт закрыт
}
//---------------------------------------------------------------------------
//--- КОНСТРУИРОВАНИЕ ГЛАВНОЙ ФОРМЫ -----------------------------------------
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
        : TForm(Owner)
{ DisableButtons();                                     // выключаем кнопки управления, включаем кнопку Connect
  Form1->AutoSize               = true;                 // устанавливаем авторазмер формы
  Port                          = INVALID_HANDLE_VALUE; // никакой порт не открыт
  SelectedChip.ID               = 0;                    // не выбран ни один чип
  Delays = Form1->TrackBar1->Position;                  // получаем значение задержек
}
//---------------------------------------------------------------------------
//--- КНОПКА ОТКРЫТИЯ COM-ПОРТА ---------------------------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::Button1Click(TObject *Sender)
{ OpenPort();
}
//---------------------------------------------------------------------------
//--- КНОПКА ЗАКРЫТИЯ COM-ПОРТА ---------------------------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::Button2Click(TObject *Sender)
{ ClosePort();
}
//---------------------------------------------------------------------------
//--- ЕСЛИ ПОМЕНЯЛИ ВЫБРАННЫЙ COM-ПОРТ --------------------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::ComboBox1Change(TObject *Sender)
{ // если порт открыт, то его надо закрыть
  if(Port!=INVALID_HANDLE_VALUE) ClosePort();
}
//---------------------------------------------------------------------------
//--- ВЫБРАЛИ В МЕНЮ ПУНКТ EXIT ---------------------------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::Exit1Click(TObject *Sender)
{ if(Port!=INVALID_HANDLE_VALUE) ClosePort();
  Close();
}
//---------------------------------------------------------------------------
//--- ЧЕРЕЗ ВЕРХНЕЕ МЕНЮ ВЫБРАНО СОХРАНЕНИЕ ЛОГА ----------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::SaveLogas1Click(TObject *Sender)
{ AnsiString FilePath;                                  // полный путь к файлу

  if(SaveDialog1->Execute())                            // если определились куда сохранять (не нажали отмена)
  { FilePath=SaveDialog1->FileName;                     // получаем имя файла для сохранения (с путём)
    Form1->RichEdit5->Lines->SaveToFile(FilePath);      // сохраняем в него данные из RichEdit5
    SendMsgToLog(8,FilePath);                           // выводим в лог сообщение о сохранении
  }
}
//---------------------------------------------------------------------------
//--- ВЫБРАЛИ В МЕНЮ ПУНКТ ABOUT --------------------------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::About1Click(TObject *Sender)
{ AboutBox->Show();
}
//---------------------------------------------------------------------------
//--- ВЫБРАЛИ В МЕНЮ ПУНКТ LOCK & FUSES... ----------------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::LockFuses1Click(TObject *Sender)
{ Application->CreateForm(__classid(TLockFusesForm),&LockFusesForm);    // создаём форму с фьюзами
  LockFusesForm->ShowModal();                                           // показываем её в модальном окне
  LockFusesForm->Free();                                                // уничтожаем форму после закрытия
}
//---------------------------------------------------------------------------
void __fastcall TForm1::RichEditsKeyPress(TObject *Sender, char &Key)
{  Key=0;
}
//---------------------------------------------------------------------------
//--- РЕДАКТИРОВАНИЕ ПОЛЯ ID BYTES ------------------------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::Edit2KeyDown(TObject *Sender, WORD &Key,
      TShiftState Shift)
{ char *Charset1="0123456789abcdefABCDEF";      // допустимые символы
  char Symbol;                                  // символ для замены
  int Position;                                 // позиция курсора

  Position=Form1->Edit2->SelStart;              // позиция курсора в тексте
  switch(Key)
  { // обработчик backspace ***********************************
    case 8:     Position-=1;                            // уменьшаем позицию
                if(Position<0)       Position=8;       // если позиция <0, то переходим в начало строки
                else if(Position%3!=2)                  // если новая позиция не перед пробелом
                { Form1->Edit2->SelStart=Position;      // устанавливаем курсор
                  Form1->Edit2->SelLength=1;            // выделяем 1 символ
                  Symbol=0x46;                          // будем писать символ F
                  Form1->Edit2->SelText=Symbol;         // пишем
                }
                // устанавливаем курсор в нужную позицию
                Form1->Edit2->SelStart=Position;      // ставим курсор в нужную позицию
                Form1->Edit2->SelLength=0;            // отменяем выделение
                break;
    // обработчик стрелок *************************************
     case 0x25:
     case 0x26:
     case 0x27:
     case 0x28: return;
     // обработчик delete **************************************
     case 0x2E: Key=0x46;                    // заменяем на F, а дальше как все остальные вводы
     // обработчик всех остальных кнопок ***********************
     default:   if(Position>7)       Position=-1;             // если позиция >22, то переходим в начало строки
                else if(strchr(Charset1,Key)&&Position%3!=2)  // если символ есть в наборе и позиция не перед пробелом
                { Form1->Edit2->SelStart=Position;            // ставим курсор в нужную позицию
                  Form1->Edit2->SelLength=1;                  // выделяем 1 символ
                  Symbol=Key;
                  Form1->Edit2->SelText=Symbol;               // пишем туда введённый символ
                  Form1->Edit2->SelStart=Position;            // ставим курсор в нужную позицию
                  Form1->Edit2->SelLength=1;                  // выделяем 1 символ
                  Form1->Edit2->SelText=UpperCase(Form1->Edit2->SelText); // переводим введённый символ в верхний регистр
                }
                // устанавливаем курсор в нужную позицию
                Position+=1;                          // увеличиваем позицию курсора
                Form1->Edit2->SelStart=Position;      // ставим курсор в нужную позицию
                Form1->Edit2->SelLength=0;            // отменяем выделение
  }
  Key=0;
}
//---------------------------------------------------------------------------
//--- РЕДАКТИРОВАНИЕ ПОЛЯ RICHEDIT1 (Area 1) --------------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::RichEdit1KeyDown(TObject *Sender, WORD &Key,
      TShiftState Shift)
{ char *Charset1="0123456789abcdefABCDEF";              // допустимые символы
  char Symbol;                                          // символ для замены
  int  PositionGlobal, LineNumber, PositionLocal;       // глобальная позиция, номер строки, позиция в строке
  int  MaxLineNumber, CharPos;                          // максимальный номер строки, позиция символа на другой стороне
  char *InHexBuf, TempBuf[1], OutHexBuf[3];             // для преобразования
  AnsiString SubStr;                                    // для преобразования

  PositionGlobal=Form1->RichEdit1->SelStart;            // глобальная позиция курсора в тексте
  LineNumber=PositionGlobal/82;                         // номер строки, в которой находится курсор  80 символов + CR+LF
  PositionLocal=PositionGlobal-82*LineNumber;           // позиция курсора в строке
  MaxLineNumber=(FormData.RE1Size-1)/16;                // максимальный номер строки
  switch(Key)
  { // обработчик backspace ***********************************
    case 8:     PositionLocal-=1;                       // уменьшаем позицию в строке
                if(PositionLocal<10)
                { PositionLocal=57;                     // если позиция <6, то переходим в начало предыдущей строки
                  LineNumber-=1;
                  if(LineNumber<0)                      // если номер строки <0
                        LineNumber=MaxLineNumber;       // переходим на последнюю строку
                }
                else if(PositionLocal<57)               // если новая позиция в области hex
                { if ((PositionLocal-10)%3!=2)           // если новая позиция не перед пробелом
                  { // меняем область слева
                    Form1->RichEdit1->SelStart=LineNumber*82+PositionLocal;     // устанавливаем курсор
                    Form1->RichEdit1->SelLength=1;      // выделяем 1 символ
                    Symbol=0x46;                        // будем писать символ F
                    Form1->RichEdit1->SelText=Symbol;   // пишем
                    // получаем символ, который будем писать в область справа
                    CharPos=(PositionLocal-10)/3;        // номер байта в строке, который нужно поменять
                    Form1->RichEdit1->SelStart=82*LineNumber+10+3*CharPos;       // ставим курсор на начало байта (в области слева)
                    Form1->RichEdit1->SelLength=2;                              // выделяем 2 символа
                    SubStr=LowerCase(Form1->RichEdit1->SelText);                // получаем их в строку
                    InHexBuf=SubStr.c_str();            //скопировать в буфер байт для передачи (в виде строки)
                    HexToBin(InHexBuf,TempBuf,1);       //преобразовать строку в целое (байт)
                    Key=TempBuf[0];
                    if(Key<0x1F) Symbol=0x1F;           //заменяем непечатные (TempBuf[0] сравнивать нельзя так как он знаковый)
                    else         Symbol=TempBuf[0];
                    // меняем область справа
                    Form1->RichEdit1->SelStart=LineNumber*82+64+CharPos;        // устанавливаем курсор
                    Form1->RichEdit1->SelLength=1;      // выделяем 1 символ
                    Form1->RichEdit1->SelText=Symbol;   // пишем туда полученный символ
                  }
                }
                else if(PositionLocal<64)               // если мы между правой и левой областями
                { PositionLocal=80;                     // если позиция <36, то переходим в начало предыдущей строки
                  LineNumber-=1;
                  if(LineNumber<0)                      // если номер строки <0
                        LineNumber=MaxLineNumber;       // переходим на последнюю строку
                }
                else                                    // если мы в области справа
                { // меняем область справа
                  Form1->RichEdit1->SelStart=LineNumber*82+PositionLocal;       // устанавливаем курсор
                  Form1->RichEdit1->SelLength=1;        // выделяем 1 символ
                  Symbol=0xFF;                          // будем писать символ я
                  Form1->RichEdit1->SelText=Symbol;     // пишем
                  // получаем символ, который будем менять
                  CharPos=PositionLocal-64;             // номер байта в строке, который нужно поменять
                  // меняем область слева
                  Form1->RichEdit1->SelStart=LineNumber*82+10+3*CharPos;         // устанавливаем курсор
                  Form1->RichEdit1->SelLength=2;        // выделяем 2 символа
                  Form1->RichEdit1->SelText="FF";       // пишем
                }
                // устанавливаем курсор в нужную позицию
                Form1->RichEdit1->SelStart=LineNumber*82+PositionLocal;         // ставим курсор в нужную позицию
                Form1->RichEdit1->SelLength=0;                                  // отменяем выделение
                break;
    // обработчик стрелок *************************************
     case 0x25:
     case 0x26:
     case 0x27:
     case 0x28: return;
     // обработчик delete **************************************
     case 0x2E: // если мы в области слева - заменяем на F
                if((PositionLocal>9) && (PositionLocal<57))
                {       Key=0x46;                    // заменяем символ слева на F
                }
                // если мы в области справа - заменяем на я
                if(PositionLocal>63)
                {       Key=0xFF;                    // заменяем символ справа на F
                }

     // обработчик всех остальных кнопок ***********************
     default:   if(PositionLocal>79)            // если позиция > 43
                { PositionLocal=63;             // то переходим в начало строки
                  LineNumber+=1;                // увеличиваем номер строки
                  if(LineNumber>MaxLineNumber)
                        LineNumber=0;           // если номер > максимального - переходим на первую строку
                }
                else if(PositionLocal>63)       // если позиция > 35
                { // меняем область справа
                  Form1->RichEdit1->SelStart=LineNumber*82+PositionLocal;       // ставим курсор в нужную позицию
                  Form1->RichEdit1->SelLength=1;                                // выделяем 1 символ
                  if(Key<0x1F)  Key=0x1F;                                       // если символ непечатный (спецсимвол) - заменяем
                  Symbol=Key;
                  Form1->RichEdit1->SelText=Symbol;                             // пишем туда введённый символ
                  Form1->RichEdit1->SelStart=LineNumber*82+PositionLocal;       // ставим курсор в нужную позицию
                  Form1->RichEdit1->SelLength=1;                                // выделяем 1 символ
                  Form1->RichEdit1->SelText=UpperCase(Form1->RichEdit1->SelText); // переводим введённый символ в верхний регистр
                  // получаем символ, который будем менять
                  CharPos=PositionLocal-64;             // номер байта в строке, который нужно поменять
                  TempBuf[0]=Key;
                  BinToHex(TempBuf,OutHexBuf,1);        //преобразовать строку в целое (байт)
                  OutHexBuf[2]=0;                       //строка должна заканчиваться нулём
                  // меняем область слева
                  Form1->RichEdit1->SelStart=LineNumber*82+10+3*CharPos;         // ставим курсор на начало байт
                  Form1->RichEdit1->SelLength=2;                                // выделяем 2 символа
                  Form1->RichEdit1->SelText=OutHexBuf;
                }
                else if(PositionLocal>56)       // если позиция >52,
                { PositionLocal=9;              // то переходим в начало строки
                  LineNumber+=1;                // увеличиваем номер строки
                  if(LineNumber>MaxLineNumber)
                        LineNumber=0;           // если номер > максимального - переходим на первую строку
                }
                else if(PositionLocal>9)        // если позиция > 5
                { if(strchr(Charset1,Key)&&((PositionLocal-10)%3!=2))            // если символ есть в наборе и позиция не перед пробелом
                  { // меняем область слева
                    Form1->RichEdit1->SelStart=LineNumber*82+PositionLocal;     // ставим курсор в нужную позицию
                    Form1->RichEdit1->SelLength=1;                              // выделяем 1 символ
                    Symbol=Key;
                    Form1->RichEdit1->SelText=Symbol;                           // пишем туда введённый символ
                    Form1->RichEdit1->SelStart=LineNumber*82+PositionLocal;     // ставим курсор в нужную позицию
                    Form1->RichEdit1->SelLength=1;                              // выделяем 1 символ
                    Form1->RichEdit1->SelText=UpperCase(Form1->RichEdit1->SelText);     // переводим введённый символ в верхний регистр
                    // получаем символ, который будем писать в область справа
                    CharPos=(PositionLocal-10)/3;        // номер байта в строке, который нужно поменять
                    Form1->RichEdit1->SelStart=82*LineNumber+10+3*CharPos;       // ставим курсор на начало байта (в области слева)
                    Form1->RichEdit1->SelLength=2;                              // выделяем 2 символа
                    SubStr=LowerCase(Form1->RichEdit1->SelText);                // получаем их в строку
                    InHexBuf=SubStr.c_str();            //скопировать в буфер байт для передачи (в виде строки)
                    HexToBin(InHexBuf,TempBuf,1);       //преобразовать строку в целое (байт)
                    Key=TempBuf[0];
                    if(Key<0x1F) Symbol=0x1F;           //заменяем непечатные
                    else         Symbol=TempBuf[0];
                    // меняем область справа
                    Form1->RichEdit1->SelStart=LineNumber*82+64+CharPos;        // устанавливаем курсор
                    Form1->RichEdit1->SelLength=1;      // выделяем 1 символ
                    Form1->RichEdit1->SelText=Symbol;   // пишем туда полученный символ
                  }
                }
                else    PositionLocal=9;        // переходим в начало строки
                // устанавливаем курсор в нужную позицию
                PositionLocal+=1;                                       // увеличиваем позицию курсора
                Form1->RichEdit1->SelStart=LineNumber*82+PositionLocal; // ставим курсор в нужную позицию
                Form1->RichEdit1->SelLength=0;                          // отменяем выделение
  }
  Key=0;
}
//---------------------------------------------------------------------------
//--- РЕДАКТИРОВАНИЕ ПОЛЯ RICHEDIT2 (Area 2) --------------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::RichEdit2KeyDown(TObject *Sender, WORD &Key,
      TShiftState Shift)
{ char *Charset1="0123456789abcdefABCDEF";              // допустимые символы
  char Symbol;                                          // символ для замены
  int  PositionGlobal, LineNumber, PositionLocal;       // глобальная позиция, номер строки, позиция в строке
  int  MaxLineNumber, CharPos;                          // максимальный номер строки, позиция символа на другой стороне
  char *InHexBuf, TempBuf[1], OutHexBuf[3];             // для преобразования
  AnsiString SubStr;                                    // для преобразования

  PositionGlobal=Form1->RichEdit2->SelStart;            // глобальная позиция курсора в тексте
  LineNumber=PositionGlobal/82;                         // номер строки, в которой находится курсор  80 символов + CR+LF
  PositionLocal=PositionGlobal-82*LineNumber;           // позиция курсора в строке
  MaxLineNumber=(FormData.RE2Size-1)/16;                // максимальный номер строки
  switch(Key)
  { // обработчик backspace ***********************************
    case 8:     PositionLocal-=1;                       // уменьшаем позицию в строке
                if(PositionLocal<10)
                { PositionLocal=57;                     // если позиция <6, то переходим в начало предыдущей строки
                  LineNumber-=1;
                  if(LineNumber<0)                      // если номер строки <0
                        LineNumber=MaxLineNumber;       // переходим на последнюю строку
                }
                else if(PositionLocal<57)               // если новая позиция в области hex
                { if ((PositionLocal-10)%3!=2)           // если новая позиция не перед пробелом
                  { // меняем область слева
                    Form1->RichEdit2->SelStart=LineNumber*82+PositionLocal;     // устанавливаем курсор
                    Form1->RichEdit2->SelLength=1;      // выделяем 1 символ
                    Symbol=0x46;                        // будем писать символ F
                    Form1->RichEdit2->SelText=Symbol;   // пишем
                    // получаем символ, который будем писать в область справа
                    CharPos=(PositionLocal-10)/3;        // номер байта в строке, который нужно поменять
                    Form1->RichEdit2->SelStart=82*LineNumber+10+3*CharPos;       // ставим курсор на начало байта (в области слева)
                    Form1->RichEdit2->SelLength=2;                              // выделяем 2 символа
                    SubStr=LowerCase(Form1->RichEdit2->SelText);                // получаем их в строку
                    InHexBuf=SubStr.c_str();            //скопировать в буфер байт для передачи (в виде строки)
                    HexToBin(InHexBuf,TempBuf,1);       //преобразовать строку в целое (байт)
                    Key=TempBuf[0];
                    if(Key<0x1F) Symbol=0x1F;           //заменяем непечатные (TempBuf[0] сравнивать нельзя так как он знаковый)
                    else         Symbol=TempBuf[0];
                    // меняем область справа
                    Form1->RichEdit2->SelStart=LineNumber*82+64+CharPos;        // устанавливаем курсор
                    Form1->RichEdit2->SelLength=1;      // выделяем 1 символ
                    Form1->RichEdit2->SelText=Symbol;   // пишем туда полученный символ
                  }
                }
                else if(PositionLocal<64)               // если мы между правой и левой областями
                { PositionLocal=80;                     // если позиция <36, то переходим в начало предыдущей строки
                  LineNumber-=1;
                  if(LineNumber<0)                      // если номер строки <0
                        LineNumber=MaxLineNumber;       // переходим на последнюю строку
                }
                else                                    // если мы в области справа
                { // меняем область справа
                  Form1->RichEdit2->SelStart=LineNumber*82+PositionLocal;       // устанавливаем курсор
                  Form1->RichEdit2->SelLength=1;        // выделяем 1 символ
                  Symbol=0xFF;                          // будем писать символ я
                  Form1->RichEdit2->SelText=Symbol;     // пишем
                  // получаем символ, который будем менять
                  CharPos=PositionLocal-64;             // номер байта в строке, который нужно поменять
                  // меняем область слева
                  Form1->RichEdit2->SelStart=LineNumber*82+10+3*CharPos;         // устанавливаем курсор
                  Form1->RichEdit2->SelLength=2;        // выделяем 2 символа
                  Form1->RichEdit2->SelText="FF";       // пишем
                }
                // устанавливаем курсор в нужную позицию
                Form1->RichEdit2->SelStart=LineNumber*82+PositionLocal;         // ставим курсор в нужную позицию
                Form1->RichEdit2->SelLength=0;                                  // отменяем выделение
                break;
    // обработчик стрелок *************************************
     case 0x25:
     case 0x26:
     case 0x27:
     case 0x28: return;
     // обработчик delete **************************************
     case 0x2E: // если мы в области слева - заменяем на F
                if((PositionLocal>9) && (PositionLocal<57))
                {       Key=0x46;                    // заменяем символ слева на F
                }
                // если мы в области справа - заменяем на я
                if(PositionLocal>63)
                {       Key=0xFF;                    // заменяем символ справа на F
                }

     // обработчик всех остальных кнопок ***********************
     default:   if(PositionLocal>79)            // если позиция > 43
                { PositionLocal=63;             // то переходим в начало строки
                  LineNumber+=1;                // увеличиваем номер строки
                  if(LineNumber>MaxLineNumber)
                        LineNumber=0;           // если номер > максимального - переходим на первую строку
                }
                else if(PositionLocal>63)       // если позиция > 35
                { // меняем область справа
                  Form1->RichEdit2->SelStart=LineNumber*82+PositionLocal;       // ставим курсор в нужную позицию
                  Form1->RichEdit2->SelLength=1;                                // выделяем 1 символ
                  if(Key<0x1F)  Key=0x1F;                                       // если символ непечатный (спецсимвол) - заменяем
                  Symbol=Key;
                  Form1->RichEdit2->SelText=Symbol;                             // пишем туда введённый символ
                  Form1->RichEdit2->SelStart=LineNumber*82+PositionLocal;       // ставим курсор в нужную позицию
                  Form1->RichEdit2->SelLength=1;                                // выделяем 1 символ
                  Form1->RichEdit2->SelText=UpperCase(Form1->RichEdit2->SelText); // переводим введённый символ в верхний регистр
                  // получаем символ, который будем менять
                  CharPos=PositionLocal-64;             // номер байта в строке, который нужно поменять
                  TempBuf[0]=Key;
                  BinToHex(TempBuf,OutHexBuf,1);        //преобразовать строку в целое (байт)
                  OutHexBuf[2]=0;                       //строка должна заканчиваться нулём
                  // меняем область слева
                  Form1->RichEdit2->SelStart=LineNumber*82+10+3*CharPos;         // ставим курсор на начало байт
                  Form1->RichEdit2->SelLength=2;                                // выделяем 2 символа
                  Form1->RichEdit2->SelText=OutHexBuf;
                }
                else if(PositionLocal>56)       // если позиция >52,
                { PositionLocal=9;              // то переходим в начало строки
                  LineNumber+=1;                // увеличиваем номер строки
                  if(LineNumber>MaxLineNumber)
                        LineNumber=0;           // если номер > максимального - переходим на первую строку
                }
                else if(PositionLocal>9)        // если позиция > 5
                { if(strchr(Charset1,Key)&&((PositionLocal-10)%3!=2))            // если символ есть в наборе и позиция не перед пробелом
                  { // меняем область слева
                    Form1->RichEdit2->SelStart=LineNumber*82+PositionLocal;     // ставим курсор в нужную позицию
                    Form1->RichEdit2->SelLength=1;                              // выделяем 1 символ
                    Symbol=Key;
                    Form1->RichEdit2->SelText=Symbol;                           // пишем туда введённый символ
                    Form1->RichEdit2->SelStart=LineNumber*82+PositionLocal;     // ставим курсор в нужную позицию
                    Form1->RichEdit2->SelLength=1;                              // выделяем 1 символ
                    Form1->RichEdit2->SelText=UpperCase(Form1->RichEdit2->SelText);     // переводим введённый символ в верхний регистр
                    // получаем символ, который будем писать в область справа
                    CharPos=(PositionLocal-10)/3;        // номер байта в строке, который нужно поменять
                    Form1->RichEdit2->SelStart=82*LineNumber+10+3*CharPos;       // ставим курсор на начало байта (в области слева)
                    Form1->RichEdit2->SelLength=2;                              // выделяем 2 символа
                    SubStr=LowerCase(Form1->RichEdit2->SelText);                // получаем их в строку
                    InHexBuf=SubStr.c_str();            //скопировать в буфер байт для передачи (в виде строки)
                    HexToBin(InHexBuf,TempBuf,1);       //преобразовать строку в целое (байт)
                    Key=TempBuf[0];
                    if(Key<0x1F) Symbol=0x1F;           //заменяем непечатные
                    else         Symbol=TempBuf[0];
                    // меняем область справа
                    Form1->RichEdit2->SelStart=LineNumber*82+64+CharPos;        // устанавливаем курсор
                    Form1->RichEdit2->SelLength=1;      // выделяем 1 символ
                    Form1->RichEdit2->SelText=Symbol;   // пишем туда полученный символ
                  }
                }
                else    PositionLocal=9;        // переходим в начало строки
                // устанавливаем курсор в нужную позицию
                PositionLocal+=1;                                       // увеличиваем позицию курсора
                Form1->RichEdit2->SelStart=LineNumber*82+PositionLocal; // ставим курсор в нужную позицию
                Form1->RichEdit2->SelLength=0;                          // отменяем выделение
  }
  Key=0;
}
//---------------------------------------------------------------------------
//--- РЕДАКТИРОВАНИЕ ПОЛЯ RICHEDIT3 (Area 3) --------------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::RichEdit3KeyDown(TObject *Sender, WORD &Key,
      TShiftState Shift)
{ char *Charset1="0123456789abcdefABCDEF";              // допустимые символы
  char Symbol;                                          // символ для замены
  int  PositionGlobal, LineNumber, PositionLocal;       // глобальная позиция, номер строки, позиция в строке
  int  MaxLineNumber, CharPos;                          // максимальный номер строки, позиция символа на другой стороне
  char *InHexBuf, TempBuf[1], OutHexBuf[3];             // для преобразования
  AnsiString SubStr;                                    // для преобразования

  PositionGlobal=Form1->RichEdit3->SelStart;            // глобальная позиция курсора в тексте
  LineNumber=PositionGlobal/82;                         // номер строки, в которой находится курсор  76 символов + CR+LF
  PositionLocal=PositionGlobal-82*LineNumber;           // позиция курсора в строке
  MaxLineNumber=(FormData.RE3Size-1)/16;                // максимальный номер строки
  switch(Key)
  { // обработчик backspace ***********************************
    case 8:     PositionLocal-=1;                       // уменьшаем позицию в строке
                if(PositionLocal<10)
                { PositionLocal=57;                     // если позиция <6, то переходим в начало предыдущей строки
                  LineNumber-=1;
                  if(LineNumber<0)                      // если номер строки <0
                        LineNumber=MaxLineNumber;       // переходим на последнюю строку
                }
                else if(PositionLocal<57)               // если новая позиция в области hex
                { if ((PositionLocal-10)%3!=2)           // если новая позиция не перед пробелом
                  { // меняем область слева
                    Form1->RichEdit3->SelStart=LineNumber*82+PositionLocal;     // устанавливаем курсор
                    Form1->RichEdit3->SelLength=1;      // выделяем 1 символ
                    Symbol=0x46;                        // будем писать символ F
                    Form1->RichEdit3->SelText=Symbol;   // пишем
                    // получаем символ, который будем писать в область справа
                    CharPos=(PositionLocal-10)/3;        // номер байта в строке, который нужно поменять
                    Form1->RichEdit3->SelStart=82*LineNumber+10+3*CharPos;       // ставим курсор на начало байта (в области слева)
                    Form1->RichEdit3->SelLength=2;                              // выделяем 2 символа
                    SubStr=LowerCase(Form1->RichEdit3->SelText);                // получаем их в строку
                    InHexBuf=SubStr.c_str();            //скопировать в буфер байт для передачи (в виде строки)
                    HexToBin(InHexBuf,TempBuf,1);       //преобразовать строку в целое (байт)
                    Key=TempBuf[0];
                    if(Key<0x1F) Symbol=0x1F;           //заменяем непечатные (TempBuf[0] сравнивать нельзя так как он знаковый)
                    else         Symbol=TempBuf[0];
                    // меняем область справа
                    Form1->RichEdit3->SelStart=LineNumber*82+64+CharPos;        // устанавливаем курсор
                    Form1->RichEdit3->SelLength=1;      // выделяем 1 символ
                    Form1->RichEdit3->SelText=Symbol;   // пишем туда полученный символ
                  }
                }
                else if(PositionLocal<64)               // если мы между правой и левой областями
                { PositionLocal=80;                     // если позиция <36, то переходим в начало предыдущей строки
                  LineNumber-=1;
                  if(LineNumber<0)                      // если номер строки <0
                        LineNumber=MaxLineNumber;       // переходим на последнюю строку
                }
                else                                    // если мы в области справа
                { // меняем область справа
                  Form1->RichEdit3->SelStart=LineNumber*82+PositionLocal;       // устанавливаем курсор
                  Form1->RichEdit3->SelLength=1;        // выделяем 1 символ
                  Symbol=0xFF;                          // будем писать символ я
                  Form1->RichEdit3->SelText=Symbol;     // пишем
                  // получаем символ, который будем менять
                  CharPos=PositionLocal-64;             // номер байта в строке, который нужно поменять
                  // меняем область слева
                  Form1->RichEdit3->SelStart=LineNumber*82+10+3*CharPos;         // устанавливаем курсор
                  Form1->RichEdit3->SelLength=2;        // выделяем 2 символа
                  Form1->RichEdit3->SelText="FF";       // пишем
                }
                // устанавливаем курсор в нужную позицию
                Form1->RichEdit3->SelStart=LineNumber*82+PositionLocal;         // ставим курсор в нужную позицию
                Form1->RichEdit3->SelLength=0;                                  // отменяем выделение
                break;
    // обработчик стрелок *************************************
     case 0x25:
     case 0x26:
     case 0x27:
     case 0x28: return;
     // обработчик delete **************************************
     case 0x2E: // если мы в области слева - заменяем на F
                if((PositionLocal>9) && (PositionLocal<57))
                {       Key=0x46;                    // заменяем символ слева на F
                }
                // если мы в области справа - заменяем на я
                if(PositionLocal>63)
                {       Key=0xFF;                    // заменяем символ справа на F
                }

     // обработчик всех остальных кнопок ***********************
     default:   if(PositionLocal>79)            // если позиция > 43
                { PositionLocal=63;             // то переходим в начало строки
                  LineNumber+=1;                // увеличиваем номер строки
                  if(LineNumber>MaxLineNumber)
                        LineNumber=0;           // если номер > максимального - переходим на первую строку
                }
                else if(PositionLocal>63)       // если позиция > 35
                { // меняем область справа
                  Form1->RichEdit3->SelStart=LineNumber*82+PositionLocal;       // ставим курсор в нужную позицию
                  Form1->RichEdit3->SelLength=1;                                // выделяем 1 символ
                  if(Key<0x1F)  Key=0x1F;                                       // если символ непечатный (спецсимвол) - заменяем
                  Symbol=Key;
                  Form1->RichEdit3->SelText=Symbol;                             // пишем туда введённый символ
                  Form1->RichEdit3->SelStart=LineNumber*82+PositionLocal;       // ставим курсор в нужную позицию
                  Form1->RichEdit3->SelLength=1;                                // выделяем 1 символ
                  Form1->RichEdit3->SelText=UpperCase(Form1->RichEdit3->SelText); // переводим введённый символ в верхний регистр
                  // получаем символ, который будем менять
                  CharPos=PositionLocal-64;             // номер байта в строке, который нужно поменять
                  TempBuf[0]=Key;
                  BinToHex(TempBuf,OutHexBuf,1);        //преобразовать строку в целое (байт)
                  OutHexBuf[2]=0;                       //строка должна заканчиваться нулём
                  // меняем область слева
                  Form1->RichEdit3->SelStart=LineNumber*82+10+3*CharPos;         // ставим курсор на начало байт
                  Form1->RichEdit3->SelLength=2;                                // выделяем 2 символа
                  Form1->RichEdit3->SelText=OutHexBuf;
                }
                else if(PositionLocal>56)       // если позиция >52,
                { PositionLocal=9;              // то переходим в начало строки
                  LineNumber+=1;                // увеличиваем номер строки
                  if(LineNumber>MaxLineNumber)
                        LineNumber=0;           // если номер > максимального - переходим на первую строку
                }
                else if(PositionLocal>9)        // если позиция > 5
                { if(strchr(Charset1,Key)&&((PositionLocal-10)%3!=2))            // если символ есть в наборе и позиция не перед пробелом
                  { // меняем область слева
                    Form1->RichEdit3->SelStart=LineNumber*82+PositionLocal;     // ставим курсор в нужную позицию
                    Form1->RichEdit3->SelLength=1;                              // выделяем 1 символ
                    Symbol=Key;
                    Form1->RichEdit3->SelText=Symbol;                           // пишем туда введённый символ
                    Form1->RichEdit3->SelStart=LineNumber*82+PositionLocal;     // ставим курсор в нужную позицию
                    Form1->RichEdit3->SelLength=1;                              // выделяем 1 символ
                    Form1->RichEdit3->SelText=UpperCase(Form1->RichEdit3->SelText);     // переводим введённый символ в верхний регистр
                    // получаем символ, который будем писать в область справа
                    CharPos=(PositionLocal-10)/3;        // номер байта в строке, который нужно поменять
                    Form1->RichEdit3->SelStart=82*LineNumber+10+3*CharPos;       // ставим курсор на начало байта (в области слева)
                    Form1->RichEdit3->SelLength=2;                              // выделяем 2 символа
                    SubStr=LowerCase(Form1->RichEdit3->SelText);                // получаем их в строку
                    InHexBuf=SubStr.c_str();            //скопировать в буфер байт для передачи (в виде строки)
                    HexToBin(InHexBuf,TempBuf,1);       //преобразовать строку в целое (байт)
                    Key=TempBuf[0];
                    if(Key<0x1F) Symbol=0x1F;           //заменяем непечатные
                    else         Symbol=TempBuf[0];
                    // меняем область справа
                    Form1->RichEdit3->SelStart=LineNumber*82+64+CharPos;        // устанавливаем курсор
                    Form1->RichEdit3->SelLength=1;      // выделяем 1 символ
                    Form1->RichEdit3->SelText=Symbol;   // пишем туда полученный символ
                  }
                }
                else    PositionLocal=9;        // переходим в начало строки
                // устанавливаем курсор в нужную позицию
                PositionLocal+=1;                                       // увеличиваем позицию курсора
                Form1->RichEdit3->SelStart=LineNumber*82+PositionLocal; // ставим курсор в нужную позицию
                Form1->RichEdit3->SelLength=0;                          // отменяем выделение
  }
  Key=0;
}
//---------------------------------------------------------------------------
//--- РЕДАКТИРОВАНИЕ ПОЛЯ RICHEDIT4 (Area 4) --------------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::RichEdit4KeyDown(TObject *Sender, WORD &Key,
      TShiftState Shift)
{ char *Charset1="0123456789abcdefABCDEF";              // допустимые символы
  char Symbol;                                          // символ для замены
  int  PositionGlobal, LineNumber, PositionLocal;       // глобальная позиция, номер строки, позиция в строке
  int  MaxLineNumber, CharPos;                          // максимальный номер строки, позиция символа на другой стороне
  char *InHexBuf, TempBuf[1], OutHexBuf[3];             // для преобразования
  AnsiString SubStr;                                    // для преобразования

  PositionGlobal=Form1->RichEdit4->SelStart;            // глобальная позиция курсора в тексте
  LineNumber=PositionGlobal/82;                         // номер строки, в которой находится курсор  80 символов + CR+LF
  PositionLocal=PositionGlobal-82*LineNumber;           // позиция курсора в строке
  MaxLineNumber=(FormData.RE4Size-1)/16;                // максимальный номер строки
  switch(Key)
  { // обработчик backspace ***********************************
    case 8:     PositionLocal-=1;                       // уменьшаем позицию в строке
                if(PositionLocal<10)
                { PositionLocal=57;                     // если позиция <6, то переходим в начало предыдущей строки
                  LineNumber-=1;
                  if(LineNumber<0)                      // если номер строки <0
                        LineNumber=MaxLineNumber;       // переходим на последнюю строку
                }
                else if(PositionLocal<57)               // если новая позиция в области hex
                { if ((PositionLocal-10)%3!=2)           // если новая позиция не перед пробелом
                  { // меняем область слева
                    Form1->RichEdit4->SelStart=LineNumber*82+PositionLocal;     // устанавливаем курсор
                    Form1->RichEdit4->SelLength=1;      // выделяем 1 символ
                    Symbol=0x46;                        // будем писать символ F
                    Form1->RichEdit4->SelText=Symbol;   // пишем
                    // получаем символ, который будем писать в область справа
                    CharPos=(PositionLocal-10)/3;        // номер байта в строке, который нужно поменять
                    Form1->RichEdit4->SelStart=82*LineNumber+10+3*CharPos;       // ставим курсор на начало байта (в области слева)
                    Form1->RichEdit4->SelLength=2;                              // выделяем 2 символа
                    SubStr=LowerCase(Form1->RichEdit4->SelText);                // получаем их в строку
                    InHexBuf=SubStr.c_str();            //скопировать в буфер байт для передачи (в виде строки)
                    HexToBin(InHexBuf,TempBuf,1);       //преобразовать строку в целое (байт)
                    Key=TempBuf[0];
                    if(Key<0x1F) Symbol=0x1F;           //заменяем непечатные (TempBuf[0] сравнивать нельзя так как он знаковый)
                    else         Symbol=TempBuf[0];
                    // меняем область справа
                    Form1->RichEdit4->SelStart=LineNumber*82+64+CharPos;        // устанавливаем курсор
                    Form1->RichEdit4->SelLength=1;      // выделяем 1 символ
                    Form1->RichEdit4->SelText=Symbol;   // пишем туда полученный символ
                  }
                }
                else if(PositionLocal<64)               // если мы между правой и левой областями
                { PositionLocal=80;                     // если позиция <36, то переходим в начало предыдущей строки
                  LineNumber-=1;
                  if(LineNumber<0)                      // если номер строки <0
                        LineNumber=MaxLineNumber;       // переходим на последнюю строку
                }
                else                                    // если мы в области справа
                { // меняем область справа
                  Form1->RichEdit4->SelStart=LineNumber*82+PositionLocal;       // устанавливаем курсор
                  Form1->RichEdit4->SelLength=1;        // выделяем 1 символ
                  Symbol=0xFF;                          // будем писать символ я
                  Form1->RichEdit4->SelText=Symbol;     // пишем
                  // получаем символ, который будем менять
                  CharPos=PositionLocal-64;             // номер байта в строке, который нужно поменять
                  // меняем область слева
                  Form1->RichEdit4->SelStart=LineNumber*82+10+3*CharPos;         // устанавливаем курсор
                  Form1->RichEdit4->SelLength=2;        // выделяем 2 символа
                  Form1->RichEdit4->SelText="FF";       // пишем
                }
                // устанавливаем курсор в нужную позицию
                Form1->RichEdit4->SelStart=LineNumber*82+PositionLocal;         // ставим курсор в нужную позицию
                Form1->RichEdit4->SelLength=0;                                  // отменяем выделение
                break;
    // обработчик стрелок *************************************
     case 0x25:
     case 0x26:
     case 0x27:
     case 0x28: return;
     // обработчик delete **************************************
     case 0x2E: // если мы в области слева - заменяем на F
                if((PositionLocal>9) && (PositionLocal<57))
                {       Key=0x46;                    // заменяем символ слева на F
                }
                // если мы в области справа - заменяем на я
                if(PositionLocal>63)
                {       Key=0xFF;                    // заменяем символ справа на F
                }

     // обработчик всех остальных кнопок ***********************
     default:   if(PositionLocal>79)            // если позиция > 43
                { PositionLocal=63;             // то переходим в начало строки
                  LineNumber+=1;                // увеличиваем номер строки
                  if(LineNumber>MaxLineNumber)
                        LineNumber=0;           // если номер > максимального - переходим на первую строку
                }
                else if(PositionLocal>63)       // если позиция > 35
                { // меняем область справа
                  Form1->RichEdit4->SelStart=LineNumber*82+PositionLocal;       // ставим курсор в нужную позицию
                  Form1->RichEdit4->SelLength=1;                                // выделяем 1 символ
                  if(Key<0x1F)  Key=0x1F;                                       // если символ непечатный (спецсимвол) - заменяем
                  Symbol=Key;
                  Form1->RichEdit4->SelText=Symbol;                             // пишем туда введённый символ
                  Form1->RichEdit4->SelStart=LineNumber*82+PositionLocal;       // ставим курсор в нужную позицию
                  Form1->RichEdit4->SelLength=1;                                // выделяем 1 символ
                  Form1->RichEdit4->SelText=UpperCase(Form1->RichEdit4->SelText); // переводим введённый символ в верхний регистр
                  // получаем символ, который будем менять
                  CharPos=PositionLocal-64;             // номер байта в строке, который нужно поменять
                  TempBuf[0]=Key;
                  BinToHex(TempBuf,OutHexBuf,1);        //преобразовать строку в целое (байт)
                  OutHexBuf[2]=0;                       //строка должна заканчиваться нулём
                  // меняем область слева
                  Form1->RichEdit4->SelStart=LineNumber*82+10+3*CharPos;         // ставим курсор на начало байт
                  Form1->RichEdit4->SelLength=2;                                // выделяем 2 символа
                  Form1->RichEdit4->SelText=OutHexBuf;
                }
                else if(PositionLocal>56)       // если позиция >52,
                { PositionLocal=9;              // то переходим в начало строки
                  LineNumber+=1;                // увеличиваем номер строки
                  if(LineNumber>MaxLineNumber)
                        LineNumber=0;           // если номер > максимального - переходим на первую строку
                }
                else if(PositionLocal>9)        // если позиция > 5
                { if(strchr(Charset1,Key)&&((PositionLocal-10)%3!=2))            // если символ есть в наборе и позиция не перед пробелом
                  { // меняем область слева
                    Form1->RichEdit4->SelStart=LineNumber*82+PositionLocal;     // ставим курсор в нужную позицию
                    Form1->RichEdit4->SelLength=1;                              // выделяем 1 символ
                    Symbol=Key;
                    Form1->RichEdit4->SelText=Symbol;                           // пишем туда введённый символ
                    Form1->RichEdit4->SelStart=LineNumber*82+PositionLocal;     // ставим курсор в нужную позицию
                    Form1->RichEdit4->SelLength=1;                              // выделяем 1 символ
                    Form1->RichEdit4->SelText=UpperCase(Form1->RichEdit4->SelText);     // переводим введённый символ в верхний регистр
                    // получаем символ, который будем писать в область справа
                    CharPos=(PositionLocal-10)/3;        // номер байта в строке, который нужно поменять
                    Form1->RichEdit4->SelStart=82*LineNumber+10+3*CharPos;       // ставим курсор на начало байта (в области слева)
                    Form1->RichEdit4->SelLength=2;                              // выделяем 2 символа
                    SubStr=LowerCase(Form1->RichEdit4->SelText);                // получаем их в строку
                    InHexBuf=SubStr.c_str();            //скопировать в буфер байт для передачи (в виде строки)
                    HexToBin(InHexBuf,TempBuf,1);       //преобразовать строку в целое (байт)
                    Key=TempBuf[0];
                    if(Key<0x1F) Symbol=0x1F;           //заменяем непечатные
                    else         Symbol=TempBuf[0];
                    // меняем область справа
                    Form1->RichEdit4->SelStart=LineNumber*82+64+CharPos;        // устанавливаем курсор
                    Form1->RichEdit4->SelLength=1;      // выделяем 1 символ
                    Form1->RichEdit4->SelText=Symbol;   // пишем туда полученный символ
                  }
                }
                else    PositionLocal=9;        // переходим в начало строки
                // устанавливаем курсор в нужную позицию
                PositionLocal+=1;                                       // увеличиваем позицию курсора
                Form1->RichEdit4->SelStart=LineNumber*82+PositionLocal; // ставим курсор в нужную позицию
                Form1->RichEdit4->SelLength=0;                          // отменяем выделение
  }
  Key=0;
}
//---------------------------------------------------------------------------
//--- ЧЕРЕЗ ВЕРХНЕЕ МЕНЮ ВЫБРАНО ОТКРЫТИЕ ФАЙЛА С ПРОГРАММОЙ ----------------
//---------------------------------------------------------------------------
void __fastcall TForm1::LoadProgramfromFile1Click(TObject *Sender)
{ AnsiString FilePath, Ext;
  int NameLength;

  if(OpenDialog1->Execute())
  { if(SelectedChip.ID!=0)                                      // если тип чипа определён или выбран чип с перезаписываемым ROM
    { FilePath=OpenDialog1->FileName;                           // получаем имя загружаемого файла
      NameLength=FilePath.Length();                             // длинну всего пути вместе с именем
      Ext=FilePath.SubString(NameLength-2,3);                   // расширение
      Ext=UpperCase(Ext);                                       // переводим в верхний регистр
      if(Ext=="BIN")      LoadFromBinFileToMemory(FilePath,1);  // загружаем программу из bin-файла
      else                LoadFromHexFileToMemory(FilePath,1);  // загружаем программу из hex- или eep-файла
    }
    else        SendMsgToLog(14,"");                            // чип не выбран
  }
}
//---------------------------------------------------------------------------
//--- ЧЕРЕЗ ВЕРХНЕЕ МЕНЮ ВЫБРАНО ОТКРЫТИЕ ФАЙЛА С ДАННЫМИ -------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::Open1Click(TObject *Sender)
{ AnsiString FilePath, Ext;
  int NameLength;

  if(OpenDialog1->Execute())
  { if(SelectedChip.ID!=0)                                      // если тип чипа определён или выбран чип с перезаписываемым ROM
    { FilePath=OpenDialog1->FileName;                           // получаем имя загружаемого файла
      NameLength=FilePath.Length();                             // длинну всего пути вместе с именем
      Ext=FilePath.SubString(NameLength-2,3);                   // расширение
      Ext=UpperCase(Ext);                                       // переводим в верхний регистр
      if(Ext=="BIN")      LoadFromBinFileToMemory(FilePath,2);  // загружаем данные из bin-файла
      else                LoadFromHexFileToMemory(FilePath,2);  // загружаем данные из hex- или eep-файла
    }
    else        SendMsgToLog(14,"");                            // чип не выбран
  }
}
//---------------------------------------------------------------------------
//--- ЧЕРЕЗ ВЕРХНЕЕ МЕНЮ ВЫБРАНО СОХРАНЕНИЕ ФАЙЛА С ПРОГРАММОЙ --------------
//---------------------------------------------------------------------------
void __fastcall TForm1::SaveProgramtoFile1Click(TObject *Sender)
{ AnsiString FilePath, Ext;                     // полный путь к файлу и расширение
  int FilePathLength;                           // длина полного пути
  bool SelBin, SelHex;                          // какой формат сохранения выбран

  SelBin=false; SelHex=false;                   // сначала формат не выбран
  if(SaveDialog1->Execute())                    // если определились куда сохранять (не нажали отмена)
  { FilePath=SaveDialog1->FileName;             // получаем имя файла для сохранения
    FilePathLength=FilePath.Length();           // вычисляем длину всего пути вместе с именем
    Ext=FilePath.SubString(FilePathLength-2,3); // выделяем расширение (последние 3 символа)
    Ext=UpperCase(Ext);                         // переводим расширение в верхний регистр
    // определяем расширение (куда будем сохранять)
    if(SaveDialog1->FilterIndex == 1)           // выбран формат HEX (он в списке SaveDialog первый)
    { if(Ext!="HEX")    FilePath = FilePath + ".hex";   // если расширение файла не hex - дописываем в конце .hex
      SelHex=true;
    }
    else if(SaveDialog1->FilterIndex == 2)           // выбран формат EEP (он в списке SaveDialog второй)
    { if(Ext!="EEP")    FilePath = FilePath + ".eep";   // если расширение файла не eep - дописываем в конце .eep
      SelHex=true;                              // данные в eep-файле хранятся в формате hex-файла
    }
    else                                        // выбран формат BIN (ну раз не HEX и не EEP, их в списке всего три)
    { if(Ext!="BIN")    FilePath = FilePath + ".bin";   // если расширение файла не bin - дописываем в конце .bin
      SelBin=true;
    }
  }
  //------------------------------------------
  // А теперь, собственно, пишем данные в файл
  //------------------------------------------
  if(SelBin)                                    // если нужно сохранять в bin
  { SaveFromMemoryToBinFile(FilePath,1);        // сохраняем программу из памяти в bin-файл
  }
  if(SelHex)                                    // если нужно сохранять в hex
  { SaveFromMemoryToHexFile(FilePath,1);        // сохраняем программу из памяти в hex-файл
  }
}
//---------------------------------------------------------------------------
//--- ЧЕРЕЗ ВЕРХНЕЕ МЕНЮ ВЫБРАНО СОХРАНЕНИЕ ФАЙЛА С ДАННЫМИ -----------------
//---------------------------------------------------------------------------
void __fastcall TForm1::Save1Click(TObject *Sender)
{  AnsiString FilePath, Ext;                     // полный путь к файлу и расширение
  int FilePathLength;                           // длина полного пути
  bool SelBin, SelHex;                          // какой формат сохранения выбран

  SelBin=false; SelHex=false;                   // сначала формат не выбран
  if(SaveDialog1->Execute())                    // если определились куда сохранять (не нажали отмена)
  { FilePath=SaveDialog1->FileName;             // получаем имя файла для сохранения
    FilePathLength=FilePath.Length();           // вычисляем длину всего пути вместе с именем
    Ext=FilePath.SubString(FilePathLength-2,3); // выделяем расширение (последние 3 символа)
    Ext=UpperCase(Ext);                         // переводим расширение в верхний регистр
    // определяем расширение (куда будем сохранять)
    if(SaveDialog1->FilterIndex == 1)           // выбран формат HEX (он в списке SaveDialog первый)
    { if(Ext!="HEX")    FilePath = FilePath + ".hex";   // если расширение файла не hex - дописываем в конце .hex
      SelHex=true;
    }
    else if(SaveDialog1->FilterIndex == 2)           // выбран формат EEP (он в списке SaveDialog второй)
    { if(Ext!="EEP")    FilePath = FilePath + ".eep";   // если расширение файла не eep - дописываем в конце .eep
      SelHex=true;                              // в eep-файле данные лежат в формате hex-файла
    }
    else                                        // выбран формат BIN (ну раз не HEX и не EEP, их в списке всего три)
    { if(Ext!="BIN")    FilePath = FilePath + ".bin";   // если расширение файла не bin - дописываем в конце .bin
      SelBin=true;
    }
  }
  //------------------------------------------
  // А теперь, собственно, пишем данные в файл
  //------------------------------------------
  if(SelBin)                                    // если нужно сохранять в bin
  { SaveFromMemoryToBinFile(FilePath,2);        // сохраняем данные из памяти в bin-файл
  }
  if(SelHex)                                    // если нужно сохранять в hex
  { SaveFromMemoryToHexFile(FilePath,2);        // сохраняем данные из памяти в hex-файл
  }
}
//---------------------------------------------------------------------------
//--- Изменили позицию трек-бара, определяющего величину задержек -----------
//---------------------------------------------------------------------------
void __fastcall TForm1::TrackBar1Change(TObject *Sender)
{ Delays = Form1->TrackBar1->Position;  // считываем установленную величину задержек
}
//---------------------------------------------------------------------------
//////////////////////////////
// ОБРАБОТКА НАЖАТИЙ КНОПОК //
//////////////////////////////
//---------------------------------------------------------------------------
//--- НАЖАТА КНОПКА АВТОПОИСК ЧИПА ------------------------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::Button3Click(TObject *Sender)
{ unsigned int ChipID;  // сюда будем принимать ID чипа из байт сигнатуры
  WRITE_BUFFER wr_buf;  // буфер для отправки данных
  READ_BUFFER rd_buf;   // буфер для приёма данных

  if(!ProgrammingEnable())                      // пробуем перевести чип в режим программирования и синхронизироваться с ним
  {     SendMsgToLog(19," with fail.");         // если вернуло false - не удалось синхронизироваться
        return;                                 // выходим
  }

  ChipID = ReadSignatureBytes();        // пробуем узнать что у нас за чип,
  InitChip(ChipID);                     // если мы знаем такой чип - заполняем структуру чипа, инициализируем его память
}
//---------------------------------------------------------------------------
//--- НАЖАТА КНОПКА CHIP ERASE ----------------------------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::Button11Click(TObject *Sender)
{ if (Application->MessageBox("All previous chip data will be lost (Flash, EEPROM, Lock Bits). Are you sure?", "Warning", MB_YESNO|MB_ICONWARNING|MB_DEFBUTTON2|MB_APPLMODAL) == IDYES)
  {     // включаем прогресс-бар
        Application->CreateForm(__classid(TLBar),&LBar);      // создаём форму с прогресс-баром
        LBar->Show();                                         // показываем её в немодальном окне

        switch(SelectedChip.ID)
        { case 0xD931E: // выбрано устройство ATtiny861
          case 0x8921E: // выбрано устройство ATtiny461
          case 0xC911E: // выбрано устройство ATtiny261
                        if(!ATtiny261_ProgrammingEnable())     // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого можно уже и стирать
                        if(!ATtiny261_ChipErase())             // пробуем стереть чип
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось стереть
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        break;
          case 0x9911E: // выбрано устройство ATtiny26
                        if(!ATtiny26_ProgrammingEnable())     // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого можно уже и стирать
                        if(!ATtiny26_ChipErase())             // пробуем стереть чип
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось стереть
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        break;
          case 0xB931E: // выбрано устройство ATtiny85
          case 0x6921E: // выбрано устройство ATtiny45
          case 0x8911E: // выбрано устройство ATtiny25
                        if(!ATtiny25_ProgrammingEnable())     // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого можно уже и стирать
                        if(!ATtiny25_ChipErase())             // пробуем стереть чип
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось стереть
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        break;
          case 0x6911E: // выбрано устройство ATtiny22
                        if(!ATtiny22_ProgrammingEnable())     // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого можно уже и стирать
                        if(!ATtiny22_ChipErase())             // пробуем стереть чип
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось стереть
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        break;
          case 0x6901E: // выбрано устройство ATtiny15
                        if(!ATtiny15_ProgrammingEnable())     // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого можно уже и стирать
                        if(!ATtiny15_ChipErase())             // пробуем стереть чип
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось стереть
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        break;
          case 0x7901E: // выбрано устройство ATtiny13
                        if(!ATtiny13_ProgrammingEnable())     // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого можно уже и стирать
                        if(!ATtiny13_ChipErase())             // пробуем стереть чип
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось стереть
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        break;
          case 0x5901E: // выбрано устройство ATtiny12
                        if(!ATtiny12_ProgrammingEnable())      // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого можно уже и стирать
                        if(!ATtiny12_ChipErase())              // пробуем стереть чип
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось стереть
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        if(!ATtiny12_ProgrammingEnable())      // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        if(!ATtiny12_WriteFFTo0ProgramMemory()) // пробуем записать 0xFF во флеш по адресу 0x0
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        if(!ATtiny12_ChipErase())              // пробуем стереть чип ещё раз (вот такой кривой алгоритм для этого чипа)
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось стереть
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        break;
          case 0x81971E: // выбрано устройство AT90CAN128
          case 0x81961E: // выбрано устройство AT90CAN64
          case 0x81951E: // выбрано устройство AT90CAN32
                        if(!AT90CAN32_ProgrammingEnable())      // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого можно уже и стирать
                        if(!AT90CAN32_ChipErase())              // пробуем стереть чип
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось стереть
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        break;
          case 0x3931E:       // выбран чип AT90S8535
          case 0x2921E:       // выбран чип AT90S4434
                        if(!AT90S4434_ProgrammingEnable())     // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого можно уже и стирать
                        if(!AT90S4434_ChipErase())              // пробуем стереть чип
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось стереть
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        break;
          case 0x1931E:       // выбран чип AT90S8515
          case 0x1921E:       // выбран чип AT90S4414
                        if(!AT90S4414_ProgrammingEnable())     // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого можно уже и стирать
                        if(!AT90S4414_ChipErase())              // пробуем стереть чип
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось стереть
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        break;
          case 0x3921E:       // выбран чип AT90S4433
          case 0x5911E:       // выбран чип AT90S2333
                        if(!AT90S2333_ProgrammingEnable())     // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого можно уже и стирать
                        if(!AT90S2333_ChipErase())              // пробуем стереть чип
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось стереть
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        break;
          case 0x3911E:       // выбран чип AT90S2343
                        if(!AT90S2343_ProgrammingEnable())     // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого можно уже и стирать
                        if(!AT90S2343_ChipErase())              // пробуем стереть чип
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось стереть
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        break;
          case 0x2911E:       // выбран чип AT90S2323
                        if(!AT90S2323_ProgrammingEnable())     // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого можно уже и стирать
                        if(!AT90S2323_ChipErase())              // пробуем стереть чип
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось стереть
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        break;
          case 0x1911E:       // выбран чип AT90S2313
                        if(!AT90S2313_ProgrammingEnable())     // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого можно уже и стирать
                        if(!AT90S2313_ChipErase())              // пробуем стереть чип
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось стереть
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        break;
          case 0x1901E: // выбран чип AT90S1200
                        if(!AT90S1200_ProgrammingEnable())     // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого можно уже и стирать
                        if(!AT90S1200_ChipErase())              // пробуем стереть чип
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось стереть
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        break;
          case 0xA911E: // выбрано устройство ATtiny2313
                        if(!ATtiny2313_ProgrammingEnable())     // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого можно уже и стирать
                        if(!ATtiny2313_ChipErase())             // пробуем стереть чип
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось стереть
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        break;
          case 0:  SendMsgToLog(14,"");            // сообщение в лог, что не выбран ни один чип
                   break;                          // выходим
          default: SendMsgToLog(15," unknown");    // сообщение в лог, что чип нам неизвестен и выходим
                   break;                          // выходим
        }
        LBar->Free();                   // уничтожаем форму с прогресс-баром
  }
}
//---------------------------------------------------------------------------
//--- НАЖАТА КНОПКА READ CALIBRATION ----------------------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::Button7Click(TObject *Sender)
{ AnsiString TempStr;                // для преобразования
  char TempBuf[1], OutHexBuf[3];     // для преобразования

  // включаем прогресс-бар
  Application->CreateForm(__classid(TLBar),&LBar);      // создаём форму с прогресс-баром
  LBar->Show();                                         // показываем её в немодальном окне

  switch(SelectedChip.ID)
  { case 0xD931E:       // выбрано устройство ATtiny861
    case 0x8921E:       // выбрано устройство ATtiny461
    case 0xC911E:       // выбрано устройство ATtiny261
                        if(!ATtiny261_ProgrammingEnable())     // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого можно уже и читать
                        if(!ATtiny261_ReadCalibrationBytes())  // пробуем прочитать биты калибровки
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось прочитать
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        break;
    case 0x9911E:       // выбрано устройство ATtiny26
                        if(!ATtiny26_ProgrammingEnable())     // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого можно уже и читать
                        if(!ATtiny26_ReadCalibrationBytes())  // пробуем прочитать биты калибровки
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось прочитать
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        break;
    case 0xB931E:       // выбрано устройство ATtiny85
    case 0x6921E:       // выбрано устройство ATtiny45
    case 0x8911E:       // выбрано устройство ATtiny25
                        if(!ATtiny25_ProgrammingEnable())     // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого можно уже и читать
                        if(!ATtiny25_ReadCalibrationBytes())  // пробуем прочитать биты калибровки
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось прочитать
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        break;
    case 0x6901E:      // выбрано устройство ATtiny15
                        if(!ATtiny15_ProgrammingEnable())      // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого можно уже и читать
                        if(!ATtiny15_ReadCalibrationBytes())   // пробуем прочитать биты калибровки
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось прочитать
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        break;
    case 0x7901E:      // выбрано устройство ATtiny13
                        if(!ATtiny13_ProgrammingEnable())      // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого можно уже и читать
                        if(!ATtiny13_ReadCalibrationBytes())   // пробуем прочитать биты калибровки
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось прочитать
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        break;
     case 0x5901E:      // выбрано устройство ATtiny12
                        if(!ATtiny12_ProgrammingEnable())      // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого можно уже и читать
                        if(!ATtiny12_ReadCalibrationBytes())   // пробуем прочитать биты калибровки
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось прочитать
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        break;
    case 0x81971E:      // выбрано устройство AT90CAN128
    case 0x81961E:      // выбрано устройство AT90CAN64
    case 0x81951E:      // выбрано устройство AT90CAN32
                        if(!AT90CAN32_ProgrammingEnable())      // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого можно уже и читать
                        if(!AT90CAN32_ReadCalibrationBytes())   // пробуем прочитать биты калибровки
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось прочитать
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        break;
    case 0xA911E:       // выбрано устройство ATtiny2313
                        if(!ATtiny2313_ProgrammingEnable())     // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого можно уже и читать
                        if(!ATtiny2313_ReadCalibrationBytes())  // пробуем прочитать биты калибровки
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось прочитать
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        break;
    case 0x6911E:       // выбран чип ATtiny22
    case 0x3931E:       // выбран чип AT90S8535
    case 0x2921E:       // выбран чип AT90S4434
    case 0x1931E:       // выбран чип AT90S8515
    case 0x1921E:       // выбран чип AT90S4414
    case 0x3921E:       // выбран чип AT90S4433
    case 0x5911E:       // выбран чип AT90S2333
    case 0x3911E:       // выбран чип AT90S2343
    case 0x2911E:       // выбран чип AT90S2323
    case 0x1911E:       // выбран чип AT90S2313
    case 0x1901E:       // выбран чип AT90S1200
                        SendMsgToLog(20,"");            // сообщение в лог, что команда недоступна
                        LBar->Free();                   // уничтожаем форму с прогресс-баром
                        return;
    case 0:     SendMsgToLog(14,"");            // сообщение в лог, что не выбран ни один чип
                LBar->Free();                   // уничтожаем форму с прогресс-баром
                return;                         // выходим
    default:    SendMsgToLog(15," unknown");    // сообщение в лог, что чип нам неизвестен и выходим
                LBar->Free();                   // уничтожаем форму с прогресс-баром
                return;                         // выходим
  }
  LBar->Free();                 // уничтожаем форму с прогресс-баром

  // формируем строку для вывода в лог прочитанных байт калибровки
  TempStr="";           // строка сначала пустая
  for(unsigned char i=0; i<SelectedChip.Area4Size; i++)
  {     TempBuf[0]=SelectedChip.Area4[i];
        BinToHex(TempBuf,OutHexBuf,1);      // преобразовать строку в целое (байт)
        OutHexBuf[2]=0;                     // строка должна заканчиваться нулём
        TempStr += "calibration "+IntToStr(i)+" = 0x" + AnsiString(OutHexBuf);
  }
  SendMsgToLog(0,TempStr);      // выводим сформированную строку
}
//---------------------------------------------------------------------------
//--- НАЖАТА КНОПКА VERIFY PROGRAM ------------------------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::Button6Click(TObject *Sender)
{ char TempBuf[1], OutHexBuf[3];        // для преобразования
  AnsiString TempStr;                   // временная переменная для вывода адреса

  // сначала нужно поместить в память данные с формы, в зависимости от вкладки
  switch(Form1->PageControl1->TabIndex)
  {       case 0: GetDataToMemory(1,1);      // из RichEdit1 в Area1
                  break;
          case 1: GetDataToMemory(2,1);      // из RichEdit2 в Area1
                  break;
          default: break;
  }

  // включаем прогресс-бар
  Application->CreateForm(__classid(TLBar),&LBar);      // создаём форму с прогресс-баром
  LBar->Show();                                         // показываем её в немодальном окне

  SendMsgToLog(18," verify the program");       // сообщаем о попытке прочитать программу
  SendStartTimeToLog();                         // пишем в лог время начала операции
  switch(SelectedChip.ID)
  { case 0xD931E:       // выбрано устройство ATtiny861
    case 0x8921E:       // выбрано устройство ATtiny461
    case 0xC911E:       // выбрано устройство ATtiny261
                        if(!ATtiny261_ProgrammingEnable())     // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                SendEndTimeToLog();             // пишем в лог время окончания операции
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого можно уже и читать
                        for(unsigned int i=0; i<SelectedChip.Area1Size; i++)
                        {       if(!ATtiny261_ReadProgramMemory(i,1))          // пробуем прочитать байт программы
                                {       TempBuf[0]=i>>8;                        // берём старший байт адреса
                                        BinToHex(TempBuf,OutHexBuf,1);          // преобразуем в строку
                                        OutHexBuf[2]=0;                         // строка должна заканчиваться нулём
                                        TempStr=UpperCase(OutHexBuf);           // переводим в верхний регистр и пишем в строку
                                        TempBuf[0]=i;                           // берём младший байт адреса
                                        BinToHex(TempBuf,OutHexBuf,1);          // преобразуем в строку
                                        OutHexBuf[2]=0;                         // строка должна заканчиваться нулём
                                        TempStr+=UpperCase(OutHexBuf);          // переводим в верхний регистр и дописываем к строке

                                        SendMsgToLog(19," with fail. Address: 0x" + TempStr);   // если вернуло false - не совпало
                                        SendEndTimeToLog();                                     // пишем в лог время окончания операции
                                        LBar->Free();                                           // уничтожаем форму с прогресс-баром
                                        return;                                                 // выходим
                                }
                                // если прочитали количество байт кратное 32-м
                                if((i+1)%32==0)
                                {       LBar->ProgressBar1->Position=100*(i+1)/SelectedChip.Area1Size;  // вычисляем новую позицию прогресс-бара
                                }
                        }
                        break;
    case 0x9911E:       // выбрано устройство ATtiny26
                        if(!ATtiny26_ProgrammingEnable())     // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                SendEndTimeToLog();             // пишем в лог время окончания операции
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого можно уже и читать
                        for(unsigned int i=0; i<SelectedChip.Area1Size; i++)
                        {       if(!ATtiny26_ReadProgramMemory(i,1))          // пробуем прочитать байт программы
                                {       TempBuf[0]=i>>8;                        // берём старший байт адреса
                                        BinToHex(TempBuf,OutHexBuf,1);          // преобразуем в строку
                                        OutHexBuf[2]=0;                         // строка должна заканчиваться нулём
                                        TempStr=UpperCase(OutHexBuf);           // переводим в верхний регистр и пишем в строку
                                        TempBuf[0]=i;                           // берём младший байт адреса
                                        BinToHex(TempBuf,OutHexBuf,1);          // преобразуем в строку
                                        OutHexBuf[2]=0;                         // строка должна заканчиваться нулём
                                        TempStr+=UpperCase(OutHexBuf);          // переводим в верхний регистр и дописываем к строке

                                        SendMsgToLog(19," with fail. Address: 0x" + TempStr);   // если вернуло false - не совпало
                                        SendEndTimeToLog();                                     // пишем в лог время окончания операции
                                        LBar->Free();                                           // уничтожаем форму с прогресс-баром
                                        return;                                                 // выходим
                                }
                                // если прочитали количество байт кратное 32-м
                                if((i+1)%32==0)
                                {       LBar->ProgressBar1->Position=100*(i+1)/SelectedChip.Area1Size;  // вычисляем новую позицию прогресс-бара
                                }
                        }
                        break;
    case 0xB931E:       // выбрано устройство ATtiny85
    case 0x6921E:       // выбрано устройство ATtiny45
    case 0x8911E:       // выбрано устройство ATtiny25
                        if(!ATtiny25_ProgrammingEnable())     // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                SendEndTimeToLog();             // пишем в лог время окончания операции
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого можно уже и читать
                        for(unsigned int i=0; i<SelectedChip.Area1Size; i++)
                        {       if(!ATtiny25_ReadProgramMemory(i,1))          // пробуем прочитать байт программы
                                {       TempBuf[0]=i>>8;                        // берём старший байт адреса
                                        BinToHex(TempBuf,OutHexBuf,1);          // преобразуем в строку
                                        OutHexBuf[2]=0;                         // строка должна заканчиваться нулём
                                        TempStr=UpperCase(OutHexBuf);           // переводим в верхний регистр и пишем в строку
                                        TempBuf[0]=i;                           // берём младший байт адреса
                                        BinToHex(TempBuf,OutHexBuf,1);          // преобразуем в строку
                                        OutHexBuf[2]=0;                         // строка должна заканчиваться нулём
                                        TempStr+=UpperCase(OutHexBuf);          // переводим в верхний регистр и дописываем к строке

                                        SendMsgToLog(19," with fail. Address: 0x" + TempStr);   // если вернуло false - не совпало
                                        SendEndTimeToLog();                                     // пишем в лог время окончания операции
                                        LBar->Free();                                           // уничтожаем форму с прогресс-баром
                                        return;                                                 // выходим
                                }
                                // если прочитали количество байт кратное 32-м
                                if((i+1)%32==0)
                                {       LBar->ProgressBar1->Position=100*(i+1)/SelectedChip.Area1Size;  // вычисляем новую позицию прогресс-бара
                                }
                        }
                        break;
    case 0x6911E:       // выбран чип ATtiny22
                        if(!ATtiny22_ProgrammingEnable())      // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                SendEndTimeToLog();             // пишем в лог время окончания операции
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого можно уже и читать
                        for(unsigned int i=0; i<SelectedChip.Area1Size; i++)
                        {       if(!ATtiny22_ReadProgramMemory(i,1))           // пробуем прочитать байт программы
                                {       TempBuf[0]=i>>8;                        // берём старший байт адреса
                                        BinToHex(TempBuf,OutHexBuf,1);          // преобразуем в строку
                                        OutHexBuf[2]=0;                         // строка должна заканчиваться нулём
                                        TempStr=UpperCase(OutHexBuf);           // переводим в верхний регистр и пишем в строку
                                        TempBuf[0]=i;                           // берём младший байт адреса
                                        BinToHex(TempBuf,OutHexBuf,1);          // преобразуем в строку
                                        OutHexBuf[2]=0;                         // строка должна заканчиваться нулём
                                        TempStr+=UpperCase(OutHexBuf);          // переводим в верхний регистр и дописываем к строке

                                        SendMsgToLog(19," with fail. Address: 0x" + TempStr);   // если вернуло false - не совпало
                                        SendEndTimeToLog();                                     // пишем в лог время окончания операции
                                        LBar->Free();                                           // уничтожаем форму с прогресс-баром
                                        return;                                                 // выходим
                                }
                                // если прочитали количество байт кратное 32-м
                                if((i+1)%32==0)
                                {       LBar->ProgressBar1->Position=100*(i+1)/SelectedChip.Area1Size;  // вычисляем новую позицию прогресс-бара
                                }
                        }
                        break;
    case 0x6901E:       // выбран чип ATtiny15
                        if(!ATtiny15_ProgrammingEnable())      // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                SendEndTimeToLog();             // пишем в лог время окончания операции
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого можно уже и читать
                        for(unsigned int i=0; i<SelectedChip.Area1Size; i++)
                        {       if(!ATtiny15_ReadProgramMemory(i,1))           // пробуем прочитать байт программы
                                {       TempBuf[0]=i>>8;                        // берём старший байт адреса
                                        BinToHex(TempBuf,OutHexBuf,1);          // преобразуем в строку
                                        OutHexBuf[2]=0;                         // строка должна заканчиваться нулём
                                        TempStr=UpperCase(OutHexBuf);           // переводим в верхний регистр и пишем в строку
                                        TempBuf[0]=i;                           // берём младший байт адреса
                                        BinToHex(TempBuf,OutHexBuf,1);          // преобразуем в строку
                                        OutHexBuf[2]=0;                         // строка должна заканчиваться нулём
                                        TempStr+=UpperCase(OutHexBuf);          // переводим в верхний регистр и дописываем к строке

                                        SendMsgToLog(19," with fail. Address: 0x" + TempStr);   // если вернуло false - не совпало
                                        SendEndTimeToLog();                                     // пишем в лог время окончания операции
                                        LBar->Free();                                           // уничтожаем форму с прогресс-баром
                                        return;                                                 // выходим
                                }
                                // если прочитали количество байт кратное 32-м
                                if((i+1)%32==0)
                                {       LBar->ProgressBar1->Position=100*(i+1)/SelectedChip.Area1Size;  // вычисляем новую позицию прогресс-бара
                                }
                        }
                        break;
    case 0x7901E:       // выбран чип ATtiny13
                        if(!ATtiny13_ProgrammingEnable())      // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                SendEndTimeToLog();             // пишем в лог время окончания операции
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого можно уже и читать
                        for(unsigned int i=0; i<SelectedChip.Area1Size; i++)
                        {       if(!ATtiny13_ReadProgramMemory(i,1))           // пробуем прочитать байт программы
                                {       TempBuf[0]=i>>8;                        // берём старший байт адреса
                                        BinToHex(TempBuf,OutHexBuf,1);          // преобразуем в строку
                                        OutHexBuf[2]=0;                         // строка должна заканчиваться нулём
                                        TempStr=UpperCase(OutHexBuf);           // переводим в верхний регистр и пишем в строку
                                        TempBuf[0]=i;                           // берём младший байт адреса
                                        BinToHex(TempBuf,OutHexBuf,1);          // преобразуем в строку
                                        OutHexBuf[2]=0;                         // строка должна заканчиваться нулём
                                        TempStr+=UpperCase(OutHexBuf);          // переводим в верхний регистр и дописываем к строке

                                        SendMsgToLog(19," with fail. Address: 0x" + TempStr);   // если вернуло false - не совпало
                                        SendEndTimeToLog();                                     // пишем в лог время окончания операции
                                        LBar->Free();                                           // уничтожаем форму с прогресс-баром
                                        return;                                                 // выходим
                                }
                                // если прочитали количество байт кратное 32-м
                                if((i+1)%32==0)
                                {       LBar->ProgressBar1->Position=100*(i+1)/SelectedChip.Area1Size;  // вычисляем новую позицию прогресс-бара
                                }
                        }
                        break;
    case 0x5901E:       // выбран чип ATtiny12
                        if(!ATtiny12_ProgrammingEnable())      // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                SendEndTimeToLog();             // пишем в лог время окончания операции
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого можно уже и читать
                        for(unsigned int i=0; i<SelectedChip.Area1Size; i++)
                        {       if(!ATtiny12_ReadProgramMemory(i,1))           // пробуем прочитать байт программы
                                {       TempBuf[0]=i>>8;                        // берём старший байт адреса
                                        BinToHex(TempBuf,OutHexBuf,1);          // преобразуем в строку
                                        OutHexBuf[2]=0;                         // строка должна заканчиваться нулём
                                        TempStr=UpperCase(OutHexBuf);           // переводим в верхний регистр и пишем в строку
                                        TempBuf[0]=i;                           // берём младший байт адреса
                                        BinToHex(TempBuf,OutHexBuf,1);          // преобразуем в строку
                                        OutHexBuf[2]=0;                         // строка должна заканчиваться нулём
                                        TempStr+=UpperCase(OutHexBuf);          // переводим в верхний регистр и дописываем к строке

                                        SendMsgToLog(19," with fail. Address: 0x" + TempStr);   // если вернуло false - не совпало
                                        SendEndTimeToLog();                                     // пишем в лог время окончания операции
                                        LBar->Free();                                           // уничтожаем форму с прогресс-баром
                                        return;                                                 // выходим
                                }
                                // если прочитали количество байт кратное 32-м
                                if((i+1)%32==0)
                                {       LBar->ProgressBar1->Position=100*(i+1)/SelectedChip.Area1Size;  // вычисляем новую позицию прогресс-бара
                                }
                        }
                        break;
    case 0x81971E:      // выбрано устройство AT90CAN128
    case 0x81961E:      // выбрано устройство AT90CAN64
    case 0x81951E:      // выбрано устройство AT90CAN32
                        if(!AT90CAN32_ProgrammingEnable())      // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                SendEndTimeToLog();             // пишем в лог время окончания операции
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого можно уже и читать
                        for(unsigned int i=0; i<SelectedChip.Area1Size; i++)
                        {       if(!AT90CAN32_ReadProgramMemory(i,1))           // пробуем прочитать байт программы
                                {       TempBuf[0]=i>>8;                        // берём старший байт адреса
                                        BinToHex(TempBuf,OutHexBuf,1);          // преобразуем в строку
                                        OutHexBuf[2]=0;                         // строка должна заканчиваться нулём
                                        TempStr=UpperCase(OutHexBuf);           // переводим в верхний регистр и пишем в строку
                                        TempBuf[0]=i;                           // берём младший байт адреса
                                        BinToHex(TempBuf,OutHexBuf,1);          // преобразуем в строку
                                        OutHexBuf[2]=0;                         // строка должна заканчиваться нулём
                                        TempStr+=UpperCase(OutHexBuf);          // переводим в верхний регистр и дописываем к строке

                                        SendMsgToLog(19," with fail. Address: 0x" + TempStr);   // если вернуло false - не совпало
                                        SendEndTimeToLog();                                     // пишем в лог время окончания операции
                                        LBar->Free();                                           // уничтожаем форму с прогресс-баром
                                        return;                                                 // выходим
                                }
                                // если прочитали количество байт кратное 256-и
                                if((i+1)%256==0)
                                {       LBar->ProgressBar1->Position=100*(i+1)/SelectedChip.Area1Size;  // вычисляем новую позицию прогресс-бара
                                }
                        }
                        break;
    case 0x3931E:       // выбран чип AT90S8535
    case 0x2921E:       // выбран чип AT90S4434
                        if(!AT90S4434_ProgrammingEnable())      // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                SendEndTimeToLog();             // пишем в лог время окончания операции
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого можно уже и читать
                        for(unsigned int i=0; i<SelectedChip.Area1Size; i++)
                        {       if(!AT90S4434_ReadProgramMemory(i,1))           // пробуем прочитать байт программы
                                {       TempBuf[0]=i>>8;                        // берём старший байт адреса
                                        BinToHex(TempBuf,OutHexBuf,1);          // преобразуем в строку
                                        OutHexBuf[2]=0;                         // строка должна заканчиваться нулём
                                        TempStr=UpperCase(OutHexBuf);           // переводим в верхний регистр и пишем в строку
                                        TempBuf[0]=i;                           // берём младший байт адреса
                                        BinToHex(TempBuf,OutHexBuf,1);          // преобразуем в строку
                                        OutHexBuf[2]=0;                         // строка должна заканчиваться нулём
                                        TempStr+=UpperCase(OutHexBuf);          // переводим в верхний регистр и дописываем к строке

                                        SendMsgToLog(19," with fail. Address: 0x" + TempStr);   // если вернуло false - не совпало
                                        SendEndTimeToLog();                                     // пишем в лог время окончания операции
                                        LBar->Free();                                           // уничтожаем форму с прогресс-баром
                                        return;                                                 // выходим
                                }
                                // если прочитали количество байт кратное 32-м
                                if((i+1)%32==0)
                                {       LBar->ProgressBar1->Position=100*(i+1)/SelectedChip.Area1Size;  // вычисляем новую позицию прогресс-бара
                                }
                        }
                        break;
    case 0x1931E:       // выбран чип AT90S8515
    case 0x1921E:       // выбран чип AT90S4414
                        if(!AT90S4414_ProgrammingEnable())      // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                SendEndTimeToLog();             // пишем в лог время окончания операции
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого можно уже и читать
                        for(unsigned int i=0; i<SelectedChip.Area1Size; i++)
                        {       if(!AT90S4414_ReadProgramMemory(i,1))           // пробуем прочитать байт программы
                                {       TempBuf[0]=i>>8;                        // берём старший байт адреса
                                        BinToHex(TempBuf,OutHexBuf,1);          // преобразуем в строку
                                        OutHexBuf[2]=0;                         // строка должна заканчиваться нулём
                                        TempStr=UpperCase(OutHexBuf);           // переводим в верхний регистр и пишем в строку
                                        TempBuf[0]=i;                           // берём младший байт адреса
                                        BinToHex(TempBuf,OutHexBuf,1);          // преобразуем в строку
                                        OutHexBuf[2]=0;                         // строка должна заканчиваться нулём
                                        TempStr+=UpperCase(OutHexBuf);          // переводим в верхний регистр и дописываем к строке

                                        SendMsgToLog(19," with fail. Address: 0x" + TempStr);   // если вернуло false - не совпало
                                        SendEndTimeToLog();                                     // пишем в лог время окончания операции
                                        LBar->Free();                                           // уничтожаем форму с прогресс-баром
                                        return;                                                 // выходим
                                }
                                // если прочитали количество байт кратное 32-м
                                if((i+1)%32==0)
                                {       LBar->ProgressBar1->Position=100*(i+1)/SelectedChip.Area1Size;  // вычисляем новую позицию прогресс-бара
                                }
                        }
                        break;
    case 0x3921E:       // выбран чип AT90S4433
    case 0x5911E:       // выбран чип AT90S2333
                        if(!AT90S2333_ProgrammingEnable())      // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                SendEndTimeToLog();             // пишем в лог время окончания операции
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого можно уже и читать
                        for(unsigned int i=0; i<SelectedChip.Area1Size; i++)
                        {       if(!AT90S2333_ReadProgramMemory(i,1))           // пробуем прочитать байт программы
                                {       TempBuf[0]=i>>8;                        // берём старший байт адреса
                                        BinToHex(TempBuf,OutHexBuf,1);          // преобразуем в строку
                                        OutHexBuf[2]=0;                         // строка должна заканчиваться нулём
                                        TempStr=UpperCase(OutHexBuf);           // переводим в верхний регистр и пишем в строку
                                        TempBuf[0]=i;                           // берём младший байт адреса
                                        BinToHex(TempBuf,OutHexBuf,1);          // преобразуем в строку
                                        OutHexBuf[2]=0;                         // строка должна заканчиваться нулём
                                        TempStr+=UpperCase(OutHexBuf);          // переводим в верхний регистр и дописываем к строке

                                        SendMsgToLog(19," with fail. Address: 0x" + TempStr);   // если вернуло false - не совпало
                                        SendEndTimeToLog();                                     // пишем в лог время окончания операции
                                        LBar->Free();                                           // уничтожаем форму с прогресс-баром
                                        return;                                                 // выходим
                                }
                                // если прочитали количество байт кратное 32-м
                                if((i+1)%32==0)
                                {       LBar->ProgressBar1->Position=100*(i+1)/SelectedChip.Area1Size;  // вычисляем новую позицию прогресс-бара
                                }
                        }
                        break;
    case 0x3911E:       // выбран чип AT90S2343
                        if(!AT90S2343_ProgrammingEnable())      // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                SendEndTimeToLog();             // пишем в лог время окончания операции
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого можно уже и читать
                        for(unsigned int i=0; i<SelectedChip.Area1Size; i++)
                        {       if(!AT90S2343_ReadProgramMemory(i,1))           // пробуем прочитать байт программы
                                {       TempBuf[0]=i>>8;                        // берём старший байт адреса
                                        BinToHex(TempBuf,OutHexBuf,1);          // преобразуем в строку
                                        OutHexBuf[2]=0;                         // строка должна заканчиваться нулём
                                        TempStr=UpperCase(OutHexBuf);           // переводим в верхний регистр и пишем в строку
                                        TempBuf[0]=i;                           // берём младший байт адреса
                                        BinToHex(TempBuf,OutHexBuf,1);          // преобразуем в строку
                                        OutHexBuf[2]=0;                         // строка должна заканчиваться нулём
                                        TempStr+=UpperCase(OutHexBuf);          // переводим в верхний регистр и дописываем к строке

                                        SendMsgToLog(19," with fail. Address: 0x" + TempStr);   // если вернуло false - не совпало
                                        SendEndTimeToLog();                                     // пишем в лог время окончания операции
                                        LBar->Free();                                           // уничтожаем форму с прогресс-баром
                                        return;                                                 // выходим
                                }
                                // если прочитали количество байт кратное 32-м
                                if((i+1)%32==0)
                                {       LBar->ProgressBar1->Position=100*(i+1)/SelectedChip.Area1Size;  // вычисляем новую позицию прогресс-бара
                                }
                        }
                        break;
    case 0x2911E:       // выбран чип AT90S2323
                        if(!AT90S2323_ProgrammingEnable())      // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                SendEndTimeToLog();             // пишем в лог время окончания операции
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого можно уже и читать
                        for(unsigned int i=0; i<SelectedChip.Area1Size; i++)
                        {       if(!AT90S2323_ReadProgramMemory(i,1))           // пробуем прочитать байт программы
                                {       TempBuf[0]=i>>8;                        // берём старший байт адреса
                                        BinToHex(TempBuf,OutHexBuf,1);          // преобразуем в строку
                                        OutHexBuf[2]=0;                         // строка должна заканчиваться нулём
                                        TempStr=UpperCase(OutHexBuf);           // переводим в верхний регистр и пишем в строку
                                        TempBuf[0]=i;                           // берём младший байт адреса
                                        BinToHex(TempBuf,OutHexBuf,1);          // преобразуем в строку
                                        OutHexBuf[2]=0;                         // строка должна заканчиваться нулём
                                        TempStr+=UpperCase(OutHexBuf);          // переводим в верхний регистр и дописываем к строке

                                        SendMsgToLog(19," with fail. Address: 0x" + TempStr);   // если вернуло false - не совпало
                                        SendEndTimeToLog();                                     // пишем в лог время окончания операции
                                        LBar->Free();                                           // уничтожаем форму с прогресс-баром
                                        return;                                                 // выходим
                                }
                                // если прочитали количество байт кратное 32-м
                                if((i+1)%32==0)
                                {       LBar->ProgressBar1->Position=100*(i+1)/SelectedChip.Area1Size;  // вычисляем новую позицию прогресс-бара
                                }
                        }
                        break;
    case 0x1911E:       // выбран чип AT90S2313
                        if(!AT90S2313_ProgrammingEnable())      // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                SendEndTimeToLog();             // пишем в лог время окончания операции
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого можно уже и читать
                        for(unsigned int i=0; i<SelectedChip.Area1Size; i++)
                        {       if(!AT90S2313_ReadProgramMemory(i,1))           // пробуем прочитать байт программы
                                {       TempBuf[0]=i>>8;                        // берём старший байт адреса
                                        BinToHex(TempBuf,OutHexBuf,1);          // преобразуем в строку
                                        OutHexBuf[2]=0;                         // строка должна заканчиваться нулём
                                        TempStr=UpperCase(OutHexBuf);           // переводим в верхний регистр и пишем в строку
                                        TempBuf[0]=i;                           // берём младший байт адреса
                                        BinToHex(TempBuf,OutHexBuf,1);          // преобразуем в строку
                                        OutHexBuf[2]=0;                         // строка должна заканчиваться нулём
                                        TempStr+=UpperCase(OutHexBuf);          // переводим в верхний регистр и дописываем к строке

                                        SendMsgToLog(19," with fail. Address: 0x" + TempStr);   // если вернуло false - не совпало
                                        SendEndTimeToLog();                                     // пишем в лог время окончания операции
                                        LBar->Free();                                           // уничтожаем форму с прогресс-баром
                                        return;                                                 // выходим
                                }
                                // если прочитали количество байт кратное 32-м
                                if((i+1)%32==0)
                                {       LBar->ProgressBar1->Position=100*(i+1)/SelectedChip.Area1Size;  // вычисляем новую позицию прогресс-бара
                                }
                        }
                        break;
    case 0x1901E:       // выбран чип AT90S1200
                        if(!AT90S1200_ProgrammingEnable())      // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                SendEndTimeToLog();             // пишем в лог время окончания операции
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого можно уже и читать
                        for(unsigned int i=0; i<SelectedChip.Area1Size; i++)
                        {       if(!AT90S1200_ReadProgramMemory(i,1))           // пробуем прочитать байт программы
                                {       TempBuf[0]=i>>8;                        // берём старший байт адреса
                                        BinToHex(TempBuf,OutHexBuf,1);          // преобразуем в строку
                                        OutHexBuf[2]=0;                         // строка должна заканчиваться нулём
                                        TempStr=UpperCase(OutHexBuf);           // переводим в верхний регистр и пишем в строку
                                        TempBuf[0]=i;                           // берём младший байт адреса
                                        BinToHex(TempBuf,OutHexBuf,1);          // преобразуем в строку
                                        OutHexBuf[2]=0;                         // строка должна заканчиваться нулём
                                        TempStr+=UpperCase(OutHexBuf);          // переводим в верхний регистр и дописываем к строке

                                        SendMsgToLog(19," with fail. Address: 0x" + TempStr);   // если вернуло false - не совпало
                                        SendEndTimeToLog();                                     // пишем в лог время окончания операции
                                        LBar->Free();                                           // уничтожаем форму с прогресс-баром
                                        return;                                                 // выходим
                                }
                                // если прочитали количество байт кратное 32-м
                                if((i+1)%32==0)
                                {       LBar->ProgressBar1->Position=100*(i+1)/SelectedChip.Area1Size;  // вычисляем новую позицию прогресс-бара
                                }
                        }
                        break;
    case 0xA911E:       // выбрано устройство ATtiny2313
                        if(!ATtiny2313_ProgrammingEnable())     // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                SendEndTimeToLog();             // пишем в лог время окончания операции
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого можно уже и читать
                        for(unsigned int i=0; i<SelectedChip.Area1Size; i++)
                        {       if(!ATtiny2313_ReadProgramMemory(i,1))          // пробуем прочитать байт программы
                                {       TempBuf[0]=i>>8;                        // берём старший байт адреса
                                        BinToHex(TempBuf,OutHexBuf,1);          // преобразуем в строку
                                        OutHexBuf[2]=0;                         // строка должна заканчиваться нулём
                                        TempStr=UpperCase(OutHexBuf);           // переводим в верхний регистр и пишем в строку
                                        TempBuf[0]=i;                           // берём младший байт адреса
                                        BinToHex(TempBuf,OutHexBuf,1);          // преобразуем в строку
                                        OutHexBuf[2]=0;                         // строка должна заканчиваться нулём
                                        TempStr+=UpperCase(OutHexBuf);          // переводим в верхний регистр и дописываем к строке

                                        SendMsgToLog(19," with fail. Address: 0x" + TempStr);   // если вернуло false - не совпало
                                        SendEndTimeToLog();                                     // пишем в лог время окончания операции
                                        LBar->Free();                                           // уничтожаем форму с прогресс-баром
                                        return;                                                 // выходим
                                }
                                // если прочитали количество байт кратное 32-м
                                if((i+1)%32==0)
                                {       LBar->ProgressBar1->Position=100*(i+1)/SelectedChip.Area1Size;  // вычисляем новую позицию прогресс-бара
                                }
                        }
                        break;
    case 0:     SendMsgToLog(14,"");            // сообщение в лог, что не выбран ни один чип
                SendEndTimeToLog();             // пишем в лог время окончания операции
                LBar->Free();                   // уничтожаем форму с прогресс-баром
                return;                         // выходим
    default:    SendMsgToLog(15," unknown");    // сообщение в лог, что чип нам неизвестен и выходим
                SendEndTimeToLog();             // пишем в лог время окончания операции
                LBar->Free();                   // уничтожаем форму с прогресс-баром
                return;                         // выходим
  }
  LBar->Free();         // уничтожаем форму с прогресс-баром
  SendMsgToLog(19,". No differences found.");  // сообщаем о завершении операции
  SendEndTimeToLog();   // пишем в лог время окончания операции
}
//---------------------------------------------------------------------------
//--- НАЖАТА КНОПКА VERIFY DATA ---------------------------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::Button10Click(TObject *Sender)
{ char TempBuf[1], OutHexBuf[3];        // для преобразования
  AnsiString TempStr;                   // временная переменная для вывода адреса

  // сначала нужно поместить в память данные с формы, в зависимости от вкладки
  switch(Form1->PageControl1->TabIndex)
  {       case 0: GetDataToMemory(3,2);      // из RichEdit3 в Area2
                  break;
          case 1: GetDataToMemory(4,2);      // из RichEdit4 в Area2
                  break;
          default: break;
  }

  // включаем прогресс-бар
  Application->CreateForm(__classid(TLBar),&LBar);      // создаём форму с прогресс-баром
  LBar->Show();                                         // показываем её в немодальном окне

  SendMsgToLog(18," verify the EEPROM");        // сообщаем о попытке проверить EEPROM
  SendStartTimeToLog();                         // пишем в лог время начала операции
  switch(SelectedChip.ID)
  { case 0xD931E:       // выбрано устройство ATtiny861
    case 0x8921E:       // выбрано устройство ATtiny461
    case 0xC911E:       // выбрано устройство ATtiny261
                        if(!ATtiny261_ProgrammingEnable())     // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                SendEndTimeToLog();             // пишем в лог время окончания операции
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого можно уже и читать
                        for(unsigned int i=0; i<SelectedChip.Area2Size; i++)
                        {       if(!ATtiny261_ReadEEPROMMemory(i,1))             // пробуем прочитать байт EEPROM
                                {       TempBuf[0]=i>>8;                        // берём старший байт адреса
                                        BinToHex(TempBuf,OutHexBuf,1);          // преобразуем в строку
                                        OutHexBuf[2]=0;                         // строка должна заканчиваться нулём
                                        TempStr=UpperCase(OutHexBuf);           // переводим в верхний регистр и пишем в строку
                                        TempBuf[0]=i;                           // берём младший байт адреса
                                        BinToHex(TempBuf,OutHexBuf,1);          // преобразуем в строку
                                        OutHexBuf[2]=0;                         // строка должна заканчиваться нулём
                                        TempStr+=UpperCase(OutHexBuf);          // переводим в верхний регистр и дописываем к строке

                                        SendMsgToLog(19," with fail. Address: 0x" + TempStr);   // если вернуло false - не совпало
                                        SendEndTimeToLog();                                     // пишем в лог время окончания операции
                                        LBar->Free();                                           // уничтожаем форму с прогресс-баром
                                        return;                                                 // выходим
                                }
                                // если прочитали количество байт кратное 4-м
                                if((i+1)%4==0)
                                {       LBar->ProgressBar1->Position=100*(i+1)/SelectedChip.Area2Size;  // вычисляем новую позицию прогресс-бара
                                }
                        }
                        break;
    case 0x9911E:       // выбрано устройство ATtiny26
                        if(!ATtiny26_ProgrammingEnable())     // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                SendEndTimeToLog();             // пишем в лог время окончания операции
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого можно уже и читать
                        for(unsigned int i=0; i<SelectedChip.Area2Size; i++)
                        {       if(!ATtiny26_ReadEEPROMMemory(i,1))             // пробуем прочитать байт EEPROM
                                {       TempBuf[0]=i>>8;                        // берём старший байт адреса
                                        BinToHex(TempBuf,OutHexBuf,1);          // преобразуем в строку
                                        OutHexBuf[2]=0;                         // строка должна заканчиваться нулём
                                        TempStr=UpperCase(OutHexBuf);           // переводим в верхний регистр и пишем в строку
                                        TempBuf[0]=i;                           // берём младший байт адреса
                                        BinToHex(TempBuf,OutHexBuf,1);          // преобразуем в строку
                                        OutHexBuf[2]=0;                         // строка должна заканчиваться нулём
                                        TempStr+=UpperCase(OutHexBuf);          // переводим в верхний регистр и дописываем к строке

                                        SendMsgToLog(19," with fail. Address: 0x" + TempStr);   // если вернуло false - не совпало
                                        SendEndTimeToLog();                                     // пишем в лог время окончания операции
                                        LBar->Free();                                           // уничтожаем форму с прогресс-баром
                                        return;                                                 // выходим
                                }
                                // если прочитали количество байт кратное 4-м
                                if((i+1)%4==0)
                                {       LBar->ProgressBar1->Position=100*(i+1)/SelectedChip.Area2Size;  // вычисляем новую позицию прогресс-бара
                                }
                        }
                        break;
    case 0xB931E:       // выбрано устройство ATtiny85
    case 0x6921E:       // выбрано устройство ATtiny45
    case 0x8911E:       // выбрано устройство ATtiny25
                        if(!ATtiny25_ProgrammingEnable())     // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                SendEndTimeToLog();             // пишем в лог время окончания операции
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого можно уже и читать
                        for(unsigned int i=0; i<SelectedChip.Area2Size; i++)
                        {       if(!ATtiny25_ReadEEPROMMemory(i,1))             // пробуем прочитать байт EEPROM
                                {       TempBuf[0]=i>>8;                        // берём старший байт адреса
                                        BinToHex(TempBuf,OutHexBuf,1);          // преобразуем в строку
                                        OutHexBuf[2]=0;                         // строка должна заканчиваться нулём
                                        TempStr=UpperCase(OutHexBuf);           // переводим в верхний регистр и пишем в строку
                                        TempBuf[0]=i;                           // берём младший байт адреса
                                        BinToHex(TempBuf,OutHexBuf,1);          // преобразуем в строку
                                        OutHexBuf[2]=0;                         // строка должна заканчиваться нулём
                                        TempStr+=UpperCase(OutHexBuf);          // переводим в верхний регистр и дописываем к строке

                                        SendMsgToLog(19," with fail. Address: 0x" + TempStr);   // если вернуло false - не совпало
                                        SendEndTimeToLog();                                     // пишем в лог время окончания операции
                                        LBar->Free();                                           // уничтожаем форму с прогресс-баром
                                        return;                                                 // выходим
                                }
                                // если прочитали количество байт кратное 4-м
                                if((i+1)%4==0)
                                {       LBar->ProgressBar1->Position=100*(i+1)/SelectedChip.Area2Size;  // вычисляем новую позицию прогресс-бара
                                }
                        }
                        break;
    case 0x6911E:       // выбран чип ATtiny22
                        if(!ATtiny22_ProgrammingEnable())      // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                SendEndTimeToLog();             // пишем в лог время окончания операции
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого можно уже и читать
                        for(unsigned int i=0; i<SelectedChip.Area2Size; i++)
                        {       if(!ATtiny22_ReadEEPROMMemory(i,1))            // пробуем прочитать байт EEPROM
                                {       TempBuf[0]=i>>8;                        // берём старший байт адреса
                                        BinToHex(TempBuf,OutHexBuf,1);          // преобразуем в строку
                                        OutHexBuf[2]=0;                         // строка должна заканчиваться нулём
                                        TempStr=UpperCase(OutHexBuf);           // переводим в верхний регистр и пишем в строку
                                        TempBuf[0]=i;                           // берём младший байт адреса
                                        BinToHex(TempBuf,OutHexBuf,1);          // преобразуем в строку
                                        OutHexBuf[2]=0;                         // строка должна заканчиваться нулём
                                        TempStr+=UpperCase(OutHexBuf);          // переводим в верхний регистр и дописываем к строке

                                        SendMsgToLog(19," with fail. Address: 0x" + TempStr);   // если вернуло false - не совпало
                                        SendEndTimeToLog();                                     // пишем в лог время окончания операции
                                        LBar->Free();                                           // уничтожаем форму с прогресс-баром
                                        return;                                                 // выходим
                                }
                                // если прочитали количество байт кратное 4-м
                                if((i+1)%4==0)
                                {       LBar->ProgressBar1->Position=100*(i+1)/SelectedChip.Area2Size;  // вычисляем новую позицию прогресс-бара
                                }
                        }
                        break;
    case 0x6901E:       // выбран чип ATtiny15
                        if(!ATtiny15_ProgrammingEnable())      // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                SendEndTimeToLog();             // пишем в лог время окончания операции
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого можно уже и читать
                        for(unsigned int i=0; i<SelectedChip.Area2Size; i++)
                        {       if(!ATtiny15_ReadEEPROMMemory(i,1))            // пробуем прочитать байт EEPROM
                                {       TempBuf[0]=i>>8;                        // берём старший байт адреса
                                        BinToHex(TempBuf,OutHexBuf,1);          // преобразуем в строку
                                        OutHexBuf[2]=0;                         // строка должна заканчиваться нулём
                                        TempStr=UpperCase(OutHexBuf);           // переводим в верхний регистр и пишем в строку
                                        TempBuf[0]=i;                           // берём младший байт адреса
                                        BinToHex(TempBuf,OutHexBuf,1);          // преобразуем в строку
                                        OutHexBuf[2]=0;                         // строка должна заканчиваться нулём
                                        TempStr+=UpperCase(OutHexBuf);          // переводим в верхний регистр и дописываем к строке

                                        SendMsgToLog(19," with fail. Address: 0x" + TempStr);   // если вернуло false - не совпало
                                        SendEndTimeToLog();                                     // пишем в лог время окончания операции
                                        LBar->Free();                                           // уничтожаем форму с прогресс-баром
                                        return;                                                 // выходим
                                }
                                // если прочитали количество байт кратное 4-м
                                if((i+1)%4==0)
                                {       LBar->ProgressBar1->Position=100*(i+1)/SelectedChip.Area2Size;  // вычисляем новую позицию прогресс-бара
                                }
                        }
                        break;
    case 0x7901E:       // выбран чип ATtiny13
                        if(!ATtiny13_ProgrammingEnable())      // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                SendEndTimeToLog();             // пишем в лог время окончания операции
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого можно уже и читать
                        for(unsigned int i=0; i<SelectedChip.Area2Size; i++)
                        {       if(!ATtiny13_ReadEEPROMMemory(i,1))            // пробуем прочитать байт EEPROM
                                {       TempBuf[0]=i>>8;                        // берём старший байт адреса
                                        BinToHex(TempBuf,OutHexBuf,1);          // преобразуем в строку
                                        OutHexBuf[2]=0;                         // строка должна заканчиваться нулём
                                        TempStr=UpperCase(OutHexBuf);           // переводим в верхний регистр и пишем в строку
                                        TempBuf[0]=i;                           // берём младший байт адреса
                                        BinToHex(TempBuf,OutHexBuf,1);          // преобразуем в строку
                                        OutHexBuf[2]=0;                         // строка должна заканчиваться нулём
                                        TempStr+=UpperCase(OutHexBuf);          // переводим в верхний регистр и дописываем к строке

                                        SendMsgToLog(19," with fail. Address: 0x" + TempStr);   // если вернуло false - не совпало
                                        SendEndTimeToLog();                                     // пишем в лог время окончания операции
                                        LBar->Free();                                           // уничтожаем форму с прогресс-баром
                                        return;                                                 // выходим
                                }
                                // если прочитали количество байт кратное 4-м
                                if((i+1)%4==0)
                                {       LBar->ProgressBar1->Position=100*(i+1)/SelectedChip.Area2Size;  // вычисляем новую позицию прогресс-бара
                                }
                        }
                        break;
    case 0x5901E:       // выбран чип ATtiny12
                        if(!ATtiny12_ProgrammingEnable())      // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                SendEndTimeToLog();             // пишем в лог время окончания операции
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого можно уже и читать
                        for(unsigned int i=0; i<SelectedChip.Area2Size; i++)
                        {       if(!ATtiny12_ReadEEPROMMemory(i,1))            // пробуем прочитать байт EEPROM
                                {       TempBuf[0]=i>>8;                        // берём старший байт адреса
                                        BinToHex(TempBuf,OutHexBuf,1);          // преобразуем в строку
                                        OutHexBuf[2]=0;                         // строка должна заканчиваться нулём
                                        TempStr=UpperCase(OutHexBuf);           // переводим в верхний регистр и пишем в строку
                                        TempBuf[0]=i;                           // берём младший байт адреса
                                        BinToHex(TempBuf,OutHexBuf,1);          // преобразуем в строку
                                        OutHexBuf[2]=0;                         // строка должна заканчиваться нулём
                                        TempStr+=UpperCase(OutHexBuf);          // переводим в верхний регистр и дописываем к строке

                                        SendMsgToLog(19," with fail. Address: 0x" + TempStr);   // если вернуло false - не совпало
                                        SendEndTimeToLog();                                     // пишем в лог время окончания операции
                                        LBar->Free();                                           // уничтожаем форму с прогресс-баром
                                        return;                                                 // выходим
                                }
                                // если прочитали количество байт кратное 4-м
                                if((i+1)%4==0)
                                {       LBar->ProgressBar1->Position=100*(i+1)/SelectedChip.Area2Size;  // вычисляем новую позицию прогресс-бара
                                }
                        }
                        break;
    case 0x81971E:      // выбрано устройство AT90CAN128
    case 0x81961E:      // выбрано устройство AT90CAN64
    case 0x81951E:      // выбрано устройство AT90CAN32
                        if(!AT90CAN32_ProgrammingEnable())     // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                SendEndTimeToLog();             // пишем в лог время окончания операции
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого можно уже и читать
                        for(unsigned int i=0; i<SelectedChip.Area2Size; i++)
                        {       if(!AT90CAN32_ReadEEPROMMemory(i,1))                           // пробуем прочитать байт EEPROM
                                {       TempBuf[0]=i>>8;                        // берём старший байт адреса
                                        BinToHex(TempBuf,OutHexBuf,1);          // преобразуем в строку
                                        OutHexBuf[2]=0;                         // строка должна заканчиваться нулём
                                        TempStr=UpperCase(OutHexBuf);           // переводим в верхний регистр и пишем в строку
                                        TempBuf[0]=i;                           // берём младший байт адреса
                                        BinToHex(TempBuf,OutHexBuf,1);          // преобразуем в строку
                                        OutHexBuf[2]=0;                         // строка должна заканчиваться нулём
                                        TempStr+=UpperCase(OutHexBuf);          // переводим в верхний регистр и дописываем к строке

                                        SendMsgToLog(19," with fail. Address: 0x" + TempStr);   // если вернуло false - не совпало
                                        SendEndTimeToLog();                                     // пишем в лог время окончания операции
                                        LBar->Free();                                           // уничтожаем форму с прогресс-баром
                                        return;                                                 // выходим
                                }
                                // если прочитали количество байт кратное 8-и
                                if((i+1)%8==0)
                                {       LBar->ProgressBar1->Position=100*(i+1)/SelectedChip.Area2Size;  // вычисляем новую позицию прогресс-бара
                                }
                        }
                        break;
    case 0x3931E:       // выбран чип AT90S8535
    case 0x2921E:       // выбран чип AT90S4434
                        if(!AT90S4434_ProgrammingEnable())      // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                SendEndTimeToLog();             // пишем в лог время окончания операции
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого можно уже и читать
                        for(unsigned int i=0; i<SelectedChip.Area2Size; i++)
                        {       if(!AT90S4434_ReadEEPROMMemory(i,1))            // пробуем прочитать байт EEPROM
                                {       TempBuf[0]=i>>8;                        // берём старший байт адреса
                                        BinToHex(TempBuf,OutHexBuf,1);          // преобразуем в строку
                                        OutHexBuf[2]=0;                         // строка должна заканчиваться нулём
                                        TempStr=UpperCase(OutHexBuf);           // переводим в верхний регистр и пишем в строку
                                        TempBuf[0]=i;                           // берём младший байт адреса
                                        BinToHex(TempBuf,OutHexBuf,1);          // преобразуем в строку
                                        OutHexBuf[2]=0;                         // строка должна заканчиваться нулём
                                        TempStr+=UpperCase(OutHexBuf);          // переводим в верхний регистр и дописываем к строке

                                        SendMsgToLog(19," with fail. Address: 0x" + TempStr);   // если вернуло false - не совпало
                                        SendEndTimeToLog();                                     // пишем в лог время окончания операции
                                        LBar->Free();                                           // уничтожаем форму с прогресс-баром
                                        return;                                                 // выходим
                                }
                                // если прочитали количество байт кратное 4-м
                                if((i+1)%4==0)
                                {       LBar->ProgressBar1->Position=100*(i+1)/SelectedChip.Area2Size;  // вычисляем новую позицию прогресс-бара
                                }
                        }
                        break;
    case 0x1931E:       // выбран чип AT90S8515
    case 0x1921E:       // выбран чип AT90S4414
                        if(!AT90S4414_ProgrammingEnable())      // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                SendEndTimeToLog();             // пишем в лог время окончания операции
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого можно уже и читать
                        for(unsigned int i=0; i<SelectedChip.Area2Size; i++)
                        {       if(!AT90S4414_ReadEEPROMMemory(i,1))            // пробуем прочитать байт EEPROM
                                {       TempBuf[0]=i>>8;                        // берём старший байт адреса
                                        BinToHex(TempBuf,OutHexBuf,1);          // преобразуем в строку
                                        OutHexBuf[2]=0;                         // строка должна заканчиваться нулём
                                        TempStr=UpperCase(OutHexBuf);           // переводим в верхний регистр и пишем в строку
                                        TempBuf[0]=i;                           // берём младший байт адреса
                                        BinToHex(TempBuf,OutHexBuf,1);          // преобразуем в строку
                                        OutHexBuf[2]=0;                         // строка должна заканчиваться нулём
                                        TempStr+=UpperCase(OutHexBuf);          // переводим в верхний регистр и дописываем к строке

                                        SendMsgToLog(19," with fail. Address: 0x" + TempStr);   // если вернуло false - не совпало
                                        SendEndTimeToLog();                                     // пишем в лог время окончания операции
                                        LBar->Free();                                           // уничтожаем форму с прогресс-баром
                                        return;                                                 // выходим
                                }
                                // если прочитали количество байт кратное 4-м
                                if((i+1)%4==0)
                                {       LBar->ProgressBar1->Position=100*(i+1)/SelectedChip.Area2Size;  // вычисляем новую позицию прогресс-бара
                                }
                        }
                        break;
    case 0x3921E:       // выбран чип AT90S4433
    case 0x5911E:       // выбран чип AT90S2333
                        if(!AT90S2333_ProgrammingEnable())      // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                SendEndTimeToLog();             // пишем в лог время окончания операции
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого можно уже и читать
                        for(unsigned int i=0; i<SelectedChip.Area2Size; i++)
                        {       if(!AT90S2333_ReadEEPROMMemory(i,1))            // пробуем прочитать байт EEPROM
                                {       TempBuf[0]=i>>8;                        // берём старший байт адреса
                                        BinToHex(TempBuf,OutHexBuf,1);          // преобразуем в строку
                                        OutHexBuf[2]=0;                         // строка должна заканчиваться нулём
                                        TempStr=UpperCase(OutHexBuf);           // переводим в верхний регистр и пишем в строку
                                        TempBuf[0]=i;                           // берём младший байт адреса
                                        BinToHex(TempBuf,OutHexBuf,1);          // преобразуем в строку
                                        OutHexBuf[2]=0;                         // строка должна заканчиваться нулём
                                        TempStr+=UpperCase(OutHexBuf);          // переводим в верхний регистр и дописываем к строке

                                        SendMsgToLog(19," with fail. Address: 0x" + TempStr);   // если вернуло false - не совпало
                                        SendEndTimeToLog();                                     // пишем в лог время окончания операции
                                        LBar->Free();                                           // уничтожаем форму с прогресс-баром
                                        return;                                                 // выходим
                                }
                                // если прочитали количество байт кратное 4-м
                                if((i+1)%4==0)
                                {       LBar->ProgressBar1->Position=100*(i+1)/SelectedChip.Area2Size;  // вычисляем новую позицию прогресс-бара
                                }
                        }
                        break;
    case 0x3911E:       // выбран чип AT90S2343
                        if(!AT90S2343_ProgrammingEnable())      // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                SendEndTimeToLog();             // пишем в лог время окончания операции
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого можно уже и читать
                        for(unsigned int i=0; i<SelectedChip.Area2Size; i++)
                        {       if(!AT90S2343_ReadEEPROMMemory(i,1))            // пробуем прочитать байт EEPROM
                                {       TempBuf[0]=i>>8;                        // берём старший байт адреса
                                        BinToHex(TempBuf,OutHexBuf,1);          // преобразуем в строку
                                        OutHexBuf[2]=0;                         // строка должна заканчиваться нулём
                                        TempStr=UpperCase(OutHexBuf);           // переводим в верхний регистр и пишем в строку
                                        TempBuf[0]=i;                           // берём младший байт адреса
                                        BinToHex(TempBuf,OutHexBuf,1);          // преобразуем в строку
                                        OutHexBuf[2]=0;                         // строка должна заканчиваться нулём
                                        TempStr+=UpperCase(OutHexBuf);          // переводим в верхний регистр и дописываем к строке

                                        SendMsgToLog(19," with fail. Address: 0x" + TempStr);   // если вернуло false - не совпало
                                        SendEndTimeToLog();                                     // пишем в лог время окончания операции
                                        LBar->Free();                                           // уничтожаем форму с прогресс-баром
                                        return;                                                 // выходим
                                }
                                // если прочитали количество байт кратное 4-м
                                if((i+1)%4==0)
                                {       LBar->ProgressBar1->Position=100*(i+1)/SelectedChip.Area2Size;  // вычисляем новую позицию прогресс-бара
                                }
                        }
                        break;
    case 0x2911E:       // выбран чип AT90S2323
                        if(!AT90S2323_ProgrammingEnable())      // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                SendEndTimeToLog();             // пишем в лог время окончания операции
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого можно уже и читать
                        for(unsigned int i=0; i<SelectedChip.Area2Size; i++)
                        {       if(!AT90S2323_ReadEEPROMMemory(i,1))            // пробуем прочитать байт EEPROM
                                {       TempBuf[0]=i>>8;                        // берём старший байт адреса
                                        BinToHex(TempBuf,OutHexBuf,1);          // преобразуем в строку
                                        OutHexBuf[2]=0;                         // строка должна заканчиваться нулём
                                        TempStr=UpperCase(OutHexBuf);           // переводим в верхний регистр и пишем в строку
                                        TempBuf[0]=i;                           // берём младший байт адреса
                                        BinToHex(TempBuf,OutHexBuf,1);          // преобразуем в строку
                                        OutHexBuf[2]=0;                         // строка должна заканчиваться нулём
                                        TempStr+=UpperCase(OutHexBuf);          // переводим в верхний регистр и дописываем к строке

                                        SendMsgToLog(19," with fail. Address: 0x" + TempStr);   // если вернуло false - не совпало
                                        SendEndTimeToLog();                                     // пишем в лог время окончания операции
                                        LBar->Free();                                           // уничтожаем форму с прогресс-баром
                                        return;                                                 // выходим
                                }
                                // если прочитали количество байт кратное 4-м
                                if((i+1)%4==0)
                                {       LBar->ProgressBar1->Position=100*(i+1)/SelectedChip.Area2Size;  // вычисляем новую позицию прогресс-бара
                                }
                        }
                        break;
    case 0x1911E:       // выбран чип AT90S2313
                        if(!AT90S2313_ProgrammingEnable())      // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                SendEndTimeToLog();             // пишем в лог время окончания операции
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого можно уже и читать
                        for(unsigned int i=0; i<SelectedChip.Area2Size; i++)
                        {       if(!AT90S2313_ReadEEPROMMemory(i,1))            // пробуем прочитать байт EEPROM
                                {       TempBuf[0]=i>>8;                        // берём старший байт адреса
                                        BinToHex(TempBuf,OutHexBuf,1);          // преобразуем в строку
                                        OutHexBuf[2]=0;                         // строка должна заканчиваться нулём
                                        TempStr=UpperCase(OutHexBuf);           // переводим в верхний регистр и пишем в строку
                                        TempBuf[0]=i;                           // берём младший байт адреса
                                        BinToHex(TempBuf,OutHexBuf,1);          // преобразуем в строку
                                        OutHexBuf[2]=0;                         // строка должна заканчиваться нулём
                                        TempStr+=UpperCase(OutHexBuf);          // переводим в верхний регистр и дописываем к строке

                                        SendMsgToLog(19," with fail. Address: 0x" + TempStr);   // если вернуло false - не совпало
                                        SendEndTimeToLog();                                     // пишем в лог время окончания операции
                                        LBar->Free();                                           // уничтожаем форму с прогресс-баром
                                        return;                                                 // выходим
                                }
                                // если прочитали количество байт кратное 4-м
                                if((i+1)%4==0)
                                {       LBar->ProgressBar1->Position=100*(i+1)/SelectedChip.Area2Size;  // вычисляем новую позицию прогресс-бара
                                }
                        }
                        break;
    case 0x1901E:       // выбран чип AT90S1200
                        if(!AT90S1200_ProgrammingEnable())      // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                SendEndTimeToLog();             // пишем в лог время окончания операции
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого можно уже и читать
                        for(unsigned int i=0; i<SelectedChip.Area2Size; i++)
                        {       if(!AT90S1200_ReadEEPROMMemory(i,1))            // пробуем прочитать байт EEPROM
                                {       TempBuf[0]=i>>8;                        // берём старший байт адреса
                                        BinToHex(TempBuf,OutHexBuf,1);          // преобразуем в строку
                                        OutHexBuf[2]=0;                         // строка должна заканчиваться нулём
                                        TempStr=UpperCase(OutHexBuf);           // переводим в верхний регистр и пишем в строку
                                        TempBuf[0]=i;                           // берём младший байт адреса
                                        BinToHex(TempBuf,OutHexBuf,1);          // преобразуем в строку
                                        OutHexBuf[2]=0;                         // строка должна заканчиваться нулём
                                        TempStr+=UpperCase(OutHexBuf);          // переводим в верхний регистр и дописываем к строке

                                        SendMsgToLog(19," with fail. Address: 0x" + TempStr);   // если вернуло false - не совпало
                                        SendEndTimeToLog();                                     // пишем в лог время окончания операции
                                        LBar->Free();                                           // уничтожаем форму с прогресс-баром
                                        return;                                                 // выходим
                                }
                                // если прочитали количество байт кратное 4-м
                                if((i+1)%4==0)
                                {       LBar->ProgressBar1->Position=100*(i+1)/SelectedChip.Area2Size;  // вычисляем новую позицию прогресс-бара
                                }
                        }
                        break;
    case 0xA911E:       // выбрано устройство ATtiny2313
                        if(!ATtiny2313_ProgrammingEnable())     // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                SendEndTimeToLog();             // пишем в лог время окончания операции
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого можно уже и читать
                        for(unsigned int i=0; i<SelectedChip.Area2Size; i++)
                        {       if(!ATtiny2313_ReadEEPROMMemory(i,1))                           // пробуем прочитать байт EEPROM
                                {       TempBuf[0]=i>>8;                        // берём старший байт адреса
                                        BinToHex(TempBuf,OutHexBuf,1);          // преобразуем в строку
                                        OutHexBuf[2]=0;                         // строка должна заканчиваться нулём
                                        TempStr=UpperCase(OutHexBuf);           // переводим в верхний регистр и пишем в строку
                                        TempBuf[0]=i;                           // берём младший байт адреса
                                        BinToHex(TempBuf,OutHexBuf,1);          // преобразуем в строку
                                        OutHexBuf[2]=0;                         // строка должна заканчиваться нулём
                                        TempStr+=UpperCase(OutHexBuf);          // переводим в верхний регистр и дописываем к строке

                                        SendMsgToLog(19," with fail. Address: 0x" + TempStr);   // если вернуло false - не совпало
                                        SendEndTimeToLog();                                     // пишем в лог время окончания операции
                                        LBar->Free();                                           // уничтожаем форму с прогресс-баром
                                        return;                                                 // выходим
                                }
                                // если прочитали количество байт кратное 4-м
                                if((i+1)%4==0)
                                {       LBar->ProgressBar1->Position=100*(i+1)/SelectedChip.Area2Size;  // вычисляем новую позицию прогресс-бара
                                }
                        }
                        break;
    case 0:     SendMsgToLog(14,"");            // сообщение в лог, что не выбран ни один чип
                SendEndTimeToLog();             // пишем в лог время окончания операции
                LBar->Free();                   // уничтожаем форму с прогресс-баром
                return;                         // выходим
    default:    SendMsgToLog(15," unknown");    // сообщение в лог, что чип нам неизвестен и выходим
                SendEndTimeToLog();             // пишем в лог время окончания операции
                LBar->Free();                   // уничтожаем форму с прогресс-баром
                return;                         // выходим
  }
  LBar->Free();         // уничтожаем форму с прогресс-баром
  SendMsgToLog(19,". No differences found.");  // сообщаем о завершении операции
  SendEndTimeToLog();   // пишем в лог время окончания операции
}
//---------------------------------------------------------------------------
//--- НАЖАТА КНОПКА WRITE PROGRAM -------------------------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::Button5Click(TObject *Sender)
{ if (Application->MessageBox("All previous chip data will be lost (Flash, EEPROM, Lock Bits). Are you sure?", "Warning", MB_YESNO|MB_ICONWARNING|MB_DEFBUTTON2|MB_APPLMODAL) == IDYES)
  {     // сначала нужно поместить в память данные с формы, в зависимости от вкладки
        switch(Form1->PageControl1->TabIndex)
        {       case 0: GetDataToMemory(1,1);      // из RichEdit1 в Area1
                        break;
                case 1: GetDataToMemory(2,1);      // из RichEdit2 в Area1
                        break;
                default: break;
        }

        // включаем прогресс-бар
        Application->CreateForm(__classid(TLBar),&LBar);      // создаём форму с прогресс-баром
        LBar->Show();                                         // показываем её в немодальном окне

        SendMsgToLog(18," write the program");        // сообщаем о попытке записать программу
        SendStartTimeToLog();                         // пишем в лог время начала операции
        switch(SelectedChip.ID)
        { case 0xD931E: // выбрано устройство ATtiny861
          case 0x8921E: // выбрано устройство ATtiny461
          case 0xC911E: // выбрано устройство ATtiny261
                        if(!ATtiny261_ProgrammingEnable())     // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                SendEndTimeToLog();             // пишем в лог время окончания операции
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // прежде, чем писать во флеш, - нужно всё стереть
                        if(!ATtiny261_ChipErase())             // пробуем стереть чип
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось стереть
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого ещё раз ProgrammingEnable и можно писать
                        if(!ATtiny261_ProgrammingEnable())     // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                SendEndTimeToLog();             // пишем в лог время окончания операции
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        for(unsigned int i=0; i<SelectedChip.Area1Size; i++)
                        {       if(!ATtiny261_LoadProgramMemoryPage(i))        // пишем байт в страницу буфера
                                {       SendMsgToLog(19," with fail.");         // если вернуло false - не удалось прочитать
                                        SendEndTimeToLog();                     // пишем в лог время окончания операции
                                        LBar->Free();                           // уничтожаем форму с прогресс-баром
                                        return;                                 // выходим
                                }
                                // если передали количество байт кратное 32-м (размер буфера = 16 слов = 32 байта) - пробуем записать буфер в память
                                if((i+1)%32==0)
                                {       if(!ATtiny261_WriteProgramMemoryPage(i))       // пишем страницу буфера в память
                                        {       SendMsgToLog(19," with fail.");         // если вернуло false - не удалось записать
                                                SendEndTimeToLog();                     // пишем в лог время окончания операции
                                                LBar->Free();                           // уничтожаем форму с прогресс-баром
                                                return;                                 // выходим
                                        }
                                        LBar->ProgressBar1->Position=100*(i+1)/SelectedChip.Area1Size;  // вычисляем новую позицию прогресс-бара
                                }
                        }
                        break;
          case 0x9911E: // выбрано устройство ATtiny26
                        if(!ATtiny26_ProgrammingEnable())     // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                SendEndTimeToLog();             // пишем в лог время окончания операции
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // прежде, чем писать во флеш, - нужно всё стереть
                        if(!ATtiny26_ChipErase())             // пробуем стереть чип
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось стереть
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого ещё раз ProgrammingEnable и можно писать
                        if(!ATtiny26_ProgrammingEnable())     // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                SendEndTimeToLog();             // пишем в лог время окончания операции
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        for(unsigned int i=0; i<SelectedChip.Area1Size; i++)
                        {       if(!ATtiny26_LoadProgramMemoryPage(i))        // пишем байт в страницу буфера
                                {       SendMsgToLog(19," with fail.");         // если вернуло false - не удалось прочитать
                                        SendEndTimeToLog();                     // пишем в лог время окончания операции
                                        LBar->Free();                           // уничтожаем форму с прогресс-баром
                                        return;                                 // выходим
                                }
                                // если передали количество байт кратное 32-м (размер буфера = 16 слов = 32 байта) - пробуем записать буфер в память
                                if((i+1)%32==0)
                                {       if(!ATtiny26_WriteProgramMemoryPage(i))       // пишем страницу буфера в память
                                        {       SendMsgToLog(19," with fail.");         // если вернуло false - не удалось записать
                                                SendEndTimeToLog();                     // пишем в лог время окончания операции
                                                LBar->Free();                           // уничтожаем форму с прогресс-баром
                                                return;                                 // выходим
                                        }
                                        LBar->ProgressBar1->Position=100*(i+1)/SelectedChip.Area1Size;  // вычисляем новую позицию прогресс-бара
                                }
                        }
                        break;
          case 0xB931E: // выбрано устройство ATtiny85
          case 0x6921E: // выбрано устройство ATtiny45
          case 0x8911E: // выбрано устройство ATtiny25
                        if(!ATtiny25_ProgrammingEnable())     // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                SendEndTimeToLog();             // пишем в лог время окончания операции
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // прежде, чем писать во флеш, - нужно всё стереть
                        if(!ATtiny25_ChipErase())             // пробуем стереть чип
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось стереть
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого ещё раз ProgrammingEnable и можно писать
                        if(!ATtiny25_ProgrammingEnable())     // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                SendEndTimeToLog();             // пишем в лог время окончания операции
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        for(unsigned int i=0; i<SelectedChip.Area1Size; i++)
                        {       if(!ATtiny25_LoadProgramMemoryPage(i))        // пишем байт в страницу буфера
                                {       SendMsgToLog(19," with fail.");         // если вернуло false - не удалось прочитать
                                        SendEndTimeToLog();                     // пишем в лог время окончания операции
                                        LBar->Free();                           // уничтожаем форму с прогресс-баром
                                        return;                                 // выходим
                                }
                                // если передали количество байт кратное 32-м (размер буфера = 16 слов = 32 байта) - пробуем записать буфер в память
                                if((i+1)%32==0)
                                {       if(!ATtiny25_WriteProgramMemoryPage(i))       // пишем страницу буфера в память
                                        {       SendMsgToLog(19," with fail.");         // если вернуло false - не удалось записать
                                                SendEndTimeToLog();                     // пишем в лог время окончания операции
                                                LBar->Free();                           // уничтожаем форму с прогресс-баром
                                                return;                                 // выходим
                                        }
                                        LBar->ProgressBar1->Position=100*(i+1)/SelectedChip.Area1Size;  // вычисляем новую позицию прогресс-бара
                                }
                        }
                        break;
          case 0x6911E: // выбрано устройство ATtiny22
                        if(!ATtiny22_ProgrammingEnable())     // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                SendEndTimeToLog();             // пишем в лог время окончания операции
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // прежде, чем писать во флеш, - нужно всё стереть
                        if(!ATtiny22_ChipErase())             // пробуем стереть чип
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось стереть
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого ещё раз ProgrammingEnable и можно писать
                        if(!ATtiny22_ProgrammingEnable())     // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                SendEndTimeToLog();             // пишем в лог время окончания операции
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        for(unsigned int i=0; i<SelectedChip.Area1Size; i++)
                        {       if(!ATtiny22_WriteProgramMemory(i))            // пишем байт в страницу буфера
                                {       SendMsgToLog(19," with fail.");         // если вернуло false - не удалось прочитать
                                        SendEndTimeToLog();                     // пишем в лог время окончания операции
                                        LBar->Free();                           // уничтожаем форму с прогресс-баром
                                        return;                                 // выходим
                                }
                                // если передали количество байт кратное 32-м - меняем позицию progress bara
                                if((i+1)%32==0)
                                {       LBar->ProgressBar1->Position=100*(i+1)/SelectedChip.Area1Size;  // вычисляем новую позицию прогресс-бара
                                }
                        }
                        break;
          case 0x6901E: // выбрано устройство ATtiny15
                        if(!ATtiny15_ProgrammingEnable())     // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                SendEndTimeToLog();             // пишем в лог время окончания операции
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // прежде, чем писать во флеш, - нужно всё стереть
                        if(!ATtiny15_ChipErase())             // пробуем стереть чип
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось стереть
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого ещё раз ProgrammingEnable и можно писать
                        if(!ATtiny15_ProgrammingEnable())     // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                SendEndTimeToLog();             // пишем в лог время окончания операции
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        for(unsigned int i=0; i<SelectedChip.Area1Size; i++)
                        {       if(!ATtiny15_WriteProgramMemory(i))            // пишем байт в страницу буфера
                                {       SendMsgToLog(19," with fail.");         // если вернуло false - не удалось прочитать
                                        SendEndTimeToLog();                     // пишем в лог время окончания операции
                                        LBar->Free();                           // уничтожаем форму с прогресс-баром
                                        return;                                 // выходим
                                }
                                // если передали количество байт кратное 32-м - меняем позицию progress bara
                                if((i+1)%32==0)
                                {       LBar->ProgressBar1->Position=100*(i+1)/SelectedChip.Area1Size;  // вычисляем новую позицию прогресс-бара
                                }
                        }
                        break;
          case 0x7901E: // выбрано устройство ATtiny13
                        if(!ATtiny13_ProgrammingEnable())     // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                SendEndTimeToLog();             // пишем в лог время окончания операции
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // прежде, чем писать во флеш, - нужно всё стереть
                        if(!ATtiny13_ChipErase())             // пробуем стереть чип
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось стереть
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого ещё раз ProgrammingEnable и можно писать
                        if(!ATtiny13_ProgrammingEnable())     // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                SendEndTimeToLog();             // пишем в лог время окончания операции
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        for(unsigned int i=0; i<SelectedChip.Area1Size; i++)
                        {       if(!ATtiny13_LoadProgramMemoryPage(i))        // пишем байт в страницу буфера
                                {       SendMsgToLog(19," with fail.");         // если вернуло false - не удалось прочитать
                                        SendEndTimeToLog();                     // пишем в лог время окончания операции
                                        LBar->Free();                           // уничтожаем форму с прогресс-баром
                                        return;                                 // выходим
                                }
                                // если передали количество байт кратное 32-м (размер буфера = 16 слов = 32 байта) - пробуем записать буфер в память
                                if((i+1)%32==0)
                                {       if(!ATtiny13_WriteProgramMemoryPage(i))       // пишем страницу буфера в память
                                        {       SendMsgToLog(19," with fail.");         // если вернуло false - не удалось записать
                                                SendEndTimeToLog();                     // пишем в лог время окончания операции
                                                LBar->Free();                           // уничтожаем форму с прогресс-баром
                                                return;                                 // выходим
                                        }
                                        LBar->ProgressBar1->Position=100*(i+1)/SelectedChip.Area1Size;  // вычисляем новую позицию прогресс-бара
                                }
                        }
                        break;
          case 0x5901E: // выбран чип ATtiny12
                        if(!ATtiny12_ProgrammingEnable())      // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // прежде чем писать во флеш нужно всё стереть, а алгоритм стирания в этом чипе кривой
                        if(!ATtiny12_ChipErase())              // пробуем стереть чип
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось стереть
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        if(!ATtiny12_ProgrammingEnable())      // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        if(!ATtiny12_WriteFFTo0ProgramMemory()) // пробуем записать 0xFF во флеш по адресу 0x0
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        if(!ATtiny12_ChipErase())              // пробуем стереть чип ещё раз (вот такой кривой алгоритм для этого чипа)
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось стереть
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого ещё раз ProgrammingEnable и можно писать
                        if(!ATtiny12_ProgrammingEnable())     // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                SendEndTimeToLog();             // пишем в лог время окончания операции
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        for(unsigned int i=0; i<SelectedChip.Area1Size; i++)
                        {       if(!ATtiny12_WriteProgramMemory(i))            // пишем байт в страницу буфера
                                {       SendMsgToLog(19," with fail.");         // если вернуло false - не удалось прочитать
                                        SendEndTimeToLog();                     // пишем в лог время окончания операции
                                        LBar->Free();                           // уничтожаем форму с прогресс-баром
                                        return;                                 // выходим
                                }
                                // если передали количество байт кратное 32-м - меняем позицию progress bara
                                if((i+1)%32==0)
                                {       LBar->ProgressBar1->Position=100*(i+1)/SelectedChip.Area1Size;  // вычисляем новую позицию прогресс-бара
                                }
                        }
                        break;
          case 0x81971E:// выбрано устройство AT90CAN128
          case 0x81961E:// выбрано устройство AT90CAN64
          case 0x81951E:// выбрано устройство AT90CAN32
                        if(!AT90CAN32_ProgrammingEnable())      // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                SendEndTimeToLog();             // пишем в лог время окончания операции
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // прежде, чем писать во флеш, - нужно всё стереть
                        if(!AT90CAN32_ChipErase())              // пробуем стереть чип
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось стереть
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого ещё раз ProgrammingEnable и можно писать
                        if(!AT90CAN32_ProgrammingEnable())     // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                SendEndTimeToLog();             // пишем в лог время окончания операции
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        for(unsigned int i=0; i<SelectedChip.Area1Size; i++)
                        {       if(!AT90CAN32_LoadProgramMemoryPage(i))         // пишем байт в страницу буфера
                                {       SendMsgToLog(19," with fail.");         // если вернуло false - не удалось прочитать
                                        SendEndTimeToLog();                     // пишем в лог время окончания операции
                                        LBar->Free();                           // уничтожаем форму с прогресс-баром
                                        return;                                 // выходим
                                }
                                // если передали количество байт кратное 256-и (размер буфера = 128 слов = 256 байт) - пробуем записать буфер в память
                                if((i+1)%256==0)
                                {       if(!AT90CAN32_WriteProgramMemoryPage(i))        // пишем страницу буфера в память
                                        {       SendMsgToLog(19," with fail.");         // если вернуло false - не удалось записать
                                                SendEndTimeToLog();                     // пишем в лог время окончания операции
                                                LBar->Free();                           // уничтожаем форму с прогресс-баром
                                                return;                                 // выходим
                                        }
                                        LBar->ProgressBar1->Position=100*(i+1)/SelectedChip.Area1Size;  // вычисляем новую позицию прогресс-бара
                                }
                        }
                        break;
          case 0x3931E: // выбран чип AT90S8535
          case 0x2921E: // выбран чип AT90S4434
                        if(!AT90S4434_ProgrammingEnable())      // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                SendEndTimeToLog();             // пишем в лог время окончания операции
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // прежде, чем писать во флеш, - нужно всё стереть
                        if(!AT90S4434_ChipErase())              // пробуем стереть чип
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось стереть
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого ещё раз ProgrammingEnable и можно писать
                        if(!AT90S4434_ProgrammingEnable())     // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                SendEndTimeToLog();             // пишем в лог время окончания операции
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        for(unsigned int i=0; i<SelectedChip.Area1Size; i++)
                        {       if(!AT90S4434_WriteProgramMemory(i))            // пишем байт в страницу буфера
                                {       SendMsgToLog(19," with fail.");         // если вернуло false - не удалось прочитать
                                        SendEndTimeToLog();                     // пишем в лог время окончания операции
                                        LBar->Free();                           // уничтожаем форму с прогресс-баром
                                        return;                                 // выходим
                                }
                                // если передали количество байт кратное 32-м - меняем позицию progress bara
                                if((i+1)%32==0)
                                {       LBar->ProgressBar1->Position=100*(i+1)/SelectedChip.Area1Size;  // вычисляем новую позицию прогресс-бара
                                }
                        }
                        break;
          case 0x1931E: // выбран чип AT90S8515
          case 0x1921E: // выбран чип AT90S4414
                        if(!AT90S4414_ProgrammingEnable())      // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                SendEndTimeToLog();             // пишем в лог время окончания операции
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // прежде, чем писать во флеш, - нужно всё стереть
                        if(!AT90S4414_ChipErase())              // пробуем стереть чип
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось стереть
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого ещё раз ProgrammingEnable и можно писать
                        if(!AT90S4414_ProgrammingEnable())     // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                SendEndTimeToLog();             // пишем в лог время окончания операции
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        for(unsigned int i=0; i<SelectedChip.Area1Size; i++)
                        {       if(!AT90S4414_WriteProgramMemory(i))            // пишем байт в страницу буфера
                                {       SendMsgToLog(19," with fail.");         // если вернуло false - не удалось прочитать
                                        SendEndTimeToLog();                     // пишем в лог время окончания операции
                                        LBar->Free();                           // уничтожаем форму с прогресс-баром
                                        return;                                 // выходим
                                }
                                // если передали количество байт кратное 32-м - меняем позицию progress bara
                                if((i+1)%32==0)
                                {       LBar->ProgressBar1->Position=100*(i+1)/SelectedChip.Area1Size;  // вычисляем новую позицию прогресс-бара
                                }
                        }
                        break;
          case 0x3921E: // выбран чип AT90S4433
          case 0x5911E: // выбран чип AT90S2333
                        if(!AT90S2333_ProgrammingEnable())      // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                SendEndTimeToLog();             // пишем в лог время окончания операции
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // прежде, чем писать во флеш, - нужно всё стереть
                        if(!AT90S2333_ChipErase())              // пробуем стереть чип
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось стереть
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого ещё раз ProgrammingEnable и можно писать
                        if(!AT90S2333_ProgrammingEnable())     // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                SendEndTimeToLog();             // пишем в лог время окончания операции
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        for(unsigned int i=0; i<SelectedChip.Area1Size; i++)
                        {       if(!AT90S2333_WriteProgramMemory(i))            // пишем байт в страницу буфера
                                {       SendMsgToLog(19," with fail.");         // если вернуло false - не удалось прочитать
                                        SendEndTimeToLog();                     // пишем в лог время окончания операции
                                        LBar->Free();                           // уничтожаем форму с прогресс-баром
                                        return;                                 // выходим
                                }
                                // если передали количество байт кратное 32-м - меняем позицию progress bara
                                if((i+1)%32==0)
                                {       LBar->ProgressBar1->Position=100*(i+1)/SelectedChip.Area1Size;  // вычисляем новую позицию прогресс-бара
                                }
                        }
                        break;
          case 0x3911E: // выбран чип AT90S2343
                        if(!AT90S2343_ProgrammingEnable())      // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                SendEndTimeToLog();             // пишем в лог время окончания операции
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // прежде, чем писать во флеш, - нужно всё стереть
                        if(!AT90S2343_ChipErase())              // пробуем стереть чип
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось стереть
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого ещё раз ProgrammingEnable и можно писать
                        if(!AT90S2343_ProgrammingEnable())     // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                SendEndTimeToLog();             // пишем в лог время окончания операции
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        for(unsigned int i=0; i<SelectedChip.Area1Size; i++)
                        {       if(!AT90S2343_WriteProgramMemory(i))            // пишем байт в страницу буфера
                                {       SendMsgToLog(19," with fail.");         // если вернуло false - не удалось прочитать
                                        SendEndTimeToLog();                     // пишем в лог время окончания операции
                                        LBar->Free();                           // уничтожаем форму с прогресс-баром
                                        return;                                 // выходим
                                }
                                // если передали количество байт кратное 32-м - меняем позицию progress bara
                                if((i+1)%32==0)
                                {       LBar->ProgressBar1->Position=100*(i+1)/SelectedChip.Area1Size;  // вычисляем новую позицию прогресс-бара
                                }
                        }
                        break;
          case 0x2911E: // выбран чип AT90S2323
                        if(!AT90S2323_ProgrammingEnable())      // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                SendEndTimeToLog();             // пишем в лог время окончания операции
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // прежде, чем писать во флеш, - нужно всё стереть
                        if(!AT90S2323_ChipErase())              // пробуем стереть чип
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось стереть
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого ещё раз ProgrammingEnable и можно писать
                        if(!AT90S2323_ProgrammingEnable())     // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                SendEndTimeToLog();             // пишем в лог время окончания операции
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        for(unsigned int i=0; i<SelectedChip.Area1Size; i++)
                        {       if(!AT90S2323_WriteProgramMemory(i))            // пишем байт в страницу буфера
                                {       SendMsgToLog(19," with fail.");         // если вернуло false - не удалось прочитать
                                        SendEndTimeToLog();                     // пишем в лог время окончания операции
                                        LBar->Free();                           // уничтожаем форму с прогресс-баром
                                        return;                                 // выходим
                                }
                                // если передали количество байт кратное 32-м - меняем позицию progress bara
                                if((i+1)%32==0)
                                {       LBar->ProgressBar1->Position=100*(i+1)/SelectedChip.Area1Size;  // вычисляем новую позицию прогресс-бара
                                }
                        }
                        break;
          case 0x1911E: // выбран чип AT90S2313
                        if(!AT90S2313_ProgrammingEnable())      // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                SendEndTimeToLog();             // пишем в лог время окончания операции
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // прежде, чем писать во флеш, - нужно всё стереть
                        if(!AT90S2313_ChipErase())              // пробуем стереть чип
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось стереть
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого ещё раз ProgrammingEnable и можно писать
                        if(!AT90S2313_ProgrammingEnable())     // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                SendEndTimeToLog();             // пишем в лог время окончания операции
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        for(unsigned int i=0; i<SelectedChip.Area1Size; i++)
                        {       if(!AT90S2313_WriteProgramMemory(i))            // пишем байт в страницу буфера
                                {       SendMsgToLog(19," with fail.");         // если вернуло false - не удалось прочитать
                                        SendEndTimeToLog();                     // пишем в лог время окончания операции
                                        LBar->Free();                           // уничтожаем форму с прогресс-баром
                                        return;                                 // выходим
                                }
                                // если передали количество байт кратное 32-м - меняем позицию progress bara
                                if((i+1)%32==0)
                                {       LBar->ProgressBar1->Position=100*(i+1)/SelectedChip.Area1Size;  // вычисляем новую позицию прогресс-бара
                                }
                        }
                        break;
          case 0x1901E: // выбран чип AT90S1200
                        if(!AT90S1200_ProgrammingEnable())      // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                SendEndTimeToLog();             // пишем в лог время окончания операции
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // прежде, чем писать во флеш, - нужно всё стереть
                        if(!AT90S1200_ChipErase())              // пробуем стереть чип
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось стереть
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого ещё раз ProgrammingEnable и можно писать
                        if(!AT90S1200_ProgrammingEnable())     // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                SendEndTimeToLog();             // пишем в лог время окончания операции
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        for(unsigned int i=0; i<SelectedChip.Area1Size; i++)
                        {       if(!AT90S1200_WriteProgramMemory(i))            // пишем байт в страницу буфера
                                {       SendMsgToLog(19," with fail.");         // если вернуло false - не удалось прочитать
                                        SendEndTimeToLog();                     // пишем в лог время окончания операции
                                        LBar->Free();                           // уничтожаем форму с прогресс-баром
                                        return;                                 // выходим
                                }
                                // если передали количество байт кратное 32-м - меняем позицию progress bara
                                if((i+1)%32==0)
                                {       LBar->ProgressBar1->Position=100*(i+1)/SelectedChip.Area1Size;  // вычисляем новую позицию прогресс-бара
                                }
                        }
                        break;
          case 0xA911E: // выбрано устройство ATtiny2313
                        if(!ATtiny2313_ProgrammingEnable())     // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                SendEndTimeToLog();             // пишем в лог время окончания операции
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // прежде, чем писать во флеш, - нужно всё стереть
                        if(!ATtiny2313_ChipErase())             // пробуем стереть чип
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось стереть
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого ещё раз ProgrammingEnable и можно писать
                        if(!ATtiny2313_ProgrammingEnable())     // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                SendEndTimeToLog();             // пишем в лог время окончания операции
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        for(unsigned int i=0; i<SelectedChip.Area1Size; i++)
                        {       if(!ATtiny2313_LoadProgramMemoryPage(i))        // пишем байт в страницу буфера
                                {       SendMsgToLog(19," with fail.");         // если вернуло false - не удалось прочитать
                                        SendEndTimeToLog();                     // пишем в лог время окончания операции
                                        LBar->Free();                           // уничтожаем форму с прогресс-баром
                                        return;                                 // выходим
                                }
                                // если передали количество байт кратное 32-м (размер буфера = 16 слов = 32 байта) - пробуем записать буфер в память
                                if((i+1)%32==0)
                                {       if(!ATtiny2313_WriteProgramMemoryPage(i))       // пишем страницу буфера в память
                                        {       SendMsgToLog(19," with fail.");         // если вернуло false - не удалось записать
                                                SendEndTimeToLog();                     // пишем в лог время окончания операции
                                                LBar->Free();                           // уничтожаем форму с прогресс-баром
                                                return;                                 // выходим
                                        }
                                        LBar->ProgressBar1->Position=100*(i+1)/SelectedChip.Area1Size;  // вычисляем новую позицию прогресс-бара
                                }
                        }
                        break;
          case 0:  SendMsgToLog(14,"");            // сообщение в лог, что не выбран ни один чип
                   SendEndTimeToLog();             // пишем в лог время окончания операции
                   LBar->Free();                   // уничтожаем форму с прогресс-баром
                   return;                         // выходим
          default: SendMsgToLog(15," unknown");    // сообщение в лог, что чип нам неизвестен и выходим
                   SendEndTimeToLog();             // пишем в лог время окончания операции
                   LBar->Free();                   // уничтожаем форму с прогресс-баром
                   return;                         // выходим
        }
        LBar->Free();         // уничтожаем форму с прогресс-баром
        SendMsgToLog(19,"");  // сообщаем о завершении операции
        SendEndTimeToLog();   // пишем в лог время окончания операции
  }
}
//---------------------------------------------------------------------------
//--- НАЖАТА КНОПКА WRITE DATA ----------------------------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::Button9Click(TObject *Sender)
{ if (Application->MessageBox("All previous chip data will be lost (EEPROM). Are you sure?", "Warning", MB_YESNO|MB_ICONWARNING|MB_DEFBUTTON2|MB_APPLMODAL) == IDYES)
  { // сначала нужно поместить в память данные с формы, в зависимости от вкладки
    switch(Form1->PageControl1->TabIndex)
    {   case 0: GetDataToMemory(3,2);      // из RichEdit3 в Area2
                break;
        case 1: GetDataToMemory(4,2);      // из RichEdit4 в Area2
                break;
        default: break;
    }

    // включаем прогресс-бар
    Application->CreateForm(__classid(TLBar),&LBar);      // создаём форму с прогресс-баром
    LBar->Show();                                         // показываем её в немодальном окне

    SendMsgToLog(18," write the EEPROM");    // сообщаем о попытке записать EEPROM
    SendStartTimeToLog();                    // пишем в лог время начала операции
    switch(SelectedChip.ID)
    { case 0xD931E:   // выбрано устройство ATtiny861
      case 0x8921E:   // выбрано устройство ATtiny461
      case 0xC911E:   // выбран чип ATtiny261
                       if(!ATtiny261_ProgrammingEnable())      // пробуем перевести чип в режим программирования и синхронизироваться с ним
                       {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                               SendEndTimeToLog();             // пишем в лог время окончания операции
                               LBar->Free();                   // уничтожаем форму с прогресс-баром
                               return;                         // выходим
                       }
                       // после этого можно уже и писать
                       for(unsigned int i=0; i<SelectedChip.Area2Size; i++)
                       {       if(!ATtiny261_WriteEEPROMMemory(i))             // пишем байт в страницу буфера
                               {       SendMsgToLog(19," with fail.");         // если вернуло false - не удалось прочитать
                                       SendEndTimeToLog();                     // пишем в лог время окончания операции
                                       LBar->Free();                           // уничтожаем форму с прогресс-баром
                                       return;                                 // выходим
                               }
                               // если передали количество байт кратное 4-м - меняем позицию progress bara
                               if((i+1)%4==0)
                               {       LBar->ProgressBar1->Position=100*(i+1)/SelectedChip.Area2Size;  // вычисляем новую позицию прогресс-бара
                               }
                       }
                       break;
      case 0x9911E:   // выбран чип ATtiny26
                       if(!ATtiny26_ProgrammingEnable())      // пробуем перевести чип в режим программирования и синхронизироваться с ним
                       {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                               SendEndTimeToLog();             // пишем в лог время окончания операции
                               LBar->Free();                   // уничтожаем форму с прогресс-баром
                               return;                         // выходим
                       }
                       // после этого можно уже и писать
                       for(unsigned int i=0; i<SelectedChip.Area2Size; i++)
                       {       if(!ATtiny26_WriteEEPROMMemory(i))             // пишем байт в страницу буфера
                               {       SendMsgToLog(19," with fail.");         // если вернуло false - не удалось прочитать
                                       SendEndTimeToLog();                     // пишем в лог время окончания операции
                                       LBar->Free();                           // уничтожаем форму с прогресс-баром
                                       return;                                 // выходим
                               }
                               // если передали количество байт кратное 4-м - меняем позицию progress bara
                               if((i+1)%4==0)
                               {       LBar->ProgressBar1->Position=100*(i+1)/SelectedChip.Area2Size;  // вычисляем новую позицию прогресс-бара
                               }
                       }
                       break;
      case 0xB931E:   // выбрано устройство ATtiny85
      case 0x6921E:   // выбрано устройство ATtiny45
      case 0x8911E:   // выбрано устройство ATtiny25
                       if(!ATtiny25_ProgrammingEnable())     // пробуем перевести чип в режим программирования и синхронизироваться с ним
                       {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                               SendEndTimeToLog();             // пишем в лог время окончания операции
                               LBar->Free();                   // уничтожаем форму с прогресс-баром
                               return;                         // выходим
                       }
                       // после этого можно уже и писать
                       for(unsigned int i=0; i<SelectedChip.Area2Size; i++)
                       {       if(!ATtiny25_LoadEEPROMMemoryPage(i))         // пишем байт в страницу буфера
                               {       SendMsgToLog(19," with fail.");         // если вернуло false - не удалось прочитать
                                       SendEndTimeToLog();                     // пишем в лог время окончания операции
                                       LBar->Free();                           // уничтожаем форму с прогресс-баром
                                       return;                                 // выходим
                               }
                               // если передали количество байт кратное 4-м (размер буфера) - пробуем записать буфер в память
                               if((i+1)%4==0)
                               {       if(!ATtiny25_WriteEEPROMMemoryPage(i))        // пишем страницу буфера в память
                                       {       SendMsgToLog(19," with fail.");         // если вернуло false - не удалось записать
                                               SendEndTimeToLog();             // пишем в лог время окончания операции
                                               LBar->Free();                           // уничтожаем форму с прогресс-баром
                                               return;                                 // выходим
                                       }
                                       LBar->ProgressBar1->Position=100*(i+1)/SelectedChip.Area2Size;  // вычисляем новую позицию прогресс-бара
                               }
                       }
                       break;
      case 0x6911E:   // выбран чип ATtiny22
                       if(!ATtiny22_ProgrammingEnable())      // пробуем перевести чип в режим программирования и синхронизироваться с ним
                       {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                               SendEndTimeToLog();             // пишем в лог время окончания операции
                               LBar->Free();                   // уничтожаем форму с прогресс-баром
                               return;                         // выходим
                       }
                       // после этого можно уже и писать
                       for(unsigned int i=0; i<SelectedChip.Area2Size; i++)
                       {       if(!ATtiny22_WriteEEPROMMemory(i))             // пишем байт в страницу буфера
                               {       SendMsgToLog(19," with fail.");         // если вернуло false - не удалось прочитать
                                       SendEndTimeToLog();                     // пишем в лог время окончания операции
                                       LBar->Free();                           // уничтожаем форму с прогресс-баром
                                       return;                                 // выходим
                               }
                               // если передали количество байт кратное 4-м - меняем позицию progress bara
                               if((i+1)%4==0)
                               {       LBar->ProgressBar1->Position=100*(i+1)/SelectedChip.Area2Size;  // вычисляем новую позицию прогресс-бара
                               }
                       }
                       break;
      case 0x6901E:   // выбран чип ATtiny15
                       if(!ATtiny15_ProgrammingEnable())      // пробуем перевести чип в режим программирования и синхронизироваться с ним
                       {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                               SendEndTimeToLog();             // пишем в лог время окончания операции
                               LBar->Free();                   // уничтожаем форму с прогресс-баром
                               return;                         // выходим
                       }
                       // после этого можно уже и писать
                       for(unsigned int i=0; i<SelectedChip.Area2Size; i++)
                       {       if(!ATtiny15_WriteEEPROMMemory(i))             // пишем байт в страницу буфера
                               {       SendMsgToLog(19," with fail.");         // если вернуло false - не удалось прочитать
                                       SendEndTimeToLog();                     // пишем в лог время окончания операции
                                       LBar->Free();                           // уничтожаем форму с прогресс-баром
                                       return;                                 // выходим
                               }
                               // если передали количество байт кратное 4-м - меняем позицию progress bara
                               if((i+1)%4==0)
                               {       LBar->ProgressBar1->Position=100*(i+1)/SelectedChip.Area2Size;  // вычисляем новую позицию прогресс-бара
                               }
                       }
                       break;
      case 0x7901E:   // выбрано устройство ATtiny13
                       if(!ATtiny13_ProgrammingEnable())     // пробуем перевести чип в режим программирования и синхронизироваться с ним
                       {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                               SendEndTimeToLog();             // пишем в лог время окончания операции
                               LBar->Free();                   // уничтожаем форму с прогресс-баром
                               return;                         // выходим
                       }
                       // после этого можно уже и писать
                       for(unsigned int i=0; i<SelectedChip.Area2Size; i++)
                       {       if(!ATtiny13_LoadEEPROMMemoryPage(i))         // пишем байт в страницу буфера
                               {       SendMsgToLog(19," with fail.");         // если вернуло false - не удалось прочитать
                                       SendEndTimeToLog();                     // пишем в лог время окончания операции
                                       LBar->Free();                           // уничтожаем форму с прогресс-баром
                                       return;                                 // выходим
                               }
                               // если передали количество байт кратное 4-м (размер буфера) - пробуем записать буфер в память
                               if((i+1)%4==0)
                               {       if(!ATtiny13_WriteEEPROMMemoryPage(i))        // пишем страницу буфера в память
                                       {       SendMsgToLog(19," with fail.");         // если вернуло false - не удалось записать
                                               SendEndTimeToLog();             // пишем в лог время окончания операции
                                               LBar->Free();                           // уничтожаем форму с прогресс-баром
                                               return;                                 // выходим
                                       }
                                       LBar->ProgressBar1->Position=100*(i+1)/SelectedChip.Area2Size;  // вычисляем новую позицию прогресс-бара
                               }
                       }
                       break;
      case 0x5901E:   // выбран чип ATtiny12
                       if(!ATtiny12_ProgrammingEnable())      // пробуем перевести чип в режим программирования и синхронизироваться с ним
                       {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                               SendEndTimeToLog();             // пишем в лог время окончания операции
                               LBar->Free();                   // уничтожаем форму с прогресс-баром
                               return;                         // выходим
                       }
                       // после этого можно уже и писать
                       for(unsigned int i=0; i<SelectedChip.Area2Size; i++)
                       {       if(!ATtiny12_WriteEEPROMMemory(i))             // пишем байт в страницу буфера
                               {       SendMsgToLog(19," with fail.");         // если вернуло false - не удалось прочитать
                                       SendEndTimeToLog();                     // пишем в лог время окончания операции
                                       LBar->Free();                           // уничтожаем форму с прогресс-баром
                                       return;                                 // выходим
                               }
                               // если передали количество байт кратное 4-м - меняем позицию progress bara
                               if((i+1)%4==0)
                               {       LBar->ProgressBar1->Position=100*(i+1)/SelectedChip.Area2Size;  // вычисляем новую позицию прогресс-бара
                               }
                       }
                       break;
      case 0x81971E:   // выбрано устройство AT90CAN128
      case 0x81961E:   // выбрано устройство AT90CAN64
      case 0x81951E:   // выбрано устройство AT90CAN32
                       if(!AT90CAN32_ProgrammingEnable())     // пробуем перевести чип в режим программирования и синхронизироваться с ним
                       {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                               SendEndTimeToLog();             // пишем в лог время окончания операции
                               LBar->Free();                   // уничтожаем форму с прогресс-баром
                               return;                         // выходим
                       }
                       // после этого можно уже и писать
                       for(unsigned int i=0; i<SelectedChip.Area2Size; i++)
                       {       if(!AT90CAN32_LoadEEPROMMemoryPage(i))         // пишем байт в страницу буфера
                               {       SendMsgToLog(19," with fail.");         // если вернуло false - не удалось прочитать
                                       SendEndTimeToLog();                     // пишем в лог время окончания операции
                                       LBar->Free();                           // уничтожаем форму с прогресс-баром
                                       return;                                 // выходим
                               }
                               // если передали количество байт кратное 8-и (размер буфера) - пробуем записать буфер в память
                               if((i+1)%8==0)
                               {       if(!AT90CAN32_WriteEEPROMMemoryPage(i))        // пишем страницу буфера в память
                                       {       SendMsgToLog(19," with fail.");         // если вернуло false - не удалось записать
                                               SendEndTimeToLog();             // пишем в лог время окончания операции
                                               LBar->Free();                           // уничтожаем форму с прогресс-баром
                                               return;                                 // выходим
                                       }
                                       LBar->ProgressBar1->Position=100*(i+1)/SelectedChip.Area2Size;  // вычисляем новую позицию прогресс-бара
                               }
                       }
                       break;
      case 0x3931E:   // выбран чип AT90S8535
      case 0x2921E:   // выбран чип AT90S4434
                       if(!AT90S4434_ProgrammingEnable())      // пробуем перевести чип в режим программирования и синхронизироваться с ним
                       {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                               SendEndTimeToLog();             // пишем в лог время окончания операции
                               LBar->Free();                   // уничтожаем форму с прогресс-баром
                               return;                         // выходим
                       }
                       // после этого можно уже и писать
                       for(unsigned int i=0; i<SelectedChip.Area2Size; i++)
                       {       if(!AT90S4434_WriteEEPROMMemory(i))             // пишем байт в страницу буфера
                               {       SendMsgToLog(19," with fail.");         // если вернуло false - не удалось прочитать
                                       SendEndTimeToLog();                     // пишем в лог время окончания операции
                                       LBar->Free();                           // уничтожаем форму с прогресс-баром
                                       return;                                 // выходим
                               }
                               // если передали количество байт кратное 4-м - меняем позицию progress bara
                               if((i+1)%4==0)
                               {       LBar->ProgressBar1->Position=100*(i+1)/SelectedChip.Area2Size;  // вычисляем новую позицию прогресс-бара
                               }
                       }
                       break;
      case 0x1931E:   // выбран чип AT90S8515
      case 0x1921E:   // выбран чип AT90S4414
                       if(!AT90S4414_ProgrammingEnable())      // пробуем перевести чип в режим программирования и синхронизироваться с ним
                       {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                               SendEndTimeToLog();             // пишем в лог время окончания операции
                               LBar->Free();                   // уничтожаем форму с прогресс-баром
                               return;                         // выходим
                       }
                       // после этого можно уже и писать
                       for(unsigned int i=0; i<SelectedChip.Area2Size; i++)
                       {       if(!AT90S4414_WriteEEPROMMemory(i))             // пишем байт в страницу буфера
                               {       SendMsgToLog(19," with fail.");         // если вернуло false - не удалось прочитать
                                       SendEndTimeToLog();                     // пишем в лог время окончания операции
                                       LBar->Free();                           // уничтожаем форму с прогресс-баром
                                       return;                                 // выходим
                               }
                               // если передали количество байт кратное 4-м - меняем позицию progress bara
                               if((i+1)%4==0)
                               {       LBar->ProgressBar1->Position=100*(i+1)/SelectedChip.Area2Size;  // вычисляем новую позицию прогресс-бара
                               }
                       }
                       break;
      case 0x3921E:   // выбран чип AT90S4433
      case 0x5911E:   // выбран чип AT90S2333
                       if(!AT90S2333_ProgrammingEnable())      // пробуем перевести чип в режим программирования и синхронизироваться с ним
                       {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                               SendEndTimeToLog();             // пишем в лог время окончания операции
                               LBar->Free();                   // уничтожаем форму с прогресс-баром
                               return;                         // выходим
                       }
                       // после этого можно уже и писать
                       for(unsigned int i=0; i<SelectedChip.Area2Size; i++)
                       {       if(!AT90S2333_WriteEEPROMMemory(i))             // пишем байт в страницу буфера
                               {       SendMsgToLog(19," with fail.");         // если вернуло false - не удалось прочитать
                                       SendEndTimeToLog();                     // пишем в лог время окончания операции
                                       LBar->Free();                           // уничтожаем форму с прогресс-баром
                                       return;                                 // выходим
                               }
                               // если передали количество байт кратное 4-м - меняем позицию progress bara
                               if((i+1)%4==0)
                               {       LBar->ProgressBar1->Position=100*(i+1)/SelectedChip.Area2Size;  // вычисляем новую позицию прогресс-бара
                               }
                       }
                       break;
      case 0x3911E:   // выбран чип AT90S2343
                       if(!AT90S2343_ProgrammingEnable())      // пробуем перевести чип в режим программирования и синхронизироваться с ним
                       {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                               SendEndTimeToLog();             // пишем в лог время окончания операции
                               LBar->Free();                   // уничтожаем форму с прогресс-баром
                               return;                         // выходим
                       }
                       // после этого можно уже и писать
                       for(unsigned int i=0; i<SelectedChip.Area2Size; i++)
                       {       if(!AT90S2343_WriteEEPROMMemory(i))             // пишем байт в страницу буфера
                               {       SendMsgToLog(19," with fail.");         // если вернуло false - не удалось прочитать
                                       SendEndTimeToLog();                     // пишем в лог время окончания операции
                                       LBar->Free();                           // уничтожаем форму с прогресс-баром
                                       return;                                 // выходим
                               }
                               // если передали количество байт кратное 4-м - меняем позицию progress bara
                               if((i+1)%4==0)
                               {       LBar->ProgressBar1->Position=100*(i+1)/SelectedChip.Area2Size;  // вычисляем новую позицию прогресс-бара
                               }
                       }
                       break;
      case 0x2911E:   // выбран чип AT90S2323
                       if(!AT90S2323_ProgrammingEnable())      // пробуем перевести чип в режим программирования и синхронизироваться с ним
                       {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                               SendEndTimeToLog();             // пишем в лог время окончания операции
                               LBar->Free();                   // уничтожаем форму с прогресс-баром
                               return;                         // выходим
                       }
                       // после этого можно уже и писать
                       for(unsigned int i=0; i<SelectedChip.Area2Size; i++)
                       {       if(!AT90S2323_WriteEEPROMMemory(i))             // пишем байт в страницу буфера
                               {       SendMsgToLog(19," with fail.");         // если вернуло false - не удалось прочитать
                                       SendEndTimeToLog();                     // пишем в лог время окончания операции
                                       LBar->Free();                           // уничтожаем форму с прогресс-баром
                                       return;                                 // выходим
                               }
                               // если передали количество байт кратное 4-м - меняем позицию progress bara
                               if((i+1)%4==0)
                               {       LBar->ProgressBar1->Position=100*(i+1)/SelectedChip.Area2Size;  // вычисляем новую позицию прогресс-бара
                               }
                       }
                       break;
      case 0x1911E:   // выбран чип AT90S2313
                       if(!AT90S2313_ProgrammingEnable())      // пробуем перевести чип в режим программирования и синхронизироваться с ним
                       {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                               SendEndTimeToLog();             // пишем в лог время окончания операции
                               LBar->Free();                   // уничтожаем форму с прогресс-баром
                               return;                         // выходим
                       }
                       // после этого можно уже и писать
                       for(unsigned int i=0; i<SelectedChip.Area2Size; i++)
                       {       if(!AT90S2313_WriteEEPROMMemory(i))             // пишем байт в страницу буфера
                               {       SendMsgToLog(19," with fail.");         // если вернуло false - не удалось прочитать
                                       SendEndTimeToLog();                     // пишем в лог время окончания операции
                                       LBar->Free();                           // уничтожаем форму с прогресс-баром
                                       return;                                 // выходим
                               }
                               // если передали количество байт кратное 4-м - меняем позицию progress bara
                               if((i+1)%4==0)
                               {       LBar->ProgressBar1->Position=100*(i+1)/SelectedChip.Area2Size;  // вычисляем новую позицию прогресс-бара
                               }
                       }
                       break;
      case 0x1901E:   // выбран чип AT90S1200
                       if(!AT90S1200_ProgrammingEnable())      // пробуем перевести чип в режим программирования и синхронизироваться с ним
                       {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                               SendEndTimeToLog();             // пишем в лог время окончания операции
                               LBar->Free();                   // уничтожаем форму с прогресс-баром
                               return;                         // выходим
                       }
                       // после этого можно уже и писать
                       for(unsigned int i=0; i<SelectedChip.Area2Size; i++)
                       {       if(!AT90S1200_WriteEEPROMMemory(i))             // пишем байт в страницу буфера
                               {       SendMsgToLog(19," with fail.");         // если вернуло false - не удалось прочитать
                                       SendEndTimeToLog();                     // пишем в лог время окончания операции
                                       LBar->Free();                           // уничтожаем форму с прогресс-баром
                                       return;                                 // выходим
                               }
                               // если передали количество байт кратное 4-м - меняем позицию progress bara
                               if((i+1)%4==0)
                               {       LBar->ProgressBar1->Position=100*(i+1)/SelectedChip.Area2Size;  // вычисляем новую позицию прогресс-бара
                               }
                       }
                       break;
      case 0xA911E:   // выбрано устройство ATtiny2313
                       if(!ATtiny2313_ProgrammingEnable())     // пробуем перевести чип в режим программирования и синхронизироваться с ним
                       {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                               SendEndTimeToLog();             // пишем в лог время окончания операции
                               LBar->Free();                   // уничтожаем форму с прогресс-баром
                               return;                         // выходим
                       }
                       // после этого можно уже и писать
                       for(unsigned int i=0; i<SelectedChip.Area2Size; i++)
                       {       if(!ATtiny2313_LoadEEPROMMemoryPage(i))         // пишем байт в страницу буфера
                               {       SendMsgToLog(19," with fail.");         // если вернуло false - не удалось прочитать
                                       SendEndTimeToLog();                     // пишем в лог время окончания операции
                                       LBar->Free();                           // уничтожаем форму с прогресс-баром
                                       return;                                 // выходим
                               }
                               // если передали количество байт кратное 4-м (размер буфера) - пробуем записать буфер в память
                               if((i+1)%4==0)
                               {       if(!ATtiny2313_WriteEEPROMMemoryPage(i))        // пишем страницу буфера в память
                                       {       SendMsgToLog(19," with fail.");         // если вернуло false - не удалось записать
                                               SendEndTimeToLog();             // пишем в лог время окончания операции
                                               LBar->Free();                           // уничтожаем форму с прогресс-баром
                                               return;                                 // выходим
                                       }
                                       LBar->ProgressBar1->Position=100*(i+1)/SelectedChip.Area2Size;  // вычисляем новую позицию прогресс-бара
                               }
                       }
                       break;
      case 0:  SendMsgToLog(14,"");            // сообщение в лог, что не выбран ни один чип
               SendEndTimeToLog();             // пишем в лог время окончания операции
               LBar->Free();                   // уничтожаем форму с прогресс-баром
               return;                         // выходим
      default: SendMsgToLog(15," unknown");    // сообщение в лог, что чип нам неизвестен и выходим
               SendEndTimeToLog();             // пишем в лог время окончания операции
               LBar->Free();                   // уничтожаем форму с прогресс-баром
               return;                         // выходим
    }
    LBar->Free();         // уничтожаем форму с прогресс-баром
    SendMsgToLog(19,"");  // сообщаем о завершении операции
    SendEndTimeToLog();   // пишем в лог время окончания операции
  }
}
//---------------------------------------------------------------------------
//--- НАЖАТА КНОПКА READ PROGRAM --------------------------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::Button4Click(TObject *Sender)
{ // включаем прогресс-бар
  Application->CreateForm(__classid(TLBar),&LBar);      // создаём форму с прогресс-баром
  LBar->Show();                                         // показываем её в немодальном окне

  SendMsgToLog(18," read the program");         // сообщаем о попытке прочитать программу
  SendStartTimeToLog();                         // пишем в лог время начала операции
  switch(SelectedChip.ID)
  { case 0xD931E:       // выбрано устройство ATtiny861
    case 0x8921E:       // выбрано устройство ATtiny461
    case 0xC911E:       // выбрано устройство ATtiny261
                        if(!ATtiny261_ProgrammingEnable())     // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                SendEndTimeToLog();             // пишем в лог время окончания операции
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого можно уже и читать
                        for(unsigned int i=0; i<SelectedChip.Area1Size; i++)
                        {       if(!ATtiny261_ReadProgramMemory(i,0))          // пробуем прочитать байт программы
                                {       SendMsgToLog(19," with fail.");         // если вернуло false - не удалось прочитать
                                        SendEndTimeToLog();                     // пишем в лог время окончания операции
                                        LBar->Free();                           // уничтожаем форму с прогресс-баром
                                        return;                                 // выходим
                                }
                                // если прочитали количество байт кратное 32-м
                                if((i+1)%32==0)
                                {       LBar->ProgressBar1->Position=100*(i+1)/SelectedChip.Area1Size;  // вычисляем новую позицию прогресс-бара
                                }
                        }
                        break;
    case 0x9911E:       // выбрано устройство ATtiny26
                        if(!ATtiny26_ProgrammingEnable())     // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                SendEndTimeToLog();             // пишем в лог время окончания операции
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого можно уже и читать
                        for(unsigned int i=0; i<SelectedChip.Area1Size; i++)
                        {       if(!ATtiny26_ReadProgramMemory(i,0))          // пробуем прочитать байт программы
                                {       SendMsgToLog(19," with fail.");         // если вернуло false - не удалось прочитать
                                        SendEndTimeToLog();                     // пишем в лог время окончания операции
                                        LBar->Free();                           // уничтожаем форму с прогресс-баром
                                        return;                                 // выходим
                                }
                                // если прочитали количество байт кратное 32-м
                                if((i+1)%32==0)
                                {       LBar->ProgressBar1->Position=100*(i+1)/SelectedChip.Area1Size;  // вычисляем новую позицию прогресс-бара
                                }
                        }
                        break;
    case 0xB931E:       // выбрано устройство ATtiny85
    case 0x6921E:       // выбрано устройство ATtiny45
    case 0x8911E:       // выбрано устройство ATtiny25
                        if(!ATtiny25_ProgrammingEnable())     // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                SendEndTimeToLog();             // пишем в лог время окончания операции
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого можно уже и читать
                        for(unsigned int i=0; i<SelectedChip.Area1Size; i++)
                        {       if(!ATtiny25_ReadProgramMemory(i,0))          // пробуем прочитать байт программы
                                {       SendMsgToLog(19," with fail.");         // если вернуло false - не удалось прочитать
                                        SendEndTimeToLog();                     // пишем в лог время окончания операции
                                        LBar->Free();                           // уничтожаем форму с прогресс-баром
                                        return;                                 // выходим
                                }
                                // если прочитали количество байт кратное 32-м
                                if((i+1)%32==0)
                                {       LBar->ProgressBar1->Position=100*(i+1)/SelectedChip.Area1Size;  // вычисляем новую позицию прогресс-бара
                                }
                        }
                        break;
    case 0x6911E:       // выбран чип ATtiny22
                        if(!ATtiny22_ProgrammingEnable())      // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                SendEndTimeToLog();             // пишем в лог время окончания операции
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого можно уже и читать
                        for(unsigned int i=0; i<SelectedChip.Area1Size; i++)
                        {       if(!ATtiny22_ReadProgramMemory(i,0))           // пробуем прочитать байт программы
                                {       SendMsgToLog(19," with fail.");         // если вернуло false - не удалось прочитать
                                        SendEndTimeToLog();                     // пишем в лог время окончания операции
                                        LBar->Free();                           // уничтожаем форму с прогресс-баром
                                        return;                                 // выходим
                                }
                                // если прочитали количество байт кратное 32-м
                                if((i+1)%32==0)
                                {       LBar->ProgressBar1->Position=100*(i+1)/SelectedChip.Area1Size;  // вычисляем новую позицию прогресс-бара
                                }
                        }
                        break;
    case 0x6901E:       // выбран чип ATtiny15
                        if(!ATtiny15_ProgrammingEnable())      // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                SendEndTimeToLog();             // пишем в лог время окончания операции
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого можно уже и читать
                        for(unsigned int i=0; i<SelectedChip.Area1Size; i++)
                        {       if(!ATtiny15_ReadProgramMemory(i,0))           // пробуем прочитать байт программы
                                {       SendMsgToLog(19," with fail.");         // если вернуло false - не удалось прочитать
                                        SendEndTimeToLog();                     // пишем в лог время окончания операции
                                        LBar->Free();                           // уничтожаем форму с прогресс-баром
                                        return;                                 // выходим
                                }
                                // если прочитали количество байт кратное 32-м
                                if((i+1)%32==0)
                                {       LBar->ProgressBar1->Position=100*(i+1)/SelectedChip.Area1Size;  // вычисляем новую позицию прогресс-бара
                                }
                        }
                        break;
    case 0x7901E:       // выбран чип ATtiny13
                        if(!ATtiny13_ProgrammingEnable())      // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                SendEndTimeToLog();             // пишем в лог время окончания операции
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого можно уже и читать
                        for(unsigned int i=0; i<SelectedChip.Area1Size; i++)
                        {       if(!ATtiny13_ReadProgramMemory(i,0))           // пробуем прочитать байт программы
                                {       SendMsgToLog(19," with fail.");         // если вернуло false - не удалось прочитать
                                        SendEndTimeToLog();                     // пишем в лог время окончания операции
                                        LBar->Free();                           // уничтожаем форму с прогресс-баром
                                        return;                                 // выходим
                                }
                                // если прочитали количество байт кратное 32-м
                                if((i+1)%32==0)
                                {       LBar->ProgressBar1->Position=100*(i+1)/SelectedChip.Area1Size;  // вычисляем новую позицию прогресс-бара
                                }
                        }
                        break;
    case 0x5901E:       // выбран чип ATtiny12
                        if(!ATtiny12_ProgrammingEnable())      // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                SendEndTimeToLog();             // пишем в лог время окончания операции
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого можно уже и читать
                        for(unsigned int i=0; i<SelectedChip.Area1Size; i++)
                        {       if(!ATtiny12_ReadProgramMemory(i,0))           // пробуем прочитать байт программы
                                {       SendMsgToLog(19," with fail.");         // если вернуло false - не удалось прочитать
                                        SendEndTimeToLog();                     // пишем в лог время окончания операции
                                        LBar->Free();                           // уничтожаем форму с прогресс-баром
                                        return;                                 // выходим
                                }
                                // если прочитали количество байт кратное 32-м
                                if((i+1)%32==0)
                                {       LBar->ProgressBar1->Position=100*(i+1)/SelectedChip.Area1Size;  // вычисляем новую позицию прогресс-бара
                                }
                        }
                        break;
    case 0x81971E:      // выбрано устройство AT90CAN128
    case 0x81961E:      // выбрано устройство AT90CAN64
    case 0x81951E:      // выбрано устройство AT90CAN32
                        if(!AT90CAN32_ProgrammingEnable())     // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                SendEndTimeToLog();             // пишем в лог время окончания операции
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого можно уже и читать
                        for(unsigned int i=0; i<SelectedChip.Area1Size; i++)
                        {       if(!AT90CAN32_ReadProgramMemory(i,0))          // пробуем прочитать байт программы
                                {       SendMsgToLog(19," with fail.");         // если вернуло false - не удалось прочитать
                                        SendEndTimeToLog();                     // пишем в лог время окончания операции
                                        LBar->Free();                           // уничтожаем форму с прогресс-баром
                                        return;                                 // выходим
                                }
                                // если прочитали количество байт кратное 256-и
                                if((i+1)%256==0)
                                {       LBar->ProgressBar1->Position=100*(i+1)/SelectedChip.Area1Size;  // вычисляем новую позицию прогресс-бара
                                }
                        }
                        break;
    case 0x3931E:       // выбран чип AT90S8535
    case 0x2921E:       // выбран чип AT90S4434
                        if(!AT90S4434_ProgrammingEnable())      // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                SendEndTimeToLog();             // пишем в лог время окончания операции
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого можно уже и читать
                        for(unsigned int i=0; i<SelectedChip.Area1Size; i++)
                        {       if(!AT90S4434_ReadProgramMemory(i,0))           // пробуем прочитать байт программы
                                {       SendMsgToLog(19," with fail.");         // если вернуло false - не удалось прочитать
                                        SendEndTimeToLog();                     // пишем в лог время окончания операции
                                        LBar->Free();                           // уничтожаем форму с прогресс-баром
                                        return;                                 // выходим
                                }
                                // если прочитали количество байт кратное 32-м
                                if((i+1)%32==0)
                                {       LBar->ProgressBar1->Position=100*(i+1)/SelectedChip.Area1Size;  // вычисляем новую позицию прогресс-бара
                                }
                        }
                        break;
    case 0x1931E:       // выбран чип AT90S8515
    case 0x1921E:       // выбран чип AT90S4414
                        if(!AT90S4414_ProgrammingEnable())      // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                SendEndTimeToLog();             // пишем в лог время окончания операции
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого можно уже и читать
                        for(unsigned int i=0; i<SelectedChip.Area1Size; i++)
                        {       if(!AT90S4414_ReadProgramMemory(i,0))           // пробуем прочитать байт программы
                                {       SendMsgToLog(19," with fail.");         // если вернуло false - не удалось прочитать
                                        SendEndTimeToLog();                     // пишем в лог время окончания операции
                                        LBar->Free();                           // уничтожаем форму с прогресс-баром
                                        return;                                 // выходим
                                }
                                // если прочитали количество байт кратное 32-м
                                if((i+1)%32==0)
                                {       LBar->ProgressBar1->Position=100*(i+1)/SelectedChip.Area1Size;  // вычисляем новую позицию прогресс-бара
                                }
                        }
                        break;
    case 0x3921E:       // выбран чип AT90S4433
    case 0x5911E:       // выбран чип AT90S2333
                        if(!AT90S2333_ProgrammingEnable())      // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                SendEndTimeToLog();             // пишем в лог время окончания операции
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого можно уже и читать
                        for(unsigned int i=0; i<SelectedChip.Area1Size; i++)
                        {       if(!AT90S2333_ReadProgramMemory(i,0))           // пробуем прочитать байт программы
                                {       SendMsgToLog(19," with fail.");         // если вернуло false - не удалось прочитать
                                        SendEndTimeToLog();                     // пишем в лог время окончания операции
                                        LBar->Free();                           // уничтожаем форму с прогресс-баром
                                        return;                                 // выходим
                                }
                                // если прочитали количество байт кратное 32-м
                                if((i+1)%32==0)
                                {       LBar->ProgressBar1->Position=100*(i+1)/SelectedChip.Area1Size;  // вычисляем новую позицию прогресс-бара
                                }
                        }
                        break;
    case 0x3911E:       // выбран чип AT90S2343
                        if(!AT90S2343_ProgrammingEnable())      // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                SendEndTimeToLog();             // пишем в лог время окончания операции
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого можно уже и читать
                        for(unsigned int i=0; i<SelectedChip.Area1Size; i++)
                        {       if(!AT90S2343_ReadProgramMemory(i,0))           // пробуем прочитать байт программы
                                {       SendMsgToLog(19," with fail.");         // если вернуло false - не удалось прочитать
                                        SendEndTimeToLog();                     // пишем в лог время окончания операции
                                        LBar->Free();                           // уничтожаем форму с прогресс-баром
                                        return;                                 // выходим
                                }
                                // если прочитали количество байт кратное 32-м
                                if((i+1)%32==0)
                                {       LBar->ProgressBar1->Position=100*(i+1)/SelectedChip.Area1Size;  // вычисляем новую позицию прогресс-бара
                                }
                        }
                        break;
    case 0x2911E:       // выбран чип AT90S2323
                        if(!AT90S2323_ProgrammingEnable())      // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                SendEndTimeToLog();             // пишем в лог время окончания операции
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого можно уже и читать
                        for(unsigned int i=0; i<SelectedChip.Area1Size; i++)
                        {       if(!AT90S2323_ReadProgramMemory(i,0))           // пробуем прочитать байт программы
                                {       SendMsgToLog(19," with fail.");         // если вернуло false - не удалось прочитать
                                        SendEndTimeToLog();                     // пишем в лог время окончания операции
                                        LBar->Free();                           // уничтожаем форму с прогресс-баром
                                        return;                                 // выходим
                                }
                                // если прочитали количество байт кратное 32-м
                                if((i+1)%32==0)
                                {       LBar->ProgressBar1->Position=100*(i+1)/SelectedChip.Area1Size;  // вычисляем новую позицию прогресс-бара
                                }
                        }
                        break;
    case 0x1911E:       // выбран чип AT90S2313
                        if(!AT90S2313_ProgrammingEnable())      // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                SendEndTimeToLog();             // пишем в лог время окончания операции
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого можно уже и читать
                        for(unsigned int i=0; i<SelectedChip.Area1Size; i++)
                        {       if(!AT90S2313_ReadProgramMemory(i,0))           // пробуем прочитать байт программы
                                {       SendMsgToLog(19," with fail.");         // если вернуло false - не удалось прочитать
                                        SendEndTimeToLog();                     // пишем в лог время окончания операции
                                        LBar->Free();                           // уничтожаем форму с прогресс-баром
                                        return;                                 // выходим
                                }
                                // если прочитали количество байт кратное 32-м
                                if((i+1)%32==0)
                                {       LBar->ProgressBar1->Position=100*(i+1)/SelectedChip.Area1Size;  // вычисляем новую позицию прогресс-бара
                                }
                        }
                        break;
    case 0x1901E:       // выбран чип AT90S1200
                        if(!AT90S1200_ProgrammingEnable())      // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                SendEndTimeToLog();             // пишем в лог время окончания операции
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого можно уже и читать
                        for(unsigned int i=0; i<SelectedChip.Area1Size; i++)
                        {       if(!AT90S1200_ReadProgramMemory(i,0))           // пробуем прочитать байт программы
                                {       SendMsgToLog(19," with fail.");         // если вернуло false - не удалось прочитать
                                        SendEndTimeToLog();                     // пишем в лог время окончания операции
                                        LBar->Free();                           // уничтожаем форму с прогресс-баром
                                        return;                                 // выходим
                                }
                                // если прочитали количество байт кратное 32-м
                                if((i+1)%32==0)
                                {       LBar->ProgressBar1->Position=100*(i+1)/SelectedChip.Area1Size;  // вычисляем новую позицию прогресс-бара
                                }
                        }
                        break;
    case 0xA911E:       // выбрано устройство ATtiny2313
                        if(!ATtiny2313_ProgrammingEnable())     // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                SendEndTimeToLog();             // пишем в лог время окончания операции
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого можно уже и читать
                        for(unsigned int i=0; i<SelectedChip.Area1Size; i++)
                        {       if(!ATtiny2313_ReadProgramMemory(i,0))          // пробуем прочитать байт программы
                                {       SendMsgToLog(19," with fail.");         // если вернуло false - не удалось прочитать
                                        SendEndTimeToLog();                     // пишем в лог время окончания операции
                                        LBar->Free();                           // уничтожаем форму с прогресс-баром
                                        return;                                 // выходим
                                }
                                // если прочитали количество байт кратное 32-м
                                if((i+1)%32==0)
                                {       LBar->ProgressBar1->Position=100*(i+1)/SelectedChip.Area1Size;  // вычисляем новую позицию прогресс-бара
                                }
                        }
                        break;
    case 0:     SendMsgToLog(14,"");            // сообщение в лог, что не выбран ни один чип
                SendEndTimeToLog();             // пишем в лог время окончания операции
                LBar->Free();                   // уничтожаем форму с прогресс-баром
                return;                         // выходим
    default:    SendMsgToLog(15," unknown");    // сообщение в лог, что чип нам неизвестен и выходим
                SendEndTimeToLog();             // пишем в лог время окончания операции
                LBar->Free();                   // уничтожаем форму с прогресс-баром
                return;                         // выходим
  }
  LBar->Free();         // уничтожаем форму с прогресс-баром
  // помещаем прочитанное на форму в зависимости от вкладки
  switch(Form1->PageControl1->TabIndex)
  {     case 0: PlaceDataToForm(1,1);      // в RichEdit1 из Area1
                break;
        case 1: PlaceDataToForm(2,1);      // в RichEdit2 из Area1
                break;
        default: break;
  }
  SendMsgToLog(19,"");  // сообщаем о завершении операции
  SendEndTimeToLog();   // пишем в лог время окончания операции
}
//---------------------------------------------------------------------------
//--- НАЖАТА КНОПКА READ DATA -----------------------------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::Button8Click(TObject *Sender)
{ // включаем прогресс-бар
  Application->CreateForm(__classid(TLBar),&LBar);      // создаём форму с прогресс-баром
  LBar->Show();                                         // показываем её в немодальном окне

  SendMsgToLog(18," read the EEPROM");          // сообщаем о попытке прочитать программу
  SendStartTimeToLog();                         // пишем в лог время начала операции
  switch(SelectedChip.ID)
  { case 0xD931E:       // выбрано устройство ATtiny861
    case 0x8921E:       // выбрано устройство ATtiny461
    case 0xC911E:       // выбрано устройство ATtiny261
                        if(!ATtiny261_ProgrammingEnable())     // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                SendEndTimeToLog();             // пишем в лог время окончания операции
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого можно уже и читать
                        for(unsigned int i=0; i<SelectedChip.Area2Size; i++)
                        {       if(!ATtiny261_ReadEEPROMMemory(i,0))           // пробуем прочитать байт EEPROM
                                {       SendMsgToLog(19," with fail.");         // если вернуло false - не удалось прочитать
                                        SendEndTimeToLog();                     // пишем в лог время окончания операции
                                        LBar->Free();                           // уничтожаем форму с прогресс-баром
                                        return;                                 // выходим
                                }
                                // если прочитали количество байт кратное 4-м
                                if((i+1)%4==0)
                                {       LBar->ProgressBar1->Position=100*(i+1)/SelectedChip.Area2Size;  // вычисляем новую позицию прогресс-бара
                                }
                        }
                        break;
    case 0x9911E:       // выбрано устройство ATtiny26
                        if(!ATtiny26_ProgrammingEnable())     // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                SendEndTimeToLog();             // пишем в лог время окончания операции
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого можно уже и читать
                        for(unsigned int i=0; i<SelectedChip.Area2Size; i++)
                        {       if(!ATtiny26_ReadEEPROMMemory(i,0))           // пробуем прочитать байт EEPROM
                                {       SendMsgToLog(19," with fail.");         // если вернуло false - не удалось прочитать
                                        SendEndTimeToLog();                     // пишем в лог время окончания операции
                                        LBar->Free();                           // уничтожаем форму с прогресс-баром
                                        return;                                 // выходим
                                }
                                // если прочитали количество байт кратное 4-м
                                if((i+1)%4==0)
                                {       LBar->ProgressBar1->Position=100*(i+1)/SelectedChip.Area2Size;  // вычисляем новую позицию прогресс-бара
                                }
                        }
                        break;
    case 0xB931E:       // выбрано устройство ATtiny85
    case 0x6921E:       // выбрано устройство ATtiny45
    case 0x8911E:       // выбрано устройство ATtiny25
                        if(!ATtiny25_ProgrammingEnable())     // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                SendEndTimeToLog();             // пишем в лог время окончания операции
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого можно уже и читать
                        for(unsigned int i=0; i<SelectedChip.Area2Size; i++)
                        {       if(!ATtiny25_ReadEEPROMMemory(i,0))           // пробуем прочитать байт EEPROM
                                {       SendMsgToLog(19," with fail.");         // если вернуло false - не удалось прочитать
                                        SendEndTimeToLog();                     // пишем в лог время окончания операции
                                        LBar->Free();                           // уничтожаем форму с прогресс-баром
                                        return;                                 // выходим
                                }
                                // если прочитали количество байт кратное 4-м
                                if((i+1)%4==0)
                                {       LBar->ProgressBar1->Position=100*(i+1)/SelectedChip.Area2Size;  // вычисляем новую позицию прогресс-бара
                                }
                        }
                        break;
    case 0x6911E:       // выбран чип ATtiny22
                        if(!ATtiny22_ProgrammingEnable())      // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                SendEndTimeToLog();             // пишем в лог время окончания операции
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого можно уже и читать
                        for(unsigned int i=0; i<SelectedChip.Area2Size; i++)
                        {       if(!ATtiny22_ReadEEPROMMemory(i,0))            // пробуем прочитать байт EEPROM
                                {       SendMsgToLog(19," with fail.");         // если вернуло false - не удалось прочитать
                                        SendEndTimeToLog();                     // пишем в лог время окончания операции
                                        LBar->Free();                           // уничтожаем форму с прогресс-баром
                                        return;                                 // выходим
                                }
                                // если прочитали количество байт кратное 4-м
                                if((i+1)%4==0)
                                {       LBar->ProgressBar1->Position=100*(i+1)/SelectedChip.Area2Size;  // вычисляем новую позицию прогресс-бара
                                }
                        }
                        break;
    case 0x6901E:       // выбран чип ATtiny15
                        if(!ATtiny15_ProgrammingEnable())      // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                SendEndTimeToLog();             // пишем в лог время окончания операции
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого можно уже и читать
                        for(unsigned int i=0; i<SelectedChip.Area2Size; i++)
                        {       if(!ATtiny15_ReadEEPROMMemory(i,0))            // пробуем прочитать байт EEPROM
                                {       SendMsgToLog(19," with fail.");         // если вернуло false - не удалось прочитать
                                        SendEndTimeToLog();                     // пишем в лог время окончания операции
                                        LBar->Free();                           // уничтожаем форму с прогресс-баром
                                        return;                                 // выходим
                                }
                                // если прочитали количество байт кратное 4-м
                                if((i+1)%4==0)
                                {       LBar->ProgressBar1->Position=100*(i+1)/SelectedChip.Area2Size;  // вычисляем новую позицию прогресс-бара
                                }
                        }
                        break;
    case 0x7901E:       // выбран чип ATtiny13
                        if(!ATtiny13_ProgrammingEnable())      // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                SendEndTimeToLog();             // пишем в лог время окончания операции
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого можно уже и читать
                        for(unsigned int i=0; i<SelectedChip.Area2Size; i++)
                        {       if(!ATtiny13_ReadEEPROMMemory(i,0))            // пробуем прочитать байт EEPROM
                                {       SendMsgToLog(19," with fail.");         // если вернуло false - не удалось прочитать
                                        SendEndTimeToLog();                     // пишем в лог время окончания операции
                                        LBar->Free();                           // уничтожаем форму с прогресс-баром
                                        return;                                 // выходим
                                }
                                // если прочитали количество байт кратное 4-м
                                if((i+1)%4==0)
                                {       LBar->ProgressBar1->Position=100*(i+1)/SelectedChip.Area2Size;  // вычисляем новую позицию прогресс-бара
                                }
                        }
                        break;
    case 0x5901E:       // выбран чип ATtiny12
                        if(!ATtiny12_ProgrammingEnable())      // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                SendEndTimeToLog();             // пишем в лог время окончания операции
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого можно уже и читать
                        for(unsigned int i=0; i<SelectedChip.Area2Size; i++)
                        {       if(!ATtiny12_ReadEEPROMMemory(i,0))            // пробуем прочитать байт EEPROM
                                {       SendMsgToLog(19," with fail.");         // если вернуло false - не удалось прочитать
                                        SendEndTimeToLog();                     // пишем в лог время окончания операции
                                        LBar->Free();                           // уничтожаем форму с прогресс-баром
                                        return;                                 // выходим
                                }
                                // если прочитали количество байт кратное 4-м
                                if((i+1)%4==0)
                                {       LBar->ProgressBar1->Position=100*(i+1)/SelectedChip.Area2Size;  // вычисляем новую позицию прогресс-бара
                                }
                        }
                        break;
    case 0x81971E:       // выбрано устройство AT90CAN128
    case 0x81961E:       // выбрано устройство AT90CAN64
    case 0x81951E:       // выбрано устройство AT90CAN32
                        if(!AT90CAN32_ProgrammingEnable())     // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                SendEndTimeToLog();             // пишем в лог время окончания операции
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого можно уже и читать
                        for(unsigned int i=0; i<SelectedChip.Area2Size; i++)
                        {       if(!AT90CAN32_ReadEEPROMMemory(i,0))           // пробуем прочитать байт EEPROM
                                {       SendMsgToLog(19," with fail.");         // если вернуло false - не удалось прочитать
                                        SendEndTimeToLog();                     // пишем в лог время окончания операции
                                        LBar->Free();                           // уничтожаем форму с прогресс-баром
                                        return;                                 // выходим
                                }
                                // если прочитали количество байт кратное 8-и
                                if((i+1)%8==0)
                                {       LBar->ProgressBar1->Position=100*(i+1)/SelectedChip.Area2Size;  // вычисляем новую позицию прогресс-бара
                                }
                        }
                        break;
    case 0x3931E:       // выбран чип AT90S8535
    case 0x2921E:       // выбран чип AT90S4434
                        if(!AT90S4434_ProgrammingEnable())      // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                SendEndTimeToLog();             // пишем в лог время окончания операции
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого можно уже и читать
                        for(unsigned int i=0; i<SelectedChip.Area2Size; i++)
                        {       if(!AT90S4434_ReadEEPROMMemory(i,0))            // пробуем прочитать байт EEPROM
                                {       SendMsgToLog(19," with fail.");         // если вернуло false - не удалось прочитать
                                        SendEndTimeToLog();                     // пишем в лог время окончания операции
                                        LBar->Free();                           // уничтожаем форму с прогресс-баром
                                        return;                                 // выходим
                                }
                                // если прочитали количество байт кратное 4-м
                                if((i+1)%4==0)
                                {       LBar->ProgressBar1->Position=100*(i+1)/SelectedChip.Area2Size;  // вычисляем новую позицию прогресс-бара
                                }
                        }
                        break;
    case 0x1931E:       // выбран чип AT90S8515
    case 0x1921E:       // выбран чип AT90S4414
                        if(!AT90S4414_ProgrammingEnable())      // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                SendEndTimeToLog();             // пишем в лог время окончания операции
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого можно уже и читать
                        for(unsigned int i=0; i<SelectedChip.Area2Size; i++)
                        {       if(!AT90S4414_ReadEEPROMMemory(i,0))            // пробуем прочитать байт EEPROM
                                {       SendMsgToLog(19," with fail.");         // если вернуло false - не удалось прочитать
                                        SendEndTimeToLog();                     // пишем в лог время окончания операции
                                        LBar->Free();                           // уничтожаем форму с прогресс-баром
                                        return;                                 // выходим
                                }
                                // если прочитали количество байт кратное 4-м
                                if((i+1)%4==0)
                                {       LBar->ProgressBar1->Position=100*(i+1)/SelectedChip.Area2Size;  // вычисляем новую позицию прогресс-бара
                                }
                        }
                        break;
    case 0x3921E:       // выбран чип AT90S4433
    case 0x5911E:       // выбран чип AT90S2333
                        if(!AT90S2333_ProgrammingEnable())      // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                SendEndTimeToLog();             // пишем в лог время окончания операции
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого можно уже и читать
                        for(unsigned int i=0; i<SelectedChip.Area2Size; i++)
                        {       if(!AT90S2333_ReadEEPROMMemory(i,0))            // пробуем прочитать байт EEPROM
                                {       SendMsgToLog(19," with fail.");         // если вернуло false - не удалось прочитать
                                        SendEndTimeToLog();                     // пишем в лог время окончания операции
                                        LBar->Free();                           // уничтожаем форму с прогресс-баром
                                        return;                                 // выходим
                                }
                                // если прочитали количество байт кратное 4-м
                                if((i+1)%4==0)
                                {       LBar->ProgressBar1->Position=100*(i+1)/SelectedChip.Area2Size;  // вычисляем новую позицию прогресс-бара
                                }
                        }
                        break;
    case 0x3911E:       // выбран чип AT90S2343
                        if(!AT90S2343_ProgrammingEnable())      // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                SendEndTimeToLog();             // пишем в лог время окончания операции
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого можно уже и читать
                        for(unsigned int i=0; i<SelectedChip.Area2Size; i++)
                        {       if(!AT90S2343_ReadEEPROMMemory(i,0))            // пробуем прочитать байт EEPROM
                                {       SendMsgToLog(19," with fail.");         // если вернуло false - не удалось прочитать
                                        SendEndTimeToLog();                     // пишем в лог время окончания операции
                                        LBar->Free();                           // уничтожаем форму с прогресс-баром
                                        return;                                 // выходим
                                }
                                // если прочитали количество байт кратное 4-м
                                if((i+1)%4==0)
                                {       LBar->ProgressBar1->Position=100*(i+1)/SelectedChip.Area2Size;  // вычисляем новую позицию прогресс-бара
                                }
                        }
                        break;
    case 0x2911E:       // выбран чип AT90S2323
                        if(!AT90S2323_ProgrammingEnable())      // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                SendEndTimeToLog();             // пишем в лог время окончания операции
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого можно уже и читать
                        for(unsigned int i=0; i<SelectedChip.Area2Size; i++)
                        {       if(!AT90S2323_ReadEEPROMMemory(i,0))            // пробуем прочитать байт EEPROM
                                {       SendMsgToLog(19," with fail.");         // если вернуло false - не удалось прочитать
                                        SendEndTimeToLog();                     // пишем в лог время окончания операции
                                        LBar->Free();                           // уничтожаем форму с прогресс-баром
                                        return;                                 // выходим
                                }
                                // если прочитали количество байт кратное 4-м
                                if((i+1)%4==0)
                                {       LBar->ProgressBar1->Position=100*(i+1)/SelectedChip.Area2Size;  // вычисляем новую позицию прогресс-бара
                                }
                        }
                        break;
    case 0x1911E:       // выбран чип AT90S2313
                        if(!AT90S2313_ProgrammingEnable())      // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                SendEndTimeToLog();             // пишем в лог время окончания операции
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого можно уже и читать
                        for(unsigned int i=0; i<SelectedChip.Area2Size; i++)
                        {       if(!AT90S2313_ReadEEPROMMemory(i,0))            // пробуем прочитать байт EEPROM
                                {       SendMsgToLog(19," with fail.");         // если вернуло false - не удалось прочитать
                                        SendEndTimeToLog();                     // пишем в лог время окончания операции
                                        LBar->Free();                           // уничтожаем форму с прогресс-баром
                                        return;                                 // выходим
                                }
                                // если прочитали количество байт кратное 4-м
                                if((i+1)%4==0)
                                {       LBar->ProgressBar1->Position=100*(i+1)/SelectedChip.Area2Size;  // вычисляем новую позицию прогресс-бара
                                }
                        }
                        break;
    case 0x1901E:       // выбран чип AT90S1200
                        if(!AT90S1200_ProgrammingEnable())      // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                SendEndTimeToLog();             // пишем в лог время окончания операции
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого можно уже и читать
                        for(unsigned int i=0; i<SelectedChip.Area2Size; i++)
                        {       if(!AT90S1200_ReadEEPROMMemory(i,0))            // пробуем прочитать байт EEPROM
                                {       SendMsgToLog(19," with fail.");         // если вернуло false - не удалось прочитать
                                        SendEndTimeToLog();                     // пишем в лог время окончания операции
                                        LBar->Free();                           // уничтожаем форму с прогресс-баром
                                        return;                                 // выходим
                                }
                                // если прочитали количество байт кратное 4-м
                                if((i+1)%4==0)
                                {       LBar->ProgressBar1->Position=100*(i+1)/SelectedChip.Area2Size;  // вычисляем новую позицию прогресс-бара
                                }
                        }
                        break;
    case 0xA911E:       // выбрано устройство ATtiny2313
                        if(!ATtiny2313_ProgrammingEnable())     // пробуем перевести чип в режим программирования и синхронизироваться с ним
                        {       SendMsgToLog(19," with fail."); // если вернуло false - не удалось синхронизироваться
                                SendEndTimeToLog();             // пишем в лог время окончания операции
                                LBar->Free();                   // уничтожаем форму с прогресс-баром
                                return;                         // выходим
                        }
                        // после этого можно уже и читать
                        for(unsigned int i=0; i<SelectedChip.Area2Size; i++)
                        {       if(!ATtiny2313_ReadEEPROMMemory(i,0))           // пробуем прочитать байт EEPROM
                                {       SendMsgToLog(19," with fail.");         // если вернуло false - не удалось прочитать
                                        SendEndTimeToLog();                     // пишем в лог время окончания операции
                                        LBar->Free();                           // уничтожаем форму с прогресс-баром
                                        return;                                 // выходим
                                }
                                // если прочитали количество байт кратное 4-м
                                if((i+1)%4==0)
                                {       LBar->ProgressBar1->Position=100*(i+1)/SelectedChip.Area2Size;  // вычисляем новую позицию прогресс-бара
                                }
                        }
                        break;
    case 0:     SendMsgToLog(14,"");            // сообщение в лог, что не выбран ни один чип
                SendEndTimeToLog();             // пишем в лог время окончания операции
                LBar->Free();                   // уничтожаем форму с прогресс-баром
                return;                         // выходим
    default:    SendMsgToLog(15," unknown");    // сообщение в лог, что чип нам неизвестен и выходим
                SendEndTimeToLog();             // пишем в лог время окончания операции
                LBar->Free();                   // уничтожаем форму с прогресс-баром
                return;                         // выходим
  }
  LBar->Free();         // уничтожаем форму с прогресс-баром
  // помещаем прочитанное на форму в зависимости от вкладки
  switch(Form1->PageControl1->TabIndex)
  {     case 0: PlaceDataToForm(3,2);      // в RichEdit3 из Area2
                break;
        case 1: PlaceDataToForm(4,2);      // в RichEdit4 из Area2
                break;
        default: break;
  }
  SendMsgToLog(19,"");  // сообщаем о завершении операции
  SendEndTimeToLog();   // пишем в лог время окончания операции
}
//---------------------------------------------------------------------------
//--- ЧЕРЕЗ ВЕРХНЕЕ МЕНЮ ВЫБРАН ЧИП ATtiny2313 ------------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::tiny23131Click(TObject *Sender)
{ InitChip(0xA911E);                    // заполняем структуру чипа, инициализируем его память
}
//---------------------------------------------------------------------------
//--- ЧЕРЕЗ ВЕРХНЕЕ МЕНЮ ВЫБРАН ЧИП AT90S1200 -------------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::AT90S12001Click(TObject *Sender)
{ InitChip(0x1901E);                    // заполняем структуру чипа, инициализируем его память
}
//---------------------------------------------------------------------------
//--- ЧЕРЕЗ ВЕРХНЕЕ МЕНЮ ВЫБРАН ЧИП AT90S2313 -------------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::AT90S23131Click(TObject *Sender)
{ InitChip(0x1911E);                    // заполняем структуру чипа, инициализируем его память
}
//---------------------------------------------------------------------------
//--- ЧЕРЕЗ ВЕРХНЕЕ МЕНЮ ВЫБРАН ЧИП AT90S2323 -------------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::AT90S23231Click(TObject *Sender)
{ InitChip(0x2911E);                    // заполняем структуру чипа, инициализируем его память
}
//---------------------------------------------------------------------------
//--- ЧЕРЕЗ ВЕРХНЕЕ МЕНЮ ВЫБРАН ЧИП AT90S2343 -------------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::AT90S23431Click(TObject *Sender)
{ InitChip(0x3911E);                    // заполняем структуру чипа, инициализируем его память
}
//---------------------------------------------------------------------------
//--- ЧЕРЕЗ ВЕРХНЕЕ МЕНЮ ВЫБРАН ЧИП AT90S2333 -------------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::AT90S23331Click(TObject *Sender)
{ InitChip(0x5911E);                    // заполняем структуру чипа, инициализируем его память
}
//---------------------------------------------------------------------------
//--- ЧЕРЕЗ ВЕРХНЕЕ МЕНЮ ВЫБРАН ЧИП AT90S4433 -------------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::AT90S44331Click(TObject *Sender)
{ InitChip(0x3921E);                    // заполняем структуру чипа, инициализируем его память
}
//---------------------------------------------------------------------------
//--- ЧЕРЕЗ ВЕРХНЕЕ МЕНЮ ВЫБРАН ЧИП AT90S4414 -------------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::AT90S44141Click(TObject *Sender)
{ InitChip(0x1921E);                    // заполняем структуру чипа, инициализируем его память
}
//---------------------------------------------------------------------------
//--- ЧЕРЕЗ ВЕРХНЕЕ МЕНЮ ВЫБРАН ЧИП AT90S8515 -------------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::AT90S85151Click(TObject *Sender)
{ InitChip(0x1931E);                    // заполняем структуру чипа, инициализируем его память
}
//---------------------------------------------------------------------------
//--- ЧЕРЕЗ ВЕРХНЕЕ МЕНЮ ВЫБРАН ЧИП AT90S4434 -------------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::AT90S44341Click(TObject *Sender)
{ InitChip(0x2921E);                    // заполняем структуру чипа, инициализируем его память
}
//---------------------------------------------------------------------------
//--- ЧЕРЕЗ ВЕРХНЕЕ МЕНЮ ВЫБРАН ЧИП AT90S8535 -------------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::AT90S85351Click(TObject *Sender)
{ InitChip(0x3931E);                    // заполняем структуру чипа, инициализируем его память
}
//---------------------------------------------------------------------------
//--- ЧЕРЕЗ ВЕРХНЕЕ МЕНЮ ВЫБРАН ЧИП AT90CAN32 -------------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::AT90CAN321Click(TObject *Sender)
{ InitChip(0x81951E);                   // заполняем структуру чипа, инициализируем его память
}
//---------------------------------------------------------------------------
//--- ЧЕРЕЗ ВЕРХНЕЕ МЕНЮ ВЫБРАН ЧИП AT90CAN64 -------------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::AT90CAN641Click(TObject *Sender)
{ InitChip(0x81961E);                   // заполняем структуру чипа, инициализируем его память
}
//---------------------------------------------------------------------------
//--- ЧЕРЕЗ ВЕРХНЕЕ МЕНЮ ВЫБРАН ЧИП AT90CAN128 ------------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::AT90CAN1281Click(TObject *Sender)
{ InitChip(0x81971E);                   // заполняем структуру чипа, инициализируем его память
}
//---------------------------------------------------------------------------
//--- ЧЕРЕЗ ВЕРХНЕЕ МЕНЮ ВЫБРАН ЧИП ATTINY12 --------------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::ATtiny121Click(TObject *Sender)
{ InitChip(0x5901E);                   // заполняем структуру чипа, инициализируем его память
}
//---------------------------------------------------------------------------
//--- ЧЕРЕЗ ВЕРХНЕЕ МЕНЮ ВЫБРАН ЧИП ATTINY13 --------------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::ATtiny131Click(TObject *Sender)
{ InitChip(0x7901E);                   // заполняем структуру чипа, инициализируем его память
}
//---------------------------------------------------------------------------
//--- ЧЕРЕЗ ВЕРХНЕЕ МЕНЮ ВЫБРАН ЧИП ATTINY15 --------------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::ATtiny151Click(TObject *Sender)
{ InitChip(0x6901E);                   // заполняем структуру чипа, инициализируем его память
}
//---------------------------------------------------------------------------
//--- ЧЕРЕЗ ВЕРХНЕЕ МЕНЮ ВЫБРАН ЧИП ATTINY22 --------------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::ATtiny221Click(TObject *Sender)
{ InitChip(0x6911E);                   // заполняем структуру чипа, инициализируем его память
}
//---------------------------------------------------------------------------
//--- ЧЕРЕЗ ВЕРХНЕЕ МЕНЮ ВЫБРАН ЧИП ATTINY25 --------------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::ATtiny251Click(TObject *Sender)
{ InitChip(0x8911E);                   // заполняем структуру чипа, инициализируем его память
}
//---------------------------------------------------------------------------
//--- ЧЕРЕЗ ВЕРХНЕЕ МЕНЮ ВЫБРАН ЧИП ATTINY45 --------------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::ATtiny451Click(TObject *Sender)
{ InitChip(0x6921E);                   // заполняем структуру чипа, инициализируем его память
}
//---------------------------------------------------------------------------
//--- ЧЕРЕЗ ВЕРХНЕЕ МЕНЮ ВЫБРАН ЧИП ATTINY85 --------------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::ATtiny851Click(TObject *Sender)
{ InitChip(0xB931E);                   // заполняем структуру чипа, инициализируем его память
}
//---------------------------------------------------------------------------
//--- ЧЕРЕЗ ВЕРХНЕЕ МЕНЮ ВЫБРАН ЧИП ATTINY26 --------------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::ATtiny261Click(TObject *Sender)
{ InitChip(0x9911E);                   // заполняем структуру чипа, инициализируем его память
}
//---------------------------------------------------------------------------
//--- ЧЕРЕЗ ВЕРХНЕЕ МЕНЮ ВЫБРАН ЧИП ATTINY26 --------------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::ATtiny2611Click(TObject *Sender)
{ InitChip(0xC911E);                   // заполняем структуру чипа, инициализируем его память
}
//---------------------------------------------------------------------------
//--- ЧЕРЕЗ ВЕРХНЕЕ МЕНЮ ВЫБРАН ЧИП ATTINY461 --------------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::ATtiny4611Click(TObject *Sender)
{ InitChip(0x8921E);                   // заполняем структуру чипа, инициализируем его память
}
//---------------------------------------------------------------------------
//--- ЧЕРЕЗ ВЕРХНЕЕ МЕНЮ ВЫБРАН ЧИП ATTINY861 --------------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::ATtiny8611Click(TObject *Sender)
{ InitChip(0xD931E);                   // заполняем структуру чипа, инициализируем его память
}
//---------------------------------------------------------------------------

