Proteus и два с половиной hello world для UART и USB на микроконтроллере

char uart_rd;
void main()
{
    UART1_Init(9600);
    UART1_Write_Text("Hello Habrahabr");
    UART1_Write(10);
    UART1_Write(13);
    for(;;)
    {
        if(UART1_Data_Ready())
        {
            uart_rd = UART1_Read( );
            switch(uart_rd)
            {
                case 0xD:
                UART1_Write(10);
                UART1_Write(13);
                break;
                default:
                UART1_Write(uart_rd);
                break;
            }
        }
    }
}

#define CRLF UART1_Write(10);UART1_Write(13)
char uart_rd = 0;
char cmd[32] = {0};
int char_counter = 0;
void cmd_exec(void)
{
    if (strstr(cmd, "hello"))
    {
        UART1_Write_Text("EHLO");
        CRLF;
    }
    else if (strstr(cmd, "test"))
    {
        UART1_Write_Text("TSET");
        CRLF;
    }
    else
    {
        UART1_Write_Text("Unknown command");
        CRLF;
    }
    char_counter=0;
    memset(cmd, 0, sizeof cmd);
}
void main(void)
{
    UART1_Init(9600);
    UART1_Write_Text("MCU started");
    UART1_Write(10);
    UART1_Write(13);
    for(;;)
    {
        if(UART1_Data_Ready())
        {
            uart_rd = UART1_Read( );
            switch(uart_rd)
            {
                case 0xD:
                CRLF;
                cmd_exec();
                break;
                default:
                UART1_Write(uart_rd);
                break;
            }
            cmd[char_counter++] = uart_rd;
            if(char_counter == (sizeof cmd - 1))
            {
                CRLF;
                cmd_exec();
            }
        }
    }
}

const unsigned int USB_VENDOR_ID = 0xdead;
const unsigned int USB_PRODUCT_ID = 0xbeaf;
const char USB_SELF_POWER = 0x80;            // Self powered 0xC0,  0x80 bus powered
const char USB_MAX_POWER = 50;               // Bus power required in units of 2 mA
const char HID_INPUT_REPORT_BYTES = 8;
const char HID_OUTPUT_REPORT_BYTES = 8;
const char USB_TRANSFER_TYPE = 0x03;         //0x03 Interrupt
const char EP_IN_INTERVAL = 1;
const char EP_OUT_INTERVAL = 1;
const char USB_INTERRUPT = 1;
const char USB_HID_EP = 1;
const char USB_HID_RPT_SIZE = 63;
/* Device Descriptor */
const struct {
    char bLength;               // bLength         - Descriptor size in bytes (12h)
    char bDescriptorType;       // bDescriptorType - The constant DEVICE (01h)
    unsigned int bcdUSB;        // bcdUSB          - USB specification release number (BCD)
    char bDeviceClass;          // bDeviceClass    - Class Code
    char bDeviceSubClass;       // bDeviceSubClass - Subclass code
    char bDeviceProtocol;       // bDeviceProtocol - Protocol code
    char bMaxPacketSize0;       // bMaxPacketSize0 - Maximum packet size for endpoint 0
    unsigned int idVendor;      // idVendor        - Vendor ID
    unsigned int idProduct;     // idProduct       - Product ID
    unsigned int bcdDevice;     // bcdDevice       - Device release number (BCD)
    char iManufacturer;         // iManufacturer   - Index of string descriptor for the manufacturer
    char iProduct;              // iProduct        - Index of string descriptor for the product.
    char iSerialNumber;         // iSerialNumber   - Index of string descriptor for the serial number.
    char bNumConfigurations;    // bNumConfigurations - Number of possible configurations
}
device_dsc = {
    0x12,                   // bLength
    0x01,                   // bDescriptorType
    0x0200,                 // bcdUSB
    0x00,                   // bDeviceClass
    0x00,                   // bDeviceSubClass
    0x00,                   // bDeviceProtocol
    8,                      // bMaxPacketSize0
    USB_VENDOR_ID,          // idVendor
    USB_PRODUCT_ID,         // idProduct
    0x0001,                 // bcdDevice
    0x01,                   // iManufacturer
    0x02,                   // iProduct
    0x00,                   // iSerialNumber
    0x01                    // bNumConfigurations
}
;
/* Configuration 1 Descriptor */
const char configDescriptor1[]= {
    // Configuration Descriptor
    0x09,                   // bLength             - Descriptor size in bytes
    0x02,                   // bDescriptorType     - The constant CONFIGURATION (02h)
    0x29,0x00,              // wTotalLength        - The number of bytes in the configuration descriptor and all of its subordinate descriptors
    1,                      // bNumInterfaces      - Number of interfaces in the configuration
    1,                      // bConfigurationValue - Identifier for Set Configuration and Get Configuration requests
    0,                      // iConfiguration      - Index of string descriptor for the configuration
    USB_SELF_POWER,         // bmAttributes        - Self/bus power and remote wakeup settings
    USB_MAX_POWER,          // bMaxPower           - Bus power required in units of 2 mA
    // Interface Descriptor
    0x09,                   // bLength - Descriptor size in bytes (09h)
    0x04,                   // bDescriptorType - The constant Interface (04h)
    0,                      // bInterfaceNumber - Number identifying this interface
    0,                      // bAlternateSetting - A number that identifies a descriptor with alternate settings for this bInterfaceNumber.
    2,                      // bNumEndpoint - Number of endpoints supported not counting endpoint zero
    0x03,                   // bInterfaceClass - Class code
    0,                      // bInterfaceSubclass - Subclass code
    0,                      // bInterfaceProtocol - Protocol code
    0,                      // iInterface - Interface string index
    // HID Class-Specific Descriptor
    0x09,                   // bLength - Descriptor size in bytes.
    0x21,                   // bDescriptorType - This descriptor's type: 21h to indicate the HID class.
    0x01,0x01,              // bcdHID - HID specification release number (BCD).
    0x00,                   // bCountryCode - Numeric expression identifying the country for localized hardware (BCD) or 00h.
    1,                      // bNumDescriptors - Number of subordinate report and physical descriptors.
    0x22,                   // bDescriptorType - The type of a class-specific descriptor that follows
    USB_HID_RPT_SIZE,0x00,  // wDescriptorLength - Total length of the descriptor identified above.
    // Endpoint Descriptor
    0x07,                   // bLength - Descriptor size in bytes (07h)
    0x05,                   // bDescriptorType - The constant Endpoint (05h)
    USB_HID_EP | 0x80,      // bEndpointAddress - Endpoint number and direction
    USB_TRANSFER_TYPE,      // bmAttributes - Transfer type and supplementary information
    0x40,0x00,              // wMaxPacketSize - Maximum packet size supported
    EP_IN_INTERVAL,         // bInterval - Service interval or NAK rate
    // Endpoint Descriptor
    0x07,                   // bLength - Descriptor size in bytes (07h)
    0x05,                   // bDescriptorType - The constant Endpoint (05h)
    USB_HID_EP,             // bEndpointAddress - Endpoint number and direction
    USB_TRANSFER_TYPE,      // bmAttributes - Transfer type and supplementary information
    0x40,0x00,              // wMaxPacketSize - Maximum packet size supported
    EP_OUT_INTERVAL         // bInterval - Service interval or NAK rate
}
;
const struct {
    char report[];
}
hid_rpt_desc =
{
    0x05, 0x01,                    // USAGE_PAGE (Generic Desktop)
    0x09, 0x06,                    // USAGE (Keyboard)
    0xa1, 0x01,                    // COLLECTION (Application)
    0x05, 0x07,                    //   USAGE_PAGE (Keyboard)
    0x19, 0xe0,                    //   USAGE_MINIMUM 224(Keyboard LeftControl)
    0x29, 0xe7,                    //   USAGE_MAXIMUM 231(Keyboard Right GUI)    (left and right: alt, shift, ctrl and win)
    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, 0x65,                    //   LOGICAL_MAXIMUM (101)
    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
}
;
//Language code string descriptor
const struct {
    char bLength;
    char bDscType;
    unsigned int string[1];
}
strd1 = {
    4,
    0x03,
    {
        0x0409
    }
}
;
//Manufacturer string descriptor
const struct{
    char bLength;
    char bDscType;
    unsigned int string[10];
}
strd2={
    22,           //sizeof this descriptor string
    0x03,
    {
        'H','a','b','r','a','h','a','b','r'
    }
}
;
//Product string descriptor
const struct{
    char bLength;
    char bDscType;
    unsigned int string[15];
}
strd3={
    32,          //sizeof this descriptor string
    0x03,
    {
        'H','a','b','r','a','K','e','y','b','o','a','r','d'
    }
}
;
//Array of configuration descriptors
const char* USB_config_dsc_ptr[1];
//Array of string descriptors
const char* USB_string_dsc_ptr[3];
void USB_Init_Desc(){
    USB_config_dsc_ptr[0] = &configDescriptor1;
    USB_string_dsc_ptr[0] = (const char*)&strd1;
    USB_string_dsc_ptr[1] = (const char*)&strd2;
    USB_string_dsc_ptr[2] = (const char*)&strd3;
}

unsigned short USBResponse[8] = { 0} absolute 0x500;
unsigned short USBCommand[8] = {0} absolute 0x508;

char *text="habrahabr";
int i = 0;
void interrupt(void)
{
    USB_Interrupt_Proc( );
}
void clrUSB(void)
{    
    memset(USBCommand, 0, sizeof USBCommand);
   while ( !HID_Write(&USBCommand, sizeof USBCommand));
}
void
main(void)
{
    ADCON1 |= 0x0F;
    CMCON |= 7;
    HID_Enable(&USBResponse, &USBCommand);
    delay_ms(1000);
    for (i=0; i < strlen(text); i++)
    {
        USBCommand[2] = text[i] - 93;
        while ( !HID_Write(&USBCommand, sizeof USBCommand));
        clrUSB();
        delay_ms(200);
    }
}