MSP430F5527: Modifying MPS430 Keyboard Project: Changing Consumer Control Report Usage ID from 8-bit to 16-bit

How are you sending the usage id to the computer? Do you send two bytes? Is the computer expecting 2 bytes?

There is an output buffer of 2 byes, the first byte is not used, the second byte is or'ed as a bitmap. The #defines are in the same order as the descriptor lists them.

#define CONSREP_DATA_OFFSET     (1)

#define hidUsageVolumeUp            0x1101  //bit 0 of Consumer Control Input Report
#define hidUsageVolumeDown          0x1102  //bit 1 of Consumer Control Input Report
#define hidUsageConsumerMute        0x1104  //bit 2 of Consumer Control Input Report
#define hidUsageApp1                0x1108  //bit 3 of Consumer Control Input Report
#define hidUsageApp2                0x1110  //bit 4 of Consumer Control Input Report
#define hidUsagePlay                0x1120  //bit 5 of Consumer Control Input Report
#define hidUsageBrightnessUp        0x1140  //bit 6 of Consumer Control Input Report
#define hidUsageBrightnessDown      0x1180  //bit 7 of Consumer Control Input Report


//in KBD320_Keyboard.c
if ((keycode & 0xFF00) == CONSUMER_KEY(0))
{
    #ifdef USE_CONSUMER_REPORT
    // Add key to Consumer Report
    KBD430_ConsReport_Addkey((keycode & 0x00FF));
    #endif
}

//in KBD430_report.c
/******************************************************************************
 * @brief  Adds key to the consumer report
 *   Note that the consumer report is bit-based, so it sets/clears bits when
 *   a key is pressed
 *
 * @param key   Bits being set in the report (value will be ORed with the report)
 *
 * @return  true 
 *****************************************************************************/
#ifdef USE_CONSUMER_REPORT
bool KBD430_ConsReport_Addkey( uint8_t key )
{
    ConsReport_buff.Buff[CONSREP_DATA_OFFSET] |= key;
    ConsReport_buff.Update = true;
    return true;
}
#endif

This buffer is then passed to a function that send it

#ifdef USE_CONSUMER_REPORT    
    if (ConsReport_buff.Update == true)
    {
        if (KBD430_ReportSend((uint8_t *)&ConsReport_buff.Buff[0], HID_Consumer) == true)
        {
            // Clear flag if the report was sent correctly
            ConsReport_buff.Update = false;
        }
    }
#endif

bool KBD430_ReportSend(uint8_t * reportData, uint8_t intfNum)
{
    if (USBHID_sendReport(reportData, intfNum) == kUSBHID_sendComplete)
    {
        return true;
    }
    else
    {
        return false;
    }
}

uint8_t USBHID_sendReport (const uint8_t * reportData, uint8_t intfNum)
{
    uint8_t byte_count;
    uint8_t * pEP1;
    uint8_t * pCT1;

    uint8_t edbIndex;

    edbIndex = stUsbHandle[intfNum].edb_Index;

    //do not access USB memory if suspended (PLL off). It may produce BUS_ERROR
    if ((bFunctionSuspended) ||
        (bEnumerationStatus != ENUMERATION_COMPLETE)){
        return (kUSBHID_busNotAvailable);
    }

    if (HidWriteCtrl[INTFNUM_OFFSET(intfNum)].bCurrentBufferXY == X_BUFFER){
        //this is the active EP buffer
        pEP1 = (uint8_t*)stUsbHandle[intfNum].iep_X_Buffer;
        pCT1 = &tInputEndPointDescriptorBlock[edbIndex].bEPBCTX;
    } else {
        //this is the active EP buffer
        pEP1 = (uint8_t*)stUsbHandle[intfNum].iep_Y_Buffer;
        pCT1 = &tInputEndPointDescriptorBlock[edbIndex].bEPBCTY;
    }

    byte_count = report_len_input[INTFNUM_OFFSET(intfNum)];

    if (*pCT1 & EPBCNT_NAK){                                                        //if this EP is empty
        USB_TX_memcpy(pEP1, reportData, byte_count);                                //copy data into IEP X or Y buffer
        uint8_t au8HIDReportDebug[10] = {0};
        memcpy(au8HIDReportDebug, reportData, byte_count);                                //copy data into IEP X or Y buffer
        *pCT1 = byte_count;                                                         //Set counter for usb In-Transaction
        HidWriteCtrl[INTFNUM_OFFSET(intfNum)].bCurrentBufferXY =
            (HidWriteCtrl[INTFNUM_OFFSET(intfNum)].bCurrentBufferXY + 1) & 0x01;    //switch buffer
        return (kUSBHID_sendComplete);
    }
    return (kUSBHID_intfBusyError);
}

So I assume it is always sending a single 8-bit bitmap of which the usages are defined during the descriptor creation. The size of the usages should not matter to the code.

Hi Pillip,

I do not have the experience on this library development.

One suggestion from my perspective is to check then whole send message logic to see whether its array counter is messed up with the increased data in the report_desc_HID2[].

B.R.

Sal