usb_keyboard.c

Go to the documentation of this file.

// Copyright 2021 IOsetting <iosetting(at)outlook.com>
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
 
#include "fw_hal.h"
#include <string.h>
 
#define KeyIO P0
 
__BIT B_1ms;         // 1ms flag
__BIT KeyChangeTemp;
__BIT KeyChangeFlag;
uint16_t cnt50ms;
uint16_t KeyCode;       // code of key pressed
uint16_t OldKeyCode;    // for key status changing check
uint16_t NewKeyCode;    // new key status
uint16_t KeyHoldTime;
 
__CODE uint8_t DEVICEDESC[18];
__CODE uint8_t CONFIGDESC[41];
__CODE uint8_t HIDREPORTDESC[63];
__CODE uint8_t LANGIDDESC[4];
__CODE uint8_t MANUFACTDESC[8];
__CODE uint8_t PRODUCTDESC[30];
__CODE uint8_t KeyMap[16];
__XDATA uint8_t HidFreature[64];
__XDATA uint8_t HidInput[64];
__XDATA uint8_t HidOutput[64];
USB_Request_t usb_request;
USB_EP0_Stage_t usb_ep0_stage;
 
void USB_Init(void);
void KeyScan(void);
void SendKeyStatus(void);
 
void main()
{
    uint8_t i;
 
    GPIO_P1_SetMode(GPIO_Pin_All, GPIO_Mode_InOut_QBD);
    GPIO_P3_SetMode(GPIO_Pin_0 | GPIO_Pin_1, GPIO_Mode_Input_HIP);
    GPIO_P6_SetMode(GPIO_Pin_All, GPIO_Mode_Output_PP);
 
    USB_Init();
 
    TIM_Timer0_Config(HAL_State_ON, TIM_TimerMode_16BitAuto, 1000);
    EXTI_Timer0_SetIntState(HAL_State_ON);
    EXTI_Timer0_SetIntPriority(EXTI_IntPriority_High);
    TIM_Timer0_SetRunState(HAL_State_ON);
    EXTI_Global_SetIntState(HAL_State_ON);
 
    for (i = 0; i < 8; i++)
    {
        HidInput[i] = 0;
    }
 
    while (1)
    {
        if (B_1ms) // every 1 ms
        {
            B_1ms = 0;
            if (++cnt50ms >= 50) // scan every 50 ms
            {
                cnt50ms = 0;
                KeyScan();
            }
            if (KeyChangeFlag) // if key status changed
            {
                KeyChangeFlag = 0;
                SendKeyStatus();
            }
        }
    }
}
 
void USB_Init()
{
    SYS_EnableOscillator48M();
    USB_SetClockSource(USB_ClockSource_6M);
    USB_SetEnabled(HAL_State_ON);
    USB_SetDpDmPullUp(HAL_State_ON);
    EXTI_USB_SetIntPriority(EXTI_IntPriority_Highest);
 
    USB_WriteReg(FADDR, 0x00);
    USB_WriteReg(POWER, 0x08);
    USB_WriteReg(INTRIN1E, 0x3f);
    USB_WriteReg(INTROUT1E, 0x3f);
    USB_WriteReg(INTRUSBE, 0x00);
    USB_WriteReg(POWER, 0x01);
    usb_ep0_stage.bStage = USB_CtrlState_Idle;
 
    EXTI_USB_SetIntState(HAL_State_ON);
}
 
INTERRUPT(USB_Routine, EXTI_VectUSB)
{
    uint8_t intrusb;
    uint8_t intrin;
    uint8_t introut;
    uint8_t csr;
    uint8_t cnt;
    uint16_t len = 0;
    intrusb = USB_ReadReg(INTRUSB);
    intrin = USB_ReadReg(INTRIN1);
    introut = USB_ReadReg(INTROUT1);
    if (intrusb & RSTIF)
    {
        USB_SelectEndPoint(1);
        USB_WriteReg(INCSR1, INCLRDT);
        USB_SelectEndPoint(1);
        USB_WriteReg(OUTCSR1, OUTCLRDT);
        usb_ep0_stage.bStage = USB_CtrlState_Idle;
    }
    if (intrin & EP0IF)
    {
        USB_SelectEndPoint(0);
        csr = USB_ReadReg(CSR0);
        if (csr & STSTL)
        {
            USB_WriteReg(CSR0, csr & ~STSTL);
            usb_ep0_stage.bStage = USB_CtrlState_Idle;
        }
        if (csr & SUEND)
        {
            USB_WriteReg(CSR0, csr | SSUEND);
        }
        switch (usb_ep0_stage.bStage)
        {
            case USB_CtrlState_Idle:
            if (csr & OPRDY)
            {
                usb_ep0_stage.bStage = USB_CtrlState_SettingUp;
                USB_ReadFIFO(FIFO0, (uint8_t *)&usb_request);
                ((uint8_t *)&usb_ep0_stage.wResidue)[0] = usb_request.wLength.bb.bh;
                ((uint8_t *)&usb_ep0_stage.wResidue)[1] = usb_request.wLength.bb.bl;
                switch (usb_request.bmRequestType & REQUEST_TYPE_MASK)
                {
                    case USB_RequestType_Standard:
                        switch (usb_request.bRequest)
                        {
                            case USB_StdReq_SetAddress:
                                USB_WriteReg(FADDR, usb_request.wValue.bb.bl);
                                break;
 
                            case USB_StdReq_SetConfiguration:
                                USB_SelectEndPoint(1);
                                USB_WriteReg(INCSR2, INMODEIN);
                                USB_WriteReg(INMAXP, 8);
                                USB_SelectEndPoint(1);
                                USB_WriteReg(INCSR2, INMODEOUT);
                                USB_WriteReg(OUTMAXP, 8);
                                USB_SelectEndPoint(0);
                                break;
 
                            case USB_StdReq_GetDescriptor:
                                usb_ep0_stage.bStage = USB_CtrlState_DataIn;
                                switch (usb_request.wValue.bb.bh)
                                {
                                    case USB_DescriptorType_Device:
                                        usb_ep0_stage.pData = (uint8_t *)DEVICEDESC;
                                        len = sizeof(DEVICEDESC);
                                        break;
 
                                    case USB_DescriptorType_Configuration:
                                        usb_ep0_stage.pData = (uint8_t *)CONFIGDESC;
                                        len = sizeof(CONFIGDESC);
                                        break;
 
                                    case USB_DescriptorType_String:
                                        switch (usb_request.wValue.bb.bl)
                                        {
                                            case 0:
                                                usb_ep0_stage.pData = (uint8_t *)LANGIDDESC;
                                                len = sizeof(LANGIDDESC);
                                                break;
 
                                            case 1:
                                                usb_ep0_stage.pData = (uint8_t *)MANUFACTDESC;
                                                len = sizeof(MANUFACTDESC);
                                                break;
 
                                            case 2:
                                                usb_ep0_stage.pData = (uint8_t *)PRODUCTDESC;
                                                len = sizeof(PRODUCTDESC);
                                                break;
 
                                            default:
                                                usb_ep0_stage.bStage = USB_CtrlState_Stalled;
                                                break;
                                        }
                                        break;
 
                                    case USB_DescriptorType_Report:
                                        usb_ep0_stage.pData = (uint8_t *)HIDREPORTDESC;
                                        len = sizeof(HIDREPORTDESC);
                                        break;
 
                                    default:
                                        usb_ep0_stage.bStage = USB_CtrlState_Stalled;
                                        break;
                                }
                                if (len < usb_ep0_stage.wResidue)
                                {
                                    usb_ep0_stage.wResidue = len;
                                }
                                break;
 
                            default:
                                usb_ep0_stage.bStage = USB_CtrlState_Stalled;
                                break;
                        }
                        break;
 
                    case USB_RequestType_Class:
                        switch (usb_request.bRequest)
                        {
                            case USB_HidReq_GetReport:
                                usb_ep0_stage.pData = HidFreature;
                                usb_ep0_stage.bStage = USB_CtrlState_DataIn;
                                break;
 
                            case USB_HidReq_SetReport:
                                usb_ep0_stage.pData = HidFreature;
                                usb_ep0_stage.bStage = USB_CtrlState_DataOut;
                                break;
 
                            case USB_HidReq_SetIdle:
                                break;
 
                            // case USB_HidReq_GetIdle:
                            // case USB_HidReq_GetProtocol:
                            // case USB_HidReq_SetProtocol:
                            default:
                                usb_ep0_stage.bStage = USB_CtrlState_Stalled;
                                break;
                        }
                        break;
 
                    default:
                        usb_ep0_stage.bStage = USB_CtrlState_Stalled;
                        break;
                }
 
                switch (usb_ep0_stage.bStage)
                {
                    case USB_CtrlState_DataIn:
                        USB_WriteReg(CSR0, SOPRDY);
                        goto L_Ep0SendData;
                        break;
 
                    case USB_CtrlState_DataOut:
                        USB_WriteReg(CSR0, SOPRDY);
                        break;
 
                    case USB_CtrlState_SettingUp:
                        USB_WriteReg(CSR0, SOPRDY | DATEND);
                        usb_ep0_stage.bStage = USB_CtrlState_Idle;
                        break;
 
                    case USB_CtrlState_Stalled:
                        USB_WriteReg(CSR0, SOPRDY | SDSTL);
                        usb_ep0_stage.bStage = USB_CtrlState_Idle;
                        break;
                }
            }
            break;
            
            case USB_CtrlState_DataIn:
                if (!(csr & IPRDY))
                {
                    L_Ep0SendData:
                    cnt = usb_ep0_stage.wResidue > 64 ? 64 : usb_ep0_stage.wResidue;
                    USB_WriteFIFO(FIFO0, usb_ep0_stage.pData, cnt);
                    usb_ep0_stage.wResidue -= cnt;
                    usb_ep0_stage.pData += cnt;
                    if (usb_ep0_stage.wResidue == 0)
                    {
                        USB_WriteReg(CSR0, IPRDY | DATEND);
                        usb_ep0_stage.bStage = USB_CtrlState_Idle;
                    }
                    else
                    {
                        USB_WriteReg(CSR0, IPRDY);
                    }
                }
                break;
 
            case USB_CtrlState_DataOut:
                if (csr & OPRDY)
                {
                    cnt = USB_ReadFIFO(FIFO0, usb_ep0_stage.pData);
                    usb_ep0_stage.wResidue -= cnt;
                    usb_ep0_stage.pData += cnt;
                    if (usb_ep0_stage.wResidue == 0)
                    {
                        USB_WriteReg(CSR0, SOPRDY | DATEND);
                        usb_ep0_stage.bStage = USB_CtrlState_Idle;
                    }
                    else
                    {
                        USB_WriteReg(CSR0, SOPRDY);
                    }
                }
                break;
        }
    }
 
    if (intrin & EP1INIF)
    {
        USB_SelectEndPoint(1);
        csr = USB_ReadReg(INCSR1);
        if (csr & INSTSTL)
        {
            USB_WriteReg(INCSR1, INCLRDT);
        }
        if (csr & INUNDRUN)
        {
            USB_WriteReg(INCSR1, 0);
        }
    }
 
    if (introut & EP1OUTIF)
    {
        USB_SelectEndPoint(1);
        csr = USB_ReadReg(OUTCSR1);
        if (csr & OUTSTSTL)
        {
            USB_WriteReg(OUTCSR1, OUTCLRDT);
        }
        if (csr & OUTOPRDY)
        {
            USB_ReadFIFO(FIFO1, HidOutput);
            USB_WriteReg(OUTCSR1, 0);
            
            P6 = ~HidOutput[0];    // update LED status
        }
    }
}
 
uint8_t KeyCount(uint16_t dat)
{
    uint8_t i;
 
    i = 0;
    while (dat)
    {
        if (dat & 0x8000) i++;
        dat <<= 1;
    }
    return i;
}
 
//HidInput first byte for special keys，second byte is reserved，the reset 6 bytes for normal keys
void SendKeyStatus(void)
{
    uint8_t i,n;
    
    if(KeyCode) // if key pressed
    {
        // allow 3 keys pressed simultaneously
        if(KeyCount(KeyCode) > 3) 
        {
            return;  // too many keys
        }
        else
        {
            n = 2;
            for (i = 0; i < 16; i++)
            {
                if (i == 1)
                {
                    if (KeyCode & (1 << i)) // left Ctrl
                    {
                        HidInput[0] |= 1;
                    }
                    else
                    {
                        HidInput[0] &= ~1;
                    }
                }
                else if (i == 2)
                {
                    if (KeyCode & (1 << i)) // left alt
                    {
                        HidInput[0] |= 1 << 2;
                    }
                    else
                    {
                        HidInput[0] &= ~(1 << 2);
                    }
                }
                else
                {
                    if (KeyCode & (1 << i))
                    {
                        HidInput[n++] = KeyMap[i];
                    }
                }
            }
 
            for(; n<8; n++)
            {
                HidInput[n]=0;  // fill 0 to the rest
            }
        }
    }
    else // if no key pressed, return 0
    {
        for (i = 0; i < 8; i++)
        {
            HidInput[i] = 0;
        }
    }
 
    // return 8 bytes data
    USB_SelectEndPoint(1);
    for (i = 0; i < 8; i++)
    {
        USB_WriteReg(FIFO1, HidInput[i]);
    }
    USB_WriteReg(INCSR1, INIPRDY);
}
 
INTERRUPT(Timer0_Routine, EXTI_VectTimer0)
{
    B_1ms = 1;
}
 
/*****************************************************
    Key Matrix Scan
 
     Y   P04      P05      P06      P07
          |        |        |        |
X         |        |        |        |
P00 ---- K00 ---- K01 ---- K02 ---- K03 ----
          |        |        |        |
P01 ---- K04 ---- K05 ---- K06 ---- K07 ----
          |        |        |        |
P02 ---- K08 ---- K09 ---- K10 ---- K11 ----
          |        |        |        |
P03 ---- K12 ---- K13 ---- K14 ---- K15 ----
          |        |        |        |
******************************************************/
 
void KeyScan(void)
{
    uint8_t temp;
 
    KeyIO = 0x0F;
    SYS_DelayUs(1);
    if ((KeyIO & 0x0F) == 0x0F) // no key pressed
    {
        NewKeyCode = 0;
    }
    else // start scan
    {
        // scan first line
        KeyIO = (uint8_t)~0x10;
        SYS_DelayUs(1);
        // save 4 keys status
        temp = KeyIO & 0x0F;
 
        // second line
        KeyIO = (uint8_t)~0x20;
        SYS_DelayUs(1);
        temp |= KeyIO << 4;
 
        // save current key status
        NewKeyCode = (~temp) & 0xFF;
 
        // third line
        KeyIO = (uint8_t)~0x40;
        SYS_DelayUs(1);
        temp = KeyIO & 0x0F;
 
        // 4th line
        KeyIO = (uint8_t)~0x80;
        SYS_DelayUs(1);
        temp |= KeyIO << 4;
 
        // save all 16 keys' status in 2 bytes, 1 indicates key pressed
        NewKeyCode |= (((uint16_t)~temp) << 8);
    }
 
    if (NewKeyCode != OldKeyCode)
    {
        KeyHoldTime = 0;
        OldKeyCode = NewKeyCode;
        KeyChangeTemp = 1;
    }
    else
    {
        KeyHoldTime++;
        if (KeyHoldTime >= 1)
        {
            KeyHoldTime = 1;
            KeyCode = OldKeyCode;
            if (KeyChangeTemp)
            {
                KeyChangeTemp = 0;
                KeyChangeFlag = 1; // Set send flag
            }
        }
    }
}
 
__CODE uint8_t DEVICEDESC[18] =
{
    0x12, //bLength(18);
    0x01, //bDescriptorType(Device);
    0x00,0x02, //bcdUSB(2.00);
    0x00, //bDeviceClass(0);
    0x00, //bDeviceSubClass0);
    0x00, //bDeviceProtocol(0);
    0x40, //bMaxPacketSize0(64);
    0x54,0x53, //idVendor(5354);
    0x80,0x44, //idProduct(4480);
    0x00,0x01, //bcdDevice(1.00);
    0x01, //iManufacturer(1);
    0x02, //iProduct(2);
    0x03, //iSerialNumber(3);
    0x01, //bNumConfigurations(1);
};
 
__CODE uint8_t CONFIGDESC[41] =
{
    0x09, //bLength(9);
    0x02, //bDescriptorType(Configuration);
    0x29,0x00, //wTotalLength(41);
    0x01, //bNumInterfaces(1);
    0x01, //bConfigurationValue(1);
    0x00, //iConfiguration(0);
    0xa0, //bmAttributes(BUSPower);
    0xc8, //MaxPower(400mA);
    
    0x09, //bLength(9);
    0x04, //bDescriptorType(Interface);
    0x00, //bInterfaceNumber(0);
    0x00, //bAlternateSetting(0);
    0x02, //bNumEndpoints(2);
    0x03, //bInterfaceClass(HID);
    0x01, //bInterfaceSubClass(1);
    0x01, //bInterfaceProtocol(1);
    0x00, //iInterface(0);
    
    0x09, //bLength(9);
    0x21, //bDescriptorType(HID);
    0x01,0x10, //bcdHID(1.01);
    0x00, //bCountryCode(0);
    0x01, //bNumDescriptors(1);
    0x22, //bDescriptorType(HID Report);
    0x3f,0x00, //wDescriptorLength(63);
    0x07, //bLength(7);
    0x05, //bDescriptorType(Endpoint);
    0x81, //bEndpointAddress(EndPoint1 as IN);
    0x03, //bmAttributes(Interrupt);
    0x40,0x00, //wMaxPacketSize(64);
    0x0a, //bInterval(10ms);
    0x07, //bLength(7);
    0x05, //bDescriptorType(Endpoint);
    0x01, //bEndpointAddress(EndPoint1 as OUT);
    0x03, //bmAttributes(Interrupt);
    0x40,0x00, //wMaxPacketSize(64);
    0x0a, //bInterval(10ms);
};
 
__CODE uint8_t HIDREPORTDESC[63] =
{
    0x05, 0x01,    // USAGE_PAGE (Generic Desktop)
    0x09, 0x06,    // USAGE (Keyboard)
    0xa1, 0x01,    // COLLECTION (Application)
    0x05, 0x07,    //   USAGE_PAGE (Keyboard)
    0x19, 0xe0,    //   USAGE_MINIMUM (Keyboard LeftControl)
    0x29, 0xe7,    //   USAGE_MAXIMUM (Keyboard Right GUI)
    0x15, 0x00,    //   LOGICAL_MINIMUM (0)
    0x25, 0x01,    //   LOGICAL_MAXIMUM (1)
    0x75, 0x01,    //   REPORT_SIZE (1)
    0x95, 0x08,    //   REPORT_COUNT (8)
    0x81, 0x02,    //   INPUT (Data,Var,Abs)
    0x95, 0x01,    //   REPORT_COUNT (1)
    0x75, 0x08,    //   REPORT_SIZE (8)
    0x81, 0x03,    //   INPUT (Cnst,Var,Abs)
    0x95, 0x05,    //   REPORT_COUNT (5)
    0x75, 0x01,    //   REPORT_SIZE (1)
    0x05, 0x08,    //   USAGE_PAGE (LEDs)
    0x19, 0x01,    //   USAGE_MINIMUM (Num Lock)
    0x29, 0x05,    //   USAGE_MAXIMUM (Kana)
    0x91, 0x02,    //   OUTPUT (Data,Var,Abs)
    0x95, 0x01,    //   REPORT_COUNT (1)
    0x75, 0x03,    //   REPORT_SIZE (3)
    0x91, 0x03,    //   OUTPUT (Cnst,Var,Abs)
    0x95, 0x06,    //   REPORT_COUNT (6)
    0x75, 0x08,    //   REPORT_SIZE (8)
    0x15, 0x00,    //   LOGICAL_MINIMUM (0)
    0x25, 0xFF,    //   LOGICAL_MAXIMUM (255)
    0x05, 0x07,    //   USAGE_PAGE (Keyboard)
    0x19, 0x00,    //   USAGE_MINIMUM (Reserved (no event indicated))
    0x29, 0x65,    //   USAGE_MAXIMUM (Keyboard Application)
    0x81, 0x00,    //   INPUT (Data,Ary,Abs)
    0xc0           // END_COLLECTION
};
 
__CODE uint8_t LANGIDDESC[4] =
{
    0x04,0x03,
    0x09,0x04,
};
 
__CODE uint8_t MANUFACTDESC[8] =
{
    0x08,0x03,
    'S',0,
    'T',0,
    'C',0,
};
 
__CODE uint8_t PRODUCTDESC[30] =
{
    0x1e,0x03,
    'S',0,
    'T',0,
    'C',0,
    ' ',0,
    'U',0,
    'S',0,
    'B',0,
    ' ',0,
    'D',0,
    'e',0,
    'v',0,
    'i',0,
    'c',0,
    'e',0,
};
 
__CODE uint8_t KeyMap[16] = {
    0x53,    //0: Num Lock
    0xFF,    //1: NULL - Left Ctrl
    0xFF,    //2: NULL - Left ALT
    0x2A,    //3: BackSpace
 
    0x5F,    //4: 7
    0x60,    //5: 8
    0x61,    //6: 9
    0x62,    //7: 0
 
    0x5C,    //8: 4
    0x5D,    //9: 5
    0x5E,    //A: 6
    0x63,    //B: DEL
 
    0x59,    //C: 1
    0x5A,    //D: 2
    0x5B,    //E: 3
    0x58,    //F: Return
};