usb_keyboard.c File Reference

#include "fw_hal.h"
#include <string.h>

Go to the source code of this file.

Macros
#define	KeyIO   P0

Functions
void	USB_Init (void)
void	KeyScan (void)
void	SendKeyStatus (void)
void	main ()
	INTERRUPT (USB_Routine, EXTI_VectUSB)
uint8_t	KeyCount (uint16_t dat)
	INTERRUPT (Timer0_Routine, EXTI_VectTimer0)

Variables
__BIT	B_1ms
__BIT	KeyChangeTemp
__BIT	KeyChangeFlag
uint16_t	cnt50ms
uint16_t	KeyCode
uint16_t	OldKeyCode
uint16_t	NewKeyCode
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

Macro Definition Documentation

KeyIO

#define KeyIO   P0

USB Keyboard Demo

P0: 8 bits for 4x4 Key matrix P6.0: NumLock P6.1: CapsLock

Definition at line 26 of file usb_keyboard.c.

Function Documentation

INTERRUPT() [1/2]

INTERRUPT	(	Timer0_Routine	,
		EXTI_VectTimer0
	)

Definition at line 442 of file usb_keyboard.c.

{
    B_1ms = 1;
}

INTERRUPT() [2/2]

INTERRUPT	(	USB_Routine	,
		EXTI_VectUSB
	)

Definition at line 113 of file usb_keyboard.c.

{
    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
        }
    }
}

KeyCount()

uint8_t KeyCount

(

uint16_t

dat

)

Definition at line 358 of file usb_keyboard.c.

{
    uint8_t i;
 
    i = 0;
    while (dat)
    {
        if (dat & 0x8000) i++;
        dat <<= 1;
    }
    return i;
}

KeyScan()

void KeyScan

(

void

)

Definition at line 463 of file usb_keyboard.c.

{
    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
            }
        }
    }
}

main()

void main

(

void

)

Definition at line 54 of file usb_keyboard.c.

{
    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();
            }
        }
    }
}

SendKeyStatus()

void SendKeyStatus

(

void

)

Definition at line 372 of file usb_keyboard.c.

{
    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);
}

USB_Init()

void USB_Init

(

void

)

Definition at line 94 of file usb_keyboard.c.

{
    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);
}

Variable Documentation

B_1ms

__BIT B_1ms

Definition at line 28 of file usb_keyboard.c.

cnt50ms

uint16_t cnt50ms

Definition at line 31 of file usb_keyboard.c.

CONFIGDESC

__CODE uint8_t CONFIGDESC[41]

Definition at line 38 of file usb_keyboard.c.

DEVICEDESC

__CODE uint8_t DEVICEDESC[18]

Initial value:

=
{
    0x12, 
    0x01, 
    0x00,0x02, 
    0x00, 
    0x00, 
    0x00, 
    0x40, 
    0x54,0x53, 
    0x80,0x44, 
    0x00,0x01, 
    0x01, 
    0x02, 
    0x03, 
    0x01, 
}

Definition at line 37 of file usb_keyboard.c.

HidFreature

__XDATA uint8_t HidFreature[64]

Definition at line 44 of file usb_keyboard.c.

HidInput

__XDATA uint8_t HidInput[64]

Definition at line 45 of file usb_keyboard.c.

HidOutput

__XDATA uint8_t HidOutput[64]

Definition at line 46 of file usb_keyboard.c.

HIDREPORTDESC

__CODE uint8_t HIDREPORTDESC[63]

Definition at line 39 of file usb_keyboard.c.

KeyChangeFlag

__BIT KeyChangeFlag

Definition at line 30 of file usb_keyboard.c.

KeyChangeTemp

__BIT KeyChangeTemp

Definition at line 29 of file usb_keyboard.c.

KeyCode

uint16_t KeyCode

Definition at line 32 of file usb_keyboard.c.

KeyHoldTime

uint16_t KeyHoldTime

Definition at line 35 of file usb_keyboard.c.

KeyMap

__CODE uint8_t KeyMap

Initial value:

= {
    0x53,    
    0xFF,    
    0xFF,    
    0x2A,    
 
    0x5F,    
    0x60,    
    0x61,    
    0x62,    
 
    0x5C,    
    0x5D,    
    0x5E,    
    0x63,    
 
    0x59,    
    0x5A,    
    0x5B,    
    0x58,    
}

Definition at line 43 of file usb_keyboard.c.

LANGIDDESC

__CODE uint8_t LANGIDDESC[4]

Initial value:

=
{
    0x04,0x03,
    0x09,0x04,
}

Definition at line 40 of file usb_keyboard.c.

MANUFACTDESC

__CODE uint8_t MANUFACTDESC[8]

Initial value:

=
{
    0x08,0x03,
    'S',0,
    'T',0,
    'C',0,
}

Definition at line 41 of file usb_keyboard.c.

NewKeyCode

uint16_t NewKeyCode

Definition at line 34 of file usb_keyboard.c.

OldKeyCode

uint16_t OldKeyCode

Definition at line 33 of file usb_keyboard.c.

PRODUCTDESC

__CODE uint8_t PRODUCTDESC[30]

Initial value:

=
{
    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,
}

Definition at line 42 of file usb_keyboard.c.

usb_ep0_stage

USB_EP0_Stage_t usb_ep0_stage

Definition at line 48 of file usb_keyboard.c.

usb_request

USB_Request_t usb_request

Definition at line 47 of file usb_keyboard.c.