Changeset 8d96947 in avrstuff


Ignore:
Timestamp:
Feb 7, 2023, 9:03:10 PM (15 months ago)
Author:
PulkoMandy <pulkomandy@…>
Branches:
main
Children:
88a38a8
Parents:
110c692
Message:

More untested code for PCW to HID keyboard adapter

  • Use VOTI shared keyboard ID
  • Use standard keyboard descriptor from LUFA demo
  • Don't scan past row 10 of the PCW keyboard (we don't need more)
  • Convert PCW keys to (roughly) corresponding USB HID keycodes

TODO:

  • If shift is pressed, maybe convert f1/3/5/7 to f2/4/6/8
  • Some keys (ab)use F2/4/6/8 keycodes, move them to F9-F12 instead
  • Some keys use "unusual" keycodes (cancel, stop), maybe move to more common ones
Location:
kbd/pcw2hid/code
Files:
5 edited

Legend:

Unmodified
Added
Removed

  • kbd/pcw2hid/code/Descriptors.c

    r110c692 r8d96947  
    4444 *  more details on HID report descriptors.
    4545 */
    46 const USB_Descriptor_HIDReport_Datatype_t PROGMEM JoystickReport[] =
    47 {
    48                         HID_RI_USAGE_PAGE(8, 0x01),
    49                         HID_RI_USAGE(8, 0x04),
    50                         HID_RI_COLLECTION(8, 0x01),
    51 
    52                                 0x85, 0x01, // Report ID 1
    53 
    54                                 // 15 constant bytes
    55                                 HID_RI_REPORT_SIZE(8, 15),
    56                                 HID_RI_REPORT_COUNT(8, 0x01),
    57                                 HID_RI_INPUT(8, HID_IOF_CONSTANT),
    58 
    59                                 HID_RI_USAGE_PAGE(8, 0x09),
    60                                 HID_RI_LOGICAL_MINIMUM(8, 0x00),
    61                                 HID_RI_LOGICAL_MAXIMUM(8, 0x01),
    62 
    63                                 HID_RI_USAGE_MINIMUM(8, 7),
    64                                 HID_RI_USAGE_MAXIMUM(8, 9),
    65                                 HID_RI_USAGE(8, 4),
    66                                 HID_RI_REPORT_SIZE(8, 0x01),
    67                                 HID_RI_REPORT_COUNT(8, 4),
    68                                 HID_RI_INPUT(8, HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_ABSOLUTE),
    69 
    70                                 HID_RI_REPORT_SIZE(8, 1),
    71                                 HID_RI_REPORT_COUNT(8, 0x01),
    72                                 HID_RI_INPUT(8, HID_IOF_CONSTANT),
    73 
    74                                 HID_RI_USAGE(8, 10),
    75                                 HID_RI_USAGE_MINIMUM(8, 1),
    76                                 HID_RI_USAGE_MAXIMUM(8, 3),
    77                                 HID_RI_REPORT_SIZE(8, 0x01),
    78                                 HID_RI_REPORT_COUNT(8, 4),
    79                                 HID_RI_INPUT(8, HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_ABSOLUTE),
    80 
    81                                 HID_RI_REPORT_SIZE(8, 1),
    82                                 HID_RI_REPORT_COUNT(8, 0x01),
    83                                 HID_RI_INPUT(8, HID_IOF_CONSTANT),
    84 
    85                                 HID_RI_USAGE_MINIMUM(8, 5),
    86                                 HID_RI_USAGE_MAXIMUM(8, 6),
    87                                 HID_RI_REPORT_SIZE(8, 0x01),
    88                                 HID_RI_REPORT_COUNT(8, 2),
    89                                 HID_RI_INPUT(8, HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_ABSOLUTE),
    90 
    91                                 HID_RI_USAGE_PAGE(8, 0x01),
    92                                 HID_RI_USAGE(8, 0x01),
    93                                 HID_RI_COLLECTION(8, 0x00),
    94                                         HID_RI_USAGE(8, 0x31),
    95                                         HID_RI_LOGICAL_MINIMUM(8, -2),
    96                                         HID_RI_LOGICAL_MAXIMUM(8, 1),
    97                                         HID_RI_REPORT_COUNT(8, 1),
    98                                         HID_RI_REPORT_SIZE(8, 2),
    99                                         HID_RI_INPUT(8, HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_ABSOLUTE),
    100 
    101                                         HID_RI_REPORT_SIZE(8, 1),
    102                                         HID_RI_REPORT_COUNT(8, 0x01),
    103                                         HID_RI_INPUT(8, HID_IOF_CONSTANT),
    104 
    105                                         HID_RI_USAGE(8, 0x30),
    106                                         HID_RI_LOGICAL_MINIMUM(8, -2),
    107                                         HID_RI_LOGICAL_MAXIMUM(8, 1),
    108                                         HID_RI_REPORT_COUNT(8, 1),
    109                                         HID_RI_REPORT_SIZE(8, 2),
    110                                         HID_RI_INPUT(8, HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_ABSOLUTE),
    111                                 HID_RI_END_COLLECTION(0),
    112 
    113                         HID_RI_END_COLLECTION(0)
     46const USB_Descriptor_HIDReport_Datatype_t PROGMEM KeyboardReport[] =
     47{
     48        /* Use the HID class driver's standard Keyboard report.
     49         *   Max simultaneous keys: 6
     50         */
     51        HID_DESCRIPTOR_KEYBOARD(6)
    11452};
    11553
    … …  
    13169
    13270        .VendorID               = 0x16c0,
    133         .ProductID              = 0x27dc,
     71        .ProductID              = 0x27db,
    13472        .ReleaseNumber          = VERSION_BCD(0,0,1),
    13573
    … …  
    167105                        .Header                 = {.Size = sizeof(USB_Descriptor_Interface_t), .Type = DTYPE_Interface},
    168106
    169                         .InterfaceNumber        = INTERFACE_ID_Joystick,
     107                        .InterfaceNumber        = INTERFACE_ID_Keyboard,
    170108                        .AlternateSetting       = 0x00,
    171109
    … …  
    173111
    174112                        .Class                  = HID_CSCP_HIDClass,
    175                         .SubClass               = HID_CSCP_NonBootSubclass,
    176                         .Protocol               = HID_CSCP_NonBootProtocol,
     113                        .SubClass               = HID_CSCP_BootSubclass,
     114                        .Protocol               = HID_CSCP_KeyboardBootProtocol,
    177115
    178116                        .InterfaceStrIndex      = NO_DESCRIPTOR
    179117                },
    180118
    181         .HID_JoystickHID =
     119        .HID_KeyboardHID =
    182120                {
    183121                        .Header                 = {.Size = sizeof(USB_HID_Descriptor_HID_t), .Type = HID_DTYPE_HID},
    … …  
    187125                        .TotalReportDescriptors = 1,
    188126                        .HIDReportType          = HID_DTYPE_Report,
    189                         .HIDReportLength        = sizeof(JoystickReport)
     127                        .HIDReportLength        = sizeof(KeyboardReport)
    190128                },
    191129
    … …  
    194132                        .Header                 = {.Size = sizeof(USB_Descriptor_Endpoint_t), .Type = DTYPE_Endpoint},
    195133
    196                         .EndpointAddress        = JOYSTICK_EPADDR,
     134                        .EndpointAddress        = KEYBOARD_EPADDR,
    197135                        .Attributes             = (EP_TYPE_INTERRUPT | ENDPOINT_ATTR_NO_SYNC | ENDPOINT_USAGE_DATA),
    198                         .EndpointSize           = JOYSTICK_EPSIZE,
     136                        .EndpointSize           = KEYBOARD_EPSIZE,
    199137                        .PollingIntervalMS      = 0x05
    200138                }
    … …  
    264202                        break;
    265203                case HID_DTYPE_HID:
    266                         Address = &ConfigurationDescriptor.HID_JoystickHID;
     204                        Address = &ConfigurationDescriptor.HID_KeyboardHID;
    267205                        Size    = sizeof(USB_HID_Descriptor_HID_t);
    268206                        break;
    269207                case HID_DTYPE_Report:
    270                         Address = &JoystickReport;
    271                         Size    = sizeof(JoystickReport);
     208                        Address = &KeyboardReport;
     209                        Size    = sizeof(KeyboardReport);
    272210                        break;
    273211        }

  • kbd/pcw2hid/code/Descriptors.h

    r110c692 r8d96947  
    5151                        USB_Descriptor_Configuration_Header_t Config;
    5252
    53                         // Joystick HID Interface
     53                        // Keyboard HID Interface
    5454                        USB_Descriptor_Interface_t            HID_Interface;
    55                         USB_HID_Descriptor_HID_t              HID_JoystickHID;
    56                 USB_Descriptor_Endpoint_t             HID_ReportINEndpoint;
     55                        USB_HID_Descriptor_HID_t              HID_KeyboardHID;
     56                        USB_Descriptor_Endpoint_t             HID_ReportINEndpoint;
    5757                } USB_Descriptor_Configuration_t;
    5858
    … …  
    6363                enum InterfaceDescriptors_t
    6464                {
    65                         INTERFACE_ID_Joystick = 0, /**< Joystick interface desciptor ID */
     65                        INTERFACE_ID_Keyboard = 0, /**< Keyboard interface descriptor ID */
    6666                };
    6767
    … …  
    7878
    7979        /* Macros: */
    80                 /** Endpoint address of the Joystick HID reporting IN endpoint. */
    81                 #define JOYSTICK_EPADDR              (ENDPOINT_DIR_IN | 1)
     80                /** Endpoint address of the Keyboard HID reporting IN endpoint. */
     81                #define KEYBOARD_EPADDR              (ENDPOINT_DIR_IN | 1)
    8282
    83                 /** Size in bytes of the Joystick HID reporting IN endpoint. */
    84                 #define JOYSTICK_EPSIZE              16
     83                /** Size in bytes of the Keyboard HID reporting IN endpoint. */
     84                #define KEYBOARD_EPSIZE              8
    8585
    8686        /* Function Prototypes: */

  • kbd/pcw2hid/code/Keyboard.c

    r110c692 r8d96947  
    3131/** \file
    3232 *
    33  *  Main source file for the Joystick demo. This file contains the main tasks of
     33 *  Main source file for the Keyboard demo. This file contains the main tasks of
    3434 *  the demo and is responsible for the initial application hardware configuration.
    3535 */
    … …  
    3737#include "Keyboard.h"
    3838
    39 extern void PCW_Init();
    40 extern void scanall();
    41 
    42 /** Buffer to hold the previously generated HID report, for comparison purposes inside the HID class driver. */
    43 static uint8_t PrevJoystickHIDReportBuffer[4];
     39extern void PCW_Init(void);
     40extern uint8_t* scanall(void);
     41
     42/** Buffer to hold the previously generated Keyboard HID report, for comparison purposes inside the HID class driver. */
     43static uint8_t PrevKeyboardHIDReportBuffer[sizeof(USB_KeyboardReport_Data_t)];
    4444
    4545/** LUFA HID Class driver interface configuration and state information. This structure is
    … …  
    4747 *  within a device can be differentiated from one another.
    4848 */
    49 USB_ClassInfo_HID_Device_t Joystick_HID_Interface =
     49USB_ClassInfo_HID_Device_t Keyboard_HID_Interface =
    5050        {
    5151                .Config =
    5252                        {
    53                                 .InterfaceNumber              = INTERFACE_ID_Joystick,
     53                                .InterfaceNumber              = INTERFACE_ID_Keyboard,
    5454                                .ReportINEndpoint             =
    5555                                        {
    56                                                 .Address              = JOYSTICK_EPADDR,
    57                                                 .Size                 = JOYSTICK_EPSIZE,
     56                                                .Address              = KEYBOARD_EPADDR,
     57                                                .Size                 = KEYBOARD_EPSIZE,
    5858                                                .Banks                = 1,
    5959                                        },
    60                                 .PrevReportINBuffer           = PrevJoystickHIDReportBuffer,
    61                                 .PrevReportINBufferSize       = sizeof(PrevJoystickHIDReportBuffer),
     60                                .PrevReportINBuffer           = PrevKeyboardHIDReportBuffer,
     61                                .PrevReportINBufferSize       = sizeof(PrevKeyboardHIDReportBuffer),
    6262                        },
    6363        };
    … …  
    7676        for (;;)
    7777        {
    78                 HID_Device_USBTask(&Joystick_HID_Interface);
     78                HID_Device_USBTask(&Keyboard_HID_Interface);
    7979                USB_USBTask();
    8080        }
    … …  
    127127        bool ConfigSuccess = true;
    128128
    129         ConfigSuccess &= HID_Device_ConfigureEndpoints(&Joystick_HID_Interface);
     129        ConfigSuccess &= HID_Device_ConfigureEndpoints(&Keyboard_HID_Interface);
    130130
    131131        USB_Device_EnableSOFEvents();
    … …  
    137137void EVENT_USB_Device_ControlRequest(void)
    138138{
    139         HID_Device_ProcessControlRequest(&Joystick_HID_Interface);
     139        HID_Device_ProcessControlRequest(&Keyboard_HID_Interface);
    140140}
    141141
    … …  
    143143void EVENT_USB_Device_StartOfFrame(void)
    144144{
    145         HID_Device_MillisecondElapsed(&Joystick_HID_Interface);
     145        HID_Device_MillisecondElapsed(&Keyboard_HID_Interface);
    146146}
    147147
    … …  
    162162                                         uint16_t* const ReportSize)
    163163{
     164        USB_KeyboardReport_Data_t* KeyboardReport = (USB_KeyboardReport_Data_t*)ReportData;
     165
    164166        uint8_t* matrix = scanall();
    165         *ReportID = 1;
    166 
    167         *ReportSize = 16;
    168         for (int i = 0; i < 16; i++) {
    169                 ReportData[i] = matrix[i];
    170         }
    171         return true;
     167
     168        uint8_t UsedKeyCodes = 0;
     169
     170#define MAP(i, j, k) \
     171        if (matrix[i] & (1 << j)) \
     172                KeyboardReport->KeyCode[UsedKeyCodes++] = k; \
     173        if (UsedKeyCodes == 6) \
     174                goto full;
     175
     176#define MODIFIER(i, j, k) \
     177        if (matrix[i] & (1 << j)) \
     178                KeyboardReport->Modifier |= k;
     179
     180        MAP(0, 7, HID_KEYBOARD_SC_KEYPAD_2_AND_DOWN_ARROW);
     181        MAP(0, 6, HID_KEYBOARD_SC_KEYPAD_3_AND_PAGE_DOWN);
     182        MAP(0, 5, HID_KEYBOARD_SC_KEYPAD_6_AND_RIGHT_ARROW);
     183        MAP(0, 4, HID_KEYBOARD_SC_KEYPAD_9_AND_PAGE_UP);
     184        MAP(0, 3, HID_KEYBOARD_SC_PASTE);
     185        MAP(0, 2, HID_KEYBOARD_SC_F1);
     186        MAP(0, 1, HID_KEYBOARD_SC_KEYPAD_0_AND_INSERT);
     187        MAP(0, 0, HID_KEYBOARD_SC_F3);
     188
     189        MAP(1, 7, HID_KEYBOARD_SC_KEYPAD_1_AND_END);
     190        MAP(1, 6, HID_KEYBOARD_SC_KEYPAD_5);
     191        MAP(1, 5, HID_KEYBOARD_SC_KEYPAD_4_AND_LEFT_ARROW);
     192        MAP(1, 4, HID_KEYBOARD_SC_KEYPAD_8_AND_UP_ARROW);
     193        MAP(1, 3, HID_KEYBOARD_SC_COPY);
     194        MAP(1, 2, HID_KEYBOARD_SC_CUT);
     195        MAP(1, 1, HID_KEYBOARD_SC_F2);
     196        MAP(1, 0, HID_KEYBOARD_SC_F4);
     197
     198        MAP(2, 7, HID_KEYBOARD_SC_KEYPAD_PLUS);
     199        MAP(2, 6, HID_KEYBOARD_SC_NON_US_HASHMARK_AND_TILDE);
     200        MODIFIER(2, 5, HID_KEYBOARD_MODIFIER_LEFTSHIFT | HID_KEYBOARD_MODIFIER_RIGHTSHIFT);
     201        MAP(2, 4, HID_KEYBOARD_SC_KEYPAD_7_AND_HOME);
     202        MAP(2, 3, HID_KEYBOARD_SC_BACKSLASH_AND_PIPE);
     203        MAP(2, 2, HID_KEYBOARD_SC_ENTER);
     204        MAP(2, 1, HID_KEYBOARD_SC_CLOSING_BRACKET_AND_CLOSING_BRACE);
     205        MAP(2, 0, HID_KEYBOARD_SC_DELETE);
     206
     207        MAP(3, 7, HID_KEYBOARD_SC_DOT_AND_GREATER_THAN_SIGN);
     208        MAP(3, 6, HID_KEYBOARD_SC_SLASH_AND_QUESTION_MARK);
     209        MAP(3, 5, HID_KEYBOARD_SC_SEMICOLON_AND_COLON);
     210        MAP(3, 4, HID_KEYBOARD_SC_APOSTROPHE_AND_QUOTE);
     211        MAP(3, 3, HID_KEYBOARD_SC_P);
     212        MAP(3, 2, HID_KEYBOARD_SC_OPENING_BRACKET_AND_OPENING_BRACE);
     213        MAP(3, 1, HID_KEYBOARD_SC_MINUS_AND_UNDERSCORE);
     214        MAP(3, 0, HID_KEYBOARD_SC_EQUAL_AND_PLUS);
     215
     216        MAP(4, 7, HID_KEYBOARD_SC_COMMA_AND_LESS_THAN_SIGN);
     217        MAP(4, 6, HID_KEYBOARD_SC_M);
     218        MAP(4, 5, HID_KEYBOARD_SC_K);
     219        MAP(4, 4, HID_KEYBOARD_SC_L);
     220        MAP(4, 3, HID_KEYBOARD_SC_I);
     221        MAP(4, 2, HID_KEYBOARD_SC_O);
     222        MAP(4, 1, HID_KEYBOARD_SC_9_AND_OPENING_PARENTHESIS);
     223        MAP(4, 0, HID_KEYBOARD_SC_0_AND_CLOSING_PARENTHESIS);
     224
     225        MAP(5, 7, HID_KEYBOARD_SC_SPACE);
     226        MAP(5, 6, HID_KEYBOARD_SC_N);
     227        MAP(5, 5, HID_KEYBOARD_SC_J);
     228        MAP(5, 4, HID_KEYBOARD_SC_H);
     229        MAP(5, 3, HID_KEYBOARD_SC_Y);
     230        MAP(5, 2, HID_KEYBOARD_SC_U);
     231        MAP(5, 1, HID_KEYBOARD_SC_7_AND_AMPERSAND);
     232        MAP(5, 0, HID_KEYBOARD_SC_8_AND_ASTERISK);
     233
     234        MAP(6, 7, HID_KEYBOARD_SC_V);
     235        MAP(6, 6, HID_KEYBOARD_SC_B);
     236        MAP(6, 5, HID_KEYBOARD_SC_F);
     237        MAP(6, 4, HID_KEYBOARD_SC_G);
     238        MAP(6, 3, HID_KEYBOARD_SC_T);
     239        MAP(6, 2, HID_KEYBOARD_SC_R);
     240        MAP(6, 1, HID_KEYBOARD_SC_S);
     241        MAP(6, 0, HID_KEYBOARD_SC_6_AND_CARET);
     242
     243        MAP(7, 7, HID_KEYBOARD_SC_X);
     244        MAP(7, 6, HID_KEYBOARD_SC_C);
     245        MAP(7, 5, HID_KEYBOARD_SC_D);
     246        MAP(7, 4, HID_KEYBOARD_SC_S);
     247        MAP(7, 3, HID_KEYBOARD_SC_W);
     248        MAP(7, 2, HID_KEYBOARD_SC_E);
     249        MAP(7, 1, HID_KEYBOARD_SC_3_AND_HASHMARK);
     250        MAP(7, 0, HID_KEYBOARD_SC_4_AND_DOLLAR);
     251
     252        MAP(8, 7, HID_KEYBOARD_SC_Z);
     253        MAP(8, 6, HID_KEYBOARD_SC_CAPS_LOCK);
     254        MAP(8, 5, HID_KEYBOARD_SC_A);
     255        MAP(8, 4, HID_KEYBOARD_SC_TAB);
     256        MAP(8, 3, HID_KEYBOARD_SC_Q);
     257        MAP(8, 2, HID_KEYBOARD_SC_STOP);
     258        MAP(8, 1, HID_KEYBOARD_SC_2_AND_AT);
     259        MAP(8, 0, HID_KEYBOARD_SC_1_AND_EXCLAMATION);
     260
     261        MAP(9, 7, HID_KEYBOARD_SC_BACKSPACE);
     262        //MAP(9, 6, HID_KEYBOARD_SC_CAPS_LOCK);
     263        MAP(9, 5, HID_KEYBOARD_SC_F6);
     264        MAP(9, 4, HID_KEYBOARD_SC_F8);
     265        MAP(9, 3, HID_KEYBOARD_SC_RIGHT_ARROW);
     266        MAP(9, 2, HID_KEYBOARD_SC_LEFT_ARROW);
     267        MAP(9, 1, HID_KEYBOARD_SC_DOWN_ARROW);
     268        MAP(9, 0, HID_KEYBOARD_SC_UP_ARROW);
     269
     270        MODIFIER(10, 7, HID_KEYBOARD_MODIFIER_LEFTALT | HID_KEYBOARD_MODIFIER_RIGHTALT);
     271        MAP(10, 6, HID_KEYBOARD_SC_KEYPAD_DOT_AND_DELETE);
     272        MAP(10, 5, HID_KEYBOARD_SC_KEYPAD_ENTER);
     273        MAP(10, 4, HID_KEYBOARD_SC_F7);
     274        MAP(10, 3, HID_KEYBOARD_SC_KEYPAD_MINUS);
     275        MAP(10, 2, HID_KEYBOARD_SC_CANCEL);
     276        MAP(10, 1, HID_KEYBOARD_SC_HOME);
     277        MAP(10, 0, HID_KEYBOARD_SC_F5);
     278
     279full:
     280        *ReportSize = sizeof(USB_KeyboardReport_Data_t);
     281        return false;
    172282}
    173283

  • kbd/pcw2hid/code/Keyboard.h

    r110c692 r8d96947  
    3131/** \file
    3232 *
    33  *  Header file for Joystick.c.
     33 *  Header file for Keyboard.c.
    3434 */
    3535
    36 #ifndef _JOYSTICK_H_
    37 #define _JOYSTICK_H_
     36#ifndef _KEYBOARD_H_
     37#define _KEYBOARD_H_
    3838
    3939        /* Includes: */

  • kbd/pcw2hid/code/protocol.cpp

    r110c692 r8d96947  
    7575        do {
    7676                address = scanbyte();
    77         } while ((address < 15) && (kmatrix[15] & 0x80 != 0));
     77        // } while ((address < 15) && ((kmatrix[15] & 0x80) != 0));
     78        } while ((address != 10) && ((kmatrix[15] & 0x80) != 0));
     79        // nothing interesting past row 10, so stop scanning there.
    7880
    7981        return kmatrix;
Note: See TracChangeset for help on using the changeset viewer.