Lemz_SwCtrlStmProj/App/usbtmc/endpoints.c

#include <string.h>
#include "lpc176x.h"
#include "hal.h"
#include "main.h"
#include "usb_hardware.h"

#ifdef USBTMC // #endif â êîíöå ôàéëà

#define _ENDPOINTS_C_
#include "endpoints.h"
#include "usb_application.h"
#include "usb_proto.h"
#include "usbtmc.h"

const BYTE abDescriptors_USBTMC[] =
{

  // =======================================================================================
  // ============================ Device descriptor ========================================
  // =======================================================================================
                              // ---------------------------------------------------------------------- 
                              // # bLength 
                                sizeof(USB_DEVICE_DESCRIPTOR),  
                              // ---------------------------------------------------------------------- 
                              // # bDescriptorType
                                USB_DESCR_TYPE_DEVICE,   
                              // ----------------------------------------------------------------------
                              // # bcdUSB
                                 TWOBYTES_LE(0x0200),    //-- bcdUSB    2.00
                              // ---------------------------------------------------------------------- 
                              // # bDeviceClass          // bDeviceClass    >> ïî USBTMC âñåãäà 0x00
                                 0x00, 
                              // ----------------------------------------------------------------------    
                              // # bDeviceSubClass       // bDeviceSubClass >> ïî USBTMC âñåãäà 0x00
                                 0x00,    
                              // ----------------------------------------------------------------------    
                              // # bDeviceProtocol       // bDeviceProtocol >> ïî USBTMC âñåãäà 0x00
                                 0x00,       
                              // ----------------------------------------------------------------------    
                              // # bMaxPacketSize äëÿ EP0, äëÿ USB 2.0 âñåãäà 64
                                 USB_MAX_PACKET0,             
                              // ---------------------------------------------------------------------- 
                              // # idVendor - Planar
                                 TWOBYTES_LE(0x2226),          
                              // ----------------------------------------------------------------------    
                              // # idProduct - Auto Calibration Module SCPI
                                 TWOBYTES_LE(0x000F), 
                              // ----------------------------------------------------------------------    
                              // # bcdDevice     1.00
                                 TWOBYTES_LE(0x0100),   
                              // ----------------------------------------------------------------------    
                              // # iManufacturer  - index of string 1
                                 2,                   
                              // ----------------------------------------------------------------------    
                              // # iProduct       - index of string 2
                                 1,   
                              // ----------------------------------------------------------------------    
                              // # iSerialNumber  - index of string 3
                                 4,
#warning Íóæåí óíèêàëüíûé iSerialNumber, à íå 00000000. USBTMC spec, see 5.1 Device Descriptor Table 40 -- Device Descriptor
                              // ---------------------------------------------------------------------    
                              // # bNumConfigurations
                                 1,                              

  // =======================================================================================
  // ============================ Configuration descriptor =================================
  // =======================================================================================

                              // # bLength
                                 sizeof(USB_CONFIGURATION_DESCRIPTOR),  
                              // ----------------------------------------------------------------------    
                              // # bDescriptorType
                                 USB_DESCR_TYPE_CONFIGURATION,  
                              // ----------------------------------------------------------------------    
                              // # wTotalLength
                                 TWOBYTES_LE(  										
                                        // length of configuration desc
                                        sizeof(USB_CONFIGURATION_DESCRIPTOR) +            
                                        // length of interface desc
                                        sizeof(USB_INTERFACE_DESCRIPTOR) +               	//-- 1st Interface
                                        // length of bulk-endpoints phy4, phy5 desc, interrupt phy 3
                                        NUM_ENDPOINTS * sizeof(USB_ENDPOINT_DESCRIPTOR)
                                            ),
                              // ----------------------------------------------------------------------    
                              // # bNumInterfaces   
                                 0x01,              
                              // ---------------------------------------------------------------------- 
                              // # bConfigurationValue
                                 0x01,      
                              // ----------------------------------------------------------------------    
                              // # iConfiguration
                                 0x03,                 
                              // ----------------------------------------------------------------------    
                              // # bmAttributes
                                 USB_CONFIG_BUS_POWERED | USB_CONFIG_REMOTE_WAKEUP,  
                              // ----------------------------------------------------------------------    
                              // # bMaxPower (mA /2)
                                 100>>1,                                				

  // =======================================================================================
  // ============================ Interface descriptor =====================================
  // =======================================================================================
   
                              // # bLength
                                 sizeof(USB_INTERFACE_DESCRIPTOR), 
                              // ----------------------------------------------------------------------    
                              // # bDescriptorType
                                 USB_DESCR_TYPE_INTERFACE,      
                              // ---------------------------------------------------------------------- 
                              // # bInterfaceNumber
                                 0x00,                 
                              // ----------------------------------------------------------------------    
                              // # bAlternateSetting
                                 0x00,           
                              // ----------------------------------------------------------------------    
                              // # bNumEndPoints
                                 NUM_ENDPOINTS,                    
                              // ----------------------------------------------------------------------    
                              // # bInterfaceClass         // bInterfaceClass    >> ïî USBTMC spec (page 33) == 0xFE
                                 0xFE,     
                              // ----------------------------------------------------------------------   
                              // # bInterfaceSubClass      // bInterfaceSubClass >> ïî USBTMC spec (page 33) == 0x03
                                 0x03,  
                              // ----------------------------------------------------------------------    
                              // # bInterfaceProtocol      // bInterfaceProtocol >> ïî USBTMC spec (page 33) == 0x01
                                 0x01,                             
                              // ----------------------------------------------------------------------    
                              // # iInterface              // index of string descriptor describing this interface
                                 3,             					 

  // =======================================================================================
  // ================= Physical EndPoint 4 descriptor ======================================
  // =======================================================================================

                              // # bLength
                                 sizeof(USB_ENDPOINT_DESCRIPTOR),  
                              // ----------------------------------------------------------------------    
                              // # bDescriptorType
                                 USB_DESCR_TYPE_ENDPOINT,   
                              // ----------------------------------------------------------------------    
                              // # bEndpointAddress,      Out, EP4
                                 0x02, 
                              // ----------------------------------------------------------------------    
                              // # bmAttributes,          Bulk
                                 0x02,               
                              // ----------------------------------------------------------------------    
                              // # wMaxPacketSize,        64
                                 TWOBYTES_LE(USB_MAX_PACKET2),
                              // ----------------------------------------------------------------------    
                              // # bInterval,             *ignored for bulk!*
                                 0x00,                             

  // =======================================================================================
  // ================= Psysical EndPoint 5 descriptor ======================================
  // =======================================================================================

                              // # bLength
                                 sizeof(USB_ENDPOINT_DESCRIPTOR),  
                              // ----------------------------------------------------------------------    
                              // # bDescriptorType
                                 USB_DESCR_TYPE_ENDPOINT,    
                              // ----------------------------------------------------------------------    
                              // # bEndpointAddress,      In, EP5
                                 0x82,         
                              // ----------------------------------------------------------------------   
                              // # bmAttributes,          Bulk
                                 0x02,                             
                              // ----------------------------------------------------------------------    
                              // # wMaxPacketSize,        64
                                 TWOBYTES_LE(USB_MAX_PACKET2),              
                              // ----------------------------------------------------------------------    
                              // # bInterval,             *ignored for bulk!*
                                 0x00,                             
                              // ---------------------------------------------------------------------- 

#ifdef __SERIAL_POLL_SUPPORT__
  // =======================================================================================
  // ================= Psysical EndPoint 3 descriptor ======================================
  // =======================================================================================

                              // # bLength
                                 sizeof(USB_ENDPOINT_DESCRIPTOR),  
                              // ----------------------------------------------------------------------    
                              // # bDescriptorType
                                 USB_DESCR_TYPE_ENDPOINT,    
                              // ----------------------------------------------------------------------    
                              // # bEndpointAddress,      In, EP5
                                 0x81,         
                              // ----------------------------------------------------------------------   
                              // # bmAttributes,          Interrupt
                                 0x03,                             
                              // ----------------------------------------------------------------------    
                              // # wMaxPacketSize,        64
                                 TWOBYTES_LE(USB_MAX_PACKET1),              
                              // ----------------------------------------------------------------------    
                              // # bInterval,             VALUE = 2 ^ (bInterval-1);   1<=VALUE<=16, see USB 2.0 Spec, Table 9-13. Standard Endpoint Descriptor (Continued)
                                 0x08,                                    
                              // ---------------------------------------------------------------------- 
#endif

  // =======================================================================================
  // ================== String descriptors =================================================
  // =======================================================================================

                              // ##### 0 String Descriptior describes support languages ( USB-IF Spec )
                              // # bLength
                                 4, 
                              // ----------------------------------------------------------------------    
                              // # bDescriptorType
                                 USB_DESCR_TYPE_STRING,  
                              // ----------------------------------------------------------------------    
                              // # Lang - English  
                                 TWOBYTES_LE(0x0409),  
                              // ----------------------------------------------------------------------       
#if defined(PLANAR)
                              // ##### 1 String Descriptior describes device name
                              // # bLength
                                 38,  
                              // ----------------------------------------------------------------------    
                              // # DescriptorType
                                 USB_DESCR_TYPE_STRING, 
                              // ----------------------------------------------------------------------    
                              // Text in unicode
                                 'A', 0,
                                 'u', 0,
                                 't', 0,
                                 'o', 0,
                                 'C', 0,
                                 'a', 0,
                                 'l', 0,
                                 ' ', 0,
                                 'M', 0,
                                 'o', 0,
                                 'd', 0,
                                 'u', 0,
                                 'l', 0,
                                 'e', 0,
                                 ' ', 0,
                                 'A', 0,
                                 'C', 0,
                                 'M', 0,                                 
                              // ----------------------------------------------------------------------    
#elif defined(CMT)
                              // ##### 1 String Descriptior describes device name
                              // # bLength
                                 38,  
                              // ----------------------------------------------------------------------    
                              // # DescriptorType
                                 USB_DESCR_TYPE_STRING, 
                              // ----------------------------------------------------------------------    
                              // Text in unicode
                                 'A', 0,
                                 'u', 0,
                                 't', 0,
                                 'o', 0,
                                 'C', 0,
                                 'a', 0,
                                 'l', 0,
                                 ' ', 0,
                                 'M', 0,
                                 'o', 0,
                                 'd', 0,
                                 'u', 0,
                                 'l', 0,
                                 'e', 0,
                                 ' ', 0,
                                 'A', 0,
                                 'C', 0,
                                 'M', 0,                                 
                              // ----------------------------------------------------------------------    
#else
#error Please, specify VENDOR macro
#endif                                 

#if defined(PLANAR)
                                 68,                               //-- bLength
                                 USB_DESCR_TYPE_STRING,            //-- bDescriptorType
                                 'P', 0,
                                 'l', 0,
                                 'a', 0,
                                 'n', 0,
                                 'a', 0,
                                 'r', 0,
                                 ' ', 0,
                                 '(', 0,
                                 'h', 0,
                                 't', 0, 
                                 't', 0,
                                 'p', 0,
                                 ':', 0,
                                 '/', 0,
                                 '/', 0,
                                 'w', 0,
                                 'w', 0,
                                 'w', 0,
                                 '.', 0,
                                 'p', 0,
                                 'l', 0,
                                 'a', 0,
                                 'n', 0,
                                 'a', 0, 
                                 'r', 0, 
                                 'c', 0,
                                 'h', 0,
                                 'e', 0,
                                 'l', 0,
                                 '.', 0,
                                 'r', 0,
                                 'u', 0,
                                 ')', 0, 
#elif defined(CMT)
                              // ##### 2 String Descriptior describes manufacturer name
                              // # bLength
                                 122,       
                              // ----------------------------------------------------------------------    
                              // # DescriptorType
                                 USB_DESCR_TYPE_STRING,            //-- bDescriptorType
                              // ----------------------------------------------------------------------    

                                 'C', 0,
                                 'o', 0,
                                 'p', 0,
                                 'p', 0,
                                 'e', 0,
                                 'r', 0,
                                 ' ', 0,
                                 'M', 0,
                                 'o', 0,
                                 'u', 0,   
                                 'n', 0,
                                 't', 0,
                                 'a', 0,
                                 'i', 0,
                                 'n', 0,
                                 ' ', 0,//16
                                 'T', 0,
                                 'e', 0,
                                 'c', 0,
                                 'h', 0,
                                 'n', 0,
                                 'o', 0,
                                 'l', 0,
                                 'o', 0,
                                 'g', 0,
                                 'i', 0,
                                 'e', 0,
                                 's', 0, 
                                 ' ', 0,
                                 '(', 0,
                                 'h', 0,
                                 't', 0,  //32 
                                 't', 0,
                                 'p', 0,
                                 ':', 0,
                                 '/', 0,
                                 '/', 0,
                                 'c', 0,
                                 'o', 0,
                                 'p', 0,
                                 'p', 0,
                                 'e', 0,
                                 'r', 0,
                                 'm', 0,
                                 'o', 0,
                                 'u', 0,   
                                 'n', 0,
                                 't', 0,
                                 'a', 0,
                                 'i', 0,
                                 'n', 0,
                                 't', 0,
                                 'e', 0,
                                 'c', 0,
                                 'h', 0,
                                 '.', 0,
                                 'c', 0,
                                 'o', 0,
                                 'm', 0,
                                 ')', 0, //60
// ----------------------------------------------------------------------
#else
#error Please, specify VENDOR macro
#endif
                              // ##### 3 String Descriptior describes interface name
                              // # bLength
                                 28, 
                              // ----------------------------------------------------------------------  
                              // # DescriptorType
                                 USB_DESCR_TYPE_STRING,            //-- bDescriptorType
                              // ----------------------------------------------------------------------  
                                 'U', 0,
                                 'S', 0,
                                 'B', 0,
                                 'T', 0,
                                 'M', 0,
                                 'C', 0,
                                 '-', 0,
                                 'U', 0,
                                 'S', 0,
                                 'B', 0,
                                 '4', 0,
                                 '8', 0,
                                 '8', 0,

                              // ##### 4 String Descriptior describes interface serial number, USB_SN_STRING_DESCRIPTOR
                              // # bLength
// ----------------------------------------------------------------------  
//-- Terminating zero
   0
};


// ----------------------------------------------------------------------  


BYTE SerialNumberDescriptor[] =
{
  18, 
  // ----------------------------------------------------------------------  
  // # DescriptorType
     USB_DESCR_TYPE_STRING,            //-- bDescriptorType
  // ----------------------------------------------------------------------  
     '0', 0,
     '0', 0,
     '0', 0,
     '0', 0,
     '0', 0,
     '0', 0,
     '0', 0,
     '0', 0,
};

void ModifySerialNumberDescriptor( const char * sn, unsigned int maxsize )
{
   uint8_t * pSerial = SerialNumberDescriptor;
   int32_t limit = sizeof(SerialNumberDescriptor) - 2;

   pSerial++; // skip length in @SerialNumberDescriptor
   pSerial++; // skip type in @SerialNumberDescriptor

   for( unsigned int i = 0; (limit > 0) && (maxsize > 0); ++i )
   {
      *pSerial = *sn; // copy

      pSerial++; // skip current character (low)
      pSerial++; // skip current character (high)
      limit-=2;
      maxsize--; //
      sn++;      // 
   }
}

// ====================================================================================================================
static inline void USB_INTERRUPT_CLEAR_BULKIN()
{
  #ifdef MYDEBUG_OLDMETHOD
  rUSBEpIntClr = 1<<(USB_EP_PHY_ADDRESS_BULK_IN);
  #else
  USB_EpIntrClr( USB_EP_PHY_ADDRESS_BULK_IN );
  #endif
}

static inline void USB_INTERRUPT_CLEAR_BULKOUT()
{
  #ifdef MYDEBUG_OLDMETHOD 
  rUSBEpIntClr = 1<<(USB_EP_PHY_ADDRESS_BULK_OUT);
  #else
  USB_EpIntrClr( USB_EP_PHY_ADDRESS_BULK_OUT );
  #endif
}

static inline void USB_INTERRUPT_CLEAR_INTIN()
{
  #ifdef MYDEBUG_OLDMETHOD
  rUSBEpIntClr = 1<<(USB_EP_PHY_ADDRESS_INT_IN);  
  #else
  USB_EpIntrClr( USB_EP_PHY_ADDRESS_INT_IN );
  #endif
}

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

#ifdef __SERIAL_POLL_SUPPORT__
// Ðåàëèçàöèÿ Serial Poll äëÿ USB488
//
// Òî÷êà InterruptIN Îòäàåò äâà áàéòà ñòðóêòóðû _INTERRUPT_IN, îïèñàíîé â USB488, ñòð 9
//
void usb_EP1_tx_int_func(USB_DEVICE_INFO * udi) //-- Interrupt IN
{ 
   USB_INTERRUPT_CLEAR_INTIN();
}
#endif 

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

//----------------------------------------------------------------------------
/* =========================================================================================================================================*/
//  @@@@   @@@@@           @@@@@@  @    @   @@@@           @@@@@@  @    @           @@@    @    @  @@@@@@  
// @    @  @    @            @     @    @  @    @            @      @  @             @     @@   @    @     
// @@@@@@  @    @            @     @    @  @    @            @       @               @     @ @  @    @     
// @       @@@@@             @     @ @@ @  @    @            @        @              @     @  @ @    @     
// @    @  @                 @     @@  @@  @    @            @      @  @             @     @   @@    @     
//  @@@@   @                @@@    @    @   @@@@            @@@    @    @           @@@    @    @   @@@    

// ---------------- EP2 Device-To-Host stream ------------------
//  usb_EP2_tx_int_func - âûçûâàåòñÿ ïîñëå îòïðàâêè äàííûõ èç áóôåðà
// êîíå÷íîé òî÷êè Ep5 (Bulk-In) õîñòó èëè îòâåòà åìó NAK. Ñàìûé ïåðâûé
// Bulk-In òîêåí âñåãäà çàâåðøàåòñÿ NAKîì, åñëè äàííûå â áóôåð çàãðóæàþòñÿ
// òîëüêî â ýòîì ïðåðûâàíèè.
//

void usb_EP2_tx_int_func(USB_DEVICE_INFO * udi)
{
   /*
   // -------------------------------------------------------------------
   // USB_INTERRUPT_DISABLE_BULKIN_NAK - çàïðåùàåò ïðåðûâàíèÿ îò âñåõ Bulk-In
   // òî÷åê ïî NAK. Ýòî äåëàåòñÿ äëÿ òîãî, ÷òîáû â ñëó÷àå ïðèõîäà íåñâîåâðåìåííîãî
   // Bulk-IN ïàêåòà (ðàíüøå Bulk-Out ïàêåòà) ýòî ïðåðûâàíèå íå ïîðòèëî íàì æèçíü,
   // îñòàíàâëèâàÿ îñíîâíóþ ïðîãðàììó - è, â ñâîþ î÷åðåäü, îñòàíàâëèâàÿ îáðàáîòêó
   // ñîáûòèÿ ïðèõîäà äàííûõ Bulk-Out
     
   // ÷èòàåì ñòàòóñ òîëüêî ÷òî îòïðàâëåííîãî ïàêåòà
   int ep_status = usb_lpc_cmd_read(CMD_EP_SELECT | USB_EP_PHY_ADDRESS_BULK_IN);  
   if( ep_status & ( 1<<1 ))   // åñëè ìû îòâåòèëè STALL-îì
   {
      int error = usb_getlasterror();
      udi->BulkRespondStatus.INTransferInProgress = FALSE;   //ïåðåäà÷à çàâåðøåíà
      udi->BulkRespondStatus.INTransferTerminating = FALSE;
   }
   //
   // -------------------------------------------------------------------
   */
   USB_INTERRUPT_CLEAR_BULKIN();      // Ñáðîñ ïðåðûâàíèÿ, ÷òîá íå ùåëêàëî
   
   usb_EP2_tx_func__( udi );
}

// volatile size_t debug_call_1 = 0;
//------------------------------------------------------------------------------------------------------------------------------------------
//  @@@@   @@@@@           @@@@@@  @    @   @@@@           @@@@@@  @    @           @@@@    @@@@   @    @  @@@@@   @        @@@@   @@@@@@   @@@@   
// @    @  @    @            @     @    @  @    @            @      @  @           @    @  @    @  @@  @@  @    @  @       @    @    @     @    @  
// @@@@@@  @    @            @     @    @  @    @            @       @             @       @    @  @ @@ @  @    @  @       @@@@@@    @     @@@@@@  
// @       @@@@@             @     @ @@ @  @    @            @        @            @       @    @  @    @  @@@@@   @       @         @     @       
// @    @  @                 @     @@  @@  @    @            @      @  @           @    @  @    @  @    @  @       @    @  @    @    @     @    @  
//  @@@@   @                @@@    @    @   @@@@            @@@    @    @           @@@@    @@@@   @    @  @       @@@@@@   @@@@    @@@     @@@@   


void usb_EP2_tx_func__(USB_DEVICE_INFO * udi)
{  
   //- --------------------------------------------------------------------------------------------------
   USB_EP_STATUS            * bulk_status   = (USB_EP_STATUS          *) &udi->EPBulkStatus;
   USB_BULKRESPOND_STATUS   * pBulkRespond  = (USB_BULKRESPOND_STATUS *) &udi->BulkRespondStatus;
   USB_BULKMESSAGE_STATUS   * pBulkMessage  = (USB_BULKMESSAGE_STATUS *) &udi->BulkMessageStatus;
   USB_USBTMC_CLASS_STATUS  * pUSBTMCStatus = (USB_USBTMC_CLASS_STATUS*) &udi->usbtmcStatus;
   USB_PIPE_ENTRY_IN        * pInPipe       = (USB_PIPE_ENTRY_IN      *) &bulk_status->InPipe;
   //- --------------------------------------------------------------------------------------------------
   volatile unsigned int ep_status;
   volatile unsigned int ep_errorcode;
   int bytes;
   //- --------------------------------------------------------------------------------------------------
   // bTag çàïðîñà è îòâåòà íå ñîâïàäàþò. Îòâåò áóäåò íå êîððåêòíûì
   if( pInPipe->dwLength > 0 && (pBulkRespond->bTag != pBulkMessage->bTag) )   
   {
       ep_status = usb_lpc_cmd_read( CMD_EP_SELECT | USB_EP_PHY_ADDRESS_BULK_IN );
       
       if( (!(ep_status & (1<<4))) && ( ep_status&((1<<5)|(1<<6))) ) // îòâåòèëè íå NAK-îì, à äàííûìè, è äàííûå åùå îñòàëèñü â îäíîì èç áóôåðîâ
       {  
           usb_ep_clear_buffers( USB_EP_LOG_ADDRESS_BULK_IN ); 
       }
       
       pInPipe->dwLength  = 0;
       
       // âîçìîæíî ðàíüøå ÷åì Bulk-Out ïðèøåë Bulk-IN.
       return;
   }
   //- ----------------------------------------------------------------------------------

   if( pInPipe->dwLength > 0 )
   {  
         //USB_BULKRESPOND_STATUS debug_test_brs;
         //USB_PIPE_ENTRY_IN      debug_test_ip;
         //
         //memcpy( &debug_test_brs, pBulkRespond, sizeof(debug_test_brs) );
         //memcpy( &debug_test_ip, pInPipe, sizeof(debug_test_ip) );
         
         pBulkRespond->INTransferInProgress = TRUE; 
         
         // ------------------------------------------------------------------------------------
         // ìèíèìàëüíîå èç InPipe.dwLength  è  USB_MAX_PACKET2
         bytes = (pInPipe->dwLength > USB_MAX_PACKET2)? USB_MAX_PACKET2:pInPipe->dwLength;
         // ------------------------------------------------------------------------------------
//#error Ïðè óìåíüøåíèè âûõîäíîãî áóôåðà  äî 96 áàéò, êàæäàÿ òî÷êà çàíèìàëà 38 áàéò, êîòîðûå è îòïðàâëÿëèñü\
          íî èíîãäà çäåñü bytes>64, ïî÷åìó? èççà ýòîãî óõîäèò short ïàêåò, ïðè÷åì ðàíüøå, ÷åì\
            ñàìà ôóíêöèÿ ïåðåäàñò âñå äàííûå
         //---------------------------------------------------------------------------------
         // çàïèñü â áóôåð êîíå÷íîé òî÷êè
         bytes = usb_ep_write( USB_EP_LOG_ADDRESS_BULK_IN, (BYTE*)pInPipe->pData, bytes); 
         //---------------------------------------------------------------------------------

         // --------------------------------------------------------------------------
         // óâåëè÷èâàåì ñ÷åò÷èê ïåðåäàíûõ áàéò äëÿ çàïðîñà CHECK_ABORT_BULK_IN_STATUS
         pBulkRespond->nBytesSent += bytes;    
         // à òàêæå èçìåíÿåì äàííûå Pipe
                  pInPipe->dwLength    -= bytes; // -- êîëè÷åñòâî áàéò ê ïåðåäà÷å (òåêóùàÿ Transfer)
                  pInPipe->dwAllLength -= bytes; // -- âñåãî áàéò ê ïåðåäà÷å 
                  pInPipe->pData       += bytes; // ++ óêàçàòåëü ïåðåäà÷è (RD)
         pBulkRespond->dwDeviceOut     -= bytes; // -- âñåãî áàéò êîòîðûå ïîñòàâèëî â î÷åðåäü óñòðîéñòâî (ðàçìåð âûõ áóôåðà Device)        
         pBulkRespond->bEndOfMessage = FALSE;
         // --------------------------------------------------------------------------

         // ----------------------- âûçîâ Callback ôóíêöèè ïî çàâåðøåíèþ ïåðåäà÷è áóôåðà ---------------
           if( pBulkRespond->dwDeviceOut == 0 || pInPipe->dwLength == 0)                      // åñëè áóôåð îïóñòåë (êîíåö Transfer)
                if( pBulkRespond->bIsLastTransfer == FALSE )            // åñëè ýòî íå ïîñëåäÿÿ Transfer
                  if( pInPipe->pfTransferEndHandler != NULL )           // åñëè åñòü CallBack
                  {   
                       // -------------------------------------------------------------------------
                       pBulkRespond->INTransferInProgress = FALSE;       // Transfer - çàâåðøåíà
                       if( pBulkRespond->INTransferTerminating == TRUE ) // åñëè ìû æäàëè ...
                       { pBulkRespond->INTransferTerminating = FALSE;    // ... çàâåðøåíèÿ ïåðåäà÷è
                         pUSBTMCStatus->USBTMC_status = STATUS_SUCCESS;}    
                       // -------------------------------------------------------------------------
//#error âûçâàëè. îí ìîäèôèöèðîâàë íàì dwLength (è âñòàâèë BULKINHEADER ñî ñòàðûì bTag!!!)
                      // debug_call_1 ++; 
                      pInPipe->pfTransferEndHandler ( udi );             // îáðàáîò÷èê çàâåðøåíèÿ Transfer
                  }

         // --------------------------------------------------------------------------------------------

         // ---------------------------------------
         if(pBulkRespond->dwDeviceOut == 0) GPIB_CLR_MAV();
         // ---------------------------------------

         // ---------------------------------------------------------------------------------------------------------------------------                       
         // Åñëè âñåòàêè pInPipe->dwLength === 0, íóæíî çàâåðøèòü ïåðåäà÷ó Short ïàêåòîì
         // ----------------------------------------------------------------------------
         bulk_status->shortpacket = FALSE;  // ñòàâèòü â î÷åðåäü Short ïàêåò íå òðåáóåòñÿ ïî óìîë÷àíèþ  
//#error ïðîâåðèòü, âåðíî ëè óñëîâèå óñòàíîâêè bulk_status->shortpacket=true, ïîäîçðèòåëüíî, ÷òî bytes ïðèñâàèâàåòñÿ ÄÎ âûçîâà pfTransferEndHandler, à ïîòîì îíî àíàëèçèðóåòñÿ...\
           À åñëè pfTransferEndHandler âûäàñò äàííûå è shortïàêåò íå íóæåí?
             
         // åñëè òðåáóåòñÿ ïðåðâàòü ïåðåäà÷ó - îòïàâëÿåì short-ïàêåò    
         if( pBulkRespond->INTransferTerminating )
             bulk_status->shortpacket = TRUE;
         
         // åñëè òîëüêî ÷òî îòïðàâëåííûå - ïîñëåäíèå âî âñåé ïîñûëêå USBTMC - îòïàâëÿåì short-ïàêåò     
         if( (pInPipe->dwLength == 0) && (bytes == USB_MAX_PACKET2) ) 
         {    
             // äàííûõ íà ïåðåäà÷ó â êàíàëå íå îñòàëîñü (pInPipe->dwLength = 0)
             // ïîñëåäíÿÿ ïîñûëêà â EP îêàçàëàñü ðàâíà ìàêñèìàëüíîìó ðàçìåðó EP (bytes == USB_MAX_PACKET2)
             // âðîäå êàê íàäî îòïðàâèòü short-ïàêåò .... 
             // 03/09/18. õîñò óïðàâëÿåò êîëè÷åñòâîì ñ÷èòûâàåìûõ äàííûõ. Äàæå åñëè
             // óæå pBulkRespond->dwDeviceOut > 0, ïåðåäà÷à BulkIN çàêîí÷èëàñü, õîñò äîëæåí
             // ïðèñëàòü ñëåäóþùèé çàïðîñ íà BulkIN. À ýòó ïåðåäà÷ó íåîáõîäèìî çàêîí÷èòü
             // short-ïàêåòîì.
             bulk_status->shortpacket = TRUE; 
         }  
         // ---------------------------------------------------------------------------------------------------------------------------

   }
   else
   {     
         // =============== QUEUE SHORT PACKET ====================
         if( bulk_status->shortpacket == TRUE )
         {
             bulk_status->shortpacket = FALSE;
             bulk_status->shortpacketsending = TRUE;
             usb_ep_write( USB_EP_LOG_ADDRESS_BULK_IN, (BYTE*)pInPipe->pData, 0);  // ÷åñòíûé áàëê æäåò îò íàñ Short ïàêåòà.          
         }   
         else
         {  
             //NAK â ñëåäóþùåì IN òîêåíå
             if( bulk_status->shortpacketsending == TRUE )
             {   
                 bulk_status->shortpacketsending = FALSE;
                 bulk_status->shortpacket        = FALSE;
             }
             
             // =======================================================
             pBulkRespond->INTransferInProgress = FALSE;
             
             if( pBulkRespond->INTransferTerminating == TRUE ) // åñëè ìû æäàëè çàâåðøåíèÿ ïåðåäà÷è
             {  
                 pBulkRespond->INTransferTerminating = FALSE;
                 pUSBTMCStatus->USBTMC_status = STATUS_SUCCESS;    
             }
           
             //---------------------------------------------------
             // -- ñáðàñûâàåì Message Available áèò, âñå ïåðåäàëè. 
             if(pBulkRespond->dwDeviceOut == 0) 
             {  
                GPIB_CLR_MAV(); 
             }  
             // see USB488 spec ,rev 1.0, 2003, page 13, 4.3.1.3
             //---------------------------------------------------
         } 
   }
}

// ---------------- ------------------------- ------------------
/* =========================================================================================================================================*/


/* =========================================================================================================================================*/
//  @@@@   @@@@@           @@@@@@  @    @   @@@@           @@@@@   @    @           @@@    @    @  @@@@@@  
// @    @  @    @            @     @    @  @    @          @    @   @  @             @     @@   @    @     
// @@@@@@  @    @            @     @    @  @    @          @@@@@     @               @     @ @  @    @     
// @       @@@@@             @     @ @@ @  @    @          @ @        @              @     @  @ @    @     
// @    @  @                 @     @@  @@  @    @          @  @     @  @             @     @   @@    @     
//  @@@@   @                @@@    @    @   @@@@           @   @@  @    @           @@@    @    @   @@@    

// ---------------- EP2 Host-To-Device stream ------------------

void usb_EP2_rx_int_func(USB_DEVICE_INFO * udi)
{
  USB_INTERRUPT_CLEAR_BULKOUT(); 
  usb_EP2_rx_func__ ( udi );
}


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

void usb_EP2_rx_func__(USB_DEVICE_INFO * udi)
{
   //------------------------------------------------------------------------------------------
   unsigned int len;
   unsigned int treshold;
   volatile unsigned int ep_status;
   int sibytes_limit;
   int iDoubleBufferPeekAttempts;  // ñêîëüêî ðàç ìîæíî ïðè bNeedHaltEndpoint çàáèðàòü äàííûå èç âòîðîãî áóôåðà FIFO
   //------------------------------------------------------------------------------------------
   BOOL     rc;
   BOOL     bNeedHaltEndpoint = FALSE;  // óñëîâèå îñòàíîâêè Bulk-End point. see USBTMC spec, rev 1.0, page 11, "3.2.2.4 Halt"
   BOOL     bItIsFirstPacket = FALSE;  // ýòî ïåðâûé ïàêåò ïåðåäà÷è, ñîäåðæàùèé çàãîëîâîê
   BOOL     bHostToDevice_Direction;   // åñëè TRUE, ñòàäèÿ äàííûõ íàïðàâëåíà îò Host -> Device, çàïèñü â óñòðîéñòâî   
   
   BOOL     bBufferOverflow = FALSE;    // TRUE óêàçûâàåò, ïðîèçîøëî ëè ïåðåïîëíåíèå âõîäíîãî áóôåðà
   BOOL     bBuffer1Full;
   BOOL     bBuffer2Full;
   BOOL     bSkipPacket;
   BOOL     bGenError      = FALSE;
   //------------------------------------------------------------------------------------------
   USB_PIPE_ENTRY_IN      * pPipeIn = (USB_PIPE_ENTRY_IN *) &udi->EPBulkStatus.InPipe;   // HostIN, DeviceOUT
   USB_PIPE_ENTRY_OUT     * pPipeOut    = (USB_PIPE_ENTRY_OUT*) &udi->EPBulkStatus.OutPipe;  // HostOUT, DeviceIN
   //------------------------------------------------------------------------------------------
   USB_BULKMESSAGE_STATUS * pBulkMessage   = (USB_BULKMESSAGE_STATUS*) &udi->BulkMessageStatus;
   USB_BULKRESPOND_STATUS * pBulkRespond   = (USB_BULKRESPOND_STATUS*) &udi->BulkRespondStatus;
   BULKOUT_HEADER         * pBulkOutHeader;       //
   BYTE                   * pBulkData;            // 
   //------------------------------------------------------------------------------------------
   iDoubleBufferPeekAttempts = 1; // ñêîëüêî ðàç ìîæíî ïðè bNeedHaltEndpoint çàáèðàòü äàííûå èç âòîðîãî áóôåðà FIFO
   
   // --- ïðîâåðêà îáîèõ áóôåðîâ EP
   while((bNeedHaltEndpoint==FALSE) || (bNeedHaltEndpoint && iDoubleBufferPeekAttempts--))    // äàæå åñëè  bNeedHaltEndpoint âòîðîé ïàêåò ïîõîæå íóæíî çàáðàòü (DoubleBuffer)  
   {     
         // ------------------------------------------------------------------------------------------------------------------------
            ep_status = usb_lpc_cmd_read(CMD_EP_SELECT | USB_EP_PHY_ADDRESS_BULK_OUT); // Phy EP4 - Host-to-Device Direction (Host OUT)
              bBuffer1Full = (ep_status & (1<<5));
              bBuffer2Full = (ep_status & (1<<6));
            if( bBuffer1Full==FALSE && bBuffer2Full == FALSE ) break;
         // ------------------------------------------------------------------------------------------------------------------------  
         // ---- Åñòü äàííûå â áóôåðå
        
            if( pBulkMessage->bBulkHeaderRecieved == FALSE || bBufferOverflow == TRUE)  // åñëè íå ïðèíÿò çàãîëîâîê èëè ïåðåïîëíåíèå áóôåðà
            {
              pPipeOut->pData = pPipeOut->pDefaultBuffer;
              pPipeOut->dwLength = 0; 
              pBulkMessage->nBytesRecieved = 0;              
              pBulkMessage->bBulkHeaderRecieved = FALSE; //
              sibytes_limit = -1;  // íåò ëèìèòà
              

            } else {
              // îãðàíè÷èâàåì ðàçìåð ñ÷èòûâàåìûõ áàéò â áóôåð. ïðè ïðåâûøåíèè ëèìèòà áàéòû ïðîñòî äîñòàþòñÿ èç FIFO è òåðÿþòñÿ
              sibytes_limit = USB_MAX_BULKOUT_BUFFERSIZE - pBulkMessage->nBytesRecieved - sizeof(BULKOUT_HEADER);  // äëèííà çàãîëîâêà â nBytesRecieved íå âõîäèò, íî çàãîëîâîê òî òîæå íóæíî õðàíèòü
                                                      
              if( sibytes_limit >= USB_MAX_PACKET2) 
                  sibytes_limit = -1; //åñòü ñìûñë îãðàíè÷èâàòü êîëè÷åñòâî áàéò òîãäà, êîãäà îíî áîëüøå ÷åì USB_MAX_PACKET2.
                                   // åñëè sibytes_limit ñêàæåì 500, íå íóæíî ïîñûëàòü 500, ïîòîìó ÷òî ó òî÷êè âñÿêî ìåíüøå: USB_MAX_PACKET2                                   
            }
            // ----------------------------- Îñâîáîæäåíèå FIFO áóôåðà --------------------------------------------------------
              
              
              len = usb_ep_read( USB_EP_LOG_ADDRESS_BULK_OUT, pPipeOut->pData, sibytes_limit );   // çàïèñü áóôåðà FIFO ïî óêàçàòåëþ çàïèñè
                                                                                  // åñëè çàãîëîâîê íå ïðèíÿò, çàïèñü èäåò â íà÷àëî áóôåðà
            //-------------------------------------------------------------------------------------------------------------------------------
            
            //-------------------------------------------------------------------------------------------------------------------------------
              bBufferOverflow = (( (sibytes_limit >=0 ) && (  len > sibytes_limit ) ) )?TRUE:FALSE;     // ïåðåïîëíåíèå áóôåðà    
              bBufferOverflow = bBufferOverflow || bNeedHaltEndpoint;
              if(bBufferOverflow == TRUE && bGenError == FALSE)
              {  bGenError = TRUE;
                 usbtmc_GenRecieveError( udi );
              }
            //-------------------------------------------------------------------------------------------------------------------------------

            //---------------- Èíèöèàëèçàöèÿ óêàçàòåëåé -------------------------------------------------------------------------------------
              pBulkData = pPipeOut->pData;  
              pBulkOutHeader = (BULKOUT_HEADER*) pPipeOut->pData; 
            //-------------------------------------------------------------------------------------------------------------------------------

            // -- îïðåäåëÿåì ïîðîã êîëè÷åñòâà áàéò 
              if(pBulkMessage->bBulkHeaderRecieved != TRUE)
                  treshold = (USB_MAX_PACKET2<sizeof(BULKOUT_HEADER))?USB_MAX_PACKET2:sizeof(BULKOUT_HEADER);// åñëè íå ïðèíÿò çàãîëîâîê- ïîðîã ðàçìåð çàãîëîâêà, èíà÷å ïàêåò íåêîððåêòåí
              else
                  treshold = 1; // åñëè çàãîëîâîê ïðèíÿò, ïîðîã - õîòÿáû îäèí áàéò
            // -------------------------------------------------------------------------------------------
            // Îòáðàñûâàåì âñå ïàêåòû, åñëè åùå íå ïðèíÿëè çàãîëîâîê (Bulk-In Header è íàì ïðèøåë ïàêåò
            // äëèííîé ìåíüøå ÷åì äëèííà çàãîëîâêà è äàæå ìåíüøå ÷åì ðàçìåð áóôåðà EP. Ïîèäåå, åñëè ðàçìåð
            // çàãîëîâêà áîëüøå ðàçìåðà áóôåðà, òî treshold == ðàçìåðó áóôåðà, äàííûå ïðîéäóò. Åñëè æå
            // ðàçìåð çàãîëîâêà ìåíüøå ðàçìåðà áóôåðà, treshold == ðàçìåðó çàãîëîâêà, äàííûå îïÿòü ïðîéäóò.
            // Íî åñëè æå ìû åùå íå ïðèíÿëè çàãîëîâîê, òîåñòü pBulkMessage->bBulkHeaderRecieved == FALSE,
            // òî íåïðåìåííî ïðèíèìàåìûå äàííûå äîëæíû íà÷àòüñÿ ñ ýòîãî çàãîëîâêà, à äàííûå íåêîððåêòíû ïî 
            // ðàçìåðó. Çíà÷èò èìååò ìåñòî ðàñ-ñèíõðîíèçàöèÿ Bulk-Out - äàííûå áóäóò îòáðîøåíû
            // --------------------------------------------------------------------------------------------
        if(len>=treshold && bBufferOverflow==FALSE)
        {  
                     // see USBTMC spec, rev 1.0, 2003, page 6, cipfer 3. Åñëè õîñò ïðèøëåò äâà Bulk-Out header, âòîðîé îïîçíàåòñÿ êàê äàííûå åñëè ôëàã óñòàíîâëåí 
                     // #### -------------- òðåáóåòñÿ ïðèíÿòü çàãîëîâîê Bulk-Out, åñëè îí åùå íå ïðèíÿò
                     if(pBulkMessage->bBulkHeaderRecieved!= TRUE || pBulkMessage->nBytesRecieved == 0 )           
                     {  
                        // -------- çàãîëîâîê ïðèíÿò: ñëåä ïîñûëêà ðàññìàòðèâàåòñÿ êàê äàííûå ------
                            pBulkMessage->bBulkHeaderRecieved = TRUE;  
                        // -------------------------------------------------------------------------

                        // ----------- çàïîëíÿåì ñòðóêòóðó USBTMC ñîîáùåíèÿ ----------------------------------------------------------
                            pBulkMessage->MsgID    = pBulkOutHeader->MsgID;               // ïðèíÿòî ñîîáùåíèå USBTMC
                            pBulkMessage->bTagLast = pBulkMessage->bTag;                  // Ïðåäûäóùèé òåã ñîîáùåíèÿ, åñëè ñîîáùåíèå ðàçäåëåíî íà íåñê. ïåðåäà÷ ( ïåðåäà÷, à íå òðàíçàêöèé )
                            pBulkMessage->bTag     = pBulkOutHeader->bTag;                // òåêóùèé òåã ñîîáùåíèÿ, åñëè ñîîáùåíèå ðàçäåëåíî íà íåñê. ïåðåäà÷ ( ïåðåäà÷, à íå òðàíçàêöèé )
                            pBulkMessage->bEOM     = (pBulkOutHeader->stCommandMessage.bmTransferAttributes & USBTMC_BITMAP_EOM);
                        // -----------------------------------------------------------------------------------------------------------

                        // ---- îïðåäåëÿåì íàïðàâëåíèå ñòàäèè äàííûõ (çàïðîñ èç óñòðîéñòâà èëè çàïèñü â íåãî íà îñíîâíèè êîäà çàïðîñà) ----
                           bHostToDevice_Direction = usbtmc_parse( udi, TRUE );      // ïñåâäî âûçîâ ñ ôëàãîì âîçâðàùàåò íàïðàâëåíèå                           
                        // ----------------------------------------------------------------------------------------------------------------

                        if( bHostToDevice_Direction ){  
                           // Host(OUT) -> (IN)Device
                           // -- ïîëó÷àåì äëèííó ïîñûëêè: see usbtmc.h, Appendix 1
                               pPipeOut->dwLength = pBulkOutHeader->stCommandMessage.TransferSize;             // -- OutPipe.dwLength --- äëèííà âèðòóàëüíîãî ìàññèâà äàííûõ pBulkData,
                               pBulkMessage->OutTransferSize = pBulkOutHeader->stCommandMessage.TransferSize;  // -- êîòîðûé ìîæåò ðàçáèâàòüñÿ íà ÷àñòè â ðàçíûõ òðàíçàêöèÿõ è ïåðåäà÷àõ 
                        } else {   
                           // Host(IN) <- (OUT)Device                                                      
                                pPipeIn->dwLength = 0;     // ìîäèôèöèðóåòñÿ â REQUEST_DEP_DEV_MSG_IN
                               pPipeOut->dwLength = 0;     // íàïðàâëåíèå ñòàäèè äàííûõ Device->Host
                               pBulkRespond->InTransferSize = pBulkOutHeader->stCommandMessage.TransferSize;   // -- ñêîëüêî õîñò õî÷åò ïðî÷èòàòü
                        }
                        
                        // ïðîâåðÿåì êîððåêòíîñòü çàãîëîâêà, åñëè bTag != bTagInverse, òî ïðèøëè íåâåðíûå äàííûå. çàãîëîâîê íåêîððåêòíûé è áóäåò îòáðîøåí
                        if( !((pBulkOutHeader->bTag ^ pBulkOutHeader->bTagInverse) == 0xFF) )
                            pBulkMessage->bBulkHeaderRecieved = FALSE;
                        
                        if( pBulkMessage->bBulkHeaderRecieved == TRUE)
                        {  
                            pBulkData += sizeof(BULKOUT_HEADER);   // -- ïðûãàåì ê íà÷àëó äàííûõ, ñëåäóþøèõ ÇÀ çàãîëîâêîì
                            len       -= sizeof(BULKOUT_HEADER);   // -- len == êîëè÷åñòâî áàéò ÄÀÍÍÛÕ òðàíçàêöèè ïîñëå çàãîëîâêà
                            bItIsFirstPacket = TRUE;               // -- óêàçûâàåò ÷òî ýòî ïåðâàÿ òðàíçàêöèÿ ñîîáøåíèÿ (ñîäåðæèò çàãîëîâîê)
                            pBulkMessage->pData = pBulkData;       // -- ñîõðàíÿåì óêàçàòåëü íà äàííûå
           
                            if( pPipeOut->dwLength <= USB_MAX_BULK_PAYLOAD ) {
                                // åñëè ïîñûëêà ÍÅ ðàçáèâàåòñÿ íà íåñêîëüêî òðàíçàêöèé 
                                  pBulkMessage->nBytesRecieved = 0;     // óâåëè÷èâàåòñÿ äàëüøå
                                  
                            } else {
                               // åñëè ïîñûëêà ðàçáèâàåòñÿ íà íåñêîëüêî òðàíçàêöèé 
                                  pBulkMessage->nBytesRecieved = 0;     // óâåëè÷èâàåòñÿ äàëüøå
                                  pBulkMessage->OUTTransferInProgress = TRUE;  // ïîêàçûâàåò, ÷òî ïðîèñõîäèò äëèòåëüíàÿ ïåðåäà÷à äàííûõ - íóæíî äëÿ îáðàáîòêè çàïðîñà INITIATE_ABORT_BULK_OUT
                                  
                            }
          

                        } // if ( HEADER RECIEVED )
                        
                     }
                     else
                     {   
                         // fixed 29/08/18
                         bHostToDevice_Direction = usbtmc_parse( udi, TRUE );      // ïñåâäî âûçîâ ñ ôëàãîì âîçâðàùàåò íàïðàâëåíèå                         
                     }
             
                     
                     //-------------------------------------------------------------------------------------------------------------
                      if( pBulkMessage->bBulkHeaderRecieved == TRUE )
                     {
                                //-----------------------------------------------------------------------------------------------
   
                                if( pBulkMessage->nBytesRecieved + len > USB_MAX_BULKOUT_BUFFERSIZE )     // çàùèòà
                                {  
                                    len = USB_MAX_BULKOUT_BUFFERSIZE - pBulkMessage->nBytesRecieved;              
                                    // =============================== //
                                    // >>> Ïàìÿòü ïåðåïîëíåíà      <<< //
                                    // ------------------------------- //
                                    //     __                          //
                                    //   /    \  Ïàìÿòü ïåðåïîëíåíà    //
                                    //  |  X  |  Â áóôåðå íåò ìåñòà    //
                                    //  \ __ /   äëÿ êåøèðîâàíèÿ äàí-  //
                                    //           íûõ.                  //  
                                    // ------------------------------- //
                                }
                                pBulkData += len; //ïåðåäâèãàåì óêàçàòåëü çàïèñè. Ïî çàâåðøåíèè íóæíî çàïèñàòü ýòîò óêàçàòåëü â pPipeOut->pData                              
                                pBulkMessage->nBytesRecieved +=len;                      // óâåëè÷èâàåì ñ÷åò÷èê ïðèíÿòûõ áàéò
                
                                  //-----------------------------------------------------------------------------------------------
                             
                                 // see USBTMC spec, rev 1.0, 2003, page 11, table 7, point 6
                                 if(len > pPipeOut->dwLength)
                                  if(len - pPipeOut->dwLength > 3)   // it is not aligment bytes
                                    bNeedHaltEndpoint = TRUE;
                             
                                 //------------------------------------------------------------------
                                 // Âûÿñíÿåì, ñêîëüêî äàííûõ îñòàëîñü ïðèíÿòü
                                 // â pBulkEPStatus->OutPipe.dwLength ñîäåðæèòñÿ îæèäàåìîå êîëè÷åñòâî áàéò ñîîáùåíèÿ, êîòîðûå åùå íå ïðèíÿòû 
                                 if( bHostToDevice_Direction ) 
                                     pPipeOut->dwLength = (len > pPipeOut->dwLength)? 0: pPipeOut->dwLength-len;
                                 
                             //------------------------------------------------------------------
                             BOOL bShortPacketRecieved = ((len+((bItIsFirstPacket)?sizeof(BULKOUT_HEADER):0)) < USB_MAX_PACKET2)?TRUE:FALSE;
                             //-------------------------------------------------------------------------------------------------
                             // see USBTMC spec, rev 1.0, 2003, page 6, cipfer 4, "The device must consider the transfer complete when it has recieved and processed"
                             // - exactly the amount of data expected           : udi->EPBulkStatus.OutPipe.dwLength == 0
                             // - a packet with payload size less wMaxPacketSize: len < USB_MAX_PACKET2
                             //                                                 - òîëüêî len - äëèííà âñåãî ïàêåòà âìåñòå ñ çàãîëîâêîì
                             //see USBTMC spec, rev 1.0, 2003, page 11, table 7, point 4
                             if( bShortPacketRecieved && pPipeOut->dwLength != 0) // dwLength - åùå îñòàëîñü ïðèíÿòü
                                     bNeedHaltEndpoint = TRUE; 

                             // ------------------------------------------------------------------------------------ 
                             // -- ïðîïóñêàåì ïàêåò åñëè bNeedHaltEndpoint âñåãäà, çà èñêêëþ÷åíèåì: bBufferOverflow==TRUE && iDoubleBufferPeekAttempts == 0
                             bSkipPacket = bNeedHaltEndpoint;
                             if(bSkipPacket) {  bSkipPacket = (bBufferOverflow==FALSE);
                                                if( bSkipPacket )
                                                    bSkipPacket = (iDoubleBufferPeekAttempts > 0);
                                                    // îáðàáàòûâàåì ÑËÅÄÓÞÙÈÉ ïàêåò, ïîñëå ïàêåòà ïåðåïîëíèâøåãî áóôôåð
                                             }

                             // ------------------------------------------------------------------------------------ 
 
                             if( !bSkipPacket && (pPipeOut->dwLength == 0 || bShortPacketRecieved)) // åñëè ñîîáùåíèå ïîëíîñòüþ ïðèíÿòî
                             {                                           
                               pBulkMessage->OUTTransferInProgress = FALSE;
                               
                
                                  // =====================================================================
                                  // >>> Î áóôåðå è ðàçìåðå îòâåòíîãî ñîîáùåíèÿ                        <<<
                                  // ---------------------------------------------------------------------
                                  //   ____   Âíèìàíèå! Èñïîëüçóåòñÿ áóôåð ðàçìåðîì 1,5Êá, ñîîáùåíèÿ,
                                  //  /    \  ðàçìåðîì áîëüøå 1,5Êá îòïðàâëÿòü íåëüçÿ! Òàê êàê îòïðàâêà
                                  // |  X  |  ïðîèñõîäèò ïî ïðåðûâàíèþ è óêàçàòåëè ñäâèãàþòñÿ ïî ïðåðûâàíèþ,
                                  // \____/   â usbtmc_parse ñëåäóåò áûòü îñòîðîæíåå ñ ðàçìåðîì ïåðåäàâàåìûõ
                                  //          äàííûõ. Åñëè çàïèñàòü ïî óêàçàòåëþ pData äàííûõ áîëüøå ÷åì 1,5Êá
                                  //  âñå ïðîéäåò íåçàìåòíî è äàííûå âûëåçóò çà ãðàíèöó ìàññèâà è ïîéäåò êàòàâàñèÿ
                                  // =====================================================================
                                  
                                  if( bHostToDevice_Direction) // åñëè DEV_DEP_MSG_OUT ÷èñòèì áóôåð, îí çàïîëíèòñÿ äàííûìè, à êîãäà ïðèäåò REQUEST_DEV_DEP_MSG_IN óæå ÷èñòèòü íåëüçÿ, òàì îòâåò!
                                        {   
                                            usb_reset_pipe_status( pPipeIn );   
                                            usbtmc_flush_buffer ( USB_EP_LOG_ADDRESS_BULK_IN, pPipeIn ); 
                                        }
                                     
                                  rc = usbtmc_parse( udi, FALSE );   // Ðàçáèðàåì ñîîáùåíèå
                                                                   
                                  if( rc == TRUE ) 
                                    {
                                      // ÅÑËÈ ïðèøåë DEV_DEP_MSG_OUT        - äàííûå â âûõîäíîì áóôåðå (pPipeIn) íî äëèííà pPipeIn->dwLength ðàâíà íóëþ. Îíà èçìåíèòñÿ íà âàëèäíóþ â REQUEST_DEP_DEV_MSG_IN      
                                      // ÅÑËÈ ïðèøåë REQUEST_DEP_DEV_MSG_IN - äàííûå â áóôåðå, êîëè÷åñòâî îòïðàâëÿåìûõ äàííûõ ëåæèò â ïåðåìåííîé eps->InPipe.dwLength
                                      //if( bNeedHaltEndpoint ) //!#!
                                      //    pPipeIn->dwLength = 0; // ñîîáùåíèå ðàñïàðñåíî, íî òàê êàê ïåðåïîëíåíèå áûëî, äàííûõ ìû íå îòäàäèì! Íóæíî äëÿ INITIATE_ABORT_BULK_IN 
                                    }  
                                  else
                                     bNeedHaltEndpoint = TRUE; // see USBTMC spec, rev 1.0,2003, page 10, table 7, index =2
                                 
                                  
                                  pBulkMessage->bBulkHeaderRecieved = FALSE;        // ñáðîñèòü ôëàã çàãîëîâêà - òåïåðü íàäî ïðèíÿòü ñëåäóþùèé çàãîëîâîê, ïîòîê äàííûõ çàêîí÷èëñÿ
                                  
                                              
                                    
                             }
                             else
                             { // ñîîáùåíèå ïðèÿíÿòî íå ïîëíîñòüþ
                               // æäåì...
                             }
                             pPipeOut->pData = pBulkData;   // ñîõðàíÿåì ïîçèöèþ çàïèñè
                             //--------------------------------------------------------------------------------------------------
                     }
                     else {
                       //see USBTMC spec, rev 1.0, 2003, page 11, "3.2.2.4 Halt": 
                       //  +  "The device may Halt the endpoint for reasons other than those specified in Table 7."
                       //  +  The device does not receive a complete Bulk-OUT Header in the first transaction of the transfer.
                         bNeedHaltEndpoint = TRUE; 
                     }
                    //--------------------------------------------------------------------------------------------*
         
                     // ============ # INFO # ============= # ============ # =========== # =========== # ========
                     //
                     // len - ïåðåìåííàÿ, ñîäåðæàùàÿ êîëè÷åñòâî áàéò äàííûõ â ñîîáùåíèè, ïî àäðåñó pBulkData
                     // udi->EPBulkStatus.OutPipe.dwLength - ïåðåìåííàÿ, ñîäåðæàùàÿ îáùåå ÎÑÒÀÂØÅÅÑß êîëè÷åñòâî áàéò ïîñûëêè, êîòîðûå òðåáóåòñÿ ïðèíÿòü â ñëåäóþùèõ òðàíçàêöèÿõ ñîîáùåíèÿ   
                     //
                     // ============ # ---- # ============= # ============ # =========== # =========== # ========
        
         // ####...........................................................................................................####
         // ###################################################################################################################
                     
                     
        }// if(len>=treshold) ... 
        else {
           
          // see USBTMC spec, p 10, table 7
          // see USBTMC spec, p 6, point 4: "If the last data payload is wMaxPacketSize, the Host should not send a zero-length packet", 
          // should - íå ñëåäóåò, íî ìîæåò è ïîñëàòü, ïîýòîìó èãíîðèì íóëåâîé ïàêåò
          if(len>0) 
            bNeedHaltEndpoint = TRUE;  
        }
    
               
   }
   
   USB_INTERRUPT_ENABLE_BULKOUT();
   
   
   //---------------------------------------
   if( bNeedHaltEndpoint ) 
   /* --------------------------------------- */
   // ñì usbtmc.c :: usbtmc_HOOK_control_out()
   // abort() ïðîèçîéäåò êàê òîëüêî õîñò î÷èñòèò òî÷êó STALL->UNSTALL.
   // Abort() òàêæå ïðîèñçîéäåò åñëè õîñò ïðèøëåò initiate_abort_bulk_out() èëè initiate_clear()
   // ïîýòîìó ñìûñëà òóò äåëàòü abort() íåò, ê òîìó æå, íóæíî ñîõðàíèòü ñîñòîÿíèå, íà ñëó÷àé åñëè õîñò
   // âñå æå ïðèøëåò initiate_abort_bulk_out è ìû åìó îòâåòèì SUCCESS à íå STATUS_TRANSFER_NOT_IN_PROGRESS
         usb_stall_ep( USB_EP_LOG_ADDRESS_BULK_OUT, 0x01 );  // ïóñòü õîñò ïðèñûëàåò INITIATE_ABORT!
   /* --------------------------------------- */
}
//----------------------------------------------------------------------------

void usb_ep_clear_buffers( TENDPOINT_PHY_ADDRESS ep_num_physical )
{
  int ep_status = usb_lpc_cmd_read(CMD_EP_SELECT | ep_num_physical);
  if( ep_status & 0x60 )
  {  
              usb_lpc_cmd(CMD_EP_CLEAR_BUFFER);
              usb_lpc_cmd(CMD_EP_CLEAR_BUFFER);
  ep_status = usb_lpc_cmd_read(CMD_EP_SELECT | ep_num_physical);
              usb_lpc_cmd(CMD_EP_CLEAR_BUFFER);
  }
}

#endif