Где можно найти информацию про чтение из com-порта?

bool __fastcall OpenPort()
{
   DCB ComDcb;
   COMMTIMEOUTS TimeOuts;
   int ok;
   // открытие СОМ- порта
   hCOM_Scaner = INVALID_HANDLE_VALUE;
   memset(&ComDcb, '\0', sizeof(DCB));
   String ComPort = "COM" + IntToStr(ScanerCom);
   String Speed= IntToStr(ScanerBound);
   hCOM_Scaner = CreateFile(ComPort.c_str(), GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL);
   ok = hCOM_Scaner != INVALID_HANDLE_VALUE;
   String tmp = "baud=" + Speed + " parity=N data=8 stop=1";
   ok = ok && BuildCommDCB(tmp.c_str(), &ComDcb);
   ComDcb.fDtrControl = DTR_CONTROL_ENABLE;
   ComDcb.fBinary = TRUE;
   ok = ok && SetCommState(hCOM_Scaner, &ComDcb);
   ok = ok && GetCommTimeouts(hCOM_Scaner, &TimeOuts);
   TimeOuts.ReadTotalTimeoutMultiplier = 50;
   ok = ok && SetCommTimeouts(hCOM_Scaner, &TimeOuts);
   if ((!ok) && (hCOM_Scaner != INVALID_HANDLE_VALUE)){
      showError("Неможливо установити параметри СОМ-порту сканера.");
      WriteLog("Неможливо установити параметри СОМ-порту сканера.", MainForm->isLog);
      CloseHandle(hCOM_Scaner);
      hCOM_Scaner = INVALID_HANDLE_VALUE;
      return false;
   }// if
   if (hCOM_Scaner == INVALID_HANDLE_VALUE){
      showError("COM-порт сканера не відкривається.");
      WriteLog("COM-порт сканера не відкривається.", MainForm->isLog);
      return false;
   }// if
   Stop = true;
   //Создаем нить для сканера
   TheScaner = new TTheScaner();
   return true;
}
//---------------------------------------------------------------------------
bool __fastcall ClosePort()
{
  // Закрываем COM порт
  Stop = false;
  TheScaner->Free();
  CloseHandle(hCOM_Scaner);
  return true;
}
 
int __fastcall ReadPort( unsigned char *buf, int len)
{
   DWORD rTmp;
   if(ReadFile(hCOM_Scaner, buf, len, &rTmp, NULL)){
      return rTmp;
   }
   return 0;
}

UINT ThreadReadFromPort(LPVOID  tfParam);
 
extern CTab2* tab2;
extern CTab1* tab1;
 
extern CString SystemMess;
extern CString SkanerMess;
 
extern CString  sm_COM_PORT;
 
CWThrd232* pWThrd232;
 
CArray <int,int&> rez_vozvrat;//массив режимов
 
CZavnomManager* m_pZavManager;
CTehnomManager* m_pTehManager;
 
STR_CURRENT_WASHER    cur_washer;
STR_VOZVRAT_WASHER washer_voz;
 
extern CWPassportView* myForm;
/////////////////////////////////////////////////////////////////////////////
IMPLEMENT_DYNCREATE(CWThrd232, CWinThread)
 
 
CWThrd232::CWThrd232()
{
    CString  strParity;
        
    m_pSerialPort = NULL;
 
        if (sm_COM_PORT=="COM2")
                m_nPortNumber = COM2;
        else
                m_nPortNumber = COM1;
    strParity = "N";
    m_chParity = strParity.GetAt(0);
    m_dwSpeed = 9600;
    m_nStopBits = 1;
    m_nWordLength = 8;
    m_dwTimeOut = 0;
 
    m_requestExit = false;
    m_thrdHdl = NULL;
 
    pWThrd232=this;
 
    cur_washer.bTehNomReady = FALSE;
    cur_washer.bZavNomReady = FALSE;
    cur_washer.bPereup = FALSE;
    cur_washer.bDovodka = FALSE;
    memset(&cur_washer.ctehnom_1_11,0,sizeof(cur_washer.ctehnom_1_11));
    memset(&cur_washer.ctehnom_12_22,0,sizeof(cur_washer.ctehnom_12_22));
    memset(&cur_washer.ctehnom,0,sizeof(cur_washer.ctehnom));
    memset(&cur_washer.czavnom,0,sizeof(cur_washer.czavnom));
    memset(&cur_washer.cmodcod,0,sizeof(cur_washer.cmodcod));
    memset(&cur_washer.cmodname,0,sizeof(cur_washer.cmodname));
    memset(&cur_washer.czaknar,0,sizeof(cur_washer.czaknar));
    memset(&cur_washer.ccountry,0,sizeof(cur_washer.ccountry));
    memset(&cur_washer.clastaddr,0,sizeof(cur_washer.clastaddr));
    memset(&cur_washer.ctestpro,0,sizeof(cur_washer.ctestpro));
}
////////////////////////////////////////////////////////////////////////////
CWThrd232::~CWThrd232()
{
 }
////////////////////////////////////////////////////////////////////////////
BOOL CWThrd232::InitInstance()
{
        m_thrdHdl = AfxBeginThread(ThreadReadFromPort,this);
 
        m_pZavManager = new CZavnomManager(this);    // Create Object Message Manager
        m_pTehManager = new CTehnomManager(this);    // Create Object Message Manager
       
        int w = 0;
        for (int i=0;i<SKAN_ALL+1;i++)// изночально обычный режим
        {
            rez_vozvrat.Add(w);
           
        }
//      pMsgMan->SetTimerMsgManager();
 
        return TRUE;
}
////////////////////////////////////////////////////////////////////////////
int CWThrd232::ExitInstance()
{
        return CWinThread::ExitInstance();
}
////////////////////////////////////////////////////////////////////////////
BEGIN_MESSAGE_MAP(CWThrd232, CWinThread)
        //{{AFX_MSG_MAP(CWThrd232)
                // NOTE - the ClassWizard will add and remove mapping macros here.
        //}}AFX_MSG_MAP
        ON_THREAD_MESSAGE(ID_START_THREAD,CWThrd232::OnStartThread)
        ON_THREAD_MESSAGE(ID_END_THREAD,CWThrd232::OnEndThread)
        ON_THREAD_MESSAGE(ID_ZAVNOM_FROM_SKANER,CWThrd232::OnZavnomFromSkaner)
        ON_THREAD_MESSAGE(ID_TEHNOM_FROM_SKANER,CWThrd232::OnTehnomFromSkaner)
        ON_THREAD_MESSAGE(ID_UNDEF_FROM_SKANER,CWThrd232::OnUndefFromSkaner)
        ON_THREAD_MESSAGE(ID_REPEAT_FROM_SKANER,CWThrd232::OnRepeatFromSkaner)
        ON_THREAD_MESSAGE(ID_BUTTON_FROM_SKANER,CWThrd232::OnButtonFromSkaner)
 
        ON_THREAD_MESSAGE(ID_MESS_TO_SKANER,CWThrd232::SendMessToScaner)
 END_MESSAGE_MAP()
/////////////////////////////////////////////////////////////////////////////
afx_msg LRESULT CWThrd232::OnStartThread(WPARAM wparam, LPARAM lparam)
{
        CWnd*           pWin = (CWnd*) wparam;
 
        m_pSerialPort = PortOpenMSWin32(m_nPortNumber,
                                            m_dwSpeed,
                                            m_chParity,
                                            m_nWordLength,
                                            m_nStopBits);
        if (m_pSerialPort != NULL)
    {
                bConnect = true;
                SystemMess = "Начало работы.Порт открыт";
                tab2->SendMessage(ID_MESSAGE_LIST,SYS_MESS, SYS_MESS);
 
                if (IsRXEmpty(m_pSerialPort) == FALSE)
                        ClearRXBuffer(m_pSerialPort);
        }
        else
        {
                SystemMess = "Начало работы. Невозможно открыть порт.";
                tab2->SendMessage(ID_MESSAGE_LIST,SYS_MESS, SYS_MESS);
        }
 
         char cMessToScan[NUM_BYTE_TX]="";
        memset(&cMessToScan,0,NUM_BYTE_RX);
        strcat(cMessToScan,"Programma^zarabotala !");
        Sleep(300);
        pWThrd232->SendMessToScaner("003",cMessToScan);
        pWThrd232->SendGoodBeepLight("003");
        Sleep(300);
        pWThrd232->SendMessToScaner("002",cMessToScan);
        pWThrd232->SendGoodBeepLight("002");
        Sleep(300);
 
        pWThrd232->SendMessToScaner("001",cMessToScan);
        pWThrd232->SendGoodBeepLight("001");
        Sleep(300);
 
        pWThrd232->SendMessToScaner("000",cMessToScan);
        pWThrd232->SendGoodBeepLight("000");
        Sleep(300);
 
        pWin->PostMessage(ID_START_THREAD,lparam,0);
        return 0;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
afx_msg LRESULT CWThrd232::OnEndThread(WPARAM wparam, LPARAM lparam)
{
        CWnd* pWin = (CWnd*) wparam;
        int repeat = 0;
 
        bConnect = false;
 
        delete (m_pZavManager); 
        delete (m_pTehManager);
 
        m_requestExitOk = false;
        m_requestExit = true;
        if (m_requestExitOk == false)
        {
                while ((m_requestExitOk == false)&&(repeat < 20))
                {
                        Sleep(100);
                        repeat++;
                }
        }
        
        if(m_pSerialPort != NULL)
            PortClose(m_pSerialPort);
 
        m_pSerialPort = NULL;
        SystemMess = "ЗАВЕРШЕНИЕ РАБОТЫ. Порт закрыт.";
        tab2->SendMessage(ID_MESSAGE_LIST,SYS_MESS, SYS_MESS);
        
        pWin->PostMessage(ID_END_THREAD,lparam,0);
        ::PostQuitMessage(0);
        return 0;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
afx_msg LRESULT CWThrd232::OnUndefFromSkaner(WPARAM wparam, LPARAM lparam)
{
        if (FALSE)
        {
                Sleep(WAIT_BEFORE_SUSPEND);
                ResThrReadBuf();
                return 0;
        }
        bAskMess_D=FALSE;
 
        BYTE*   pBuff = (BYTE*)wparam;
        
        char cMessToScan[NUM_BYTE_TX]="";
        memset(&cMessToScan,0,NUM_BYTE_RX);
 
        char mess[NUM_BYTE_RX];
        memset(&mess,0,NUM_BYTE_RX);
 
        memcpy(&mess, pBuff, NUM_BYTE_RX);
//=============================
        SKANER_MSG_ERR  msg_err;
 
        char    addr[ADDR_LEN+1];
        memset(&addr,0,sizeof(addr));
 
        memset(&msg_err,0,sizeof(SKANER_MSG_ERR));
        memcpy(&msg_err, pBuff, sizeof(SKANER_MSG_ERR));
        
        memcpy(addr, msg_err.addr, ADDR_LEN);
        
        if (strcmp(addr,cur_washer.clastaddr))
        {
                strcpy(addr, cur_washer.clastaddr);
 
                if (strcmp(addr,"003")|| strcmp(addr,"002")||strcmp(addr,"001")||strcmp(addr,"000"))
                {
                    int p=0;
                }
                else
                {
                        strcpy(addr, "003");
                }
                }
//=============================
       
        SkanerMess.Format(" Неверный формат данных: %s", mess);
        tab2->SendMessage(ID_MESSAGE_LIST,SKANER_PC, SKANER_PC);
//===
        strncat(cMessToScan,"Ne verno pro-   ^chitalsya kod,  ^perechitaite ego",NUM_BYTE_TX);
        pWThrd232->SendMessToScaner(addr,cMessToScan);
//===
 
        pWThrd232->SendBadBeepLight(addr);
 
 
        Sleep(700);
        ResThrReadBuf();
        return 0;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// wparam - (UINT) buff_rx
afx_msg LRESULT CWThrd232::OnRepeatFromSkaner(WPARAM wparam, LPARAM lparam)
{
        BYTE*   pBuff = (BYTE*)wparam;
 
        char mess[NUM_BYTE_RX];
        memset(&mess,0,NUM_BYTE_RX);
 
        memcpy(&mess, pBuff, NUM_BYTE_RX);
        
        SkanerMess.Format(" Повтор предыдущего сообщения: %s", mess);
        tab2->SendMessage(ID_MESSAGE_LIST,SKANER_PC, SKANER_PC);
               
        Sleep(700);
        ResThrReadBuf();
        return 0;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
afx_msg LRESULT CWThrd232::OnZavnomFromSkaner(WPARAM wparam, LPARAM lparam)
{
        if (bAskMess_DYN==TRUE)
        {
                Sleep(WAIT_BEFORE_SUSPEND);
                ResThrReadBuf();
                return 0;
        }
        BOOL mode_skan;
        BYTE*   pBuff = (BYTE*)wparam;
 
        char    addr[ADDR_LEN+1];
        memset(&addr,0,sizeof(addr));
 
        char    zavnom[ZAVNOM_LEN+1];
        memset(&zavnom,0,sizeof(zavnom));
 
        SKANER_MSG_ZAVNOM  msg_zavnom;
        memset(&msg_zavnom,0,sizeof(SKANER_MSG_ZAVNOM));
 
        memcpy(&msg_zavnom, pBuff, sizeof(SKANER_MSG_ZAVNOM));
        
        memcpy(addr, msg_zavnom.addr, ADDR_LEN);
        memcpy(zavnom, msg_zavnom.zavnom, ZAVNOM_LEN);
        SkanerMess.Format(" Сканер: %s. Считан заводской номер: %s", addr, zavnom);
        tab2->SendMessage(ID_MESSAGE_LIST,SKANER_PC, SKANER_PC);
        mode_skan = GetSkanMode(addr);
        if (mode_skan)// обработка возврата да
        {
            m_pZavManager->SendMessage(ID_ZAVNOM_VOZVRAT,(UINT)_T(zavnom), (UINT)_T(addr));
            strcpy(washer_voz.vlastaddr,addr);
        }
        else
        {
           m_pZavManager->SendMessage(ID_ZAVNOM_FROM_SKANER,(UINT)_T(zavnom), (UINT)_T(addr));
            strcpy(cur_washer.clastaddr,addr);
        }
         Sleep(700);
        ResThrReadBuf();
        return 0;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// wparam - (UINT) buff_rx
afx_msg LRESULT CWThrd232::OnTehnomFromSkaner(WPARAM wparam, LPARAM lparam)
{
        if ((bAskMess_DYN==TRUE) || (bAskMess_D==TRUE))
        {
            Sleep(WAIT_BEFORE_SUSPEND);
            ResThrReadBuf();
            return 0;
        }
 
        BYTE*   pBuff = (BYTE*)wparam;
        BOOL skan_mode;
        char    addr[ADDR_LEN+1];
        memset(&addr,0,sizeof(addr));
 
        char    tehnom[TEHNOM_LEN+1];
        memset(&tehnom,0,sizeof(tehnom));
        SKANER_MSG_TEHNOM  msg_tehnom;
        memset(&msg_tehnom,0,sizeof(SKANER_MSG_TEHNOM));
 
        memcpy(&msg_tehnom, pBuff, sizeof(SKANER_MSG_TEHNOM));
        memcpy(addr, msg_tehnom.addr, ADDR_LEN);
        memcpy(tehnom, msg_tehnom.tehnom, TEHNOM_LEN);
 
        skan_mode = GetSkanMode(addr);
 
        if (skan_mode)
        {
             char cMessToScan[NUM_BYTE_TX]="";
            memset(&cMessToScan,0,NUM_BYTE_RX);
            strncat(cMessToScan, "V rezime VOZVRAT^chitayut tolko^ZAVNOM!!!",NUM_BYTE_TX);
                                                       
                                SendMessToScaner(addr,cMessToScan);
                                SendBadBeepLight(addr);
 
 
        }
        else
        {
            m_pTehManager->SendMessage(ID_TEHNOM_FROM_SKANER,(UINT)_T(tehnom), (UINT)_T(addr));
 
            strcpy(cur_washer.clastaddr,addr);
        }
            SkanerMess.Format(" Сканер: %s. Считан технол-кий номер: %s", addr, tehnom);
            tab2->SendMessage(ID_MESSAGE_LIST,SKANER_PC, SKANER_PC);
     
        Sleep(700);
        ResThrReadBuf();
        return 0;
}
///////////////////////////////////////////////////////////////////
int CWThrd232::SendMessToScaner(char* pAddr, char* pMess)
{
        int nResult = -1;
        int countErr = 0;
        BYTE TxBuffer[NUM_BYTE_TX];
        memset(TxBuffer,0,sizeof(TxBuffer));
 
        BYTE TxLength = strlen(pMess);
 
        for (BYTE k=0; k < (ADDR_LEN); k++)
        {
                TxBuffer[k]=pAddr[k];
        }
 
        TxBuffer[k++]='-';      // addres delimiter
 
        TxBuffer[k++]=0x1b;     // cls display
        TxBuffer[k++]='[';
        TxBuffer[k++]='2';
        TxBuffer[k++]='J';
 
        BYTE k1=k;
        TxLength=TxLength+k1;
       
        for (k; k < TxLength; k++)
        {
                if (k>=(NUM_BYTE_TX-1))
                        break;
 
                if(pMess[k-k1]=='^')
                {
                        /////////////////////////////////
                        TxBuffer[k++]=0x1b;     // CR
                        k1++;
                        TxLength++;
                        
                         TxBuffer[k++]='E';
                        k1++;
                        TxLength++;
                        /////////////////////////////////
                        k--;
                        k1--;
                        continue;
                }
                TxBuffer[k]=pMess[k-k1];
        }
        TxBuffer[k]=0x0d;
        TxLength = ++k;
        nResult = WriteBuffer(m_pSerialPort,(char*) TxBuffer, TxLength);
        while ((nResult != ASSUCCESS) && (countErr < 3))
        {
                nResult = WriteBuffer(m_pSerialPort,(char*) TxBuffer, TxLength);
                countErr++;
        }
        return nResult;
}
///////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////
int CWThrd232::SendAskMess_Del_TEHNOM_ToScaner(char* pAddr, char* pMess)
{
                bAskMess_D=TRUE;
 
        int             nResult = -1;
        int             countErr = 0;
        BYTE    TxBuffer_tmp[NUM_BYTE_TX];
 
        BYTE    TxBuffer[NUM_BYTE_TX];
        memset(TxBuffer,0,sizeof(TxBuffer));
 
        BYTE    TxLength = strlen(pMess);
        BYTE    k=0;
        BYTE    len_esc=0;
//=====================
        TxBuffer_tmp[k++]=0x1b; // reverse mode
        TxBuffer_tmp[k++]='[';
        TxBuffer_tmp[k++]='7';
        TxBuffer_tmp[k++]='m';
 
        TxBuffer_tmp[k++]=0x1b; // move to 4,1, say Del
        TxBuffer_tmp[k++]='[';
        TxBuffer_tmp[k++]='4';
        TxBuffer_tmp[k++]=';';
        TxBuffer_tmp[k++]='1';
        TxBuffer_tmp[k++]='H';
        TxBuffer_tmp[k++]=' ';
        TxBuffer_tmp[k++]='d';
        TxBuffer_tmp[k++]='e';
        TxBuffer_tmp[k++]='l';
        TxBuffer_tmp[k++]=' ';
        TxBuffer_tmp[k++]='T';
        TxBuffer_tmp[k++]='E';
        TxBuffer_tmp[k++]='H';
        TxBuffer_tmp[k++]='N';
        TxBuffer_tmp[k++]='O';
        TxBuffer_tmp[k++]='M';
        TxBuffer_tmp[k++]=' ';
 
        TxBuffer_tmp[k++]=0x1b; // normal mode
        TxBuffer_tmp[k++]='[';
        TxBuffer_tmp[k++]='0';
        TxBuffer_tmp[k++]='m';
        len_esc=k;
//=====================
        for (k=0; k < (ADDR_LEN); k++)
        {
           TxBuffer[k]=pAddr[k];
        }
        TxBuffer[k++]='-';      // addres delimiter
        TxBuffer[k++]=0x1b;     // cls display
        TxBuffer[k++]='[';
        TxBuffer[k++]='2';
        TxBuffer[k++]='J';
 
        BYTE k1=k;
        TxLength=TxLength+k1;
         for (k; k < TxLength; k++)
        {
                if (k>=(NUM_BYTE_TX-len_esc-2))
                        break;
 
                if(pMess[k-k1]=='^')
                {
                       TxBuffer[k++]=0x1b;     // CR
                        k1++;
                        TxLength++;
                        
                        TxBuffer[k++]='E';
                        k1++;
                        TxLength++;
                        /////////////////////////////////
                        k--;
                        k1--;
                        continue;
                }
                TxBuffer[k]=pMess[k-k1];
        }
/////
        for (k1=0; k1 < len_esc; k1++,k++)
        {
            TxBuffer[k]=TxBuffer_tmp[k1];
        }
/////
        TxBuffer[k]=0x0d;
        TxLength = ++k;
         nResult = WriteBuffer(m_pSerialPort,(char*) TxBuffer, TxLength);
        while ((nResult != ASSUCCESS) && (countErr < 3))
        {
                nResult = WriteBuffer(m_pSerialPort,(char*) TxBuffer, TxLength);
                countErr++;
        }
        return nResult;
}
///////////////////////////////////////////////////////////////////
int CWThrd232::SendAskMess_Y_N_ToScaner(char* pAddr, char* pMess, int* bLocalVar)
{
                bAskMess_DYN=TRUE;              
        bVar=bLocalVar;
        int             nResult = -1;
        int             countErr = 0;
        BYTE    TxBuffer_tmp[NUM_BYTE_TX];
        BYTE    TxBuffer[NUM_BYTE_TX];
        memset(TxBuffer,0,sizeof(TxBuffer));
 
        BYTE    TxLength = strlen(pMess);
        BYTE    k=0;
        BYTE    len_esc=0;
//=====================
        TxBuffer_tmp[k++]=0x1b; // reverse mode
        TxBuffer_tmp[k++]='[';
        TxBuffer_tmp[k++]='7';
        TxBuffer_tmp[k++]='m';
 
        TxBuffer_tmp[k++]=0x1b; // move to 4,1, say Del
        TxBuffer_tmp[k++]='[';
        TxBuffer_tmp[k++]='4';
        TxBuffer_tmp[k++]=';';
        TxBuffer_tmp[k++]='1';
        TxBuffer_tmp[k++]='H';
        TxBuffer_tmp[k++]=' ';
        TxBuffer_tmp[k++]='d';
        TxBuffer_tmp[k++]='e';
        TxBuffer_tmp[k++]='l';
        TxBuffer_tmp[k++]=' ';
 
        TxBuffer_tmp[k++]=0x1b; // move to 4,7, say Yes
        TxBuffer_tmp[k++]='[';
        TxBuffer_tmp[k++]='4';
        TxBuffer_tmp[k++]=';';
        TxBuffer_tmp[k++]='7';
        TxBuffer_tmp[k++]='H';
        TxBuffer_tmp[k++]=' ';
        TxBuffer_tmp[k++]='y';
        TxBuffer_tmp[k++]='e';
        TxBuffer_tmp[k++]='s';
        TxBuffer_tmp[k++]=' ';
 
        TxBuffer_tmp[k++]=0x1b; // move to 4,13, say No
        TxBuffer_tmp[k++]='[';
        TxBuffer_tmp[k++]='4';
        TxBuffer_tmp[k++]=';';
        TxBuffer_tmp[k++]='1';
        TxBuffer_tmp[k++]='3';
        TxBuffer_tmp[k++]='H';
        TxBuffer_tmp[k++]=' ';
        TxBuffer_tmp[k++]='n';
        TxBuffer_tmp[k++]='o';
        TxBuffer_tmp[k++]=' ';
//---
        TxBuffer_tmp[k++]=0x1b; // normal mode
        TxBuffer_tmp[k++]='[';
        TxBuffer_tmp[k++]='0';
        TxBuffer_tmp[k++]='m';
        len_esc=k;
//=====================
        for (k=0; k < (ADDR_LEN); k++)
        {
                TxBuffer[k]=pAddr[k];
        }
        TxBuffer[k++]='-';      // addres delimiter
        TxBuffer[k++]=0x1b;     // cls display
        TxBuffer[k++]='[';
        TxBuffer[k++]='2';
        TxBuffer[k++]='J';
 
        BYTE k1=k;
        TxLength=TxLength+k1;
         for (k; k < TxLength; k++)
        {
                if (k>=(NUM_BYTE_TX-len_esc-2))
                        break;
                if(pMess[k-k1]=='^')
                {
                        TxBuffer[k++]=0x1b;     // CR
                        k1++;
                        TxLength++;
                        
                        TxBuffer[k++]='E';
                        k1++;
                        TxLength++;
                        /////////////////////////////////
                        k--;
                        k1--;
                        continue;
                }
                TxBuffer[k]=pMess[k-k1];
        }
        for (k1=0; k1 < len_esc; k1++,k++)
        {
                TxBuffer[k]=TxBuffer_tmp[k1];
        }
        TxBuffer[k]=0x0d;
        TxLength = ++k;
        nResult = WriteBuffer(m_pSerialPort,(char*) TxBuffer, TxLength);
        while ((nResult != ASSUCCESS) && (countErr < 3))
        {
                nResult = WriteBuffer(m_pSerialPort,(char*) TxBuffer, TxLength);
                countErr++;
        }
        return nResult;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
afx_msg LRESULT CWThrd232::OnButtonFromSkaner(WPARAM wparam, LPARAM lparam)
{
        BOOL mode_skan;
         BYTE*   pBuff = (BYTE*)wparam;
         BYTE eq = 0x3d;//ввод!!!
        
        char    addr[ADDR_LEN+1];
        memset(&addr,0,sizeof(addr));
     
        SKANER_MSG_BUTTON  msg_button;
        memset(&msg_button,0,sizeof(SKANER_MSG_BUTTON));
        memcpy(&msg_button, pBuff, sizeof(SKANER_MSG_BUTTON));
        memcpy(addr, msg_button.addr, ADDR_LEN);
        mode_skan = GetSkanMode(addr);// режим сканера
 
        char cMessToScan[NUM_BYTE_TX]="";
        memset(&cMessToScan,0,sizeof(cMessToScan));
 
        SkanerMess.Format(" Сканер: %s. Нажата клавиша: %c", addr, msg_button.button);
        tab2->SendMessage(ID_MESSAGE_LIST,SKANER_PC, SKANER_PC);
 
        if (bAskMess_DYN==FALSE)
        {
                if(bAskMess_D==TRUE)
                {
                }
                else
                {
                        if (msg_button.button==eq)
                       {
                            if (mode_skan)
                            {
                                SetMainMode(addr);
                                SkanerMess.Format(" Сканер: %s. Переход в обычный режим", addr);
                                tab2->SendMessage(ID_MESSAGE_LIST,SKANER_PC, SKANER_PC);
                                CWnd* pWnd = (CWnd*) myForm->GetDlgItem(IDC_STATIC_REZ);
                                pWnd->SetWindowText("ОБЫЧНЫЙ");
                                strncat(cMessToScan, "---Perehod v--- ^ ---OBYCHNYI--- ^ ----rezim---- ",NUM_BYTE_TX);            
                                SendMessToScaner(addr,cMessToScan);
                                SendGoodBeepLight(addr);
                        }
                            else
                            {    SetVozvratMode(addr);
                                  SkanerMess.Format(" Сканер: %s. Переход в режим приема возврата ", addr);
                                tab2->SendMessage(ID_MESSAGE_LIST,SKANER_PC, SKANER_PC);
                                CWnd* pWnd = (CWnd*) myForm->GetDlgItem(IDC_STATIC_REZ);
                                pWnd->SetWindowText("ВОЗВРАТ");
                                strncat(cMessToScan, "---Perehod v---^   --rezim--   ^ ---VOZVRAT---",NUM_BYTE_TX);
                                SendMessToScaner(addr,cMessToScan);
                                SendGoodBeepLight(addr);
                            }
                        }
                        Sleep(WAIT_BEFORE_SUSPEND);
                        ResThrReadBuf();
                        return 0;
                }
        }
        switch(msg_button.button)
        {
        case 0x3c:  // '<' // DEL
                m_pTehManager->PereupDovodka_YES_NO_DEL(addr,DEL_TEH);
                bAskMess_DYN=FALSE; 
                bAskMess_D=FALSE;
                /////
                break;
        case 0x3d:  // '=' // YES
                if(bAskMess_DYN==TRUE)
                {
                        *bVar=TRUE;
                        bAskMess_DYN=FALSE;
                        bAskMess_D=FALSE;
                        m_pTehManager->PereupDovodka_YES_NO_DEL(addr,TRUE);
                        SkanerMess.Format(" Сканер: %s. Переупаковка? Да.", addr);
                        tab2->SendMessage(ID_MESSAGE_LIST,SKANER_PC, SKANER_PC);
                }
                break;
        case 0x3e:  // '>' // NO
                if(bAskMess_DYN==TRUE)
                {
                        *bVar=FALSE;
                        bAskMess_DYN=FALSE;
                        bAskMess_D=FALSE;
                        m_pTehManager->PereupDovodka_YES_NO_DEL(addr,FALSE);
                }
                break;
        }
        Sleep(700);
        ResThrReadBuf();
        return 0;
}
///////////////////////////////////////////////////////////////////////////////////////////
int CWThrd232::SendGoodBeepLight(char* pAddr)
{
        int nResult = -1;
        int countErr = 0;
        BYTE TxBuffer[NUM_BYTE_TX];
        memset(TxBuffer,0,sizeof(TxBuffer));
 
        BYTE TxLength = 0;
        for (BYTE k=0; k < 3; k++)
        {
                TxBuffer[k]=pAddr[k];
        }
        TxBuffer[k++]='-';
 
        TxBuffer[k++]=0x1b;
        TxBuffer[k++]='[';
        TxBuffer[k++]='6';  // GREEN ON
        TxBuffer[k++]='q';
 
        TxBuffer[k++]=0x1b;
        TxBuffer[k++]='[';
        TxBuffer[k++]='5';  // WAIT 100 ms
        TxBuffer[k++]='q';
 
        TxBuffer[k++]=0x1b;
        TxBuffer[k++]='[';
        TxBuffer[k++]='3';  // GOOD BEEP
        TxBuffer[k++]='q';
 
        TxBuffer[k++]=0x1b;
        TxBuffer[k++]='[';
        TxBuffer[k++]='5';  // WAIT 100 ms
        TxBuffer[k++]='q';
 
        TxBuffer[k++]=0x1b;
        TxBuffer[k++]='[';
        TxBuffer[k++]='3';  // GOOD BEEP
        TxBuffer[k++]='q';
 
        TxBuffer[k++]=0x1b;
        TxBuffer[k++]='[';
        TxBuffer[k++]='7';  // GREEN OFF
        TxBuffer[k++]='q';
 
        TxBuffer[k++]=0x0d;
        TxLength=k;
        nResult = WriteBuffer(m_pSerialPort,(char*) TxBuffer, TxLength);
        while ((nResult != ASSUCCESS) && (countErr < 3))
        {
                nResult = WriteBuffer(m_pSerialPort,(char*) TxBuffer, TxLength);
                countErr++;
        }
        return nResult;
}
///////////////////////////////////////////////////////////////////////////////////////////