//*----------------------------------------------------------------------------
//* \fn    AT91F_UDP_IsConfigured
//* \brief Test if the device is configured and handle enumeration
//*----------------------------------------------------------------------------
static uchar AT91F_UDP_IsConfigured(AT91PS_CDC pCdc)
{
    AT91PS_UDP pUDP = pCdc->pUdp;
    AT91_REG isr = pUDP->UDP_ISR;

    if (isr & AT91C_UDP_ENDBUSRES) {
        pUDP->UDP_ICR = AT91C_UDP_ENDBUSRES;
        // reset all endpoints
        pUDP->UDP_RSTEP  = (unsigned int)-1;
        pUDP->UDP_RSTEP  = 0;
        // Enable the function
        pUDP->UDP_FADDR = AT91C_UDP_FEN;
        // Configure endpoint 0
        pUDP->UDP_CSR[0] = (AT91C_UDP_EPEDS | AT91C_UDP_EPTYPE_CTRL);
    }
    else if (isr & AT91C_UDP_EPINT0) {
        pUDP->UDP_ICR = AT91C_UDP_EPINT0;
        AT91F_CDC_Enumerate(pCdc);
    }
             else if (isr & AT91C_UDP_EPINT1){
             pUDP->UDP_ICR = AT91C_UDP_EPINT1;
         pUDP->UDP_CSR[1]=0; //подтверждает, что хост принял данные
             }
                  else if (isr & AT91C_UDP_EPINT2){
                  pUDP->UDP_ICR = AT91C_UDP_EPINT2;
                  AT91F_CDC_ReadData(pCdc);
                  }  
    return pCdc->currentConfiguration;
}

  extern struct _AT91S_CDC     pCDC;
  static char adrRT[64];
  AT91PS_UDP pUDP = pCdc->pUdp;
  
  pCDC.Read(&pCDC, adrRT,64);
  uint nbytes = AT91F_UDP_Read(pCdc, adrRT, 64);
  pUDP->UDP_CSR[2]=pUDP->UDP_CSR[2]&0x7FFFFFD;/*сброс бита  RX_DATA_BK0 -
подтвердение того, что данные из FIFO считаны*/  
  static char CWord[64];
  CWord[1] = nbytes;
  pCDC.Write(&pCDC,CWord,64);

// Enable User Reset and set its minimal assertion to 960 us
     AT91C_BASE_RSTC->RSTC_RMR = AT91C_RSTC_URSTEN | (0x4<<8) | (unsigned int)(0xA5<<24);
    
    // Init USB device
    AT91F_USB_Open();
    // Init USB device
    // Wait for the end of enumeration
    while (!pCDC.IsConfigured(&pCDC));  
    
    while(1);

#define MSG_SIZE                 1000
#define MIN(a, b) (((a) < (b)) ? (a) : (b))
#define AT91C_EP_IN_SIZE 0x40
#define UDP_INTERRUPT_LEVEL 0x7
//*--------------------------------------------------------------------------------------
//* Function Name       : main
//* Object              :
//*--------------------------------------------------------------------------------------
int main ( void )
{
  __ramfunc __arm void udp_c_irq_handler(void);  
  // Enable User Reset and set its minimal assertion to 960 us
     AT91C_BASE_RSTC->RSTC_RMR = AT91C_RSTC_URSTEN | (0x4<<8) | (unsigned int)(0xA5<<24);
    
    // Init USB device
    AT91F_USB_Open();
    // Init USB device
    // Wait for the end of enumeration
    while (!pCDC.IsConfigured(&pCDC));  
    pCDC.pUdp->UDP_ICR = 0xff00;
    AT91F_UDP_DisableIt ( pCDC.pUdp, 0xFFFF);
    AT91F_UDP_EnableIt (pCDC.pUdp, AT91C_UDP_EPINT2);
    AT91F_AIC_ConfigureIt ( AT91C_BASE_AIC, AT91C_ID_UDP, UDP_INTERRUPT_LEVEL,AT91C_AIC_SRCTYPE_INT_HIGH_LEVEL, udp_c_irq_handler);
    AT91F_AIC_EnableIt (AT91C_BASE_AIC, AT91C_ID_UDP);
  
  
}

//udp_c_irq_handler
    __ramfunc __arm void udp_c_irq_handler(void)
    {
      char buff_r[64];
      static char buff_w[64];
      pCDC.Write = UDP_Write;      
      pCDC.Read = UDP_Read;    
      
      unsigned int ret_val = pCDC.Read(&pCDC, buff_r,64);
      for(int i=0;i<64;i++)
      {
        buff_w[i] = i;
      }  
      pCDC.Write(&pCDC, buff_w,64);
    
    
    }    

//*----------------------------------------------------------------------------
//* \fn    UDP_Read
//* \brief Read available data from Endpoint OUT 2
//*----------------------------------------------------------------------------
__ramfunc __arm unsigned int UDP_Read(AT91PS_CDC pCdc, char *data_in, unsigned int length_in)
{      
      AT91PS_UDP pUdp = pCDC.pUdp;      
      unsigned int packetSize, nbBytesRcv = 0, currentReceiveBank = pCDC.currentRcvBank;
      pUdp->UDP_CSR[AT91C_EP_OUT] &= ~(AT91C_UDP_TXCOMP | AT91C_UDP_RXSETUP | AT91C_UDP_ISOERROR );
      
      while (length_in)
      {
        if ( pUdp->UDP_CSR[AT91C_EP_OUT] & (AT91C_UDP_RX_DATA_BK0 | AT91C_UDP_RX_DATA_BK1) ) {
        packetSize = MIN(pUdp->UDP_CSR[AT91C_EP_OUT] >> 16, length_in);
        length_in -= packetSize;
        if (packetSize < AT91C_EP_OUT_SIZE)
        length_in = 0;
        while(packetSize--)
        data_in[nbBytesRcv++] = pUdp->UDP_FDR[AT91C_EP_OUT];
        pUdp->UDP_CSR[AT91C_EP_OUT] &= ~(currentReceiveBank);
        if (currentReceiveBank == AT91C_UDP_RX_DATA_BK0)
        currentReceiveBank = AT91C_UDP_RX_DATA_BK1;
        else
        currentReceiveBank = AT91C_UDP_RX_DATA_BK0;
        }
      }
       pCDC.currentRcvBank = currentReceiveBank;
      return nbBytesRcv;
}

//*----------------------------------------------------------------------------
//* \fn    UDP_Write
//* \brief Send through endpoint 1
//*----------------------------------------------------------------------------
__ramfunc __arm unsigned int UDP_Write(AT91PS_CDC pCdc, const char *pData, unsigned int length)
{
    AT91PS_UDP pUdp = pCdc->pUdp;
unsigned int cpt = 0;
if (length)
while ( (pUdp->UDP_CSR[AT91C_EP_IN] & AT91C_UDP_TXPKTRDY) && !(pUdp->UDP_ISR & AT91C_UDP_RXSUSP) );
// Send the first packet
cpt = MIN(length, AT91C_EP_IN_SIZE);
length -= cpt;
while (cpt--) pUdp->UDP_FDR[AT91C_EP_IN] = *pData++;
pUdp->UDP_CSR[AT91C_EP_IN] |= AT91C_UDP_TXPKTRDY;
while (length) {
// Fill the second bank
cpt = MIN(length, AT91C_EP_IN_SIZE);
length -= cpt;
while ( (pUdp->UDP_CSR[AT91C_EP_IN] & AT91C_UDP_TXPKTRDY) && !(pUdp->UDP_ISR & AT91C_UDP_RXSUSP) );
if ( pUdp->UDP_ISR & AT91C_UDP_RXSUSP ) return length;
while (cpt--) pUdp->UDP_FDR[AT91C_EP_IN] = *pData++;
// Wait for the the first bank to be sent
while ( !(pUdp->UDP_CSR[AT91C_EP_IN] & AT91C_UDP_TXCOMP) )
//if ( !AT91F_UDP_IsConfigured(pCdc) )
//return length;
pUdp->UDP_CSR[AT91C_EP_IN] &= ~(AT91C_UDP_TXCOMP);
while (pUdp->UDP_CSR[AT91C_EP_IN] & AT91C_UDP_TXCOMP);
pUdp->UDP_CSR[AT91C_EP_IN] |= AT91C_UDP_TXPKTRDY;
}
// Wait for the end of transfer
while ( !(pUdp->UDP_CSR[AT91C_EP_IN] & AT91C_UDP_TXCOMP) ){
//if ( !AT91F_UDP_IsConfigured(pCdc) )
//return length;
};
pUdp->UDP_CSR[AT91C_EP_IN] &= ~(AT91C_UDP_TXCOMP);
while (pUdp->UDP_CSR[AT91C_EP_IN] & AT91C_UDP_TXCOMP);

return length;
}

#define MSG_SIZE                 1000
#define MIN(a, b) (((a) < (b)) ? (a) : (b))
#define AT91C_EP_IN_SIZE 0x40
#define UDP_INTERRUPT_LEVEL 0x7
//*--------------------------------------------------------------------------------------
//* Function Name       : main
//* Object              :
//*--------------------------------------------------------------------------------------
int main ( void )
{
  __ramfunc __arm void udp_c_irq_handler(void);  
  // Enable User Reset and set its minimal assertion to 960 us
     AT91C_BASE_RSTC->RSTC_RMR = AT91C_RSTC_URSTEN | (0x4<<8) | (unsigned int)(0xA5<<24);    
    // Init USB device
    AT91F_USB_Open();
    // Init USB device
    // Wait for the end of enumeration
    while (!pCDC.IsConfigured(&pCDC));  
    pCDC.pUdp->UDP_ICR = 0xff00;
    AT91F_UDP_DisableIt ( pCDC.pUdp, 0xFFFF);
    AT91F_UDP_EnableIt (pCDC.pUdp, AT91C_UDP_EPINT2);
    AT91F_AIC_ConfigureIt ( AT91C_BASE_AIC, AT91C_ID_UDP, UDP_INTERRUPT_LEVEL,AT91C_AIC_SRCTYPE_INT_HIGH_LEVEL, udp_c_irq_handler);
    AT91F_AIC_EnableIt (AT91C_BASE_AIC, AT91C_ID_UDP);  
}

//udp_c_irq_handler
    __ramfunc __arm void udp_c_irq_handler(void)
    {
      char buff_r[64];
      static char buff_w[64];
      pCDC.Write = UDP_Write;      
      pCDC.Read = UDP_Read;          
      
      pCDC.Read(&pCDC, buff_r,64);
      
      for(int i=0;i<64;i++)
      {
        buff_w[i] = i;
      }  
      pCDC.Write(&pCDC, buff_w,64);    
    
    }

#pragma vector = 0x18
__irq __arm void IRQ_Switch()
{
    void (*Handler)() = (void(*)())AT91C_BASE_AIC->AIC_IVR;
    Handler();
    AT91C_BASE_AIC->AIC_EOICR = 0;                    // Reset AIC logic
}

#pragma vector = 0x18
__irq __arm void IRQ_Switch()
{
    void (*udp_c_irq_handler)() = (void(*)())AT91C_BASE_AIC->AIC_IVR;
    udp_c_irq_handler();
    AT91C_BASE_AIC->AIC_EOICR = 0;                    // Reset AIC logic
}

int main ( void )
{
  __ramfunc __arm void udp_c_irq_handler(void);  
  // Enable User Reset and set its minimal assertion to 960 us
     AT91C_BASE_RSTC->RSTC_RMR = AT91C_RSTC_URSTEN | (0x4<<8) | (unsigned int)(0xA5<<24);    
    // Init USB device
    AT91F_USB_Open();
    // Init USB device
    // Wait for the end of enumeration
    while(!pCDC.IsConfigured(&pCDC));
    
    AT91C_BASE_AIC->AIC_IECR |= (1<<AT91C_ID_UDP);
    AT91C_BASE_AIC->AIC_IDCR = ~AT91C_BASE_AIC->AIC_IECR;
    
    pCDC.pUdp->UDP_ICR = 0xff00;
    AT91F_UDP_DisableIt ( pCDC.pUdp, 0xFFFF);
    AT91F_UDP_EnableIt (pCDC.pUdp, AT91C_UDP_EPINT2);
    AT91F_AIC_ConfigureIt ( AT91C_BASE_AIC, AT91C_ID_UDP, UDP_INTERRUPT_LEVEL,AT91C_AIC_SRCTYPE_HIGH_LEVEL, udp_c_irq_handler);
    AT91F_AIC_EnableIt (AT91C_BASE_AIC, AT91C_ID_UDP);  
}

//udp_c_irq_handler
    __ramfunc __arm void udp_c_irq_handler(void)
    {
      char buff_r[64];
      static char buff_w[64];
      //pCDC.Write = UDP_Write;      
      //pCDC.Read = UDP_Read;
      
      unsigned int ret_val = UDP_Read(&pCDC, buff_r,64);
      for(int i=0;i<64;i++)
      {
        buff_w[i] = i;
      }  
      UDP_Write(&pCDC, buff_w,64);    
    }