Lemz_SwCtrlStmProj/App/usbtmc/usbtmc.c

#define _USBTMC_C_

#include <string.h>
#include "lpc176x.h"
#include "stdio.h"
#include "usb_hardware.h"
#include "queue.h"
#include "mem.h"

#ifndef USBTMC // #endif â êîíöå ôàéëà
#pragma message(" _____________________________________________________________ " )
#pragma message(" ############################################################# " )
#pragma message(" # USBTMC Project, Alpha Version                             # " )
#pragma message(" # v 2.1 - Âåðñèÿ ïðîåêòà                                    # " )
#pragma message(" # Ïðîåêò ïîääåðæèâàåò ñòàðûé ïðîòîêîë USB-CONTROL           # " )
#pragma message(" # ×òîáû âêëþ÷òü TMC íóæíî îáúÿâèòü ìàêðîñ 'USBTMC' â ôàéëå  # " )
#pragma message(" # project.h                                                 # " )
#pragma message(" #                                        21-ñåí-2011  15:00 # " )
#pragma message(" ############################################################# " )
#pragma message(" ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ " )
#else

#include "gpib_parser.h"

#include "usb_enumeration.h"

//#include "spi.h"
#include "hal.h"
#include "usbtmc.h"
#include "utils.h"
#include "i2_c.h"
#include "options.h"
#include "usb_options.h"
#include "endpoints.h"

#include "usb_application.h"
#include "usb_proto.h"

//
// Âñå ñâÿçàííîå ñ USBTMC ïðîòîêîëîì íàõîäèòñÿ â ýòîì ôàéëå, à
// òàêæå â ôàéëå GPIB_parser.c
//



#include "../usbtmc/gpib.h"

BYTE     SerialNumber[9];       
unsigned short int DeviceID = 0;                     

BYTE     gEP2BufOutExpand[USB_MAX_BULKOUT_BUFFERSIZE]; // ïåðåä gEP2BufInExpand 
BYTE      gEP2BufInExpand[USB_MAX_BULKIN_BUFFERSIZE];  // ñëåäîì çà gEP2BufOutExpand  ( íà ñëó÷àé ïåðåïîëíåíèÿ )

BYTE     gGPIBErrorQueue[USB_MAX_ERROR_QUEUE];

BYTE     gGPIBFunctionContext[USB_MAX_FUNCCONTEXT];

extern const BYTE abDescriptors_USBTMC[];
extern const BYTE abDescriptors_Proprietary[];
extern BYTE  SerialNumberDescriptor[];


         const char *DeviceIDs[] =
          {
          "SC6000T",
          "SC8000T"
          };

BOOL bUSBTMCEnable =FALSE;

BOOL usbtmc_RaiseError_CatDescription( USB_DEVICE_INFO * udi, const char * description, unsigned int desc_len );
BOOL usbtmc_RaiseError( USB_DEVICE_INFO * udi, GPIB_ErrorClass_t errClass,  int dwCode, const char * description, unsigned int desc_len );
// =========================================================================================================================================
void ReadDeviceInfo( void )
{
   {                
      s_memset( SerialNumber, '0',        8 );
       DeviceID  = 0;
   }
  
   SerialNumber[8] = '\0';
}

// =========================================================================================================================================
void usbtmc_HOOK_control_out( USB_DEVICE_INFO * udi );
// =========================================================================================================================================

// volatile size_t debug_call_ep2irq_1 = 0;
// volatile size_t debug_call_ep2irq_2 = 0;
// volatile size_t debug_call_ep2irq_3 = 0;
// volatile size_t debug_call_ep2irq_4 = 0;
// volatile size_t debug_call_ep2irq_5 = 0;

// Îáðàáîò÷èê ïðåðûâàíèé EP2 (IN/OUT)
// âûçûâàåòñÿ ïî àäðåñó èç ïåðåìåííîé, èíèöèàëèçàöèÿ â UsbtmcInit()
void USB_Interrupt( unsigned int EndpointStatus )
{
  // debug_call_ep2irq_5++;
  
  if( USB_EVENT_ENDPOINT( EndpointStatus,USB_EP_PHY_ADDRESS_BULK_OUT ) )
  {  //debug_call_ep2irq_1++;
     usb_EP2_rx_int_func(&gUSBInfo); //-- Bulk-OUT
  } 

  if( USB_EVENT_ENDPOINT( EndpointStatus,USB_EP_PHY_ADDRESS_BULK_IN ) )
  {  //debug_call_ep2irq_2++;
     usb_EP2_tx_int_func(&gUSBInfo); //-- Bulk-IN
  } 

  if( USB_EVENT_ENDPOINT( EndpointStatus,USB_EP_PHY_ADDRESS_INT_IN ) )
  {  // debug_call_ep2irq_3++;
     usb_EP1_tx_int_func(&gUSBInfo); //-- Int-IN
  }  

  if(USB_EVENT_ENDPOINT(EndpointStatus,USB_EP_PADDRESS_OUT ))   // Control OUT
  {  //debug_call_ep2irq_4++;
     usbtmc_HOOK_control_out(&gUSBInfo); //-- IN 
  }  
}
// =========================================================================================================================================
IRQ_FUNCTION_ADDRESS UsbtmcInit(void) 
{

   USB_DEVICE_INFO * udi = &gUSBInfo;  

   bUSBTMCEnable = FALSE;
   
   #ifdef USBTMC_SUPPORT_OLD
   if(USB_INTERFACE_CONT==GetInterface(udi)) 
   {
       //ReadDeviceInfo();  --- replaced with VariableInit_Post()
     
       // DevDepInit(); --- replaced with VariableInit_Post()
       
       return 0;   // åñëè áûëî ïðîèçâåäåíî ïåðåêëþ÷åíèå èíòåðôåéñà -> âûõîäèì
   }
   #endif
                  
   bUSBTMCEnable = TRUE;

   udi->Descriptors        = (BYTE*)&abDescriptors_USBTMC[0];             //-- Descriptors

   udi->EPBulkStatus.OutPipe.pDefaultBuffer  = gEP2BufOutExpand;//-- EP2 buffer
   udi->EPBulkStatus.InPipe.pDefaultBuffer   = gEP2BufInExpand;//-- EP2 buffer

   udi->EPBulkStatus.InPipe.pfTransferEndHandler       = usbtmc_EndOfTransfer;
   udi->EPBulkStatus.OutPipe.pfTransferEndHandler       = NULL;

   memset( (BYTE*)&udi->GPIBFunctionContext, 0, sizeof(udi->GPIBFunctionContext) );

   usb_reset_endpoint_status( &udi->EPBulkStatus );

   //-- configure logical-EP2 [In-EP5, Out-EP4, Bulk]

   // ÄÎÑÒÀÒÎ×ÍÎ ÏÎÄÌÅÍÈÒÜ udi->Descriptors
   // -- usb_config_endpoints( udi->Descriptors ) --
   // âûçûâàòü usb_config_endpoints íå íàäî, âûçîâ â InitUSB()

   udi->usbtmcGpib.gpib_root = GPIB_InitializeAllCommands(); // init SCPI command tree 

   usbtmc_state_machine_init( &udi->usbtmcGpib.StateMachine );

   /* ---------- îáÿçàòåëüíàÿ çàùèòà áàíêà ïàìÿòè 0 (çàâîäñêèå êàëèáðîâêè) ------------- */
   /* WARNING: êîìàíäà çàùèòà ïàìÿòè ïåðåíåñåíà, òåïåðü îíà âûïîëíÿåòñÿ ïðè èíèöèàëèçàöèè
      êëàññà ACMBase() âíå çàâèñèìîñòè îò èñïîëüçóåìîãî ïðîòîêîëà (USBTMC/PLANAR)        */
   // SPI äîëæåí áûòü èíèöèàëèçèðîâàí 
   // USB_SETUP_PACKET dummy_setup_packet; 
   // s_memset( &dummy_setup_packet, 0, sizeof(USB_SETUP_PACKET));
   // usbapp_SET_PROTECT_FLASH( &dummy_setup_packet ); // çàùèòà áàíêà ïàìÿòè 0
   /* ---------------------------------------------------------------------------------- */ 

   UsbtmcDevDepInit( udi );
   return (IRQ_FUNCTION_ADDRESS)USB_Interrupt;
}

// ====================================================================================================================
// ïåðåõâàò ñîáûòèé EP0
//
void usbtmc_HOOK_control_out( USB_DEVICE_INFO * udi )   // ïåðåõâàò ñîîáùåíèé êîíòðîëüíîãî ïðîòîêîëà (OUT)
{                                                       // ïîñëå åãî îáðàáîòêè â usb_enumeration
   USB_SETUP_PACKET    * usb_setup_packet = &udi->EP0SetupPacket;
   switch( usb_setup_packet->bmRequestType & USB_CMD_MASK_COMMON )
   {
      case USB_CMD_STD_DEV_OUT:       //-- STANDARD OUT device requests
      {
           switch(usb_setup_packet->bRequest)
           {
              case CLEAR_FEATURE:  
              { 
                   if( usb_setup_packet->wValue == 0 ) // for EP
                   {  
                          switch(usb_setup_packet->wIndex)
                          {
                             case USB_EP_LOG_ADDRESS_BULK_IN:
                             {  
                                  usbtmc_reset_bulkrespond_status  (&udi->BulkRespondStatus);
                                  usb_reset_pipe_status            (&udi->EPBulkStatus.InPipe);
                                  s_memset( (BYTE*)usb_setup_packet, 0x00, sizeof(USB_SETUP_PACKET) ); // ïàêåò óæå îòðàáîòàí, ñòðèàåì ïàêåò ÷òîáû íå ïîïàñòü ñþäà ñíîâà ïðè ëþáîì äðóãîì ïðåðûâàíèè 
                             }
                             break;
                             case USB_EP_LOG_ADDRESS_BULK_OUT: 
                             {  
                                  usbtmc_reset_bulkmessage_status  (&udi->BulkMessageStatus);
                                  usb_reset_pipe_status            (&udi->EPBulkStatus.OutPipe);
                                  s_memset( (BYTE*)usb_setup_packet, 0x00, sizeof(USB_SETUP_PACKET) ); // ïàêåò óæå îòðàáîòàí, ñòðèàåì ïàêåò ÷òîáû íå ïîïàñòü ñþäà ñíîâà ïðè ëþáîì äðóãîì ïðåðûâàíèè
                             }     
                             break;
                          }
                   }
              }
              break;
         } // switch(usb_setup_packet->bRequest)
     } // case USB_CMD_STD_DEV_OUT
     break;
  }   
}
// =========================================================================================================================================
void UsbtmcDevDepInit( USB_DEVICE_INFO * udi )
{
  /* ReadDeviceInfo(); --- replaced, VariableInit_Post */
  GPIBInit( udi );
  GPIB_DevDepInit( udi );
}
// =========================================================================================================================================
void usbtmc_state_machine_init( USB_USBTMC_GPIBEMULATION_STATEMACHINE * pStateMachine  )
{
   s_memset( (BYTE*)pStateMachine, 0x00, sizeof(USB_USBTMC_GPIBEMULATION_STATEMACHINE) );
   
   pStateMachine->ESR |= (1<<ESR_PWN);
   
   queue_create( gGPIBErrorQueue, USB_MAX_ERROR_QUEUE, &pStateMachine->qErrorQueue);
}



// =========================================================================================================================================
// @    @   @@@@@  @@@@@   @@@@@@  @    @   @@@@            @@@@   @@@@@   @@@@@    @@@@   @@@@@   
// @    @  @       @    @    @     @@  @@  @    @          @    @  @    @  @    @  @    @  @    @  
// @    @  @@@@@@  @@@@@     @     @ @@ @  @               @@@@@@  @@@@@   @@@@@   @    @  @@@@@   
// @    @       @  @   @     @     @    @  @               @       @ @     @ @     @    @  @ @     
// @    @  @   @   @    @    @     @    @  @    @          @    @  @  @    @  @    @    @  @  @    
//  @@@@   @@@@    @@@@@    @@@    @    @   @@@@            @@@@   @   @@  @   @@   @@@@   @   @@  
void usbtmc_GenRecieveError( USB_DEVICE_INFO * udi )
{
  //usbtmc_RaiseError( udi, GPIB_ERROR_ID_EXE, ERROR_USBTMC_BUFFER_OVERFLOW_OUT, "", 0);
  /* 27/08/18 usbtmc_RaiseError( udi, GPIB_ERROR_ID_EXE, ERROR_USBTMC_INTERNAL, "", 0); */
  if( ! usbtmc_RaiseError( udi, errClass_Device, ERROR_USBTMC_INTERNAL, "", 0) )
  {
      usbtmc_ErrorQueue_RestoreCheckpoint( udi );
  }
}

BOOL usbtmc_RaiseError_CatDescription( USB_DEVICE_INFO * udi,  const char * description, unsigned int desc_len )
{  
   // äîïîëíÿåò usbtmc_RaiseError(). íóæíà äëÿ äîáàâëåíèÿ description ïðåäûäóùåé äîáàâëåííîé îøèáêè â î÷åðåäü
   // Ïîçâîëÿåò íå ñîçäàâàòü íîâûé ýëåìåíò â î÷åðåäè (ñ êîäîì îøèáêè) à äîáàâèòü òåêñò ê ïðåäûäóùåé
   QUEUE * pQueue = &udi->usbtmcGpib.StateMachine.qErrorQueue;
   
   return queue_cat( pQueue, description, desc_len );
}
// =========================================================================================================================================
BOOL usbtmc_ErrorQueue_CreateCheckpoint( USB_DEVICE_INFO * udi )
{
   QUEUE * pQueueSrc = &udi->usbtmcGpib.StateMachine.qErrorQueue;
   QUEUE * pQueueDst = &udi->usbtmcGpib.StateMachine.qErrorQueue_backup;
   
   *pQueueDst = *pQueueSrc;
   
   return TRUE;
}

BOOL usbtmc_ErrorQueue_RestoreCheckpoint( USB_DEVICE_INFO * udi )
{
   QUEUE * pQueueDst = &udi->usbtmcGpib.StateMachine.qErrorQueue;
   QUEUE * pQueueSrc = &udi->usbtmcGpib.StateMachine.qErrorQueue_backup;
   
   *pQueueDst = *pQueueSrc;
   
   return TRUE;
} 
// =========================================================================================================================================
BOOL usbtmc_RaiseError( USB_DEVICE_INFO * udi, GPIB_ErrorClass_t errClass, 
                        int dwCode, 
                        const char * pDesc, 
                        size_t nDescLen )
{
  QUEUE * pQueue = &udi->usbtmcGpib.StateMachine.qErrorQueue;  
  BOOL rc = FALSE;  

  uint8_t aMemBuf[64];
    
  // ---------------------------------------------------------
  usbtmc_ErrorQueue_CreateCheckpoint( udi );  
  // ---------------------------------------------------------
  if( pDesc == NULL ) nDescLen = 0;
  if( nDescLen > sizeof(aMemBuf) - 2*sizeof(uint32_t) ) 
  {  
      nDescLen = sizeof(aMemBuf) - 2*sizeof(uint32_t);
  }  
  // ---------------------------------------------------------
  {
  size_t nCount = 0;  
  if( !queue_getcount( pQueue, &nCount ) ) return FALSE;  
  if( nCount > 16 ) return FALSE;
  }
  // ---------------------------------------------------------
  uint32_t * pCode  = (unsigned int*)((ptrdiff_t)aMemBuf + 0);                 // error code
  uint32_t * pClass = (unsigned int*)((ptrdiff_t)aMemBuf + sizeof(uint32_t));  // error class
  // ---------------------------------------------------------
  *pCode = dwCode;
  *pClass = errClass; // 27/08/18, *pCode = ErrorID
  // ---------------------------------------------------------
  if( NULL != pDesc && 0 != nDescLen )
  {  
      char     * pText  = (char*)((ptrdiff_t)aMemBuf + 2* sizeof(uint32_t));   // error description
      memcpy( pText, pDesc, nDescLen );
  }
  // ---------------------------------------------------------
  switch( errClass )
  {
     case errClass_Command:    GPIB_SET_CME(); break;
     case errClass_Execution:  GPIB_SET_EXE(); break;
     case errClass_Query:      GPIB_SET_QRE(); break;
     case errClass_Device:     GPIB_SET_DDE(); break;
     default:                  GPIB_SET_DDE(); break; 
  }
  // ---------------------------------------------------------  
  if( TRUE == queue_add( pQueue, aMemBuf, 2* sizeof(uint32_t) + nDescLen ) ) 
  {
      GPIB_SET_EAV(); 
      rc = TRUE;
  }

  return rc; 
}
// =========================================================================================================================================
BOOL usbtmc_ClearLastError( USB_DEVICE_INFO * udi )
{  
  char dummy[64];
  usbtmc_GetErrorText( udi, dummy, 64 );
  return (GPIB_GET_EAV());
}
// =========================================================================================================================================
int usbtmc_GetRegisteredErrorDescription( int dwErrCode, char * pOutput, unsigned int cbMaxLength )
{
  switch(dwErrCode)
  {  case ERROR_USBTMC_PARAMETER:
     return snprintf(pOutput, cbMaxLength, "%s", "Parameter error ");
     case ERROR_USBTMC_EXECUTION:
     return snprintf(pOutput, cbMaxLength, "%s", "Execution error ");
     case ERROR_USBTMC_DATANOTFOUND:
     return snprintf(pOutput, cbMaxLength, "%s", "No data found ");
     case ERROR_USBTMC_NOTHERMCOMPDATA:  
     return snprintf(pOutput, cbMaxLength, "%s", "No data found ");
     case ERROR_USBTMC_ARRAY_CORRUPTED:
     return snprintf(pOutput, cbMaxLength, "%s", "Data array corrupted ");  
     //case ERROR_USBTMC_HEADER_CORRUPTED:
     //return snprintf(pOutput, cbMaxLength, "%s", "Header corrupted ");    
     case ERROR_USBTMC_INTERNAL:
     return snprintf(pOutput, cbMaxLength, "%s", "Internal execution error");
     case ERROR_USBTMC_TOOMANY_REQUESTS:
     return snprintf(pOutput, cbMaxLength, "%s", "Too many requests in line (");
    
     case ERROR_USBTMC_INVALID_HEADER:
     //case ERROR_USBTMC_COMMANDONLY:
     //case ERROR_USBTMC_REQUESTONLY:
     //
     return snprintf(pOutput, cbMaxLength, "%s", "Invalid header ");
     //case ERROR_USBTMC_BUFFER_OVERFLOW_OUT:
     //return snprintf(pOutput, cbMaxLength, "%s", "IN-Buffer overflow");  // IN-Buffer: Host->Dev
     //case ERROR_USBTMC_BUFFER_OVERFLOW_IN:
     //return snprintf(pOutput, cbMaxLength, "%s", "OUT-Buffer overflow"); // OUT-Buffer: Dev->Host
  }
  return 0;
}
// =========================================================================================================================================
                            
int usbtmc_GetErrorText( USB_DEVICE_INFO * udi, char * pText, unsigned int dwMaxSize)
{
  QUEUE * pQueue = &udi->usbtmcGpib.StateMachine.qErrorQueue;
  int rc = 0;
  size_t nCount = 0;
  if( queue_getcount( pQueue, &nCount ) )
  {  
      if( nCount == 0 )
      {
          GPIB_CLR_EAV();
          strcpy( pText, "0, \"No error\"" ); 
          rc = strlen( pText );
      }
      else
      {
          if( queue_get_topitemsize(pQueue, (unsigned int*)&rc) )
          {
               
               
               if( queue_get( pQueue, pText, dwMaxSize, (unsigned int*)&rc) )
               {     
                  
                  // ---------------------------------------------------------------
                  // 80 00 00 00  B  L  A     B  L  A     B  L  A
                  // _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _  _ _ _ _ _ ... _ _ _ 
                  // \    /  \                                           /
                  //  code        error description
                  //
                  //
                  // 1 2 8 ,   " BLA BLA BLA "
                  // _ _ _ ...  _ _ _ _ _ _ _ _ _ _ _ ... _ _ _ 
                  // \      / \                           /
                  //   code            error description
                  //
                  // ---------------------------------------------------------------

                  // the description is the rest bytes after two integer codes (8bytes)
                  size_t nDescLen = ( rc - sizeof(int) * 2 ); 
                  
                  if( rc > 0 )
                  {
                      if( pText[ rc - 1 ] == '\0' )
                      {
                          nDescLen--;        // cut off the null-term
                      }
                  }
                                   
                  // retrieve the error number 
                  int dwCode = *((int*)pText);  
                  //unsigned int ID = *((unsigned int*)pText + 1);
                    
                  char tmpBuf[64]; 
                  size_t nTmpBufSize = sizeof(tmpBuf);

                  nCount = snprintf( tmpBuf, nTmpBufSize,"%d, \"", dwCode);
                  
                  if( nCount >= nTmpBufSize )
                      nCount = 0;
                  else
                      nTmpBufSize -= nCount;

                  // retrieve the common description length
                  // note: cbMaxLength is 0
                  size_t nCommonDescLength = usbtmc_GetRegisteredErrorDescription( dwCode, &tmpBuf[nCount], 0 ); 

                  if( dwMaxSize < nCount + nCommonDescLength + nDescLen )
                  {
                      // not enougth free space in the buffer
                      rc = 0;
                  }
                  else
                  {  
                      // The description begins with the (sizeof(int) * 2) character 
                      // and has a nDescLen character length
                      // We have @nCount bytes in @tmpBuf to print
                      // It is required to move the description in the @pText
                      // to the (nCount + nCommonDescLength), due to it is
                      // required to print firstly the data from @pText, then
                      // the @nCommonDescLength bytes of data returned by @usbtmc_GetRegisteredErrorDescription(),
                      // and then the data that actually is in @pText (@nDescLen length)
                      // [nCount] [nCommonDescLength] [nDescLen]
                      // So, we know, that is required to allocate the space for:
                      //  - @nCount bytes of @tmpBuf
                      //  - @nCommonDescLength bytes of common description (usbtmc_GetRegisteredErrorDescription)
                      // Let's move the description:
                      memmove( &pText[nCount + nCommonDescLength], &pText[sizeof(int) * 2], nDescLen );
                      
                      // copy @tmpBuf to the begin of @pText
                      memcpy( &pText[0], tmpBuf, nCount );
                      
                      // and actually print the common description to the @pText after the @tmpBuf contents
                      char x = pText[nCount+nCommonDescLength]; // this character will be filled with null-term by usbtmc_GetRegisteredErrorDescription()
                      usbtmc_GetRegisteredErrorDescription( dwCode, &pText[nCount], (nCommonDescLength + 1) ); 
                      pText[nCount+nCommonDescLength] = x;
                      
                      rc = nCount + nCommonDescLength + nDescLen;
                      
                      if( rc < dwMaxSize )
                      {
                          pText[rc] = '\"'; 
                          rc++;
                      }
                  }

               }
               else
               {
                   rc = 0;
               }
         }
         
         if( queue_getcount(pQueue, &nCount)==TRUE && nCount==0) GPIB_CLR_EAV();
      }
  }
  
  return rc;
}
// =========================================================================================================================================
unsigned int usbtmc_EndOfTransfer( void * vudi )
{
  USB_DEVICE_INFO        *             udi  = (USB_DEVICE_INFO       *)   vudi;
  USB_EP_STATUS          *   pbulk_status   = (USB_EP_STATUS         *)  &udi->EPBulkStatus;
  USB_PIPE_ENTRY_IN      *   pInPipe        = (USB_PIPE_ENTRY_IN     *)  &pbulk_status->InPipe;
  USB_BULKRESPOND_STATUS *   pBulkRespond   = (USB_BULKRESPOND_STATUS*)  &udi->BulkRespondStatus;
  
  // âûçûâàåòñÿ êîãäà â Pipe êîí÷àþòñÿ äàííûå:
  // InPipe èìååò äâà ïîëÿ: dwAllLength è dwLength
  // Ïåðâîå çàäàåò êîè÷åñòâî äàííûõ, êîòîðûå íóæíî ïåðåäàòü
  // Âòîðîå - òîëüêî òî ÷òî âìåùàåòñÿ â âûõîäíîé áóôåð (èëè ñêîëüêî çàïðîñèë Host, ñìîòðÿ, ÷òî ìåíüøå)  

  // -----------------------------------
  if( pInPipe->dwLength != 0 ) return 0;
  // -----------------------------------

  if ( pBulkRespond->dwDeviceOut > 0 && pInPipe->dwLength == 0 )
  {
      
      unsigned int dwBytesRemaining = pBulkRespond->dwDeviceOut;


      s_memcpy( pInPipe->pDefaultBuffer + sizeof(BULKIN_HEADER),        // ñäâèãàåì áóôåð ê íà÷àëó. Îñòàâëÿåì ìåñòî ïîä çàãîëîâîê
                pInPipe->pData,                                         // òåêóùèé óêàçàòåëü íà äàííûå
                dwBytesRemaining);     // îñòàâøååñÿ êîëè÷åñòâî íåïåðåäàííûõ äàííûõ

      // ---------------------------
      usbtmc_init_intransfer( udi );                                    // ñáðîñ
      // ---------------------------

      pBulkRespond->dwDeviceOut     = dwBytesRemaining;
      
      pBulkRespond->bIsLastTransfer = FALSE;
      pBulkRespond->bEndOfMessage = FALSE;
      if( (udi->GPIBFunctionContext.LastFunction != NULL && udi->GPIBFunctionContext.bEnable == TRUE) )
      {
            TCmdParser_f LastFunction = (TCmdParser_f)udi->GPIBFunctionContext.LastFunction;
            // ------------------------------------------
            udi->GPIBFunctionContext.bEnable = TRUE;
            udi->GPIBFunctionContext.LastFunction = NULL;
            // ------------------------------------------
            udi->usbtmcGpib.pData = pInPipe->pDefaultBuffer + sizeof(BULKIN_HEADER) + dwBytesRemaining;
            udi->BulkRespondStatus.RespondBufferSize-= dwBytesRemaining;
            udi->BulkRespondStatus.dwDeviceOut += LastFunction( udi, NULL, FALSE ); 
      }

      // íå óõîäèì íà REQUEST_DEV_DEP_MSG_IN. òàê êàê ñþäà ïîïàäåì ðàíüøå ÷åì ïðèäåò ðåàëüíûé REQ_MSG_IN => bTag åùå ñòàðûé
      // îñòàâëÿåì pInPipe.dwLength = 0 ÷òîáû êîðìèòü NAKàìè äî ïðèõîäà ñëåäóþùåãî REQ_MSG_IN
  }
  else
  {  
      // ---------------------------------------------------------------------------------
      // ïîêà ôóíêöèÿ íå óñòàíîâèò ôëàã bIsLastTransfer, EndOfTransfer() áóäåò âûçûâàòü åå
      if( pBulkRespond->bIsLastTransfer == FALSE )
      {  
          if( ! (udi->GPIBFunctionContext.LastFunction != NULL && udi->GPIBFunctionContext.bEnable == TRUE) )
          { 
              pInPipe->dwAllLength = 0;
              pBulkRespond->bIsLastTransfer = TRUE; 
              pBulkRespond->bEndOfMessage = TRUE;
          }
          else 
          {   
              TCmdParser_f LastFunction = (TCmdParser_f)udi->GPIBFunctionContext.LastFunction;
              // ---------------------------------------------------------------------------------

              // ------------------------------------------
              udi->GPIBFunctionContext.bEnable = TRUE;
              udi->GPIBFunctionContext.LastFunction = NULL;
              // ------------------------------------------
     
              // ---------------------------
              usbtmc_init_intransfer( udi );
              // ---------------------------

              udi->BulkRespondStatus.dwDeviceOut += LastFunction( udi, NULL, FALSE ); 

             // usbtmc_REQUEST_DEV_DEP_MSG_IN( udi ); // òàì èäåò ìîäèôèêàöèÿ çàãîëîâêà äàííûõ
          } 
      } 
 } 
 return pBulkRespond->bIsLastTransfer;
}
// =========================================================================================================================================

void usbtmc_create_function_context( USB_DEVICE_INFO * udi, void * pFunction )
{
   udi->GPIBFunctionContext.LastFunction = pFunction;
   udi->GPIBFunctionContext.bEnable  =TRUE;
   queue_create( gGPIBFunctionContext, USB_MAX_FUNCCONTEXT, &udi->GPIBFunctionContext.Context);    
}
// =========================================================================================================================================

void usbtmc_delete_function_context( USB_DEVICE_INFO * udi )
{
   udi->GPIBFunctionContext.bEnable = FALSE;
   udi->GPIBFunctionContext.LastFunction = NULL;
   queue_clear( &udi->GPIBFunctionContext.Context);    
}
// =========================================================================================================================================
int USBTMC_StateMachine_Modified( USB_USBTMC_GPIBEMULATION_STATEMACHINE * pStateMachine)
{
  // Check event status register and the mask
  if( (pStateMachine->ESE) & (pStateMachine->ESR) )  
  {  
     // set Event Status Bit
     pStateMachine->STB |= (1<<STB_ESB);
  }   
  else
  {  
     // clear Event Status Bit
     pStateMachine->STB &= (~(1<<STB_ESB));
  }   
  
  // Check the Status Byte Register and the mask (SRE)
  if( (pStateMachine->STB & 0xBF) & pStateMachine->SRE )
  {  
     pStateMachine->STB  |= (1<<STB_RQS_MSS);
  }   
  else
  {  
     pStateMachine->STB  &= (~(1<<STB_RQS_MSS)); 
  }  
  
  // pStateMachine->ESR |= (1<<ESR_PWN);
  // pStateMachine->ESR |= (1<<ESR_OPC);  
 
  return TRUE;   // only true!, see usbtmc.h, #defines
}


// ====================================================================================================================
void usbtmc_service( USB_DEVICE_INFO * udi, BOOL Tick )
{
  /* 30/08/18 Ðåôàêòîðèíã.
     Ìåòîä âûçîâà ôóíêöèé èç îñíîâîãî ïîòîêà, êîòîðûé áûë ðåàëèçîâàí çäåñü,
     áûë îñíîâàí íà ïðåäïîëîæåíèè, ÷òî íåëüçÿ îáîðâàòü ïåðåäà÷ó bulk â ïðîöåññå
     åå âûïîëíåíèÿ â îñíîâíîì ïîòîêå... Íî ïîñëå îñìîòðà êîäà, òàêèõ âûçîâîâ
     èç îñíîâíîãî ïîòîêà ÿ íå íàøåë. Âîçìîæíî ýòî legacy-êîä, êîìåíòàðèè áîëåå
     íå àêòóàëüíû. Ò.ê. âñå âûçîâû ðàáîòàþò èñêëþ÷èòåëüíî â ïðåðûâàíèÿõ,
     ÿ çàìåíèë âñå âûçîâû ÷åðåç ôëàãè íà ïðÿìûå âûçîâû ôóíêöèé. 
     À äàííàÿ ôóíêöèÿ áîëåå íåàêòóàëüíà.
  
    if(bUSBTMCEnable==FALSE) return;       // ñì UsbtmcInit()   
   
          // ---------- ÔËÀà INITIATE_CLEAR ïîëó÷åí -----------
          USB_INTERRUPT_DISABLE();
          if(MACRO_FLAGGET_INITIATE_CLEAR())
          {  MACRO_FLAGCLR_INITIATE_CLEAR();  
          
             USB_INTERRUPT_ENABLE();
             
             // íåëüçÿ âûïîëíèòü usbtmc_initiate_clear ñðàçó â ïðåðûâàíèè, ýòî ÷ðåâàòî 
             // òåì, ÷òî çàïðîñ íà usbtmc_initiate_clear ìîæåò ïðèéòè âî âðåìÿ îáàáîòêè
             // ñêàæåì usb_EP2_tx_func__() êîãäà îíà âûïîëíÿåòñÿ â îñíîâíîì ïîòîêå. 
             // Ôóíêöèÿ usbtmc_initiate_clear âûïîëíèò 
             // usbtmc_abort_bulkin_transfer() â êîíòåêñòå ïðåðûâàíèÿ, îñòàíîâèâ usb_EP2_tx_func__
             // â ñàìîì íåïðèëè÷íîì ìåñòå (:-D) usbtmc_initiate_clear îòðàáîòàâ, âåðíåò óïðàâëåíèå ê
             // usb_EP2_tx_func__() è òàê êàê íè â ÷åì íå áûâàëî ïðîäîëæèò ÍÅÈÇÂÅÑÒÍÎ îòêóäà
             // è íåèçâåñòíî ÷òî ïðè ýòîì ñäåëàåò ( ïåðåäà÷à òî óæå çàâåðøåíà ïîèäåå, à îíà
             // òàì ïåðåìåííûå íà÷íåò ìåíÿòü )
             usbtmc_initiate_clear( udi, 0 );
             
          }
          USB_INTERRUPT_ENABLE();
          // -------------------------------------------   
          
          // ---------- ÔËÀà INITIATE_ABORT_BULK_IN ïîëó÷åí ----------
          USB_INTERRUPT_DISABLE();
          if(MACRO_FLAGGET_INITIATE_BULKIN_ABORT())
          {  MACRO_FLAGCLR_INITIATE_BULKIN_ABORT();  
          
             USB_INTERRUPT_ENABLE();
             
             // ïðè÷èíó ñì âûøå äëÿ usbtmc_initiate_clear, àíàëîãè÷íî
             usbtmc_abort_bulkin_transfer ( udi, 0 );
             
          }
          USB_INTERRUPT_ENABLE();
          // -------------------------------------------
          
          
          // -------------------------------------------
          
          // ---------- ÔËÀà INITIATE_ABORT_BULK_OUT ïîëó÷åí ----------
          USB_INTERRUPT_DISABLE();
          if(MACRO_FLAGGET_INITIATE_BULKOUT_ABORT())
          {  MACRO_FLAGCLR_INITIATE_BULKOUT_ABORT();  
          
             USB_INTERRUPT_ENABLE();
             
             // ïðè÷èíó ñì âûøå äëÿ usbtmc_initiate_clear, àíàëîãè÷íî
             usbtmc_abort_bulkout_transfer ( udi, 0 );
             
          }
          USB_INTERRUPT_ENABLE();
          // -------------------------------------------
   */        
}

//=========================================================================================================================
//  @@@@    @@@@   @    @  @    @   @@@@   @    @          @@@@@@  @    @  @    @   @@@@   
// @    @  @    @  @@  @@  @@  @@  @    @  @@   @          @       @    @  @@   @  @    @  
// @       @    @  @ @@ @  @ @@ @  @    @  @ @  @          @@@@    @    @  @ @  @  @       
// @       @    @  @    @  @    @  @    @  @  @ @          @       @    @  @  @ @  @       
// @    @  @    @  @    @  @    @  @    @  @   @@          @       @    @  @   @@  @    @  
//  @@@@    @@@@   @    @  @    @   @@@@   @    @          @        @@@@   @    @   @@@@   
void usbtmc_bulkout_stall_and_abort( USB_DEVICE_INFO * udi )
{ 
  usb_stall_ep( USB_EP_LOG_ADDRESS_BULK_OUT, 0x01 ); 
  usbtmc_abort_bulkout_transfer( udi, FLAG_USBTMC_FORCE_BULKOUT_ABORT ); // ôëàã FLAG_USBTMC_FORCE_BULKIN_ABORT - çàãëóøêà, ôëàã FLAG_USBTMC_FORCE_BULKOUT_ABORT ïðèíóæäàåò çàâåðøèòü ïåðåäà÷ó ìãíîâåííî
}
// ----------------------------------------------------------------------------------------------------
void usbtmc_bulkin_stall_and_abort( USB_DEVICE_INFO * udi )
{   
  usb_stall_ep( USB_EP_LOG_ADDRESS_BULK_IN, 0x01 ); 
  usbtmc_abort_bulkin_transfer( udi, FLAG_USBTMC_FORCE_BULKIN_ABORT ); // ôëàã FLAG_USBTMC_FORCE_BULKIN_ABORT ïðèíóæäàåò çàâåðøèòü ïåðåäà÷ó ìíãîâåííî, áåç îæèäàíèÿ îòïðàâêè Short ïàêåòà
}

//=========================================================================================================================
// see USBTMC spec., rev 1.0., 2003, page 22, 4.2.1.3
//  @@@@   @   @   @@@@    @@@@   @    @      @@@@   @@@@@    @@@   @@@@@   @@@@@@@     @@@@@   @    @   @       @    @         @@@   @    @   @@@@@@@
// @    @  @   @  @    @  @    @  @   @      @    @  @    @  @   @  @    @     @        @    @  @    @   @       @   @         @   @  @    @      @
// @       @   @  @@@@@@  @       @@@@       @    @  @@@@@   @   @  @    @     @        @@@@@   @    @   @       @@@@    @@@@@ @   @  @    @      @
// @       @@@@@  @       @       @   @      @@@@@@  @   @   @   @  @@@@@      @        @   @   @    @   @       @   @         @   @  @    @      @
// @    @  @   @  @    @  @    @  @    @     @    @  @    @  @   @  @    @     @        @    @  @    @   @    @  @    @        @   @  @    @      @
//  @@@@   @   @   @@@@    @@@@   @     @    @    @  @@@@@    @@@   @     @    @        @@@@@    @@@@ @  @@@@@@  @     @        @@@    @@@@ @     @
int usbtmc_checkstatus_abort_bulkout( USB_DEVICE_INFO * udi )
{  
   USB_USBTMC_CLASS_STATUS * pusbtmcStatus = (USB_USBTMC_CLASS_STATUS *) &udi->usbtmcStatus;
   USB_BULKMESSAGE_STATUS * pBulkMessage   = (USB_BULKMESSAGE_STATUS*) &udi->BulkMessageStatus;
   USB_SETUP_PACKET  * usp = &udi->EP0SetupPacket;
   USB_EP_STATUS * eps = &udi->EP0Status;
   BYTE * pbRespondBytes = ( BYTE * ) eps->InPipe.pData;
   
   // ïðîâåðÿþò, ñáðîñèëè ëè ìû ïåðåäà÷ó ïî Bulk-OUT.
   if( pusbtmcStatus->USBTMC_InitiateRecieved == TRUE )  // åñëè âîîáùå áûë ïðèíÿò çàïðîñ íà ñáðîñ ïåðåäà÷è
   {
       pusbtmcStatus->USBTMC_InitiateRecieved = FALSE; 
       pbRespondBytes[0] = pusbtmcStatus->USBTMC_status;                     
       pbRespondBytes[1] = 0;   // reserved
       pbRespondBytes[2] = 0;   // reserved
       pbRespondBytes[3] = 0;   // reserved
       
       *((unsigned int *)(&pbRespondBytes[4])) = pBulkMessage->nBytesRecieved; 
       pBulkMessage->nBytesRecieved = 0; 
     
   } 
   else 
   {
       pbRespondBytes[0] = STATUS_SPLIT_NOT_IN_PROGRESS; 
       pbRespondBytes[1] = 0;   // reserved
       pbRespondBytes[2] = 0;   // reserved
       pbRespondBytes[3] = 0;   // reserved
       
       *((unsigned int *)(&pbRespondBytes[4])) = 0;
   }
   
   eps->InPipe.dwLength = ( 8 <= usp->wLength)? 8: usp->wLength; 
   
   return 0x00;
}
//=========================================================================================================================



//=========================================================================================================================
// usbtmc_abort_bulkout_transfer - ïðåðûâàåò òåêóùóþ ïåðåäà÷ó Bulk-OUT, 
// èíèöèàëèçèðóÿ âñå íåîáõîäèìûå ïåðåìåííûå è ïàðàìåòðû òàê, ÷òîáû ïðèíÿòü
// êîððåêòíî íîâóþ Bulk-OUT ïåðåäà÷ó íà÷èíàÿ ñ BULK-OUT Header îò õîñòà
//    @@@@  @@@@@    @@@   @@@@@   @@@@@@@     @@@@@   @    @   @       @    @         @@@   @    @   @@@@@@@
//  @    @  @    @  @   @  @    @     @        @    @  @    @   @       @   @         @   @  @    @      @
//  @    @  @@@@@   @   @  @    @     @        @@@@@   @    @   @       @@@@    @@@@@ @   @  @    @      @
//  @@@@@@  @   @   @   @  @@@@@      @        @   @   @    @   @       @   @         @   @  @    @      @
//  @    @  @    @  @   @  @    @     @        @    @  @    @   @    @  @    @        @   @  @    @      @
//  @    @  @@@@@    @@@   @     @    @        @@@@@    @@@@ @  @@@@@@  @     @        @@@    @@@@ @     @
  
int usbtmc_abort_bulkout_transfer ( USB_DEVICE_INFO * udi, int dwFlags ){ 
  
  // abort HOST->DEVICE
   int ep_state; 
   USB_USBTMC_CLASS_STATUS * pusbtmcStatus = (USB_USBTMC_CLASS_STATUS *) &udi->usbtmcStatus;
   USB_BULKMESSAGE_STATUS * pBulkMessage   = (USB_BULKMESSAGE_STATUS*) &udi->BulkMessageStatus;
   USB_SETUP_PACKET  * usp = &udi->EP0SetupPacket;
   USB_EP_STATUS * eps = &udi->EP0Status;
   BYTE * pbRespondBytes = ( BYTE * ) eps->InPipe.pData;
   
   // MACRO_PROGRAMSECURITY_BOACXT_TRYENTER(); // ïðîâåðÿåì, âûçâàíà ëè usbtmc_abort_bulkin_transfer() ðåêóðñèâíî, åñëè äà, âûõîäèì
   
   //-----------------------------------------------------------------------------------------------------------------
   if( dwFlags & FLAG_USB_SETUPPACKET_RECIEVED ) 
   {   
     /* åñëè ôóíêöèÿ âûçâàíà ñ ýòèì ôëàãîì, ýòî îçíà÷àåò, ÷òî áûë ïðèíÿò çàïðîñ íà óíè÷òîæåíèå ïåðåäà÷è Bulk-Out
        Ïåðåäà÷à íå áóäåò óíè÷òîæåíà ñðàçó.  ïðåðûâàíèè äåëàòü ýòîãî íå ñòîèò, òàê êàê âïîëíå âîçìîæíî, ÷òî ôóíêöèÿ
        áóäåò âûçâàíà â ìîìåíò, êîãäà âåäåòñÿ ïåðåäà÷à è âûïîëíÿåòñÿ ôóíêöèÿ usb_EP2_tx_func__(), êîòîðàÿ ðàáîòàåò
        ñ ïåðåìåííûìè è óêàçàòåëÿìè, êîòîðûå íóæíî îáíóëèòü çäåñü. Íóæíî äîæäàòüñÿ, îñíîâíîé ïîòîê âûäéäåò èç òàêèõ 
        ôóíêöèé. Ñëåäóåò ïîñòàâèòü çàïïðîñ â î÷åðåäü, óñòàíîâèâ ôëàæîê. 
     
        Ðåôàêòîðèíã. 30/08/18. Ïðî÷èòàë. Íå ïîíÿë. 
        Íè îäíà èç ôóíêöèé ïðîòîêîëà USBTMC íå âûçûâàåòñÿ èç îñíîâãîãî ïîòîêà.
        Âîçìîæíî, êîìåíòàðèé óæå óñòàðåë. Âñå ïåðåäà÷è âåäóòñÿ èç ïðåðûâàíèÿ,
        à çíà÷èò "çàñòàòü" íèêàêóþ ôóíêöèþ â íèêàêîì ìåñòå íåëüçÿ, ïîñêîëüêó
        îíà âûçûâàåòñÿ èç êîíòåêñòà òîãî æå âåêòîðà ïðåðûâàíèÿ.
     */

     // çàïðîñ ïîñòàâëåí â î÷åðåäü íà îáðàáîòêó èç êîíòåêñòà ïðåðûâàíèÿ
     
     // see "USBTMC spec., rev 1.0, 2003": "page 18-19..."
     if(pusbtmcStatus->USBTMC_InitiateRecieved == FALSE) 
     {
        // --  çàïðîñ INITIATE_ABORT_BULK_OUT ïðèíÿò íå áûë
        // --  õîñò íå äîëæåí ïðèñûëàòü äâà òàêèõ çàïðîñà ïîäðÿä
        // --  åñëè õîñò ïðèñëàë class request íå CHECK_STATUS, åãî îáðàáîòàåò usbtmc_class_request_fault
                   
        pbRespondBytes[1] = pBulkMessage->bTag;                        // -- çàïîëíÿåì îñòàâøååñÿ ïîëå îòâåòíîãî ñîîáùåíèÿ               
        eps->InPipe.dwLength = ( 2 <= usp->wLength)? 2: usp->wLength;  // -- îòâåòíîå ñîîáùåíèå ñîäåðæèò 2 áàéòà 
                     
        if((pBulkMessage->OUTTransferInProgress == TRUE) && (pBulkMessage->bTag == (0xFF & usp->wValue)))
        {
            // - Ïåðåäà÷à â ïðîöåññå    ---> Ïåðåäà÷à áóäåò çàâåðøåíà, 
            // - bTag ñîâïàë            --->   çàïðîñ ïîñòàâëåí â î÷åðåäü, ñòàòóñ: STATUS_PENDING
            pusbtmcStatus->USBTMC_InitiateRecieved      = TRUE;            // -- ïðèíÿò çàïðîñ INITIATE
            pusbtmcStatus->USBTMC_status                = STATUS_PENDING;  // -- ïåðåäà÷à îæèæàåò çàâåðøåíèÿ 
            pbRespondBytes[0] = STATUS_SUCCESS;                            // -- ñòàòóñ îïåðàöèè (òåêóùåãî çàïðîñà) : STATUS_SUCCESS, îïåðàöèÿ âûïîëíåíà, çàïðîñ ïîñòàâëåí â î÷åðåäü        
                                  
            /* 30/08/18, ðåôàêòîðèíã.
            ïîñêîëüêó â ïðîãðàììå íå íàéäåíû âûçîâû îáðàáîò÷èêîâ usbtmc
            â îñíîâíîì ïîòîêå main(), ìåðà ïðåäîñòîðîæíîñòè îáðàáîòêè
            âûçîâà usbtmc_abort_bulkout_transfer ( udi, 0 ) ÷åðåç usbtmc_service èçëèøíÿÿ.
            Çàìåíèë âûçîâ -MACRO_FLAGSET_INITIATE_BULKOUT_ABORT()- íà ïðÿìîé
            âûçîâ usbtmc_abort_bulkout_transfer ( udi, 0 )
            -- MACRO_FLAGSET_INITIATE_BULKOUT_ABORT();                        // -- ñèãíàëèçèðóåì
            */
            usbtmc_abort_bulkout_transfer ( udi, 0 );                        
        } 
        else
        {
            // - èëè bTag íå ñîâïàë                          --->
            // - èëè bTag ñîâïàë, íî ïåðåäà÷à óæå çàâåðøåíà. ---> ñòàòóñ îïåðàöèè: íå STATUS_SUCCESS
                                  
            pusbtmcStatus->USBTMC_InitiateRecieved      = FALSE;           // -- çàïðîñ INITIATE íå ïðèíÿò

            // -- see USBTMC spec, rev 1.0, 2003, page 22, table 20
            // -- ïîëó÷àåì ñîñîòîÿíèå EP. ñìîòðèì, çàíÿòû ëè åå áóôåðû
            ep_state = usb_lpc_cmd_read(CMD_EP_SELECT | USB_EP_PHY_ADDRESS_BULK_OUT);
            if( ep_state & ((1<<5)|(1<<6)))
                pusbtmcStatus->USBTMC_status = STATUS_TRANSFER_NOT_IN_PROGRESS;
            else
                pusbtmcStatus->USBTMC_status = STATUS_FAILED;
                                 
            pbRespondBytes[0] = pusbtmcStatus->USBTMC_status; 
        }
     }               
   } 
   else 
   {
      // âûçîâ ôóíêöèè èç main
      // -- ñþäà ìû ïîïàäåì, åñëè âûçîâåì ô-þ áåç ôëàãà FLAG_USB_SETUPPACKET_RECIEVED
      // -- ýòî ìîæåò îçíà÷àòü, ÷òî áûë ïðèíÿò çàïðîñ íà îáðûâ ïåðåäà÷è è óñòàíîâëåí ôëàã  FLAG_USBTMC_INITIATE_BULKOUT_ABORT
      // -- òàê êàê âûçîâ îñóùåñòâëåí èç îñíîâíîãî ïîòîêà, à íå èç ïðåðûâàíèÿ, îáðàáîòàåì çàïðîñ
     
      // ===============================================================================================
      // >>> Âàæíî! Î âûçîâå usbtmc_abort_bulkin, usbtmc_abort_bulkout                               <<<
      // -----------------------------------------------------------------------------------------------
      //      / \    > Íåëüçÿ âûçûâàòü usbtmc_abort_bulkout è usbtmc_abort_bulkin èç ïðåðûâàíèÿ!    < //
      //     / | \   > Òàê êàê ôóíêöèè usb_EP2_t(/r)x âûçûâàþòñÿ èç îñíîâíîãî ïîòîêà, òî è          < //
      //    /__*__\  > ïðåðûâàòü ïåðåäà÷è íóæíî ÓÁÅÄÈÂØÈÑÜ, ÷òî îñíîâíîé ïîòîê íå íàõîäèòñÿ â       < //
      //             > usb_EP2_t(/r)x è íå èçìåíèò êàêóþ ëèáî èç ïåðåìåííûõ ñðàçó ïîñëå âûõîäà      < //
      // > èç ïðåðûâàíèÿ, ãäå ýòà ïåðåìåííàÿ áûëà ñáðîøåíà. Ýòî ÷ðåâàòî íåïðîãíîçèðóåìûì ïîâåäåíèåì < //
      // > óñòðîéñòâà è, ñîîòâåòñòâåííî, íåïðàâèëüíîé ðàáîòîé ïðîòîêîëà USBTMC                      < //
      // >                                                                                          < //
      // ===============================================================================================   
     
      // Abort Bulk trnasfer (Host->Device)
      //usp->wValue;         // -- D0...D7 - the bTag value associated with  the transfer to abort
      //usp->wIndex;         // -- must specify direction (D7) and endpoint number (D0...D3)
      //usp->wLength;        // -- Number of bytes to transfer: length of response to this request 
      // -- èìååì òîëüêî îäíó Bulk-Out ïîýòîìó èãíîðèðóåì ïîëå usp->wIndex
      // -- îáðàáàòûâàåì bTag
                     
                    
      // -- see "USBTMC spec., rev 1.0, 2003": "page 18-19..."
      if(pBulkMessage->OUTTransferInProgress == TRUE )
      {
         // -- bTag ñîâïàë ïðè ïðîâåðêå çàïðîñà èç ïðåðûâàíèÿ, ïåðåäà÷à â ïðîãðåññå è áóäåò çàâåðøåíà
         usb_stall_ep( USB_EP_LOG_ADDRESS_BULK_OUT, 0x01 );               // -- see USBTMC spec, rev 1.0, 2003, page 22, table 20, desc. of "STATUS_SUCCESS"
         pusbtmcStatus->USBTMC_status = STATUS_SUCCESS; 
      }
      else
      {
         // bTag õîòü è ñîâïàë ïðè ïðîâåðêå çàïðîñà èç ïðåðûâàíèÿ, íî ïåðåäà÷à âèäèìî óùå çàêîí÷åíà
         usb_stall_ep( USB_EP_LOG_ADDRESS_BULK_OUT, 0x01 );               // -- see USBTMC spec, rev 1.0, 2003, page 22, table 20, desc. of "STATUS_SUCCESS"
         pusbtmcStatus->USBTMC_status                = STATUS_SUCCESS;   // -- âñå ðàâíî STATUS_SUCCESS
         // -- see USBTMC spec, rev 1.0, 2003, page 19, table 16, page 23, table 23
         // -- STATUS_TRANSFER_NOT_IN_PROGRESS ìîæíî óñòàíîâèòü ÒÎËÜÊÎ ïðè ïðèåìå çàïðîñà, òîåñòü â ïðåðâààíèè
         // -- à çäåñü ìû óæå îáðàáàòûâàåì óæå ïðèíÿòûé çàïðîñ. Çäåñü ìû ñîãëàñíû, ÷òî ïåðåäà÷à â ïðîãðåññå
         // -- òàê êàê îíà áûëà â ïðîãðåññå íà ìîìåíò ïðèåìà çàïðîñà. òîëüêî STATUS_SUCCESS
      } 
      
      pBulkMessage->MsgID                  =  0x00;
      pBulkMessage->bTag                   =  0x00;
      pBulkMessage->bTagLast               =  0x00;
      pBulkMessage->bBulkHeaderRecieved    = FALSE;
      //(void)pBulkMessage->nBytesRemaining; // =  0x00;
      pBulkMessage->nBytesRecieved         =  0x00;
      (void)pBulkMessage->nBytesRecieved;  // =  0x00;  // òðåáóåòñÿ íå îáíóëÿòü ÷òîáû âåðíóòü â çàïðîñå CHECK_ABORT_BULK_OUT_STATUS
      pBulkMessage->OUTTransferInProgress     = FALSE;     
   }

   // MACRO_PROGRAMSECURITY_BOACXT_LEAVE();  // -- ïîêèäàåì
   return 0x00;   
}
//=========================================================================================================================

void usbtmc_reset_bulkmessage_status ( USB_BULKMESSAGE_STATUS * pBulkMessage )
{
   s_memset( (BYTE*)pBulkMessage, 0x00, sizeof(USB_BULKMESSAGE_STATUS) );  
}

void usbtmc_reset_bulkrespond_status ( USB_BULKRESPOND_STATUS * pBulkRespond )
{
   s_memset( (BYTE*)pBulkRespond, 0x00, sizeof(USB_BULKRESPOND_STATUS) );  
}

//=========================================================================================================================
// usbtmc_abort_bulkin_transfer - ïðåðûâàåò òåêóùóþ ïåðåäà÷ó Bulk-IN, 
// èíèöèàëèçèðóÿ âñå íåîáõîäèìûå ïåðåìåííûå è ïàðàìåòðû òàê, ÷òîáû íà÷àòü
// êîððåêòíî íîâóþ Bulk-IN ïåðåäà÷ó íà÷èíàÿ ñ BULK-IN Header ê õîñòó
//    @@@@  @@@@@    @@@   @@@@@   @@@@@@@     @@@@@   @    @   @       @    @         @@@   @    @           
//  @    @  @    @  @   @  @    @     @        @    @  @    @   @       @   @           @    @@   @       
//  @    @  @@@@@   @   @  @    @     @        @@@@@   @    @   @       @@@@    @@@@@   @    @ @  @       
//  @@@@@@  @   @   @   @  @@@@@      @        @   @   @    @   @       @   @           @    @ @  @       
//  @    @  @    @  @   @  @    @     @        @    @  @    @   @    @  @    @          @    @  @ @       
//  @    @  @@@@@    @@@   @     @    @        @@@@@    @@@@ @  @@@@@@  @     @        @@@   @   @@    
int usbtmc_abort_bulkin_transfer ( USB_DEVICE_INFO * udi, int dwFlags )
{   
   // abort DEVICE->HOST
   USB_USBTMC_CLASS_STATUS * pusbtmcStatus = (USB_USBTMC_CLASS_STATUS *) &udi->usbtmcStatus;   
   USB_BULKRESPOND_STATUS * pBulkRespond = (USB_BULKRESPOND_STATUS*) &udi->BulkRespondStatus;
   USB_SETUP_PACKET  * usp = &udi->EP0SetupPacket;
   USB_EP_STATUS * eps = &udi->EP0Status;
   BYTE * pbRespondBytes = ( BYTE * ) eps->InPipe.pData;
   int ep_state;
   
   // MACRO_PROGRAMSECURITY_BIACXT_TRYENTER();  // ïðîâåðÿåì, âûçâàíà ëè usbtmc_abort_bulkin_transfer() ðåêóðñèâíî, åñëè äà, âûõîäèì
   //-------------------------------------------------------------------------------------------
   
   // ======================================================= //
   // >>> Î ñòàòóñàõ STATUS_SUCCESS è STATUS_PENDING      <<< //
   // ------------------------------------------------------- //
   //            Îïåðàöèÿ INITIATE_ABORT_BULK_IN ïðîèñõîäèò â //
   //     / \    äâà ýòàïà: ïðèíèìàåòñÿ çàïðîñ îò õîñòà, ÷òî  //
   //    / | \   òðåáóåòñÿ çàâåðøèòü ïåðåäà÷ó, çàòåì õîñò ïî- //
   //   /__*__\  ñûëàåò çàïðîñ, ñïðàâëÿÿñü î ðåçóëüòàòàõ.     //
   //                                                         // 
   // INITIATE_ABORT_BULK_IN - èíèöèðóåò çàâåðøåíèå ïåðåäà÷è. //
   // Åñëè â îòâåò íà ýòîò çàïðîñ óñòðîéñòâî îòïðàâèò STATUS_ //
   // SUCCESS, äëÿ õîñòà ýòî çíà÷èò, ÷òî óñòðîéñòâî ïðèíÿëî   //
   // çàïðîñ â îáðàáîòêó, íî íå îçíà÷àåò, ÷òî ïåðåäà÷à ÓÆÅ    //
   // ïðåðâàíà! Îá ðåçóëüòàòå îí óçíàåò ïîçæå, ïîýòîìó, ñðàçó //
   // ïîñëå îòïðàâêè îòâåòà STATUS_SUCCESS, óñòðîéñòâî ìåíÿåò //
   // ñòàòóñ íà STATUS_PENDING è ñòàðàåòñÿ çàâåðøèòü ïåðåäà÷ó //
   // Òåïåðü, åñëè õîñò ïðèøëåò çàïðîñ CHECK_ABORT_BULK_OUT_  //
   // STATUS ÄÎ òîãî, êàê ïðèøëåò î÷åðåäíîé Bulk-IN çàïðîñ,   //
   // ëèøàÿ óñòðîéñòâî âîçìîæíîñòè îòîñëàâ SHORT ïàêåò êîððå- // 
   // êòíî çàâåðøèòü ïåðåäà÷ó, óñòðîéñòâî îòâåòèò åìó ñòà -   //
   // òóñîì STATUS_PENDING! À åñëè õîñò ñíà÷àëà çàïðîñèò      //
   // Short ïàêåò, è îïðåäåëèâ, ÷òî îí Short, çàïðîñèò        //
   // CHECK_ABORT_BULK_OUT_STATUS, óñòðîéñòâî âåðíåò õîñòó    //
   // STATUS_SUCCESS, òàê êàê îíî êîððåêòíî çàâåðøèëî ïåðåäà÷ó//
   // =======================================================
   
   if( dwFlags & FLAG_USB_SETUPPACKET_RECIEVED )
   {
        /* åñëè ôóíêöèÿ âûçâàíà ñ ýòèì ôëàãîì, ýòî îçíà÷àåò, ÷òî áûë ïðèíÿò çàïðîñ íà óíè÷òîæåíèå ïåðåäà÷è Bulk-In
        Ïåðåäà÷à íå áóäåò óíè÷òîæåíà ñðàçó.  ïðåðûâàíèè äåëàòü ýòîãî íå ñòîèò, òàê êàê âïîëíå âîçìîæíî, ÷òî ôóíêöèÿ
        áóäåò âûçâàíà â ìîìåíò, êîãäà âåäåòñÿ ïåðåäà÷à è âûïîëíÿåòñÿ ôóíêöèÿ usb_EP2_rx_func(), êîòîðàÿ ðàáîòàåò
        ñ ïåðåìåííûìè è óêàçàòåëÿìè, êîòîðûå íóæíî îáíóëèòü çäåñü. Íóæíî äîæäàòüñÿ, îñíîâíîé ïîòîê âûäéäåò èç òàêèõ 
        ôóíêöèé. Ñëåäóåò ïîñòàâèòü çàïïðîñ â î÷åðåäü, óñòàíîâèâ ôëàæîê. */
                                                      
        // çàïðîñ ïîñòàâëåí â î÷åðåäü íà îáðàáîòêó èç êîíòåêñòà ïðåðûâàíèÿ 
     
        // see "USBTMC spec., rev 1.0, 2003": "page 18-19..."
        if(pusbtmcStatus->USBTMC_InitiateRecieved == FALSE) 
        {
           // --  çàïðîñ INITIATE_ABORT_BULK_OUT ïðèíÿò íå áûë
           // --  õîñò íå äîëæåí ïðèñûëàòü äâà òàêèõ çàïðîñà ïîäðÿä
           // --  åñëè õîñò ïðèñëàë class request íå CHECK_STATUS, åãî îáðàáîòàåò usbtmc_class_request_fault
           pbRespondBytes[1] = udi->BulkRespondStatus.bTag;            
           eps->InPipe.dwLength = (2 <= usp->wLength)? 2: usp->wLength;
                   
           if((pBulkRespond->INTransferInProgress == TRUE) && (udi->BulkRespondStatus.bTag == (0xFF & usp->wValue)))
           {
               // - Ïåðåäà÷à â ïðîöåññå    ---> Ïåðåäà÷à áóäåò çàâåðøåíà, 
               // - bTag ñîâïàë            --->   çàïðîñ ïîñòàâëåí â î÷åðåäü, ñòàòóñ: STATUS_PENDING
               pusbtmcStatus->USBTMC_InitiateRecieved      = TRUE;            // -- ïðèíÿò çàïðîñ INITIATE
               pusbtmcStatus->USBTMC_status                = STATUS_PENDING;  // -- ïåðåäà÷à îæèæàåò çàâåðøåíèÿ 
               pbRespondBytes[0] = STATUS_SUCCESS;                            // -- ñòàòóñ îïåðàöèè (òåêóùåãî çàïðîñà) : STATUS_SUCCESS, îïåðàöèÿ âûïîëíåíà, çàïðîñ ïîñòàâëåí â î÷åðåäü        
                                  
               /* 30/08/18, ðåôàêòîðèíã.
               ïîñêîëüêó â ïðîãðàììå íå íàéäåíû âûçîâû îáðàáîò÷èêîâ usbtmc
               â îñíîâíîì ïîòîêå main(), ìåðà ïðåäîñòîðîæíîñòè îáðàáîòêè
               âûçîâà usbtmc_abort_bulkin_transfer ( udi, 0 ) ÷åðåç usbtmc_service èçëèøíÿÿ.
               Çàìåíèë âûçîâ -MACRO_FLAGSET_INITIATE_BULKIN_ABORT()- íà ïðÿìîé
               âûçîâ usbtmc_abort_bulkout_transfer ( udi, 0 )
               -- MACRO_FLAGSET_INITIATE_BULKIN_ABORT(); 
               */
               usbtmc_abort_bulkin_transfer ( udi, 0 );
                                  
           } 
           else 
           {
               // - èëè bTag íå ñîâïàë                          --->
               // - èëè bTag ñîâïàë, íî ïåðåäà÷à óæå çàâåðøåíà. ---> ñòàòóñ îïåðàöèè: íå STATUS_SUCCESS
                                  
               pusbtmcStatus->USBTMC_InitiateRecieved      = FALSE;           // -- çàïðîñ INITIATE íå ïðèíÿò

               // -- see USBTMC spec, rev 1.0, 2003, page 22, table 24
               // -- ïîëó÷àåì ñîñîòîÿíèå EP. ñìîòðèì, çàíÿòû ëè åå áóôåðû
               ep_state = usb_lpc_cmd_read(CMD_EP_SELECT | USB_EP_PHY_ADDRESS_BULK_IN);
               
               if( ep_state & ((1<<5)|(1<<6)))
                   pusbtmcStatus->USBTMC_status = STATUS_TRANSFER_NOT_IN_PROGRESS;
               else
                   pusbtmcStatus->USBTMC_status                = STATUS_FAILED;
                                 
               pbRespondBytes[0] = pusbtmcStatus->USBTMC_status; 
           }
                   
        }                     
   } 
   else 
   {
      // ================================================================================== //
      // >>> Î INTransferInProgress = TRUE, ÷òî íàïèñàíî ÷óòü íèæå                      <<< //
      // --------------------------------------------------------------------------------   //
      //    / \        Âíèìàíèå! Âîçìîæåí òàêîé âàðèàíò. Õîñò çàïðîñèë äàííûå. Êîëè÷åñòâî   //
      //   / | \   äàííûõ êðàòíî ðàçìåðó áóôåðà òî÷êè, è, ïîèäåå, ñëåäóåò îòïðàâèòü Short   //
      //  /__*__\  ïàêåò. Êîãäà Short ïàêåò ñòàâèòñÿ â î÷åðåäü íà îòïðàâêó ïî ïðåðûâàíèþ,   //
      //           ïåðåìåííàÿ  INTransferInProgress óñòàíàâëèâàåòñÿ â FALSE. Åñëè õîñò íå   //
      //  ñòàíåò çàïðàøèâàòü ýòîò Short ïàêåò,  òî ïåðåäà÷à ïîèäåå åùå íå çàâåðøåíà.  Íî:   //
      //  INTransferInProgress óæå ðàâíà FALSE. Åñëè ïðèñëàòü çàïðîñ INITIATE_ABORT_BULK_IN //
      //  òî âåðíåòñÿ  ñòàòóñ STATUS_TRANSFER_NOT_IN_PROGRESS,  õîòÿ ýòî íå òàê,  ò.ê. íå   //
      // çàïðîøåí Short ïàêåò! Ïîýòîìó, INTransferInProgress ðàâíà TRUE âîïðåêè ëîãèêå      //
      /*--------------------------------------------------------*/                          //
      /* see USBTMC spec, page 12, point 10, and also           */                          //
      /* see USBTMC spec, page 26, example in 4.2.1.5           */                          //
      /* "Device MUST always terminate bulk-in trnasfer by sen- */                          //
      /* ding short packet!!!" ïîýòîìó íåëüçÿ ñðàçó âçÿòü è     */                          //
      /* pBulkMessage->INTransferInProgress = false, òàê êàê    */                          //
      /* òîãäà short ïàêåò íå îòïðàâèòñÿ.                       */                          //
      /* Îäíàêî åñëè ôëàã FLAG_USBTMC_FORCE_BULKIN_ABORT óñòà - */                          //
      /* íîâëåí, çíà÷èò EP îñòàíîâëåíà (HALT (STALLED)), è íåò  */                          //
      /* íåîáõîäèìîñòè è ñìûñëà æäàòü îòñûëêè Short ïàêåòà,     */                          //
      /* êîòîðûé, ñîáñòâåííî, íèêîäà íå áóäåò îòïðàâëåí ïî îäíîé*/                          //
      /* ïðîñòîé ïðè÷èíå:  òî÷êà îñòàíîâëåíà (HALT) è íàù short */                          //
      /* ïàêåò õîñòó íå íóæåí, îí ïðèøëåò CLEAR_FEATURE, ïîýòîìó*/                          // 
      /* íóæíî INTransferInProgress óñòàíîâèòü â FALSE          */                          // 
      /*---                                                  ---*/                          //
      /* Åñëè âûçâàòü ôóíêöèþ èç Initiate_clear ñ ïàðàìåòðîì    */
      /* FLAG_USBTMC_FORCE_BULKIN_ABORT òî âñå îãðàíè÷åíèÿ îò-  */
      /* ìåíÿþòñÿ è INTransferInProgress è INTransferTerminating*/
      /* ïðèðàâíèâàþòñÿ â FALSE                                 */ 
      /* !!!  âîîáùå, â ñïåöèôèêàöèè ñêàçàíî, ÷òî ìîæíî âåðíóòü */
      /* ñòàòóñ PENDING â îòâåò íà çàïðîñ CHECK_CLEAR_STATUS    */
      /* åñëè õîñò íå ïðî÷åë short ïàêåò. (USBTMC, rev 1.0,2003 */  
      /* page 28, table 34                Îäíàêî ýòî ñïðàâåäëèâî*/
      /* åñëè óñòðîéñòâî ÍÅ ìîæåò óäàëèòü ïàêåò èç FIFO è òðå-  */
      /* áóåòñÿ, ÷òîáû õîñò åãî ïðî÷åë. Ìîæíî ïðîñòî óäàëèòü âñå*/
      /* äàííûå èç áóôåðîâ è âñåãäà âîçâðàùàòü STATUS_SUCCESS   */
      /*---                                                  ---*/                       
      /* BOOLVAR ðàâíÿåòñÿ TRUE åñëè íå ïåðåäàí íóëåâîé ïàêåò   */                          //
      /* èëè åùå îñòàëèñü äàííûå íà îòïðàâêó                    */                          //  
      /**/BOOL BOOLVAR = (udi->EPBulkStatus.InPipe.dwLength>0 || eps->shortpacketsending || eps->shortpacket) ? TRUE:FALSE;                       //
      /**/     BOOLVAR&= pBulkRespond->INTransferInProgress; // -- åñëè ìû ïîïàëè ñþäà ïîñëå ïîñëåäíåãî ïàêåòà ïåðåäà÷è è ïåðåäà÷à óæå çàâåðøåíà!
      /**/pBulkRespond->INTransferInProgress = ( dwFlags &                                  //
      /**/                 FLAG_USBTMC_FORCE_BULKIN_ABORT )?FALSE:(BOOLVAR);                //                    
      /**/pBulkRespond->INTransferTerminating =( dwFlags &                                  //
      /**/                 FLAG_USBTMC_FORCE_BULKIN_ABORT )?FALSE:(BOOLVAR);                //
      /**/ /* pBulkMessage->nBytesSent = 0;  */               /*  Îáíóëèòñÿ ïî íà÷àëó íî- *///
      /**/                                     /* âîé ïåðåäà÷è. Íóæíà äëÿ çàïðîñà ñòàòóñà *///
      /**/                            /* çàâåðøåíèÿ ïåðåäà÷è (CHECK_ABORT_BULK_IN_STATUS) *///
      /*--------------------------------------------------------*/                          //
      // ---------------------------------------------------------------------------------- //
      
      //============================================================================================================
      // ïåðåäà÷à äîëæíà çàâåðøèòüñÿ Short ïàêåòîì. äëÿ ýòîãî åãî íàäî ïîëîæèòü â î÷åðåäü íà îòïðàâêó â áóôåð EP
      // åñëè áóôåðû â äàííûé ìîìåíò çàíÿòû, òî ïî çàâåðøåíèþ ïåðåäà÷è â ôóíêöèè ïî ïðåðûâàíèþ îò çàâåðøåíèÿ ïåðåäà÷è
      // (usb_EP2_tx_func__) short ïàêåò ñàì âñòàíåò â î÷åðåäü, åñëè íóæíî (åñëè êîëè÷åñòâî äàííûõ êðàòíî ðàçìåðó
      // áóôåðà. Åñëè õîòÿ áû îäèí áóôåð ïóñò, ìîæíî ïîëîæèòü Short ïàêåò ïðÿìî çäåñü. Îäíàêî îí íå íóæåí, åñëè îñòàâ-
      // øååñÿ êîëè÷åñòâî äàííûõ ìåíüøå ðàçìåðà áóôåðà EP.
      //-----------------------------------------------------------------------------------------------------------
      ep_state = usb_lpc_cmd_read(CMD_EP_SELECT | USB_EP_PHY_ADDRESS_BULK_IN); 
                       
      if( udi->EPBulkStatus.InPipe.dwLength!=0 && (!(dwFlags & FLAG_USBTMC_FORCE_BULKIN_ABORT)))                   // åñëè îñòàëèñü íå ïåðåäàííûå äàííûå
      {  
           if(udi->EPBulkStatus.InPipe.dwLength >= USB_MAX_PACKET2)   // íåîáõîäèì short ïàêåò, òàê êàê ïîñëåäíÿÿ ïîðöèÿ äàííûõ ðàâíà èëè áîëüøå ðàçìåð áóôåðà
           { 
                if( !((ep_state&(1<<5))) && ((ep_state&(1<<6))) )           // åñëè áóôåðû òî÷êè ñâîáîäíû (õîòÿáû îäèí)
                {  
                    udi->EPBulkStatus.shortpacket = FALSE;                   // áóäåì èñïîëüçîâàòü äâîéíóþ áóôôåðèçàöèþ
                    usb_ep_write(USB_EP_LOG_ADDRESS_BULK_IN,(BYTE*)0, 0);    // ñòàâèì â î÷åðåäü short ïàêåò
                }   
                else
                {  
                    udi->EPBulkStatus.shortpacket = FALSE; // ïàêåò ïåðåäàòñÿ â ñëåäóùåé òðàíçàêöèè
                }                 
           }        
      } 
      else 
      {
           
           // ÷òî ìû èìååì: udi->EPBulkStatus.InPipe.dwLength == 0
           //               ìû â ôóíêöèè, çíà÷èò INTransferInProgress áûëà ðàâíà true, êîãäà áûë ïðèíÿò çàïðîñ
           //               çíà÷èò ïîëó÷èëîñü òàê, ÷òî çàïðîñ îáðàáîòàí ñ îïîçäàíèåì è ïîñëåäíÿÿ ïîðöèÿ äàííûõ óæå îòïðàâëåíà
           // âîçìîæíî åùå íå ïåðåäàí short ïàêåò íóëåâîé äëèííû
           
           // òàêæå ñþäà ïîïàäåì åñëè âûçâàëè ôóíêöèþ èç initiate_clear ñ ôëàãîì FLAG_USBTMC_FORCE_BULKIN_ABORT
           if(dwFlags & FLAG_USBTMC_FORCE_BULKIN_ABORT)
           { 
              udi->EPBulkStatus.shortpacket=FALSE;
              udi->EPBulkStatus.shortpacketsending=FALSE;
           }
      }
      //===========================================================================================================
      
      usb_reset_pipe_status( &udi->EPBulkStatus.InPipe ); 
                       
      pBulkRespond->MsgID = 0x00; // äëÿ   ÷åñòíîñòè
      pBulkRespond->bTag  = 0x00;  // äëÿ  ÷åñòíîñòè
                       
      udi->GPIBFunctionContext.bEnable = FALSE;
      udi->GPIBFunctionContext.LastFunction = NULL;                                 
  }
    
  // MACRO_PROGRAMSECURITY_BIACXT_LEAVE(); 
  return 0x00;   
}

//=========================================================================================================================



//=========================================================================================================================
//  @@@@   @   @   @@@@    @@@@   @    @      @@@@   @@@@@    @@@   @@@@@   @@@@@@@     @@@@@   @    @   @       @    @         @@@  @@    @           
// @    @  @   @  @    @  @    @  @   @      @    @  @    @  @   @  @    @     @        @    @  @    @   @       @   @           @    @@   @  
// @       @   @  @@@@@@  @       @@@@       @    @  @@@@@   @   @  @    @     @        @@@@@   @    @   @       @@@@    @@@@@   @    @ @  @ 
// @       @@@@@  @       @       @   @      @@@@@@  @   @   @   @  @@@@@      @        @   @   @    @   @       @   @           @    @  @ @      
// @    @  @   @  @    @  @    @  @    @     @    @  @    @  @   @  @    @     @        @    @  @    @   @    @  @    @          @    @   @@
//  @@@@   @   @   @@@@    @@@@   @     @    @    @  @@@@@    @@@   @     @    @        @@@@@    @@@@ @  @@@@@@  @     @        @@@   @    @@
int usbtmc_checkstatus_abort_bulkin (USB_DEVICE_INFO * udi )
{
   USB_USBTMC_CLASS_STATUS * pusbtmcStatus = (USB_USBTMC_CLASS_STATUS *) &udi->usbtmcStatus;   
   USB_BULKRESPOND_STATUS * pBulkRespond = (USB_BULKRESPOND_STATUS*) &udi->BulkRespondStatus;
   USB_SETUP_PACKET  * usp = &udi->EP0SetupPacket;
   USB_EP_STATUS * eps = &udi->EP0Status;
   BYTE * pbRespondBytes = ( BYTE * ) eps->InPipe.pData;
   
   // ïðîâåðÿþò, ñáðîñèëè ëè ìû ïåðåäà÷ó ïî Bulk-IN.
   if( pusbtmcStatus->USBTMC_InitiateRecieved == TRUE )  // åñëè âîîáùå áûë ïðèíÿò çàïðîñ íà ñáðîñ ïåðåäà÷è
   {
       pusbtmcStatus->USBTMC_InitiateRecieved = FALSE; 
       pbRespondBytes[0] = pusbtmcStatus->USBTMC_status;  
     
       //----------------------------------------------------------------------
       // see USBTMC spec, rev 1.0, 2003, page 25, table 29, description of "STATUS_PENDING"
       // and also see USBTMC spec, rev 1.0, 2003, page 25, table 28, desc. of byte with offset 1
       pbRespondBytes[1] = (           /* bmAbortBulkIn */                 
                            (pusbtmcStatus->USBTMC_status==STATUS_PENDING) 
                           &&                                              
                            (pBulkRespond->INTransferInProgress == TRUE)           
                           &&                                                
                            (pBulkRespond->INTransferTerminating == TRUE)          
                           )?(1<<0):0x00;
       // Åñëè ñòàòóñ STATUS_PENDING (îæèäàåòñÿ), INTransferInProgress=TRUE, è INTransferTerminating = TRUE                    
       // çíà÷èò ïåðåäà÷à â ïðîöåññå çàâåðøåíèÿ, è ñóäÿ ïî äîêóìåíòàöèè äëÿ ñ÷àñòüÿ òîëüêî è íåõâàòàåò îòïðàâèòü
       // Short ïàêåò õîñòó. ( ñì ññûëêè íà äîê-þ âûøå ) 
       pbRespondBytes[1] &= 0x01;  // bytes Reserved                 
       //-----------------------------------------------------------------------
       pbRespondBytes[2] = 0;   // reserved
       pbRespondBytes[3] = 0;   // reserved
     
       *((unsigned int *)(&pbRespondBytes[4])) = pBulkRespond->nBytesSent;
     
       pBulkRespond->nBytesSent = 0; 
   }
   else
   {
       pbRespondBytes[0] = STATUS_SPLIT_NOT_IN_PROGRESS; 
       pbRespondBytes[1] = 0;   // reserved
       pbRespondBytes[2] = 0;   // reserved
       pbRespondBytes[3] = 0;   // reserved
       
       *((unsigned int *)(&pbRespondBytes[4])) = 0;
   }
   
   eps->InPipe.dwLength = ( 8 <= usp->wLength)? 8: usp->wLength; 
   
   return 0x00;
}
//=========================================================================================================================


//=========================================================================================================================
//  @@@  @    @  @@@  @@@@@  @@@    @@@@   @@@@@  @@@@      @@@@   @        @@@@    @@@@   @@@@@
//   @   @@   @   @     @     @    @    @    @   @    @    @    @  @       @    @  @    @  @    @
//   @   @ @  @   @     @     @    @@@@@@    @   @@@@@     @       @       @@@@@@  @@@@@@  @@@@@
//   @   @  @ @   @     @     @    @    @    @   @         @       @       @       @    @  @ @
//   @   @   @@   @     @     @    @    @    @   @    @    @    @  @    @  @    @  @    @  @  @
//  @@@  @    @  @@@    @    @@@   @    @    @    @@@@      @@@@   @@@@@@   @@@@   @    @  @   @@
  
int usbtmc_initiate_clear( USB_DEVICE_INFO * udi, int dwFlags) 
{  
   USB_USBTMC_CLASS_STATUS * pusbtmcStatus = (USB_USBTMC_CLASS_STATUS *) &udi->usbtmcStatus;   
   USB_BULKRESPOND_STATUS * pBulkRespond = (USB_BULKRESPOND_STATUS*) &udi->BulkRespondStatus;   
   USB_EP_STATUS * eps = &udi->EP0Status;
   BYTE * pbRespondBytes = ( BYTE * ) eps->InPipe.pData;

   if( FLAG_USB_SETUPPACKET_RECIEVED & dwFlags ) 
   {
       if(pusbtmcStatus->USBTMC_InitiateRecieved == FALSE)
       {  
          //pbRespondBytes[0] = STATUS_SPLIT_NOT_IN_PROGRESS;
          //pusbtmcStatus->USBTMC_status = STATUS_SPLIT_NOT_IN_PROGRESS;
             
          // -- çàïðîñ òîëüêî ïðèøåë, ñòàâèì åãî â îæèäàíèå
          pusbtmcStatus->USBTMC_InitiateRecieved = TRUE;
          pusbtmcStatus->USBTMC_status = STATUS_PENDING;
          pbRespondBytes[0] = STATUS_SUCCESS;
               
          /* 30/08/18, ðåôàêòîðèíã.
             ïîñêîëüêó â ïðîãðàììå íå íàéäåíû âûçîâû îáðàáîò÷èêîâ usbtmc
             â îñíîâíîì ïîòîêå main(), ìåðà ïðåäîñòîðîæíîñòè îáðàáîòêè
             âûçîâà usbtmc_initiate_clear() ÷åðåç usbtmc_service èçëèøíÿÿ.
             Çàìåíèë âûçîâ -MACRO_FLAGSET_INITIATE_CLEAR()- íà ïðÿìîé
             âûçîâ usbtmc_initiate_clear(udi, 0)
             -- MACRO_FLAGSET_INITIATE_CLEAR(); --
          */
          eps->InPipe.dwLength = 1;
               
          usbtmc_initiate_clear(udi, 0);
               
       } 
       else ; // -- îòðàáîòàåò usbtmc_class_request_fault() 
       
   } 
   else
   {         
       usbtmc_bulkout_stall_and_abort ( udi );     // see USBTMC spec, rev 1.0, 2003, page 26, "4.2.1.6 INITIATE_CLEAR", last paragraph
              
       // =====================================================================
       // >>> Ïî÷åìó áóôåðû ÷èñòÿòñÿ äî âûçîâà usbtmc_abort_bulkin_transfer <<<
       // ---------------------------------------------------------------------
       //   / \    > Ïî ñïåöèôèêàöèè êàæäàÿ ïåðåäà÷à Bulk-In Äîëæíà çàêàí÷è-
       //  / | \   > âàòüñÿ short ïàêåòîì. Â ñîîòâåñòâèè ñ íåé, ñòð 28, òàáë. 34
       // /__*__\  > îïèñàíèå áàéòà bmClear, â î÷åðåäè äîëæåí íàõîäèòüñÿ short
       //          > ïàêåò, ïîêà õîñò åãî íå ïðî÷òåò. Âûçîâ ôóíöèè  
       // > usbtmc_abort_bulkin_transfer ìîæåò ïîñòàâèòü â î÷åðåäü íóëåâîé ïàêåò,
       // > êîòîðûé íåîáõîäèì äëÿ çàâåðøåíèÿ ïåðåäà÷è, à ÷èñòêà áóôåðîâ åãî 
       // > åãî óíè÷òîæèò. Ïîýòîìó, íóæíî ñíà÷àëà ïî÷èñèòü, à ïîòîì âûçâàòü
       // > ôóíêöèþ, êîòîðàÿ !ìîæåò áûòü! ïîñòàâèò â î÷åðåäü short ïàêåò.
       // ---------------------------------------------------------------------
       
       // íåîáõîäèìî Î×ÈÑÒÈÒÜ ÂÑÅ áóôåðû
       // ---------- Discard Last queued respond -----------------------------/
       /*----- Clear Buffer 1*/
       usb_lpc_cmd(CMD_EP_SELECT | USB_EP_PHY_ADDRESS_BULK_IN);
       usb_lpc_cmd(CMD_EP_CLEAR_BUFFER );
       /*----- Clear Buffer 2*/
       usb_lpc_cmd(CMD_EP_SELECT | USB_EP_PHY_ADDRESS_BULK_IN);
       usb_lpc_cmd(CMD_EP_CLEAR_BUFFER );   
       /*----- Clear Buffer 1*/
       usb_lpc_cmd(CMD_EP_SELECT | USB_EP_PHY_ADDRESS_BULK_OUT);
       usb_lpc_cmd(CMD_EP_CLEAR_BUFFER );
       /*----- Clear Buffer 2*/
       usb_lpc_cmd(CMD_EP_SELECT | USB_EP_PHY_ADDRESS_BULK_OUT);
       usb_lpc_cmd(CMD_EP_CLEAR_BUFFER );  
       
       // clear Bulk-IN transfer
       usbtmc_abort_bulkin_transfer( udi, FLAG_USBTMC_FORCE_BULKIN_ABORT );
       
       // clear Bulk-Out transfer for restore Bulk-Out syncronization
       // it is invoked in usbtmc_bulkout_stall() above
       // -- usbtmc_abort_bulkout_transfer ( udi, 0);

       eps->InPipe.dwLength = 1;
       if( pBulkRespond->INTransferInProgress == TRUE)
       {
           // see USBTMC spec, rev 1.0, 2003, page 27, table 32
           // íóæíî óíè÷òîæèòü âñå ïåðåäà÷è, âíå çàâèñèìîñòè îò òîãî, ïåðåäàí ëè short ïàêåò èëè íåò
           pusbtmcStatus->USBTMC_status = STATUS_SUCCESS;
           pbRespondBytes[0] = STATUS_SUCCESS; // -- çàïðîñ îáðàáîòàí       
       } 
       else 
       {   
           pusbtmcStatus->USBTMC_status = STATUS_SUCCESS; 
           pbRespondBytes[0] = STATUS_SUCCESS; // -- çàïðîñ îáðàáîòàí          
       }             
  }     
               
  return 0x00;  
}

//=========================================================================================================================



//=========================================================================================================================
//  @@@@  @    @  @@@@   @@@@  @    @         @@@@  @       @@@@   @@@@  @@@@@       
// @    @ @    @ @    @ @    @ @   @         @    @ @      @    @ @    @ @    @      
// @      @@@@@@ @@@@@@ @      @@@@          @      @      @@@@@@ @@@@@@ @@@@@       
// @      @    @ @      @      @  @          @      @      @      @    @ @ @         
// @    @ @    @ @    @ @    @ @   @         @    @ @    @ @    @ @    @ @  @        
//  @@@@  @    @  @@@@   @@@@  @    @         @@@@  @@@@@@  @@@@  @    @ @   @@      
       
int usbtmc_checkstatus_clear( USB_DEVICE_INFO * udi ) 
{  
   USB_USBTMC_CLASS_STATUS * pusbtmcStatus = (USB_USBTMC_CLASS_STATUS *) &udi->usbtmcStatus; 
   USB_BULKRESPOND_STATUS * pBulkRespond = (USB_BULKRESPOND_STATUS*) &udi->BulkRespondStatus;   
   USB_EP_STATUS * eps = &udi->EP0Status;
   BYTE * pbRespondBytes = ( BYTE * ) eps->InPipe.pData;
  
   if( pusbtmcStatus->USBTMC_InitiateRecieved == TRUE ) 
   {
       eps->InPipe.dwLength = 2;
       if( pBulkRespond->INTransferInProgress == TRUE ) 
       {
           pbRespondBytes[0] = pusbtmcStatus->USBTMC_status;
           pbRespondBytes[1] = (0x01 & (1<<0));   // -- bmClear.D0 = 0, see USBTMC spec, rev 1.0, 2003, page 29, table 34. 
       } 
       else 
       {
           pbRespondBytes[0] = pusbtmcStatus->USBTMC_status;
           pbRespondBytes[1] = (0x01 & (0<<0));   // -- bmClear.D0 = 0, see USBTMC spec, rev 1.0, 2003, page 29, table 34. 
       }
     
       pusbtmcStatus->USBTMC_InitiateRecieved = FALSE;     
   } 
   else 
   {
       pbRespondBytes[0] = STATUS_SPLIT_NOT_IN_PROGRESS;
       pbRespondBytes[1] = 0x00;
   }

   eps->InPipe.dwLength = 2;
   
   return 0x00;
}
 //=========================================================================================================================

//=========================================================================================================================
// #####    ####    ####   ####             #####  ######   ####   ######  #    #   #####          #####   #    #  ######   ####   
// #    #  #    #  #    #  #   #           #         #     #    #    #     #    #  #               #    #  #    #    #     #    #  
// #####   ######  ######  #    #          ######    #     ######    #     #    #  ######          #####    #  #     #     ######  
// # #     #       #    #  #    #               #    #     #    #    #     #    #       #          #   #     ##      #     #       
// #  #    #    #  #    #  #   #           #   #     #     #    #    #     #    #  #   #           #    #    ##      #     #    #  
// #   ##   ####   #    #  ####            ####     ###    #    #   ###     ####   ####            #####     ##     ###     ####   

#ifdef __SERIAL_POLL_SUPPORT__
int usbtmc_READ_STATUS_BYTE( USB_DEVICE_INFO * udi ){
  
 int rc = FALSE;

 struct _INTERRUPT_IN {
         BYTE bNotify1;
         BYTE bNotify2;
 } InterruptIn;
     
    USB_INTERRUPT_DISABLE_INTIN_NAK();
 
    InterruptIn.bNotify1 = 0x80;     //D7 must be 1,  see USB488 spec, rev 1.0, 2003, page 9, 3.4 Interrupt_IN, Table 6,7     
    InterruptIn.bNotify2 = _STB;   
  
    #ifdef __USBTMC_SERVICE_REQUEST_SUPPORT__
    // see USB488 spec, rev 1.0, 2003, page 9, 3.4 Interrupt_IN, Table      
    if( GPIB_GET_RQS() )  // GPIB_GET_RQS() gets RQS Bit from STB registers and DO not clears it!
    {
      InterruptIn.bNotify1 = 0x81; //  see USB488 spec, rev 1.0, 2003, page 9, 3.4 Interrupt_IN, Table 6 
                                // see USB488 spec, rev 1.0, 2003, page 9, 3.4 Interrupt_IN, text below Table 6 
      GPIB_CLR_RQS__();   // no state-machine state modify, clear ServiceRequestBit
    }  
    else
    #endif
    InterruptIn.bNotify1 |=udi->usbtmcGpib.StateMachine.bTag_Interrupt;
  


    // --------------- ïðîâåðÿåì ìîæåì ëè ïîëîæèòü â Interrupt Òî÷êó äàííûå --------------
    rc = usb_lpc_cmd_read( CMD_EP_SELECT | USB_EP_PHY_ADDRESS_INT_IN );
    rc = ( (rc & (1<<5))?FALSE:TRUE );    // return whether it is possible to queue bytes
    if( rc )
      {
        usb_ep_write( USB_EP_LOG_ADDRESS_INT_IN, (BYTE*)&InterruptIn, 2);
        rc = usb_lpc_cmd_read( CMD_EP_SELECT | USB_EP_PHY_ADDRESS_INT_IN );
        rc = ( (rc & (1<<5))?TRUE:FALSE );     // return result of queuing bytes 
      }
  return rc;  
}
#endif

int usbtmc_read_status_byte( USB_DEVICE_INFO * udi ) {
   
   USB_USBTMC_CLASS_STATUS * pusbtmcStatus = (USB_USBTMC_CLASS_STATUS *) &udi->usbtmcStatus;
   USB_EP_STATUS * eps = &udi->EP0Status;
   BYTE * pbRespondBytes = ( BYTE * ) eps->InPipe.pData;
   USB_SETUP_PACKET  * usp = &udi->EP0SetupPacket;
   USB_USBTMC_GPIBEMULATION_STATEMACHINE * pStateMachine = (USB_USBTMC_GPIBEMULATION_STATEMACHINE*) &(udi->usbtmcGpib.StateMachine);
   // ------------------------------------------------------------------------------------------- 
   pStateMachine->bTag_Interrupt = (0x7F & (usp->wValue)); // Prior to call usbtmc_READ_STATUS_BYTE_Interrupt()
   // -----------------------------------------------------------
    
    #ifdef __SERIAL_POLL_SUPPORT__ 
      // see USB488 spec, rev 1.0, 2003, page 13, 4.3.1.2

      if( usbtmc_READ_STATUS_BYTE(udi) == FALSE )
          pusbtmcStatus->USBTMC_status =  STATUS_INTERRUPT_IN_BUSY;
       else
          pusbtmcStatus->USBTMC_status = STATUS_SUCCESS;
      
      pbRespondBytes[2] = 0x00;     // STB will be returned in INTERRUPT IN  
    #else
      pbRespondBytes[2] = _STB;     // STB will be returned here, in Control Response Packet
      pusbtmcStatus->USBTMC_status = STATUS_SUCCESS;
    #endif


    // see USB488 spec, rev 1.0, 2003, page 13, table 12
    pbRespondBytes[0] = pusbtmcStatus->USBTMC_status;
    pbRespondBytes[1] = pStateMachine->bTag_Interrupt;   
    
    // -----------------------------------------------------------
    eps->InPipe.dwLength = 3;

   return 0x00;
}

//=========================================================================================================================
//=========================================================================================================================
//  @@@@    @@@@   @@@@@@           @@@@    @@@@   @@@@@    @@@@   @@@@@    @@@    @        @@@    @@@@@@   @@@@    @@@@@  
// @    @  @    @    @             @    @  @    @  @    @  @    @  @    @    @     @         @       @     @    @  @       
// @       @@@@@@    @             @       @@@@@@  @    @  @@@@@@  @@@@@     @     @         @       @     @@@@@@  @@@@@@  
// @  @@@  @         @             @       @    @  @@@@@   @    @  @   @     @     @         @       @     @            @  
// @    @  @    @    @             @    @  @    @  @       @    @  @    @    @     @    @    @       @     @    @  @   @   
//  @@@@    @@@@    @@@             @@@@   @    @  @       @    @  @@@@@    @@@    @@@@@@   @@@     @@@     @@@@   @@@@    

// see USBTMC spec, rev 1,0, 2003, page 28-29
int usbtmc_getcapabilites ( USB_DEVICE_INFO * udi ) {
   
   USB_USBTMC_CLASS_STATUS * pusbtmcStatus = (USB_USBTMC_CLASS_STATUS *) &udi->usbtmcStatus;   
   USB_EP_STATUS * eps = &udi->EP0Status;
   BYTE * pbRespondBytes = ( BYTE * ) eps->InPipe.pData;
  
 /*pbRespondBytes[0] = pusbtmcStatus->USBTMC_status;*/
   pbRespondBytes[0] = STATUS_SUCCESS; // fixed: 05/09/18, NiVisa warned VI_WARN_UNKNOWN_STATUS if this value is 0x00
   pbRespondBytes[1] = 0;   // reserved
   pbRespondBytes[2] = 0x01;   // BCD version number of the relevant USBTMC spec
   pbRespondBytes[3] = 0x00;   // ver 1.0
   
   // interface in not Listen-only and is not Talk-Only
   // interface not support INDICATOR_PULSE
   pbRespondBytes[4] = (0x07 & ((0<<USBTMC_SUPPORT__INDICATOR_PULSE) | (0<<USBTMC_SUPPORT__TALK_ONLY) | (0<<USBTMC_SUPPORT__LISTEN_ONLY)));
   
   // device not support TermChar
   pbRespondBytes[5] = (0x01 & (0<<USBTMC_SUPPORT__TERMCHAR));
   
   pbRespondBytes[6]  = 0x00; // reserved
   pbRespondBytes[7]  = 0x00; // reserved
   pbRespondBytes[8]  = 0x00; // reserved
   pbRespondBytes[9]  = 0x00; // reserved
   pbRespondBytes[10] = 0x00; // reserved
   pbRespondBytes[11] = 0x00; // reserved
     
   // ---- USB488 ---------------------
   // -- see USB488 spec, rev 1.0, 2003, page 10, table 8
   *( (unsigned short int *) &(pbRespondBytes[12]) ) = 0x0001;    // -- bcdUSB488 1.00  
       
    #ifdef __USBTMC_SERVICE_REQUEST_SUPPORT__
       #ifndef __SERIAL_POLL_SUPPORT__
         #error Íåâîçìîæíà ïîääåðæêà Service Request áåç ïîääåðæêè Serial Poll. 
         #error Îáúÿâèòå __SERIAL_POLL_SUPPORT__ â options.h
       #else
           // byte with offset 15:
           //                      D0 - DT0 Device Trigger
           //                      D1 - RL0 Remote Local
           //                      D2 - SR1 Service Request
           //                      D3 - Support SCPI
           pbRespondBytes[15] = 0x0F & ((1<<3) | (1<<2) | (0<<1) | (0<<0));
           
           // byte with offset 14:
           //                      D0 - Not support TRIGGER message
           //                      D1 - Not support GO_TO_LOCAL, REN_CONTROL, LOCAL_LOCKOUT
           //                      D2 - It is USB488 interface.
           pbRespondBytes[14] = 0x07 & ((1<<2) | (0<<1) | (0<<0));
           #pragma message(">>> USB488 compatibilites: IEEE 488.2 Interface <<<")
           #pragma message(">>> USB488 compatibilites: SCPI Commands are supported <<<")
           #pragma message(">>> USB488 compatibilites: Service Request are supported <<<")
       #endif
    #else
     // byte with offset 15:
     //                      D0 - DT0 Device Trigger
     //                      D1 - RL0 Remote Local
     //                      D2 - SR0 Service Request
     //                      D3 - Not Support SCPI
     pbRespondBytes[15] = 0x0F & ((0<<3) | (0<<2) | (0<<1) | (0<<0));
     
     // byte with offset 14:
     //                      D0 - Not support TRIGGER message
     //                      D1 - Not support GO_TO_LOCAL, REN_CONTROL, LOCAL_LOCKOUT
     //                      D2 - It is  USB488 interface, but SR1 not supported, SCPI not supported
     pbRespondBytes[14] = 0x07 & ((1<<2) | (0<<1) | (0<<0)); 
       #pragma message(">>> USB488 compatibilites: IEEE 488.2 Interface <<<")
       #pragma message(">>> USB488 compatibilites: NOT Support SCPI <<<")
       #pragma message(">>> USB488 compatibilites: NOT Support Service Request <<<")
     
    #endif
     
     
     pbRespondBytes[16] = 0x00; // USB488 Reserved
     pbRespondBytes[17] = 0x00; // USB488 Reserved
     pbRespondBytes[18] = 0x00; // USB488 Reserved
     pbRespondBytes[19] = 0x00; // USB488 Reserved
     pbRespondBytes[20] = 0x00; // USB488 Reserved
     pbRespondBytes[21] = 0x00; // USB488 Reserved
     pbRespondBytes[22] = 0x00; // USB488 Reserved
     pbRespondBytes[23] = 0x00; // USB488 Reserved
     

     eps->InPipe.dwLength = 24; 
   
     return 0x00;
}

//=========================================================================================================================
//  @@@    @    @  @@@@     @@@     @@@@    @@@@   @@@@@@   @@@@   @@@@@           @@@@@   @    @  @        @@@@@   @@@@   
//   @     @@   @  @   @     @     @    @  @    @    @     @    @  @    @          @    @  @    @  @       @       @    @  
//   @     @ @  @  @    @    @     @       @@@@@@    @     @    @  @@@@@           @    @  @    @  @       @@@@@@  @@@@@@  
//   @     @  @ @  @    @    @     @       @    @    @     @    @  @ @             @@@@@   @    @  @            @  @       
//   @     @   @@  @   @     @     @    @  @    @    @     @    @  @  @            @       @    @  @    @  @   @   @    @  
//  @@@    @    @  @@@@     @@@     @@@@   @    @   @@@     @@@@   @   @@          @        @@@@   @@@@@@  @@@@     @@@@   
//=========================================================================================================================

int usbtmc_indicator_pulse ( USB_DEVICE_INFO * udi )
{
    // -- Request "INDICATOR_PULSE" is not supported.
    // see USBTMC spec, rev 1.0, 2003, page 29, table 37, decription of byte with offset 4, bit D2.
    // Control-IN -> STALL

    usb_stall_ep( 0x01, TRUE );
    
    return 0x00;
}
//=========================================================================================================================


//=========================================================================================================================
// @@@@@    @@@@   @@@@@    @@@@@   @@@@           @@@@@   @    @  @       @    @          @    @   @@@@    @@@@@   @@@@@   @@@@    @@@@    @@@@   
// @    @  @    @  @    @  @       @    @          @    @  @    @  @       @   @           @@  @@  @    @  @       @       @    @  @    @  @    @  
// @    @  @@@@@@  @@@@@   @@@@@@  @@@@@@          @@@@@   @    @  @       @@@@            @ @@ @  @@@@@@  @@@@@@  @@@@@@  @@@@@@  @       @@@@@@  
// @@@@@   @    @  @ @          @  @               @   @   @    @  @       @  @            @    @  @            @       @  @    @  @  @@@  @       
// @       @    @  @  @    @   @   @    @          @    @  @    @  @    @  @   @           @    @  @    @  @   @   @   @   @    @  @    @  @    @  
// @       @    @  @   @@  @@@@     @@@@           @@@@@    @@@@   @@@@@@  @    @          @    @   @@@@   @@@@    @@@@    @    @   @@@@    @@@@   
//
// Ïàðàìåòð  bCheckDataStage:
// Ïðîòîêîë USBTMC ñîäåðæèò 4 îñíîâíûõ êîììàíäû: DEV_DEP_MSG_OUT, VENDOR_SPECIFIC_OUT,  REQUEST_DEV_DEP_MSG_IN, REQUEST_VENDOR_SPECIFIC_IN
// DEV_DEP_MSG_OUT, VENDOR_SPECIFIC_OUT ïðåäïîëàãàþò ñòàäèþ äàííûõ â Bulk-Out, òîåñòü óñòðîéñòâî ïðèíèìàåò TransferSize áàéò
// REQUEST_DEV_DEP_MSG_IN, REQUEST_VENDOR_SPECIFIC_IN æå ïðåäïîëàãàþò ñòàäèþ äàííûõ â Bulk-IN, òîåñòü óñòðîéñòâî íå ïðèíèìàåò, à ïåðåäàåò TransferSize áàéò
// Ïðè ïðèåìå êîììàíäû Bulk-Out òðåáóåòñÿ òî÷íî îïðåäåëèòü, ñêîëüêî äàííûõ áóäåò ïåðåäàíî, òîåñòü êîãäà çàâåðøàòü ïåðåäà÷ó è ðàññìàòðèâàòü ñëåäóþùóþ ïîðöèþ
// äàííûõ êàê íîâóþ ïåðåäà÷ó. Äëÿ ýòîãî è ñëóæèò ïîëå TransferSize. Îäíàêî â äâóõ çàïðîñàõ REQUEST_DEV_DEP_MSG_IN, REQUEST_VENDOR_SPECIFIC_IN ýòî
// ïîëå ó÷èòûâàòü íå íóæíî, òàê êàê îíî èìååò ïðîòèâîïîëîæíûé ñìûñë. Äëÿ îïðåäåëåíèÿ, ó÷èòûâàòü èëè íå ó÷èòûâàòü TransferSize ââåäåí ïàðàìåòð bCheckDataStage
// Ïðèíèìàÿ çàïðîñ è îïðåäåëèâ, ÷òî ýòî çàãîëîâîê, íóæíî âûçâàòü ôóíêöèþ usbtmc_parse( ..., TRUE ), ôóíêöèÿ âåðíåò TRUE, åñëè ýòî ïîòîê
// Host->Device ( DEV_DEP_MSG_OUT, VENDOR_SPECIFIC_OUT ) èëè FALSE, åñëè TransferSize îïðåäåëÿåò, ñêîëüêî äàííûõ òðåáóåòñÿ ïðî÷èòàòü èç óñòðîéñòâà Device->Host (REQUEST_DEV_DEP_MSG_IN, REQUEST_VENDOR_SPECIFIC_IN)
// Ôóíêöèÿ, ïðèíÿâ TRUE â bCheckDataStage çàâåðøèòñÿ íåìåäëåííî, íå îáðàáàòûâàÿ çàïðîñ
int usbtmc_parse( USB_DEVICE_INFO * udi, BOOL bCheckDataStage )
{
   USB_BULKMESSAGE_STATUS * pBulkMessage = (USB_BULKMESSAGE_STATUS*) &udi->BulkMessageStatus;
   int rc = FALSE;
   //----------------------------------------------------------------------------------------
   switch( pBulkMessage->MsgID )
   {    
      // DEV_DEP_MSG_OUT
      // Host sent a message to the device
      // The message length: TransferSize ( size of Bulk-Out transaction )
      case DEV_DEP_MSG_OUT:                                    
      {  
             // Process the flag: @bCheckDataStage
             // It is dummy call to identify the direction
             if( bCheckDataStage ) return (TRUE);      
             
             // identify a transfer that sends a USBTMC device dependent
             // command message from the Host to a device
             rc = usbtmc_DEV_DEP_MSG_OUT( udi );                                                                 
      }       
      break;
      
      // REQUEST_DEV_DEP_MSG_IN
      // Device responds to the host
      // Maximum Bulk-IN transaction size is @TransferSize
      case REQUEST_DEV_DEP_MSG_IN:
      {  
             // Process the flag: @bCheckDataStage
             // It is dummy call to identify the direction
             if( bCheckDataStage == TRUE ) return (FALSE); 
             
             // identify the transfer as a USBTMC command  message to the device, 
             // allowing the device to send a USBTMC response message containing 
             // device dependent message data bytes  
             rc = usbtmc_REQUEST_DEV_DEP_MSG_IN( udi );                                                        
      }       
      break; 
      
      //
      // VENDOR_SPECIFIC_OUT
      // Host sent a vendor specific message to the device
      case VENDOR_SPECIFIC_OUT:                               
      {  
             // Process the flag: @bCheckDataStage
             // It is dummy call to identify the direction
             if( bCheckDataStage == TRUE ) return (TRUE);      
                                               
             rc = FALSE; // not supported
      }       
      break;
      
      //
      // VENDOR_SPECIFIC_OUT
      // Host requests answer on vendor specific message from device
      case REQUEST_VENDOR_SPECIFIC_IN:
      {  
             // Process the flag: @bCheckDataStage
             // It is dummy call to identify the direction
             if( bCheckDataStage == TRUE ) return (FALSE);
                                             
             rc = FALSE; // not supported 
      }   
      break;
      
      case TRIGGER:
             rc = FALSE; // not supported 
      break;
      
      default:;
             rc = FALSE; // not supported 
  }
  
  return rc;
}

//=========================================================================================================================


//=========================================================================================================================
// @@@@@    @@@@   @@@@@    @@@@@   @@@@            @@@@   @@@@@@  @@@@@   @               @@@@@    @@@@    @@@@   
// @    @  @    @  @    @  @       @    @          @    @    @     @    @  @               @    @  @    @  @    @  
// @    @  @@@@@@  @@@@@   @@@@@@  @@@@@@          @         @     @@@@@   @               @@@@@   @@@@@@  @    @  
// @@@@@   @    @  @ @          @  @               @         @     @ @     @               @ @     @       @  @ @  
// @       @    @  @  @    @   @   @    @          @    @    @     @  @    @    @          @  @    @    @  @   @   
// @       @    @  @   @@  @@@@     @@@@            @@@@    @@@    @   @@  @@@@@@          @   @@   @@@@    @@@ @  
BOOL usbtmc_class_request(USB_DEVICE_INFO * udi) 
{
   BOOL rc = FALSE;
   
   USB_USBTMC_CLASS_STATUS * pusbtmcStatus = (USB_USBTMC_CLASS_STATUS *) &udi->usbtmcStatus;   
   USB_SETUP_PACKET  * usp = &udi->EP0SetupPacket;

   // -- ïðîâåðÿåì, íóæíî ëè îáðàáàòûâàòü çàïðîñ.
   // -- åñëè èíèöèðîâàí çàïðîñ INITIATE, çàïðîñ ðàññìàòðèâàåòñÿ êàê non operate, ñîãëàñíî äîêóìåíòàöèè
   // -- see USBTMC spec, rev 1.0, 2003, page 20-21 "a","b","c"
   // See USBTMC spec, rev 1.0, 2003, 4.2.1.1, "USBTMC split transactions"
   if(    (TRUE == pusbtmcStatus->USBTMC_InitiateRecieved) 
       && (CHECK_ABORT_BULK_IN_STATUS != usp->bRequest) 
       && (CHECK_ABORT_BULK_OUT_STATUS != usp->bRequest) 
       && (CHECK_CLEAR_STATUS != usp->bRequest)
     )
   {  
      rc = usbtmc_class_request_fault( udi );
   }   
   else
   {  
      // Processing USBTMC Class requests, see "USBTMC spec., rev. 1.0, 2003", 4.2.1, "USBTMC requests"
      switch(usp->bRequest)
      {  
               
         case INITIATE_ABORT_BULK_OUT:
              usbtmc_abort_bulkout_transfer ( udi, FLAG_USB_SETUPPACKET_RECIEVED );
              rc = TRUE;
         break;
                 
         case CHECK_ABORT_BULK_OUT_STATUS:
              usbtmc_checkstatus_abort_bulkout( udi );                                  
              rc = TRUE;
         break;
         case INITIATE_ABORT_BULK_IN:   
              usbtmc_abort_bulkin_transfer ( udi, FLAG_USB_SETUPPACKET_RECIEVED );
              rc = TRUE;
         break;
         case CHECK_ABORT_BULK_IN_STATUS: 
              usbtmc_checkstatus_abort_bulkin( udi );  
              rc = TRUE;
         break;
         case INITIATE_CLEAR:          
              usbtmc_initiate_clear( udi, FLAG_USB_SETUPPACKET_RECIEVED );
              rc = TRUE;
         break;
         case CHECK_CLEAR_STATUS:  
              usbtmc_checkstatus_clear( udi );
              rc = TRUE;
         break;              
         case GET_CAPABILITES:   
              usbtmc_getcapabilites( udi );
              rc = TRUE;
         break;
         case READ_STATUS_BYTE:
              usbtmc_read_status_byte( udi );
              rc = TRUE;
         break;
         case INDICATOR_PULSE:   
              rc = usbtmc_indicator_pulse( udi ); // see USBTMC spec, rev 1.0, 2003, page29, table 37, desc. of byte with offset 4,  bit D2
         break; 
         
         case GO_TO_LOCAL:     
         case LOCAL_LOCKOUT:  
         case REN_CONTROL:
              usb_stall_ep( 0x01, TRUE );   // not support, -> stall
              rc = FALSE;         
         break;
         
         default:
         // see USB 2.0 spec, page 256, 9.4.5, last paragaph, "device need not return STALL for class-specific and vendor-specific requests."
         // see USB 2.0 spec, 9.2.7: It is preferred that the STALL PID be returned at the next Data stage transaction, as this avoids unnecessary bus activity
         // "preferred" - ïðåäïî÷òèòåëüíî, íî íå îáÿçàòåëüíî
         //         
         // rc = FALSE; // STALL, see USB 2.0 spec, page 252, "9.4 Standard Device Requests"         
         rc = TRUE; // No STALL           
      }           
   }
   return rc;
}   

//- ---------------------------------------------------------------------------------------------------------------------------------
int usbtmc_class_request_fault ( USB_DEVICE_INFO * udi )
{ 
   // -- usbtmc_request_fault - îáðàáîò÷èê çàïðîñà êàê non-operation çàïðîñà.
   USB_USBTMC_CLASS_STATUS * pusbtmcStatus = (USB_USBTMC_CLASS_STATUS *) &udi->usbtmcStatus;   
   USB_EP_STATUS * eps = &udi->EP0Status; 
   BYTE * pbRespondBytes = ( BYTE * ) eps->InPipe.pData;
  
   if( pusbtmcStatus->USBTMC_InitiateRecieved==TRUE )
   {
      pbRespondBytes[0] = STATUS_SPLIT_IN_PROGRESS;
      pbRespondBytes[1] = 0x00; // -- íå âàæíî, see USBTMC spec, rev 1.0, 2003, page 19, after table 16, "A response with ...", "Host MUST ignore " ... "all response bytes"
      eps->InPipe.dwLength = 2;
   }
   
   return TRUE; 
}

//=========================================================================================================================
int usbtmc_DEV_DEP_MSG_OUT ( USB_DEVICE_INFO * udi )
{
   int rc = FALSE;
   USB_BULKRESPOND_STATUS * pBulkRespond        = (USB_BULKRESPOND_STATUS*) &udi->BulkRespondStatus;
   BYTE                   * pBulkData_DeviceIn  = (BYTE*)                    udi->BulkMessageStatus.pData; // óêàçàòåëü íà ïðèíÿòûå äàííûå. äàííûå ìîãóò ëåæàòü êàê â áóôåðå EP òàê è â îáùåì áóôåðå
   
   // -----------------------------------------------------------------------------------------------------------------------------------------------------------------
   // Õîñò èíèöèðóåò DEV_DEP_MSG_OUT. Ðàçìåð ïåðåäà÷è ýòîãî çàïðîñà ìîæåò áûòü áîëüøå
   // áóôåðà êîíå÷íîé òî÷êè, è òîãäà äàííûå íóæíî êåøèðîâàòü. Êåøèðîâàíèå ïðîèñõîäèò
   // â åäèíñòâåííûé áóôôåð, â 1,5Êá, àäðåñ get_addr_in_buffer(). Äåëàåòñÿ äîïóùåíèå,
   // ÷òî êîãäà õîñò èíèöèðóåò REQUEST_DEV_DEP_MSG_IN, ýòîò áóôåð íå ïîíàäîáèòñÿ, ïîñêîëüêó
   // â íåì óæå ëåæàò ïîäãîòîâëåííûå äàííûå äëÿ îòâåòà íà çàïðîñ DEV_DEP_MSG_OUT. 
   
   // Îäíàêî åñëè ïðèäåò íåñêîëüêî êîììàíä â îäíîé ñòðîêå, âûçîâû íàçíà÷åííûõ íà êîììàíäó
   // ôóíêöèé èçìåíÿò ñîäåðæèìîå áóôåðà pBulkData_DeviceIn îáðàùàÿñü ê íåìó êàê
   // ê óêàçàòåëþ íà çàãîëîâîê BULKIN, áóäóò êåøèðîâàòü îòïðàâëÿåìûå äàííûå â íåãî
   // Âîáùåì, ñòðîêà êîììàíä áóäåò ïîâðåæäåíà. ×òîáû ýòîãî èçáåæàòü, GPIB_CommandExecute
   // êåøèðóåò ñòðîêó êîììàíä íà âðåìÿ ðàçáîðà.
  
   // ---------------------------------------------
   // èíèöèàëèçàöèÿ ïåðåäà÷è
   usbtmc_init_intransfer_newcmd( udi );
   // ---------------------------------------------
   // ïåðåä âûïîëíåíèåì GPIB ôóíêöèè  íåëüçÿ óäàëÿòü êîíòåêñò, 
   // âåäü ñëåä êîììàíäà ( cmd1;cmd2 ) ìîæåò åãî è íå èñïîëüçóåò, à òåêóùàÿ (cmd1) íå óñïååò ïåðåäàòü äàííûå
   usbtmc_delete_function_context( udi );       
   // ----------------------------------------------------------------------------------------------------------------------------
   // âûçûâàåì îáðàáîò÷èê êîììàíä SCPI
   if( 0 <= GPIB_CommandExecute( udi, pBulkData_DeviceIn ) )  
   { 
      //  òóò ïðîèçîøëî ïðåîáðàçîâàíèå â ÂÅÐÕÍÈÉ ÐÅÃÈÑÒÐ!!!
      rc = TRUE;

      // -------------------------------------------------------------------
      // See USB488, rev 1.0, 2003, page 13, 4.3.1.3 Status byte MAV bit
      if( pBulkRespond->dwDeviceOut > 0 ) GPIB_SET_MAV(); 
      // -- óñòàíàâëèâàåì Message Available áèò åñëè åñòü ÷òî îòâåòèòü                                         
      // -------------------------------------------------------------------
   }
   else
   {  
      rc = FALSE; // êàêàÿ-òî îøèáêà
   }     

   return rc;
}

// =========================================================================================================================================
int usbtmc_REQUEST_DEV_DEP_MSG_IN ( USB_DEVICE_INFO * udi )    {
  int rc = FALSE;
//  USB_USBTMC_CLASS_STATUS * pusbtmcStatus   = (USB_USBTMC_CLASS_STATUS *) &udi->usbtmcStatus;
  USB_EP_STATUS          * bulk_endpoint    = (USB_EP_STATUS*)            &udi->EPBulkStatus;  
  USB_PIPE_ENTRY_IN      * pInPipe          = (USB_PIPE_ENTRY_IN*)        &bulk_endpoint->InPipe;
  USB_BULKMESSAGE_STATUS * pBulkMessage     = (USB_BULKMESSAGE_STATUS*)   &udi->BulkMessageStatus;
  USB_BULKRESPOND_STATUS * pBulkRespond     = (USB_BULKRESPOND_STATUS*)   &udi->BulkRespondStatus;
  BULKIN_HEADER          * pBulkInHeader    = (BULKIN_HEADER*)             pInPipe->pData;
  BYTE                   * pData            = (BYTE*)                      pInPipe->pData + sizeof(BULKIN_HEADER); // pdata !!!
  // -------------------------------------------------------------------------------------------------------------------------------------
  // ============== INITIALIZE RESPOND ===============
       pInPipe->dwLength = 0;
  pBulkRespond->nBytesSent = 0;  // îáíóëÿåì ñòàòèñòèêó îòïðàâëåííûõ áàéò
  pBulkRespond->bTag =  pBulkMessage->bTag;
  pBulkRespond->MsgID = DEV_DEP_MSG_IN;
  pBulkRespond->INTransferInProgress = TRUE; // see USBTMC spec, rev 1.0, 2003, page 12, point 5     
  // íóæíî: ïðèìåð: õîñò ïîñëàë DEV_DEP_MSG_OUT à ïîòîì ïåðåäóìàë è ðåøèë ïðåðâàòü çàïðîñ BulkIN, äàæå íå íà÷àâ ÷èòàòü!
  //-----------------------------------------------------

  // WARNING! 29/08/18
  // Ïðè âêëþ÷åíèè îïòèìèçàöèè êîìïèëÿòîð ìîæåò çàìåíèòü âûçîâ
  // memset() íà ïîñëåäîâàòåëüíîñòü èíñòðóêöèé áûñòðîé î÷èñòêè
  // ïàìÿòè íà îñíîâå èíñòðóêöèè STM, êîòîðàÿ òðåáóåò, ÷òîáû
  // àäðåñ áûë âûðîâíåí íà 4. Ò.ê. óêàçàòåëü pBulkInHeader
  // áûë ïîëó÷åí ïðåîáðàçîâàíèåì òèïà èç pData òèïà uint8_t,
  // òî è ïîëó÷åííûé óêàçàòåëü ìîæåò îêàçàòüñÿ íåâûðîâíåí íà 4.
  // Îäíàêî ïîñëå êàñòèíãà ê òèïó BULKIN_HEADER* êîìïèëÿòîð ïðî
  // ýòî "çàáûâàåò" è ñ÷èòàåò àäðåñ @pBulkInHeader âûðîâíåííûì.
  // Íà íåêîòîðîì óðîâíå îïòèìèçàöèè ïðèâåäåò ê HardFault,
  // ò.ê. êîìïèëÿòîð ïî ïðàâó ñ÷èòàåò @pBulkInHeader ÷åñòíûì
  // àäðåñîì íà âûðîâíåííóþ ñòðóêòóðó è âñòàâëÿåò èíñòðóêöèþ STM
  // (STM R6!, {R0-R2}, ãäå R0..R2 = 0x00000000 )
  // ×ÒÎÁÛ èçáåæàòü òàêîãî ïîâåäåíèÿ, òðåáóåòñÿ ÎÁÐÀÒÍÎ ñêàñòèòü
  // óêàçàòåëü @pBulkInHeader ê òèïó uint8_t, ÷òîáû ó êîìïèëÿòîðà
  // íå âîçíèêàëà ñîáëàçíà ïðîâåðíóòü âûøåîïèñàííûé òðþê.
  // Ïðè áàíàëüíîì (BYTE*)pBulkInHeader ïîëó÷åííûé óêàçàòåëü óæå
  // íå ñ÷èòàåòñÿ âûðîâíåííûì íà 4, è âûçîâ memset() áóäåò íåëüçÿ
  // çàìåíèòü íà STM-èíñòðóêöèþ, è êîìïèëÿòîðó ïðèäåòñÿ ñäåëàòü
  // âûçîâ memclr(), ÷òî óæå íå ïðèâåäåò ê îøèáêå.
  // Òàêèå äåëà. 
  memset( (BYTE*) /* ïðîáëåìû ñ îïòèìèçàöèåé: ÍÓÆÍÎ ÎÁßÇÀÒÅËÜÍÎ ÊÀÑÒÈÒÜ Ê ÒÈÏÓ uint8_t !!!! */
          pBulkInHeader, 0x00, sizeof(BULKIN_HEADER) );

  // =============== DEFAULT ====================
  pBulkInHeader->MsgID = pBulkRespond->MsgID;
  pBulkInHeader->bTag =    pBulkRespond->bTag;         // -- must match with bTag in last message
  pBulkInHeader->bTagInverse =  ~pBulkInHeader->bTag;
  
  // TransferSize èíèöèàëèçèðîâàíà â DEV_DEP_MSG_OUT

  // ------------------------------------------------------
  rc = TRUE;
  // ------------------------------------------------------
  
  // Êîãäà ïðèõîäèò DEV_DEP_MSG_OUT äàííûå, êîòîðûå íóæíî îòïðàâèòü â îòâåò
  // ñêëàäûâàþòñÿ â âûõîäíîé áóôåð ñî ñìåùåíèåì â sizeof(BULKIN_HEADER)
  // â REQUEST_DEV_DEP_MSG_OUT ìîäèôèöèðóåòñÿ ëèøü HEADER, è îòïðàâëÿåòñÿ îòâåò
  // Ýòî äîñòèãàåòñÿ çà ñ÷åò ðàçíåñåíèÿ áóôåðîâ ïðèåìà êîììàíä DEV_DEP_MSG_OUT 
  // è REQUEST_DEV_DEP_MSG_OUT.
  //----------------------------------------------------- 
  {
    // õîñò ïðèñëûàåò â Bulk-Out çàãîëîâêå ðàçìåð ïåðåäà÷è TransferSize
    // äëÿ çàïðîñà REQUEST_DEV_DEP_MSG_IN ýòî ÷èñëî îïðåäåëÿåò êîëè÷åñòâî äàííûõ
    // êîòîðûå òðåáóåòñÿ ïðî÷èòàòü èç óñòðîéñòâà. Ñâûøå ýòîãî ÷èñëà îòïðàâëÿòü íåëüçÿ
 
    USB_INTERRUPT_ENABLE_BULKIN_NAK();

    
    if(pBulkRespond->bIsLastTransfer == TRUE && pBulkRespond->dwDeviceOut > pBulkRespond->InTransferSize)
    pBulkRespond->bIsLastTransfer = FALSE;
  
    // ------------------------------------------------------------------------------------------------------
    // Is it the last transfer?
    if( pBulkRespond->bIsLastTransfer == TRUE )
    {  
        // Yes, it is the last transfer
      
        // Is anything to send?
        if( 0 == pBulkRespond->dwDeviceOut )
        {
            // No.
          
            // IEEE 488.2, 11.5.1.1.7 Bit 2 — Query ERROR (QYE)
            // An attempt is being made to read data from the Output Queue when no output is either present or pending
          
            if( pBulkRespond->bEndOfMessage )
            {
               // this is the last read event of long transfer
               // ignore this read
               (void)pBulkRespond->bEndOfMessage;
            }
            else
            GPIB_SET_QRE();
        }
        
        pData[pBulkRespond->dwDeviceOut++] = '\n';        
    }  
    // ------------------------------------------------------------------------------------------------------

    // ---------------------------------------------------------------------------------------------------------
    pBulkInHeader->stRespondMessage.TransferSize = MIN(pBulkRespond->dwDeviceOut, pBulkRespond->InTransferSize);
    // ---------------------------------------------------------------------------------------------------------

    // ----------------------------------------------------------------------------
    pBulkRespond->dwDeviceOut+=sizeof(BULKIN_HEADER); // äëÿ óïðîùåíèÿ ó÷åòà äàííûõ
    // ----------------------------------------------------------------------------

    // -----------------------------------------------------------------------------------------
    pInPipe->dwLength    = sizeof(BULKIN_HEADER) + pBulkInHeader->stRespondMessage.TransferSize;
    // -----------------------------------------------------------------------------------------
    
   // -----------------------------------------------------------------
   //   Óñòàíîâêà àòòðèáóòà End Of Message (EOM) â BULKIN çàãîëîâêå
   if( pBulkRespond->bIsLastTransfer == TRUE)
       pBulkInHeader->stRespondMessage.bmTransferAttributes |= (1<<0);     
   //   Åñëè ôóíêöèÿ íå ñáðîñèëà bIsLastTransfer, òî ïåðåäà÷à ñ÷èòàåòñÿ ïîñëåäíåé            
   else
       pBulkInHeader->stRespondMessage.bmTransferAttributes &= ~(1<<0);   
   // -----------------------------------------------------------------
  } 
      
  return rc;
}
// ==========================================================================================================================================

// ==========================================================================================================================================
void usbtmc_flush_buffer( TENDPOINT_LOG_ADDRESS apropriate_endpoint, USB_PIPE_ENTRY * pipe_entry )
{
   switch( apropriate_endpoint )
   {
      case USB_EP_LOG_ADDRESS_BULK_OUT:
      {  
          if( pipe_entry->pDefaultBuffer == gEP2BufOutExpand ) 
            s_memset( (BYTE*)gEP2BufOutExpand, 0x00, USB_MAX_BULKOUT_BUFFERSIZE );
      } 
      break;
      
      case USB_EP_LOG_ADDRESS_BULK_IN:
      {  
          if( pipe_entry->pDefaultBuffer == gEP2BufInExpand ) 
            s_memset( (BYTE*)gEP2BufInExpand, 0x00, USB_MAX_BULKIN_BUFFERSIZE );
      }    
      break;
   }
}
// ==========================================================================================================================================
void usbtmc_init_intransfer( USB_DEVICE_INFO * udi )
{
   USB_EP_STATUS          * bulk_endpoint    = (USB_EP_STATUS*)            &udi->EPBulkStatus;  
   USB_PIPE_ENTRY_IN      * pPipeIn          = (USB_PIPE_ENTRY_IN*)        &bulk_endpoint->InPipe;
   USB_BULKRESPOND_STATUS * pBulkRespond     = (USB_BULKRESPOND_STATUS*)   &udi->BulkRespondStatus;
   BULKIN_HEADER          * pBulkInHeader    = (BULKIN_HEADER*)             pPipeIn->pDefaultBuffer;
   GPIB_COMMAND_TREE      * pGpib            = (GPIB_COMMAND_TREE*)        &udi->usbtmcGpib;
   // -------------------------------------------------------------------------------------------------------------------------
  
   // -------------------------------------------------------------------------------------------------------------------------
   pPipeIn->pData = pPipeIn->pDefaultBuffer;           // óêàçûâàåì áóôåð äëÿ ïåðåäà÷è

   pBulkInHeader->stRespondMessage.TransferSize = 0;   // îáíóëÿåì ðàçìåð ïåðåäà÷è

   pGpib->pData = pPipeIn->pData + sizeof(BULKIN_HEADER);  // óêàçûâàåì íà÷àëî áóôåðà äëÿ ñêëàäûâàíèÿ îòâåòîâ íà êîììàíäû    

   pBulkRespond->bIsLastTransfer   = TRUE;             // ñ÷èòàåì ñîîáøåíèå êîðîòêèì (â îäíó Transfer )               
   // óñòàíàâëèâàåì ìàêñèìàëüíîå êîëè÷åñòâî äàííûõ, êîòîðîå ìîæíî çàïèñàòü â âûõîäíîé áóôåð
   pBulkRespond->RespondBufferSize = USB_MAX_BULKIN_BUFFERSIZE - sizeof(BULKIN_HEADER);
   pBulkRespond->dwDeviceOut       = 0;
}

void usbtmc_init_intransfer_newcmd( USB_DEVICE_INFO * udi ) 
{
   USB_EP_STATUS          * bulk_endpoint    = (USB_EP_STATUS*)            &udi->EPBulkStatus;  
   USB_BULKRESPOND_STATUS * pBulkRespond     = (USB_BULKRESPOND_STATUS*)   &udi->BulkRespondStatus;

   if( pBulkRespond->dwDeviceOut > 0 )
   {
       /*  IEEE 488.2, 11.5.1.1.7 Bit 2 — Query ERROR (QYE)
        Query Errors are detected by the Output Queue Control, see 6.1.10. This event bit indicates that either
          1) An attempt is being made to read data from the Output Queue when no output is either present or pending, or
        > 2) Data in the Output Queue has been lost.
        See 6.5.7 for a complete description.
          The Query Error bit shall not be set to report any other condition. Events that generate Query Errors shall not also
          generate Execution Errors, Command Errors, or Device-Specific Errors.
       */
       // The device already has some bytes of respond.
       // This call will make the device to lost the respond.
       // In this case the Query Error bit should be set in Event Status Register
       GPIB_SET_QRE();
   }
   // -------------------------------------------------------------------------------------------------------------------------
   usbtmc_init_intransfer( udi );
}
#endif