USB HID reports longer than 64 bytes on lpc1768

Hi Tsuneo,

thank you, I realized my mistake.

Now, I fixed my wMaxPacketSize IN and OUT at 0x0040 (64bytes) and my PC fully recognize my USB-HID.

I come now to send the PC to the LPC more than 64 bytes, but not the LPC to the PC.

Here is my example :

__task void USB_EndPoint1 (void) {
U16 evt;
static U32 report_size=0;

for (;;) {
  os_evt_wait_or(0xFFFF, 0xFFFF);         /* Wait for an Event */
  evt = os_evt_get();                     /* Get Event Flags */

  if (evt & USB_EVT_OUT) {                                 // OUT EP1 interrupt comes
    report_size += USB_ReadEP( HID_EP_OUT, &OutReport[report_size] );     //   read out the output report

    if(report_size==HID_OUTPUT_REPORT_BYTES)
    {
        memcpy(InReport, OutReport, report_size );
        report_size=0;
        os_sem_wait( USB_IN_EP1_Semaphore, 0xffff );           //   wait until IN EP is available
        USB_WriteEP( HID_EP_IN, InReport, HID_INPUT_REPORT_BYTES ); //   pass it to the endpoint
    }
  }

  if (evt & USB_EVT_IN)                                                                                                                                      // IN EP1 interrupt comes
    os_sem_send( USB_IN_EP1_Semaphore );                   //   IN EP1 is free

  }
}

When I look with USBlyzer, it warns me of bytes that will come but I do not see them.
Reception is not acknowledged.

I understand that the packets are mince by 64.
But the function USB_WriteEP() does not cut in blocks of 64?
do support the function more than 64 bytes?
do I change it?

U32 USB_WriteEP (U32 EPNum, U8 *pData, U32 cnt) {
  U32 n;
  os_mut_wait(USB_HW_Mutex, 0xFFFF);
  LPC_USB->USBCtrl = ((EPNum & 0x0F) << 2) | CTRL_WR_EN;
  LPC_USB->USBTxPLen = cnt;
  for (n = 0; n < (cnt + 3) / 4; n++) {
    LPC_USB->USBTxData = *((__packed U32 *)pData);
    pData += 4;
  }
  LPC_USB->USBCtrl = 0;
  WrCmdEP(EPNum, CMD_VALID_BUF);
  os_mut_release(USB_HW_Mutex);
  return (cnt);
}

> But the function USB_WriteEP() does not cut in blocks of 64?

No it doesn't.
USB_WriteEP() sends a packet, up to 64 bytes (wMaxPacketSize).
Like the OUT endpoint, your firmware has to split the report into 64 bytes packets.
Each packets is passed to USB_WriteEP() in USB_EVT_IN

__task void USB_EndPoint1 (void) {
U16 evt;
static U32 out_report_size = 0;
static U32 in_report_size = 0;
       U32 in_index;
       U32 in_send_size;

for (;;) {
  os_evt_wait_or(0xFFFF, 0xFFFF);         /* Wait for an Event */
  evt = os_evt_get();                     /* Get Event Flags */

  if (evt & USB_EVT_OUT) {                        // OUT EP1 interrupt comes
                                                  // read out the output report
    out_report_size += USB_ReadEP( HID_EP_OUT, &OutReport[out_report_size] );

    if(out_report_size == HID_OUTPUT_REPORT_BYTES)
    {
                                                  // wait until IN EP is available
        os_sem_wait( USB_IN_EP1_Semaphore, 0xffff );
                                                  // now, IN EP and its context is available
        memcpy(InReport, OutReport, out_report_size );
        in_report_size = out_report_size;
        in_index = 0;
        out_report_size = 0;
                                                  // force EP1 IN interrupt manually
        LPC_USB->USBEpIntSet = 1 << EPAdr(HID_EP_IN);
    }
  }

  if (evt&USB_EVT_IN) {                            // IN EP1 interrupt comes
    if ( in_report_size == 0 ) {                   // this interrupt is caused by the last packet?
      os_sem_send( USB_IN_EP1_Semaphore );         // IN EP1 is free

    } else {                                       // there remains bytes to be sent
      in_send_size = HID_IN_EP_MAXPACKET_SIZE;     // pick up a packet size
      if ( in_report_size < HID_IN_EP_MAXPACKET_SIZE ) {
        in_send_size = in_report_size;
      }
                                                   //   pass it to the endpoint
      USB_WriteEP( HID_EP_IN, InReport + in_index, in_send_size );
      in_report_size -= in_send_size;              // move counter and index by sent size
      in_index       += in_send_size;
    }
  }
}

Tsuneo

Aha, missed on this line

static U32 in_index;

Tsuneo

hi tsuneo,

thank for you help.

If I fixed my reports a 64 and I send several packets, there is no real difference ?