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

#include "MainProgram.h"        // переменные для работы с основной формой
#include "ProgressBar.h"        // для использования прогресс-бара
#include "About.h"              // для использования окна About
#include "Schematic.h"          // для вывода формы Schema
#include "PortFunctions.h"      // для работы с портом
#include "WireFunctions.h"      // для работы через 1-Wire
#include "ChipFunctions.h"      // для работы с памятью чипа
#include "FormFunctions.h"      // для работы с элементами формы чипа
#include "SendMsgFunctions.h"   // для отправки сообщений в лог
#include "CalcCRC.h"            // для расчёта CRC
#include "DS2431.h"             // для работы с чипами DS2431 / DS28E07
#include "DS2430A.h"            // для работы с чипами DS2430A / DS1971
#include "DS24B33.h"            // для работы с чипами DS24B33
#include "DS18B20.h"            // для работы с чипами DS18B20, DS1822
#include "DS18S20.h"            // для работы с чипами DS18S20 / DS1920
#include "DS1991.h"             // для работы с чипами DS1991
#include "DS1992.h"             // для работы с чипами DS1992, DS1993, DS1995, DS1996
#include "DS2405.h"             // для работы с чипами DS2405
#include "DS2415.h"             // для работы с чипами DS2415, DS2417
#include "DS1994.h"             // для работы с чипами DS1994, DS1427
#include "DS1963L.h"            // для работы с чипами DS1963L, DS2423
#include "DS2890.h"             // для работы с чипами DS2890
#include "RW1990.h"             // для работы с чипами RW1990
#include "DS28E05.h"            // для работы с чипами DS28E05
#include "AN1990.h"             // для работы с чипами AN1990 / TM2004 
#include "DS2502.h"             // для работы с чипами DS2502 / DS1982
#include "DS2432.h"             // для работы с чипами DS2432 / DS1961S
#include "MAX31826.h"           // для работы с чипами MAX31826
#include "DS28EC20.h"           // для работы с чипами DS28EC20
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
//---------------------------------------------------------------------------
//--- ГЛОБАЛЬНЫЕ ПЕРЕМЕННЫЕ -------------------------------------------------
//---------------------------------------------------------------------------
TForm1 *Form1;  // форма
//---------------------------------------------------------------------------
//--- ОТКРЫТИЕ ВЫБРАННОГО COM-ПОРТА -----------------------------------------
//---------------------------------------------------------------------------
void OpenPort()
{ //откроем выбранный порт. Чтобы открыть порт на nt-платформе надо указывать
  // "\\.\PortName", в СИ для печати символа \ надо его указывать 2 раза
  char PortName[100]="\\\\.\\";
  strcat(PortName,Form1->ComboBox1->Text.c_str());
  OpenCom(PortName);                    // само открытие порта происходит здесь
  if(Port!=INVALID_HANDLE_VALUE)
  { Form1->Button1->Enabled=false;
    Form1->Button2->Enabled=true;
    Form1->Button3->Enabled=true;
    EnableControlButtons();                     // включаем кнопки управления
    SendMsgToLogForm(4,AnsiString(PortName));   // открыт COM-порт
  }
  else  SendMsgToLogForm(2,"");                 // COM-порт не доступен
}
//---------------------------------------------------------------------------
//--- ЗАКРЫТИЕ ВЫБРАННОГО COM-ПОРТА -----------------------------------------
//---------------------------------------------------------------------------
void ClosePort()
{ CloseHandle(Port);
  Port=INVALID_HANDLE_VALUE;
  Form1->Button1->Enabled=true;
  Form1->Button2->Enabled=false;
  Form1->Button3->Enabled=false;
  DisableControlButtons();              // выключаем кнопки управления
  SendMsgToLogForm(5,"");               // COM-порт закрыт
}
//---------------------------------------------------------------------------
//--- КОНСТРУИРОВАНИЕ ГЛАВНОЙ ФОРМЫ -----------------------------------------
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
        : TForm(Owner)
{ Port                          = INVALID_HANDLE_VALUE;         // порт не открыт
  SelectedChip.Family           = 0;                            // чип не выбран
  SelectedChip.Modify           = 0;                            // и вручную тоже не выбран
  Form1->Panel2->Visible        = false;                        // выключаем панель чипа
  Form1->Panel3->Visible        = false;                        // выключаем панель с путём к файлу
  Form1->Timer1->Enabled        = false;                        // выключаем таймер
  Form1->AutoSize               = true;
  Button1->Enabled              = true;
  Button2->Enabled              = false;
  Button3->Enabled              = false;
  StringGrid1->Cells[0][0]      = "№";
  StringGrid1->Cells[1][0]      = "ROM Number";
  StringGrid1->Cells[2][0]      = "Description";
  LoadOptions();                                                // загружаем сохранённый выбор языка и программатора
  RenameFormElements();                                         // подписываем менюшки
  RenameProgrammerMenu();                                       // подписываем элементы в меню выбора программтаора
}
//---------------------------------------------------------------------------
//--- КНОПКА ОТКРЫТИЯ 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();
  SaveOptions();    // запоминаем выбор языка и программатора
  Close();
}
//---------------------------------------------------------------------------
//--- ВЫБРАЛИ В МЕНЮ ПУНКТ ABOUT --------------------------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::About1Click(TObject *Sender)
{ AboutBox->Show();
}
//---------------------------------------------------------------------------
//--- КНОПКА ПОИСКА УСТРОЙСТВ НА ШИНЕ 1-WIRE --------------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::Button3Click(TObject *Sender)
{ int  DevCounter;      // счётчик найденных устройств

  DevCounter=SearchDevices();
  Edit2->Text=IntToStr(DevCounter);
}
//---------------------------------------------------------------------------
//--- ВЫБОР УСТРОЙСТВ ИЗ СПИСКА НАЙДЕННЫХ ЧЕРЕЗ POPUP МЕНЮ ------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::Select1Click(TObject *Sender)
{ int CurrentRow;
  unsigned char *InBuf, OutBuf[1];
  AnsiString StringROM, SubStr;

  CurrentRow=StringGrid1->Row;                  // номер текущей выделенной строки
  if((CurrentRow>0)&&(StringGrid1->Cells[0][CurrentRow]!=""))
  { // копируем ROM выбранного устройства на форму
    StringROM=StringGrid1->Cells[1][CurrentRow];
    Edit3->Text=StringROM;
    // определяем тип устройства
    SubStr=StringROM.SubString(1,2);            // выделяем ROM[0] - family code
    InBuf=SubStr.c_str();
    HexToBin(InBuf,OutBuf,1);                   // преобразовать строку в целое (байт)
    SelectedChip.Modify=0;                      // выбираем чип по-умолчанию для данного семейства
    InitChip(OutBuf[0]);                        // заполняем структуру чипа, инициализируем память
    InitFormInf(OutBuf[0]);                     // инициализируем данные формы под наш чип
    InitForm(OutBuf[0]);                        // инициализируем элементы формы под наш чип
  }
  else  SendMsgToLogForm(1,"");                 // сообщение 1 (не выбрана строка с ROM)
}
//---------------------------------------------------------------------------
//--- ОТКРЫТИЕ PDF-ДОКУМЕНТА НА ЧИП -----------------------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::Chippdf1Click(TObject *Sender)
{ unsigned short ChipType;      // семейство и модификация чипа
  AnsiString FilePath;          // путь к файлу

  ChipType = SelectedChip.Family<<8 + SelectedChip.Modify;      // вычисляем код чипа
  FilePath="pdf\\";                                             // путь к файлу не определён
  switch(ChipType)
  { case 0x0001: FilePath += "RW1990.pdf";      // этой доки пока нет
                 break;
    case 0x0002: FilePath += "AN1990.pdf";
                 break;
    case 0x0003: FilePath += "TM2004.pdf";      // этой доки пока нет
                 break;
    case 0x2D00: FilePath += "DS2431.pdf";
                 break;
    case 0x2D01: FilePath += "DS28E07.pdf";
                 break;
    case 0x1400: FilePath += "DS2430A.pdf";
                 break;
    case 0x1401: FilePath += "DS1971.pdf";
                 break;
    case 0x2300: FilePath += "DS24B33.pdf";
                 break;
    case 0x2800: FilePath += "DS18B20.pdf";
                 break;
    case 0x1000: FilePath += "DS18S20.pdf";
                 break;
    case 0x1001: FilePath += "DS1920.pdf";
                 break;
    case 0x0200: FilePath += "DS1991.pdf";
                 break;
    case 0x8200: FilePath += "DS1425.pdf";
                 break;
    case 0x0800: FilePath += "DS1992-DS1993.pdf";
                 break;
    case 0x0600: FilePath += "DS1992-DS1993.pdf";
                 break;
    case 0x0A00: FilePath += "DS1995.pdf";
                 break;
    case 0x0C00: FilePath += "DS1996.pdf";
                 break;
    case 0x0500: FilePath += "DS2405.pdf";
                 break;
    case 0x2200: FilePath += "DS1822.pdf";
                 break;
    case 0x2400: FilePath += "DS2415.pdf";
                 break;
    case 0x2700: FilePath += "DS2417.pdf";
                 break;
    case 0x0400: FilePath += "DS1994.pdf";
                 break;
    case 0x0401: FilePath += "DS2404.pdf";
                 break;
    case 0x1A00: FilePath += "DS1963L.pdf";
                 break;
    case 0x1D00: FilePath += "DS2423.pdf";
                 break;
    case 0x2C00: FilePath += "DS2890.pdf";
                 break;
    case 0x3300: FilePath += "DS2432.pdf";
                 break;
    case 0x3301: FilePath += "DS1961S.pdf";
                 break;
    case 0x4300: FilePath += "DS28EC20.pdf";
                 break;
    case 0x8400: FilePath += "DS1427.pdf";
                 break;
    case 0x0D00: FilePath += "DS28E05.pdf";
                 break;
    case 0x0900: FilePath += "DS2502.pdf";
                 break;
    case 0x0901: FilePath += "DS1982.pdf";
                 break;
    case 0x3B00: FilePath += "MAX31826.pdf";
                 break;
    default:     break;
  }
  if(FilePath.Length()>5 && FileExists(FilePath))
  {     ShellExecute(Form1->Handle,"open", FilePath.c_str(),NULL,NULL,SW_SHOWNORMAL);     // открытие pdf
  }
  else
  {     ShowMessage("Documentation is not found.");
        SendMsgToLogForm(156,"");                                       // документация не найдена
  }
}
//---------------------------------------------------------------------------
//--- ВЫЧИСЛЕНИЕ CRC8 ДЛЯ ROM -----------------------------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::Button13Click(TObject *Sender)
{ char TempBuf[1], OutHexBuf[3];                // для преобразования
  unsigned char CurrentByte, CurrentBit;        // текущие передаваемый байт и бит
  unsigned char CRC8, TempByte;                 // для вычисления CRC8, временное хранилище
  AnsiString TempString;                        // временное хранилище

  GetDataToMemory(0,0);                         // получаем ROM с формы (второй параметр может быть любым)
  CRC8=0x0;                                       // инициализируем и начинаем вычислять CRC8
  // вычисляем CRC8 для младших 56 бит
  for(unsigned int i=0; i<56; i++)
  { CurrentByte=i/8; CurrentBit=i-8*CurrentByte;
    TempByte=SelectedChip.ROM[CurrentByte]>>CurrentBit; // младший бит результирующего байта используем для вычисления CRC
    CRC8=CalcCRC8(CRC8, TempByte);              // продолжаем вычислять CRC8
  }
  // дописываем вместо последнего байта нули
  for(unsigned int i=0; i<8; i++)
  { CRC8=CalcCRC8(CRC8, 0x0);                   // продолжаем вычислять CRC8
  }
  // меняем порядок бит в полученном байте
  CRC8 = (CRC8 & 0x55) << 1 | (CRC8 & 0xAA) >> 1;
  CRC8 = (CRC8 & 0x33) << 2 | (CRC8 & 0xCC) >> 2;
  CRC8 = (CRC8 & 0x0F) << 4 | (CRC8 & 0xF0) >> 4;
  // выводим полученный CRC
  TempString=Form1->Edit3->Text;                // получаем текст с формы
  TempString=TempString.SubString(1,21);        // берём всё, кроме последних двух символов
  TempBuf[0]=CRC8;                              // берём байт CRC
  BinToHex(TempBuf,OutHexBuf,1);                // преобразовать строку в целое (байт)
  OutHexBuf[2]=0;                               // строка должна заканчиваться нулём
  TempString+=UpperCase(OutHexBuf);             // переводим в верхний регистр и дописываем к ROM
  Form1->Edit3->Text=TempString;                // выводим текст на форму
}
//---------------------------------------------------------------------------
//--- РЕДАКТИРОВАНИЕ ПОЛЯ ROM -----------------------------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::Edit3KeyDown(TObject *Sender, WORD &Key,
      TShiftState Shift)
{ char *Charset1="0123456789abcdefABCDEF";      // допустимые символы
  char Symbol;                                  // символ для замены
  int Position;                                 // позиция курсора

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

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

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

  Position=Form1->Edit6->SelStart;              // позиция курсора в тексте
  switch(Key)
  { // обработчик backspace ***********************************
    case 8:     Position-=1;                            // уменьшаем позицию
                if(Position<0)       Position=2;        // если позиция <0, то переходим в конец строки
                else
                { Form1->Edit6->SelStart=Position;      // устанавливаем курсор
                  Form1->Edit6->SelLength=1;            // выделяем 1 символ
                  Symbol=0x46;                          // будем писать символ F
                  Form1->Edit6->SelText=Symbol;         // пишем
                }
                // устанавливаем курсор в нужную позицию
                Form1->Edit6->SelStart=Position;        // ставим курсор в нужную позицию
                Form1->Edit6->SelLength=0;              // отменяем выделение
                break;
    // обработчик стрелок *************************************
     case 0x25:
     case 0x26:
     case 0x27:
     case 0x28: return;
     // обработчик delete **************************************
     case 0x2E: Key=0x46;                    // заменяем на F, а дальше как все остальные вводы
     // обработчик всех остальных кнопок ***********************
     default:   if(Position>1)       Position=-1;             // если позиция >1, то переходим в начало строки
                else if(strchr(Charset1,Key))                 // если символ есть в наборе
                { Form1->Edit6->SelStart=Position;            // ставим курсор в нужную позицию
                  Form1->Edit6->SelLength=1;                  // выделяем 1 символ
                  Symbol=Key;
                  Form1->Edit6->SelText=Symbol;               // пишем туда введённый символ
                  Form1->Edit6->SelStart=Position;            // ставим курсор в нужную позицию
                  Form1->Edit6->SelLength=1;                  // выделяем 1 символ
                  Form1->Edit6->SelText=UpperCase(Form1->Edit6->SelText); // переводим введённый символ в верхний регистр
                }
                // устанавливаем курсор в нужную позицию
                Position+=1;                          // увеличиваем позицию курсора
                Form1->Edit6->SelStart=Position;      // ставим курсор в нужную позицию
                Form1->Edit6->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/46;                         // номер строки, в которой находится курсор  44 символа + CR+LF
  PositionLocal=PositionGlobal-46*LineNumber;           // позиция курсора в строке
  MaxLineNumber=(FormData.RE1Size-1)/8;                 // максимальный номер строки
  switch(Key)
  { // обработчик backspace ***********************************
    case 8:     PositionLocal-=1;                       // уменьшаем позицию в строке
                if(PositionLocal<6)
                { PositionLocal=29;                     // если позиция <6, то переходим в начало предыдущей строки
                  LineNumber-=1;
                  if(LineNumber<0)                      // если номер строки <0
                        LineNumber=MaxLineNumber;       // переходим на последнюю строку
                }
                else if(PositionLocal<29)               // если новая позиция в области hex
                { if ((PositionLocal-6)%3!=2)           // если новая позиция не перед пробелом
                  { // меняем область слева
                    Form1->RichEdit1->SelStart=LineNumber*46+PositionLocal;     // устанавливаем курсор
                    Form1->RichEdit1->SelLength=1;      // выделяем 1 символ
                    Symbol=0x46;                        // будем писать символ F
                    Form1->RichEdit1->SelText=Symbol;   // пишем
                    // получаем символ, который будем писать в область справа
                    CharPos=(PositionLocal-6)/3;        // номер байта в строке, который нужно поменять
                    Form1->RichEdit1->SelStart=46*LineNumber+6+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*46+36+CharPos;        // устанавливаем курсор
                    Form1->RichEdit1->SelLength=1;      // выделяем 1 символ
                    Form1->RichEdit1->SelText=Symbol;   // пишем туда полученный символ
                  }
                }
                else if(PositionLocal<36)               // если мы между правой и левой областями
                { PositionLocal=44;                     // если позиция <36, то переходим в начало предыдущей строки
                  LineNumber-=1;
                  if(LineNumber<0)                      // если номер строки <0
                        LineNumber=MaxLineNumber;       // переходим на последнюю строку
                }
                else                                    // если мы в области справа
                { // меняем область справа
                  Form1->RichEdit1->SelStart=LineNumber*46+PositionLocal;       // устанавливаем курсор
                  Form1->RichEdit1->SelLength=1;        // выделяем 1 символ
                  Symbol=0xFF;                          // будем писать символ я
                  Form1->RichEdit1->SelText=Symbol;     // пишем
                  // получаем символ, который будем менять
                  CharPos=PositionLocal-36;             // номер байта в строке, который нужно поменять
                  // меняем область слева
                  Form1->RichEdit1->SelStart=LineNumber*46+6+3*CharPos;         // устанавливаем курсор
                  Form1->RichEdit1->SelLength=2;        // выделяем 2 символа
                  Form1->RichEdit1->SelText="FF";       // пишем
                }
                // устанавливаем курсор в нужную позицию
                Form1->RichEdit1->SelStart=LineNumber*46+PositionLocal;         // ставим курсор в нужную позицию
                Form1->RichEdit1->SelLength=0;                                  // отменяем выделение
                break;
    // обработчик стрелок *************************************
     case 0x25:
     case 0x26:
     case 0x27:
     case 0x28: return;
     // обработчик delete **************************************
     case 0x2E: // если мы в области слева - заменяем на F
                if((PositionLocal>5) && (PositionLocal<29))
                {       Key=0x46;                    // заменяем символ слева на F
                }
                // если мы в области справа - заменяем на я
                if(PositionLocal>35)
                {       Key=0xFF;                    // заменяем символ справа на F
                }

     // обработчик всех остальных кнопок ***********************
     default:   if(PositionLocal>43)            // если позиция > 43
                { PositionLocal=35;             // то переходим в начало строки
                  LineNumber+=1;                // увеличиваем номер строки
                  if(LineNumber>MaxLineNumber)
                        LineNumber=0;           // если номер > максимального - переходим на первую строку
                }
                else if(PositionLocal>35)       // если позиция > 35
                { // меняем область справа
                  Form1->RichEdit1->SelStart=LineNumber*46+PositionLocal;       // ставим курсор в нужную позицию
                  Form1->RichEdit1->SelLength=1;                                // выделяем 1 символ
                  if(Key<0x1F)  Key=0x1F;                                       // если символ непечатный (спецсимвол) - заменяем
                  Symbol=Key;
                  Form1->RichEdit1->SelText=Symbol;                             // пишем туда введённый символ
                  Form1->RichEdit1->SelStart=LineNumber*46+PositionLocal;       // ставим курсор в нужную позицию
                  Form1->RichEdit1->SelLength=1;                                // выделяем 1 символ
                  Form1->RichEdit1->SelText=UpperCase(Form1->RichEdit1->SelText); // переводим введённый символ в верхний регистр
                  // получаем символ, который будем менять
                  CharPos=PositionLocal-36;             // номер байта в строке, который нужно поменять
                  TempBuf[0]=Key;
                  BinToHex(TempBuf,OutHexBuf,1);        //преобразовать строку в целое (байт)
                  OutHexBuf[2]=0;                       //строка должна заканчиваться нулём
                  // меняем область слева
                  Form1->RichEdit1->SelStart=LineNumber*46+6+3*CharPos;         // ставим курсор на начало байт
                  Form1->RichEdit1->SelLength=2;                                // выделяем 2 символа
                  Form1->RichEdit1->SelText=OutHexBuf;
                }
                else if(PositionLocal>28)       // если позиция >28,
                { PositionLocal=5;              // то переходим в начало строки
                  LineNumber+=1;                // увеличиваем номер строки
                  if(LineNumber>MaxLineNumber)
                        LineNumber=0;           // если номер > максимального - переходим на первую строку
                }
                else if(PositionLocal>5)        // если позиция > 5
                { if(strchr(Charset1,Key)&&((PositionLocal-6)%3!=2))            // если символ есть в наборе и позиция не перед пробелом
                  { // меняем область слева
                    Form1->RichEdit1->SelStart=LineNumber*46+PositionLocal;     // ставим курсор в нужную позицию
                    Form1->RichEdit1->SelLength=1;                              // выделяем 1 символ
                    Symbol=Key;
                    Form1->RichEdit1->SelText=Symbol;                           // пишем туда введённый символ
                    Form1->RichEdit1->SelStart=LineNumber*46+PositionLocal;     // ставим курсор в нужную позицию
                    Form1->RichEdit1->SelLength=1;                              // выделяем 1 символ
                    Form1->RichEdit1->SelText=UpperCase(Form1->RichEdit1->SelText);     // переводим введённый символ в верхний регистр
                    // получаем символ, который будем писать в область справа
                    CharPos=(PositionLocal-6)/3;        // номер байта в строке, который нужно поменять
                    Form1->RichEdit1->SelStart=46*LineNumber+6+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*46+36+CharPos;        // устанавливаем курсор
                    Form1->RichEdit1->SelLength=1;      // выделяем 1 символ
                    Form1->RichEdit1->SelText=Symbol;   // пишем туда полученный символ
                  }
                }
                else    PositionLocal=5;        // переходим в начало строки
                // устанавливаем курсор в нужную позицию
                PositionLocal+=1;                                       // увеличиваем позицию курсора
                Form1->RichEdit1->SelStart=LineNumber*46+PositionLocal; // ставим курсор в нужную позицию
                Form1->RichEdit1->SelLength=0;                          // отменяем выделение
  }
  Key=0;
}
//---------------------------------------------------------------------------
void __fastcall TForm1::RichEditsKeyPress(TObject *Sender, char &Key)
{ Key=0;
}
//---------------------------------------------------------------------------
//--- РЕДАКТИРОВАНИЕ ПОЛЯ RICHEDIT2 (Area 1) --------------------------------
//---------------------------------------------------------------------------
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/46;                         // номер строки, в которой находится курсор  44 символа + CR+LF
  PositionLocal=PositionGlobal-46*LineNumber;           // позиция курсора в строке
  MaxLineNumber=(FormData.RE2Size-1)/8;           // максимальный номер строки
  switch(Key)
  { // обработчик backspace ***********************************
    case 8:     PositionLocal-=1;                       // уменьшаем позицию в строке
                if(PositionLocal<6)
                { PositionLocal=29;                     // если позиция <6, то переходим в начало предыдущей строки
                  LineNumber-=1;
                  if(LineNumber<0)                      // если номер строки <0
                        LineNumber=MaxLineNumber;       // переходим на последнюю строку
                }
                else if(PositionLocal<29)               // если новая позиция в области hex
                { if ((PositionLocal-6)%3!=2)           // если новая позиция не перед пробелом
                  { // меняем область слева
                    Form1->RichEdit2->SelStart=LineNumber*46+PositionLocal;     // устанавливаем курсор
                    Form1->RichEdit2->SelLength=1;      // выделяем 1 символ
                    Symbol=0x46;                        // будем писать символ F
                    Form1->RichEdit2->SelText=Symbol;   // пишем
                    // получаем символ, который будем писать в область справа
                    CharPos=(PositionLocal-6)/3;        // номер байта в строке, который нужно поменять
                    Form1->RichEdit2->SelStart=46*LineNumber+6+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*46+36+CharPos;        // устанавливаем курсор
                    Form1->RichEdit2->SelLength=1;      // выделяем 1 символ
                    Form1->RichEdit2->SelText=Symbol;   // пишем туда полученный символ
                  }
                }
                else if(PositionLocal<36)               // если мы между правой и левой областями
                { PositionLocal=44;                     // если позиция <36, то переходим в начало предыдущей строки
                  LineNumber-=1;
                  if(LineNumber<0)                      // если номер строки <0
                        LineNumber=MaxLineNumber;       // переходим на последнюю строку
                }
                else                                    // если мы в области справа
                { // меняем область справа
                  Form1->RichEdit2->SelStart=LineNumber*46+PositionLocal;       // устанавливаем курсор
                  Form1->RichEdit2->SelLength=1;        // выделяем 1 символ
                  Symbol=0xFF;                          // будем писать символ я
                  Form1->RichEdit2->SelText=Symbol;     // пишем
                  // получаем символ, который будем менять
                  CharPos=PositionLocal-36;             // номер байта в строке, который нужно поменять
                  // меняем область слева
                  Form1->RichEdit2->SelStart=LineNumber*46+6+3*CharPos;         // устанавливаем курсор
                  Form1->RichEdit2->SelLength=2;        // выделяем 2 символа
                  Form1->RichEdit2->SelText="FF";       // пишем
                }
                // устанавливаем курсор в нужную позицию
                Form1->RichEdit2->SelStart=LineNumber*46+PositionLocal;         // ставим курсор в нужную позицию
                Form1->RichEdit2->SelLength=0;                                  // отменяем выделение
                break;
    // обработчик стрелок *************************************
     case 0x25:
     case 0x26:
     case 0x27:
     case 0x28: return;
     // обработчик delete **************************************
     case 0x2E: // если мы в области слева - заменяем на F
                if((PositionLocal>5) && (PositionLocal<29))
                {       Key=0x46;                    // заменяем символ слева на F
                }
                // если мы в области справа - заменяем на я
                if(PositionLocal>35)
                {       Key=0xFF;                    // заменяем символ справа на F
                }

     // обработчик всех остальных кнопок ***********************
     default:   if(PositionLocal>43)            // если позиция > 43
                { PositionLocal=35;             // то переходим в начало строки
                  LineNumber+=1;                // увеличиваем номер строки
                  if(LineNumber>MaxLineNumber)
                        LineNumber=0;           // если номер > максимального - переходим на первую строку
                }
                else if(PositionLocal>35)       // если позиция > 35
                { // меняем область справа
                  Form1->RichEdit2->SelStart=LineNumber*46+PositionLocal;       // ставим курсор в нужную позицию
                  Form1->RichEdit2->SelLength=1;                                // выделяем 1 символ
                  if(Key<0x1F)  Key=0x1F;                                       // если символ непечатный (спецсимвол) - заменяем
                  Symbol=Key;
                  Form1->RichEdit2->SelText=Symbol;                             // пишем туда введённый символ
                  Form1->RichEdit2->SelStart=LineNumber*46+PositionLocal;       // ставим курсор в нужную позицию
                  Form1->RichEdit2->SelLength=1;                                // выделяем 1 символ
                  Form1->RichEdit2->SelText=UpperCase(Form1->RichEdit2->SelText); // переводим введённый символ в верхний регистр
                  // получаем символ, который будем менять
                  CharPos=PositionLocal-36;             // номер байта в строке, который нужно поменять
                  TempBuf[0]=Key;
                  BinToHex(TempBuf,OutHexBuf,1);        //преобразовать строку в целое (байт)
                  OutHexBuf[2]=0;                       //строка должна заканчиваться нулём
                  // меняем область слева
                  Form1->RichEdit2->SelStart=LineNumber*46+6+3*CharPos;         // ставим курсор на начало байт
                  Form1->RichEdit2->SelLength=2;                                // выделяем 2 символа
                  Form1->RichEdit2->SelText=OutHexBuf;
                }
                else if(PositionLocal>28)       // если позиция >28,
                { PositionLocal=5;              // то переходим в начало строки
                  LineNumber+=1;                // увеличиваем номер строки
                  if(LineNumber>MaxLineNumber)
                        LineNumber=0;           // если номер > максимального - переходим на первую строку
                }
                else if(PositionLocal>5)        // если позиция > 5
                { if(strchr(Charset1,Key)&&((PositionLocal-6)%3!=2))            // если символ есть в наборе и позиция не перед пробелом
                  { // меняем область слева
                    Form1->RichEdit2->SelStart=LineNumber*46+PositionLocal;     // ставим курсор в нужную позицию
                    Form1->RichEdit2->SelLength=1;                              // выделяем 1 символ
                    Symbol=Key;
                    Form1->RichEdit2->SelText=Symbol;                           // пишем туда введённый символ
                    Form1->RichEdit2->SelStart=LineNumber*46+PositionLocal;     // ставим курсор в нужную позицию
                    Form1->RichEdit2->SelLength=1;                              // выделяем 1 символ
                    Form1->RichEdit2->SelText=UpperCase(Form1->RichEdit2->SelText);     // переводим введённый символ в верхний регистр
                    // получаем символ, который будем писать в область справа
                    CharPos=(PositionLocal-6)/3;        // номер байта в строке, который нужно поменять
                    Form1->RichEdit2->SelStart=46*LineNumber+6+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*46+36+CharPos;        // устанавливаем курсор
                    Form1->RichEdit2->SelLength=1;      // выделяем 1 символ
                    Form1->RichEdit2->SelText=Symbol;   // пишем туда полученный символ
                  }
                }
                else    PositionLocal=5;        // переходим в начало строки
                // устанавливаем курсор в нужную позицию
                PositionLocal+=1;                                       // увеличиваем позицию курсора
                Form1->RichEdit2->SelStart=LineNumber*46+PositionLocal; // ставим курсор в нужную позицию
                Form1->RichEdit2->SelLength=0;                          // отменяем выделение
  }
  Key=0;
}
//---------------------------------------------------------------------------
//--- РЕДАКТИРОВАНИЕ ПОЛЯ RICHEDIT3 (Area 2) --------------------------------
//---------------------------------------------------------------------------
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/46;                         // номер строки, в которой находится курсор  44 символа + CR+LF
  PositionLocal=PositionGlobal-46*LineNumber;           // позиция курсора в строке
  MaxLineNumber=(FormData.RE3Size-1)/8;           // максимальный номер строки
  switch(Key)
  { // обработчик backspace ***********************************
    case 8:     PositionLocal-=1;                       // уменьшаем позицию в строке
                if(PositionLocal<6)
                { PositionLocal=29;                     // если позиция <6, то переходим в начало предыдущей строки
                  LineNumber-=1;
                  if(LineNumber<0)                      // если номер строки <0
                        LineNumber=MaxLineNumber;       // переходим на последнюю строку
                }
                else if(PositionLocal<29)               // если новая позиция в области hex
                { if ((PositionLocal-6)%3!=2)           // если новая позиция не перед пробелом
                  { // меняем область слева
                    Form1->RichEdit3->SelStart=LineNumber*46+PositionLocal;     // устанавливаем курсор
                    Form1->RichEdit3->SelLength=1;      // выделяем 1 символ
                    Symbol=0x46;                        // будем писать символ F
                    Form1->RichEdit3->SelText=Symbol;   // пишем
                    // получаем символ, который будем писать в область справа
                    CharPos=(PositionLocal-6)/3;        // номер байта в строке, который нужно поменять
                    Form1->RichEdit3->SelStart=46*LineNumber+6+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*46+36+CharPos;        // устанавливаем курсор
                    Form1->RichEdit3->SelLength=1;      // выделяем 1 символ
                    Form1->RichEdit3->SelText=Symbol;   // пишем туда полученный символ
                  }
                }
                else if(PositionLocal<36)               // если мы между правой и левой областями
                { PositionLocal=44;                     // если позиция <36, то переходим в начало предыдущей строки
                  LineNumber-=1;
                  if(LineNumber<0)                      // если номер строки <0
                        LineNumber=MaxLineNumber;       // переходим на последнюю строку
                }
                else                                    // если мы в области справа
                { // меняем область справа
                  Form1->RichEdit3->SelStart=LineNumber*46+PositionLocal;       // устанавливаем курсор
                  Form1->RichEdit3->SelLength=1;        // выделяем 1 символ
                  Symbol=0xFF;                          // будем писать символ я
                  Form1->RichEdit3->SelText=Symbol;     // пишем
                  // получаем символ, который будем менять
                  CharPos=PositionLocal-36;             // номер байта в строке, который нужно поменять
                  // меняем область слева
                  Form1->RichEdit3->SelStart=LineNumber*46+6+3*CharPos;         // устанавливаем курсор
                  Form1->RichEdit3->SelLength=2;        // выделяем 2 символа
                  Form1->RichEdit3->SelText="FF";       // пишем
                }
                // устанавливаем курсор в нужную позицию
                Form1->RichEdit3->SelStart=LineNumber*46+PositionLocal;         // ставим курсор в нужную позицию
                Form1->RichEdit3->SelLength=0;                                  // отменяем выделение
                break;
    // обработчик стрелок *************************************
     case 0x25:
     case 0x26:
     case 0x27:
     case 0x28: return;
     // обработчик delete **************************************
     case 0x2E: // если мы в области слева - заменяем на F
                if((PositionLocal>5) && (PositionLocal<29))
                {       Key=0x46;                    // заменяем символ слева на F
                }
                // если мы в области справа - заменяем на я
                if(PositionLocal>35)
                {       Key=0xFF;                    // заменяем символ справа на F
                }

     // обработчик всех остальных кнопок ***********************
     default:   if(PositionLocal>43)            // если позиция > 43
                { PositionLocal=35;             // то переходим в начало строки
                  LineNumber+=1;                // увеличиваем номер строки
                  if(LineNumber>MaxLineNumber)
                        LineNumber=0;           // если номер > максимального - переходим на первую строку
                }
                else if(PositionLocal>35)       // если позиция > 35
                { // меняем область справа
                  Form1->RichEdit3->SelStart=LineNumber*46+PositionLocal;       // ставим курсор в нужную позицию
                  Form1->RichEdit3->SelLength=1;                                // выделяем 1 символ
                  if(Key<0x1F)  Key=0x1F;                                       // если символ непечатный (спецсимвол) - заменяем
                  Symbol=Key;
                  Form1->RichEdit3->SelText=Symbol;                             // пишем туда введённый символ
                  Form1->RichEdit3->SelStart=LineNumber*46+PositionLocal;       // ставим курсор в нужную позицию
                  Form1->RichEdit3->SelLength=1;                                // выделяем 1 символ
                  Form1->RichEdit3->SelText=UpperCase(Form1->RichEdit3->SelText); // переводим введённый символ в верхний регистр
                  // получаем символ, который будем менять
                  CharPos=PositionLocal-36;             // номер байта в строке, который нужно поменять
                  TempBuf[0]=Key;
                  BinToHex(TempBuf,OutHexBuf,1);        //преобразовать строку в целое (байт)
                  OutHexBuf[2]=0;                       //строка должна заканчиваться нулём
                  // меняем область слева
                  Form1->RichEdit3->SelStart=LineNumber*46+6+3*CharPos;         // ставим курсор на начало байт
                  Form1->RichEdit3->SelLength=2;                                // выделяем 2 символа
                  Form1->RichEdit3->SelText=OutHexBuf;
                }
                else if(PositionLocal>28)       // если позиция >28,
                { PositionLocal=5;              // то переходим в начало строки
                  LineNumber+=1;                // увеличиваем номер строки
                  if(LineNumber>MaxLineNumber)
                        LineNumber=0;           // если номер > максимального - переходим на первую строку
                }
                else if(PositionLocal>5)        // если позиция > 5
                { if(strchr(Charset1,Key)&&((PositionLocal-6)%3!=2))            // если символ есть в наборе и позиция не перед пробелом
                  { // меняем область слева
                    Form1->RichEdit3->SelStart=LineNumber*46+PositionLocal;     // ставим курсор в нужную позицию
                    Form1->RichEdit3->SelLength=1;                              // выделяем 1 символ
                    Symbol=Key;
                    Form1->RichEdit3->SelText=Symbol;                           // пишем туда введённый символ
                    Form1->RichEdit3->SelStart=LineNumber*46+PositionLocal;     // ставим курсор в нужную позицию
                    Form1->RichEdit3->SelLength=1;                              // выделяем 1 символ
                    Form1->RichEdit3->SelText=UpperCase(Form1->RichEdit3->SelText);     // переводим введённый символ в верхний регистр
                    // получаем символ, который будем писать в область справа
                    CharPos=(PositionLocal-6)/3;        // номер байта в строке, который нужно поменять
                    Form1->RichEdit3->SelStart=46*LineNumber+6+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*46+36+CharPos;        // устанавливаем курсор
                    Form1->RichEdit3->SelLength=1;      // выделяем 1 символ
                    Form1->RichEdit3->SelText=Symbol;   // пишем туда полученный символ
                  }
                }
                else    PositionLocal=5;        // переходим в начало строки
                // устанавливаем курсор в нужную позицию
                PositionLocal+=1;                                       // увеличиваем позицию курсора
                Form1->RichEdit3->SelStart=LineNumber*46+PositionLocal; // ставим курсор в нужную позицию
                Form1->RichEdit3->SelLength=0;                          // отменяем выделение
  }
  Key=0;
}
//---------------------------------------------------------------------------
//--- РЕДАКТИРОВАНИЕ ПОЛЯ RICHEDIT4 (Area 2) --------------------------------
//---------------------------------------------------------------------------
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/46;                         // номер строки, в которой находится курсор  44 символа + CR+LF
  PositionLocal=PositionGlobal-46*LineNumber;           // позиция курсора в строке
  MaxLineNumber=(FormData.RE4Size-1)/8;           // максимальный номер строки
  switch(Key)
  { // обработчик backspace ***********************************
    case 8:     PositionLocal-=1;                       // уменьшаем позицию в строке
                if(PositionLocal<6)
                { PositionLocal=29;                     // если позиция <6, то переходим в начало предыдущей строки
                  LineNumber-=1;
                  if(LineNumber<0)                      // если номер строки <0
                        LineNumber=MaxLineNumber;       // переходим на последнюю строку
                }
                else if(PositionLocal<29)               // если новая позиция в области hex
                { if ((PositionLocal-6)%3!=2)           // если новая позиция не перед пробелом
                  { // меняем область слева
                    Form1->RichEdit4->SelStart=LineNumber*46+PositionLocal;     // устанавливаем курсор
                    Form1->RichEdit4->SelLength=1;      // выделяем 1 символ
                    Symbol=0x46;                        // будем писать символ F
                    Form1->RichEdit4->SelText=Symbol;   // пишем
                    // получаем символ, который будем писать в область справа
                    CharPos=(PositionLocal-6)/3;        // номер байта в строке, который нужно поменять
                    Form1->RichEdit4->SelStart=46*LineNumber+6+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*46+36+CharPos;        // устанавливаем курсор
                    Form1->RichEdit4->SelLength=1;      // выделяем 1 символ
                    Form1->RichEdit4->SelText=Symbol;   // пишем туда полученный символ
                  }
                }
                else if(PositionLocal<36)               // если мы между правой и левой областями
                { PositionLocal=44;                     // если позиция <36, то переходим в начало предыдущей строки
                  LineNumber-=1;
                  if(LineNumber<0)                      // если номер строки <0
                        LineNumber=MaxLineNumber;       // переходим на последнюю строку
                }
                else                                    // если мы в области справа
                { // меняем область справа
                  Form1->RichEdit4->SelStart=LineNumber*46+PositionLocal;       // устанавливаем курсор
                  Form1->RichEdit4->SelLength=1;        // выделяем 1 символ
                  Symbol=0xFF;                          // будем писать символ я
                  Form1->RichEdit4->SelText=Symbol;     // пишем
                  // получаем символ, который будем менять
                  CharPos=PositionLocal-36;             // номер байта в строке, который нужно поменять
                  // меняем область слева
                  Form1->RichEdit4->SelStart=LineNumber*46+6+3*CharPos;         // устанавливаем курсор
                  Form1->RichEdit4->SelLength=2;        // выделяем 2 символа
                  Form1->RichEdit4->SelText="FF";       // пишем
                }
                // устанавливаем курсор в нужную позицию
                Form1->RichEdit4->SelStart=LineNumber*46+PositionLocal;         // ставим курсор в нужную позицию
                Form1->RichEdit4->SelLength=0;                                  // отменяем выделение
                break;
    // обработчик стрелок *************************************
     case 0x25:
     case 0x26:
     case 0x27:
     case 0x28: return;
     // обработчик delete **************************************
     case 0x2E: // если мы в области слева - заменяем на F
                if((PositionLocal>5) && (PositionLocal<29))
                {       Key=0x46;                    // заменяем символ слева на F
                }
                // если мы в области справа - заменяем на я
                if(PositionLocal>35)
                {       Key=0xFF;                    // заменяем символ справа на F
                }

     // обработчик всех остальных кнопок ***********************
     default:   if(PositionLocal>43)            // если позиция > 43
                { PositionLocal=35;             // то переходим в начало строки
                  LineNumber+=1;                // увеличиваем номер строки
                  if(LineNumber>MaxLineNumber)
                        LineNumber=0;           // если номер > максимального - переходим на первую строку
                }
                else if(PositionLocal>35)       // если позиция > 35
                { // меняем область справа
                  Form1->RichEdit4->SelStart=LineNumber*46+PositionLocal;       // ставим курсор в нужную позицию
                  Form1->RichEdit4->SelLength=1;                                // выделяем 1 символ
                  if(Key<0x1F)  Key=0x1F;                                       // если символ непечатный (спецсимвол) - заменяем
                  Symbol=Key;
                  Form1->RichEdit4->SelText=Symbol;                             // пишем туда введённый символ
                  Form1->RichEdit4->SelStart=LineNumber*46+PositionLocal;       // ставим курсор в нужную позицию
                  Form1->RichEdit4->SelLength=1;                                // выделяем 1 символ
                  Form1->RichEdit4->SelText=UpperCase(Form1->RichEdit4->SelText); // переводим введённый символ в верхний регистр
                  // получаем символ, который будем менять
                  CharPos=PositionLocal-36;             // номер байта в строке, который нужно поменять
                  TempBuf[0]=Key;
                  BinToHex(TempBuf,OutHexBuf,1);        //преобразовать строку в целое (байт)
                  OutHexBuf[2]=0;                       //строка должна заканчиваться нулём
                  // меняем область слева
                  Form1->RichEdit4->SelStart=LineNumber*46+6+3*CharPos;         // ставим курсор на начало байт
                  Form1->RichEdit4->SelLength=2;                                // выделяем 2 символа
                  Form1->RichEdit4->SelText=OutHexBuf;
                }
                else if(PositionLocal>28)       // если позиция >28,
                { PositionLocal=5;              // то переходим в начало строки
                  LineNumber+=1;                // увеличиваем номер строки
                  if(LineNumber>MaxLineNumber)
                        LineNumber=0;           // если номер > максимального - переходим на первую строку
                }
                else if(PositionLocal>5)        // если позиция > 5
                { if(strchr(Charset1,Key)&&((PositionLocal-6)%3!=2))            // если символ есть в наборе и позиция не перед пробелом
                  { // меняем область слева
                    Form1->RichEdit4->SelStart=LineNumber*46+PositionLocal;     // ставим курсор в нужную позицию
                    Form1->RichEdit4->SelLength=1;                              // выделяем 1 символ
                    Symbol=Key;
                    Form1->RichEdit4->SelText=Symbol;                           // пишем туда введённый символ
                    Form1->RichEdit4->SelStart=LineNumber*46+PositionLocal;     // ставим курсор в нужную позицию
                    Form1->RichEdit4->SelLength=1;                              // выделяем 1 символ
                    Form1->RichEdit4->SelText=UpperCase(Form1->RichEdit4->SelText);     // переводим введённый символ в верхний регистр
                    // получаем символ, который будем писать в область справа
                    CharPos=(PositionLocal-6)/3;        // номер байта в строке, который нужно поменять
                    Form1->RichEdit4->SelStart=46*LineNumber+6+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*46+36+CharPos;        // устанавливаем курсор
                    Form1->RichEdit4->SelLength=1;      // выделяем 1 символ
                    Form1->RichEdit4->SelText=Symbol;   // пишем туда полученный символ
                  }
                }
                else    PositionLocal=5;        // переходим в начало строки
                // устанавливаем курсор в нужную позицию
                PositionLocal+=1;                                       // увеличиваем позицию курсора
                Form1->RichEdit4->SelStart=LineNumber*46+PositionLocal; // ставим курсор в нужную позицию
                Form1->RichEdit4->SelLength=0;                          // отменяем выделение
  }
  Key=0;
}
//---------------------------------------------------------------------------
//--- РЕДАКТИРОВАНИЕ ПОЛЯ RICHEDIT5 (Area 3) --------------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::RichEdit5KeyDown(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->RichEdit5->SelStart;            // глобальная позиция курсора в тексте
  LineNumber=PositionGlobal/46;                         // номер строки, в которой находится курсор  44 символа + CR+LF
  PositionLocal=PositionGlobal-46*LineNumber;           // позиция курсора в строке
  MaxLineNumber=(FormData.RE5Size-1)/8;      // максимальный номер строки
  switch(Key)
  { // обработчик backspace ***********************************
    case 8:     PositionLocal-=1;                       // уменьшаем позицию в строке
                if(PositionLocal<6)
                { PositionLocal=29;                     // если позиция <6, то переходим в начало предыдущей строки
                  LineNumber-=1;
                  if(LineNumber<0)                      // если номер строки <0
                        LineNumber=MaxLineNumber;       // переходим на последнюю строку
                }
                else if(PositionLocal<29)               // если новая позиция в области hex
                { if ((PositionLocal-6)%3!=2)           // если новая позиция не перед пробелом
                  { // меняем область слева
                    Form1->RichEdit5->SelStart=LineNumber*46+PositionLocal;     // устанавливаем курсор
                    Form1->RichEdit5->SelLength=1;      // выделяем 1 символ
                    Symbol=0x46;                        // будем писать символ F
                    Form1->RichEdit5->SelText=Symbol;   // пишем
                    // получаем символ, который будем писать в область справа
                    CharPos=(PositionLocal-6)/3;        // номер байта в строке, который нужно поменять
                    Form1->RichEdit5->SelStart=46*LineNumber+6+3*CharPos;       // ставим курсор на начало байта (в области слева)
                    Form1->RichEdit5->SelLength=2;                              // выделяем 2 символа
                    SubStr=LowerCase(Form1->RichEdit5->SelText);                // получаем их в строку
                    InHexBuf=SubStr.c_str();           //скопировать в буфер байт для передачи (в виде строки)
                    HexToBin(InHexBuf,TempBuf,1);       //преобразовать строку в целое (байт)
                    Key=TempBuf[0];
                    if(Key<0x1F) Symbol=0x1F;           //заменяем непечатные
                    else         Symbol=TempBuf[0];
                    // меняем область справа
                    Form1->RichEdit5->SelStart=LineNumber*46+36+CharPos;        // устанавливаем курсор
                    Form1->RichEdit5->SelLength=1;      // выделяем 1 символ
                    Form1->RichEdit5->SelText=Symbol;   // пишем туда полученный символ
                  }
                }
                else if(PositionLocal<36)               // если мы между правой и левой областями
                { PositionLocal=44;                     // если позиция <36, то переходим в начало предыдущей строки
                  LineNumber-=1;
                  if(LineNumber<0)                      // если номер строки <0
                        LineNumber=MaxLineNumber;       // переходим на последнюю строку
                }
                else                                    // если мы в области справа
                { // меняем область справа
                  Form1->RichEdit5->SelStart=LineNumber*46+PositionLocal;       // устанавливаем курсор
                  Form1->RichEdit5->SelLength=1;        // выделяем 1 символ
                  Symbol=0xFF;                          // будем писать символ я
                  Form1->RichEdit5->SelText=Symbol;     // пишем
                  // получаем символ, который будем менять
                  CharPos=PositionLocal-36;             // номер байта в строке, который нужно поменять
                  // меняем область слева
                  Form1->RichEdit5->SelStart=LineNumber*46+6+3*CharPos;         // устанавливаем курсор
                  Form1->RichEdit5->SelLength=2;        // выделяем 2 символа
                  Form1->RichEdit5->SelText="FF";       // пишем
                }
                // устанавливаем курсор в нужную позицию
                Form1->RichEdit5->SelStart=LineNumber*46+PositionLocal;         // ставим курсор в нужную позицию
                Form1->RichEdit5->SelLength=0;                                  // отменяем выделение
                break;
    // обработчик стрелок *************************************
     case 0x25:
     case 0x26:
     case 0x27:
     case 0x28: return;
     // обработчик delete **************************************
     case 0x2E: // если мы в области слева - заменяем на F
                if((PositionLocal>5) && (PositionLocal<29))
                {       Key=0x46;                    // заменяем символ слева на F
                }
                // если мы в области справа - заменяем на я
                if(PositionLocal>35)
                {       Key=0xFF;                    // заменяем символ справа на F
                }

     // обработчик всех остальных кнопок ***********************
     default:   if(PositionLocal>43)            // если позиция > 43
                { PositionLocal=35;             // то переходим в начало строки
                  LineNumber+=1;                // увеличиваем номер строки
                  if(LineNumber>MaxLineNumber)
                        LineNumber=0;           // если номер > максимального - переходим на первую строку
                }
                else if(PositionLocal>35)       // если позиция > 35
                { // меняем область справа
                  Form1->RichEdit5->SelStart=LineNumber*46+PositionLocal;       // ставим курсор в нужную позицию
                  Form1->RichEdit5->SelLength=1;                                // выделяем 1 символ
                  if(Key<0x1F)  Key=0x1F;                                       // если символ непечатный (спецсимвол) - заменяем
                  Symbol=Key;
                  Form1->RichEdit5->SelText=Symbol;                             // пишем туда введённый символ
                  Form1->RichEdit5->SelStart=LineNumber*46+PositionLocal;       // ставим курсор в нужную позицию
                  Form1->RichEdit5->SelLength=1;                                // выделяем 1 символ
                  Form1->RichEdit5->SelText=UpperCase(Form1->RichEdit5->SelText); // переводим введённый символ в верхний регистр
                  // получаем символ, который будем менять
                  CharPos=PositionLocal-36;             // номер байта в строке, который нужно поменять
                  TempBuf[0]=Key;
                  BinToHex(TempBuf,OutHexBuf,1);        //преобразовать строку в целое (байт)
                  OutHexBuf[2]=0;                       //строка должна заканчиваться нулём
                  // меняем область слева
                  Form1->RichEdit5->SelStart=LineNumber*46+6+3*CharPos;         // ставим курсор на начало байт
                  Form1->RichEdit5->SelLength=2;                                // выделяем 2 символа
                  Form1->RichEdit5->SelText=OutHexBuf;
                }
                else if(PositionLocal>28)       // если позиция >28,
                { PositionLocal=5;              // то переходим в начало строки
                  LineNumber+=1;                // увеличиваем номер строки
                  if(LineNumber>MaxLineNumber)
                        LineNumber=0;           // если номер > максимального - переходим на первую строку
                }
                else if(PositionLocal>5)        // если позиция > 5
                { if(strchr(Charset1,Key)&&((PositionLocal-6)%3!=2))            // если символ есть в наборе и позиция не перед пробелом
                  { // меняем область слева
                    Form1->RichEdit5->SelStart=LineNumber*46+PositionLocal;     // ставим курсор в нужную позицию
                    Form1->RichEdit5->SelLength=1;                              // выделяем 1 символ
                    Symbol=Key;
                    Form1->RichEdit5->SelText=Symbol;                           // пишем туда введённый символ
                    Form1->RichEdit5->SelStart=LineNumber*46+PositionLocal;     // ставим курсор в нужную позицию
                    Form1->RichEdit5->SelLength=1;                              // выделяем 1 символ
                    Form1->RichEdit5->SelText=UpperCase(Form1->RichEdit5->SelText);     // переводим введённый символ в верхний регистр
                    // получаем символ, который будем писать в область справа
                    CharPos=(PositionLocal-6)/3;        // номер байта в строке, который нужно поменять
                    Form1->RichEdit5->SelStart=46*LineNumber+6+3*CharPos;       // ставим курсор на начало байта (в области слева)
                    Form1->RichEdit5->SelLength=2;                              // выделяем 2 символа
                    SubStr=LowerCase(Form1->RichEdit5->SelText);                // получаем их в строку
                    InHexBuf=SubStr.c_str();            //скопировать в буфер байт для передачи (в виде строки)
                    HexToBin(InHexBuf,TempBuf,1);       //преобразовать строку в целое (байт)
                    Key=TempBuf[0];
                    if(Key<0x1F) Symbol=0x1F;           //заменяем непечатные
                    else         Symbol=TempBuf[0];
                    // меняем область справа
                    Form1->RichEdit5->SelStart=LineNumber*46+36+CharPos;        // устанавливаем курсор
                    Form1->RichEdit5->SelLength=1;      // выделяем 1 символ
                    Form1->RichEdit5->SelText=Symbol;   // пишем туда полученный символ
                  }
                }
                else    PositionLocal=5;        // переходим в начало строки
                // устанавливаем курсор в нужную позицию
                PositionLocal+=1;                                       // увеличиваем позицию курсора
                Form1->RichEdit5->SelStart=LineNumber*46+PositionLocal; // ставим курсор в нужную позицию
                Form1->RichEdit5->SelLength=0;                          // отменяем выделение
  }
  Key=0;
}
//---------------------------------------------------------------------------
//--- РЕДАКТИРОВАНИЕ ПОЛЯ RICHEDIT6 (Area 3) --------------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::RichEdit6KeyDown(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->RichEdit6->SelStart;            // глобальная позиция курсора в тексте
  LineNumber=PositionGlobal/46;                         // номер строки, в которой находится курсор  44 символа + CR+LF
  PositionLocal=PositionGlobal-46*LineNumber;           // позиция курсора в строке
  MaxLineNumber=(FormData.RE6Size-1)/8;           // максимальный номер строки
  switch(Key)
  { // обработчик backspace ***********************************
    case 8:     PositionLocal-=1;                       // уменьшаем позицию в строке
                if(PositionLocal<6)
                { PositionLocal=29;                     // если позиция <6, то переходим в начало предыдущей строки
                  LineNumber-=1;
                  if(LineNumber<0)                      // если номер строки <0
                        LineNumber=MaxLineNumber;       // переходим на последнюю строку
                }
                else if(PositionLocal<29)               // если новая позиция в области hex
                { if ((PositionLocal-6)%3!=2)           // если новая позиция не перед пробелом
                  { // меняем область слева
                    Form1->RichEdit6->SelStart=LineNumber*46+PositionLocal;     // устанавливаем курсор
                    Form1->RichEdit6->SelLength=1;      // выделяем 1 символ
                    Symbol=0x46;                        // будем писать символ F
                    Form1->RichEdit6->SelText=Symbol;   // пишем
                    // получаем символ, который будем писать в область справа
                    CharPos=(PositionLocal-6)/3;        // номер байта в строке, который нужно поменять
                    Form1->RichEdit6->SelStart=46*LineNumber+6+3*CharPos;       // ставим курсор на начало байта (в области слева)
                    Form1->RichEdit6->SelLength=2;                              // выделяем 2 символа
                    SubStr=LowerCase(Form1->RichEdit6->SelText);                // получаем их в строку
                    InHexBuf=SubStr.c_str();         //скопировать в буфер байт для передачи (в виде строки)
                    HexToBin(InHexBuf,TempBuf,1);     //преобразовать строку в целое (байт)
                    Key=TempBuf[0];
                    if(Key<0x1F) Symbol=0x1F;      //заменяем непечатные
                    else         Symbol=TempBuf[0];
                    // меняем область справа
                    Form1->RichEdit6->SelStart=LineNumber*46+36+CharPos;        // устанавливаем курсор
                    Form1->RichEdit6->SelLength=1;      // выделяем 1 символ
                    Form1->RichEdit6->SelText=Symbol;   // пишем туда полученный символ
                  }
                }
                else if(PositionLocal<36)               // если мы между правой и левой областями
                { PositionLocal=44;                     // если позиция <36, то переходим в начало предыдущей строки
                  LineNumber-=1;
                  if(LineNumber<0)                      // если номер строки <0
                        LineNumber=MaxLineNumber;       // переходим на последнюю строку
                }
                else                                    // если мы в области справа
                { // меняем область справа
                  Form1->RichEdit6->SelStart=LineNumber*46+PositionLocal;       // устанавливаем курсор
                  Form1->RichEdit6->SelLength=1;        // выделяем 1 символ
                  Symbol=0xFF;                          // будем писать символ я
                  Form1->RichEdit6->SelText=Symbol;     // пишем
                  // получаем символ, который будем менять
                  CharPos=PositionLocal-36;             // номер байта в строке, который нужно поменять
                  // меняем область слева
                  Form1->RichEdit6->SelStart=LineNumber*46+6+3*CharPos;         // устанавливаем курсор
                  Form1->RichEdit6->SelLength=2;        // выделяем 2 символа
                  Form1->RichEdit6->SelText="FF";       // пишем
                }
                // устанавливаем курсор в нужную позицию
                Form1->RichEdit6->SelStart=LineNumber*46+PositionLocal;         // ставим курсор в нужную позицию
                Form1->RichEdit6->SelLength=0;                                  // отменяем выделение
                break;
    // обработчик стрелок *************************************
     case 0x25:
     case 0x26:
     case 0x27:
     case 0x28: return;
     // обработчик delete **************************************
     case 0x2E: // если мы в области слева - заменяем на F
                if((PositionLocal>5) && (PositionLocal<29))
                {       Key=0x46;                    // заменяем символ слева на F
                }
                // если мы в области справа - заменяем на я
                if(PositionLocal>35)
                {       Key=0xFF;                    // заменяем символ справа на F
                }

     // обработчик всех остальных кнопок ***********************
     default:   if(PositionLocal>43)            // если позиция > 43
                { PositionLocal=35;             // то переходим в начало строки
                  LineNumber+=1;                // увеличиваем номер строки
                  if(LineNumber>MaxLineNumber)
                        LineNumber=0;           // если номер > максимального - переходим на первую строку
                }
                else if(PositionLocal>35)       // если позиция > 35
                { // меняем область справа
                  Form1->RichEdit6->SelStart=LineNumber*46+PositionLocal;       // ставим курсор в нужную позицию
                  Form1->RichEdit6->SelLength=1;                                // выделяем 1 символ
                  if(Key<0x1F)  Key=0x1F;                                       // если символ непечатный (спецсимвол) - заменяем
                  Symbol=Key;
                  Form1->RichEdit6->SelText=Symbol;                             // пишем туда введённый символ
                  Form1->RichEdit6->SelStart=LineNumber*46+PositionLocal;       // ставим курсор в нужную позицию
                  Form1->RichEdit6->SelLength=1;                                // выделяем 1 символ
                  Form1->RichEdit6->SelText=UpperCase(Form1->RichEdit6->SelText); // переводим введённый символ в верхний регистр
                  // получаем символ, который будем менять
                  CharPos=PositionLocal-36;             // номер байта в строке, который нужно поменять
                  TempBuf[0]=Key;
                  BinToHex(TempBuf,OutHexBuf,1);        //преобразовать строку в целое (байт)
                  OutHexBuf[2]=0;                       //строка должна заканчиваться нулём
                  // меняем область слева
                  Form1->RichEdit6->SelStart=LineNumber*46+6+3*CharPos;         // ставим курсор на начало байт
                  Form1->RichEdit6->SelLength=2;                                // выделяем 2 символа
                  Form1->RichEdit6->SelText=OutHexBuf;
                }
                else if(PositionLocal>28)       // если позиция >28,
                { PositionLocal=5;              // то переходим в начало строки
                  LineNumber+=1;                // увеличиваем номер строки
                  if(LineNumber>MaxLineNumber)
                        LineNumber=0;           // если номер > максимального - переходим на первую строку
                }
                else if(PositionLocal>5)        // если позиция > 5
                { if(strchr(Charset1,Key)&&((PositionLocal-6)%3!=2))            // если символ есть в наборе и позиция не перед пробелом
                  { // меняем область слева
                    Form1->RichEdit6->SelStart=LineNumber*46+PositionLocal;     // ставим курсор в нужную позицию
                    Form1->RichEdit6->SelLength=1;                              // выделяем 1 символ
                    Symbol=Key;
                    Form1->RichEdit6->SelText=Symbol;                           // пишем туда введённый символ
                    Form1->RichEdit6->SelStart=LineNumber*46+PositionLocal;     // ставим курсор в нужную позицию
                    Form1->RichEdit6->SelLength=1;                              // выделяем 1 символ
                    Form1->RichEdit6->SelText=UpperCase(Form1->RichEdit6->SelText);     // переводим введённый символ в верхний регистр
                    // получаем символ, который будем писать в область справа
                    CharPos=(PositionLocal-6)/3;        // номер байта в строке, который нужно поменять
                    Form1->RichEdit6->SelStart=46*LineNumber+6+3*CharPos;       // ставим курсор на начало байта (в области слева)
                    Form1->RichEdit6->SelLength=2;                              // выделяем 2 символа
                    SubStr=LowerCase(Form1->RichEdit6->SelText);                // получаем их в строку
                    InHexBuf=SubStr.c_str();               //скопировать в буфер байт для передачи (в виде строки)
                    HexToBin(InHexBuf,TempBuf,1);          //преобразовать строку в целое (байт)
                    Key=TempBuf[0];
                    if(Key<0x1F) Symbol=0x1F;           //заменяем непечатные
                    else         Symbol=TempBuf[0];
                    // меняем область справа
                    Form1->RichEdit6->SelStart=LineNumber*46+36+CharPos;        // устанавливаем курсор
                    Form1->RichEdit6->SelLength=1;      // выделяем 1 символ
                    Form1->RichEdit6->SelText=Symbol;   // пишем туда полученный символ
                  }
                }
                else    PositionLocal=5;        // переходим в начало строки
                // устанавливаем курсор в нужную позицию
                PositionLocal+=1;                                       // увеличиваем позицию курсора
                Form1->RichEdit6->SelStart=LineNumber*46+PositionLocal; // ставим курсор в нужную позицию
                Form1->RichEdit6->SelLength=0;                          // отменяем выделение
  }
  Key=0;
}
//---------------------------------------------------------------------------
//--- РЕДАКТИРОВАНИЕ ПОЛЯ RICHEDIT7 (Area 4) --------------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::RichEdit7KeyDown(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->RichEdit7->SelStart;            // глобальная позиция курсора в тексте
  LineNumber=PositionGlobal/46;                         // номер строки, в которой находится курсор  44 символа + CR+LF
  PositionLocal=PositionGlobal-46*LineNumber;           // позиция курсора в строке
  MaxLineNumber=(FormData.RE7Size-1)/8;           // максимальный номер строки
  switch(Key)
  { // обработчик backspace ***********************************
    case 8:     PositionLocal-=1;                       // уменьшаем позицию в строке
                if(PositionLocal<6)
                { PositionLocal=29;                     // если позиция <6, то переходим в начало предыдущей строки
                  LineNumber-=1;
                  if(LineNumber<0)                      // если номер строки <0
                        LineNumber=MaxLineNumber;       // переходим на последнюю строку
                }
                else if(PositionLocal<29)               // если новая позиция в области hex
                { if ((PositionLocal-6)%3!=2)           // если новая позиция не перед пробелом
                  { // меняем область слева
                    Form1->RichEdit7->SelStart=LineNumber*46+PositionLocal;     // устанавливаем курсор
                    Form1->RichEdit7->SelLength=1;      // выделяем 1 символ
                    Symbol=0x46;                        // будем писать символ F
                    Form1->RichEdit7->SelText=Symbol;   // пишем
                    // получаем символ, который будем писать в область справа
                    CharPos=(PositionLocal-6)/3;        // номер байта в строке, который нужно поменять
                    Form1->RichEdit7->SelStart=46*LineNumber+6+3*CharPos;       // ставим курсор на начало байта (в области слева)
                    Form1->RichEdit7->SelLength=2;                              // выделяем 2 символа
                    SubStr=LowerCase(Form1->RichEdit7->SelText);                // получаем их в строку
                    InHexBuf=SubStr.c_str();         //скопировать в буфер байт для передачи (в виде строки)
                    HexToBin(InHexBuf,TempBuf,1);     //преобразовать строку в целое (байт)
                    Key=TempBuf[0];
                    if(Key<0x1F) Symbol=0x1F;      //заменяем непечатные
                    else         Symbol=TempBuf[0];
                    // меняем область справа
                    Form1->RichEdit7->SelStart=LineNumber*46+36+CharPos;        // устанавливаем курсор
                    Form1->RichEdit7->SelLength=1;      // выделяем 1 символ
                    Form1->RichEdit7->SelText=Symbol;   // пишем туда полученный символ
                  }
                }
                else if(PositionLocal<36)               // если мы между правой и левой областями
                { PositionLocal=44;                     // если позиция <36, то переходим в начало предыдущей строки
                  LineNumber-=1;
                  if(LineNumber<0)                      // если номер строки <0
                        LineNumber=MaxLineNumber;       // переходим на последнюю строку
                }
                else                                    // если мы в области справа
                { // меняем область справа
                  Form1->RichEdit7->SelStart=LineNumber*46+PositionLocal;       // устанавливаем курсор
                  Form1->RichEdit7->SelLength=1;        // выделяем 1 символ
                  Symbol=0xFF;                          // будем писать символ я
                  Form1->RichEdit7->SelText=Symbol;     // пишем
                  // получаем символ, который будем менять
                  CharPos=PositionLocal-36;             // номер байта в строке, который нужно поменять
                  // меняем область слева
                  Form1->RichEdit7->SelStart=LineNumber*46+6+3*CharPos;         // устанавливаем курсор
                  Form1->RichEdit7->SelLength=2;        // выделяем 2 символа
                  Form1->RichEdit7->SelText="FF";       // пишем
                }
                // устанавливаем курсор в нужную позицию
                Form1->RichEdit7->SelStart=LineNumber*46+PositionLocal;         // ставим курсор в нужную позицию
                Form1->RichEdit7->SelLength=0;                                  // отменяем выделение
                break;
    // обработчик стрелок *************************************
     case 0x25:
     case 0x26:
     case 0x27:
     case 0x28: return;
     // обработчик delete **************************************
     case 0x2E: // если мы в области слева - заменяем на F
                if((PositionLocal>5) && (PositionLocal<29))
                {       Key=0x46;                    // заменяем символ слева на F
                }
                // если мы в области справа - заменяем на я
                if(PositionLocal>35)
                {       Key=0xFF;                    // заменяем символ справа на F
                }

     // обработчик всех остальных кнопок ***********************
     default:   if(PositionLocal>43)            // если позиция > 43
                { PositionLocal=35;             // то переходим в начало строки
                  LineNumber+=1;                // увеличиваем номер строки
                  if(LineNumber>MaxLineNumber)
                        LineNumber=0;           // если номер > максимального - переходим на первую строку
                }
                else if(PositionLocal>35)       // если позиция > 35
                { // меняем область справа
                  Form1->RichEdit7->SelStart=LineNumber*46+PositionLocal;       // ставим курсор в нужную позицию
                  Form1->RichEdit7->SelLength=1;                                // выделяем 1 символ
                  if(Key<0x1F)  Key=0x1F;                                       // если символ непечатный (спецсимвол) - заменяем
                  Symbol=Key;
                  Form1->RichEdit7->SelText=Symbol;                             // пишем туда введённый символ
                  Form1->RichEdit7->SelStart=LineNumber*46+PositionLocal;       // ставим курсор в нужную позицию
                  Form1->RichEdit7->SelLength=1;                                // выделяем 1 символ
                  Form1->RichEdit7->SelText=UpperCase(Form1->RichEdit7->SelText); // переводим введённый символ в верхний регистр
                  // получаем символ, который будем менять
                  CharPos=PositionLocal-36;             // номер байта в строке, который нужно поменять
                  TempBuf[0]=Key;
                  BinToHex(TempBuf,OutHexBuf,1);        //преобразовать строку в целое (байт)
                  OutHexBuf[2]=0;                       //строка должна заканчиваться нулём
                  // меняем область слева
                  Form1->RichEdit7->SelStart=LineNumber*46+6+3*CharPos;         // ставим курсор на начало байт
                  Form1->RichEdit7->SelLength=2;                                // выделяем 2 символа
                  Form1->RichEdit7->SelText=OutHexBuf;
                }
                else if(PositionLocal>28)       // если позиция >28,
                { PositionLocal=5;              // то переходим в начало строки
                  LineNumber+=1;                // увеличиваем номер строки
                  if(LineNumber>MaxLineNumber)
                        LineNumber=0;           // если номер > максимального - переходим на первую строку
                }
                else if(PositionLocal>5)        // если позиция > 5
                { if(strchr(Charset1,Key)&&((PositionLocal-6)%3!=2))            // если символ есть в наборе и позиция не перед пробелом
                  { // меняем область слева
                    Form1->RichEdit7->SelStart=LineNumber*46+PositionLocal;     // ставим курсор в нужную позицию
                    Form1->RichEdit7->SelLength=1;                              // выделяем 1 символ
                    Symbol=Key;
                    Form1->RichEdit7->SelText=Symbol;                           // пишем туда введённый символ
                    Form1->RichEdit7->SelStart=LineNumber*46+PositionLocal;     // ставим курсор в нужную позицию
                    Form1->RichEdit7->SelLength=1;                              // выделяем 1 символ
                    Form1->RichEdit7->SelText=UpperCase(Form1->RichEdit7->SelText);     // переводим введённый символ в верхний регистр
                    // получаем символ, который будем писать в область справа
                    CharPos=(PositionLocal-6)/3;        // номер байта в строке, который нужно поменять
                    Form1->RichEdit7->SelStart=46*LineNumber+6+3*CharPos;       // ставим курсор на начало байта (в области слева)
                    Form1->RichEdit7->SelLength=2;                              // выделяем 2 символа
                    SubStr=LowerCase(Form1->RichEdit7->SelText);                // получаем их в строку
                    InHexBuf=SubStr.c_str();               //скопировать в буфер байт для передачи (в виде строки)
                    HexToBin(InHexBuf,TempBuf,1);          //преобразовать строку в целое (байт)
                    Key=TempBuf[0];
                    if(Key<0x1F) Symbol=0x1F;           //заменяем непечатные
                    else         Symbol=TempBuf[0];
                    // меняем область справа
                    Form1->RichEdit7->SelStart=LineNumber*46+36+CharPos;        // устанавливаем курсор
                    Form1->RichEdit7->SelLength=1;      // выделяем 1 символ
                    Form1->RichEdit7->SelText=Symbol;   // пишем туда полученный символ
                  }
                }
                else    PositionLocal=5;        // переходим в начало строки
                // устанавливаем курсор в нужную позицию
                PositionLocal+=1;                                       // увеличиваем позицию курсора
                Form1->RichEdit7->SelStart=LineNumber*46+PositionLocal; // ставим курсор в нужную позицию
                Form1->RichEdit7->SelLength=0;                          // отменяем выделение
  }
  Key=0;
}
//---------------------------------------------------------------------------
//--- РЕДАКТИРОВАНИЕ ПОЛЯ RICHEDIT8 (Area 4) --------------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::RichEdit8KeyDown(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->RichEdit8->SelStart;            // глобальная позиция курсора в тексте
  LineNumber=PositionGlobal/46;                         // номер строки, в которой находится курсор  44 символа + CR+LF
  PositionLocal=PositionGlobal-46*LineNumber;           // позиция курсора в строке
  MaxLineNumber=(FormData.RE8Size-1)/8;           // максимальный номер строки
  switch(Key)
  { // обработчик backspace ***********************************
    case 8:     PositionLocal-=1;                       // уменьшаем позицию в строке
                if(PositionLocal<6)
                { PositionLocal=29;                     // если позиция <6, то переходим в начало предыдущей строки
                  LineNumber-=1;
                  if(LineNumber<0)                      // если номер строки <0
                        LineNumber=MaxLineNumber;       // переходим на последнюю строку
                }
                else if(PositionLocal<29)               // если новая позиция в области hex
                { if ((PositionLocal-6)%3!=2)           // если новая позиция не перед пробелом
                  { // меняем область слева
                    Form1->RichEdit8->SelStart=LineNumber*46+PositionLocal;     // устанавливаем курсор
                    Form1->RichEdit8->SelLength=1;      // выделяем 1 символ
                    Symbol=0x46;                        // будем писать символ F
                    Form1->RichEdit8->SelText=Symbol;   // пишем
                    // получаем символ, который будем писать в область справа
                    CharPos=(PositionLocal-6)/3;        // номер байта в строке, который нужно поменять
                    Form1->RichEdit8->SelStart=46*LineNumber+6+3*CharPos;       // ставим курсор на начало байта (в области слева)
                    Form1->RichEdit8->SelLength=2;                              // выделяем 2 символа
                    SubStr=LowerCase(Form1->RichEdit8->SelText);                // получаем их в строку
                    InHexBuf=SubStr.c_str();         //скопировать в буфер байт для передачи (в виде строки)
                    HexToBin(InHexBuf,TempBuf,1);     //преобразовать строку в целое (байт)
                    Key=TempBuf[0];
                    if(Key<0x1F) Symbol=0x1F;      //заменяем непечатные
                    else         Symbol=TempBuf[0];
                    // меняем область справа
                    Form1->RichEdit8->SelStart=LineNumber*46+36+CharPos;        // устанавливаем курсор
                    Form1->RichEdit8->SelLength=1;      // выделяем 1 символ
                    Form1->RichEdit8->SelText=Symbol;   // пишем туда полученный символ
                  }
                }
                else if(PositionLocal<36)               // если мы между правой и левой областями
                { PositionLocal=44;                     // если позиция <36, то переходим в начало предыдущей строки
                  LineNumber-=1;
                  if(LineNumber<0)                      // если номер строки <0
                        LineNumber=MaxLineNumber;       // переходим на последнюю строку
                }
                else                                    // если мы в области справа
                { // меняем область справа
                  Form1->RichEdit8->SelStart=LineNumber*46+PositionLocal;       // устанавливаем курсор
                  Form1->RichEdit8->SelLength=1;        // выделяем 1 символ
                  Symbol=0xFF;                          // будем писать символ я
                  Form1->RichEdit8->SelText=Symbol;     // пишем
                  // получаем символ, который будем менять
                  CharPos=PositionLocal-36;             // номер байта в строке, который нужно поменять
                  // меняем область слева
                  Form1->RichEdit8->SelStart=LineNumber*46+6+3*CharPos;         // устанавливаем курсор
                  Form1->RichEdit8->SelLength=2;        // выделяем 2 символа
                  Form1->RichEdit8->SelText="FF";       // пишем
                }
                // устанавливаем курсор в нужную позицию
                Form1->RichEdit8->SelStart=LineNumber*46+PositionLocal;         // ставим курсор в нужную позицию
                Form1->RichEdit8->SelLength=0;                                  // отменяем выделение
                break;
    // обработчик стрелок *************************************
     case 0x25:
     case 0x26:
     case 0x27:
     case 0x28: return;
     // обработчик delete **************************************
     case 0x2E: // если мы в области слева - заменяем на F
                if((PositionLocal>5) && (PositionLocal<29))
                {       Key=0x46;                    // заменяем символ слева на F
                }
                // если мы в области справа - заменяем на я
                if(PositionLocal>35)
                {       Key=0xFF;                    // заменяем символ справа на F
                }

     // обработчик всех остальных кнопок ***********************
     default:   if(PositionLocal>43)            // если позиция > 43
                { PositionLocal=35;             // то переходим в начало строки
                  LineNumber+=1;                // увеличиваем номер строки
                  if(LineNumber>MaxLineNumber)
                        LineNumber=0;           // если номер > максимального - переходим на первую строку
                }
                else if(PositionLocal>35)       // если позиция > 35
                { // меняем область справа
                  Form1->RichEdit8->SelStart=LineNumber*46+PositionLocal;       // ставим курсор в нужную позицию
                  Form1->RichEdit8->SelLength=1;                                // выделяем 1 символ
                  if(Key<0x1F)  Key=0x1F;                                       // если символ непечатный (спецсимвол) - заменяем
                  Symbol=Key;
                  Form1->RichEdit8->SelText=Symbol;                             // пишем туда введённый символ
                  Form1->RichEdit8->SelStart=LineNumber*46+PositionLocal;       // ставим курсор в нужную позицию
                  Form1->RichEdit8->SelLength=1;                                // выделяем 1 символ
                  Form1->RichEdit8->SelText=UpperCase(Form1->RichEdit8->SelText); // переводим введённый символ в верхний регистр
                  // получаем символ, который будем менять
                  CharPos=PositionLocal-36;             // номер байта в строке, который нужно поменять
                  TempBuf[0]=Key;
                  BinToHex(TempBuf,OutHexBuf,1);        //преобразовать строку в целое (байт)
                  OutHexBuf[2]=0;                       //строка должна заканчиваться нулём
                  // меняем область слева
                  Form1->RichEdit8->SelStart=LineNumber*46+6+3*CharPos;         // ставим курсор на начало байт
                  Form1->RichEdit8->SelLength=2;                                // выделяем 2 символа
                  Form1->RichEdit8->SelText=OutHexBuf;
                }
                else if(PositionLocal>28)       // если позиция >28,
                { PositionLocal=5;              // то переходим в начало строки
                  LineNumber+=1;                // увеличиваем номер строки
                  if(LineNumber>MaxLineNumber)
                        LineNumber=0;           // если номер > максимального - переходим на первую строку
                }
                else if(PositionLocal>5)        // если позиция > 5
                { if(strchr(Charset1,Key)&&((PositionLocal-6)%3!=2))            // если символ есть в наборе и позиция не перед пробелом
                  { // меняем область слева
                    Form1->RichEdit8->SelStart=LineNumber*46+PositionLocal;     // ставим курсор в нужную позицию
                    Form1->RichEdit8->SelLength=1;                              // выделяем 1 символ
                    Symbol=Key;
                    Form1->RichEdit8->SelText=Symbol;                           // пишем туда введённый символ
                    Form1->RichEdit8->SelStart=LineNumber*46+PositionLocal;     // ставим курсор в нужную позицию
                    Form1->RichEdit8->SelLength=1;                              // выделяем 1 символ
                    Form1->RichEdit8->SelText=UpperCase(Form1->RichEdit8->SelText);     // переводим введённый символ в верхний регистр
                    // получаем символ, который будем писать в область справа
                    CharPos=(PositionLocal-6)/3;        // номер байта в строке, который нужно поменять
                    Form1->RichEdit8->SelStart=46*LineNumber+6+3*CharPos;       // ставим курсор на начало байта (в области слева)
                    Form1->RichEdit8->SelLength=2;                              // выделяем 2 символа
                    SubStr=LowerCase(Form1->RichEdit8->SelText);                // получаем их в строку
                    InHexBuf=SubStr.c_str();               //скопировать в буфер байт для передачи (в виде строки)
                    HexToBin(InHexBuf,TempBuf,1);          //преобразовать строку в целое (байт)
                    Key=TempBuf[0];
                    if(Key<0x1F) Symbol=0x1F;           //заменяем непечатные
                    else         Symbol=TempBuf[0];
                    // меняем область справа
                    Form1->RichEdit8->SelStart=LineNumber*46+36+CharPos;        // устанавливаем курсор
                    Form1->RichEdit8->SelLength=1;      // выделяем 1 символ
                    Form1->RichEdit8->SelText=Symbol;   // пишем туда полученный символ
                  }
                }
                else    PositionLocal=5;        // переходим в начало строки
                // устанавливаем курсор в нужную позицию
                PositionLocal+=1;                                       // увеличиваем позицию курсора
                Form1->RichEdit8->SelStart=LineNumber*46+PositionLocal; // ставим курсор в нужную позицию
                Form1->RichEdit8->SelLength=0;                          // отменяем выделение
  }
  Key=0;
}
//---------------------------------------------------------------------------
//***************************************************************************
//*** РАБОТА С КНОПКАМИ НА ФОРМЕ ********************************************
//***************************************************************************
//---------------------------------------------------------------------------
//--- нажали кнопку How to connect... ---------------------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::Button16Click(TObject *Sender)
{ Application->CreateForm(__classid(TSchema),&Schema);              // создаём форму со схемой подключения
  Schema->ShowModal();                                              // показываем её в модальном окне
  Schema->Free();                                                   // уничтожаем форму после закрытия
}
//---------------------------------------------------------------------------
//--- НАЖАТА КНОПКА BUTTON4 -------------------------------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::Button4Click(TObject *Sender)
{ AnsiString TempStr;                           // для преобразования
  char *InHexBuf, TempBuf[1], OutHexBuf[3];     // для преобразования

  switch(SelectedChip.Family)
  { case 0x0:   // выбран один из чипов с перезаписываемым ROM
                switch(SelectedChip.Modify)
                { case 1:  //-------------------------------------------
                           // выбран чип RW1990, нажата кнопка WRITE ROM
                           //-------------------------------------------
                           // добавляем нужные переменные
                           RW1990_OUTPUT_DATA RW1990_OutputData;        // выходные данные для функций RW1990
                           SendMsgToLogForm(153, Form1->Edit3->Text);   // начинаем запись ROM
                           // начинаем работать
                           GetDataToMemory(0,0);                        // получаем ROM с формы (второй параметр может быть любым)
                           if(Port!=INVALID_HANDLE_VALUE)
                           { RW1990_OutputData=RW1990_WriteROM();       // пишем новый ROM
                             if(RW1990_OutputData.Success)      SendMsgToLogForm(106,"");  // запись данных успешно завершена
                             else                               SendMsgToLogForm(105,"");  // запись данных завершена с ошибкой
                           }
                           else    SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                           break;
                  case 2:  //-------------------------------------------
                           // выбран чип AN1990, нажата кнопка WRITE ROM
                  case 3:  //-------------------------------------------
                           // выбран чип TM2004, нажата кнопка WRITE ROM
                           //-------------------------------------------
                           // добавляем нужные переменные
                           AN1990_OUTPUT_DATA AN1990_OutputData;        // выходные данные для функций AN1990
                           SendMsgToLogForm(153, Form1->Edit3->Text);   // начинаем запись ROM
                           // начинаем работать
                           GetDataToMemory(0,0);                        // получаем ROM с формы (второй параметр может быть любым)
                           if(Port!=INVALID_HANDLE_VALUE)
                           { AN1990_OutputData=AN1990_WriteROM();       // пишем новый ROM
                             if(AN1990_OutputData.Success)      SendMsgToLogForm(106,"");  // запись данных успешно завершена
                             else                               SendMsgToLogForm(105,"");  // запись данных завершена с ошибкой
                           }
                           else    SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                           break;
                  default: break;
                }
                break;
    case 0x2:   //--------------------------------------------------
                // выбран чип DS1991, нажата кнопка WRITE SCRATCHPAD
    case 0x82:  //-------------------------------------------------
                // выбран чип DS1425, нажата кнопка WRITE SCRATCHPAD
                //--------------------------------------------------
                // добавляем нужные переменные
                DS1991_OUTPUT_DATA DS1991_OutputData; // выходные данные для функций DS1991
                SendMsgToLogForm(116,"");    // начинаем запись в блокнот
                // начинаем работать
                GetDataToMemory(0,0);                   // получаем ROM с формы (второй параметр может быть любым)
                // помещаем данные с формы в память (для DS1991 Scratchpad находится в Area4)
                switch(Form1->PageControl1->TabIndex)
                { case 0:  GetDataToMemory(7,4);        // передаём данные из RichEdit7 в Scratchpad
                           break;
                  case 1:  GetDataToMemory(8,4);        // передаём данные из RichEdit8 в Scratchpad
                           break;
                  default: break;
                }
                // посылаем данные из памяти Area4 по 1-Wire
                if(Port!=INVALID_HANDLE_VALUE)
                { DS1991_OutputData=DS1991_WriteToScratchpad();
                  if(DS1991_OutputData.Success)         SendMsgToLogForm(106,"");  // запись в scratchpad успешно завершена
                  else                                  SendMsgToLogForm(105,"");  // запись в scratchpad завершена с ошибкой
                }
                else    SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                break;
    case 0x4:   //--------------------------------------------------
                // выбран чип DS1994, нажата кнопка WRITE SCRATCHPAD
    case 0x84:  //--------------------------------------------------
                // выбран чип DS1427, нажата кнопка WRITE SCRATCHPAD
                //--------------------------------------------------
                // добавляем нужные переменные
                DS1994_INPUT_DATA DS1994_InputData;     // входные данные для функций DS1994
                DS1994_OUTPUT_DATA DS1994_OutputData;   // выходные данные для функций DS1994
                SendMsgToLogForm(116,"");    // начинаем запись в блокнот
                // начинаем работать
                GetDataToMemory(0,0);                   // получаем ROM с формы (второй параметр может быть любым)
                TempStr=LowerCase(Form1->Edit4->Text);  // получаем TA1 в строку
                InHexBuf=TempStr.c_str();               // скопировать в буфер байт для передачи (в виде строки)
                HexToBin(InHexBuf,TempBuf,1);           // преобразовать строку в целое (байт)
                DS1994_InputData.TA1=TempBuf[0];        // сохраняем значение TA1
                TempStr=LowerCase(Form1->Edit5->Text);  // получаем TA2 в строку
                InHexBuf=TempStr.c_str();               // скопировать в буфер байт для передачи (в виде строки)
                HexToBin(InHexBuf,TempBuf,1);           // преобразовать строку в целое (байт)
                DS1994_InputData.TA2=TempBuf[0];        // сохраняем значение TA2
                // помещаем данные с формы в память в зависимости от вкладки (для DS1994 Scratchpad находится в Area3)
                switch(Form1->PageControl1->TabIndex)
                { case 0:  GetDataToMemory(5,3);        // передаём данные из RichEdit5 в Scratchpad
                           break;
                  case 1:  GetDataToMemory(6,3);        // передаём данные из RichEdit6 в Scratchpad
                           break;
                  default: break;
                }
                // посылаем данные по 1-Wire и помещаем результат (Test) на форму
                DS1994_InputData.AreaNumber=3;                  // блокнот - это Area3
                DS1994_InputData.Size=SelectedChip.Area3Size;   // размер равен размеру блокнота
                if(Port!=INVALID_HANDLE_VALUE)
                { DS1994_OutputData=DS1994_WriteToScratchpad(DS1994_InputData);
                  if(DS1994_OutputData.Success) SendMsgToLogForm(106,"");  // запись в scratchpad успешно завершена
                  else                          SendMsgToLogForm(105,"");  // запись в scratchpad завершена с ошибкой
                }
                else    SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                break;
    case 0x5:   //--------------------------------------------
                // выбран чип DS2405, нажата кнопка READ STATE
                //--------------------------------------------
                // добавляем нужные переменные
                DS2405_OUTPUT_DATA DS2405_OutputData; // выходные данные для функций DS2405
                SendMsgToLogForm(137,"");    // начинаем чтение состояния
                // начинаем работать
                GetDataToMemory(0,0);                   // получаем ROM с формы (второй параметр может быть любым)
                // выполняем чтение состояния
                if(Port!=INVALID_HANDLE_VALUE)
                { DS2405_OutputData=DS2405_ReadState();
                  if(DS2405_OutputData.Success)
                  { TempBuf[0]=DS2405_OutputData.Test;
                    BinToHex(TempBuf,OutHexBuf,1);      // преобразовать строку в целое (байт)
                    OutHexBuf[2]=0;                     // строка должна заканчиваться нулём
                    Form1->Edit4->Text = OutHexBuf;
                    SendMsgToLogForm(108,"");              // чтение успешно завершено
                  }
                  else  SendMsgToLogForm(107,"");  // чтение завершена с ошибкой
                }
                else    SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                break;
    case 0x6 :  //--------------------------------------------------
                // выбран чип DS1993, нажата кнопка WRITE SCRATCHPAD
    case 0x8 :  //--------------------------------------------------
                // выбран чип DS1992, нажата кнопка WRITE SCRATCHPAD
    case 0xA :  //--------------------------------------------------
                // выбран чип DS1995, нажата кнопка WRITE SCRATCHPAD
    case 0xC :  //--------------------------------------------------
                // выбран чип DS1996, нажата кнопка WRITE SCRATCHPAD
                //--------------------------------------------------
                // добавляем нужные переменные
                DS1992_INPUT_DATA DS1992_InputData;   // входные данные для функций DS1992
                DS1992_OUTPUT_DATA DS1992_OutputData; // выходные данные для функций DS1992
                SendMsgToLogForm(116,"");    // начинаем запись в блокнот
                // начинаем работать
                GetDataToMemory(0,0);                   // получаем ROM с формы (второй параметр может быть любым)
                TempStr=LowerCase(Form1->Edit4->Text);  // получаем TA1 в строку
                InHexBuf=TempStr.c_str();               // скопировать в буфер байт для передачи (в виде строки)
                HexToBin(InHexBuf,TempBuf,1);           // преобразовать строку в целое (байт)
                DS1992_InputData.TA1=TempBuf[0];        // сохраняем значение TA1
                TempStr=LowerCase(Form1->Edit5->Text);  // получаем TA2 в строку
                InHexBuf=TempStr.c_str();               // скопировать в буфер байт для передачи (в виде строки)
                HexToBin(InHexBuf,TempBuf,1);           // преобразовать строку в целое (байт)
                DS1992_InputData.TA2=TempBuf[0];        // сохраняем значение TA2
                // помещаем данные с формы в память в зависимости от вкладки (для DS1992 Scratchpad находится в Area2)
                switch(Form1->PageControl1->TabIndex)
                { case 0:  GetDataToMemory(3,2);        // передаём данные из RichEdit3 в Scratchpad
                           break;
                  case 1:  GetDataToMemory(4,2);        // передаём данные из RichEdit4 в Scratchpad
                           break;
                  default: break;
                }
                // посылаем данные из памяти Area2 по 1-Wire и помещаем результат (Test) на форму
                DS1992_InputData.AreaNumber=2;
                DS1992_InputData.Size=SelectedChip.Area2Size;
                if(Port!=INVALID_HANDLE_VALUE)
                { DS1992_OutputData=DS1992_WriteToScratchpad(DS1992_InputData);
                  if(DS1992_OutputData.Success)
                  { TempBuf[0]=DS1992_OutputData.Test;
                    BinToHex(TempBuf,OutHexBuf,1);      // преобразовать строку в целое (байт)
                    OutHexBuf[2]=0;                     // строка должна заканчиваться нулём
                    Form1->Edit7->Text = OutHexBuf;
                    SendMsgToLogForm(106,"");                // запись в scratchpad успешно завершена
                  }
                  else  SendMsgToLogForm(105,"");            // запись в scratchpad завершена с ошибкой
                }
                else    SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                break;
    case 0x9:   //-----------------------------------------------------
                // выбран чип DS2502 / DS1982, нажата кнопка WRITE DATA
                //-----------------------------------------------------
                // добавляем нужные переменные
                DS2502_INPUT_DATA DS2502_InputData;     // входные данные для функций DS2502
                DS2502_OUTPUT_DATA DS2502_OutputData;   // выходные данные для функций DS2502
                SendMsgToLogForm(121,"");    // начинаем запись в EPROM
                // начинаем работать
                GetDataToMemory(0,0);                   // получаем ROM с формы (второй параметр может быть любым)
                DS2502_InputData.TA1=0;                 // сохраняем значение TA1
                DS2502_InputData.TA2=0;                 // сохраняем значение TA2
                // помещаем данные с формы в память в зависимости от вкладки (для DS2502 EPROM находится в Area1)
                switch(Form1->PageControl1->TabIndex)
                { case 0:  GetDataToMemory(1,1);        // передаём данные из RichEdit1 в EPROM
                           break;
                  case 1:  GetDataToMemory(2,1);        // передаём данные из RichEdit2 в EPROM
                           break;
                  default: break;
                }
                // посылаем данные по 1-Wire
                DS2502_InputData.AreaNumber=1;                  // EPROM - это Area1
                DS2502_InputData.Size=SelectedChip.Area1Size;   // размер равен размеру EPROM
                if(Port!=INVALID_HANDLE_VALUE)
                { DS2502_OutputData=DS2502_WriteToMemory(DS2502_InputData);
                  if(DS2502_OutputData.Success) SendMsgToLogForm(106,"");                // запись в EPROM успешно завершена
                  else                          SendMsgToLogForm(105,"");            // запись в EPROM завершена с ошибкой
                }
                else    SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                break;
    case 0xD:   //---------------------------------------------------
                // выбран чип DS28E05, нажата кнопка WRITE DATA MEMORY
                //---------------------------------------------------
                // добавляем нужные переменные
                DS28E05_INPUT_DATA DS28E05_InputData;     // входные данные для функций DS28E05
                DS28E05_OUTPUT_DATA DS28E05_OutputData;   // выходные данные для функций DS28E05
                SendMsgToLogForm(121,"");           // начинаем запись данных в EEPROM
                // начинаем работать
                GetDataToMemory(0,0);                     // получаем ROM с формы (второй параметр может быть любым)
                // помещаем данные с формы в память в зависимости от вкладки
                switch(Form1->PageControl1->TabIndex)
                { case 0:  GetDataToMemory(1,1);        // передаём данные из RichEdit1 в Data
                           break;
                  case 1:  GetDataToMemory(2,1);        // передаём данные из RichEdit2 в Data
                           break;
                  default: break;
                }
                // посылаем данные из памяти по 1-Wire и помещаем результат (Test) на форму
                // выбираем очередной кусок для отправки в блокнот
                DS28E05_InputData.AreaNumber=1;                                 // будем посылать в блокнот данные из области данных
                // записываем первые 6 страниц
                for(unsigned char i=0; i<7; i++)
                { // если порт открыт - отправляем очередную страницу
                  if(Port!=INVALID_HANDLE_VALUE)
                  { // вычисляем новое значение байта параметров
                    DS28E05_InputData.PB=i<<4;                                  // вычисляем значение PB
                    DS28E05_OutputData=DS28E05_WriteToMemory(DS28E05_InputData);
                  }
                  else  // если порт закрыт - отправляем мессадж и выходим
                  { SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                    return;
                  }
                  // если прочитали - проверяем ответ
                  if(DS28E05_OutputData.Success==false)                 // если запись не удалась
                  { SendMsgToLogForm(105,"");    // ошибка записи
                    return;
                  }
                  else          // если запись удалась - выводим на форму Test
                  { // помещаем на форму Test
                    TempBuf[0]=DS28E05_OutputData.Test;
                    BinToHex(TempBuf,OutHexBuf,1);        // преобразовать строку в целое (байт)
                    OutHexBuf[2]=0;                       // строка должна заканчиваться нулём
                    Form1->Edit7->Text = OutHexBuf;
                  }
                }
                SendMsgToLogForm(106,"");    // запись успешно завершена
                break;
    case 0x10:  //---------------------------------------------------
                // выбран чип DS18S20, нажата кнопка WRITE SCRATCHPAD
                //---------------------------------------------------
                // добавляем нужные переменные
                DS18S20_OUTPUT_DATA DS18S20_OutputData; // выходные данные для функций DS18S20
                SendMsgToLogForm(116,"");    // начинаем запись в блокнот
                // начинаем работать
                GetDataToMemory(0,0);                   // получаем ROM с формы (второй параметр может быть любым)
                // помещаем данные с формы в память (для DS18S20 Scratchpad находится в Area1)
                switch(Form1->PageControl1->TabIndex)
                { case 0:  GetDataToMemory(1,1);        // передаём данные из RichEdit1 в Scratchpad
                           break;
                  case 1:  GetDataToMemory(2,1);        // передаём данные из RichEdit2 в Scratchpad
                           break;
                  default: break;
                }
                // посылаем данные из памяти Area1 по 1-Wire
                if(Port!=INVALID_HANDLE_VALUE)
                { DS18S20_OutputData=DS18S20_WriteToScratchpad();
                  if(DS18S20_OutputData.Success)        SendMsgToLogForm(106,"");  // запись в scratchpad успешно завершена
                  else                                  SendMsgToLogForm(105,"");  // запись в scratchpad завершена с ошибкой
                }
                else    SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                break;
    case 0x14:  //---------------------------------------------------
                // выбран чип DS2430A, нажата кнопка WRITE SCRATCHPAD
                //---------------------------------------------------
                // добавляем нужные переменные
                DS2430_INPUT_DATA DS2430_InputData;     // входные данные для функций DS2430
                DS2430_OUTPUT_DATA DS2430_OutputData;   // выходные данные для функций DS2430
                SendMsgToLogForm(116,"");    // начинаем запись в блокнот
                // начинаем работать
                GetDataToMemory(0,0);                   // получаем ROM с формы (второй параметр может быть любым)
                // помещаем данные с формы в память в зависимости от вкладки (для DS2430 Data Scratchpad находится в Area2)
                switch(Form1->PageControl1->TabIndex)
                { case 0:  GetDataToMemory(1,2);        // передаём данные из RichEdit1 в Scratchpad
                           break;
                  case 1:  GetDataToMemory(2,2);        // передаём данные из RichEdit2 в Scratchpad
                           break;
                  default: break;
                }
                // посылаем данные из памяти Area2 по 1-Wire
                DS2430_InputData.AreaNumber=2;
                if(Port!=INVALID_HANDLE_VALUE)
                { DS2430_OutputData=DS2430_WriteToScratchpad(DS2430_InputData);
                  if(DS2430_OutputData.Success)         SendMsgToLogForm(106,"");    // запись в scratchpad успешно завершена
                  else                                  SendMsgToLogForm(105,"");    // запись в scratchpad завершена с ошибкой
                }
                else    SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                break;
    case 0x1A:  //---------------------------------------------------
                // выбран чип DS1963L, нажата кнопка WRITE SCRATCHPAD
    case 0x1D:  //---------------------------------------------------
                // выбран чип DS2423, нажата кнопка WRITE SCRATCHPAD
                //---------------------------------------------------
                // добавляем нужные переменные
                DS1963L_INPUT_DATA DS1963L_InputData;   // входные данные для функций DS1963L
                DS1963L_OUTPUT_DATA DS1963L_OutputData; // выходные данные для функций DS1963L
                SendMsgToLogForm(116,"");    // начинаем запись в блокнот
                // начинаем работать
                GetDataToMemory(0,0);                   // получаем ROM с формы (второй параметр может быть любым)
                TempStr=LowerCase(Form1->Edit4->Text);  // получаем TA1 в строку
                InHexBuf=TempStr.c_str();               // скопировать в буфер байт для передачи (в виде строки)
                HexToBin(InHexBuf,TempBuf,1);           // преобразовать строку в целое (байт)
                DS1963L_InputData.TA1=TempBuf[0];       // сохраняем значение TA1
                TempStr=LowerCase(Form1->Edit5->Text);  // получаем TA2 в строку
                InHexBuf=TempStr.c_str();               // скопировать в буфер байт для передачи (в виде строки)
                HexToBin(InHexBuf,TempBuf,1);           // преобразовать строку в целое (байт)
                DS1963L_InputData.TA2=TempBuf[0];       // сохраняем значение TA2
                // помещаем данные с формы в память в зависимости от вкладки (для DS1963L Scratchpad находится в Area2)
                switch(Form1->PageControl1->TabIndex)
                { case 0:  GetDataToMemory(3,2);        // передаём данные из RichEdit3 в Scratchpad
                           break;
                  case 1:  GetDataToMemory(4,2);        // передаём данные из RichEdit4 в Scratchpad
                           break;
                  default: break;
                }
                // посылаем данные из памяти Area2 по 1-Wire и помещаем результат (Test) на форму
                DS1963L_InputData.AreaNumber=2;
                DS1963L_InputData.Size=SelectedChip.Area2Size;
                if(Port!=INVALID_HANDLE_VALUE)
                { DS1963L_OutputData=DS1963L_WriteToScratchpad(DS1963L_InputData);
                  if(DS1963L_OutputData.Success)
                  { TempBuf[0]=DS1963L_OutputData.Test;
                    BinToHex(TempBuf,OutHexBuf,1);      // преобразовать строку в целое (байт)
                    OutHexBuf[2]=0;                     // строка должна заканчиваться нулём
                    Form1->Edit7->Text = OutHexBuf;
                    SendMsgToLogForm(106,"");                // запись в scratchpad успешно завершена
                  }
                  else  SendMsgToLogForm(105,"");            // запись в scratchpad завершена с ошибкой
                }
                else    SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                break;
    case 0x23:  //---------------------------------------------------
                // выбран чип DS24B33, нажата кнопка WRITE SCRATCHPAD
                //---------------------------------------------------
                // добавляем нужные переменные
                DS24B33_INPUT_DATA DS24B33_InputData;   // входные данные для функций DS24B33
                DS24B33_OUTPUT_DATA DS24B33_OutputData; // выходные данные для функций DS24B33
                SendMsgToLogForm(116,"");    // начинаем запись в блокнот
                // начинаем работать
                GetDataToMemory(0,0);                   // получаем ROM с формы (второй параметр может быть любым)
                TempStr=LowerCase(Form1->Edit4->Text);  // получаем TA1 в строку
                InHexBuf=TempStr.c_str();               // скопировать в буфер байт для передачи (в виде строки)
                HexToBin(InHexBuf,TempBuf,1);           // преобразовать строку в целое (байт)
                DS24B33_InputData.TA1=TempBuf[0];       // сохраняем значение TA1
                TempStr=LowerCase(Form1->Edit5->Text);  // получаем TA2 в строку
                InHexBuf=TempStr.c_str();               // скопировать в буфер байт для передачи (в виде строки)
                HexToBin(InHexBuf,TempBuf,1);           // преобразовать строку в целое (байт)
                DS24B33_InputData.TA2=TempBuf[0];       // сохраняем значение TA2
                // помещаем данные с формы в память в зависимости от вкладки (для DS24B33 Scratchpad находится в Area2)
                switch(Form1->PageControl1->TabIndex)
                { case 0:  GetDataToMemory(3,2);        // передаём данные из RichEdit3 в Scratchpad
                           break;
                  case 1:  GetDataToMemory(4,2);        // передаём данные из RichEdit4 в Scratchpad
                           break;
                  default: break;
                }
                // посылаем данные из памяти Area2 по 1-Wire и помещаем результат (Test) на форму
                DS24B33_InputData.AreaNumber=2;
                DS24B33_InputData.Size=SelectedChip.Area2Size;
                if(Port!=INVALID_HANDLE_VALUE)
                { DS24B33_OutputData=DS24B33_WriteToScratchpad(DS24B33_InputData);
                  if(DS24B33_OutputData.Success)
                  { TempBuf[0]=DS24B33_OutputData.Test;
                    BinToHex(TempBuf,OutHexBuf,1);      // преобразовать строку в целое (байт)
                    OutHexBuf[2]=0;                     // строка должна заканчиваться нулём
                    Form1->Edit7->Text = OutHexBuf;
                    SendMsgToLogForm(106,"");                // запись в scratchpad успешно завершена
                  }
                  else  SendMsgToLogForm(105,"");            // запись в scratchpad завершена с ошибкой
                }
                else    SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                break;
    case 0x24:   //--------------------------------------------
                // выбран чип DS2415, нажата кнопка WRITE CLOCK
    case 0x27:   //--------------------------------------------
                // выбран чип DS2417, нажата кнопка WRITE CLOCK
                //---------------------------------------------
                // добавляем нужные переменные
                DS2415_OUTPUT_DATA DS2415_OutputData; // выходные данные для функций DS2415
                SendMsgToLogForm(142,"");    // начинаем запись данных
                // начинаем работать
                GetDataToMemory(0,0);                   // получаем ROM с формы (второй параметр может быть любым)
                // помещаем данные с формы в память (для DS2415 данные находятся в Area1)
                switch(Form1->PageControl1->TabIndex)
                { case 0:  GetDataToMemory(1,1);        // передаём данные из RichEdit1 в Area1
                           break;
                  case 1:  GetDataToMemory(2,1);        // передаём данные из RichEdit2 в Area1
                           break;
                  default: break;
                }
                // посылаем данные из памяти Area1 по 1-Wire
                if(Port!=INVALID_HANDLE_VALUE)
                { DS2415_OutputData=DS2415_WriteClock();
                  if(DS2415_OutputData.Success)         SendMsgToLogForm(106,"");  // запись данных успешно завершена
                  else                                  SendMsgToLogForm(105,"");  // запись данных завершена с ошибкой
                }
                else    SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                break;
    case 0x22:  //---------------------------------------------------
                // выбран чип DS1822, нажата кнопка WRITE SCRATCHPAD
    case 0x28:  //---------------------------------------------------
                // выбран чип DS18B20, нажата кнопка WRITE SCRATCHPAD
                //---------------------------------------------------
                // добавляем нужные переменные
                DS18B20_OUTPUT_DATA DS18B20_OutputData; // выходные данные для функций DS18B20
                SendMsgToLogForm(116,"");    // начинаем запись в блокнот
                // начинаем работать
                GetDataToMemory(0,0);                   // получаем ROM с формы (второй параметр может быть любым)
                // помещаем данные с формы в память (для DS18B20 Scratchpad находится в Area1)
                switch(Form1->PageControl1->TabIndex)
                { case 0:  GetDataToMemory(1,1);        // передаём данные из RichEdit1 в Scratchpad
                           break;
                  case 1:  GetDataToMemory(2,1);        // передаём данные из RichEdit2 в Scratchpad
                           break;
                  default: break;
                }
                // посылаем данные из памяти Area1 по 1-Wire
                if(Port!=INVALID_HANDLE_VALUE)
                { DS18B20_OutputData=DS18B20_WriteToScratchpad();
                  if(DS18B20_OutputData.Success)        SendMsgToLogForm(106,"");    // запись в scratchpad успешно завершена
                  else                                  SendMsgToLogForm(105,"");    // запись в scratchpad завершена с ошибкой
                }
                else    SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                break;
    case 0x2C:  //------------------------------------------------
                // выбран чип DS2890, нажата кнопка WRITE POSITION
                //------------------------------------------------
                // добавляем нужные переменные
                DS2890_INPUT_DATA DS2890_InputData;     // входные данные для функций DS2890
                DS2890_OUTPUT_DATA DS2890_OutputData;   // выходные данные для функций DS2890
                SendMsgToLogForm(142,"");    // начинаем запись данных
                // начинаем работать
                GetDataToMemory(0,0);                   // получаем ROM с формы (второй параметр может быть любым)
                TempStr=LowerCase(Form1->Edit4->Text);  // получаем Position в строку
                InHexBuf=TempStr.c_str();               // скопировать в буфер байт для передачи (в виде строки)
                HexToBin(InHexBuf,TempBuf,1);           // преобразовать строку в целое (байт)
                DS2890_InputData.Position=TempBuf[0];   // сохраняем значение Position
                // выполняем команду WritePosition и помещаем результат (Test) на форму
                if(Port!=INVALID_HANDLE_VALUE)
                { DS2890_OutputData=DS2890_WritePosition(DS2890_InputData);
                  if(DS2890_OutputData.Success==true && DS2890_OutputData.Test==0)
                        SendMsgToLogForm(106,"");  // запись успешно завершена
                  else  SendMsgToLogForm(105,"");  // запись завершена с ошибкой
                }
                else    SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                break;
    case 0x2D:  //--------------------------------------------------
                // выбран чип DS2431, нажата кнопка WRITE SCRATCHPAD
                //--------------------------------------------------
                // добавляем нужные переменные
                DS2431_INPUT_DATA DS2431_InputData;     // входные данные для функций DS2431
                DS2431_OUTPUT_DATA DS2431_OutputData;   // выходные данные для функций DS2431
                SendMsgToLogForm(116,"");    // начинаем запись в блокнот
                // начинаем работать
                GetDataToMemory(0,0);                   // получаем ROM с формы (второй параметр может быть любым)
                TempStr=LowerCase(Form1->Edit4->Text);  // получаем TA1 в строку
                InHexBuf=TempStr.c_str();               // скопировать в буфер байт для передачи (в виде строки)
                HexToBin(InHexBuf,TempBuf,1);           // преобразовать строку в целое (байт)
                DS2431_InputData.TA1=TempBuf[0];        // сохраняем значение TA1
                TempStr=LowerCase(Form1->Edit5->Text);  // получаем TA2 в строку
                InHexBuf=TempStr.c_str();               // скопировать в буфер байт для передачи (в виде строки)
                HexToBin(InHexBuf,TempBuf,1);           // преобразовать строку в целое (байт)
                DS2431_InputData.TA2=TempBuf[0];        // сохраняем значение TA2
                // помещаем данные с формы в память в зависимости от вкладки (для DS2431 Scratchpad находится в Area3)
                switch(Form1->PageControl1->TabIndex)
                { case 0:  GetDataToMemory(5,3);        // передаём данные из RichEdit5 в Scratchpad
                           break;
                  case 1:  GetDataToMemory(6,3);        // передаём данные из RichEdit6 в Scratchpad
                           break;
                  default: break;
                }
                // посылаем данные по 1-Wire и помещаем результат (Test) на форму
                DS2431_InputData.AreaNumber=3;                  // блокнот - это Area3
                DS2431_InputData.Size=SelectedChip.Area3Size;   // размер равен размеру блокнота
                if(Port!=INVALID_HANDLE_VALUE)
                { DS2431_OutputData=DS2431_WriteToScratchpad(DS2431_InputData);
                  if(DS2431_OutputData.Success)
                  { TempBuf[0]=DS2431_OutputData.Test;
                    BinToHex(TempBuf,OutHexBuf,1);      // преобразовать строку в целое (байт)
                    OutHexBuf[2]=0;                     // строка должна заканчиваться нулём
                    Form1->Edit7->Text = OutHexBuf;
                    SendMsgToLogForm(106,"");                // запись в scratchpad успешно завершена
                  }
                  else  SendMsgToLogForm(105,"");            // запись в scratchpad завершена с ошибкой
                }
                else    SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                break;
    case 0x33:  //--------------------------------------------------
                // выбран чип DS2432, нажата кнопка WRITE SCRATCHPAD
                //--------------------------------------------------
                // добавляем нужные переменные
                DS2432_INPUT_DATA DS2432_InputData;     // входные данные для функций DS2432
                DS2432_OUTPUT_DATA DS2432_OutputData;   // выходные данные для функций DS2432
                SendMsgToLogForm(116,"");    // начинаем запись в блокнот
                // начинаем работать
                GetDataToMemory(0,0);                   // получаем ROM с формы (второй параметр может быть любым)
                TempStr=LowerCase(Form1->Edit4->Text);  // получаем TA1 в строку
                InHexBuf=TempStr.c_str();               // скопировать в буфер байт для передачи (в виде строки)
                HexToBin(InHexBuf,TempBuf,1);           // преобразовать строку в целое (байт)
                DS2432_InputData.TA1=TempBuf[0];        // сохраняем значение TA1
                TempStr=LowerCase(Form1->Edit5->Text);  // получаем TA2 в строку
                InHexBuf=TempStr.c_str();               // скопировать в буфер байт для передачи (в виде строки)
                HexToBin(InHexBuf,TempBuf,1);           // преобразовать строку в целое (байт)
                DS2432_InputData.TA2=TempBuf[0];        // сохраняем значение TA2
                // помещаем данные с формы в память в зависимости от вкладки (для DS2432 Scratchpad находится в Area4)
                switch(Form1->PageControl1->TabIndex)
                { case 0:  GetDataToMemory(7,4);        // передаём данные из RichEdit7 в Scratchpad
                           break;
                  case 1:  GetDataToMemory(8,4);        // передаём данные из RichEdit8 в Scratchpad
                           break;
                  default: break;
                }
                // посылаем данные по 1-Wire и помещаем результат (Test) на форму
                DS2432_InputData.AreaNumber=4;                  // блокнот - это Area4
                DS2432_InputData.Size=SelectedChip.Area4Size;   // размер равен размеру блокнота
                if(Port!=INVALID_HANDLE_VALUE)
                { DS2432_OutputData=DS2432_WriteToScratchpad(DS2432_InputData);
                  if(DS2432_OutputData.Success)
                  { TempBuf[0]=DS2432_OutputData.Test;
                    BinToHex(TempBuf,OutHexBuf,1);      // преобразовать строку в целое (байт)
                    OutHexBuf[2]=0;                     // строка должна заканчиваться нулём
                    Form1->Edit7->Text = OutHexBuf;
                    SendMsgToLogForm(106,"");                // запись в scratchpad успешно завершена
                  }
                  else  SendMsgToLogForm(105,"");            // запись в scratchpad завершена с ошибкой
                }
                else    SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                break;
    case 0x3B:  //--------------------------------------------------
                // выбран чип MAX31826, нажата кнопка CONVERT T
                //--------------------------------------------------
                // добавляем нужные переменные
                MAX31826_OUTPUT_DATA MAX31826_OutputData;     // выходные данные для функций MAX31826
                // начинаем работать
                GetDataToMemory(0,0);                   // получаем ROM с формы (второй параметр может быть любым)
                if(Port!=INVALID_HANDLE_VALUE)
                { MAX31826_OutputData = MAX31826_ConvertT();    // запускаем преобразование
                  if(MAX31826_OutputData.Success) SendMsgToLogForm(151,"");       // команда Convert T успешно завершена
                  else                            SendMsgToLogForm(150,"");       // команда Convert T завершена с ошибкой
                }
                else    SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                break;
    case 0x43:  //----------------------------------------------------
                // выбран чип DS28EC20, нажата кнопка WRITE SCRATCHPAD
                //----------------------------------------------------
                // добавляем нужные переменные
                DS28EC20_INPUT_DATA DS28EC20_InputData;     // входные данные для функций DS28EC20
                DS28EC20_OUTPUT_DATA DS28EC20_OutputData;   // выходные данные для функций DS28EC20
                SendMsgToLogForm(116,"");    // начинаем запись в блокнот
                // начинаем работать
                GetDataToMemory(0,0);                   // получаем ROM с формы (второй параметр может быть любым)
                TempStr=LowerCase(Form1->Edit4->Text);  // получаем TA1 в строку
                InHexBuf=TempStr.c_str();               // скопировать в буфер байт для передачи (в виде строки)
                HexToBin(InHexBuf,TempBuf,1);           // преобразовать строку в целое (байт)
                DS28EC20_InputData.TA1=TempBuf[0];        // сохраняем значение TA1
                TempStr=LowerCase(Form1->Edit5->Text);  // получаем TA2 в строку
                InHexBuf=TempStr.c_str();               // скопировать в буфер байт для передачи (в виде строки)
                HexToBin(InHexBuf,TempBuf,1);           // преобразовать строку в целое (байт)
                DS28EC20_InputData.TA2=TempBuf[0];        // сохраняем значение TA2
                // помещаем данные с формы в память в зависимости от вкладки (для DS28EC20 Scratchpad находится в Area4)
                switch(Form1->PageControl1->TabIndex)
                { case 0:  GetDataToMemory(7,4);        // передаём данные из RichEdit7 в Scratchpad
                           break;
                  case 1:  GetDataToMemory(8,4);        // передаём данные из RichEdit8 в Scratchpad
                           break;
                  default: break;
                }
                // посылаем данные по 1-Wire и помещаем результат (Test) на форму
                DS28EC20_InputData.AreaNumber=4;                  // блокнот - это Area4
                DS28EC20_InputData.Size=SelectedChip.Area4Size;   // размер равен размеру блокнота
                if(Port!=INVALID_HANDLE_VALUE)
                { DS28EC20_OutputData=DS28EC20_WriteToScratchpad(DS28EC20_InputData);
                  if(DS28EC20_OutputData.Success)
                  { TempBuf[0]=DS28EC20_OutputData.Test;
                    BinToHex(TempBuf,OutHexBuf,1);      // преобразовать строку в целое (байт)
                    OutHexBuf[2]=0;                     // строка должна заканчиваться нулём
                    Form1->Edit7->Text = OutHexBuf;
                    SendMsgToLogForm(106,"");                // запись в scratchpad успешно завершена
                  }
                  else  SendMsgToLogForm(105,"");            // запись в scratchpad завершена с ошибкой
                }
                else    SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                break;
    default:    break;
  }
}
//---------------------------------------------------------------------------
//--- НАЖАТА КНОПКА BUTTON5 -------------------------------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::Button5Click(TObject *Sender)
{ char TempBuf[1], OutHexBuf[3];        // для преобразования

  switch(SelectedChip.Family)
  { case 0x0:   // выбран один из чипов с перезаписываемым ROM
                switch(SelectedChip.Modify)
                { case 1:  //------------------------------------------
                           // выбран чип RW1990, нажата кнопка READ ROM
                           //------------------------------------------
                           // добавляем нужные переменные
                           RW1990_OUTPUT_DATA RW1990_OutputData;        // выходные данные для функций RW1990
                           SendMsgToLogForm(154,"");                       // начинаем чтение ROM
                           // начинаем работать
                           if(Port!=INVALID_HANDLE_VALUE)
                           { RW1990_OutputData=RW1990_ReadROM();        // читаем ROM
                             if(RW1990_OutputData.Success)
                             {  PlaceDataToForm(0,0);   // помещаем прочитанный ROM на форму (второй параметр может быть любым)
                                SendMsgToLogForm(108,"");  // чтение данных успешно завершено
                             }
                             else SendMsgToLogForm(107,"");  // чтение данных завершено с ошибкой
                           }
                           else    SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                           break;
                  case 2:  //------------------------------------------
                           // выбран чип AN1990, нажата кнопка READ ROM
                  case 3:  //------------------------------------------
                           // выбран чип TM2004, нажата кнопка READ ROM
                           //------------------------------------------
                           // добавляем нужные переменные
                           AN1990_OUTPUT_DATA AN1990_OutputData;        // выходные данные для функций AN1990
                           SendMsgToLogForm(154,"");                       // начинаем чтение ROM
                           // начинаем работать
                           if(Port!=INVALID_HANDLE_VALUE)
                           { AN1990_OutputData=AN1990_ReadROM();        // читаем ROM
                             if(AN1990_OutputData.Success)
                             {  PlaceDataToForm(0,0);   // помещаем прочитанный ROM на форму (второй параметр может быть любым)
                                SendMsgToLogForm(108,"");  // чтение данных успешно завершено
                             }
                             else SendMsgToLogForm(107,"");  // чтение данных завершено с ошибкой
                           }
                           else    SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                           break;
                  default: break;
                }
                break;
    case 0x2:   //--------------------------------------------------
                // выбран чип DS1991, нажата кнопка READ SCRATCHPAD
    case 0x82:  //--------------------------------------------------
                // выбран чип DS1425, нажата кнопка READ SCRATCHPAD
                //--------------------------------------------------
                // добавляем нужные переменные
                DS1991_OUTPUT_DATA DS1991_OutputData; // выходные данные для функций 1W
                SendMsgToLogForm(117,"");    // начинаем чтение блокнота
                // начинаем работать
                GetDataToMemory(0,0);                   // получаем ROM с формы (второй параметр может быть любым)
                if(Port!=INVALID_HANDLE_VALUE)
                { DS1991_OutputData=DS1991_ReadFromScratchpad();      // читаем данные из Scratchpad
                  if(DS1991_OutputData.Success)          // если успешно прочитали
                  { // помещаем данные из памяти на форму
                    switch(Form1->PageControl1->TabIndex)
                    { case 0:  PlaceDataToForm(7,4);      // из Area4 в RichEdit7
                               break;
                      case 1:  PlaceDataToForm(8,4);      // из Area4 в RichEdit8
                               break;
                      default: break;
                    }
                    SendMsgToLogForm(108,"");                // чтение блокнота успешно завершено
                  }
                  SendMsgToLogForm(107,"");                  // чтение блокнота завершено с ошибкой
                }
                else    SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                break;
    case 0x4:   //-------------------------------------------------
                // выбран чип DS1994, нажата кнопка READ SCRATCHPAD
    case 0x84:  //-------------------------------------------------
                // выбран чип DS1427, нажата кнопка READ SCRATCHPAD
                //-------------------------------------------------
                // добавляем нужные переменные
                DS1994_OUTPUT_DATA DS1994_OutputData;   // выходные данные для функций 1W
                SendMsgToLogForm(117,"");    // начинаем чтение блокнота
                // начинаем работать
                GetDataToMemory(0,0);                   // получаем ROM с формы (второй параметр может быть любым)
                if(Port!=INVALID_HANDLE_VALUE)
                { DS1994_OutputData=DS1994_ReadFromScratchpad();  // читаем данные из Scratchpad
                  if(DS1994_OutputData.Success)           // если успешно прочитали
                  { // помещаем на форму Test
                    TempBuf[0]=DS1994_OutputData.Test;
                    BinToHex(TempBuf,OutHexBuf,1);        // преобразовать строку в целое (байт)
                    OutHexBuf[2]=0;                       // строка должна заканчиваться нулём
                    Form1->Edit7->Text = OutHexBuf;
                    // помещаем на форму E/S
                    TempBuf[0]=DS1994_OutputData.ES;
                    BinToHex(TempBuf,OutHexBuf,1);        // преобразовать строку в целое (байт)
                    OutHexBuf[2]=0;                       // строка должна заканчиваться нулём
                    Form1->Edit6->Text = OutHexBuf;
                    // помещаем на форму TA2
                    TempBuf[0]=DS1994_OutputData.TA2;
                    BinToHex(TempBuf,OutHexBuf,1);        // преобразовать строку в целое (байт)
                    OutHexBuf[2]=0;                       // строка должна заканчиваться нулём
                    Form1->Edit5->Text = OutHexBuf;
                    // помещаем на форму TA1
                    TempBuf[0]=DS1994_OutputData.TA1;
                    BinToHex(TempBuf,OutHexBuf,1);        // преобразовать строку в целое (байт)
                    OutHexBuf[2]=0;                       // строка должна заканчиваться нулём
                    Form1->Edit4->Text = OutHexBuf;
                    // помещаем данные из памяти на форму
                    switch(Form1->PageControl1->TabIndex)
                    { case 0:  PlaceDataToForm(5,3);
                               break;
                      case 1:  PlaceDataToForm(6,3);
                               break;
                      default: break;
                    }
                    SendMsgToLogForm(108,"");                // чтение блокнота успешно завершено
                  }
                  else  SendMsgToLogForm(107,"");            // чтение блокнота завершено с ошибкой
                }
                else    SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                break;
    case 0x5:   //----------------------------------------------
                // выбран чип DS2405, нажата кнопка TOGGLE STATE
                //----------------------------------------------
                // добавляем нужные переменные
                DS2405_OUTPUT_DATA DS2405_OutputData; // выходные данные для функций DS2405
                SendMsgToLogForm(138,"");    // начинаем переключение
                // начинаем работать
                GetDataToMemory(0,0);                   // получаем ROM с формы (второй параметр может быть любым)
                // выполняем переключение состояния
                if(Port!=INVALID_HANDLE_VALUE)
                { DS2405_OutputData=DS2405_ToggleState();
                  if(DS2405_OutputData.Success)
                  { TempBuf[0]=DS2405_OutputData.Test;
                    BinToHex(TempBuf,OutHexBuf,1);      // преобразовать строку в целое (байт)
                    OutHexBuf[2]=0;                     // строка должна заканчиваться нулём
                    Form1->Edit4->Text = OutHexBuf;
                    SendMsgToLogForm(139,"");              // переключение успешно завершено
                  }
                  else  SendMsgToLogForm(140,"");  // переключение завершено с ошибкой
                }
                else    SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                break;
    case 0x6:   //-------------------------------------------------
                // выбран чип DS1993, нажата кнопка READ SCRATCHPAD
    case 0x8:   //-------------------------------------------------
                // выбран чип DS1992, нажата кнопка READ SCRATCHPAD
    case 0xA:   //-------------------------------------------------
                // выбран чип DS1995, нажата кнопка READ SCRATCHPAD
    case 0xC:   //-------------------------------------------------
                // выбран чип DS1996, нажата кнопка READ SCRATCHPAD
                //-------------------------------------------------
                // добавляем нужные переменные
                DS1992_OUTPUT_DATA DS1992_OutputData;   // выходные данные для функций 1W
                SendMsgToLogForm(117,"");    // начинаем чтение блокнота
                // начинаем работать
                GetDataToMemory(0,0);                   // получаем ROM с формы (второй параметр может быть любым)
                if(Port!=INVALID_HANDLE_VALUE)
                { DS1992_OutputData=DS1992_ReadFromScratchpad();        // читаем данные из Scratchpad
                  if(DS1992_OutputData.Success)           // если успешно прочитали
                  { // помещаем на форму Test
                    TempBuf[0]=DS1992_OutputData.Test;
                    BinToHex(TempBuf,OutHexBuf,1);        // преобразовать строку в целое (байт)
                    OutHexBuf[2]=0;                       // строка должна заканчиваться нулём
                    Form1->Edit7->Text = OutHexBuf;
                    // помещаем на форму E/S
                    TempBuf[0]=DS1992_OutputData.ES;
                    BinToHex(TempBuf,OutHexBuf,1);        // преобразовать строку в целое (байт)
                    OutHexBuf[2]=0;                       // строка должна заканчиваться нулём
                    Form1->Edit6->Text = OutHexBuf;
                    // помещаем на форму TA2
                    TempBuf[0]=DS1992_OutputData.TA2;
                    BinToHex(TempBuf,OutHexBuf,1);        // преобразовать строку в целое (байт)
                    OutHexBuf[2]=0;                       // строка должна заканчиваться нулём
                    Form1->Edit5->Text = OutHexBuf;
                    // помещаем на форму TA1
                    TempBuf[0]=DS1992_OutputData.TA1;
                    BinToHex(TempBuf,OutHexBuf,1);        // преобразовать строку в целое (байт)
                    OutHexBuf[2]=0;                       // строка должна заканчиваться нулём
                    Form1->Edit4->Text = OutHexBuf;
                    // помещаем данные из памяти на форму
                    switch(Form1->PageControl1->TabIndex)
                    { case 0:  PlaceDataToForm(3,2);
                               break;
                      case 1:  PlaceDataToForm(4,2);
                               break;
                      default: break;
                    }
                    SendMsgToLogForm(108,"");                // чтение блокнота успешно завершено
                  }
                  else SendMsgToLogForm(107,"");       // чтение блокнота завершено с ошибкой
                }
                else    SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                break;
    case 0x9:   //----------------------------------------------------
                // выбран чип DS2502 / DS1982, нажата кнопка READ DATA
                //----------------------------------------------------
                // добавляем нужные переменные
                DS2502_OUTPUT_DATA DS2502_OutputData;   // выходные данные для функций 1W
                SendMsgToLogForm(124,"");    // начинаем чтение EPROM
                // начинаем работать
                GetDataToMemory(0,0);                   // получаем ROM с формы (второй параметр может быть любым)
                if(Port!=INVALID_HANDLE_VALUE)
                { DS2502_OutputData=DS2502_ReadFromMemory();  // читаем данные из Scratchpad
                  if(DS2502_OutputData.Success)           // если успешно прочитали
                  { // помещаем на форму Test
                    TempBuf[0]=DS2502_OutputData.Test;
                    BinToHex(TempBuf,OutHexBuf,1);        // преобразовать строку в целое (байт)
                    OutHexBuf[2]=0;                       // строка должна заканчиваться нулём
                    Form1->Edit7->Text = OutHexBuf;
                    // помещаем данные из памяти на форму
                    switch(Form1->PageControl1->TabIndex)
                    { case 0:  PlaceDataToForm(1,1);
                               break;
                      case 1:  PlaceDataToForm(2,1);
                               break;
                      default: break;
                    }
                    SendMsgToLogForm(108,"");                // чтение успешно завершено
                  }
                  else  SendMsgToLogForm(107,"");            // чтение завершено с ошибкой
                }
                else    SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                break;
    case 0xD:   //--------------------------------------------
                // выбран чип DS28E05, нажата кнопка READ DATA
                //--------------------------------------------
                // добавляем нужные переменные
                DS28E05_INPUT_DATA DS28E05_InputData;     // входные данные для функций 1W
                DS28E05_OUTPUT_DATA DS28E05_OutputData;   // выходные данные для функций 1W
                SendMsgToLogForm(143,"");    // начинаем чтение данных
                // начинаем работать
                GetDataToMemory(0,0);                   // получаем ROM с формы (второй параметр может быть любым)
                if(Port!=INVALID_HANDLE_VALUE)
                { DS28E05_InputData.AreaNumber=1;                       // читаем в область 1
                  DS28E05_InputData.Size=SelectedChip.Area1Size;        // размер равен размеру области 1
                  DS28E05_InputData.TA1=SelectedChip.Area1Start;        // младший байт начального адреса области
                  DS28E05_InputData.TA2=SelectedChip.Area1Start>>8;     // старший байт начального адреса области
                  DS28E05_OutputData=DS28E05_ReadFromMemory(DS28E05_InputData); // читаем данные из памяти
                  if(DS28E05_OutputData.Success)           // если успешно прочитали
                  { // помещаем на форму Test
                    TempBuf[0]=DS28E05_OutputData.Test;
                    BinToHex(TempBuf,OutHexBuf,1);        // преобразовать строку в целое (байт)
                    OutHexBuf[2]=0;                       // строка должна заканчиваться нулём
                    Form1->Edit7->Text = OutHexBuf;
                    // помещаем данные из памяти на форму
                    switch(Form1->PageControl1->TabIndex)
                    { case 0:  PlaceDataToForm(1,1);
                               break;
                      case 1:  PlaceDataToForm(2,1);
                               break;
                      default: break;
                    }
                    SendMsgToLogForm(108,"");                // чтение данных успешно завершено
                  }
                  else SendMsgToLogForm(107,"");       // чтение данных завершено с ошибкой
                }
                else    SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                break;
    case 0x10:  //--------------------------------------------------
                // выбран чип DS18S20, нажата кнопка READ SCRATCHPAD
                //--------------------------------------------------
                // добавляем нужные переменные
                DS18S20_OUTPUT_DATA DS18S20_OutputData; // выходные данные для функций 1W
                SendMsgToLogForm(117,"");    // начинаем чтение блокнота
                // начинаем работать
                GetDataToMemory(0,0);                   // получаем ROM с формы (второй параметр может быть любым)
                if(Port!=INVALID_HANDLE_VALUE)
                { DS18S20_OutputData=DS18S20_ReadFromScratchpad();      // читаем данные из Scratchpad
                  if(DS18S20_OutputData.Success)          // если успешно прочитали
                  { // выводим в ричэдит расшифрованный конфиг и вычисленные пороги
                    DS18S20_DecodeThresholds();
                    // помещаем данные из памяти на форму
                    switch(Form1->PageControl1->TabIndex)
                    { case 0:  PlaceDataToForm(1,1);      // из Area1 в RichEdit1
                               break;
                      case 1:  PlaceDataToForm(2,1);      // из Area1 в RichEdit2
                               break;
                      default: break;
                    }
                    SendMsgToLogForm(108,"");                // чтение блокнота успешно завершено
                  }
                  SendMsgToLogForm(107,"");                  // чтение блокнота завершено с ошибкой
                }
                else    SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                break;
    case 0x14:  //--------------------------------------------------
                // выбран чип DS2430A, нажата кнопка READ SCRATCHPAD
                //--------------------------------------------------
                // добавляем нужные переменные
                DS2430_OUTPUT_DATA DS2430_OutputData;   // выходные данные для функций 1W
                SendMsgToLogForm(117,"");    // начинаем чтение блокнота
                // начинаем работать
                GetDataToMemory(0,0);                   // получаем ROM с формы (второй параметр может быть любым)
                if(Port!=INVALID_HANDLE_VALUE)
                {  DS2430_OutputData=DS2430_ReadFromScratchpad();  // читаем данные из Data Scratchpad
                   if(DS2430_OutputData.Success)           // если успешно прочитали
                   { // помещаем данные из памяти на форму
                     switch(Form1->PageControl1->TabIndex)
                     { case 0:  PlaceDataToForm(1,2);
                                break;
                       case 1:  PlaceDataToForm(2,2);
                                break;
                       default: break;
                     }
                     SendMsgToLogForm(108,"");               // чтение блокнота успешно завершено
                   }
                   else SendMsgToLogForm(107,"");            // чтение блокнота завершено с ошибкой
                }
                else    SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                break;
    case 0x1A:  //--------------------------------------------------
                // выбран чип DS1963L, нажата кнопка READ SCRATCHPAD
    case 0x1D:  //--------------------------------------------------
                // выбран чип DS2423, нажата кнопка READ SCRATCHPAD
                //--------------------------------------------------
                // добавляем нужные переменные
                DS1963L_OUTPUT_DATA DS1963L_OutputData;   // выходные данные для функций 1W
                SendMsgToLogForm(117,"");    // начинаем чтение блокнота
                // начинаем работать
                GetDataToMemory(0,0);                   // получаем ROM с формы (второй параметр может быть любым)
                if(Port!=INVALID_HANDLE_VALUE)
                { DS1963L_OutputData=DS1963L_ReadFromScratchpad();        // читаем данные из Scratchpad
                  if(DS1963L_OutputData.Success)           // если успешно прочитали
                  { // помещаем на форму Test
                    TempBuf[0]=DS1963L_OutputData.Test;
                    BinToHex(TempBuf,OutHexBuf,1);        // преобразовать строку в целое (байт)
                    OutHexBuf[2]=0;                       // строка должна заканчиваться нулём
                    Form1->Edit7->Text = OutHexBuf;
                    // помещаем на форму E/S
                    TempBuf[0]=DS1963L_OutputData.ES;
                    BinToHex(TempBuf,OutHexBuf,1);        // преобразовать строку в целое (байт)
                    OutHexBuf[2]=0;                       // строка должна заканчиваться нулём
                    Form1->Edit6->Text = OutHexBuf;
                    // помещаем на форму TA2
                    TempBuf[0]=DS1963L_OutputData.TA2;
                    BinToHex(TempBuf,OutHexBuf,1);        // преобразовать строку в целое (байт)
                    OutHexBuf[2]=0;                       // строка должна заканчиваться нулём
                    Form1->Edit5->Text = OutHexBuf;
                    // помещаем на форму TA1
                    TempBuf[0]=DS1963L_OutputData.TA1;
                    BinToHex(TempBuf,OutHexBuf,1);        // преобразовать строку в целое (байт)
                    OutHexBuf[2]=0;                       // строка должна заканчиваться нулём
                    Form1->Edit4->Text = OutHexBuf;
                    // помещаем данные из памяти на форму
                    switch(Form1->PageControl1->TabIndex)
                    { case 0:  PlaceDataToForm(3,2);
                               break;
                      case 1:  PlaceDataToForm(4,2);
                               break;
                      default: break;
                    }
                    SendMsgToLogForm(108,"");                // чтение блокнота успешно завершено
                  }
                  else SendMsgToLogForm(107,"");       // чтение блокнота завершено с ошибкой
                }
                else    SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                break;
    case 0x23:  //--------------------------------------------------
                // выбран чип DS24B33, нажата кнопка READ SCRATCHPAD
                //--------------------------------------------------
                // добавляем нужные переменные
                DS24B33_OUTPUT_DATA DS24B33_OutputData;   // выходные данные для функций 1W
                SendMsgToLogForm(117,"");    // начинаем чтение блокнота
                // начинаем работать
                GetDataToMemory(0,0);                   // получаем ROM с формы (второй параметр может быть любым)
                if(Port!=INVALID_HANDLE_VALUE)
                { DS24B33_OutputData=DS24B33_ReadFromScratchpad();        // читаем данные из Scratchpad
                  if(DS24B33_OutputData.Success)           // если успешно прочитали
                  { // помещаем на форму Test
                    TempBuf[0]=DS24B33_OutputData.Test;
                    BinToHex(TempBuf,OutHexBuf,1);        // преобразовать строку в целое (байт)
                    OutHexBuf[2]=0;                       // строка должна заканчиваться нулём
                    Form1->Edit7->Text = OutHexBuf;
                    // помещаем на форму E/S
                    TempBuf[0]=DS24B33_OutputData.ES;
                    BinToHex(TempBuf,OutHexBuf,1);        // преобразовать строку в целое (байт)
                    OutHexBuf[2]=0;                       // строка должна заканчиваться нулём
                    Form1->Edit6->Text = OutHexBuf;
                    // помещаем на форму TA2
                    TempBuf[0]=DS24B33_OutputData.TA2;
                    BinToHex(TempBuf,OutHexBuf,1);        // преобразовать строку в целое (байт)
                    OutHexBuf[2]=0;                       // строка должна заканчиваться нулём
                    Form1->Edit5->Text = OutHexBuf;
                    // помещаем на форму TA1
                    TempBuf[0]=DS24B33_OutputData.TA1;
                    BinToHex(TempBuf,OutHexBuf,1);        // преобразовать строку в целое (байт)
                    OutHexBuf[2]=0;                       // строка должна заканчиваться нулём
                    Form1->Edit4->Text = OutHexBuf;
                    // помещаем данные из памяти на форму
                    switch(Form1->PageControl1->TabIndex)
                    { case 0:  PlaceDataToForm(3,2);
                               break;
                      case 1:  PlaceDataToForm(4,2);
                               break;
                      default: break;
                    }
                    SendMsgToLogForm(108,"");                // чтение блокнота успешно завершено
                  }
                  else SendMsgToLogForm(107,"");       // чтение блокнота завершено с ошибкой
                }
                else    SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                break;
    case 0x24:  //--------------------------------------------
                // выбран чип DS2415, нажата кнопка READ CLOCK
    case 0x27:  //--------------------------------------------
                // выбран чип DS2417, нажата кнопка READ CLOCK
                //--------------------------------------------
                // добавляем нужные переменные
                DS2415_OUTPUT_DATA DS2415_OutputData; // выходные данные для функций 1W
                SendMsgToLogForm(143,"");    // начинаем чтение данных
                // начинаем работать
                GetDataToMemory(0,0);                   // получаем ROM с формы (второй параметр может быть любым)
                if(Port!=INVALID_HANDLE_VALUE)
                { DS2415_OutputData=DS2415_ReadClock();      // читаем данные
                  if(DS2415_OutputData.Success)          // если успешно прочитали
                  { // помещаем данные из памяти на форму
                    switch(Form1->PageControl1->TabIndex)
                    { case 0:  PlaceDataToForm(1,1);      // из Area1 в RichEdit1
                               break;
                      case 1:  PlaceDataToForm(2,1);      // из Area1 в RichEdit2
                               break;
                      default: break;
                    }
                    SendMsgToLogForm(108,"");                // чтение данных успешно завершено
                  }
                  SendMsgToLogForm(107,"");                  // чтение данных завершено с ошибкой
                }
                else    SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                break;
    case 0x22:  //--------------------------------------------------
                // выбран чип DS1822, нажата кнопка READ SCRATCHPAD
    case 0x28:  //--------------------------------------------------
                // выбран чип DS18B20, нажата кнопка READ SCRATCHPAD
                //--------------------------------------------------
                // добавляем нужные переменные
                DS18B20_OUTPUT_DATA DS18B20_OutputData; // выходные данные для функций 1W
                SendMsgToLogForm(117,"");    // начинаем чтение блокнота
                // начинаем работать
                GetDataToMemory(0,0);                   // получаем ROM с формы (второй параметр может быть любым)
                if(Port!=INVALID_HANDLE_VALUE)
                { DS18B20_OutputData=DS18B20_ReadFromScratchpad();        // читаем данные из Scratchpad
                  if(DS18B20_OutputData.Success)          // если успешно прочитали
                  { // выводим в ричэдит расшифрованный конфиг и вычисленные пороги
                    DS18B20_DecodeConfigAndThresholds();
                    // помещаем данные из памяти на форму
                    switch(Form1->PageControl1->TabIndex)
                    { case 0:  PlaceDataToForm(1,1);      // из Area1 в RichEdit1
                               break;
                      case 1:  PlaceDataToForm(2,1);      // из Area1 в RichEdit2
                               break;
                      default: break;
                    }
                    SendMsgToLogForm(108,"");                // чтение блокнота успешно завершено
                  }
                  else SendMsgToLogForm(107,"");             // чтение блокнота завершено с ошибкой
                }
                else    SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                break;
    case 0x2C:  //-----------------------------------------------
                // выбран чип DS2890, нажата кнопка READ POSITION
                //-----------------------------------------------
                // добавляем нужные переменные
                DS2890_OUTPUT_DATA DS2890_OutputData;   // выходные данные для функций 1W
                SendMsgToLogForm(143,"");    // начинаем чтение данных
                // начинаем работать
                GetDataToMemory(0,0);                   // получаем ROM с формы (второй параметр может быть любым)
                if(Port!=INVALID_HANDLE_VALUE)
                { DS2890_OutputData=DS2890_ReadPosition();  // читаем данные
                  if(DS2890_OutputData.Success)           // если успешно прочитали
                  { // помещаем на форму Position
                    TempBuf[0]=DS2890_OutputData.Position;
                    BinToHex(TempBuf,OutHexBuf,1);        // преобразовать строку в целое (байт)
                    OutHexBuf[2]=0;                       // строка должна заканчиваться нулём
                    Form1->Edit4->Text = OutHexBuf;
                    // помещаем на форму Control
                    TempBuf[0]=DS2890_OutputData.Control;
                    BinToHex(TempBuf,OutHexBuf,1);        // преобразовать строку в целое (байт)
                    OutHexBuf[2]=0;                       // строка должна заканчиваться нулём
                    Form1->Edit5->Text = OutHexBuf;
                    SendMsgToLogForm(108,"");                // чтение блокнота успешно завершено
                  }
                  else  SendMsgToLogForm(107,"");            // чтение блокнота завершено с ошибкой
                }
                else    SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                break;
    case 0x2D:  //-------------------------------------------------
                // выбран чип DS2431, нажата кнопка READ SCRATCHPAD
                //-------------------------------------------------
                // добавляем нужные переменные
                DS2431_OUTPUT_DATA DS2431_OutputData;   // выходные данные для функций 1W
                SendMsgToLogForm(117,"");    // начинаем чтение блокнота
                // начинаем работать
                GetDataToMemory(0,0);                   // получаем ROM с формы (второй параметр может быть любым)
                if(Port!=INVALID_HANDLE_VALUE)
                { DS2431_OutputData=DS2431_ReadFromScratchpad();  // читаем данные из Scratchpad
                  if(DS2431_OutputData.Success)           // если успешно прочитали
                  { // помещаем на форму Test
                    TempBuf[0]=DS2431_OutputData.Test;
                    BinToHex(TempBuf,OutHexBuf,1);        // преобразовать строку в целое (байт)
                    OutHexBuf[2]=0;                       // строка должна заканчиваться нулём
                    Form1->Edit7->Text = OutHexBuf;
                    // помещаем на форму E/S
                    TempBuf[0]=DS2431_OutputData.ES;
                    BinToHex(TempBuf,OutHexBuf,1);        // преобразовать строку в целое (байт)
                    OutHexBuf[2]=0;                       // строка должна заканчиваться нулём
                    Form1->Edit6->Text = OutHexBuf;
                    // помещаем на форму TA2
                    TempBuf[0]=DS2431_OutputData.TA2;
                    BinToHex(TempBuf,OutHexBuf,1);        // преобразовать строку в целое (байт)
                    OutHexBuf[2]=0;                       // строка должна заканчиваться нулём
                    Form1->Edit5->Text = OutHexBuf;
                    // помещаем на форму TA1
                    TempBuf[0]=DS2431_OutputData.TA1;
                    BinToHex(TempBuf,OutHexBuf,1);        // преобразовать строку в целое (байт)
                    OutHexBuf[2]=0;                       // строка должна заканчиваться нулём
                    Form1->Edit4->Text = OutHexBuf;
                    // помещаем данные из памяти на форму
                    switch(Form1->PageControl1->TabIndex)
                    { case 0:  PlaceDataToForm(5,3);
                               break;
                      case 1:  PlaceDataToForm(6,3);
                               break;
                      default: break;
                    }
                    SendMsgToLogForm(108,"");                // чтение блокнота успешно завершено
                  }
                  else  SendMsgToLogForm(107,"");            // чтение блокнота завершено с ошибкой
                }
                else    SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                break;
    case 0x33:  //-------------------------------------------------
                // выбран чип DS2432, нажата кнопка READ SCRATCHPAD
                //-------------------------------------------------
                // добавляем нужные переменные
                DS2432_OUTPUT_DATA DS2432_OutputData;   // выходные данные для функций 1W
                SendMsgToLogForm(117,"");    // начинаем чтение блокнота
                // начинаем работать
                GetDataToMemory(0,0);                   // получаем ROM с формы (второй параметр может быть любым)
                if(Port!=INVALID_HANDLE_VALUE)
                { DS2432_OutputData=DS2432_ReadFromScratchpad();  // читаем данные из Scratchpad
                  if(DS2432_OutputData.Success)           // если успешно прочитали
                  { // помещаем на форму Test
                    TempBuf[0]=DS2432_OutputData.Test;
                    BinToHex(TempBuf,OutHexBuf,1);        // преобразовать строку в целое (байт)
                    OutHexBuf[2]=0;                       // строка должна заканчиваться нулём
                    Form1->Edit7->Text = OutHexBuf;
                    // помещаем на форму E/S
                    TempBuf[0]=DS2432_OutputData.ES;
                    BinToHex(TempBuf,OutHexBuf,1);        // преобразовать строку в целое (байт)
                    OutHexBuf[2]=0;                       // строка должна заканчиваться нулём
                    Form1->Edit6->Text = OutHexBuf;
                    // помещаем на форму TA2
                    TempBuf[0]=DS2432_OutputData.TA2;
                    BinToHex(TempBuf,OutHexBuf,1);        // преобразовать строку в целое (байт)
                    OutHexBuf[2]=0;                       // строка должна заканчиваться нулём
                    Form1->Edit5->Text = OutHexBuf;
                    // помещаем на форму TA1
                    TempBuf[0]=DS2432_OutputData.TA1;
                    BinToHex(TempBuf,OutHexBuf,1);        // преобразовать строку в целое (байт)
                    OutHexBuf[2]=0;                       // строка должна заканчиваться нулём
                    Form1->Edit4->Text = OutHexBuf;
                    // помещаем данные из памяти на форму
                    switch(Form1->PageControl1->TabIndex)
                    { case 0:  PlaceDataToForm(7,4);
                               break;
                      case 1:  PlaceDataToForm(8,4);
                               break;
                      default: break;
                    }
                    SendMsgToLogForm(108,"");                // чтение блокнота успешно завершено
                  }
                  else  SendMsgToLogForm(107,"");            // чтение блокнота завершено с ошибкой
                }
                else    SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                break;
    case 0x3B:  //-----------------------------------------------------
                // выбран чип MAX31826, нажата кнопка Read Scratchpad 1
                //-----------------------------------------------------
                // добавляем нужные переменные
                MAX31826_OUTPUT_DATA MAX31826_OutputData;   // выходные данные для функций 1W
                MAX31826_INPUT_DATA MAX31826_InputData;     // входные данные для функций 1W
                float MAX31826_TempValue;                   // температура
                // начинаем работать
                GetDataToMemory(0,0);                       // получаем ROM с формы (второй параметр может быть любым)
                if(Port!=INVALID_HANDLE_VALUE)
                { SendMsgToLogForm(117,"Scratchpad 1");                                   // начинаем чтение блокнота
                  MAX31826_InputData.AreaNumber = 3;
                  MAX31826_OutputData = MAX31826_ReadFromScratchpad(MAX31826_InputData);  // читаем данные из Scratchpad 1
                  if(MAX31826_OutputData.Success)           // если успешно прочитали
                  { // помещаем данные из памяти на форму
                    switch(Form1->PageControl1->TabIndex)
                    { case 0:  PlaceDataToForm(5,3);
                               break;
                      case 1:  PlaceDataToForm(6,3);
                               break;
                      default: break;
                    }
                    SendMsgToLogForm(108,"Scratchpad 1");                // чтение блокнота успешно завершено
                    MAX31826_TempValue = MAX31826_DecodeTemperature();
                    Form1->Edit7->Text = FloatToStrF(MAX31826_TempValue, ffFixed, 7, 7);      // выводим температуру в Edit4
                  }
                  else  SendMsgToLogForm(107,"Scratchpad 1");            // чтение блокнота завершено с ошибкой
                }
                else    SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                break;
    case 0x43:  //-------------------------------------------------
                // выбран чип DS28EC20, нажата кнопка READ SCRATCHPAD
                //-------------------------------------------------
                // добавляем нужные переменные
                DS28EC20_OUTPUT_DATA DS28EC20_OutputData;   // выходные данные для функций 1W
                SendMsgToLogForm(117,"");    // начинаем чтение блокнота
                // начинаем работать
                GetDataToMemory(0,0);                   // получаем ROM с формы (второй параметр может быть любым)
                if(Port!=INVALID_HANDLE_VALUE)
                { DS28EC20_OutputData=DS28EC20_ReadFromScratchpad();  // читаем данные из Scratchpad
                  if(DS28EC20_OutputData.Success)           // если успешно прочитали
                  { // помещаем на форму Test
                    TempBuf[0]=DS28EC20_OutputData.Test;
                    BinToHex(TempBuf,OutHexBuf,1);        // преобразовать строку в целое (байт)
                    OutHexBuf[2]=0;                       // строка должна заканчиваться нулём
                    Form1->Edit7->Text = OutHexBuf;
                    // помещаем на форму E/S
                    TempBuf[0]=DS28EC20_OutputData.ES;
                    BinToHex(TempBuf,OutHexBuf,1);        // преобразовать строку в целое (байт)
                    OutHexBuf[2]=0;                       // строка должна заканчиваться нулём
                    Form1->Edit6->Text = OutHexBuf;
                    // помещаем на форму TA2
                    TempBuf[0]=DS28EC20_OutputData.TA2;
                    BinToHex(TempBuf,OutHexBuf,1);        // преобразовать строку в целое (байт)
                    OutHexBuf[2]=0;                       // строка должна заканчиваться нулём
                    Form1->Edit5->Text = OutHexBuf;
                    // помещаем на форму TA1
                    TempBuf[0]=DS28EC20_OutputData.TA1;
                    BinToHex(TempBuf,OutHexBuf,1);        // преобразовать строку в целое (байт)
                    OutHexBuf[2]=0;                       // строка должна заканчиваться нулём
                    Form1->Edit4->Text = OutHexBuf;
                    // помещаем данные из памяти на форму
                    switch(Form1->PageControl1->TabIndex)
                    { case 0:  PlaceDataToForm(7,4);
                               break;
                      case 1:  PlaceDataToForm(8,4);
                               break;
                      default: break;
                    }
                    SendMsgToLogForm(108,"");                // чтение блокнота успешно завершено
                  }
                  else  SendMsgToLogForm(107,"");            // чтение блокнота завершено с ошибкой
                }
                else    SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                break;
    default:    break;
  }
}
//---------------------------------------------------------------------------
//--- НАЖАТА КНОПКА BUTTON6 -------------------------------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::Button6Click(TObject *Sender)
{ AnsiString TempStr;                           // для преобразования
  char *InHexBuf, TempBuf[1], OutHexBuf[3];     // для преобразования

  switch(SelectedChip.Family)
  { case 0x0:   // выбран один из чипов с перезаписываемым ROM
                switch(SelectedChip.Modify)
                { case 2:  //-------------------------------------------
                           // выбран чип AN1990, нажата кнопка BLOCK ROM
                  case 3:  //-------------------------------------------
                           // выбран чип TM2004, нажата кнопка BLOCK ROM
                           //-------------------------------------------
                           // добавляем нужные переменные
                           AN1990_OUTPUT_DATA AN1990_OutputData;        // выходные данные для функций AN1990
                           SendMsgToLogForm(157, Form1->Edit3->Text);   // начинаем блокировку ROM
                           // начинаем работать
                           GetDataToMemory(0,0);                        // получаем ROM с формы (второй параметр может быть любым)
                           if(Port!=INVALID_HANDLE_VALUE)
                           { AN1990_OutputData=AN1990_BlockROM();       // пишем новый ROM
                             if(AN1990_OutputData.Success)      SendMsgToLogForm(159,"");  // блокировка успешно завершена
                             else                               SendMsgToLogForm(158,"");  // блокировка завершена с ошибкой
                           }
                           else    SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                           break;
                  case 1:  // выбран чип RW1990
                  default: break;
                }
                break;
    case 0x2:   //------------------------------------------------------------
                // выбран чип DS1991, нажата кнопка COPY SCRATCHPAD TO MEMORY
    case 0x82:  //------------------------------------------------------------
                // выбран чип DS1425, нажата кнопка COPY SCRATCHPAD TO MEMORY
                //------------------------------------------------------------
                // добавляем нужные переменные
                DS1991_OUTPUT_DATA DS1991_OutputData; // выходные данные для функций DS1991
                DS1991_INPUT_DATA DS1991_InputData;   // входные данные для функций DS1991
                unsigned char DS1991_Done;            // счётчик количества копирований
                SendMsgToLogForm(118,"");    // начинаем копирование блокнота в EEPROM
                // начинаем работать
                DS1991_Done=0;                        // ни одна область пока не скопирована
                GetDataToMemory(0,0);                   // получаем ROM с формы (второй параметр может быть любым)
                for(unsigned int DS1991_i=0; DS1991_i<3; DS1991_i++)
                { DS1991_InputData.AreaNumber=0;        // признак того, что никуда копировать не нужно
                  switch(DS1991_i)
                  { case 0: if(Form1->CheckBox1->Checked==true) DS1991_InputData.AreaNumber=1;  // проверяем, нужно ли копировать в subkey1
                            break;
                    case 1: if(Form1->CheckBox2->Checked==true) DS1991_InputData.AreaNumber=2;  // проверяем, нужно ли копировать в subkey2
                            break;
                    case 2: if(Form1->CheckBox3->Checked==true) DS1991_InputData.AreaNumber=3;  // проверяем, нужно ли копировать в subkey3
                            break;
                    default: break;
                  }
                  if(DS1991_InputData.AreaNumber!=0)    // если нужно копировать
                  { if(Port!=INVALID_HANDLE_VALUE)
                    { DS1991_OutputData=DS1991_CopyScratchpadToMemory(DS1991_InputData);  // посылаем команду Copy to Scratchpad
                      if(DS1991_OutputData.Success)         SendMsgToLogForm(110,"");        // копирование из блокнота в EEPROM успешно завершено
                      else                                  SendMsgToLogForm(109,"");        // во время копирование из блокнота в EEPROM произошла ошибка
                    }
                    else    SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                    DS1991_Done+=1;           // увеличиваем количество попыток копирования
                  }
                }
                if(DS1991_Done==0)      SendMsgToLogForm(133,"");  // не выбрана ни одна область, для которой нужно выполнить действие
                break;
    case 0x4:   //-----------------------------------------------------------
                // выбран чип DS1994, нажата кнопка COPY SCRATCHPAD TO MEMORY
    case 0x84:  //-----------------------------------------------------------
                // выбран чип DS1427, нажата кнопка COPY SCRATCHPAD TO MEMORY
                //-----------------------------------------------------------
                // добавляем нужные переменные
                DS1994_OUTPUT_DATA DS1994_OutputData;   // выходные данные для функций DS1994
                DS1994_INPUT_DATA DS1994_InputData;     // входные данные для функций DS1994
                SendMsgToLogForm(118,"");    // начинаем копирование блокнота в EEPROM
                // начинаем работать
                TempStr=LowerCase(Form1->Edit4->Text);  // получаем TA1 в строку
                InHexBuf=TempStr.c_str();               // скопировать в буфер байт для передачи (в виде строки)
                HexToBin(InHexBuf,TempBuf,1);           // преобразовать строку в целое (байт)
                DS1994_InputData.TA1=TempBuf[0];        // сохраняем значение TA1
                TempStr=LowerCase(Form1->Edit5->Text);  // получаем TA2 в строку
                InHexBuf=TempStr.c_str();               // скопировать в буфер байт для передачи (в виде строки)
                HexToBin(InHexBuf,TempBuf,1);           // преобразовать строку в целое (байт)
                DS1994_InputData.TA2=TempBuf[0];        // сохраняем значение TA2
                TempStr=LowerCase(Form1->Edit6->Text);  // получаем ES в строку
                InHexBuf=TempStr.c_str();               // скопировать в буфер байт для передачи (в виде строки)
                HexToBin(InHexBuf,TempBuf,1);           // преобразовать строку в целое (байт)
                DS1994_InputData.ES=TempBuf[0];         // сохраняем значение ES
                // посылаем команду Copy to Scratchpad
                GetDataToMemory(0,0);                   // получаем ROM с формы (второй параметр может быть любым)
                if(Port!=INVALID_HANDLE_VALUE)  DS1994_OutputData=DS1994_CopyScratchpadToMemory(DS1994_InputData);
                else    // если порт закрыт - отправляем мессадж и выходим
                { SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                  return;
                }
                // если нужно - выполняем копирование ещё два раза
                if(Form1->CheckBox4->Checked==true)
                { DS1994_InputData.ES |= 0x80;  // устанавливаем бит AA (7-й)
                  // выполняем первое дополнительное копирование
                  if(Port!=INVALID_HANDLE_VALUE)  DS1994_OutputData=DS1994_CopyScratchpadToMemory(DS1994_InputData);
                  else  // если порт закрыт - отправляем мессадж и выходим
                  { SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                    return;
                  }
                  // выполняем второе дополнительное копирование
                  if(Port!=INVALID_HANDLE_VALUE)  DS1994_OutputData=DS1994_CopyScratchpadToMemory(DS1994_InputData);
                  else  // если порт закрыт - отправляем мессадж и выходим
                  { SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                    return;
                  }
                }
                if(DS1994_OutputData.Success) SendMsgToLogForm(110,"");    // копирование из блокнота в EEPROM успешно завершено
                else                          SendMsgToLogForm(109,"");    // во время копирование из блокнота в EEPROM произошла ошибка
                break;
    case 0x6:   //-----------------------------------------------------------
                // выбран чип DS1993, нажата кнопка COPY SCRATCHPAD TO MEMORY
    case 0x8:   //-----------------------------------------------------------
                // выбран чип DS1992, нажата кнопка COPY SCRATCHPAD TO MEMORY
    case 0xA:   //-----------------------------------------------------------
                // выбран чип DS1995, нажата кнопка COPY SCRATCHPAD TO MEMORY
    case 0xC:   //-----------------------------------------------------------
                // выбран чип DS1996, нажата кнопка COPY SCRATCHPAD TO MEMORY
                //-----------------------------------------------------------
                // добавляем нужные переменные
                DS1992_INPUT_DATA DS1992_InputData;   // входные данные для функций DS1992
                DS1992_OUTPUT_DATA DS1992_OutputData; // выходные данные для функций DS1992
                SendMsgToLogForm(118,"");    // начинаем копирование блокнота в EEPROM
                // начинаем работать
                TempStr=LowerCase(Form1->Edit4->Text);  // получаем TA1 в строку
                InHexBuf=TempStr.c_str();               // скопировать в буфер байт для передачи (в виде строки)
                HexToBin(InHexBuf,TempBuf,1);           // преобразовать строку в целое (байт)
                DS1992_InputData.TA1=TempBuf[0];        // сохраняем значение TA1
                TempStr=LowerCase(Form1->Edit5->Text);  // получаем TA2 в строку
                InHexBuf=TempStr.c_str();               // скопировать в буфер байт для передачи (в виде строки)
                HexToBin(InHexBuf,TempBuf,1);           // преобразовать строку в целое (байт)
                DS1992_InputData.TA2=TempBuf[0];        // сохраняем значение TA2
                TempStr=LowerCase(Form1->Edit6->Text);  // получаем ES в строку
                InHexBuf=TempStr.c_str();               // скопировать в буфер байт для передачи (в виде строки)
                HexToBin(InHexBuf,TempBuf,1);           // преобразовать строку в целое (байт)
                DS1992_InputData.ES=TempBuf[0];         // сохраняем значение ES
                // посылаем команду Copy to Scratchpad и помещаем результат (Test) на форму
                GetDataToMemory(0,0);                   // получаем ROM с формы (второй параметр может быть любым)
                if(Port!=INVALID_HANDLE_VALUE)
                {  DS1992_OutputData=DS1992_CopyScratchpadToMemory(DS1992_InputData);
                   if(DS1992_OutputData.Success)
                   { // помещаем Test на форму
                     TempBuf[0]=DS1992_OutputData.Test;
                     BinToHex(TempBuf,OutHexBuf,1);        // преобразовать строку в целое (байт)
                     OutHexBuf[2]=0;                       // строка должна заканчиваться нулём
                     Form1->Edit7->Text = OutHexBuf;
                     SendMsgToLogForm(110,"");    // копирование из блокнота в EEPROM успешно завершено
                   }
                   else    SendMsgToLogForm(109,"");    // во время копирование из блокнота в EEPROM произошла ошибка
                }
                else    SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                break;
    case 0x9:   //--------------------------------------------------------------
                // выбран чип DS2502 / DS1982, нажата кнопка READ DATA WITH CRC8
                //--------------------------------------------------------------
                // добавляем нужные переменные
                DS2502_OUTPUT_DATA DS2502_OutputData;   // выходные данные для функций 1W
                SendMsgToLogForm(124,"");    // начинаем чтение EPROM
                // начинаем работать
                GetDataToMemory(0,0);                   // получаем ROM с формы (второй параметр может быть любым)
                if(Port!=INVALID_HANDLE_VALUE)
                { DS2502_OutputData=DS2502_ReadFromMemoryCRC8();  // читаем данные из EPROM с постраничной генерацией CRC8
                  if(DS2502_OutputData.Success)           // если успешно прочитали
                  { // помещаем на форму Test
                    TempBuf[0]=DS2502_OutputData.Test;
                    BinToHex(TempBuf,OutHexBuf,1);        // преобразовать строку в целое (байт)
                    OutHexBuf[2]=0;                       // строка должна заканчиваться нулём
                    Form1->Edit7->Text = OutHexBuf;
                    // помещаем данные из памяти на форму
                    switch(Form1->PageControl1->TabIndex)
                    { case 0:  PlaceDataToForm(1,1);
                               break;
                      case 1:  PlaceDataToForm(2,1);
                               break;
                      default: break;
                    }
                    SendMsgToLogForm(108,"");                // чтение успешно завершено
                  }
                  else  SendMsgToLogForm(107,"");            // чтение завершено с ошибкой
                }
                else    SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                break;
    case 0xD:   //------------------------------------------------------------
                // выбран чип DS28E05, нажата кнопка WRITE ADMINISTRATIVE DATA
                //------------------------------------------------------------
                // добавляем нужные переменные
                DS28E05_INPUT_DATA DS28E05_InputData;     // входные данные для функций DS28E05
                DS28E05_OUTPUT_DATA DS28E05_OutputData;   // выходные данные для функций DS28E05
                SendMsgToLogForm(121,"");           // начинаем запись данных в EEPROM
                // начинаем работать
                GetDataToMemory(0,0);                     // получаем ROM с формы (второй параметр может быть любым)
                // помещаем данные с формы в память в зависимости от вкладки
                switch(Form1->PageControl1->TabIndex)
                { case 0:  GetDataToMemory(3,2);        // передаём данные из RichEdit3 в Administrative Data
                           break;
                  case 1:  GetDataToMemory(4,2);        // передаём данные из RichEdit4 в Administrative Data
                           break;
                  default: break;
                }
                // посылаем данные из памяти по 1-Wire и помещаем результат (Test) на форму
                // выбираем очередной кусок для отправки в блокнот
                DS28E05_InputData.AreaNumber=2;                                 // будем посылать в блокнот данные из области данных
                // записываем 7 страницу
                // если порт открыт - отправляем очередную страницу
                if(Port!=INVALID_HANDLE_VALUE)
                { // вычисляем новое значение байта параметров
                  DS28E05_InputData.PB=7<<4;                                  // вычисляем значение PB
                  DS28E05_OutputData=DS28E05_WriteToMemory(DS28E05_InputData);
                }
                else  // если порт закрыт - отправляем мессадж и выходим
                { SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                  return;
                }
                // если прочитали - проверяем ответ
                if(DS28E05_OutputData.Success==false)   // если запись не удалась
                { SendMsgToLogForm(105,"");    // ошибка записи
                  return;
                }
                else            // если запись удалась - выводим на форму Test
                { // помещаем на форму Test
                  TempBuf[0]=DS28E05_OutputData.Test;
                  BinToHex(TempBuf,OutHexBuf,1);        // преобразовать строку в целое (байт)
                  OutHexBuf[2]=0;                       // строка должна заканчиваться нулём
                  Form1->Edit7->Text = OutHexBuf;
                }
                SendMsgToLogForm(106,"");    // запись успешно завершена
                break;
    case 0x10:  //------------------------------------------------------------
                // выбран чип DS18S20, нажата кнопка COPY SCRATCHPAD TO MEMORY
                //------------------------------------------------------------
                // добавляем нужные переменные
                DS18S20_OUTPUT_DATA DS18S20_OutputData; // выходные данные для функций DS18B20
                SendMsgToLogForm(118,"");    // начинаем копирование блокнота в EEPROM
                // начинаем работать
                // посылаем команду Copy to Scratchpad
                GetDataToMemory(0,0);                   // получаем ROM с формы (второй параметр может быть любым)
                if(Port!=INVALID_HANDLE_VALUE)
                { DS18S20_OutputData=DS18S20_CopyScratchpadToMemory();
                  if(DS18S20_OutputData.Success)        SendMsgToLogForm(110,"");   // копирование из блокнота в EEPROM успешно завершено
                  else                                  SendMsgToLogForm(109,"");    // во время копирование из блокнота в EEPROM произошла ошибка
                }
                else    SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                break;
    case 0x14:  //------------------------------------------------------------
                // выбран чип DS2430A, нажата кнопка COPY SCRATCHPAD TO MEMORY
                //------------------------------------------------------------
                // добавляем нужные переменные
                DS2430_OUTPUT_DATA DS2430_OutputData;   // выходные данные для функций DS2430A
                SendMsgToLogForm(118,"");    // начинаем копирование блокнота в EEPROM
                // начинаем работать
                // посылаем команду Copy to Scratchpad
                GetDataToMemory(0,0);                   // получаем ROM с формы (второй параметр может быть любым)
                if(Port!=INVALID_HANDLE_VALUE)
                { DS2430_OutputData=DS2430_CopyScratchpadToMemory();
                  if(DS2430_OutputData.Success)         SendMsgToLogForm(110,"");   // копирование из блокнота в EEPROM успешно завершено
                  else                                  SendMsgToLogForm(109,"");    // во время копирование из блокнота в EEPROM произошла ошибка
                }
                else    SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                break;
    case 0x1A:  //------------------------------------------------------------
                // выбран чип DS1963L, нажата кнопка COPY SCRATCHPAD TO MEMORY
    case 0x1D:  //------------------------------------------------------------
                // выбран чип DS2423, нажата кнопка COPY SCRATCHPAD TO MEMORY
                //------------------------------------------------------------
                // добавляем нужные переменные
                DS1963L_INPUT_DATA DS1963L_InputData;   // входные данные для функций DS1963L
                DS1963L_OUTPUT_DATA DS1963L_OutputData; // выходные данные для функций DS1963L
                SendMsgToLogForm(118,"");    // начинаем копирование блокнота в EEPROM
                // начинаем работать
                TempStr=LowerCase(Form1->Edit4->Text);  // получаем TA1 в строку
                InHexBuf=TempStr.c_str();               // скопировать в буфер байт для передачи (в виде строки)
                HexToBin(InHexBuf,TempBuf,1);           // преобразовать строку в целое (байт)
                DS1963L_InputData.TA1=TempBuf[0];        // сохраняем значение TA1
                TempStr=LowerCase(Form1->Edit5->Text);  // получаем TA2 в строку
                InHexBuf=TempStr.c_str();               // скопировать в буфер байт для передачи (в виде строки)
                HexToBin(InHexBuf,TempBuf,1);           // преобразовать строку в целое (байт)
                DS1963L_InputData.TA2=TempBuf[0];        // сохраняем значение TA2
                TempStr=LowerCase(Form1->Edit6->Text);  // получаем ES в строку
                InHexBuf=TempStr.c_str();               // скопировать в буфер байт для передачи (в виде строки)
                HexToBin(InHexBuf,TempBuf,1);           // преобразовать строку в целое (байт)
                DS1963L_InputData.ES=TempBuf[0];         // сохраняем значение ES
                // посылаем команду Copy to Scratchpad и помещаем результат (Test) на форму
                GetDataToMemory(0,0);                   // получаем ROM с формы (второй параметр может быть любым)
                if(Port!=INVALID_HANDLE_VALUE)
                {  DS1963L_OutputData=DS1963L_CopyScratchpadToMemory(DS1963L_InputData);
                   if(DS1963L_OutputData.Success)
                   { // помещаем Test на форму
                     TempBuf[0]=DS1963L_OutputData.Test;
                     BinToHex(TempBuf,OutHexBuf,1);        // преобразовать строку в целое (байт)
                     OutHexBuf[2]=0;                       // строка должна заканчиваться нулём
                     Form1->Edit7->Text = OutHexBuf;
                     SendMsgToLogForm(110,"");    // копирование из блокнота в EEPROM успешно завершено
                   }
                   else    SendMsgToLogForm(109,"");    // во время копирование из блокнота в EEPROM произошла ошибка
                }
                else    SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                break;
    case 0x23:  //------------------------------------------------------------
                // выбран чип DS24B33, нажата кнопка COPY SCRATCHPAD TO MEMORY
                //------------------------------------------------------------
                // добавляем нужные переменные
                DS24B33_INPUT_DATA DS24B33_InputData;   // входные данные для функций DS24B33
                DS24B33_OUTPUT_DATA DS24B33_OutputData; // выходные данные для функций DS24B33
                SendMsgToLogForm(118,"");    // начинаем копирование блокнота в EEPROM
                // начинаем работать
                TempStr=LowerCase(Form1->Edit4->Text);  // получаем TA1 в строку
                InHexBuf=TempStr.c_str();               // скопировать в буфер байт для передачи (в виде строки)
                HexToBin(InHexBuf,TempBuf,1);           // преобразовать строку в целое (байт)
                DS24B33_InputData.TA1=TempBuf[0];        // сохраняем значение TA1
                TempStr=LowerCase(Form1->Edit5->Text);  // получаем TA2 в строку
                InHexBuf=TempStr.c_str();               // скопировать в буфер байт для передачи (в виде строки)
                HexToBin(InHexBuf,TempBuf,1);           // преобразовать строку в целое (байт)
                DS24B33_InputData.TA2=TempBuf[0];        // сохраняем значение TA2
                TempStr=LowerCase(Form1->Edit6->Text);  // получаем ES в строку
                InHexBuf=TempStr.c_str();               // скопировать в буфер байт для передачи (в виде строки)
                HexToBin(InHexBuf,TempBuf,1);           // преобразовать строку в целое (байт)
                DS24B33_InputData.ES=TempBuf[0];         // сохраняем значение ES
                // посылаем команду Copy to Scratchpad и помещаем результат (Test) на форму
                GetDataToMemory(0,0);                   // получаем ROM с формы (второй параметр может быть любым)
                if(Port!=INVALID_HANDLE_VALUE)
                {  DS24B33_OutputData=DS24B33_CopyScratchpadToMemory(DS24B33_InputData);
                   if(DS24B33_OutputData.Success)
                   { // помещаем Test на форму
                     TempBuf[0]=DS24B33_OutputData.Test;
                     BinToHex(TempBuf,OutHexBuf,1);        // преобразовать строку в целое (байт)
                     OutHexBuf[2]=0;                       // строка должна заканчиваться нулём
                     Form1->Edit7->Text = OutHexBuf;
                     SendMsgToLogForm(110,"");    // копирование из блокнота в EEPROM успешно завершено
                   }
                   else    SendMsgToLogForm(109,"");    // во время копирование из блокнота в EEPROM произошла ошибка
                }
                else    SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                break;
    case 0x22:  //------------------------------------------------------------
                // выбран чип DS1822, нажата кнопка COPY SCRATCHPAD TO MEMORY
    case 0x28:  //------------------------------------------------------------
                // выбран чип DS18B20, нажата кнопка COPY SCRATCHPAD TO MEMORY
                //------------------------------------------------------------
                // добавляем нужные переменные
                DS18B20_OUTPUT_DATA DS18B20_OutputData; // выходные данные для функций DS18B20
                SendMsgToLogForm(118,"");    // начинаем копирование блокнота в EEPROM
                // начинаем работать
                // посылаем команду Copy to Scratchpad
                GetDataToMemory(0,0);                   // получаем ROM с формы (второй параметр может быть любым)
                if(Port!=INVALID_HANDLE_VALUE)
                { DS18B20_OutputData=DS18B20_CopyScratchpadToMemory();
                  if(DS18B20_OutputData.Success)        SendMsgToLogForm(110,"");   // копирование из блокнота в EEPROM успешно завершено
                  else                                  SendMsgToLogForm(109,"");    // во время копирование из блокнота в EEPROM произошла ошибка
                }
                else    SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                break;
    case 0x2C:  //-------------------------------------------
                // выбран чип DS2890, нажата кнопка INCREMENT
                //-------------------------------------------
                // добавляем нужные переменные
                DS2890_OUTPUT_DATA DS2890_OutputData;   // выходные данные для функций 1W
                SendMsgToLogForm(149,"");    // начинаем выполнение команды
                // начинаем работать
                GetDataToMemory(0,0);                   // получаем ROM с формы (второй параметр может быть любым)
                if(Port!=INVALID_HANDLE_VALUE)
                { DS2890_OutputData=DS2890_Increment();   // читаем данные
                  if(DS2890_OutputData.Success)           // если успешно прочитали
                  { // помещаем на форму Position
                    TempBuf[0]=DS2890_OutputData.Position;
                    BinToHex(TempBuf,OutHexBuf,1);        // преобразовать строку в целое (байт)
                    OutHexBuf[2]=0;                       // строка должна заканчиваться нулём
                    Form1->Edit4->Text = OutHexBuf;
                    SendMsgToLogForm(151,"");                // команда успешно выпонена
                  }
                  else  SendMsgToLogForm(150,"");            // выполнение команды завершено с ошибкой
                }
                else    SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                break;
    case 0x2D:  //-----------------------------------------------------------
                // выбран чип DS2431, нажата кнопка COPY SCRATCHPAD TO MEMORY
                //-----------------------------------------------------------
                // добавляем нужные переменные
                DS2431_OUTPUT_DATA DS2431_OutputData;   // выходные данные для функций DS2431
                DS2431_INPUT_DATA DS2431_InputData;     // входные данные для функций DS2431
                SendMsgToLogForm(118,"");    // начинаем копирование блокнота в EEPROM
                // начинаем работать
                TempStr=LowerCase(Form1->Edit4->Text);  // получаем TA1 в строку
                InHexBuf=TempStr.c_str();               // скопировать в буфер байт для передачи (в виде строки)
                HexToBin(InHexBuf,TempBuf,1);           // преобразовать строку в целое (байт)
                DS2431_InputData.TA1=TempBuf[0];        // сохраняем значение TA1
                TempStr=LowerCase(Form1->Edit5->Text);  // получаем TA2 в строку
                InHexBuf=TempStr.c_str();               // скопировать в буфер байт для передачи (в виде строки)
                HexToBin(InHexBuf,TempBuf,1);           // преобразовать строку в целое (байт)
                DS2431_InputData.TA2=TempBuf[0];        // сохраняем значение TA2
                TempStr=LowerCase(Form1->Edit6->Text);  // получаем ES в строку
                InHexBuf=TempStr.c_str();               // скопировать в буфер байт для передачи (в виде строки)
                HexToBin(InHexBuf,TempBuf,1);           // преобразовать строку в целое (байт)
                DS2431_InputData.ES=TempBuf[0];         // сохраняем значение ES
                // посылаем команду Copy to Scratchpad и помещаем результат (Test) на форму
                GetDataToMemory(0,0);                   // получаем ROM с формы (второй параметр может быть любым)
                if(Port!=INVALID_HANDLE_VALUE)
                { DS2431_OutputData=DS2431_CopyScratchpadToMemory(DS2431_InputData);
                  if(DS2431_OutputData.Success)
                  { TempBuf[0]=DS2431_OutputData.Test;
                    BinToHex(TempBuf,OutHexBuf,1);        // преобразовать строку в целое (байт)
                    OutHexBuf[2]=0;                       // строка должна заканчиваться нулём
                    Form1->Edit7->Text = OutHexBuf;
                    SendMsgToLogForm(110,"");    // копирование из блокнота в EEPROM успешно завершено
                  }
                  else    SendMsgToLogForm(109,"");    // во время копирование из блокнота в EEPROM произошла ошибка
                }
                else    SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                break;
    case 0x33:  //-----------------------------------------------------------
                // выбран чип DS2432, нажата кнопка COPY SCRATCHPAD TO MEMORY
                //-----------------------------------------------------------
                // добавляем нужные переменные
                DS2432_OUTPUT_DATA DS2432_OutputData;   // выходные данные для функций DS2432
                DS2432_INPUT_DATA DS2432_InputData;     // входные данные для функций DS2432
                SendMsgToLogForm(118,"");    // начинаем копирование блокнота в EEPROM
                // начинаем работать
                TempStr=LowerCase(Form1->Edit4->Text);  // получаем TA1 в строку
                InHexBuf=TempStr.c_str();               // скопировать в буфер байт для передачи (в виде строки)
                HexToBin(InHexBuf,TempBuf,1);           // преобразовать строку в целое (байт)
                DS2432_InputData.TA1=TempBuf[0];        // сохраняем значение TA1
                TempStr=LowerCase(Form1->Edit5->Text);  // получаем TA2 в строку
                InHexBuf=TempStr.c_str();               // скопировать в буфер байт для передачи (в виде строки)
                HexToBin(InHexBuf,TempBuf,1);           // преобразовать строку в целое (байт)
                DS2432_InputData.TA2=TempBuf[0];        // сохраняем значение TA2
                TempStr=LowerCase(Form1->Edit6->Text);  // получаем ES в строку
                InHexBuf=TempStr.c_str();               // скопировать в буфер байт для передачи (в виде строки)
                HexToBin(InHexBuf,TempBuf,1);           // преобразовать строку в целое (байт)
                DS2432_InputData.ES=TempBuf[0];         // сохраняем значение ES
                // посылаем команду Copy to Scratchpad и помещаем результат (Test) на форму
                GetDataToMemory(0,0);                   // получаем ROM с формы (второй параметр может быть любым)
                // получаем данные остальных областей с формы в память
                // для того, чтобы всё получилось, области Data и Register должны быть предварительно прочитаны,
                // в область Secret вписан правильный ключ, а область блокнота записана в чип и прочитана обратно
                switch(Form1->PageControl1->TabIndex)
                { case 0:  GetDataToMemory(1,1);        // передаём данные из RichEdit1 в Data
                           GetDataToMemory(3,2);        // передаём данные из RichEdit3 в Secret
                           GetDataToMemory(5,3);        // передаём данные из RichEdit5 в Register
                           GetDataToMemory(7,4);        // передаём данные из RichEdit7 в Scratchpad
                           break;
                  case 1:  GetDataToMemory(2,1);        // передаём данные из RichEdit2 в Data
                           GetDataToMemory(4,2);        // передаём данные из RichEdit4 в Secret
                           GetDataToMemory(6,3);        // передаём данные из RichEdit6 в Register
                           GetDataToMemory(8,4);        // передаём данные из RichEdit8 в Scratchpad
                           break;
                  default: break;
                }
                // выполняем копирование
                if(Port!=INVALID_HANDLE_VALUE)
                { DS2432_OutputData=DS2432_CopyScratchpadToMemory(DS2432_InputData);
                  if(DS2432_OutputData.Success)
                  { TempBuf[0]=DS2432_OutputData.Test;
                    BinToHex(TempBuf,OutHexBuf,1);        // преобразовать строку в целое (байт)
                    OutHexBuf[2]=0;                       // строка должна заканчиваться нулём
                    Form1->Edit7->Text = OutHexBuf;
                    SendMsgToLogForm(110,"");    // копирование из блокнота в EEPROM успешно завершено
                  }
                  else    SendMsgToLogForm(109,"");    // во время копирование из блокнота в EEPROM произошла ошибка
                }
                else    SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                break;
    case 0x3B:  //-----------------------------------------------------
                // выбран чип MAX31826, нажата кнопка READ POWER SUPPLY
                //-----------------------------------------------------
                // добавляем нужные переменные
                MAX31826_OUTPUT_DATA MAX31826_OutputData; // выходные данные для функций MAX31826
                SendMsgToLogForm(126,"");           // начинаем чтение режима питания
                // начинаем работать
                GetDataToMemory(0,0);                        // получаем ROM с формы (второй параметр может быть любым)
                if(Port!=INVALID_HANDLE_VALUE)  MAX31826_OutputData=MAX31826_ReadPowerSupply();
                else  // если порт закрыт - отправляем мессадж и выходим
                { SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                  return;
                }
                if(MAX31826_OutputData.Success)  // если всё успешно
                { // формируем результаты
                  if(MAX31826_OutputData.Test==0)               SendMsgToLogForm(112,"");    // паразитное питание
                  else if(MAX31826_OutputData.Test==0xFF)       SendMsgToLogForm(113,"");    // независимое питание
                  else                                          SendMsgToLogForm(114,"");    // не удалось определить режим питания
                }
                else    SendMsgToLogForm(107,"");    // Ошибка чтения
                break;
    case 0x43:  //-----------------------------------------------------------
                // выбран чип DS28EC20, нажата кнопка COPY SCRATCHPAD TO MEMORY
                //-----------------------------------------------------------
                // добавляем нужные переменные
                DS28EC20_OUTPUT_DATA DS28EC20_OutputData;   // выходные данные для функций DS28EC20
                DS28EC20_INPUT_DATA DS28EC20_InputData;     // входные данные для функций DS28EC20
                SendMsgToLogForm(118,"");    // начинаем копирование блокнота в EEPROM
                // начинаем работать
                TempStr=LowerCase(Form1->Edit4->Text);  // получаем TA1 в строку
                InHexBuf=TempStr.c_str();               // скопировать в буфер байт для передачи (в виде строки)
                HexToBin(InHexBuf,TempBuf,1);           // преобразовать строку в целое (байт)
                DS28EC20_InputData.TA1=TempBuf[0];        // сохраняем значение TA1
                TempStr=LowerCase(Form1->Edit5->Text);  // получаем TA2 в строку
                InHexBuf=TempStr.c_str();               // скопировать в буфер байт для передачи (в виде строки)
                HexToBin(InHexBuf,TempBuf,1);           // преобразовать строку в целое (байт)
                DS28EC20_InputData.TA2=TempBuf[0];        // сохраняем значение TA2
                TempStr=LowerCase(Form1->Edit6->Text);  // получаем ES в строку
                InHexBuf=TempStr.c_str();               // скопировать в буфер байт для передачи (в виде строки)
                HexToBin(InHexBuf,TempBuf,1);           // преобразовать строку в целое (байт)
                DS28EC20_InputData.ES=TempBuf[0];         // сохраняем значение ES
                // посылаем команду Copy to Scratchpad и помещаем результат (Test) на форму
                GetDataToMemory(0,0);                   // получаем ROM с формы (второй параметр может быть любым)
                if(Port!=INVALID_HANDLE_VALUE)
                { DS28EC20_OutputData=DS28EC20_CopyScratchpadToMemory(DS28EC20_InputData);
                  if(DS28EC20_OutputData.Success)
                  { TempBuf[0]=DS28EC20_OutputData.Test;
                    BinToHex(TempBuf,OutHexBuf,1);        // преобразовать строку в целое (байт)
                    OutHexBuf[2]=0;                       // строка должна заканчиваться нулём
                    Form1->Edit7->Text = OutHexBuf;
                    SendMsgToLogForm(110,"");    // копирование из блокнота в EEPROM успешно завершено
                  }
                  else    SendMsgToLogForm(109,"");    // во время копирование из блокнота в EEPROM произошла ошибка
                }
                else    SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                break;
    case 0x5:   // выбран чип DS2405
    case 0x24:  // выбран чип DS2415
    case 0x27:  // выбран чип DS2417
    default:    break;
  }
}
//---------------------------------------------------------------------------
//--- НАЖАТА КНОПКА BUTTON7 -------------------------------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::Button7Click(TObject *Sender)
{ AnsiString TempStr;                           // для преобразования
  char *InHexBuf, TempBuf[1], OutHexBuf[3];     // для преобразования
  unsigned int TempAddr;                        // для вычисления адреса

  switch(SelectedChip.Family)
  { case 0x0:   // выбран один из чипов с перезаписываемым ROM
                switch(SelectedChip.Modify)
                { case 1:  // выбран чип RW1990
                  case 2:  // выбран ключ AN1990
                  case 3:  // выбран ключ TM2004
                  default: break;
                }
                break;
    case 0x2:   //------------------------------------------------------
                // выбран чип DS1991, нажата кнопка WRITE DATA TO SUBKEY
    case 0x82:  //------------------------------------------------------
                // выбран чип DS1425, нажата кнопка WRITE DATA TO SUBKEY
                //------------------------------------------------------
                // добавляем нужные переменные
                DS1991_OUTPUT_DATA DS1991_OutputData; // выходные данные для функций DS1991
                DS1991_INPUT_DATA DS1991_InputData;   // входные данные для функций DS1991
                unsigned char DS1991_Done;            // счётчик количества записей
                SendMsgToLogForm(134,"");    // начинаем запись ключа
                // начинаем работать
                DS1991_Done=0;                        // ни одна область пока не записана
                GetDataToMemory(0,0);                   // получаем ROM с формы (второй параметр может быть любым)
                for(unsigned int DS1991_i=0; DS1991_i<3; DS1991_i++)
                { DS1991_InputData.AreaNumber=0;        // признак того, что никуда записывать не нужно
                  if(DS1991_i==0)
                  { if(Form1->CheckBox1->Checked==true)         // проверяем, нужно ли записывать в subkey1
                    { DS1991_InputData.AreaNumber=1;            // нужно
                      switch(Form1->PageControl1->TabIndex)
                      { case 0:  GetDataToMemory(1,1);          // передаём данные из RichEdit1 в Area1
                                 break;
                        case 1:  GetDataToMemory(2,1);          // передаём данные из RichEdit2 в Area1
                                 break;
                        default: break;
                      }
                    }
                  }
                  else if(DS1991_i==1)
                  { if(Form1->CheckBox1->Checked==true)         // проверяем, нужно ли записывать в subkey2
                    { DS1991_InputData.AreaNumber=2;            // нужно
                      switch(Form1->PageControl1->TabIndex)
                      { case 0:  GetDataToMemory(3,2);          // передаём данные из RichEdit3 в Area2
                                 break;
                        case 1:  GetDataToMemory(4,2);          // передаём данные из RichEdit4 в Area2
                                 break;
                        default: break;
                      }
                    }
                  }
                  else
                  { if(Form1->CheckBox1->Checked==true)         // проверяем, нужно ли записывать в subkey3
                    { DS1991_InputData.AreaNumber=3;            // нужно
                      switch(Form1->PageControl1->TabIndex)
                      { case 0:  GetDataToMemory(5,3);          // передаём данные из RichEdit5 в Area3
                                 break;
                        case 1:  GetDataToMemory(6,3);          // передаём данные из RichEdit6 в Area3
                                 break;
                        default: break;
                      }
                    }
                  }
                  if(DS1991_InputData.AreaNumber!=0)    // если нужно записывать
                  { if(Port!=INVALID_HANDLE_VALUE)
                    { DS1991_OutputData=DS1991_WriteSubKey(DS1991_InputData);   // посылаем команду Write SubKey
                      if(DS1991_OutputData.Success)         SendMsgToLogForm(106,"");        // запись ключа успешно завершена
                      else                                  SendMsgToLogForm(105,"");        // во время записи ключа произошла ошибка
                    }
                    else    SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                    DS1991_Done+=1;           // увеличиваем количество попыток копирования
                  }
                }
                if(DS1991_Done==0)      SendMsgToLogForm(133,"");  // не выбрана ни одна область, для которой нужно выполнить действие
                break;
    case 0x4:   //---------------------------------------------------
                // выбран чип DS1994, нажата кнопка WRITE DATA MEMORY
    case 0x84:  //---------------------------------------------------
                // выбран чип DS1427, нажата кнопка WRITE DATA MEMORY
                //---------------------------------------------------
                // добавляем нужные переменные
                DS1994_INPUT_DATA DS1994_InputData;       // входные данные для функций DS1994
                DS1994_OUTPUT_DATA DS1994_OutputData;     // выходные данные для функций DS1994
                SendMsgToLogForm(121,"");           // начинаем запись данных в EEPROM
                // начинаем работать
                GetDataToMemory(0,0);                     // получаем ROM с формы (второй параметр может быть любым)
                // помещаем данные с формы в память в зависимости от вкладки
                switch(Form1->PageControl1->TabIndex)
                { case 0:  GetDataToMemory(1,1);        // передаём данные из RichEdit1 в Data
                           break;
                  case 1:  GetDataToMemory(2,1);        // передаём данные из RichEdit2 в Data
                           break;
                  default: break;
                }
                // посылаем данные из памяти по 1-Wire через блокнот и помещаем результат (Test) на форму
                // организуем цикл равный количеству кусков, равных размеру блокнота, содержащихся в отправляемой области
                for(unsigned int i=0; i<SelectedChip.Area1Size/SelectedChip.Area3Size; i++)
                { // выбираем очередной кусок для отправки в блокнот
                  DS1994_InputData.Size=SelectedChip.Area3Size;                         // размер посылки равен размеру блокнота
                  DS1994_InputData.AreaNumber=1;                                        // будем посылать в блокнот данные из области данных
                  // если порт открыт - отправляем кусок из области данных в блокнот
                  if(Port!=INVALID_HANDLE_VALUE)
                  { TempAddr=SelectedChip.Area1Start+i*SelectedChip.Area3Size;          // вычисляем новое значение начального адреса области записи
                    DS1994_InputData.TA1=TempAddr;                                      // вычисляем значение TA1
                    DS1994_InputData.TA2=TempAddr>>8;                                   // вычисляем значение TA2
                    DS1994_OutputData=DS1994_WriteToScratchpad(DS1994_InputData);
                  }
                  else  // если порт закрыт - отправляем мессадж и выходим
                  { SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                    return;
                  }
                  // если порт открыт - читаем блокнот
                  if(Port!=INVALID_HANDLE_VALUE)  DS1994_OutputData=DS1994_ReadFromScratchpad();        // читаем данные из Scratchpad
                  else  // если порт закрыт - отправляем мессадж и выходим
                  { SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                    return;
                  }
                  // здесь можно дополнительно сравнивать отправленные данные и считанные в блокнот
                  // если прочитали - проверяем ответ
                  if(DS1994_OutputData.Success==false)
                  {     SendMsgToLogForm(105,"");    // ошибка записи
                        return;
                  }
                  // если проверка прошла успешно - копируем блокнот в память
                  DS1994_InputData.TA1=DS1994_OutputData.TA1;
                  DS1994_InputData.TA2=DS1994_OutputData.TA2;
                  DS1994_InputData.ES=DS1994_OutputData.ES;
                  if(Port!=INVALID_HANDLE_VALUE)  DS1994_OutputData=DS1994_CopyScratchpadToMemory(DS1994_InputData);
                  else  // если порт закрыт - отправляем мессадж и выходим
                  { SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                    return;
                  }
                  if(DS1994_OutputData.Success==false)
                  {     SendMsgToLogForm(105,"");    // ошибка записи
                        return;
                  }
                }
                SendMsgToLogForm(106,"");    // запись успешно завершена
                break;
    case 0x6:   //---------------------------------------------------
                // выбран чип DS1993, нажата кнопка WRITE DATA MEMORY
    case 0x8:   //---------------------------------------------------
                // выбран чип DS1992, нажата кнопка WRITE DATA MEMORY
    case 0xA:   //---------------------------------------------------
                // выбран чип DS1995, нажата кнопка WRITE DATA MEMORY
    case 0xC:   //---------------------------------------------------
                // выбран чип DS1996, нажата кнопка WRITE DATA MEMORY
                //---------------------------------------------------
                // добавляем нужные переменные
                DS1992_INPUT_DATA DS1992_InputData;           // входные данные для функций DS1992
                DS1992_OUTPUT_DATA DS1992_OutputData;         // выходные данные для функций DS1992
                SendMsgToLogForm(121,"");    // начинаем запись в EEPROM
                // начинаем работать
                GetDataToMemory(0,0);                           // получаем ROM с формы (второй параметр может быть любым)
                // помещаем данные с формы в память в зависимости от вкладки
                switch(Form1->PageControl1->TabIndex)
                { case 0:  GetDataToMemory(1,1);                // передаём данные из RichEdit1 в Data
                           break;
                  case 1:  GetDataToMemory(2,1);                // передаём данные из RichEdit2 в Data
                           break;
                  default: break;
                }
                // посылаем данные из памяти по 1-Wire через блокнот и помещаем результат (Test) на форму
                // организуем цикл равный количеству кусков, равных размеру блокнота, содержащихся в отправляемой области
                for(unsigned int i=0; i<SelectedChip.Area1Size/SelectedChip.Area2Size; i++)
                { // выбираем очередной кусок для отправки в блокнот
                  DS1992_InputData.Size=SelectedChip.Area2Size;                // размер посылки равен размеру блокнота
                  DS1992_InputData.AreaNumber=1;                               // будем посылать в блокнот данные из области данных
                  // если порт открыт - отправляем кусок из области данных в блокнот
                  if(Port!=INVALID_HANDLE_VALUE)
                  { TempAddr=SelectedChip.Area1Start+i*SelectedChip.Area2Size;  // вычисляем новое значение начального адреса области записи
                    DS1992_InputData.TA1=TempAddr;                             // вычисляем значение TA1
                    DS1992_InputData.TA2=TempAddr>>8;                          // вычисляем значение TA2
                    DS1992_OutputData=DS1992_WriteToScratchpad(DS1992_InputData);
                  }
                  else  // если порт закрыт - отправляем мессадж и выходим
                  { SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                    return;
                  }
                  // если порт открыт - читаем блокнот
                  if(Port!=INVALID_HANDLE_VALUE)  DS1992_OutputData=DS1992_ReadFromScratchpad();      // читаем данные из Scratchpad
                  else  // если порт закрыт - отправляем мессадж и выходим
                  { SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                    return;
                  }
                  // здесь можно дополнительно сравнивать отправленные данные и считанные в блокнот
                  // если прочитали - проверяем ответ
                  if(DS1992_OutputData.Success==false)
                  {     SendMsgToLogForm(105,"");    // ошибка записи данных
                        return;
                  }
                  // если проверка прошла успешно - копируем блокнот в память
                  DS1992_InputData.TA1=DS1992_OutputData.TA1;
                  DS1992_InputData.TA2=DS1992_OutputData.TA2;
                  DS1992_InputData.ES=DS1992_OutputData.ES;
                  if(Port!=INVALID_HANDLE_VALUE)  DS1992_OutputData=DS1992_CopyScratchpadToMemory(DS1992_InputData);
                  else  // если порт закрыт - отправляем мессадж и выходим
                  { SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                    return;
                  }
                  if(DS1992_OutputData.Success)
                  { TempBuf[0]=DS1992_OutputData.Test;
                    BinToHex(TempBuf,OutHexBuf,1);          // преобразовать строку в целое (байт)
                    OutHexBuf[2]=0;                         // строка должна заканчиваться нулём
                    Form1->Edit7->Text = OutHexBuf;         // пишем Test на форму
                  }
                  else
                  {     SendMsgToLogForm(105,"");    // ошибка записи данных
                        return;
                  }
                }
                SendMsgToLogForm(106,"");    // данные успешно записаны
                break;
    case 0x9:   //-------------------------------------------------------
                // выбран чип DS2502 / DS1982, нажата кнопка WRITE STATUS
                //-------------------------------------------------------
                // добавляем нужные переменные
                DS2502_INPUT_DATA DS2502_InputData;     // входные данные для функций DS2502
                DS2502_OUTPUT_DATA DS2502_OutputData;   // выходные данные для функций DS2502
                SendMsgToLogForm(121,"");    // начинаем запись в EPROM
                // начинаем работать
                GetDataToMemory(0,0);                   // получаем ROM с формы (второй параметр может быть любым)
                DS2502_InputData.TA1=0;                 // сохраняем значение TA1
                DS2502_InputData.TA2=0;                 // сохраняем значение TA2
                // помещаем данные с формы в память в зависимости от вкладки (для DS2502 STATUS находится в Area2)
                switch(Form1->PageControl1->TabIndex)
                { case 0:  GetDataToMemory(3,2);        // передаём данные из RichEdit3 в Status
                           break;
                  case 1:  GetDataToMemory(4,2);        // передаём данные из RichEdit4 в Status
                           break;
                  default: break;
                }
                // посылаем данные по 1-Wire
                DS2502_InputData.Size=SelectedChip.Area2Size;   // размер равен количеству Status Bytes
                if(Port!=INVALID_HANDLE_VALUE)
                { DS2502_OutputData=DS2502_WriteToStatus(DS2502_InputData);
                  if(DS2502_OutputData.Success) SendMsgToLogForm(106,"");                // запись Status Bytes успешно завершена
                  else                          SendMsgToLogForm(105,"");            // запись Status Bytes завершена с ошибкой
                }
                else    SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                break;
    case 0xD:   //-----------------------------------------------------------
                // выбран чип DS28E05, нажата кнопка READ ADMINISTRATIVE DATA
                //-----------------------------------------------------------
                // добавляем нужные переменные
                DS28E05_INPUT_DATA DS28E05_InputData;     // входные данные для функций 1W
                DS28E05_OUTPUT_DATA DS28E05_OutputData;   // выходные данные для функций 1W
                SendMsgToLogForm(143,"");    // начинаем чтение данных
                // начинаем работать
                GetDataToMemory(0,0);                   // получаем ROM с формы (второй параметр может быть любым)
                if(Port!=INVALID_HANDLE_VALUE)
                { DS28E05_InputData.AreaNumber=2;                       // читаем в область 2
                  DS28E05_InputData.Size=SelectedChip.Area2Size;        // размер равен размеру области 2
                  DS28E05_InputData.TA1=SelectedChip.Area2Start;        // младший байт начального адреса области
                  DS28E05_InputData.TA2=SelectedChip.Area2Start>>8;     // старший байт начального адреса области
                  DS28E05_OutputData=DS28E05_ReadFromMemory(DS28E05_InputData); // читаем данные из памяти
                  if(DS28E05_OutputData.Success)           // если успешно прочитали
                  { // помещаем на форму Test
                    TempBuf[0]=DS28E05_OutputData.Test;
                    BinToHex(TempBuf,OutHexBuf,1);        // преобразовать строку в целое (байт)
                    OutHexBuf[2]=0;                       // строка должна заканчиваться нулём
                    Form1->Edit7->Text = OutHexBuf;
                    // помещаем данные из памяти на форму
                    switch(Form1->PageControl1->TabIndex)
                    { case 0:  PlaceDataToForm(3,2);
                               break;
                      case 1:  PlaceDataToForm(4,2);
                               break;
                      default: break;
                    }
                    SendMsgToLogForm(108,"");                // чтение данных успешно завершено
                  }
                  else SendMsgToLogForm(107,"");       // чтение данных завершено с ошибкой
                }
                else    SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                break;
    case 0x10:  //--------------------------------------------------------
                // выбран чип DS18S20, нажата кнопка START CYCLING POLLING
                //--------------------------------------------------------
                // добавляем нужные переменные
                DS18S20_OUTPUT_DATA DS18S20_OutputData;         // выходные данные для функций DS18S20
                SendMsgToLogForm(119,"");    // запускаем циклический опрос
                /* fixed */
                GetDataToMemory(0,0);                        // получаем ROM с формы (второй параметр может быть любым)
                // проверяем режим питания
                if(Port!=INVALID_HANDLE_VALUE)
                { DS18S20_OutputData=DS18S20_ReadPowerSupply();   // получаем режим питания
                  // если режим питания независимый - включаем таймер
                  if((DS18S20_OutputData.Success)&&(DS18S20_OutputData.Test==0xFF))     // если у нас отдельное питание
                  { Form1->Timer1->Enabled=true;                  // запускаем таймер
                    SendMsgToLogForm(103,"");        // успешно запустили циклический опрос
                  }
                  else    SendMsgToLogForm(111,""); // если режим питания паразитный - пишем, что нужно независимое питание и не включаем таймер
                }
                else    SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                break;
    case 0x14:  //-------------------------------------------------------------
                // выбран чип DS2430A, нажата кнопка WRITE APPLICATION REGISTER
                //-------------------------------------------------------------
                // добавляем нужные переменные
                DS2430_OUTPUT_DATA DS2430_OutputData;   // выходные данные для функций DS2430
                SendMsgToLogForm(120,"");    // начинаем запись в Application Register
                // начинаем работать
                GetDataToMemory(0,0);                   // получаем ROM с формы (второй параметр может быть любым)
                // помещаем данные с формы в память в зависимости от вкладки (для DS2430 Application Register находится в Area3)
                switch(Form1->PageControl1->TabIndex)
                { case 0:  GetDataToMemory(3,3);        // передаём данные из RichEdit3 в Application Register
                           break;
                  case 1:  GetDataToMemory(4,3);        // передаём данные из RichEdit4 в Application Register
                           break;
                  default: break;
                }
                // посылаем данные из памяти Area3 по 1-Wire
                if(Port!=INVALID_HANDLE_VALUE)
                { DS2430_OutputData=DS2430_WriteToApplRegister();
                  if(DS2430_OutputData.Success)         SendMsgToLogForm(106,"");    // запись в appl.register успешно завершена
                  else                                  SendMsgToLogForm(105,"");    // запись в appl.register завершена с ошибкой
                }
                else    SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                break;
    case 0x1A:  //----------------------------------------------------
                // выбран чип DS1963L, нажата кнопка WRITE DATA MEMORY
    case 0x1D:  //----------------------------------------------------
                // выбран чип DS2423, нажата кнопка WRITE DATA MEMORY
                //----------------------------------------------------
                // добавляем нужные переменные
                DS1963L_INPUT_DATA DS1963L_InputData;           // входные данные для функций DS1963L
                DS1963L_OUTPUT_DATA DS1963L_OutputData;         // выходные данные для функций DS1963L
                SendMsgToLogForm(121,"");    // начинаем запись в EEPROM
                // начинаем работать
                GetDataToMemory(0,0);                           // получаем ROM с формы (второй параметр может быть любым)
                // помещаем данные с формы в память в зависимости от вкладки
                switch(Form1->PageControl1->TabIndex)
                { case 0:  GetDataToMemory(1,1);                // передаём данные из RichEdit1 в Data
                           break;
                  case 1:  GetDataToMemory(2,1);                // передаём данные из RichEdit2 в Data
                           break;
                  default: break;
                }
                // посылаем данные из памяти по 1-Wire через блокнот и помещаем результат (Test) на форму
                // организуем цикл равный количеству кусков, равных размеру блокнота, содержащихся в отправляемой области
                for(unsigned int i=0; i<SelectedChip.Area1Size/SelectedChip.Area2Size; i++)
                { // выбираем очередной кусок для отправки в блокнот
                  DS1963L_InputData.Size=SelectedChip.Area2Size;                // размер посылки равен размеру блокнота
                  DS1963L_InputData.AreaNumber=1;                               // будем посылать в блокнот данные из области данных
                  // если порт открыт - отправляем кусок из области данных в блокнот
                  if(Port!=INVALID_HANDLE_VALUE)
                  { TempAddr=SelectedChip.Area1Start+i*SelectedChip.Area2Size;  // вычисляем новое значение начального адреса области записи
                    DS1963L_InputData.TA1=TempAddr;                             // вычисляем значение TA1
                    DS1963L_InputData.TA2=TempAddr>>8;                          // вычисляем значение TA2
                    DS1963L_OutputData=DS1963L_WriteToScratchpad(DS1963L_InputData);
                  }
                  else  // если порт закрыт - отправляем мессадж и выходим
                  { SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                    return;
                  }
                  // если порт открыт - читаем блокнот
                  if(Port!=INVALID_HANDLE_VALUE)  DS1963L_OutputData=DS1963L_ReadFromScratchpad();      // читаем данные из Scratchpad
                  else  // если порт закрыт - отправляем мессадж и выходим
                  { SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                    return;
                  }
                  // здесь можно дополнительно сравнивать отправленные данные и считанные в блокнот
                  // если прочитали - проверяем размер ответа и биты AA и PF
                  TempBuf[0]=(DS1963L_OutputData.ES>>5)&0x5;                    // выделяем биты AA и PF (обязательно ли это???)
                  if((DS1963L_OutputData.Success==false) || (TempBuf[0]!=0))
                  {     SendMsgToLogForm(105,"");    // ошибка записи данных
                        return;
                  }
                  // если проверка прошла успешно - копируем блокнот в память
                  DS1963L_InputData.TA1=DS1963L_OutputData.TA1;
                  DS1963L_InputData.TA2=DS1963L_OutputData.TA2;
                  DS1963L_InputData.ES=DS1963L_OutputData.ES;
                  if(Port!=INVALID_HANDLE_VALUE)  DS1963L_OutputData=DS1963L_CopyScratchpadToMemory(DS1963L_InputData);
                  else  // если порт закрыт - отправляем мессадж и выходим
                  { SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                    return;
                  }
                  if(DS1963L_OutputData.Success)
                  { TempBuf[0]=DS1963L_OutputData.Test;
                    BinToHex(TempBuf,OutHexBuf,1);          // преобразовать строку в целое (байт)
                    OutHexBuf[2]=0;                         // строка должна заканчиваться нулём
                    Form1->Edit7->Text = OutHexBuf;         // пишем Test на форму
                  }
                  else
                  {     SendMsgToLogForm(105,"");    // ошибка записи данных
                        return;
                  }
                }
                SendMsgToLogForm(106,"");    // данные успешно записаны
                break;
    case 0x23:  //----------------------------------------------------
                // выбран чип DS24B33, нажата кнопка WRITE DATA MEMORY
                //----------------------------------------------------
                // добавляем нужные переменные
                DS24B33_INPUT_DATA DS24B33_InputData;           // входные данные для функций DS24B33
                DS24B33_OUTPUT_DATA DS24B33_OutputData;         // выходные данные для функций DS24B33
                SendMsgToLogForm(121,"");    // начинаем запись в EEPROM
                // начинаем работать
                GetDataToMemory(0,0);                           // получаем ROM с формы (второй параметр может быть любым)
                // помещаем данные с формы в память в зависимости от вкладки
                switch(Form1->PageControl1->TabIndex)
                { case 0:  GetDataToMemory(1,1);                // передаём данные из RichEdit1 в Data
                           break;
                  case 1:  GetDataToMemory(2,1);                // передаём данные из RichEdit2 в Data
                           break;
                  default: break;
                }
                // посылаем данные из памяти по 1-Wire через блокнот и помещаем результат (Test) на форму
                // организуем цикл равный количеству кусков, равных размеру блокнота, содержащихся в отправляемой области
                for(unsigned int i=0; i<SelectedChip.Area1Size/SelectedChip.Area2Size; i++)
                { // выбираем очередной кусок для отправки в блокнот
                  DS24B33_InputData.Size=SelectedChip.Area2Size;                // размер посылки равен размеру блокнота
                  DS24B33_InputData.AreaNumber=1;                               // будем посылать в блокнот данные из области данных
                  // если порт открыт - отправляем кусок из области данных в блокнот
                  if(Port!=INVALID_HANDLE_VALUE)
                  { TempAddr=SelectedChip.Area1Start+i*SelectedChip.Area2Size;  // вычисляем новое значение начального адреса области записи
                    DS24B33_InputData.TA1=TempAddr;                             // вычисляем значение TA1
                    DS24B33_InputData.TA2=TempAddr>>8;                          // вычисляем значение TA2
                    DS24B33_OutputData=DS24B33_WriteToScratchpad(DS24B33_InputData);
                  }
                  else  // если порт закрыт - отправляем мессадж и выходим
                  { SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                    return;
                  }
                  // если порт открыт - читаем блокнот
                  if(Port!=INVALID_HANDLE_VALUE)  DS24B33_OutputData=DS24B33_ReadFromScratchpad();      // читаем данные из Scratchpad
                  else  // если порт закрыт - отправляем мессадж и выходим
                  { SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                    return;
                  }
                  // здесь можно дополнительно сравнивать отправленные данные и считанные в блокнот
                  // если прочитали - проверяем размер ответа и биты AA и PF
                  TempBuf[0]=(DS24B33_OutputData.ES>>5)&0x5;                            // выделяем биты AA и PF
                  if((DS24B33_OutputData.Success==false) || (TempBuf[0]!=0))
                  {     SendMsgToLogForm(105,"");    // ошибка записи данных
                        return;
                  }
                  // если проверка прошла успешно - копируем блокнот в память
                  DS24B33_InputData.TA1=DS24B33_OutputData.TA1;
                  DS24B33_InputData.TA2=DS24B33_OutputData.TA2;
                  DS24B33_InputData.ES=DS24B33_OutputData.ES;
                  if(Port!=INVALID_HANDLE_VALUE)  DS24B33_OutputData=DS24B33_CopyScratchpadToMemory(DS24B33_InputData);
                  else  // если порт закрыт - отправляем мессадж и выходим
                  { SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                    return;
                  }
                  if(DS24B33_OutputData.Success)
                  { TempBuf[0]=DS24B33_OutputData.Test;
                    BinToHex(TempBuf,OutHexBuf,1);          // преобразовать строку в целое (байт)
                    OutHexBuf[2]=0;                         // строка должна заканчиваться нулём
                    Form1->Edit7->Text = OutHexBuf;         // пишем Test на форму
                  }
                  else
                  {     SendMsgToLogForm(105,"");    // ошибка записи данных
                        return;
                  }
                }
                SendMsgToLogForm(106,"");    // данные успешно записаны
                break;
    case 0x22:  //--------------------------------------------------------
                // выбран чип DS1822, нажата кнопка START CYCLING POLLING
    case 0x28:  //--------------------------------------------------------
                // выбран чип DS18B20, нажата кнопка START CYCLING POLLING
                //--------------------------------------------------------
                // добавляем нужные переменные
                DS18B20_OUTPUT_DATA DS18B20_OutputData;         // выходные данные для функций DS18B20
                SendMsgToLogForm(119,"");    // запускаем циклический опрос
                /* fixed */
                GetDataToMemory(0,0);                        // получаем ROM с формы (второй параметр может быть любым)
                // проверяем режим питания
                if(Port!=INVALID_HANDLE_VALUE)
                { DS18B20_OutputData=DS18B20_ReadPowerSupply();   // получаем режим питания
                  // если режим питания независимый - включаем таймер
                  if((DS18B20_OutputData.Success)&&(DS18B20_OutputData.Test==0xFF))             // если у нас отдельное питание
                  { Form1->Timer1->Enabled=true;                // запускаем таймер
                    SendMsgToLogForm(103,"");        // успешно запустили циклический опрос
                  }
                  else    SendMsgToLogForm(111,""); // если режим питания паразитный - пишем, что нужно независимое питание и не включаем таймер
                }
                else    SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                break;
    case 0x2C:  //-------------------------------------------
                // выбран чип DS2890, нажата кнопка DECREMENT
                //-------------------------------------------
                // добавляем нужные переменные
                DS2890_OUTPUT_DATA DS2890_OutputData;   // выходные данные для функций 1W
                SendMsgToLogForm(149,"");    // начинаем выполнение команды
                // начинаем работать
                GetDataToMemory(0,0);                   // получаем ROM с формы (второй параметр может быть любым)
                if(Port!=INVALID_HANDLE_VALUE)
                { DS2890_OutputData=DS2890_Decrement();   // читаем данные
                  if(DS2890_OutputData.Success)           // если успешно прочитали
                  { // помещаем на форму Position
                    TempBuf[0]=DS2890_OutputData.Position;
                    BinToHex(TempBuf,OutHexBuf,1);        // преобразовать строку в целое (байт)
                    OutHexBuf[2]=0;                       // строка должна заканчиваться нулём
                    Form1->Edit4->Text = OutHexBuf;
                    SendMsgToLogForm(151,"");                // команда успешно выпонена
                  }
                  else  SendMsgToLogForm(150,"");            // выполнение команды завершено с ошибкой
                }
                else    SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                break;
    case 0x2D:  //-----------------------------------------------------
                // выбран чип DS2431, нажата кнопка WRITE REGISTER PAGE
                //-----------------------------------------------------
                // добавляем нужные переменные
                DS2431_INPUT_DATA DS2431_InputData;     // входные данные для функций DS2431
                DS2431_OUTPUT_DATA DS2431_OutputData;   // выходные данные для функций DS2431
                SendMsgToLogForm(122,"");    // начинаем запись в EEPROM страницы регистров
                // начинаем работать
                GetDataToMemory(0,0);                   // получаем ROM с формы (второй параметр может быть любым)
                // помещаем данные с формы в память в зависимости от вкладки
                switch(Form1->PageControl1->TabIndex)
                { case 0:  GetDataToMemory(3,2);        // передаём данные из RichEdit3 в Registers
                           break;
                  case 1:  GetDataToMemory(4,2);        // передаём данные из RichEdit4 в Registers
                           break;
                  default: break;
                }
                // посылаем данные из памяти по 1-Wire через блокнот и помещаем результат (Test) на форму
                // организуем цикл равный количеству кусков, равных размеру блокнота, содержащихся в отправляемой области
                for(unsigned int i=0; i<SelectedChip.Area2Size/SelectedChip.Area3Size; i++)
                { // выбираем очередной кусок для отправки в блокнот
                  DS2431_InputData.Size=SelectedChip.Area3Size;                 // размер посылки равен размеру блокнота
                  DS2431_InputData.AreaNumber=2;                                // будем посылать в блокнот данные из области регистров
                  // если порт открыт - отправляем кусок из области регистров в блокнот
                  if(Port!=INVALID_HANDLE_VALUE)
                  { TempAddr=SelectedChip.Area2Start+i*SelectedChip.Area3Size;  // вычисляем новое значение начального адреса области записи
                    DS2431_InputData.TA1=TempAddr;                              // вычисляем значение TA1
                    DS2431_InputData.TA2=TempAddr>>8;                           // вычисляем значение TA2
                    DS2431_OutputData=DS2431_WriteToScratchpad(DS2431_InputData);
                  }
                  else  // если порт закрыт - отправляем мессадж и выходим
                  { SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                    return;
                  }
                  // если порт открыт - читаем блокнот
                  if(Port!=INVALID_HANDLE_VALUE)  DS2431_OutputData=DS2431_ReadFromScratchpad();        // читаем данные из Scratchpad
                  else  // если порт закрыт - отправляем мессадж и выходим
                  { SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                    return;
                  }
                  // если прочитали - проверяем размер ответа и биты AA и PF
                  TempBuf[0]=(DS2431_OutputData.ES>>5)&0x5;                     // выделяем биты AA и PF
                  if((DS2431_OutputData.Success==false) || (TempBuf[0]!=0))
                  {     SendMsgToLogForm(105,"");    // ошибка записи данных
                        return;
                  }
                  // здесь можно дополнительно сравнивать отправленные данные и считанные в блокнот
                  // если проверка прошла успешно - копируем блокнот в память
                  DS2431_InputData.TA1=DS2431_OutputData.TA1;
                  DS2431_InputData.TA2=DS2431_OutputData.TA2;
                  DS2431_InputData.ES=DS2431_OutputData.ES;
                  if(Port!=INVALID_HANDLE_VALUE)  DS2431_OutputData=DS2431_CopyScratchpadToMemory(DS2431_InputData);
                  else  // если порт закрыт - отправляем мессадж и выходим
                  { SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                    return;
                  }
                  if(DS2431_OutputData.Success)
                  { TempBuf[0]=DS2431_OutputData.Test;
                    BinToHex(TempBuf,OutHexBuf,1);          // преобразовать строку в целое (байт)
                    OutHexBuf[2]=0;                         // строка должна заканчиваться нулём
                    Form1->Edit7->Text = OutHexBuf;         // пишем Test на форму
                  }
                  else
                  {     SendMsgToLogForm(105,"");    // ошибка записи данных
                        return;
                  }
                }
                SendMsgToLogForm(106,"");    // данные успешно записаны
                break;
    case 0x33:  //-----------------------------------------------------
                // выбран чип DS2432, нажата кнопка WRITE REGISTER PAGE
                //-----------------------------------------------------
                // добавляем нужные переменные
                DS2432_INPUT_DATA DS2432_InputData;     // входные данные для функций DS2432
                DS2432_OUTPUT_DATA DS2432_OutputData;   // выходные данные для функций DS2432
                unsigned char   RegisterTemp[8];        // временное хранилище для Register Page
                // начинаем работать
                GetDataToMemory(0,0);                   // получаем ROM с формы (второй параметр может быть любым)
                // получаем с формы Secret (Data для расчёта MAC (при записи Register Page) не нужны)
                switch(Form1->PageControl1->TabIndex)
                { case 0:  GetDataToMemory(3,2);        // передаём данные из RichEdit3 в Secret
                           break;
                  case 1:  GetDataToMemory(4,2);        // передаём данные из RichEdit4 в Secret
                           break;
                  default: break;
                }
                // сначала нужно прочитать и сохранить текущие данные из Register Page
                DS2432_InputData.TA1=SelectedChip.Area3Start;   // вычисляем TA1
                DS2432_InputData.TA2=SelectedChip.Area3Start>>8;// вычисляем TA2
                DS2432_InputData.AreaNumber=3;                  // будем сохранять прочитанное в область регистров
                DS2432_InputData.Size=SelectedChip.Area3Size;   // размер равен области регистров
                if(Port!=INVALID_HANDLE_VALUE)  DS2432_OutputData=DS2432_ReadFromMemory(DS2432_InputData);      // читаем область регистров
                else  // если порт закрыт - отправляем мессадж и выходим
                { SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                  return;
                }
                if(DS2432_OutputData.Success)                   // если успешно прочитали
                { // сохраняем прочитанные данные во временное хранилище
                  for(unsigned char i=0; i<8; i++)
                  {     RegisterTemp[i]=SelectedChip.Area3[i];
                  }
                  SendMsgToLogForm(108,"");    // данные успешно прочитаны
                }
                else
                {       SendMsgToLogForm(107,"");    // чтение данных завершилось с ошибкой
                        return;
                }
                // записываем область регистров в scratchpad
                SendMsgToLogForm(116,"");    // начинаем запись в блокнот
                DS2432_InputData.TA1=SelectedChip.Area3Start;   // сохраняем значение TA1
                DS2432_InputData.TA2=0;                 // сохраняем значение TA2
                // помещаем данные с формы в память в зависимости от вкладки (для DS2432 Register Page находится в Area3)
                switch(Form1->PageControl1->TabIndex)
                { case 0:  GetDataToMemory(5,3);        // передаём данные из RichEdit5 в Scratchpad
                           break;
                  case 1:  GetDataToMemory(6,3);        // передаём данные из RichEdit6 в Scratchpad
                           break;
                  default: break;
                }
                // посылаем данные по 1-Wire и помещаем результат (Test) на форму
                DS2432_InputData.AreaNumber=3;                  // Register Page - это Area3
                DS2432_InputData.Size=SelectedChip.Area3Size;   // размер register page равен размеру блокнота
                if(Port!=INVALID_HANDLE_VALUE)
                { DS2432_OutputData=DS2432_WriteToScratchpad(DS2432_InputData);
                  if(DS2432_OutputData.Success)
                  { TempBuf[0]=DS2432_OutputData.Test;
                    BinToHex(TempBuf,OutHexBuf,1);      // преобразовать строку в целое (байт)
                    OutHexBuf[2]=0;                     // строка должна заканчиваться нулём
                    Form1->Edit7->Text = OutHexBuf;
                    SendMsgToLogForm(106,"");                // запись в scratchpad успешно завершена
                  }
                  else
                  {  SendMsgToLogForm(105,"");            // запись в scratchpad завершена с ошибкой
                     return;
                  }
                }
                else
                {    SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                     return;
                }
                // читаем блокнот обратно, чтобы получить код авторизации (TA1, TA2, ES)
                if(Port!=INVALID_HANDLE_VALUE)
                { DS2432_OutputData=DS2432_ReadFromScratchpad();  // читаем данные из Scratchpad
                  if(DS2432_OutputData.Success)           // если успешно прочитали
                  { DS2432_InputData.ES=DS2432_OutputData.ES;      // запоминаем E/S
                    DS2432_InputData.TA2=DS2432_OutputData.TA2;    // запоминаем TA2
                    DS2432_InputData.TA1=DS2432_OutputData.TA1;    // запоминаем TA1
                    SendMsgToLogForm(108,"");                // чтение блокнота успешно завершено
                  }
                  else
                  {  SendMsgToLogForm(107,"");            // чтение блокнота завершено с ошибкой
                     return;
                  }
                }
                else
                {    SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                     return;
                }
                // восстанавливаем сохранённые данные Register Page (нужно для расчёта MAC)
                for(unsigned char i=0; i<8; i++)
                {     SelectedChip.Area3[i]=RegisterTemp[i];
                }
                // выполняем копирование блокнота в память
                if(Port!=INVALID_HANDLE_VALUE)
                { DS2432_OutputData=DS2432_CopyScratchpadToMemory(DS2432_InputData);
                  if(DS2432_OutputData.Success)
                  { TempBuf[0]=DS2432_OutputData.Test;
                    BinToHex(TempBuf,OutHexBuf,1);        // преобразовать строку в целое (байт)
                    OutHexBuf[2]=0;                       // строка должна заканчиваться нулём
                    Form1->Edit7->Text = OutHexBuf;
                    SendMsgToLogForm(110,"");    // копирование из блокнота в EEPROM успешно завершено
                  }
                  else    SendMsgToLogForm(109,"");    // во время копирование из блокнота в EEPROM произошла ошибка
                }
                else    SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                break;
    case 0x3B:  //------------------------------------------------------
                // выбран чип MAX31826, нажата кнопка WRITE SCRATCHPAD 2
                //------------------------------------------------------
                // добавляем нужные переменные
                MAX31826_INPUT_DATA MAX31826_InputData;     // входные данные для функций MAX31826
                MAX31826_OUTPUT_DATA MAX31826_OutputData;   // выходные данные для функций MAX31826
                SendMsgToLogForm(116,"");    // начинаем запись в блокнот
                // начинаем работать
                GetDataToMemory(0,0);                   // получаем ROM с формы (второй параметр может быть любым)
                TempStr=LowerCase(Form1->Edit4->Text);  // получаем SA в строку
                InHexBuf=TempStr.c_str();               // скопировать в буфер байт для передачи (в виде строки)
                HexToBin(InHexBuf,TempBuf,1);           // преобразовать строку в целое (байт)
                MAX31826_InputData.SA=TempBuf[0];       // сохраняем значение SA
                // помещаем данные с формы в память в зависимости от вкладки (для MAX31826 Scratchpad 2 находится в Area2)
                switch(Form1->PageControl1->TabIndex)
                { case 0:  GetDataToMemory(3,2);        // передаём данные из RichEdit3 в Scratchpad
                           break;
                  case 1:  GetDataToMemory(4,2);        // передаём данные из RichEdit4 в Scratchpad
                           break;
                  default: break;
                }
                // посылаем данные по 1-Wire
                MAX31826_InputData.AreaNumber=2;                  // блокнот 2 - это Area2
                MAX31826_InputData.Size=SelectedChip.Area2Size;   // размер равен размеру блокнота
                if(Port!=INVALID_HANDLE_VALUE)
                { MAX31826_OutputData=MAX31826_WriteToScratchpad(MAX31826_InputData);
                  if(MAX31826_OutputData.Success) SendMsgToLogForm(106,"");  // запись в scratchpad успешно завершена
                  else                          SendMsgToLogForm(105,"");  // запись в scratchpad завершена с ошибкой
                }
                else    SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                break;
    case 0x43:  //-----------------------------------------------------
                // выбран чип DS28EC20, нажата кнопка WRITE REGISTER PAGE
                //-----------------------------------------------------
                // добавляем нужные переменные
                DS28EC20_INPUT_DATA DS28EC20_InputData;     // входные данные для функций DS28EC20
                DS28EC20_OUTPUT_DATA DS28EC20_OutputData;   // выходные данные для функций DS28EC20
                SendMsgToLogForm(122,"");    // начинаем запись в EEPROM страницы регистров
                // начинаем работать
                GetDataToMemory(0,0);                   // получаем ROM с формы (второй параметр может быть любым)
                // помещаем данные с формы в память в зависимости от вкладки
                switch(Form1->PageControl1->TabIndex)
                { case 0:  GetDataToMemory(3,2);        // передаём данные из RichEdit3 в Registers
                           break;
                  case 1:  GetDataToMemory(4,2);        // передаём данные из RichEdit4 в Registers
                           break;
                  default: break;
                }
                // посылаем данные из памяти по 1-Wire через блокнот и помещаем результат (Test) на форму
                // организуем цикл равный количеству кусков, равных размеру блокнота, содержащихся в отправляемой области
                for(unsigned int i=0; i<SelectedChip.Area2Size/SelectedChip.Area4Size; i++)
                { // выбираем очередной кусок для отправки в блокнот
                  DS28EC20_InputData.Size=SelectedChip.Area4Size;                 // размер посылки равен размеру блокнота
                  DS28EC20_InputData.AreaNumber=2;                                // будем посылать в блокнот данные из области регистров
                  // если порт открыт - отправляем кусок из области регистров в блокнот
                  if(Port!=INVALID_HANDLE_VALUE)
                  { TempAddr=SelectedChip.Area2Start+i*SelectedChip.Area4Size;  // вычисляем новое значение начального адреса области записи
                    DS28EC20_InputData.TA1=TempAddr;                              // вычисляем значение TA1
                    DS28EC20_InputData.TA2=TempAddr>>8;                           // вычисляем значение TA2
                    DS28EC20_OutputData=DS28EC20_WriteToScratchpad(DS28EC20_InputData);
                  }
                  else  // если порт закрыт - отправляем мессадж и выходим
                  { SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                    return;
                  }
                  // если порт открыт - читаем блокнот
                  if(Port!=INVALID_HANDLE_VALUE)  DS28EC20_OutputData=DS28EC20_ReadFromScratchpad();        // читаем данные из Scratchpad
                  else  // если порт закрыт - отправляем мессадж и выходим
                  { SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                    return;
                  }
                  // если прочитали - проверяем размер ответа и биты AA и PF
                  TempBuf[0]=(DS28EC20_OutputData.ES>>5)&0x5;                     // выделяем биты AA и PF
                  if((DS28EC20_OutputData.Success==false) || (TempBuf[0]!=0))
                  {     SendMsgToLogForm(105,"");    // ошибка записи данных
                        return;
                  }
                  // здесь можно дополнительно сравнивать отправленные данные и считанные в блокнот
                  // если проверка прошла успешно - копируем блокнот в память
                  DS28EC20_InputData.TA1=DS28EC20_OutputData.TA1;
                  DS28EC20_InputData.TA2=DS28EC20_OutputData.TA2;
                  DS28EC20_InputData.ES=DS28EC20_OutputData.ES;
                  if(Port!=INVALID_HANDLE_VALUE)  DS28EC20_OutputData=DS28EC20_CopyScratchpadToMemory(DS28EC20_InputData);
                  else  // если порт закрыт - отправляем мессадж и выходим
                  { SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                    return;
                  }
                  if(DS28EC20_OutputData.Success)
                  { TempBuf[0]=DS28EC20_OutputData.Test;
                    BinToHex(TempBuf,OutHexBuf,1);          // преобразовать строку в целое (байт)
                    OutHexBuf[2]=0;                         // строка должна заканчиваться нулём
                    Form1->Edit7->Text = OutHexBuf;         // пишем Test на форму
                  }
                  else
                  {     SendMsgToLogForm(105,"");    // ошибка записи данных
                        return;
                  }
                }
                SendMsgToLogForm(106,"");    // данные успешно записаны
                break;
    case 0x5:   // выбран чип DS2405
    case 0x24:  // выбран чип DS2415
    case 0x27:  // выбран чип DS2417
    default:    break;
  }
}
//---------------------------------------------------------------------------
//--- НАЖАТА КНОПКА BUTTON8 -------------------------------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::Button8Click(TObject *Sender)
{ AnsiString TempStr;                           // для преобразования
  char *InHexBuf, TempBuf[1], OutHexBuf[3];     // для преобразования

  switch(SelectedChip.Family)
  { case 0x0:   // выбран один из чипов с перезаписываемым ROM
                switch(SelectedChip.Modify)
                { case 1:  // выбран чип RW1990
                  case 2:  // выбран ключ AN1990
                  case 3:  // выбран ключ TM2004
                  default: break;
                }
                break;
    case 0x2:   //-------------------------------------------------------
                // выбран чип DS1991, нажата кнопка READ DATA FROM SUBKEY
    case 0x82:  //-------------------------------------------------------
                // выбран чип DS1425, нажата кнопка READ DATA FROM SUBKEY
                //-------------------------------------------------------
                // добавляем нужные переменные
                DS1991_OUTPUT_DATA DS1991_OutputData; // выходные данные для функций DS1991
                DS1991_INPUT_DATA DS1991_InputData;   // входные данные для функций DS1991
                unsigned char DS1991_Done;            // счётчик количества записей
                SendMsgToLogForm(135,"");    // начинаем чтение ключа
                // начинаем работать
                DS1991_Done=0;                        // ни одна область пока не прочитана
                GetDataToMemory(0,0);                   // получаем ROM с формы (второй параметр может быть любым)
                for(unsigned int DS1991_i=0; DS1991_i<3; DS1991_i++)
                { DS1991_InputData.AreaNumber=0;        // признак того, что ничего читать не нужно
                  switch(DS1991_i)
                  { case 0: if(Form1->CheckBox1->Checked==true) DS1991_InputData.AreaNumber=1;  // проверяем, нужно ли читать subkey1
                            break;
                    case 1: if(Form1->CheckBox2->Checked==true) DS1991_InputData.AreaNumber=2;  // проверяем, нужно ли читать subkey2
                            break;
                    case 2: if(Form1->CheckBox3->Checked==true) DS1991_InputData.AreaNumber=3;  // проверяем, нужно ли читать subkey3
                            break;
                    default: break;
                  }
                  if(DS1991_InputData.AreaNumber!=0)    // если нужно читать
                  { if(Port!=INVALID_HANDLE_VALUE)
                    { DS1991_OutputData=DS1991_ReadSubKey(DS1991_InputData);    // посылаем команду Read SubKey
                      if(DS1991_OutputData.Success)
                      { SendMsgToLogForm(108,"");          // чтение ключа успешно завершено
                        // обновляем данные в нужном RichEdit
                        if(DS1991_i==0)                 // если читали ключ 1
                        {  switch(Form1->PageControl1->TabIndex)
                           { case 0:  PlaceDataToForm(1,1);      // из Area1 в RichEdit1
                                      break;
                             case 1:  PlaceDataToForm(2,1);      // из Area1 в RichEdit2
                                      break;
                             default: break;
                           }
                        }
                        else if(DS1991_i==1)            // если читали ключ 2
                        {  switch(Form1->PageControl1->TabIndex)
                           { case 0:  PlaceDataToForm(3,2);      // из Area2 в RichEdit3
                                      break;
                             case 1:  PlaceDataToForm(4,2);      // из Area2 в RichEdit4
                                      break;
                             default: break;
                           }
                        }
                        else                            // если читали ключ 3
                        {  switch(Form1->PageControl1->TabIndex)
                           { case 0:  PlaceDataToForm(5,3);      // из Area3 в RichEdit5
                                      break;
                             case 1:  PlaceDataToForm(6,3);      // из Area3 в RichEdit6
                                      break;
                             default: break;
                           }
                        }
                      }
                      else                                  SendMsgToLogForm(107,"");        // во время чтения ключа произошла ошибка
                    }
                    else    SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                    DS1991_Done+=1;           // увеличиваем количество попыток чтения
                  }
                }
                if(DS1991_Done==0)      SendMsgToLogForm(133,"");  // не выбрана ни одна область, для которой нужно выполнить действие
                break;
    case 0x4:   //--------------------------------------------------------
                // выбран чип DS1994, нажата кнопка WRITE TIMEKEEPING REGS
    case 0x84:  //--------------------------------------------------------
                // выбран чип DS1427, нажата кнопка WRITE TIMEKEEPING REGS
                //--------------------------------------------------------
                // добавляем нужные переменные
                DS1994_INPUT_DATA DS1994_InputData;       // входные данные для функций DS1994
                DS1994_OUTPUT_DATA DS1994_OutputData;     // выходные данные для функций DS1994
                unsigned int TempAddr;                    // для вычисления адреса
                unsigned char DS1994_SelectData;          // переменная для выбора данных для отправки
                bool DS1994_NeedMore;                     // признак, что нужно дослать ещё байты

                SendMsgToLogForm(144,"");                    // начинаем запись данных в timekeeping registers
                // начинаем работать
                GetDataToMemory(0,0);                     // получаем ROM с формы (второй параметр может быть любым)
                // помещаем данные с формы в память в зависимости от вкладки
                switch(Form1->PageControl1->TabIndex)
                { case 0:  GetDataToMemory(3,2);        // передаём данные из RichEdit3 в Timekeeping Regs
                           break;
                  case 1:  GetDataToMemory(4,2);        // передаём данные из RichEdit4 в Timekeeping Regs
                           break;
                  default: break;
                }
                DS1994_InputData.AreaNumber=2;          // будем посылать в блокнот данные из области Timekeeping Registers
                DS1994_NeedMore=false;                  // по-умолчанию ничего досылать не нужно
                // здесь нужно понять, какие данные мы шлём
                DS1994_SelectData=0;
                if(Form1->CheckBox1->Checked==true)     DS1994_SelectData += 1; // нулевой бит
                if(Form1->CheckBox2->Checked==true)     DS1994_SelectData += 2; // первый бит
                if(Form1->CheckBox3->Checked==true)     DS1994_SelectData += 4; // второй бит
                // посылаем данные из памяти по 1-Wire через блокнот
                switch(DS1994_SelectData)
                { case 1:       // посылаем только Status
                                DS1994_InputData.Size=1;                // размер посылки равен 1 байту
                                TempAddr=SelectedChip.Area2Start;       // вычисляем новое значение начального адреса области записи
                                break;
                  case 2:       // посылаем только Control
                                DS1994_InputData.Size=1;                // размер посылки равен 1 байту
                                TempAddr=SelectedChip.Area2Start+1;     // вычисляем новое значение начального адреса области записи
                                break;
                  case 3:       // посылаем Status + Control
                                DS1994_InputData.Size=2;                // размер посылки равен 2 байта
                                TempAddr=SelectedChip.Area2Start;       // вычисляем новое значение начального адреса области записи
                                break;
                  case 4:       // посылаем всё, кроме Status и Control
                                DS1994_InputData.Size=SelectedChip.Area2Size-2; // размер посылки равен 32-2 байт
                                TempAddr=SelectedChip.Area2Start+2;     // вычисляем новое значение начального адреса области записи
                                break;
                  case 5:       // нужно послать Status, а потом дослать байты после Control
                                DS1994_InputData.Size=1;                // размер посылки равен 1 байту
                                TempAddr=SelectedChip.Area2Start;       // вычисляем новое значение начального адреса области записи
                                DS1994_NeedMore=true;                   // будем досылать ещё данные
                                break;
                  case 6:       // посылаем всё, кроме Status
                                DS1994_InputData.Size=SelectedChip.Area2Size-1; // размер посылки равен 32-1 байт
                                TempAddr=SelectedChip.Area2Start+1;     // вычисляем новое значение начального адреса области записи
                                break;
                  case 7:       // посылаем всё
                                DS1994_InputData.Size=SelectedChip.Area2Size; // размер посылки равен 32 байта
                                TempAddr=SelectedChip.Area2Start;     // вычисляем новое значение начального адреса области записи
                                break;
                  default:      // шлём сообщение, что не выбрано что читать или писать и выходим
                                SendMsgToLogForm(145,"");    // не выбрано что писать/читать
                                return;
                }
                DS1994_Write_Timekeeping_Regs_Label1:
                // если порт открыт - отправляем кусок из нужной области в блокнот
                if(Port!=INVALID_HANDLE_VALUE)
                { DS1994_InputData.TA1=TempAddr;                                      // вычисляем значение TA1
                  DS1994_InputData.TA2=TempAddr>>8;                                   // вычисляем значение TA2
                  DS1994_OutputData=DS1994_WriteToScratchpad(DS1994_InputData);
                }
                else  // если порт закрыт - отправляем мессадж и выходим
                { SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                  return;
                }
                // если порт открыт - читаем блокнот
                if(Port!=INVALID_HANDLE_VALUE)  DS1994_OutputData=DS1994_ReadFromScratchpad();        // читаем данные из Scratchpad
                else  // если порт закрыт - отправляем мессадж и выходим
                { SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                  return;
                }
                // здесь можно дополнительно сравнивать отправленные данные и считанные в блокнот
                // если прочитали - проверяем ответ
                if(DS1994_OutputData.Success==false)
                {     SendMsgToLogForm(105,"");    // ошибка записи
                      return;
                }
                // если проверка прошла успешно - копируем блокнот в память
                DS1994_InputData.TA1=DS1994_OutputData.TA1;
                DS1994_InputData.TA2=DS1994_OutputData.TA2;
                DS1994_InputData.ES=DS1994_OutputData.ES;
                if(Port!=INVALID_HANDLE_VALUE)  DS1994_OutputData=DS1994_CopyScratchpadToMemory(DS1994_InputData);
                else  // если порт закрыт - отправляем мессадж и выходим
                { SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                  return;
                }
                // если нужно - выполняем копирование ещё два раза
                if(Form1->CheckBox4->Checked==true)
                { DS1994_InputData.ES |= 0x80;  // устанавливаем бит AA (7-й)
                  // выполняем первое дополнительное копирование
                  if(Port!=INVALID_HANDLE_VALUE)  DS1994_OutputData=DS1994_CopyScratchpadToMemory(DS1994_InputData);
                  else  // если порт закрыт - отправляем мессадж и выходим
                  { SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                    return;
                  }
                  // выполняем второе дополнительное копирование
                  if(Port!=INVALID_HANDLE_VALUE)  DS1994_OutputData=DS1994_CopyScratchpadToMemory(DS1994_InputData);
                  else  // если порт закрыт - отправляем мессадж и выходим
                  { SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                    return;
                  }
                }
                if(DS1994_OutputData.Success==false)
                {     SendMsgToLogForm(105,"");    // ошибка записи
                      return;
                }
                if(DS1994_NeedMore==true)       // если нужно дослать данные после Control
                { DS1994_NeedMore=false;
                  DS1994_InputData.Size=SelectedChip.Area2Size-2; // размер посылки равен 32-2 байт
                  TempAddr=SelectedChip.Area2Start+2;     // вычисляем новое значение начального адреса области записи
                  goto DS1994_Write_Timekeeping_Regs_Label1;
                }
                SendMsgToLogForm(106,"");    // запись успешно завершена
                break;
    case 0x6:   //--------------------------------------------------
                // выбран чип DS1993, нажата кнопка READ DATA MEMORY
    case 0x8:   //--------------------------------------------------
                // выбран чип DS1992, нажата кнопка READ DATA MEMORY
    case 0xA:   //--------------------------------------------------
                // выбран чип DS1995, нажата кнопка READ DATA MEMORY
    case 0xC:   //--------------------------------------------------
                // выбран чип DS1996, нажата кнопка READ DATA MEMORY
                //--------------------------------------------------
                // добавляем нужные переменные
                DS1992_OUTPUT_DATA DS1992_OutputData;           // выходные данные для функций DS1992
                DS1992_INPUT_DATA DS1992_InputData;             // входные данные для функций DS1992
                SendMsgToLogForm(124,"");           // начинаем чтение данных из EEPROM
                // начинаем работать
                GetDataToMemory(0,0);                     // получаем ROM с формы (второй параметр может быть любым)
                DS1992_InputData.TA1=SelectedChip.Area1Start;          // вычисляем TA1
                DS1992_InputData.TA2=SelectedChip.Area1Start>>8;       // вычисляем TA2
                if(Port!=INVALID_HANDLE_VALUE)  DS1992_OutputData=DS1992_ReadFromMemory(DS1992_InputData); // читаем область данных
                else  // если порт закрыт - отправляем мессадж и выходим
                { SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                  return;
                }
                if(DS1992_OutputData.Success)                          // если успешно прочитали
                { // помещаем на форму Test
                  TempBuf[0]=DS1992_OutputData.Test;
                  BinToHex(TempBuf,OutHexBuf,1);        // преобразовать строку в целое (байт)
                  OutHexBuf[2]=0;                       // строка должна заканчиваться нулём
                  Form1->Edit7->Text = OutHexBuf;
                  // помещаем данные из памяти на форму
                  switch(Form1->PageControl1->TabIndex)
                  { case 0:  PlaceDataToForm(1,1);
                             break;
                    case 1:  PlaceDataToForm(2,1);
                             break;
                    default: break;
                  }
                  SendMsgToLogForm(108,"");    // данные успешно прочитаны
                }
                else      SendMsgToLogForm(107,"");    // чтение данных завершилось с ошибкой
                break;
    case 0x9:   //------------------------------------------------------
                // выбран чип DS2502 / DS1982, нажата кнопка READ STATUS
                //------------------------------------------------------
                // добавляем нужные переменные
                DS2502_OUTPUT_DATA DS2502_OutputData;   // выходные данные для функций 1W
                SendMsgToLogForm(127,"");    // начинаем чтение Status
                // начинаем работать
                GetDataToMemory(0,0);                   // получаем ROM с формы (второй параметр может быть любым)
                if(Port!=INVALID_HANDLE_VALUE)
                { DS2502_OutputData=DS2502_ReadFromStatus();  // читаем данные из Status
                  if(DS2502_OutputData.Success)           // если успешно прочитали
                  { // помещаем на форму Test
                    TempBuf[0]=DS2502_OutputData.Test;
                    BinToHex(TempBuf,OutHexBuf,1);        // преобразовать строку в целое (байт)
                    OutHexBuf[2]=0;                       // строка должна заканчиваться нулём
                    Form1->Edit7->Text = OutHexBuf;
                    // помещаем данные из памяти на форму
                    switch(Form1->PageControl1->TabIndex)
                    { case 0:  PlaceDataToForm(3,2);
                               break;
                      case 1:  PlaceDataToForm(4,2);
                               break;
                      default: break;
                    }
                    SendMsgToLogForm(108,"");                // чтение успешно завершено
                  }
                  else  SendMsgToLogForm(107,"");            // чтение завершено с ошибкой
                }
                else    SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                break;
    case 0x10:  //-------------------------------------------------------
                // выбран чип DS18S20, нажата кнопка STOP CYCLING POLLING
                //-------------------------------------------------------
                SendMsgToLogForm(123,"");           // останавливаем циклический опрос
                Form1->Timer1->Enabled=false;    // выключаем таймер
                SendMsgToLogForm(104,"");           // таймер остановлен
                break;
    case 0x14:  //----------------------------------------------
                // выбран чип DS2430, нажата кнопка WRITE EEPROM
                //----------------------------------------------
                // добавляем нужные переменные
                DS2430_INPUT_DATA DS2430_InputData;     // входные данные для функций DS2430
                DS2430_OUTPUT_DATA DS2430_OutputData;   // выходные данные для функций DS2430
                SendMsgToLogForm(121,"");           // начинаем запись данных в EEPROM
                // начинаем работать
                GetDataToMemory(0,0);                   // получаем ROM с формы (второй параметр может быть любым)
                // помещаем данные с формы в память в зависимости от вкладки
                switch(Form1->PageControl1->TabIndex)
                { case 0:  GetDataToMemory(1,1);        // передаём данные из RichEdit1 в Data
                           break;
                  case 1:  GetDataToMemory(2,1);        // передаём данные из RichEdit2 в Data
                           break;
                  default: break;
                }
                // посылаем данные из памяти Area1 по 1-Wire в Scratchpad
                DS2430_InputData.AreaNumber=1;
                if(Port!=INVALID_HANDLE_VALUE)
                { DS2430_OutputData=DS2430_WriteToScratchpad(DS2430_InputData);
                }
                else  // если порт закрыт - отправляем мессадж и выходим
                { SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                  return;
                }
                // здесь можно при желании считать блокнот обратно и сверить с данными
                // копируем из блокнота в EEPROM
                if(Port!=INVALID_HANDLE_VALUE)  DS2430_OutputData=DS2430_CopyScratchpadToMemory();
                else  // если порт закрыт - отправляем мессадж и выходим
                { SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                  return;
                }
                if(DS2430_OutputData.Success)   SendMsgToLogForm(106,"");    // данные успешно записаны
                else                            SendMsgToLogForm(105,"");    // ошибка записи данных
                break;
    case 0x1A:  //---------------------------------------------------
                // выбран чип DS1963L, нажата кнопка READ DATA MEMORY
    case 0x1D:  //---------------------------------------------------
                // выбран чип DS2423, нажата кнопка READ DATA MEMORY
                //---------------------------------------------------
                // добавляем нужные переменные
                DS1963L_OUTPUT_DATA DS1963L_OutputData;           // выходные данные для функций DS1963L
                DS1963L_INPUT_DATA DS1963L_InputData;             // входные данные для функций DS1963L
                SendMsgToLogForm(124,"");           // начинаем чтение данных из EEPROM
                // начинаем работать
                GetDataToMemory(0,0);                     // получаем ROM с формы (второй параметр может быть любым)
                DS1963L_InputData.TA1=SelectedChip.Area1Start;          // вычисляем TA1
                DS1963L_InputData.TA2=SelectedChip.Area1Start>>8;       // вычисляем TA2
                if(Port!=INVALID_HANDLE_VALUE)  DS1963L_OutputData=DS1963L_ReadFromMemory(DS1963L_InputData); // читаем область данных
                else  // если порт закрыт - отправляем мессадж и выходим
                { SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                  return;
                }
                if(DS1963L_OutputData.Success)                          // если успешно прочитали
                { // помещаем на форму Test
                  TempBuf[0]=DS1963L_OutputData.Test;
                  BinToHex(TempBuf,OutHexBuf,1);        // преобразовать строку в целое (байт)
                  OutHexBuf[2]=0;                       // строка должна заканчиваться нулём
                  Form1->Edit7->Text = OutHexBuf;
                  // помещаем данные из памяти на форму
                  switch(Form1->PageControl1->TabIndex)
                  { case 0:  PlaceDataToForm(1,1);
                             break;
                    case 1:  PlaceDataToForm(2,1);
                             break;
                    default: break;
                  }
                  SendMsgToLogForm(108,"");    // данные успешно прочитаны
                }
                else      SendMsgToLogForm(107,"");    // чтение данных завершилось с ошибкой
                break;
    case 0x23:  //---------------------------------------------------
                // выбран чип DS24B33, нажата кнопка READ DATA MEMORY
                //---------------------------------------------------
                // добавляем нужные переменные
                DS24B33_OUTPUT_DATA DS24B33_OutputData;           // выходные данные для функций DS24B33
                DS24B33_INPUT_DATA DS24B33_InputData;             // входные данные для функций DS24B33
                SendMsgToLogForm(124,"");           // начинаем чтение данных из EEPROM
                // начинаем работать
                GetDataToMemory(0,0);                     // получаем ROM с формы (второй параметр может быть любым)
                DS24B33_InputData.TA1=SelectedChip.Area1Start;          // вычисляем TA1
                DS24B33_InputData.TA2=SelectedChip.Area1Start>>8;       // вычисляем TA2
                if(Port!=INVALID_HANDLE_VALUE)  DS24B33_OutputData=DS24B33_ReadFromMemory(DS24B33_InputData); // читаем область данных
                else  // если порт закрыт - отправляем мессадж и выходим
                { SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                  return;
                }
                if(DS24B33_OutputData.Success)                          // если успешно прочитали
                { // помещаем на форму Test
                  TempBuf[0]=DS24B33_OutputData.Test;
                  BinToHex(TempBuf,OutHexBuf,1);        // преобразовать строку в целое (байт)
                  OutHexBuf[2]=0;                       // строка должна заканчиваться нулём
                  Form1->Edit7->Text = OutHexBuf;
                  // помещаем данные из памяти на форму
                  switch(Form1->PageControl1->TabIndex)
                  { case 0:  PlaceDataToForm(1,1);
                             break;
                    case 1:  PlaceDataToForm(2,1);
                             break;
                    default: break;
                  }
                  SendMsgToLogForm(108,"");    // данные успешно прочитаны
                }
                else      SendMsgToLogForm(107,"");    // чтение данных завершилось с ошибкой
                break;
    case 0x22:  //-------------------------------------------------------
                // выбран чип DS1822, нажата кнопка STOP CYCLING POLLING
    case 0x28:  //-------------------------------------------------------
                // выбран чип DS18B20, нажата кнопка STOP CYCLING POLLING
                //-------------------------------------------------------
                SendMsgToLogForm(123,"");           // останавливаем циклический опрос
                Form1->Timer1->Enabled=false;   // выключаем таймер
                SendMsgToLogForm(104,"");           // таймер остановлен
                break;
    case 0x2C:  //--------------------------------------------------------
                // выбран чип DS2890, нажата кнопка WRITE CONTROL REGISTER
                //--------------------------------------------------------
                // добавляем нужные переменные
                DS2890_INPUT_DATA DS2890_InputData;     // входные данные для функций DS2890
                DS2890_OUTPUT_DATA DS2890_OutputData;   // выходные данные для функций DS2890
                SendMsgToLogForm(142,"");    // начинаем запись данных
                // начинаем работать
                GetDataToMemory(0,0);                   // получаем ROM с формы (второй параметр может быть любым)
                TempStr=LowerCase(Form1->Edit5->Text);  // получаем Control в строку
                InHexBuf=TempStr.c_str();               // скопировать в буфер байт для передачи (в виде строки)
                HexToBin(InHexBuf,TempBuf,1);           // преобразовать строку в целое (байт)
                DS2890_InputData.Control=TempBuf[0];    // сохраняем значение Control
                // выполняем команду WriteControl и помещаем результат (Test) на форму
                if(Port!=INVALID_HANDLE_VALUE)
                { DS2890_OutputData=DS2890_WriteControl(DS2890_InputData);
                  if(DS2890_OutputData.Success==true && DS2890_OutputData.Test==0)
                        SendMsgToLogForm(106,"");  // запись успешно завершена
                  else  SendMsgToLogForm(105,"");  // запись завершена с ошибкой
                }
                else    SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                break;
    case 0x2D:  //----------------------------------------------------
                // выбран чип DS2431, нажата кнопка READ REGISTER PAGE
                //----------------------------------------------------
                // добавляем нужные переменные
                DS2431_OUTPUT_DATA DS2431_OutputData;           // выходные данные для функций DS2431
                DS2431_INPUT_DATA DS2431_InputData;             // входные данные для функций DS2431
                SendMsgToLogForm(125,"");           // начинаем чтение из EEPROM страницы регистров
                // начинаем работать
                GetDataToMemory(0,0);                 // получаем ROM с формы (второй параметр может быть любым)
                DS2431_InputData.TA1=SelectedChip.Area2Start;   // вычисляем TA1
                DS2431_InputData.TA2=SelectedChip.Area2Start>>8;// вычисляем TA2
                DS2431_InputData.AreaNumber=2;                  // будем сохранять прочитанное в область регистров
                DS2431_InputData.Size=SelectedChip.Area2Size;   // размер равен области регистров
                if(Port!=INVALID_HANDLE_VALUE)  DS2431_OutputData=DS2431_ReadFromMemory(DS2431_InputData);      // читаем область регистров
                else  // если порт закрыт - отправляем мессадж и выходим
                { SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                  return;
                }
                if(DS2431_OutputData.Success)                   // если успешно прочитали
                { // помещаем на форму Test
                  TempBuf[0]=DS2431_OutputData.Test;
                  BinToHex(TempBuf,OutHexBuf,1);        // преобразовать строку в целое (байт)
                  OutHexBuf[2]=0;                       // строка должна заканчиваться нулём
                  Form1->Edit7->Text = OutHexBuf;
                  // помещаем данные из памяти на форму
                  switch(Form1->PageControl1->TabIndex)
                  { case 0:  PlaceDataToForm(3,2);
                             break;
                    case 1:  PlaceDataToForm(4,2);
                             break;
                    default: break;
                  }
                  SendMsgToLogForm(108,"");    // данные успешно прочитаны
                }
                else      SendMsgToLogForm(107,"");    // чтение данных завершилось с ошибкой
                break;
    case 0x33:  //----------------------------------------------------
                // выбран чип DS2432, нажата кнопка READ REGISTER PAGE
                //----------------------------------------------------
                // добавляем нужные переменные
                DS2432_OUTPUT_DATA DS2432_OutputData;           // выходные данные для функций DS2432
                DS2432_INPUT_DATA DS2432_InputData;             // входные данные для функций DS2432
                SendMsgToLogForm(125,"");           // начинаем чтение из EEPROM страницы регистров
                // начинаем работать
                GetDataToMemory(0,0);                 // получаем ROM с формы (второй параметр может быть любым)
                DS2432_InputData.TA1=SelectedChip.Area3Start;   // вычисляем TA1
                DS2432_InputData.TA2=SelectedChip.Area3Start>>8;// вычисляем TA2
                DS2432_InputData.AreaNumber=3;                  // будем сохранять прочитанное в область регистров
                DS2432_InputData.Size=SelectedChip.Area3Size;   // размер равен области регистров
                if(Port!=INVALID_HANDLE_VALUE)  DS2432_OutputData=DS2432_ReadFromMemory(DS2432_InputData);      // читаем область регистров
                else  // если порт закрыт - отправляем мессадж и выходим
                { SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                  return;
                }
                if(DS2432_OutputData.Success)                   // если успешно прочитали
                { // помещаем на форму Test
                  TempBuf[0]=DS2432_OutputData.Test;
                  BinToHex(TempBuf,OutHexBuf,1);        // преобразовать строку в целое (байт)
                  OutHexBuf[2]=0;                       // строка должна заканчиваться нулём
                  Form1->Edit7->Text = OutHexBuf;
                  // помещаем данные из памяти на форму
                  switch(Form1->PageControl1->TabIndex)
                  { case 0:  PlaceDataToForm(5,3);
                             break;
                    case 1:  PlaceDataToForm(6,3);
                             break;
                    default: break;
                  }
                  SendMsgToLogForm(108,"");    // данные успешно прочитаны
                }
                else      SendMsgToLogForm(107,"");    // чтение данных завершилось с ошибкой
                break;
    case 0x3B:  //-----------------------------------------------------
                // выбран чип MAX31826, нажата кнопка Read Scratchpad 2
                //-----------------------------------------------------
                // добавляем нужные переменные
                MAX31826_OUTPUT_DATA MAX31826_OutputData;   // выходные данные для функций 1W
                MAX31826_INPUT_DATA MAX31826_InputData;     // входные данные для функций 1W
                // начинаем работать
                GetDataToMemory(0,0);                       // получаем ROM с формы (второй параметр может быть любым)
                if(Port!=INVALID_HANDLE_VALUE)
                { SendMsgToLogForm(117,"Scratchpad 2");                // начинаем чтение блокнота
                  TempStr=LowerCase(Form1->Edit4->Text);  // получаем SA в строку
                  InHexBuf=TempStr.c_str();               // скопировать в буфер байт для передачи (в виде строки)
                  HexToBin(InHexBuf,TempBuf,1);           // преобразовать строку в целое (байт)
                  MAX31826_InputData.SA=TempBuf[0];       // сохраняем значение SA
                  MAX31826_InputData.AreaNumber = 2;
                  MAX31826_OutputData = MAX31826_ReadFromScratchpad(MAX31826_InputData);  // читаем данные из Scratchpad 2
                  if(MAX31826_OutputData.Success)           // если успешно прочитали
                  { // помещаем данные из памяти на форму
                    switch(Form1->PageControl1->TabIndex)
                    { case 0:  PlaceDataToForm(3,2);
                               break;
                      case 1:  PlaceDataToForm(4,2);
                               break;
                      default: break;
                    }
                    SendMsgToLogForm(108,"Scratchpad 2");                // чтение блокнота успешно завершено
                  }
                  else  SendMsgToLogForm(107,"Scratchpad 2");            // чтение блокнота завершено с ошибкой
                }
                else    SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                break;
    case 0x43:  //----------------------------------------------------
                // выбран чип DS28EC20, нажата кнопка READ REGISTER PAGE
                //----------------------------------------------------
                // добавляем нужные переменные
                DS28EC20_OUTPUT_DATA DS28EC20_OutputData;           // выходные данные для функций DS28EC20
                DS28EC20_INPUT_DATA DS28EC20_InputData;             // входные данные для функций DS28EC20
                SendMsgToLogForm(125,"");           // начинаем чтение из EEPROM страницы регистров
                // начинаем работать
                GetDataToMemory(0,0);                 // получаем ROM с формы (второй параметр может быть любым)
                DS28EC20_InputData.TA1=SelectedChip.Area2Start;   // вычисляем TA1
                DS28EC20_InputData.TA2=SelectedChip.Area2Start>>8;// вычисляем TA2
                DS28EC20_InputData.AreaNumber=2;                  // будем сохранять прочитанное в область регистров
                DS28EC20_InputData.Size=SelectedChip.Area2Size;   // размер равен области регистров
                if(Port!=INVALID_HANDLE_VALUE)  DS28EC20_OutputData=DS28EC20_ReadFromMemory(DS28EC20_InputData);      // читаем область регистров
                else  // если порт закрыт - отправляем мессадж и выходим
                { SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                  return;
                }
                if(DS28EC20_OutputData.Success)                   // если успешно прочитали
                { // помещаем на форму Test
                  TempBuf[0]=DS28EC20_OutputData.Test;
                  BinToHex(TempBuf,OutHexBuf,1);        // преобразовать строку в целое (байт)
                  OutHexBuf[2]=0;                       // строка должна заканчиваться нулём
                  Form1->Edit7->Text = OutHexBuf;
                  // помещаем данные из памяти на форму
                  switch(Form1->PageControl1->TabIndex)
                  { case 0:  PlaceDataToForm(3,2);
                             break;
                    case 1:  PlaceDataToForm(4,2);
                             break;
                    default: break;
                  }
                  SendMsgToLogForm(108,"");    // данные успешно прочитаны
                }
                else      SendMsgToLogForm(107,"");    // чтение данных завершилось с ошибкой
                break;
    case 0x5:   // выбран чип DS2405
    case 0xD:   // выбран чип DS28E05
    case 0x24:  // выбран чип DS2415
    case 0x27:  // выбран чип DS2417
    default:    break;
  }
}
//---------------------------------------------------------------------------
//--- НАЖАТА КНОПКА BUTTON9 -------------------------------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::Button9Click(TObject *Sender)
{ AnsiString TempStr;                           // для преобразования
  char *InHexBuf, TempBuf[1], OutHexBuf[3];     // для преобразования
  unsigned int TempAddr;                        // для вычисления адреса

  switch(SelectedChip.Family)
  { case 0x0:   // выбран один из чипов с перезаписываемым ROM
                switch(SelectedChip.Modify)
                { case 1:  // выбран чип RW1990
                  case 2:  // выбран ключ AN1990
                  case 3:  // выбран ключ TM2004
                  default: break;
                }
                break;
    case 0x2:   //----------------------------------------------------------
                // выбран чип DS1991, нажата кнопка WRITE PASSWORD TO SUBKEY
    case 0x82:   //----------------------------------------------------------
                // выбран чип DS1425, нажата кнопка WRITE PASSWORD TO SUBKEY
                //----------------------------------------------------------
                // добавляем нужные переменные
                DS1991_OUTPUT_DATA DS1991_OutputData; // выходные данные для функций DS1991
                DS1991_INPUT_DATA DS1991_InputData;   // входные данные для функций DS1991
                unsigned char DS1991_Done;            // счётчик количества записей
                SendMsgToLogForm(136,"");    // начинаем запись пароля ключа
                // начинаем работать
                DS1991_Done=0;                        // ни одна область пока не записана
                GetDataToMemory(0,0);                   // получаем ROM с формы (второй параметр может быть любым)
                for(unsigned int DS1991_i=0; DS1991_i<3; DS1991_i++)
                { DS1991_InputData.AreaNumber=0;        // признак того, что никуда записывать не нужно
                  if(DS1991_i==0)
                  { if(Form1->CheckBox1->Checked==true)         // проверяем, нужно ли записывать в subkey1
                    { DS1991_InputData.AreaNumber=1;            // нужно
                      switch(Form1->PageControl1->TabIndex)
                      { case 0:  GetDataToMemory(1,1);          // передаём данные из RichEdit1 в Area1
                                 break;
                        case 1:  GetDataToMemory(2,1);          // передаём данные из RichEdit2 в Area1
                                 break;
                        default: break;
                      }
                    }
                  }
                  else if(DS1991_i==1)
                  { if(Form1->CheckBox1->Checked==true)         // проверяем, нужно ли записывать в subkey2
                    { DS1991_InputData.AreaNumber=2;            // нужно
                      switch(Form1->PageControl1->TabIndex)
                      { case 0:  GetDataToMemory(3,2);          // передаём данные из RichEdit3 в Area2
                                 break;
                        case 1:  GetDataToMemory(4,2);          // передаём данные из RichEdit4 в Area2
                                 break;
                        default: break;
                      }
                    }
                  }
                  else
                  { if(Form1->CheckBox1->Checked==true)         // проверяем, нужно ли записывать в subkey3
                    { DS1991_InputData.AreaNumber=3;            // нужно
                      switch(Form1->PageControl1->TabIndex)
                      { case 0:  GetDataToMemory(5,3);          // передаём данные из RichEdit5 в Area3
                                 break;
                        case 1:  GetDataToMemory(6,3);          // передаём данные из RichEdit6 в Area3
                                 break;
                        default: break;
                      }
                    }
                  }
                  if(DS1991_InputData.AreaNumber!=0)    // если нужно записывать
                  { if(Port!=INVALID_HANDLE_VALUE)
                    { DS1991_OutputData=DS1991_WritePassword(DS1991_InputData);   // посылаем команду Write Password
                      if(DS1991_OutputData.Success)         SendMsgToLogForm(106,"");        // запись пароля успешно завершена
                      else                                  SendMsgToLogForm(105,"");        // во время записи пароля произошла ошибка
                    }
                    else    SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                    DS1991_Done+=1;           // увеличиваем количество попыток записи
                  }
                }
                if(DS1991_Done==0)      SendMsgToLogForm(133,"");  // не выбрана ни одна область, для которой нужно выполнить действие
                break;
    case 0x4:   //--------------------------------------------------
                // выбран чип DS1994, нажата кнопка READ DATA MEMORY
    case 0x84:  //--------------------------------------------------
                // выбран чип DS1427, нажата кнопка READ DATA MEMORY
                //--------------------------------------------------
                // добавляем нужные переменные
                DS1994_OUTPUT_DATA DS1994_OutputData;           // выходные данные для функций DS1994
                DS1994_INPUT_DATA DS1994_InputData;             // входные данные для функций DS1994
                SendMsgToLogForm(124,"");           // начинаем чтение данных из EEPROM
                // начинаем работать
                GetDataToMemory(0,0);                     // получаем ROM с формы (второй параметр может быть любым)
                DS1994_InputData.TA1=SelectedChip.Area1Start;          // вычисляем TA1
                DS1994_InputData.TA2=SelectedChip.Area1Start>>8;       // вычисляем TA2
                DS1994_InputData.AreaNumber=1;                         // будем сохранять прочитанное в область данных
                DS1994_InputData.Size=SelectedChip.Area1Size;          // размер равен области данных
                if(Port!=INVALID_HANDLE_VALUE)  DS1994_OutputData=DS1994_ReadFromMemory(DS1994_InputData); // читаем область данных
                else  // если порт закрыт - отправляем мессадж и выходим
                { SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                  return;
                }
                if(DS1994_OutputData.Success)                          // если успешно прочитали
                { // помещаем на форму Test
                  TempBuf[0]=DS1994_OutputData.Test;
                  BinToHex(TempBuf,OutHexBuf,1);        // преобразовать строку в целое (байт)
                  OutHexBuf[2]=0;                       // строка должна заканчиваться нулём
                  Form1->Edit7->Text = OutHexBuf;
                  // помещаем данные из памяти на форму
                  switch(Form1->PageControl1->TabIndex)
                  { case 0:  PlaceDataToForm(1,1);      // из Area1 в RichEdit1
                             break;
                    case 1:  PlaceDataToForm(2,1);      // из Area1 в RichEdit2
                             break;
                    default: break;
                  }
                  SendMsgToLogForm(108,"");    // чтение успешно завершено
                }
                else      SendMsgToLogForm(107,"");    // ошибка чтения
                break;
    case 0x9:   //-----------------------------------------------------------
                // выбран чип DS2502 / DS1982, нажата кнопка WRITE SCRATCHPAD
                //-----------------------------------------------------------
                // добавляем нужные переменные
                DS2502_INPUT_DATA DS2502_InputData;     // входные данные для функций DS2502
                DS2502_OUTPUT_DATA DS2502_OutputData;   // выходные данные для функций DS2502
                SendMsgToLogForm(121,"");    // начинаем запись в EPROM
                // начинаем работать
                GetDataToMemory(0,0);                   // получаем ROM с формы (второй параметр может быть любым)
                TempStr=LowerCase(Form1->Edit4->Text);  // получаем TA1 в строку
                InHexBuf=TempStr.c_str();               // скопировать в буфер байт для передачи (в виде строки)
                HexToBin(InHexBuf,TempBuf,1);           // преобразовать строку в целое (байт)
                DS2502_InputData.TA1=TempBuf[0];        // сохраняем значение TA1
                TempStr=LowerCase(Form1->Edit5->Text);  // получаем TA2 в строку
                InHexBuf=TempStr.c_str();               // скопировать в буфер байт для передачи (в виде строки)
                HexToBin(InHexBuf,TempBuf,1);           // преобразовать строку в целое (байт)
                DS2502_InputData.TA2=TempBuf[0];        // сохраняем значение TA2
                // получаем с формы Scratchpad и помещаем в первый байт Area3
                TempStr=LowerCase(Form1->Edit6->Text);  // получаем Scratchpad в строку
                InHexBuf=TempStr.c_str();               // скопировать в буфер байт для передачи (в виде строки)
                HexToBin(InHexBuf,TempBuf,1);           // преобразовать строку в целое (байт)
                SelectedChip.Area3[0]=TempBuf[0];       // сохраняем значение Scratchpad
                // посылаем данные по 1-Wire
                DS2502_InputData.AreaNumber=3;                  // для записи scratchpad используется первый байт Area3
                DS2502_InputData.Size=1;                        // размер Scratchpad 1 байт
                if(Port!=INVALID_HANDLE_VALUE)
                { DS2502_OutputData=DS2502_WriteToMemory(DS2502_InputData);
                  if(DS2502_OutputData.Success) SendMsgToLogForm(106,"");            // запись данных успешно завершена
                  else                          SendMsgToLogForm(105,"");            // запись данных завершена с ошибкой
                }
                else    SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                break;
    case 0x10:  //----------------------------------------------------
                // выбран чип DS18S20, нажата кнопка READ POWER SUPPLY
                //----------------------------------------------------
                // добавляем нужные переменные
                DS18S20_OUTPUT_DATA DS18S20_OutputData; // выходные данные для функций DS18S20
                SendMsgToLogForm(126,"");           // начинаем чтение режима питания
                /* fixed */
                GetDataToMemory(0,0);                        // получаем ROM с формы (второй параметр может быть любым)
                // начинаем работать
                if(Port!=INVALID_HANDLE_VALUE)  DS18S20_OutputData=DS18S20_ReadPowerSupply();
                else  // если порт закрыт - отправляем мессадж и выходим
                { SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                  return;
                }
                if(DS18S20_OutputData.Success)  // если всё успешно
                { // формируем результаты
                  if(DS18S20_OutputData.Test==0)                SendMsgToLogForm(112,"");    // паразитное питание
                  else if(DS18S20_OutputData.Test==0xFF)        SendMsgToLogForm(113,"");    // независимое питание
                  else                                          SendMsgToLogForm(114,"");    // не удалось определить режим питания
                }
                else    SendMsgToLogForm(107,"");    // Ошибка чтения
                break;
    case 0x14:  //-------------------------------------------------------
                // выбран чип DS2430A, нажата кнопка READ STATUS REGISTER
                //-------------------------------------------------------
                // добавляем нужные переменные
                DS2430_OUTPUT_DATA DS2430_OutputData;   // выходные данные для функций DS2430A
                SendMsgToLogForm(127,"");           // начинаем чтение регистра статуса
                // начинаем работать
                // посылаем команду ReadFromStatusRegister и помещаем результат (Test) на форму
                GetDataToMemory(0,0);                   // получаем ROM с формы (второй параметр может быть любым)
                if(Port!=INVALID_HANDLE_VALUE)  DS2430_OutputData=DS2430_ReadFromStatusRegister();
                else  // если порт закрыт - отправляем мессадж и выходим
                { SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                  return;
                }
                if(DS2430_OutputData.Success)
                { TempBuf[0]=DS2430_OutputData.Status;
                  BinToHex(TempBuf,OutHexBuf,1);        // преобразовать строку в целое (байт)
                  OutHexBuf[2]=0;                       // строка должна заканчиваться нулём
                  Form1->Edit4->Text = OutHexBuf;
                  SendMsgToLogForm(108,"");    // данные успешно прочитаны
                }
                else    SendMsgToLogForm(107,"");    // ошибка чтения
                break;
    case 0x1A:  //----------------------------------------------------------------
                // выбран чип DS1963L, нажата кнопка READ DATA MEMORY AND COUNTERS
    case 0x1D:  //----------------------------------------------------------------
                // выбран чип DS2423, нажата кнопка READ DATA MEMORY AND COUNTERS
                //----------------------------------------------------------------
                // добавляем нужные переменные
                DS1963L_OUTPUT_DATA DS1963L_OutputData;           // выходные данные для функций DS1963L
                DS1963L_INPUT_DATA DS1963L_InputData;             // входные данные для функций DS1963L
                SendMsgToLogForm(124,"");           // начинаем чтение данных из EEPROM
                // начинаем работать
                GetDataToMemory(0,0);                     // получаем ROM с формы (второй параметр может быть любым)
                DS1963L_InputData.TA1=SelectedChip.Area1Start;          // вычисляем TA1
                DS1963L_InputData.TA2=SelectedChip.Area1Start>>8;       // вычисляем TA2
                if(Port!=INVALID_HANDLE_VALUE)  DS1963L_OutputData=DS1963L_ReadFromMemoryC(DS1963L_InputData); // читаем область данных
                else  // если порт закрыт - отправляем мессадж и выходим
                { SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                  return;
                }
                if(DS1963L_OutputData.Success)                          // если успешно прочитали
                { // помещаем на форму Test
                  TempBuf[0]=DS1963L_OutputData.Test;
                  BinToHex(TempBuf,OutHexBuf,1);        // преобразовать строку в целое (байт)
                  OutHexBuf[2]=0;                       // строка должна заканчиваться нулём
                  Form1->Edit7->Text = OutHexBuf;
                  // помещаем данные из памяти на форму
                  switch(Form1->PageControl1->TabIndex)
                  { case 0:  PlaceDataToForm(1,1);      // помещаем данные в RichEdit1 из Area1
                             PlaceDataToForm(5,3);      // помещаем данные в RichEdit5 из Area3
                             break;
                    case 1:  PlaceDataToForm(2,1);      // помещаем данные в RichEdit2 из Area1
                             PlaceDataToForm(6,3);      // помещаем данные в RichEdit6 из Area3
                             break;
                    default: break;
                  }
                  SendMsgToLogForm(108,"");    // данные успешно прочитаны
                }
                else      SendMsgToLogForm(107,"");    // чтение данных завершилось с ошибкой
                break;
    case 0x22:  //----------------------------------------------------
                // выбран чип DS1822, нажата кнопка READ POWER SUPPLY
    case 0x28:  //----------------------------------------------------
                // выбран чип DS18B20, нажата кнопка READ POWER SUPPLY
                //----------------------------------------------------
                // добавляем нужные переменные
                DS18B20_OUTPUT_DATA DS18B20_OutputData; // выходные данные для функций DS18B20
                SendMsgToLogForm(126,"");           // начинаем чтение режима питания
                /* fixed */
                GetDataToMemory(0,0);                        // получаем ROM с формы (второй параметр может быть любым)
                // начинаем работать
                if(Port!=INVALID_HANDLE_VALUE)  DS18B20_OutputData=DS18B20_ReadPowerSupply();
                else  // если порт закрыт - отправляем мессадж и выходим
                { SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                  return;
                }
                if(DS18B20_OutputData.Success)  // если всё успешно
                { // формируем результаты
                  if(DS18B20_OutputData.Test==0)                SendMsgToLogForm(112,"");    // паразитное питание
                  else if(DS18B20_OutputData.Test==0xFF)        SendMsgToLogForm(113,"");    // независимое питание
                  else                                          SendMsgToLogForm(114,"");    // не удалось определить режим питания
                }
                else    SendMsgToLogForm(107,"");    // ошибка чтения
                break;
    case 0x2C:  //-------------------------------------------------------
                // выбран чип DS2890, нажата кнопка READ CONTROL REGISTER
                //-------------------------------------------------------
                // добавляем нужные переменные
                DS2890_OUTPUT_DATA DS2890_OutputData;   // выходные данные для функций 1W
                SendMsgToLogForm(143,"");    // начинаем чтение данных
                // начинаем работать
                GetDataToMemory(0,0);                   // получаем ROM с формы (второй параметр может быть любым)
                if(Port!=INVALID_HANDLE_VALUE)
                { DS2890_OutputData=DS2890_ReadControl(); // читаем данные
                  if(DS2890_OutputData.Success)           // если успешно прочитали
                  { // помещаем на форму Feature
                    TempBuf[0]=DS2890_OutputData.Feature;
                    BinToHex(TempBuf,OutHexBuf,1);        // преобразовать строку в целое (байт)
                    OutHexBuf[2]=0;                       // строка должна заканчиваться нулём
                    Form1->Edit6->Text = OutHexBuf;
                    // помещаем на форму Control
                    TempBuf[0]=DS2890_OutputData.Control;
                    BinToHex(TempBuf,OutHexBuf,1);        // преобразовать строку в целое (байт)
                    OutHexBuf[2]=0;                       // строка должна заканчиваться нулём
                    Form1->Edit5->Text = OutHexBuf;
                    SendMsgToLogForm(108,"");                // чтение блокнота успешно завершено
                  }
                  else  SendMsgToLogForm(107,"");            // чтение блокнота завершено с ошибкой
                }
                else    SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                break;
    case 0x2D:  //---------------------------------------------------
                // выбран чип DS2431, нажата кнопка WRITE DATA MEMORY
                //---------------------------------------------------
                // добавляем нужные переменные
                DS2431_INPUT_DATA DS2431_InputData;       // входные данные для функций DS2431
                DS2431_OUTPUT_DATA DS2431_OutputData;     // выходные данные для функций DS2431
                SendMsgToLogForm(121,"");           // начинаем запись данных в EEPROM
                // начинаем работать
                GetDataToMemory(0,0);                     // получаем ROM с формы (второй параметр может быть любым)
                // помещаем данные с формы в память в зависимости от вкладки
                switch(Form1->PageControl1->TabIndex)
                { case 0:  GetDataToMemory(1,1);        // передаём данные из RichEdit1 в Data
                           break;
                  case 1:  GetDataToMemory(2,1);        // передаём данные из RichEdit2 в Data
                           break;
                  default: break;
                }
                // посылаем данные из памяти по 1-Wire через блокнот и помещаем результат (Test) на форму
                // организуем цикл равный количеству кусков, равных размеру блокнота, содержащихся в отправляемой области
                for(unsigned int i=0; i<SelectedChip.Area1Size/SelectedChip.Area3Size; i++)
                { // выбираем очередной кусок для отправки в блокнот
                  DS2431_InputData.Size=SelectedChip.Area3Size;                         // размер посылки равен размеру блокнота
                  DS2431_InputData.AreaNumber=1;                                        // будем посылать в блокнот данные из области данных
                  // если порт открыт - отправляем кусок из области данных в блокнот
                  if(Port!=INVALID_HANDLE_VALUE)
                  { TempAddr=SelectedChip.Area1Start+i*SelectedChip.Area3Size;          // вычисляем новое значение начального адреса области записи
                    DS2431_InputData.TA1=TempAddr;                                      // вычисляем значение TA1
                    DS2431_InputData.TA2=TempAddr>>8;                                   // вычисляем значение TA2
                    DS2431_OutputData=DS2431_WriteToScratchpad(DS2431_InputData);
                  }
                  else  // если порт закрыт - отправляем мессадж и выходим
                  { SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                    return;
                  }
                  // если порт открыт - читаем блокнот
                  if(Port!=INVALID_HANDLE_VALUE)  DS2431_OutputData=DS2431_ReadFromScratchpad();        // читаем данные из Scratchpad
                  else  // если порт закрыт - отправляем мессадж и выходим
                  { SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                    return;
                  }
                  // здесь можно дополнительно сравнивать отправленные данные и считанные в блокнот
                  // если прочитали - проверяем размер ответа и биты AA и PF
                  TempBuf[0]=(DS2431_OutputData.ES>>5)&0x5;                             // выделяем биты AA и PF
                  if((DS2431_OutputData.Success==false) || (TempBuf[0]!=0))
                  {     SendMsgToLogForm(105,"");    // ошибка записи
                        return;
                  }
                  // если проверка прошла успешно - копируем блокнот в память
                  DS2431_InputData.TA1=DS2431_OutputData.TA1;
                  DS2431_InputData.TA2=DS2431_OutputData.TA2;
                  DS2431_InputData.ES=DS2431_OutputData.ES;
                  if(Port!=INVALID_HANDLE_VALUE)  DS2431_OutputData=DS2431_CopyScratchpadToMemory(DS2431_InputData);
                  else  // если порт закрыт - отправляем мессадж и выходим
                  { SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                    return;
                  }
                  if(DS2431_OutputData.Success)
                  { TempBuf[0]=DS2431_OutputData.Test;
                    BinToHex(TempBuf,OutHexBuf,1);          // преобразовать строку в целое (байт)
                    OutHexBuf[2]=0;                         // строка должна заканчиваться нулём
                    Form1->Edit7->Text = OutHexBuf;         // пишем Test на форму
                  }
                  else
                  {     SendMsgToLogForm(105,"");    // ошибка записи
                        return;
                  }
                }
                SendMsgToLogForm(106,"");    // запись успешно завершена
                break;
    case 0x33:  //---------------------------------------------------
                // выбран чип DS2432, нажата кнопка WRITE DATA MEMORY
                //---------------------------------------------------
                // добавляем нужные переменные
                DS2432_INPUT_DATA DS2432_InputData;     // входные данные для функций DS2432
                DS2432_OUTPUT_DATA DS2432_OutputData;   // выходные данные для функций DS2432
                unsigned char   DataTemp[128];          // временное хранилище для Data
                // начинаем работать
                GetDataToMemory(0,0);                   // получаем ROM с формы (второй параметр может быть любым)
                // получаем с формы Secret (для расчёта MAC)
                switch(Form1->PageControl1->TabIndex)
                { case 0:  GetDataToMemory(3,2);        // передаём данные из RichEdit3 в Secret
                           break;
                  case 1:  GetDataToMemory(4,2);        // передаём данные из RichEdit4 в Secret
                           break;
                  default: break;
                }
                // организуем цикл от 0 до 16 (область данных занимает 128 байт, а размер блокнота 8, поэтому нужно 128/8=16 итераций)
                for(unsigned int i=0; i<(SelectedChip.Area1Size/SelectedChip.Area4Size); i++)
                { // сначала нужно прочитать и сохранить текущие данные из области Data
                  DS2432_InputData.TA1=SelectedChip.Area1Start;   // вычисляем TA1
                  DS2432_InputData.TA2=SelectedChip.Area1Start>>8;// вычисляем TA2
                  DS2432_InputData.AreaNumber=1;                  // будем сохранять прочитанное в область данных
                  DS2432_InputData.Size=SelectedChip.Area1Size;   // размер равен области данных
                  if(Port!=INVALID_HANDLE_VALUE)  DS2432_OutputData=DS2432_ReadFromMemory(DS2432_InputData);      // читаем область данных
                  else  // если порт закрыт - отправляем мессадж и выходим
                  { SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                    return;
                  }
                  if(DS2432_OutputData.Success)                   // если успешно прочитали
                  { // сохраняем прочитанные данные во временное хранилище
                    for(unsigned char j=0; j<128; j++)
                    {     DataTemp[j]=SelectedChip.Area1[j];
                    }
                    SendMsgToLogForm(108,"");    // данные успешно прочитаны
                  }
                  else
                  {       SendMsgToLogForm(107,"");    // чтение данных завершилось с ошибкой
                          return;
                  }
                  // помещаем данные с формы в память в зависимости от вкладки (для DS2432 Data Memory находится в Area1)
                  switch(Form1->PageControl1->TabIndex)
                  { case 0:  GetDataToMemory(1,1);        // передаём данные из RichEdit1 в EEPROM
                             break;
                    case 1:  GetDataToMemory(2,1);        // передаём данные из RichEdit2 в EEPROM
                             break;
                    default: break;
                  }
                 // записываем кусок области данных в scratchpad
                  SendMsgToLogForm(116,"");    // начинаем запись в блокнот
                  DS2432_InputData.TA1=SelectedChip.Area1Start+8*i;     // сохраняем значение TA1
                  DS2432_InputData.TA2=0;                               // сохраняем значение TA2
                  // посылаем данные по 1-Wire
                  DS2432_InputData.AreaNumber=1;                  // Data Memory - это Area1
                  DS2432_InputData.Size=SelectedChip.Area4Size;   // размер равен размеру блокнота
                  if(Port!=INVALID_HANDLE_VALUE)
                  { DS2432_OutputData=DS2432_WriteToScratchpad(DS2432_InputData);
                    if(DS2432_OutputData.Success)
                    { TempBuf[0]=DS2432_OutputData.Test;
                      BinToHex(TempBuf,OutHexBuf,1);      // преобразовать строку в целое (байт)
                      OutHexBuf[2]=0;                     // строка должна заканчиваться нулём
                      Form1->Edit7->Text = OutHexBuf;
                      SendMsgToLogForm(106,"");           // запись в scratchpad успешно завершена
                    }
                    else
                    {  SendMsgToLogForm(105,"");            // запись в scratchpad завершена с ошибкой
                       return;
                    }
                  }
                  else
                  {    SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                       return;
                  }
                  // читаем блокнот обратно, чтобы получить код авторизации (TA1, TA2, ES)
                  if(Port!=INVALID_HANDLE_VALUE)
                  { DS2432_OutputData=DS2432_ReadFromScratchpad();  // читаем данные из Scratchpad
                    if(DS2432_OutputData.Success)           // если успешно прочитали
                    { DS2432_InputData.ES=DS2432_OutputData.ES;      // запоминаем E/S
                      DS2432_InputData.TA2=DS2432_OutputData.TA2;    // запоминаем TA2
                      DS2432_InputData.TA1=DS2432_OutputData.TA1;    // запоминаем TA1
                      SendMsgToLogForm(108,"");                // чтение блокнота успешно завершено
                    }
                    else
                    {  SendMsgToLogForm(107,"");            // чтение блокнота завершено с ошибкой
                       return;
                    }
                  }
                  else
                  {    SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                       return;
                  }
                  // восстанавливаем сохранённые данные области Data
                  for(unsigned char i=0; i<128; i++)
                  {     SelectedChip.Area1[i]=DataTemp[i];
                  }
                  // выполняем копирование блокнота в память
                  if(Port!=INVALID_HANDLE_VALUE)
                  { DS2432_OutputData=DS2432_CopyScratchpadToMemory(DS2432_InputData);
                    if(DS2432_OutputData.Success)
                    { TempBuf[0]=DS2432_OutputData.Test;
                      BinToHex(TempBuf,OutHexBuf,1);        // преобразовать строку в целое (байт)
                      OutHexBuf[2]=0;                       // строка должна заканчиваться нулём
                      Form1->Edit7->Text = OutHexBuf;
                      SendMsgToLogForm(110,"");    // копирование из блокнота в EEPROM успешно завершено
                    }
                    else
                    {    SendMsgToLogForm(109,"");    // во время копирование из блокнота в EEPROM произошла ошибка
                         return;
                    }
                  }
                  else
                  {    SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                       return;
                  }
                }
                break;
    case 0x3B:  //-----------------------------------------------------
                // выбран чип MAX31826, нажата кнопка WRITE DATA MEMORY
                //-----------------------------------------------------
                // добавляем нужные переменные
                MAX31826_INPUT_DATA MAX31826_InputData;       // входные данные для функций MAX31826
                MAX31826_OUTPUT_DATA MAX31826_OutputData;     // выходные данные для функций MAX31826
                SendMsgToLogForm(121,"");           // начинаем запись данных в EEPROM
                // начинаем работать
                GetDataToMemory(0,0);                     // получаем ROM с формы (второй параметр может быть любым)
                // помещаем данные с формы в память в зависимости от вкладки
                switch(Form1->PageControl1->TabIndex)
                { case 0:  GetDataToMemory(1,1);        // передаём данные из RichEdit1 в Data
                           break;
                  case 1:  GetDataToMemory(2,1);        // передаём данные из RichEdit2 в Data
                           break;
                  default: break;
                }
                // посылаем данные из памяти по 1-Wire через блокнот
                // организуем цикл равный количеству кусков, равных размеру блокнота, содержащихся в отправляемой области
                for(unsigned int i=0; i<SelectedChip.Area1Size/SelectedChip.Area2Size; i++)
                { // выбираем очередной кусок для отправки в блокнот
                  MAX31826_InputData.Size=SelectedChip.Area2Size;                         // размер посылки равен размеру блокнота
                  MAX31826_InputData.AreaNumber=1;                                        // будем посылать в блокнот данные из области данных
                  // если порт открыт - отправляем кусок из области данных в блокнот
                  if(Port!=INVALID_HANDLE_VALUE)
                  { TempAddr=SelectedChip.Area1Start+i*SelectedChip.Area2Size;          // вычисляем новое значение начального адреса области записи
                    MAX31826_InputData.SA=TempAddr;                                      // вычисляем значение SA
                    MAX31826_OutputData=MAX31826_WriteToScratchpad(MAX31826_InputData);
                  }
                  else  // если порт закрыт - отправляем мессадж и выходим
                  { SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                    return;
                  }
                  // если порт открыт - читаем блокнот
                  MAX31826_InputData.AreaNumber=2;
                  MAX31826_InputData.SA=TempAddr;
                  if(Port!=INVALID_HANDLE_VALUE)  MAX31826_OutputData=MAX31826_ReadFromScratchpad(MAX31826_InputData);        // читаем данные из Scratchpad 2
                  else  // если порт закрыт - отправляем мессадж и выходим
                  { SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                    return;
                  }
                  // здесь можно дополнительно сравнивать отправленные данные и считанные в блокнот
                  if(MAX31826_OutputData.Success==false)
                  {     SendMsgToLogForm(105,"");    // ошибка записи
                        return;
                  }
                  // если проверка прошла успешно - копируем блокнот в память
                  if(Port!=INVALID_HANDLE_VALUE)  MAX31826_OutputData=MAX31826_CopyScratchpadToMemory();
                  else  // если порт закрыт - отправляем мессадж и выходим
                  { SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                    return;
                  }
                  if(!MAX31826_OutputData.Success)
                  {     SendMsgToLogForm(105,"");    // ошибка записи
                        return;
                  }
                }
                SendMsgToLogForm(106,"");    // запись успешно завершена
                break;
    case 0x43:  //---------------------------------------------------
                // выбран чип DS28EC20, нажата кнопка WRITE DATA MEMORY
                //---------------------------------------------------
                // добавляем нужные переменные
                DS28EC20_INPUT_DATA DS28EC20_InputData;       // входные данные для функций DS28EC20
                DS28EC20_OUTPUT_DATA DS28EC20_OutputData;     // выходные данные для функций DS28EC20
                SendMsgToLogForm(121,"");           // начинаем запись данных в EEPROM
                // начинаем работать
                GetDataToMemory(0,0);                     // получаем ROM с формы (второй параметр может быть любым)
                // помещаем данные с формы в память в зависимости от вкладки
                switch(Form1->PageControl1->TabIndex)
                { case 0:  GetDataToMemory(1,1);        // передаём данные из RichEdit1 в Data
                           break;
                  case 1:  GetDataToMemory(2,1);        // передаём данные из RichEdit2 в Data
                           break;
                  default: break;
                }
                // посылаем данные из памяти по 1-Wire через блокнот и помещаем результат (Test) на форму
                // организуем цикл равный количеству кусков, равных размеру блокнота, содержащихся в отправляемой области
                for(unsigned int i=0; i<SelectedChip.Area1Size/SelectedChip.Area4Size; i++)
                { // выбираем очередной кусок для отправки в блокнот
                  DS28EC20_InputData.Size=SelectedChip.Area4Size;                         // размер посылки равен размеру блокнота
                  DS28EC20_InputData.AreaNumber=1;                                        // будем посылать в блокнот данные из области данных
                  // если порт открыт - отправляем кусок из области данных в блокнот
                  if(Port!=INVALID_HANDLE_VALUE)
                  { TempAddr=SelectedChip.Area1Start+i*SelectedChip.Area4Size;          // вычисляем новое значение начального адреса области записи
                    DS28EC20_InputData.TA1=TempAddr;                                      // вычисляем значение TA1
                    DS28EC20_InputData.TA2=TempAddr>>8;                                   // вычисляем значение TA2
                    DS28EC20_OutputData=DS28EC20_WriteToScratchpad(DS28EC20_InputData);
                  }
                  else  // если порт закрыт - отправляем мессадж и выходим
                  { SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                    return;
                  }
                  // если порт открыт - читаем блокнот
                  if(Port!=INVALID_HANDLE_VALUE)  DS28EC20_OutputData=DS28EC20_ReadFromScratchpad();        // читаем данные из Scratchpad
                  else  // если порт закрыт - отправляем мессадж и выходим
                  { SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                    return;
                  }
                  // здесь можно дополнительно сравнивать отправленные данные и считанные в блокнот
                  // если прочитали - проверяем размер ответа и биты AA и PF
                  TempBuf[0]=(DS28EC20_OutputData.ES>>5)&0x5;                             // выделяем биты AA и PF
                  if((DS28EC20_OutputData.Success==false) || (TempBuf[0]!=0))
                  {     SendMsgToLogForm(105,"");    // ошибка записи
                        return;
                  }
                  // если проверка прошла успешно - копируем блокнот в память
                  DS28EC20_InputData.TA1=DS28EC20_OutputData.TA1;
                  DS28EC20_InputData.TA2=DS28EC20_OutputData.TA2;
                  DS28EC20_InputData.ES=DS28EC20_OutputData.ES;
                  if(Port!=INVALID_HANDLE_VALUE)  DS28EC20_OutputData=DS28EC20_CopyScratchpadToMemory(DS28EC20_InputData);
                  else  // если порт закрыт - отправляем мессадж и выходим
                  { SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                    return;
                  }
                  if(DS28EC20_OutputData.Success)
                  { TempBuf[0]=DS28EC20_OutputData.Test;
                    BinToHex(TempBuf,OutHexBuf,1);          // преобразовать строку в целое (байт)
                    OutHexBuf[2]=0;                         // строка должна заканчиваться нулём
                    Form1->Edit7->Text = OutHexBuf;         // пишем Test на форму
                  }
                  else
                  {     SendMsgToLogForm(105,"");    // ошибка записи
                        return;
                  }
                }
                SendMsgToLogForm(106,"");    // запись успешно завершена
                break;
    case 0x5:   // выбран чип DS2405
    case 0x6:   // выбран чип DS1993
    case 0x8:   // выбран чип DS1992
    case 0xA:   // выбран чип DS1995
    case 0xC:   // выбран чип DS1996
    case 0xD:   // выбран чип DS28E05
    case 0x23:  // выбран чип DS24B33
    case 0x24:  // выбран чип DS2415
    case 0x27:  // выбран чип DS2417
    default:    break;
  }
}
//---------------------------------------------------------------------------
//--- НАЖАТА КНОПКА BUTTON10 ------------------------------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::Button10Click(TObject *Sender)
{ char TempBuf[1], OutHexBuf[3];        // для преобразования

  switch(SelectedChip.Family)
  { case 0x0:   // выбран один из чипов с перезаписываемым ROM
                switch(SelectedChip.Modify)
                { case 1:  // выбран чип RW1990
                  case 2:  // выбран ключ AN1990
                  case 3:  // выбран ключ TM2004
                  default: break;
                }
                break;
    case 0x10:  //----------------------------------------------
                // выбран чип DS18S20, нажата кнопка READ EEPROM
                //----------------------------------------------
                // добавляем нужные переменные
                DS18S20_OUTPUT_DATA DS18S20_OutputData; // выходные данные для функций 1W
                SendMsgToLogForm(124,"");           // начинаем чтение данных из EEPROM
                // начинаем работать
                GetDataToMemory(0,0);                   // получаем ROM с формы (второй параметр может быть любым)
                // сначала выполняем recall
                if(Port!=INVALID_HANDLE_VALUE)  DS18S20_OutputData=DS18S20_RecallE2();
                else  // если порт закрыт - отправляем мессадж и выходим
                { SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                  return;
                }
                if(DS18S20_OutputData.Success)          // если получилось
                { // выполняем read scratchpad
                  if(Port!=INVALID_HANDLE_VALUE)  DS18S20_OutputData=DS18S20_ReadFromScratchpad();
                  else  // если порт закрыт - отправляем мессадж и выходим
                  { SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                    return;
                  }
                }
                else  // если не удалось выполнить recall - выходим
                { SendMsgToLogForm(107,"");    // ошибка чтения
                  return;
                }
                if(DS18S20_OutputData.Success)          // если успешно выполнили recall и прочитали блокнот
                { // выводим в ричедит расшифрованный конфиг и вычисленные пороги
                  DS18S20_DecodeThresholds();
                  // помещаем данные из памяти на форму
                  switch(Form1->PageControl1->TabIndex)
                  { case 0:  PlaceDataToForm(1,1);      // из Area1 в RichEdit1
                             break;
                    case 1:  PlaceDataToForm(2,1);      // из Area1 в RichEdit2
                             break;
                    default: break;
                  }
                  SendMsgToLogForm(108,"");    // чтение завершено
                }
                else      SendMsgToLogForm(107,"");    // ошибка чтения
                break;
    case 0x4:   //------------------------------------------------------------
                // выбран чип DS1994, нажата кнопка READ TIMEKEEPING REGISTERS
    case 0x84:  //------------------------------------------------------------
                // выбран чип DS1427, нажата кнопка READ TIMEKEEPING REGISTERS
                //------------------------------------------------------------
                // добавляем нужные переменные
                DS1994_OUTPUT_DATA DS1994_OutputData;           // выходные данные для функций DS1994
                DS1994_INPUT_DATA DS1994_InputData;             // входные данные для функций DS1994
                unsigned int TempAddr;                          // для вычисления адреса
                unsigned char DS1994_SelectData;          // переменная для выбора данных для чтения
                bool DS1994_NeedMore;                     // признак, что нужно дочитать ещё байты

                SendMsgToLogForm(146,"");           // начинаем чтение данных из Timekeeping Registers
                // начинаем работать
                GetDataToMemory(0,0);                     // получаем ROM с формы (второй параметр может быть любым)
                DS1994_InputData.AreaNumber=2;          // будем читать данные из области Timekeeping Registers
                DS1994_NeedMore=false;                  // по-умолчанию ничего дочитывать не нужно
                // здесь нужно понять, какие данные мы читаем
                DS1994_SelectData=0;
                if(Form1->CheckBox1->Checked==true)     DS1994_SelectData += 1; // нулевой бит
                if(Form1->CheckBox2->Checked==true)     DS1994_SelectData += 2; // первый бит
                if(Form1->CheckBox3->Checked==true)     DS1994_SelectData += 4; // второй бит
                switch(DS1994_SelectData)
                { case 1:       // читаем только Status
                                DS1994_InputData.Size=1;                // размер посылки равен 1 байту
                                TempAddr=SelectedChip.Area2Start;       // вычисляем новое значение начального адреса области чтения
                                break;
                  case 2:       // читаем только Control
                                DS1994_InputData.Size=1;                // размер посылки равен 1 байту
                                TempAddr=SelectedChip.Area2Start+1;     // вычисляем новое значение начального адреса области чтения
                                break;
                  case 3:       // читаем Status + Control
                                DS1994_InputData.Size=2;                // размер посылки равен 2 байта
                                TempAddr=SelectedChip.Area2Start;       // вычисляем новое значение начального адреса области чтения
                                break;
                  case 4:       // читаем всё, кроме Status и Control
                                DS1994_InputData.Size=SelectedChip.Area2Size-2; // размер посылки равен 32-2 байт
                                TempAddr=SelectedChip.Area2Start+2;     // вычисляем новое значение начального адреса области чтения
                                break;
                  case 5:       // нужно прочитать Status, а потом дочитать байты после Control
                                DS1994_InputData.Size=1;                // размер посылки равен 1 байту
                                TempAddr=SelectedChip.Area2Start;       // вычисляем новое значение начального адреса области чтения
                                DS1994_NeedMore=true;                   // будем досылать ещё данные
                                break;
                  case 6:       // читаем всё, кроме Status
                                DS1994_InputData.Size=SelectedChip.Area2Size-1; // размер посылки равен 32-1 байт
                                TempAddr=SelectedChip.Area2Start+1;     // вычисляем новое значение начального адреса области чтения
                                break;
                  case 7:       // читаем всё
                                DS1994_InputData.Size=SelectedChip.Area2Size; // размер посылки равен 32 байта
                                TempAddr=SelectedChip.Area2Start;     // вычисляем новое значение начального адреса области чтения
                                break;
                  default:      // шлём сообщение, что не выбрано что читать или писать и выходим
                                SendMsgToLogForm(145,"");    // не выбрано что писать/читать
                                return;
                }
                DS1994_Read_Timekeeping_Regs_Label1:
                // если порт открыт - читаем кусок из нужной области
                if(Port!=INVALID_HANDLE_VALUE)
                { DS1994_InputData.TA1=TempAddr;                                      // вычисляем значение TA1
                  DS1994_InputData.TA2=TempAddr>>8;                                   // вычисляем значение TA2
                  DS1994_OutputData=DS1994_ReadFromMemory(DS1994_InputData);
                }
                else  // если порт закрыт - отправляем мессадж и выходим
                { SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                  return;
                }
                if(DS1994_NeedMore==true)       // если нужно дочитать данные после Control
                { DS1994_NeedMore=false;
                  DS1994_InputData.Size=SelectedChip.Area2Size-2; // размер посылки равен 32-2 байт
                  TempAddr=SelectedChip.Area2Start+2;     // вычисляем новое значение начального адреса области чтения
                  goto DS1994_Read_Timekeeping_Regs_Label1;
                }
                if(DS1994_OutputData.Success)                          // если успешно прочитали
                { // помещаем на форму Test
                  TempBuf[0]=DS1994_OutputData.Test;
                  BinToHex(TempBuf,OutHexBuf,1);        // преобразовать строку в целое (байт)
                  OutHexBuf[2]=0;                       // строка должна заканчиваться нулём
                  Form1->Edit7->Text = OutHexBuf;
                  // помещаем данные из памяти на форму
                  switch(Form1->PageControl1->TabIndex)
                  { case 0:  PlaceDataToForm(3,2);      // из Area2 в RichEdit3
                             break;
                    case 1:  PlaceDataToForm(4,2);      // из Area2 в RichEdit4
                             break;
                    default: break;
                  }
                  SendMsgToLogForm(108,"");    // чтение успешно завершено
                }
                else      SendMsgToLogForm(107,"");    // ошибка чтения
                break;
    case 0x14:  //------------------------------------------------------------
                // выбран чип DS2430A, нажата кнопка READ APPLICATION REGISTER
                //------------------------------------------------------------
                // добавляем нужные переменные
                DS2430_OUTPUT_DATA DS2430_OutputData;   // выходные данные для функций 1W
                SendMsgToLogForm(128,"");           // начинаем чтение данных из Appl.Register
                // начинаем работать
                GetDataToMemory(0,0);                   // получаем ROM с формы (второй параметр может быть любым)
                // сначала читаем регистр статуса
                // посылаем команду ReadFromStatusRegister и помещаем результат (Test) на форму
                if(Port!=INVALID_HANDLE_VALUE)  DS2430_OutputData=DS2430_ReadFromStatusRegister();
                else  // если порт закрыт - отправляем мессадж и выходим
                { SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                  return;
                }
                // теперь в зависимости от значения регистра Status читаем либо блокнот, либо
                // сам Application Register, но данные в любом случае сохраняются в Area3
                if(Port!=INVALID_HANDLE_VALUE)  DS2430_OutputData=DS2430_ReadFromApplRegister();        // читаем данные из Application Register
                else  // если порт закрыт - отправляем мессадж и выходим
                { SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                  return;
                }
                if(DS2430_OutputData.Success)           // если успешно прочитали
                { // выводим значение Status Register
                  TempBuf[0]=DS2430_OutputData.Status;
                  BinToHex(TempBuf,OutHexBuf,1);        // преобразовать строку в целое (байт)
                  OutHexBuf[2]=0;                       // строка должна заканчиваться нулём
                  Form1->Edit4->Text = OutHexBuf;
                  // помещаем данные из памяти на форму (из области 3)
                  switch(Form1->PageControl1->TabIndex)
                  { case 0:  PlaceDataToForm(3,3);   // выводим данные из Area3 в RichEdit3
                             break;
                    case 1:  PlaceDataToForm(4,3);   // выводим данные из Area3 в RichEdit4
                             break;
                    default: SendMsgToLogForm(107,"");    // ошибка чтения
                             return;
                  }
                  SendMsgToLogForm(108,"");    // чтение успешно завершено
                }
                else      SendMsgToLogForm(107,"");    // ошибка чтения
                break;
    case 0x22:  //----------------------------------------------
                // выбран чип DS1822, нажата кнопка READ EEPROM
    case 0x28:  //----------------------------------------------
                // выбран чип DS18B20, нажата кнопка READ EEPROM
                //----------------------------------------------
                // добавляем нужные переменные
                DS18B20_OUTPUT_DATA DS18B20_OutputData; // выходные данные для функций 1W
                SendMsgToLogForm(124,"");           // начинаем чтение данных из EEPROM
                // начинаем работать
                GetDataToMemory(0,0);                   // получаем ROM с формы (второй параметр может быть любым)
                // сначала выполняем recall
                if(Port!=INVALID_HANDLE_VALUE)  DS18B20_OutputData=DS18B20_RecallE2();
                else  // если порт закрыт - отправляем мессадж и выходим
                { SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                  return;
                }
                if(DS18B20_OutputData.Success)          // если получилось
                { // выполняем read scratchpad
                  if(Port!=INVALID_HANDLE_VALUE)  DS18B20_OutputData=DS18B20_ReadFromScratchpad();
                  else  // если порт закрыт - отправляем мессадж и выходим
                  { SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                    return;
                  }
                }
                if(DS18B20_OutputData.Success)          // если успешно выполнили recall и прочитали
                { // выводим в ричедит расшифрованный конфиг и вычисленные пороги
                  DS18B20_DecodeConfigAndThresholds();
                  // помещаем данные из памяти на форму
                  switch(Form1->PageControl1->TabIndex)
                  { case 0:  PlaceDataToForm(1,1);      // из Area1 в RichEdit1
                             break;
                    case 1:  PlaceDataToForm(2,1);      // из Area1 в RichEdit1
                             break;
                    default: break;
                  }
                  SendMsgToLogForm(108,"");    // чтение успешно завершено
                }
                else      SendMsgToLogForm(107,"");    // ошибка чтения
                break;
    case 0x2D:  //--------------------------------------------------
                // выбран чип DS2431, нажата кнопка READ DATA MEMORY
                //--------------------------------------------------
                // добавляем нужные переменные
                DS2431_OUTPUT_DATA DS2431_OutputData;           // выходные данные для функций DS2431
                DS2431_INPUT_DATA DS2431_InputData;             // входные данные для функций DS2431
                SendMsgToLogForm(124,"");           // начинаем чтение данных из EEPROM
                // начинаем работать
                GetDataToMemory(0,0);                     // получаем ROM с формы (второй параметр может быть любым)
                DS2431_InputData.TA1=SelectedChip.Area1Start;          // вычисляем TA1
                DS2431_InputData.TA2=SelectedChip.Area1Start>>8;       // вычисляем TA2
                DS2431_InputData.AreaNumber=1;                         // будем сохранять прочитанное в область данных
                DS2431_InputData.Size=SelectedChip.Area1Size;          // размер равен области данных
                if(Port!=INVALID_HANDLE_VALUE)  DS2431_OutputData=DS2431_ReadFromMemory(DS2431_InputData); // читаем область данных
                else  // если порт закрыт - отправляем мессадж и выходим
                { SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                  return;
                }
                if(DS2431_OutputData.Success)                          // если успешно прочитали
                { // помещаем на форму Test
                  TempBuf[0]=DS2431_OutputData.Test;
                  BinToHex(TempBuf,OutHexBuf,1);        // преобразовать строку в целое (байт)
                  OutHexBuf[2]=0;                       // строка должна заканчиваться нулём
                  Form1->Edit7->Text = OutHexBuf;
                  // помещаем данные из памяти на форму
                  switch(Form1->PageControl1->TabIndex)
                  { case 0:  PlaceDataToForm(1,1);
                             break;
                    case 1:  PlaceDataToForm(2,1);
                             break;
                    default: break;
                  }
                  SendMsgToLogForm(108,"");    // чтение успешно завершено
                }
                else      SendMsgToLogForm(107,"");    // ошибка чтения
                break;
    case 0x33:  //--------------------------------------------------
                // выбран чип DS2432, нажата кнопка READ DATA MEMORY
                //--------------------------------------------------
                // добавляем нужные переменные
                DS2432_OUTPUT_DATA DS2432_OutputData;           // выходные данные для функций DS2432
                DS2432_INPUT_DATA DS2432_InputData;             // входные данные для функций DS2432
                SendMsgToLogForm(124,"");           // начинаем чтение данных из EEPROM
                // начинаем работать
                GetDataToMemory(0,0);                     // получаем ROM с формы (второй параметр может быть любым)
                DS2432_InputData.TA1=SelectedChip.Area1Start;          // вычисляем TA1
                DS2432_InputData.TA2=SelectedChip.Area1Start>>8;       // вычисляем TA2
                DS2432_InputData.AreaNumber=1;                         // будем сохранять прочитанное в область данных
                DS2432_InputData.Size=SelectedChip.Area1Size;          // размер равен области данных
                if(Port!=INVALID_HANDLE_VALUE)  DS2432_OutputData=DS2432_ReadFromMemory(DS2432_InputData); // читаем область данных
                else  // если порт закрыт - отправляем мессадж и выходим
                { SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                  return;
                }
                if(DS2432_OutputData.Success)                          // если успешно прочитали
                { // помещаем на форму Test
                  TempBuf[0]=DS2432_OutputData.Test;
                  BinToHex(TempBuf,OutHexBuf,1);        // преобразовать строку в целое (байт)
                  OutHexBuf[2]=0;                       // строка должна заканчиваться нулём
                  Form1->Edit7->Text = OutHexBuf;
                  // помещаем данные из памяти на форму
                  switch(Form1->PageControl1->TabIndex)
                  { case 0:  PlaceDataToForm(1,1);
                             break;
                    case 1:  PlaceDataToForm(2,1);
                             break;
                    default: break;
                  }
                  SendMsgToLogForm(108,"");    // чтение успешно завершено
                }
                else      SendMsgToLogForm(107,"");    // ошибка чтения
                break;
    case 0x3B:  //--------------------------------------------------
                // выбран чип MAX31826, нажата кнопка READ DATA MEMORY
                //--------------------------------------------------
                // добавляем нужные переменные
                MAX31826_OUTPUT_DATA MAX31826_OutputData;           // выходные данные для функций MAX31826
                MAX31826_INPUT_DATA MAX31826_InputData;             // входные данные для функций MAX31826
                SendMsgToLogForm(124,"");           // начинаем чтение данных из EEPROM
                // начинаем работать
                GetDataToMemory(0,0);                     // получаем ROM с формы (второй параметр может быть любым)
                MAX31826_InputData.SA=0;          // вычисляем SA
                MAX31826_InputData.AreaNumber=1;                         // будем сохранять прочитанное в область данных
                MAX31826_InputData.Size=SelectedChip.Area1Size;          // размер равен области данных
                if(Port!=INVALID_HANDLE_VALUE)  MAX31826_OutputData=MAX31826_ReadFromMemory(MAX31826_InputData); // читаем область данных
                else  // если порт закрыт - отправляем мессадж и выходим
                { SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                  return;
                }
                if(MAX31826_OutputData.Success)                          // если успешно прочитали
                { // помещаем данные из памяти на форму
                  switch(Form1->PageControl1->TabIndex)
                  { case 0:  PlaceDataToForm(1,1);
                             break;
                    case 1:  PlaceDataToForm(2,1);
                             break;
                    default: break;
                  }
                  SendMsgToLogForm(108,"");    // чтение успешно завершено
                }
                else      SendMsgToLogForm(107,"");    // ошибка чтения
                break;
    case 0x43:  //--------------------------------------------------
                // выбран чип DS28EC20, нажата кнопка READ DATA MEMORY
                //--------------------------------------------------
                // добавляем нужные переменные
                DS28EC20_OUTPUT_DATA DS28EC20_OutputData;           // выходные данные для функций DS28EC20
                DS28EC20_INPUT_DATA DS28EC20_InputData;             // входные данные для функций DS28EC20
                SendMsgToLogForm(124,"");           // начинаем чтение данных из EEPROM
                // начинаем работать
                GetDataToMemory(0,0);                     // получаем ROM с формы (второй параметр может быть любым)
                DS28EC20_InputData.TA1=SelectedChip.Area1Start;          // вычисляем TA1
                DS28EC20_InputData.TA2=SelectedChip.Area1Start>>8;       // вычисляем TA2
                DS28EC20_InputData.AreaNumber=1;                         // будем сохранять прочитанное в область данных
                DS28EC20_InputData.Size=SelectedChip.Area1Size;          // размер равен области данных
                if(Port!=INVALID_HANDLE_VALUE)  DS28EC20_OutputData=DS28EC20_ReadFromMemory(DS28EC20_InputData); // читаем область данных
                else  // если порт закрыт - отправляем мессадж и выходим
                { SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                  return;
                }
                if(DS28EC20_OutputData.Success)                          // если успешно прочитали
                { // помещаем на форму Test
                  TempBuf[0]=DS28EC20_OutputData.Test;
                  BinToHex(TempBuf,OutHexBuf,1);        // преобразовать строку в целое (байт)
                  OutHexBuf[2]=0;                       // строка должна заканчиваться нулём
                  Form1->Edit7->Text = OutHexBuf;
                  // помещаем данные из памяти на форму
                  switch(Form1->PageControl1->TabIndex)
                  { case 0:  PlaceDataToForm(1,1);
                             break;
                    case 1:  PlaceDataToForm(2,1);
                             break;
                    default: break;
                  }
                  SendMsgToLogForm(108,"");    // чтение успешно завершено
                }
                else      SendMsgToLogForm(107,"");    // ошибка чтения
                break;
    case 0x2:   // выбран чип DS1991
    case 0x5:   // выбран чип DS2405
    case 0x6:   // выбран чип DS1993
    case 0x8:   // выбран чип DS1992
    case 0x9:   // выбран чип DS2502 / DS1982
    case 0xA:   // выбран чип DS1995
    case 0xC:   // выбран чип DS1996
    case 0xD:   // выбран чип DS28E05
    case 0x1A:  // выбран чип DS1963L
    case 0x1D:  // выбран чип DS2423
    case 0x23:  // выбран чип DS24B33
    case 0x24:  // выбран чип DS2415
    case 0x27:  // выбран чип DS2417
    case 0x2C:  // выбран чип DS2890
    case 0x82:  // выбран чип DS1425
    default:    break;
  }
}
//---------------------------------------------------------------------------
//--- НАЖАТА КНОПКА BUTTON11 ------------------------------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::Button11Click(TObject *Sender)
{ char TempBuf[1], OutHexBuf[3];                // для преобразования

  switch(SelectedChip.Family)
  { case 0x0:   // выбран один из чипов с перезаписываемым ROM
                switch(SelectedChip.Modify)
                { case 1:  // выбран чип RW1990
                  case 2:  // выбран ключ AN1990
                  case 3:  // выбран ключ TM2004
                  default: break;
                }
                break;
    case 0x14:  //----------------------------------------------
                // выбран чип DS2430A, нажата кнопка READ EEPROM
                //----------------------------------------------
                // добавляем нужные переменные
                DS2430_OUTPUT_DATA DS2430_OutputData;   // выходные данные для функций 1W
                SendMsgToLogForm(124,"");           // начинаем чтение данных из EEPROM
                // начинаем работать
                GetDataToMemory(0,0);                   // получаем ROM с формы (второй параметр может быть любым)
                if(Port!=INVALID_HANDLE_VALUE)  DS2430_OutputData=DS2430_ReadFromMemory();      // читаем данные из Data EEPROM
                else  // если порт закрыт - отправляем мессадж и выходим
                { SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                  return;
                }
                if(DS2430_OutputData.Success)           // если успешно прочитали
                { // помещаем данные из памяти на форму
                  switch(Form1->PageControl1->TabIndex)
                  { case 0:  PlaceDataToForm(1,1);
                             break;
                    case 1:  PlaceDataToForm(2,1);
                             break;
                    default: break;
                  }
                  SendMsgToLogForm(108,"");    // чтение успешно завершено
                }
                else      SendMsgToLogForm(107,"");    // ошибка чтения
                break;
    case 0x33:  //-----------------------------------------------------
                // выбран чип DS2432, нажата кнопка WRITE SECRET MEMORY
                //-----------------------------------------------------
                // добавляем нужные переменные
                DS2432_INPUT_DATA DS2432_InputData;     // входные данные для функций DS2432
                DS2432_OUTPUT_DATA DS2432_OutputData;   // выходные данные для функций DS2432
                // начинаем работать
                GetDataToMemory(0,0);                   // получаем ROM с формы (второй параметр может быть любым)
                // сначала записываем область секрета в scratchpad
                SendMsgToLogForm(116,"");    // начинаем запись в блокнот
                DS2432_InputData.TA1=SelectedChip.Area2Start;   // сохраняем значение TA1
                DS2432_InputData.TA2=0;                 // сохраняем значение TA2
                // помещаем данные с формы в память в зависимости от вкладки (для DS2432 Register Page находится в Area3)
                switch(Form1->PageControl1->TabIndex)
                { case 0:  GetDataToMemory(3,2);        // передаём данные из RichEdit3 в Secret
                           break;
                  case 1:  GetDataToMemory(4,2);        // передаём данные из RichEdit4 в Secret
                           break;
                  default: break;
                }
                // посылаем данные по 1-Wire и помещаем результат (Test) на форму
                DS2432_InputData.AreaNumber=2;                  // Secret - это Area2
                DS2432_InputData.Size=SelectedChip.Area2Size;   // размер секрета равен размеру блокнота
                if(Port!=INVALID_HANDLE_VALUE)
                { DS2432_OutputData=DS2432_WriteToScratchpad(DS2432_InputData);
                  if(DS2432_OutputData.Success)
                  { TempBuf[0]=DS2432_OutputData.Test;
                    BinToHex(TempBuf,OutHexBuf,1);      // преобразовать строку в целое (байт)
                    OutHexBuf[2]=0;                     // строка должна заканчиваться нулём
                    Form1->Edit7->Text = OutHexBuf;
                    SendMsgToLogForm(106,"");                // запись в scratchpad успешно завершена
                  }
                  else
                  {  SendMsgToLogForm(105,"");            // запись в scratchpad завершена с ошибкой
                     return;
                  }
                }
                else
                {    SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                     return;
                }
                // читаем блокнот обратно, чтобы получить код авторизации (TA1, TA2, ES)
                if(Port!=INVALID_HANDLE_VALUE)
                { DS2432_OutputData=DS2432_ReadFromScratchpad();  // читаем данные из Scratchpad
                  if(DS2432_OutputData.Success)           // если успешно прочитали
                  { DS2432_InputData.ES=DS2432_OutputData.ES;      // запоминаем E/S
                    DS2432_InputData.TA2=DS2432_OutputData.TA2;    // запоминаем TA2
                    DS2432_InputData.TA1=DS2432_OutputData.TA1;    // запоминаем TA1
                    SendMsgToLogForm(108,"");                // чтение блокнота успешно завершено
                  }
                  else
                  {  SendMsgToLogForm(107,"");            // чтение блокнота завершено с ошибкой
                     return;
                  }
                }
                else
                {    SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                     return;
                }
                // выполняем запись нового секрета в память
                if(Port!=INVALID_HANDLE_VALUE)
                { DS2432_OutputData=DS2432_LoadFirstSecret(DS2432_InputData);
                  if(DS2432_OutputData.Success)
                  { TempBuf[0]=DS2432_OutputData.Test;
                    BinToHex(TempBuf,OutHexBuf,1);        // преобразовать строку в целое (байт)
                    OutHexBuf[2]=0;                       // строка должна заканчиваться нулём
                    Form1->Edit7->Text = OutHexBuf;
                    SendMsgToLogForm(166,"");    // установка нового секрета успешно завершена
                  }
                  else    SendMsgToLogForm(165,"");    // во время установки нового секрета произошла ошибка
                }
                else    SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                break;
    case 0x3B:  //-----------------------------------------------------
                // выбран чип MAX31826, нажата кнопка Lock Low Memory
                //-----------------------------------------------------
                // добавляем нужные переменные
                MAX31826_INPUT_DATA MAX31826_InputData;     // входные данные для функций MAX31826
                MAX31826_OUTPUT_DATA MAX31826_OutputData;   // выходные данные для функций MAX31826
                // начинаем работать
                GetDataToMemory(0,0);                   // получаем ROM с формы (второй параметр может быть любым)
                // выполняем функцию залочивания
                SendMsgToLogForm(168," Low Memory");    // начинаем залочивание чипа
                MAX31826_InputData.SA=0x80;             // будем лочить младшую область памяти
                if(Port!=INVALID_HANDLE_VALUE)
                { MAX31826_OutputData=MAX31826_LockMemory(MAX31826_InputData);
                  if(MAX31826_OutputData.Success)
                  { SendMsgToLogForm(151,"");           // сообщаем, что Low Memory успешно залочена
                  }
                  else
                  {  SendMsgToLogForm(150,"");          // сообщаем, что во время залочивания произошла ошибка
                     return;
                  }
                }
                else
                {    SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                     return;
                }
                break;
    case 0x43:  //--------------------------------------------------
                // выбран чип DS28EC20, нажата кнопка READ FACTORY DATA
                //--------------------------------------------------
                // добавляем нужные переменные
                DS28EC20_OUTPUT_DATA DS28EC20_OutputData;           // выходные данные для функций DS28EC20
                DS28EC20_INPUT_DATA DS28EC20_InputData;             // входные данные для функций DS28EC20
                SendMsgToLogForm(124,"");           // начинаем чтение данных из EEPROM
                // начинаем работать
                GetDataToMemory(0,0);                     // получаем ROM с формы (второй параметр может быть любым)
                DS28EC20_InputData.TA1=SelectedChip.Area3Start;          // вычисляем TA1
                DS28EC20_InputData.TA2=SelectedChip.Area3Start>>8;       // вычисляем TA2
                DS28EC20_InputData.AreaNumber=3;                         // будем сохранять прочитанное в область заводских данных
                DS28EC20_InputData.Size=SelectedChip.Area3Size;          // размер равен области заводских данных
                if(Port!=INVALID_HANDLE_VALUE)  DS28EC20_OutputData=DS28EC20_ReadFromMemory(DS28EC20_InputData); // читаем область данных
                else  // если порт закрыт - отправляем мессадж и выходим
                { SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                  return;
                }
                if(DS28EC20_OutputData.Success)                          // если успешно прочитали
                { // помещаем на форму Test
                  TempBuf[0]=DS28EC20_OutputData.Test;
                  BinToHex(TempBuf,OutHexBuf,1);        // преобразовать строку в целое (байт)
                  OutHexBuf[2]=0;                       // строка должна заканчиваться нулём
                  Form1->Edit7->Text = OutHexBuf;
                  // помещаем данные из памяти на форму
                  switch(Form1->PageControl1->TabIndex)
                  { case 0:  PlaceDataToForm(5,3);
                             break;
                    case 1:  PlaceDataToForm(6,3);
                             break;
                    default: break;
                  }
                  SendMsgToLogForm(108,"");    // чтение успешно завершено
                }
                else      SendMsgToLogForm(107,"");    // ошибка чтения
                break;
    case 0x2:   // выбран чип DS1991
    case 0x4:   // выбран чип DS1994(DS2404)
    case 0x5:   // выбран чип DS2405
    case 0x6:   // выбран чип DS1993
    case 0x8:   // выбран чип DS1992
    case 0x9:   // выбран чип DS2502 / DS1982
    case 0xA:   // выбран чип DS1995
    case 0xC:   // выбран чип DS1996
    case 0xD:   // выбран чип DS28E05
    case 0x10:  // выбран чип DS18S20
    case 0x1A:  // выбран чип DS1963L
    case 0x1D:  // выбран чип DS2423
    case 0x22:  // выбран чип DS1822
    case 0x23:  // выбран чип DS24B33
    case 0x24:  // выбран чип DS2415
    case 0x27:  // выбран чип DS2417
    case 0x28:  // выбран чип DS18B20
    case 0x2C:  // выбран чип DS2890
    case 0x2D:  // выбран чип DS2431
    case 0x82:  // выбран чип DS1425
    case 0x84:  // выбран чип DS1427(DS2404S)
    default:    break;
  }
}
//---------------------------------------------------------------------------
//--- НАЖАТА КНОПКА BUTTON12 ------------------------------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::Button12Click(TObject *Sender)
{ char TempBuf[1], OutHexBuf[3];                // для преобразования

  switch(SelectedChip.Family)
  { case 0x0:   // выбран один из чипов с перезаписываемым ROM
                switch(SelectedChip.Modify)
                { case 1:  // выбран чип RW1990
                  case 2:  // выбран ключ AN1990
                  case 3:  // выбран ключ TM2004
                  default: break;
                }
                break;
    case 0x14:  //------------------------------------------------------------
                // выбран чип DS2430A, нажата кнопка COPY APPL.REGISTER & LOCK
                //------------------------------------------------------------
                // добавляем нужные переменные
                DS2430_OUTPUT_DATA DS2430_OutputData;   // выходные данные для функций DS2430A
                // начинаем работать
                // спрашиваем у пользователя подтверждение
                if (Application->MessageBox("Copy & Lock Application register? Are you sure?", "Warning", MB_YESNO|MB_ICONWARNING|MB_DEFBUTTON2|MB_APPLMODAL) == IDYES)
                { SendMsgToLogForm(129,"");           // начинаем копирование Appl.Register в OTP
                  // посылаем команду Copy Appl.Register & Lock
                  GetDataToMemory(0,0);                   // получаем ROM с формы (второй параметр может быть любым)
                  if(Port!=INVALID_HANDLE_VALUE)  DS2430_OutputData=DS2430_CopyAndLockApplRegister();
                  else  // если порт закрыт - отправляем мессадж и выходим
                  { SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                    return;
                  }
                  // проверяем результат
                  if(DS2430_OutputData.Success)         SendMsgToLogForm(110,"");   // копирование успешно завершено
                  else                                  SendMsgToLogForm(109,"");    // ошибка копирования
                }
                else    SendMsgToLogForm(115,"");    // операция отменена
                break;
    case 0x33:  //-----------------------------------------------------
                // выбран чип DS2432, нажата кнопка REFRESH DATA MEMORY
                //-----------------------------------------------------
                // добавляем нужные переменные
                DS2432_INPUT_DATA DS2432_InputData;     // входные данные для функций DS2432
                DS2432_OUTPUT_DATA DS2432_OutputData;   // выходные данные для функций DS2432
                // начинаем работать
                GetDataToMemory(0,0);                   // получаем ROM с формы (второй параметр может быть любым)
                // организуем цикл от 0 до 16 (область данных занимает 128 байт, а размер блокнота 8 - 128/8=16)
                for(unsigned int i=0; i<(SelectedChip.Area1Size/SelectedChip.Area4Size); i++)
                { // сначала записываем кусок области данных в scratchpad
                  SendMsgToLogForm(162,"");    // начинаем регенерацию памяти
                  DS2432_InputData.TA1=SelectedChip.Area1Start+8*i;     // сохраняем значение TA1
                  DS2432_InputData.TA2=0;                               // сохраняем значение TA2
                  // выполняем команду обновления
                  if(Port!=INVALID_HANDLE_VALUE)
                  { DS2432_OutputData=DS2432_RefreshScratchpad(DS2432_InputData);
                    if(DS2432_OutputData.Success)
                    { TempBuf[0]=DS2432_OutputData.Test;
                      BinToHex(TempBuf,OutHexBuf,1);      // преобразовать строку в целое (байт)
                      OutHexBuf[2]=0;                     // строка должна заканчиваться нулём
                      Form1->Edit7->Text = OutHexBuf;
                      SendMsgToLogForm(164,"");           // обновление данных успешно завершено
                    }
                    else
                    {  SendMsgToLogForm(163,"");            // обновление данных завершено с ошибкой
                       return;
                    }
                  }
                  else
                  {    SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                       return;
                  }
                  // читаем блокнот, чтобы получить код авторизации (TA1, TA2, ES)
                  if(Port!=INVALID_HANDLE_VALUE)
                  { DS2432_OutputData=DS2432_ReadFromScratchpad();  // читаем данные из Scratchpad
                    if(DS2432_OutputData.Success)           // если успешно прочитали
                    { DS2432_InputData.ES=DS2432_OutputData.ES;      // запоминаем E/S
                      DS2432_InputData.TA2=DS2432_OutputData.TA2;    // запоминаем TA2
                      DS2432_InputData.TA1=DS2432_OutputData.TA1;    // запоминаем TA1
                      SendMsgToLogForm(108,"");                // чтение блокнота успешно завершено
                    }
                    else
                    {  SendMsgToLogForm(107,"");            // чтение блокнота завершено с ошибкой
                       return;
                    }
                  }
                  else
                  {    SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                       return;
                  }
                  // выполняем команду LoadFirstSecret (в данном случае она не перезапишет Секрет, а заново запишет данные из блокнота в память)
                  if(Port!=INVALID_HANDLE_VALUE)
                  { DS2432_OutputData=DS2432_LoadFirstSecret(DS2432_InputData);
                    if(DS2432_OutputData.Success)
                    { TempBuf[0]=DS2432_OutputData.Test;
                      BinToHex(TempBuf,OutHexBuf,1);        // преобразовать строку в целое (байт)
                      OutHexBuf[2]=0;                       // строка должна заканчиваться нулём
                      Form1->Edit7->Text = OutHexBuf;
                      SendMsgToLogForm(166,"");    // установка нового секрета успешно завершена
                    }
                    else
                    {    SendMsgToLogForm(165,"");    // во время установки нового секрета произошла ошибка
                         return;
                    }
                  }
                  else
                  {    SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                       return;
                  }
                }
                break;
    case 0x3B:  //-----------------------------------------------------
                // выбран чип MAX31826, нажата кнопка Lock High Memory
                //-----------------------------------------------------
                // добавляем нужные переменные
                MAX31826_INPUT_DATA MAX31826_InputData;     // входные данные для функций MAX31826
                MAX31826_OUTPUT_DATA MAX31826_OutputData;   // выходные данные для функций MAX31826
                // начинаем работать
                GetDataToMemory(0,0);                   // получаем ROM с формы (второй параметр может быть любым)
                // выполняем функцию залочивания
                SendMsgToLogForm(168," High Memory");    // начинаем залочивание чипа
                MAX31826_InputData.SA=0x81;              // будем лочить старшую область памяти
                if(Port!=INVALID_HANDLE_VALUE)
                { MAX31826_OutputData=MAX31826_LockMemory(MAX31826_InputData);
                  if(MAX31826_OutputData.Success)
                  { SendMsgToLogForm(151,"");           // сообщаем, что Low Memory успешно залочена
                  }
                  else
                  {  SendMsgToLogForm(150,"");          // сообщаем, что во время залочивания произошла ошибка
                     return;
                  }
                }
                else
                {    SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                     return;
                }
                break;
    case 0x2:   // выбран чип DS1991
    case 0x4:   // выбран чип DS1994(DS2404)
    case 0x5:   // выбран чип DS2405
    case 0x6:   // выбран чип DS1993
    case 0x8:   // выбран чип DS1992
    case 0x9:   // выбран чип DS2502 / DS1982
    case 0xA:   // выбран чип DS1995
    case 0xC:   // выбран чип DS1996
    case 0xD:   // выбран чип DS28E05
    case 0x10:  // выбран чип DS18S20
    case 0x1A:  // выбран чип DS1963L
    case 0x1D:  // выбран чип DS2423
    case 0x22:  // выбран чип DS1822
    case 0x23:  // выбран чип DS24B33
    case 0x24:  // выбран чип DS2415
    case 0x27:  // выбран чип DS2417
    case 0x28:  // выбран чип DS18B20
    case 0x2C:  // выбран чип DS2890
    case 0x2D:  // выбран чип DS2431
    case 0x82:  // выбран чип DS1425
    case 0x84:  // выбран чип DS1427(DS2404S)
    default:    break;
  }
}
//---------------------------------------------------------------------------
//--- НАЖАТА КНОПКА BUTTON14 ------------------------------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::Button14Click(TObject *Sender)
{
  switch(SelectedChip.Family)
  { case 0x0:   // выбран один из чипов с перезаписываемым ROM
                switch(SelectedChip.Modify)
                { case 1:  // выбран чип RW1990
                  case 2:  // выбран ключ AN1990
                  case 3:  // выбран ключ TM2004
                  default: break;
                }
                break;
    case 0x3B:  //---------------------------------------------------------------
                // выбран чип MAX31826, нажата кнопка COPY SCRATCHPAD 2 TO MEMORY
                //---------------------------------------------------------------
                // добавляем нужные переменные
                MAX31826_OUTPUT_DATA MAX31826_OutputData; // выходные данные для функций MAX31826
                SendMsgToLogForm(118,"");    // начинаем копирование блокнота в EEPROM
                // начинаем работать
                // посылаем команду Copy Scratchpad 2 to Memory
                GetDataToMemory(0,0);                   // получаем ROM с формы (второй параметр может быть любым)
                if(Port!=INVALID_HANDLE_VALUE)
                {  MAX31826_OutputData=MAX31826_CopyScratchpadToMemory();
                   if(MAX31826_OutputData.Success)      SendMsgToLogForm(110,"");    // копирование из блокнота в EEPROM успешно завершено
                   else                                 SendMsgToLogForm(109,"");    // во время копирование из блокнота в EEPROM произошла ошибка
                }
                else    SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                break;
    case 0x2:   // выбран чип DS1991
    case 0x4:   // выбран чип DS1994(DS2404)
    case 0x5:   // выбран чип DS2405
    case 0x6:   // выбран чип DS1993
    case 0x8:   // выбран чип DS1992
    case 0x9:   // выбран чип DS2502 / DS1982
    case 0xA:   // выбран чип DS1995
    case 0xC:   // выбран чип DS1996
    case 0xD:   // выбран чип DS28E05
    case 0x10:  // выбран чип DS18S20
    case 0x14:  // выбран чип DS2430A
    case 0x1A:  // выбран чип DS1963L
    case 0x1D:  // выбран чип DS2423
    case 0x22:  // выбран чип DS1822
    case 0x23:  // выбран чип DS24B33
    case 0x24:  // выбран чип DS2415
    case 0x27:  // выбран чип DS2417
    case 0x28:  // выбран чип DS18B20
    case 0x2C:  // выбран чип DS2890
    case 0x2D:  // выбран чип DS2431
    case 0x33:  // выбран чип DS2432
    case 0x82:  // выбран чип DS1425
    case 0x84:  // выбран чип DS1427(DS2404S)
    default:    break;
  }
}
//---------------------------------------------------------------------------
//--- НАЖАТА КНОПКА BUTTON15 ------------------------------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::Button15Click(TObject *Sender)
{
  switch(SelectedChip.Family)
  { case 0x3B:  //--------------------------------------------------------
                // выбран чип MAX31826, нажата кнопка Read Lock Status ---
                //--------------------------------------------------------
                // добавляем нужные переменные
                MAX31826_INPUT_DATA MAX31826_InputData;     // входные данные для функций MAX31826
                MAX31826_OUTPUT_DATA MAX31826_OutputData;   // выходные данные для функций MAX31826
                // начинаем работать
                GetDataToMemory(0,0);                   // получаем ROM с формы (второй параметр может быть любым)
                // выполняем функцию чтения статуса залочивания для младшей области памяти
                SendMsgToLogForm(169,"");               // читаем lock-статус
                MAX31826_InputData.SA=0x80;             // будем читать залочена ли младшая область памяти
                if(Port!=INVALID_HANDLE_VALUE)
                { MAX31826_OutputData=MAX31826_ReadLockStatus(MAX31826_InputData);
                  if(MAX31826_OutputData.Success)
                  { if(MAX31826_OutputData.Test == 0x55 )
                    {   SendMsgToLogForm(170,": Low");       // сообщаем, что область памяти залочена
                    }
                    else
                    {   SendMsgToLogForm(171,": Low");       // сообщаем, что область памяти не залочена
                    }
                                                        // выводим прочитанный байт в лог
                  }
                  else
                  {  SendMsgToLogForm(150,"");          // сообщаем, что во время чтения статуса произошла ошибка
                     return;
                  }
                }
                else
                {    SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                     return;
                }
                // выполняем функцию чтения статуса залочивания для старшей области памяти
                MAX31826_InputData.SA=0x81;             // будем читать залочена ли младшая область памяти
                if(Port!=INVALID_HANDLE_VALUE)
                { MAX31826_OutputData=MAX31826_ReadLockStatus(MAX31826_InputData);
                  if(MAX31826_OutputData.Success)
                  { if(MAX31826_OutputData.Test == 0x55 )
                    {   SendMsgToLogForm(170,": High");       // сообщаем, что область памяти залочена
                    }
                    else
                    {   SendMsgToLogForm(171,": High");       // сообщаем, что область памяти не залочена
                    }
                                                        // выводим прочитанный байт в лог
                  }
                  else
                  {  SendMsgToLogForm(150,"");          // сообщаем, что во время чтения статуса произошла ошибка
                     return;
                  }
                }
                else
                {    SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                     return;
                }
                break;
    case 0x0:   // выбран один из чипов с перезаписываемым ROM
    case 0x2:   // выбран чип DS1991
    case 0x4:   // выбран чип DS1994(DS2404)
    case 0x5:   // выбран чип DS2405
    case 0x6:   // выбран чип DS1993
    case 0x8:   // выбран чип DS1992
    case 0x9:   // выбран чип DS2502 / DS1982
    case 0xA:   // выбран чип DS1995
    case 0xC:   // выбран чип DS1996
    case 0xD:   // выбран чип DS28E05
    case 0x10:  // выбран чип DS18S20
    case 0x14:  // выбран чип DS2430A
    case 0x1A:  // выбран чип DS1963L
    case 0x1D:  // выбран чип DS2423
    case 0x22:  // выбран чип DS1822
    case 0x23:  // выбран чип DS24B33
    case 0x24:  // выбран чип DS2415
    case 0x27:  // выбран чип DS2417
    case 0x28:  // выбран чип DS18B20
    case 0x2C:  // выбран чип DS2890
    case 0x2D:  // выбран чип DS2431
    case 0x33:  // выбран чип DS2432
    case 0x82:  // выбран чип DS1425
    case 0x84:  // выбран чип DS1427(DS2404S)
    default:    break;
  }
}
//---------------------------------------------------------------------------
//--- СРАБОТАЛ TIMER1 -------------------------------------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::Timer1Timer(TObject *Sender)
{ Form1->Timer1->Enabled=false;         // выключаем таймер
  switch(SelectedChip.Family)
  { case 0x0:   // выбран один из чипов с перезаписываемым ROM
                switch(SelectedChip.Modify)
                { case 1:  // выбран чип RW1990
                  case 2:  // выбран ключ AN1990
                  case 3:  // выбран ключ TM2004
                  default: break;
                }
                break;
    case 0x10:  //------------------------------------
                // выбран чип DS18S20, сработал TIMER1
                //------------------------------------
                // добавляем переменные
                DS18S20_OUTPUT_DATA DS18S20_OutputData; // выходные данные для функций DS18S20
                float DS18S20_TempValue;                // сюда будем получать значение температуры
                // начинаем работать
                if(Port!=INVALID_HANDLE_VALUE)  DS18S20_OutputData=DS18S20_ConvertT();          // запускаем преобразование
                else  // если порт закрыт - отправляем мессадж и выходим
                { SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                  return;
                }
                Sleep(2000);                                                                    // даём время на выполнение
                if(Port!=INVALID_HANDLE_VALUE)  DS18S20_OutputData=DS18S20_ReadFromScratchpad();        // читаем блокнот
                else  // если порт закрыт - отправляем мессадж и выходим
                { SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                  return;
                }
                if(DS18S20_OutputData.Success)                                                  // если всё получилось
                { DS18S20_TempValue = DS18S20_DecodeTemperature();                       // декодируем температуру
                  Form1->Edit4->Text=FloatToStrF(DS18S20_TempValue, ffFixed, 7, 7);      // выводим температуру в Edit4
                  Form1->Timer1->Enabled=true;          // включаем таймер и выходим
                }
                else    SendMsgToLogForm(107,"");    // ошибка чтения
                break;
    case 0x22:  //------------------------------------
                // выбран чип DS1822, сработал TIMER1
    case 0x28:  //------------------------------------
                // выбран чип DS18B20, сработал TIMER1
                //------------------------------------
                // добавляем переменные
                DS18B20_OUTPUT_DATA DS18B20_OutputData; // выходные данные для функций DS18B20
                float DS18B20_TempValue;                // сюда будем получать значение температуры
                // начинаем работать
                if(Port!=INVALID_HANDLE_VALUE)  DS18B20_OutputData=DS18B20_ConvertT();          // запускаем преобразование
                else  // если порт закрыт - отправляем мессадж и выходим
                { SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                  return;
                }
                Sleep(2000);                                                                    // даём время на выполнение
                if(Port!=INVALID_HANDLE_VALUE)  DS18B20_OutputData=DS18B20_ReadFromScratchpad();        // читаем блокнот
                else  // если порт закрыт - отправляем мессадж и выходим
                { SendMsgToLogForm(2,"");    // Ошибка. COM-порт не доступен
                  return;
                }
                if(DS18B20_OutputData.Success)                                                  // если всё получилось
                { DS18B20_TempValue = DS18B20_DecodeTemperature();                       // декодируем температуру
                  Form1->Edit4->Text=FloatToStrF(DS18B20_TempValue, ffFixed, 7, 7);      // выводим температуру в Edit4
                  Form1->Timer1->Enabled=true;          // включаем таймер и выходим
                }
                else    SendMsgToLogForm(107,"");    // ошибка чтения
                break;
    case 0x2:   // выбран чип DS1991
    case 0x4:   // выбран чип DS1994(DS2404)
    case 0x5:   // выбран чип DS2405
    case 0x6:   // выбран чип DS1993
    case 0x8:   // выбран чип DS1992
    case 0x9:   // выбран чип DS2502 / DS1982
    case 0xA:   // выбран чип DS1995
    case 0xC:   // выбран чип DS1996
    case 0xD:   // выбран чип DS28E05
    case 0x14:  // выбран чип DS2430A
    case 0x1A:  // выбран чип DS1963L
    case 0x1D:  // выбран чип DS2423
    case 0x23:  // выбран чип DS24B33
    case 0x24:  // выбран чип DS2415
    case 0x27:  // выбран чип DS2417
    case 0x2C:  // выбран чип DS2890
    case 0x2D:  // выбран чип DS2431
    case 0x33:  // выбран чип DS2432 / DS1961S
    case 0x3B:  // выбран чип MAX31826
    case 0x82:  // выбран чип DS1425
    case 0x84:  // выбран чип DS1427(DS2404S)
    default:    break;
  }
}
//---------------------------------------------------------------------------
//***************************************************************************
//*** РАБОТА С РАЗНЫМИ ПУНКТАМИ МЕНЮ ****************************************
//***************************************************************************
//---------------------------------------------------------------------------
//--- ЧЕРЕЗ ВЕРХНЕЕ МЕНЮ ВЫБРАНО ОТКРЫТИЕ ФАЙЛА -----------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::Open1Click(TObject *Sender)
{ AnsiString FilePath, Ext;
  int NameLength;

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

  // сначала определяемся, куда будем писать
  SelBin=false; SelHex=false;
  FilePath=Form1->StaticText1->Caption;         // получаем имя файла в который будем сохранять
  FilePathLength=FilePath.Length();             // вычисляем длину всего пути вместе с именем
  if(FilePathLength)                            // если длина пути не ноль (и значит есть открытый файл)
  { // спрашиваем, уверен ли юзер, что хочет продолжить
    if(MessageBox(Form1->Handle,"Текущий файл будет перезаписан, продолжить?","", MB_OKCANCEL|MB_ICONQUESTION)==IDOK)
    { // если юзер не передумал сохранять файл
      Ext=FilePath.SubString(FilePathLength-2,3); // выделяем расширение
      Ext=UpperCase(Ext);                         // переводим расширение в верхний регистр
      // определяем куда будем сохранять
      if(Ext=="BIN")    SelBin=true;            // если открыт bin-файл - будем сохранять в bin
      else              SelHex=true;            // иначе будем сохранять в hex-файл
    }
  }
  // если открытого файла нет - вызываем диалог
  else if(SaveDialog1->Execute())               // если определились куда сохранять (не нажали отмена)
  { FilePath=SaveDialog1->FileName;             // получаем имя файла для сохранения
    FilePathLength=FilePath.Length();           // вычисляем длину всего пути вместе с именем
    Ext=FilePath.SubString(FilePathLength-2,3); // выделяем расширение (последние 3 символа)
    Ext=UpperCase(Ext);                         // переводим расширение в верхний регистр
    // определяем расширение (куда будем сохранять)
    if(SaveDialog1->FilterIndex == 1)           // выбран формат BIN (он в списке SaveDialog первый)
    { if(Ext!="BIN")    FilePath = FilePath + ".bin";   // если расширение файла не bin - дописываем в конце .bin
      SelBin=true;
    }
    else                                        // выбран формат HEX (ну раз не BIN, их в списке всего два)
    { if(Ext!="HEX")    FilePath = FilePath + ".hex";   // если расширение файла не hex - дописываем в конце .hex
      SelHex=true;
    }
  }
  //------------------------------------------
  // А теперь, собственно, пишем данные в файл
  //------------------------------------------
  if(SelBin)            // если нужно сохранять в bin
  { SaveFromMemoryToBinFile(FilePath);  // потом сохраняем из памяти в bin-файл
  }
  if(SelHex)            //если нужно сохранять в hex
  { SaveFromMemoryToHexFile(FilePath);  // потом сохраняем из памяти в hex-файл
  }
}
//---------------------------------------------------------------------------
//--- ЧЕРЕЗ ВЕРХНЕЕ МЕНЮ ВЫБРАНО СОХРАНЕНИЕ НОВОГО ФАЙЛА --------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::Saveas1Click(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)           // выбран формат BIN (он в списке SaveDialog первый)
    { if(Ext!="BIN")    FilePath = FilePath + ".bin";   // если расширение файла не bin - дописываем в конце .bin
      SelBin=true;
    }
    else                                        // выбран формат HEX (ну раз не BIN, их в списке всего два)
    { if(Ext!="HEX")    FilePath = FilePath + ".hex";   // если расширение файла не hex - дописываем в конце .hex
      SelHex=true;
    }
  }
  //------------------------------------------
  // А теперь, собственно, пишем данные в файл
  //------------------------------------------
  if(SelBin)            // если нужно сохранять в bin
  { SaveFromMemoryToBinFile(FilePath);  // потом сохраняем из памяти в bin-файл
  }
  if(SelHex)            //если нужно сохранять в hex
  { SaveFromMemoryToHexFile(FilePath);  // потом сохраняем из памяти в hex-файл
  }
}
//---------------------------------------------------------------------------
//--- ЧЕРЕЗ ВЕРХНЕЕ МЕНЮ ВЫБРАНО СОХРАНЕНИЕ НОВОГО ЛОГА ---------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::SaveLogas1Click(TObject *Sender)
{ AnsiString FilePath;                          // полный путь к файлу

  if(SaveDialog1->Execute())                    // если определились куда сохранять (не нажали отмена)
  { FilePath=SaveDialog1->FileName;             // получаем имя файла для сохранения
    // сохраняем данные из лога
    Form1->RichEdit9->Lines->SaveToFile(FilePath);   // сохраняем данные из RichEdit9
  }
}
//---------------------------------------------------------------------------
//--- ЧЕРЕЗ ВЕРХНЕЕ МЕНЮ ВЫБРАН АНГЛИЙСКИЙ ЯЗЫК СООБЩЕНИЙ -------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::Lang1Click(TObject *Sender)
{ LangNum=0;            // выбираем английский
  RenameFormElements();
}
//---------------------------------------------------------------------------
//--- ЧЕРЕЗ ВЕРХНЕЕ МЕНЮ ВЫБРАН РУССКИЙ ЯЗЫК СООБЩЕНИЙ ----------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::Lang2Click(TObject *Sender)
{ LangNum=1;            // выбираем русский
  RenameFormElements();
}
//---------------------------------------------------------------------------
//--- ЧЕРЕЗ ВЕРХНЕЕ МЕНЮ ВЫБРАН ПРОГРАММАТОР RH-0004 ------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::RH00041Click(TObject *Sender)
{ SelectedProgrammer = 1;       // выбран RH-0004
  RenameProgrammerMenu();       // переподписываем элементы в меню выбора программатора
  Form1->Button2->Click();      // жмём кнопку Disconnect
}
//---------------------------------------------------------------------------
//--- ЧЕРЕЗ ВЕРХНЕЕ МЕНЮ ВЫБРАН ПРОГРАММАТОР RH-0010 ------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::RH00101Click(TObject *Sender)
{ SelectedProgrammer = 2;       // выбран RH-0010
  RenameProgrammerMenu();       // переподписываем элементы в меню выбора программатора
  Form1->Button2->Click();      // жмём кнопку Disconnect
}
//---------------------------------------------------------------------------
//--- ЧЕРЕЗ ВЕРХНЕЕ МЕНЮ ВЫБРАН ЧИП DS2431 ----------------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::DS24311Click(TObject *Sender)
{ SelectedChip.Modify = 0;      // выбрана модификация DS2431
  InitChip(0x2D);       // заполняем структуру чипа, инициализируем память
  InitFormInf(0x2D);    // инициализируем данные ричэдитов под наш чип
  InitForm(0x2D);       // инициализируем элементы формы под наш чип
}
//---------------------------------------------------------------------------
//--- ЧЕРЕЗ ВЕРХНЕЕ МЕНЮ ВЫБРАН ЧИП DS28E07 ---------------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::DS28E071Click(TObject *Sender)
{ SelectedChip.Modify = 1;      // выбрана модификация DS28E07
  InitChip(0x2D);       // заполняем структуру чипа, инициализируем память
  InitFormInf(0x2D);    // инициализируем данные ричэдитов под наш чип
  InitForm(0x2D);       // инициализируем элементы формы под наш чип
}
//---------------------------------------------------------------------------
//--- ЧЕРЕЗ ВЕРХНЕЕ МЕНЮ ВЫБРАН ЧИП DS2430A ---------------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::DS24301Click(TObject *Sender)
{ SelectedChip.Modify = 0;      // выбрана модификация DS2430A
  InitChip(0x14);       // заполняем структуру чипа, инициализируем память
  InitFormInf(0x14);    // инициализируем данные ричэдитов под наш чип
  InitForm(0x14);       // инициализируем элементы формы под наш чип
}
//---------------------------------------------------------------------------
//--- ЧЕРЕЗ ВЕРХНЕЕ МЕНЮ ВЫБРАН ЧИП DS1971 ----------------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::DS19711Click(TObject *Sender)
{ SelectedChip.Modify = 1;      // выбрана модификация DS1971
  InitChip(0x14);       // заполняем структуру чипа, инициализируем память
  InitFormInf(0x14);    // инициализируем данные ричэдитов под наш чип
  InitForm(0x14);       // инициализируем элементы формы под наш чип
}
//---------------------------------------------------------------------------
//--- ЧЕРЕЗ ВЕРХНЕЕ МЕНЮ ВЫБРАН ЧИП DS24B33 ---------------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::DS24B331Click(TObject *Sender)
{ SelectedChip.Modify = 0;      // выбрана модификация DS24B33
  InitChip(0x23);       // заполняем структуру чипа, инициализируем память
  InitFormInf(0x23);    // инициализируем данные ричэдитов под наш чип
  InitForm(0x23);       // инициализируем элементы формы под наш чип
}
//---------------------------------------------------------------------------
//--- ЧЕРЕЗ ВЕРХНЕЕ МЕНЮ ВЫБРАН ЧИП DS18B20 ---------------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::DS18B201Click(TObject *Sender)
{ SelectedChip.Modify = 0;      // выбрана модификация DS18B20
  InitChip(0x28);       // заполняем структуру чипа, инициализируем память
  InitFormInf(0x28);    // инициализируем данные ричэдитов под наш чип
  InitForm(0x28);       // инициализируем элементы формы под наш чип
}
//---------------------------------------------------------------------------
//--- ЧЕРЕЗ ВЕРХНЕЕ МЕНЮ ВЫБРАН ЧИП DS18S20 ---------------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::DS18S201Click(TObject *Sender)
{ SelectedChip.Modify = 0;      // выбрана модификация DS18S20
  InitChip(0x10);       // заполняем структуру чипа, инициализируем память
  InitFormInf(0x10);    // инициализируем данные ричэдитов под наш чип
  InitForm(0x10);       // инициализируем элементы формы под наш чип
}
//---------------------------------------------------------------------------
//--- ЧЕРЕЗ ВЕРХНЕЕ МЕНЮ ВЫБРАН ЧИП DS1920 ----------------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::DS19201Click(TObject *Sender)
{ SelectedChip.Modify = 1;      // выбрана модификация DS1920
  InitChip(0x10);       // заполняем структуру чипа, инициализируем память
  InitFormInf(0x10);    // инициализируем данные ричэдитов под наш чип
  InitForm(0x10);       // инициализируем элементы формы под наш чип
}
//---------------------------------------------------------------------------
//--- ЧЕРЕЗ ВЕРХНЕЕ МЕНЮ ВЫБРАН ЧИП DS1991 ----------------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::DS19911Click(TObject *Sender)
{ SelectedChip.Modify = 0;      // выбрана модификация DS1991
  InitChip(0x2);        // заполняем структуру чипа, инициализируем память
  InitFormInf(0x2);     // инициализируем данные ричэдитов под наш чип
  InitForm(0x2);        // инициализируем элементы формы под наш чип
}
//---------------------------------------------------------------------------
//--- ЧЕРЕЗ ВЕРХНЕЕ МЕНЮ ВЫБРАН ЧИП DS1425 ----------------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::DS14251Click(TObject *Sender)
{ SelectedChip.Modify = 0;      // выбрана модификация DS1425
  InitChip(0x82);        // заполняем структуру чипа, инициализируем память
  InitFormInf(0x82);     // инициализируем данные ричэдитов под наш чип
  InitForm(0x82);        // инициализируем элементы формы под наш чип
}
//---------------------------------------------------------------------------
//--- ЧЕРЕЗ ВЕРХНЕЕ МЕНЮ ВЫБРАН ЧИП DS1992 ----------------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::DS19921Click(TObject *Sender)
{ SelectedChip.Modify = 0;      // выбрана модификация DS1992
  InitChip(0x8);        // заполняем структуру чипа, инициализируем память
  InitFormInf(0x8);     // инициализируем данные ричэдитов под наш чип
  InitForm(0x8);        // инициализируем элементы формы под наш чип
}
//---------------------------------------------------------------------------
//--- ЧЕРЕЗ ВЕРХНЕЕ МЕНЮ ВЫБРАН ЧИП DS1993 ----------------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::DS19931Click(TObject *Sender)
{ SelectedChip.Modify = 0;      // выбрана модификация DS1993
  InitChip(0x6);        // заполняем структуру чипа, инициализируем память
  InitFormInf(0x6);     // инициализируем данные ричэдитов под наш чип
  InitForm(0x6);        // инициализируем элементы формы под наш чип
}
//---------------------------------------------------------------------------
//--- ЧЕРЕЗ ВЕРХНЕЕ МЕНЮ ВЫБРАН ЧИП DS1995 ----------------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::DS19951Click(TObject *Sender)
{ SelectedChip.Modify = 0;      // выбрана модификация DS1995
  InitChip(0xA);        // заполняем структуру чипа, инициализируем память
  InitFormInf(0xA);     // инициализируем данные ричэдитов под наш чип
  InitForm(0xA);        // инициализируем элементы формы под наш чип
}
//---------------------------------------------------------------------------
//--- ЧЕРЕЗ ВЕРХНЕЕ МЕНЮ ВЫБРАН ЧИП DS1996 ----------------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::DS19961Click(TObject *Sender)
{ SelectedChip.Modify = 0;      // выбрана модификация DS1996
  InitChip(0xC);        // заполняем структуру чипа, инициализируем память
  InitFormInf(0xC);     // инициализируем данные ричэдитов под наш чип
  InitForm(0xC);        // инициализируем элементы формы под наш чип
}
//---------------------------------------------------------------------------
//--- ЧЕРЕЗ ВЕРХНЕЕ МЕНЮ ВЫБРАН ЧИП DS2405 ----------------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::DS24051Click(TObject *Sender)
{ SelectedChip.Modify = 0;      // выбрана модификация DS2405
  InitChip(0x5);        // заполняем структуру чипа, инициализируем память
  InitFormInf(0x5);     // инициализируем данные ричэдитов под наш чип
  InitForm(0x5);        // инициализируем элементы формы под наш чип
}
//---------------------------------------------------------------------------
//--- ЧЕРЕЗ ВЕРХНЕЕ МЕНЮ ВЫБРАН ЧИП DS1822 ----------------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::DS18221Click(TObject *Sender)
{ SelectedChip.Modify = 0;      // выбрана модификация DS1822
  InitChip(0x22);        // заполняем структуру чипа, инициализируем память
  InitFormInf(0x22);     // инициализируем данные ричэдитов под наш чип
  InitForm(0x22);        // инициализируем элементы формы под наш чип
}
//---------------------------------------------------------------------------
//--- ЧЕРЕЗ ВЕРХНЕЕ МЕНЮ ВЫБРАН ЧИП DS2415 ----------------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::DS24151Click(TObject *Sender)
{ SelectedChip.Modify = 0;      // выбрана модификация DS2415
  InitChip(0x24);        // заполняем структуру чипа, инициализируем память
  InitFormInf(0x24);     // инициализируем данные ричэдитов под наш чип
  InitForm(0x24);        // инициализируем элементы формы под наш чип
}
//---------------------------------------------------------------------------
//--- ЧЕРЕЗ ВЕРХНЕЕ МЕНЮ ВЫБРАН ЧИП DS2417 ----------------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::DS24171Click(TObject *Sender)
{ SelectedChip.Modify = 0;      // выбрана модификация DS2417
  InitChip(0x27);        // заполняем структуру чипа, инициализируем память
  InitFormInf(0x27);     // инициализируем данные ричэдитов под наш чип
  InitForm(0x27);        // инициализируем элементы формы под наш чип
}
//---------------------------------------------------------------------------
//--- ЧЕРЕЗ ВЕРХНЕЕ МЕНЮ ВЫБРАН ЧИП DS1994 ----------------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::DS19941Click(TObject *Sender)
{ SelectedChip.Modify = 0;      // выбрана модификация DS1994
  InitChip(0x4);        // заполняем структуру чипа, инициализируем память
  InitFormInf(0x4);     // инициализируем данные ричэдитов под наш чип
  InitForm(0x4);        // инициализируем элементы формы под наш чип
}
//---------------------------------------------------------------------------
//--- ЧЕРЕЗ ВЕРХНЕЕ МЕНЮ ВЫБРАН ЧИП DS2404 (АНАЛОГ DS1994) ------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::DS24041Click(TObject *Sender)
{ SelectedChip.Modify = 1;      // выбрана модификация DS2404
  InitChip(0x4);        // заполняем структуру чипа, инициализируем память
  InitFormInf(0x4);     // инициализируем данные ричэдитов под наш чип
  InitForm(0x4);        // инициализируем элементы формы под наш чип
}
//---------------------------------------------------------------------------
//--- ЧЕРЕЗ ВЕРХНЕЕ МЕНЮ ВЫБРАН ЧИП DS1963L ---------------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::DS1963L1Click(TObject *Sender)
{ SelectedChip.Modify = 0;      // выбрана модификация DS1963L
  InitChip(0x1A);        // заполняем структуру чипа, инициализируем память
  InitFormInf(0x1A);     // инициализируем данные ричэдитов под наш чип
  InitForm(0x1A);        // инициализируем элементы формы под наш чип
}
//---------------------------------------------------------------------------
//--- ЧЕРЕЗ ВЕРХНЕЕ МЕНЮ ВЫБРАН ЧИП DS2423 ----------------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::DS24231Click(TObject *Sender)
{ SelectedChip.Modify = 0;      // выбрана модификация DS2423
  InitChip(0x1D);        // заполняем структуру чипа, инициализируем память
  InitFormInf(0x1D);     // инициализируем данные ричэдитов под наш чип
  InitForm(0x1D);        // инициализируем элементы формы под наш чип
}
//---------------------------------------------------------------------------
//--- ЧЕРЕЗ ВЕРХНЕЕ МЕНЮ ВЫБРАН ЧИП DS2890 ----------------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::DS28901Click(TObject *Sender)
{ SelectedChip.Modify = 0;      // выбрана модификация DS2890
  InitChip(0x2C);        // заполняем структуру чипа, инициализируем память
  InitFormInf(0x2C);     // инициализируем данные ричэдитов под наш чип
  InitForm(0x2C);        // инициализируем элементы формы под наш чип
}
//---------------------------------------------------------------------------
//--- ЧЕРЕЗ ВЕРХНЕЕ МЕНЮ ВЫБРАН ЧИП DS1427 ----------------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::DS14271Click(TObject *Sender)
{ SelectedChip.Modify = 0;      // выбрана модификация DS1427
  InitChip(0x84);        // заполняем структуру чипа, инициализируем память
  InitFormInf(0x84);     // инициализируем данные ричэдитов под наш чип
  InitForm(0x84);        // инициализируем элементы формы под наш чип
}
//---------------------------------------------------------------------------
//--- ЧЕРЕЗ ВЕРХНЕЕ МЕНЮ ВЫБРАН ЧИП RW1990 ----------------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::RW19901Click(TObject *Sender)
{ SelectedChip.Modify = 1;      // вручную выбран чип RW1990
  InitChip(0x0);                // заполняем структуру чипа, инициализируем память
  InitFormInf(0x0);             // инициализируем данные ричэдитов под наш чип
  InitForm(0x0);                // инициализируем элементы формы под наш чип
}
//---------------------------------------------------------------------------
//--- ЧЕРЕЗ ВЕРХНЕЕ МЕНЮ ВЫБРАН ЧИП DS28E05 ---------------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::DS28E051Click(TObject *Sender)
{ SelectedChip.Modify = 0;      // выбрана модификация DS28E05
  InitChip(0xD);        // заполняем структуру чипа, инициализируем память
  InitFormInf(0xD);     // инициализируем данные ричэдитов под наш чип
  InitForm(0xD);        // инициализируем элементы формы под наш чип
}
//---------------------------------------------------------------------------
//--- ЧЕРЕЗ ВЕРХНЕЕ МЕНЮ ВЫБРАН КЛЮЧ AN1990 ---------------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::AN19901Click(TObject *Sender)
{ SelectedChip.Modify = 2;      // вручную выбран ключ AN1990
  InitChip(0x0);                // заполняем структуру чипа, инициализируем память
  InitFormInf(0x0);             // инициализируем данные ричэдитов под наш чип
  InitForm(0x0);                // инициализируем элементы формы под наш чип
}
//---------------------------------------------------------------------------
//--- ЧЕРЕЗ ВЕРХНЕЕ МЕНЮ ВЫБРАН КЛЮЧ TM-2004 --------------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::TM20041Click(TObject *Sender)
{ SelectedChip.Modify = 3;      // вручную выбран ключ TM-2004
  InitChip(0x0);                // заполняем структуру чипа, инициализируем память
  InitFormInf(0x0);             // инициализируем данные ричэдитов под наш чип
  InitForm(0x0);                // инициализируем элементы формы под наш чип
}
//---------------------------------------------------------------------------
//--- ЧЕРЕЗ ВЕРХНЕЕ МЕНЮ ВЫБРАН ЧИП DS2502 ----------------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::DS25021Click(TObject *Sender)
{ SelectedChip.Modify = 0;      // выбрана модификация DS2502
  InitChip(0x9);                // заполняем структуру чипа, инициализируем память
  InitFormInf(0x9);             // инициализируем данные ричэдитов под наш чип
  InitForm(0x9);                // инициализируем элементы формы под наш чип
}
//---------------------------------------------------------------------------
//--- ЧЕРЕЗ ВЕРХНЕЕ МЕНЮ ВЫБРАН ЧИП DS1982 ----------------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::DS19821Click(TObject *Sender)
{ SelectedChip.Modify = 1;      // выбрана модификация DS1982
  InitChip(0x9);                // заполняем структуру чипа, инициализируем память
  InitFormInf(0x9);             // инициализируем данные ричэдитов под наш чип
  InitForm(0x9);                // инициализируем элементы формы под наш чип
}
//---------------------------------------------------------------------------
//--- ЧЕРЕЗ ВЕРХНЕЕ МЕНЮ ВЫБРАН ЧИП DS2432 ----------------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::DS24321Click(TObject *Sender)
{ SelectedChip.Modify = 0;      // выбрана модификация DS2432
  InitChip(0x33);        // заполняем структуру чипа, инициализируем память
  InitFormInf(0x33);     // инициализируем данные ричэдитов под наш чип
  InitForm(0x33);        // инициализируем элементы формы под наш чип
}
//---------------------------------------------------------------------------
//--- ЧЕРЕЗ ВЕРХНЕЕ МЕНЮ ВЫБРАН ЧИП DS1961S ---------------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::DS1961S1Click(TObject *Sender)
{ SelectedChip.Modify = 1;      // выбрана модификация DS1961S
  InitChip(0x33);        // заполняем структуру чипа, инициализируем память
  InitFormInf(0x33);     // инициализируем данные ричэдитов под наш чип
  InitForm(0x33);        // инициализируем элементы формы под наш чип
}
//---------------------------------------------------------------------------
//--- ЧЕРЕЗ ВЕРХНЕЕ МЕНЮ ВЫБРАН ЧИП MAX31826 --------------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::MAX318261Click(TObject *Sender)
{ SelectedChip.Modify = 0;      // выбрана модификация MAX31826
  InitChip(0x3B);        // заполняем структуру чипа, инициализируем память
  InitFormInf(0x3B);     // инициализируем данные ричэдитов под наш чип
  InitForm(0x3B);        // инициализируем элементы формы под наш чип
}
//---------------------------------------------------------------------------
//--- ЧЕРЕЗ ВЕРХНЕЕ МЕНЮ ВЫБРАН ЧИП DS28EC20 --------------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::DS28EC201Click(TObject *Sender)
{ SelectedChip.Modify = 0;      // выбрана модификация DS28EC20
  InitChip(0x43);        // заполняем структуру чипа, инициализируем память
  InitFormInf(0x43);     // инициализируем данные ричэдитов под наш чип
  InitForm(0x43);        // инициализируем элементы формы под наш чип
}
//---------------------------------------------------------------------------

