OpenWRT के साथ एक राउटर से मिनीकंप्यूटर: एक यूएसबी वीडियो कार्ड विकसित करना

लोहा

मुलायम

एलसीडी ऑपरेशन

#define CTR_OSC_START 0x0000 #define CTR_DRV_OUTPUT1 0x0001 #define CTR_DRV_WAVE 0x0002 #define CTR_ENTRY_MODE 0x0003 #define CTR_RESIZE 0x0004 #define CTR_DISPLAY1 0x0007 #define CTR_DISPLAY2 0x0008 #define CTR_DISPLAY3 0x0009 #define CTR_DISPLAY4 0x000A #define CTR_RGB_INTERFACE1 0x000C #define CTR_FRM_MARKER 0x000D #define CTR_RGB_INTERFACE2 0x000F #define CTR_POWER1 0x0010 #define CTR_POWER2 0x0011 #define CTR_POWER3 0x0012 #define CTR_POWER4 0x0013 #define CTR_HORZ_ADDRESS 0x0020 #define CTR_VERT_ADDRESS 0x0021 #define CTR_WRITE_DATA 0x0022 #define CTR_READ_DATA 0x0022 #define CTR_POWER7 0x0029 #define CTR_FRM_COLOR 0x002B #define CTR_GAMMA1 0x0030 #define CTR_GAMMA2 0x0031 #define CTR_GAMMA3 0x0032 #define CTR_GAMMA4 0x0035 #define CTR_GAMMA5 0x0036 #define CTR_GAMMA6 0x0037 #define CTR_GAMMA7 0x0038 #define CTR_GAMMA8 0x0039 #define CTR_GAMMA9 0x003C #define CTR_GAMMA10 0x003D #define CTR_HORZ_START 0x0050 #define CTR_HORZ_END 0x0051 #define CTR_VERT_START 0x0052 #define CTR_VERT_END 0x0053 #define CTR_DRV_OUTPUT2 0x0060 #define CTR_BASE_IMAGE 0x0061 #define CTR_VERT_SCROLL 0x006A #define CTR_PIMG1_POS 0x0080 #define CTR_PIMG1_START 0x0081 #define CTR_PIMG1_END 0x0082 #define CTR_PIMG2_POS 0x0083 #define CTR_PIMG2_START 0x0084 #define CTR_PIMG2_END 0x0085 #define CTR_PANEL_INTERFACE1 0x0090 #define CTR_PANEL_INTERFACE2 0x0092 #define CTR_PANEL_INTERFACE4 0x0095 #define CTR_OTP_VCMPROGRAM 0x00A1 #define CTR_OTP_VCMSTATUS 0x00A2 #define CTR_OTP_IDKEY 0x00A5 

 #define LCDRegister (*((volatile uint16_t*) 0x60000000)) 

 #define LCDMemory (*((volatile uint16_t*) 0x60020000)) 

 #define LCD_WRITE_REGISTER(REG, DATA) LCDRegister=REG;LCDMemory=DATA; #define LCD_BEGIN_RAM_WRITE LCDRegister=CTR_WRITE_DATA; #define LCD_WRITE_RAM(DATA) LCDMemory=DATA 

 #define BacklightPin GPIO_Pin_13 #define BacklightPort GPIOD #define ResetPin GPIO_Pin_1 #define ResetPort GPIOE 

 void LCDInitHardware() { SysTick_Config(SystemCoreClock/1000); GPIO_InitTypeDef GPIO_InitStructure; FSMC_NORSRAMInitTypeDef FSMC_InitStructure; FSMC_NORSRAMTimingInitTypeDef FSMC_Timing; RCC_AHBPeriphClockCmd(RCC_AHBPeriph_FSMC, ENABLE); RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOD | RCC_APB2Periph_GPIOE | RCC_APB2Periph_AFIO, ENABLE); GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_1 | GPIO_Pin_4 | GPIO_Pin_5 | GPIO_Pin_7 | GPIO_Pin_8 | GPIO_Pin_9 | GPIO_Pin_10| GPIO_Pin_11| GPIO_Pin_14| GPIO_Pin_15; //Interface GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP; GPIO_Init(GPIOD, &GPIO_InitStructure); GPIO_InitStructure.GPIO_Pin = GPIO_Pin_7 | GPIO_Pin_8 | GPIO_Pin_9 | GPIO_Pin_10 | GPIO_Pin_11| GPIO_Pin_12| GPIO_Pin_13| GPIO_Pin_14 | GPIO_Pin_15; //Interface GPIO_Init(GPIOE, &GPIO_InitStructure); GPIO_InitStructure.GPIO_Pin = BacklightPin; //Backlight GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP; GPIO_Init(BacklightPort, &GPIO_InitStructure); GPIO_InitStructure.GPIO_Pin = ResetPin; //Reset GPIO_Init(ResetPort, &GPIO_InitStructure); GPIO_SetBits(ResetPort,ResetPin); FSMC_Timing.FSMC_AddressSetupTime = 1; FSMC_Timing.FSMC_AddressHoldTime = 0; FSMC_Timing.FSMC_DataSetupTime = 5; FSMC_Timing.FSMC_BusTurnAroundDuration = 0; FSMC_Timing.FSMC_CLKDivision = 0; FSMC_Timing.FSMC_DataLatency = 0; FSMC_Timing.FSMC_AccessMode = FSMC_AccessMode_B; FSMC_InitStructure.FSMC_Bank = FSMC_Bank1_NORSRAM1; FSMC_InitStructure.FSMC_DataAddressMux = FSMC_DataAddressMux_Disable; FSMC_InitStructure.FSMC_MemoryType = FSMC_MemoryType_SRAM; FSMC_InitStructure.FSMC_MemoryDataWidth = FSMC_MemoryDataWidth_16b; FSMC_InitStructure.FSMC_BurstAccessMode = FSMC_BurstAccessMode_Disable; FSMC_InitStructure.FSMC_WaitSignalPolarity = FSMC_WaitSignalPolarity_Low; FSMC_InitStructure.FSMC_WrapMode = FSMC_WrapMode_Disable; FSMC_InitStructure.FSMC_WaitSignalActive = FSMC_WaitSignalActive_BeforeWaitState; FSMC_InitStructure.FSMC_WriteOperation = FSMC_WriteOperation_Enable; FSMC_InitStructure.FSMC_WaitSignal = FSMC_WaitSignal_Disable; FSMC_InitStructure.FSMC_ExtendedMode = FSMC_ExtendedMode_Disable; FSMC_InitStructure.FSMC_AsynchronousWait = FSMC_AsynchronousWait_Disable; FSMC_InitStructure.FSMC_WriteBurst = FSMC_WriteBurst_Disable; FSMC_InitStructure.FSMC_ReadWriteTimingStruct = &FSMC_Timing; FSMC_InitStructure.FSMC_WriteTimingStruct = &FSMC_Timing; FSMC_NORSRAMInit(&FSMC_InitStructure); FSMC_NORSRAMCmd(FSMC_Bank1_NORSRAM1, ENABLE); } 

 volatile uint32_t Tick = 0x00000000; void SysTick_Handler() { if(Tick>0) Tick--; } void SysTickDelay(uint32_t msDelay) { Tick=msDelay; while(Tick); } 

 void LCDInit() { LCDHardwareReset(); LCD_WRITE_REGISTER(CTR_OSC_START, 0x0001); LCD_WRITE_REGISTER(CTR_DRV_OUTPUT1, 0x0100); LCD_WRITE_REGISTER(CTR_DRV_WAVE, 0x0700); LCD_WRITE_REGISTER(CTR_ENTRY_MODE, 0x1038); LCD_WRITE_REGISTER(CTR_RESIZE, 0x0000); LCD_WRITE_REGISTER(CTR_DISPLAY2, 0x0202); LCD_WRITE_REGISTER(CTR_DISPLAY3, 0x0000); LCD_WRITE_REGISTER(CTR_DISPLAY4, 0x0000); LCD_WRITE_REGISTER(CTR_RGB_INTERFACE1, 0x0001); LCD_WRITE_REGISTER(CTR_FRM_MARKER, 0x0000); LCD_WRITE_REGISTER(CTR_RGB_INTERFACE2, 0x0000); LCD_WRITE_REGISTER(CTR_POWER1, 0x0000); LCD_WRITE_REGISTER(CTR_POWER2, 0x0007); LCD_WRITE_REGISTER(CTR_POWER3, 0x0000); LCD_WRITE_REGISTER(CTR_POWER4, 0x0000); SysTickDelay(200); LCD_WRITE_REGISTER(CTR_POWER1, 0x1590); LCD_WRITE_REGISTER(CTR_POWER2, 0x0227); SysTickDelay(50); LCD_WRITE_REGISTER(CTR_POWER3, 0x009C); SysTickDelay(50); LCD_WRITE_REGISTER(CTR_POWER4, 0x1900); LCD_WRITE_REGISTER(CTR_POWER7, 0x1900); LCD_WRITE_REGISTER(CTR_FRM_COLOR, 0x000E); SysTickDelay(50); LCD_WRITE_REGISTER(CTR_HORZ_ADDRESS, 0x0000); LCD_WRITE_REGISTER(CTR_VERT_ADDRESS, 0x0000); LCD_WRITE_REGISTER(CTR_HORZ_START, 0x0000); LCD_WRITE_REGISTER(CTR_HORZ_END, 239); LCD_WRITE_REGISTER(CTR_VERT_START, 0x0000); LCD_WRITE_REGISTER(CTR_VERT_END, 319); LCD_WRITE_REGISTER(CTR_DRV_OUTPUT2, 0x2700); LCD_WRITE_REGISTER(CTR_BASE_IMAGE, 0x0001); LCD_WRITE_REGISTER(CTR_VERT_SCROLL, 0x0000); GPIO_SetBits(BacklightPort,BacklightPin); } 

 void LCDHardwareReset() { GPIO_ResetBits(ResetPort,ResetPin); SysTickDelay(50); GPIO_SetBits(ResetPort,ResetPin); SysTickDelay(10); } 

 void LCDOn() { LCD_WRITE_REGISTER(CTR_DISPLAY1, 0x0133); } void LCDOff() { LCD_WRITE_REGISTER(CTR_DISPLAY1, 0x0131); } 

  void LCDSetBounds(uint16_t left, uint16_t top, uint16_t right, uint16_t bottom) { LCD_WRITE_REGISTER(CTR_VERT_START, left); LCD_WRITE_REGISTER(CTR_VERT_END, right); LCD_WRITE_REGISTER(CTR_HORZ_START, top); LCD_WRITE_REGISTER(CTR_HORZ_END, bottom); LCD_WRITE_REGISTER(CTR_HORZ_ADDRESS, top); LCD_WRITE_REGISTER(CTR_VERT_ADDRESS, left); } 

 void LCDClear(uint16_t color) { LCDSetBounds(0,0,320-1,240-1); LCD_BEGIN_RAM_WRITE; uint32_t i; for(i=0;i<320*240;i++) LCD_WRITE_RAM(color); } 

 LCDInitHardware(); LCDInit(); LCDOn(); LCDClear(0x0000); 

USB ऑपरेशन

1. नियंत्रण समापन बिंदु का उपयोग पूर्ण नियंत्रण USB के मामले में 64 बाइट तक छोटे नियंत्रण संदेशों के अतुल्यकालिक हस्तांतरण के लिए किया जाता है। शून्य समापन बिंदु किसी भी USB डिवाइस में होना चाहिए और यह नियंत्रण होना चाहिए। इसके माध्यम से, मेजबान प्रारंभिक जानकारी का अनुरोध करता है और डिवाइस को इनिशियलाइज़ करता है। इस प्रकार के समापन बिंदुओं के माध्यम से पैकेज वितरण की गारंटी दी जाती है; त्रुटि की स्थिति में, होस्ट स्वचालित रूप से डेटा को फिर से भेजने का प्रयास करता है। नियंत्रण समापन बिंदु केवल समापन बिंदु का एकमात्र द्विदिश प्रकार है, अन्य सभी या तो डेटा प्राप्त करने या केवल संचारित करने के लिए काम करते हैं।
2. इंटरप्रेन्योर एंडपॉइंट एंडपॉइंट हैं, जिनके लिए दिए गए फ्रीक्वेंसी पर होस्ट पोलिंग महत्वपूर्ण है (हमें याद है कि USB डिवाइस स्वयं ट्रांसफर शुरू नहीं कर सकते हैं, वे होस्ट से अनुरोध की प्रतीक्षा कर रहे हैं)। आमतौर पर, इस प्रकार का बिंदु कीबोर्ड और माउस जैसे HID उपकरणों में उपयोग किया जाता है। पैकेट का आकार एफएस यूएसबी में 64 बाइट तक भी हो सकता है। डिलीवरी की गारंटी।
3. Isochronous Endpoint - एक समापन बिंदु जो मुख्य रूप से ऑडियो और वीडियो जानकारी प्रसारित करने के लिए उपयोग किया जाता है जहां पैकेट हानि भयानक नहीं है - इस प्रकार के समापन बिंदु में केवल डेटा अखंडता की जांच की जाती है, एक त्रुटि के मामले में फिर से भेजने का प्रदर्शन नहीं किया जाता है। FS USB में पैकेट का आकार 1024 बाइट तक होता है।
4. बल्क एनपॉइंट सूचना भंडारण उपकरणों में उपयोग किए जाने वाले मुख्य प्रकार के समापन बिंदु हैं।
   यह गारंटी वितरण के साथ डेटा पैकेट भेजने और एफएस यूएसबी के लिए 64 बाइट्स के एक पैकेट के आकार (उच्च गति के लिए, पैकेट का आकार 1023 बाइट्स तक पहुंच सकता है) मानता है। हमारे STM32 के USB नियंत्रक में इस प्रकार के पैकेट के लिए हार्डवेयर डबल बफरिंग को व्यवस्थित करने की क्षमता है, जिससे थ्रूपुट बढ़ रहा है। इंटरप्ट, कंट्रोल और इस्सोक्रोनस के बाद शेष उपलब्ध बैंडविड्थ बल्क एंडपॉइंट्स के बीच विभाजित होता है - इसलिए आपको इस बात पर ध्यान देना चाहिए कि अन्य ट्रांसफ़र क्या समानांतर में चलते हैं। थोक के साथ।

1. सबसे पहले, आधिकारिक साइट से यूएसबी के साथ काम करने के लिए एसटीएम लाइब्रेरी डाउनलोड करें और डाउनलोड किए गए संग्रह के आंत्र से (लाइब्रेरी लाइब्रेरी में स्थित) एसटीएम 32_यूएसबी-एफएस-डिवाइस_ड्राइवर फ़ोल्डर को हमारी परियोजना के साथ फ़ोल्डर में डालें। फ़ाइल का चयन करके इसे प्रोजेक्ट में जोड़ें - लिंक्ड फ़ोल्डर जोड़ें । हम अपने प्रोजेक्ट में एक नया फोल्डर जोड़ते हैं, इसे usb_user की तरह कहते हैं, जिसमें हम hw_config.h और usb_conf.h फाइलें बनाते हैं - इन फाइलों की आवश्यकता एसटीएम से लाइब्रेरी को होती है।
   Hw_config.h में हम तुरंत लिखते हैं
   
   

    #include "stm32f10x.h" 

   
   अन्यथा अनसुलझे प्रकारों से त्रुटियों का एक गुच्छा होगा (uint8_t, uint16_t, uint32_t, ...)
   समावेश के लिए खोज करने के लिए अतिरिक्त तरीकों के रूप में प्रोजेक्ट गुणों में लाइब्रेरी और हमारे usb_user के साथ फ़ोल्डर निर्दिष्ट करना न भूलें।
   
2. Usb_user में एक नई हेडर फ़ाइल जोड़ें, जिसमें डिस्क्रिप्टर के लिए आवश्यक घोषणाएँ होंगी, आइए इसे कहते हैं, usb_desc.h, निम्नलिखित कोड वहाँ डालते हैं:
   
   

    #include "usb_lib.h" #define SIZ_DEVICE_DESC 0x12 #define SIZ_CONFIG_DESC 0x19 #define SIZ_STRING_LANGID 0x04 #define SIZ_STRING_VENDOR 0x10 #define SIZ_STRING_PRODUCT 0x10 #define SIZ_STRING_SERIAL 0x12 extern const uint8_t USB_ConfigDescriptor[SIZ_CONFIG_DESC]; extern ONE_DESCRIPTOR Device_Descriptor; extern ONE_DESCRIPTOR Config_Descriptor; extern ONE_DESCRIPTOR String_Descriptor[4]; 

   
   यहां, " SIZ_ " के साथ शुरू होने वाले परिभाषित में भविष्य के विवरणों के आकार शामिल हैं। डिजाइन प्रक्रिया के दौरान, इन आकारों को निर्धारित किया जाता है, क्योंकि विवरणकर्ता पहले से ही लिखे गए हैं, लेकिन चूंकि मैंने पहले से ही डिवाइस को डिज़ाइन किया है, आप इसे कॉपी कर सकते हैं।
   extern const uint8_t USB_ConfigDescriptor हम केवल हेडर में रखते हैं क्योंकि हमें मुख्य मॉड्यूल से इस संरचना तक पहुंच की आवश्यकता है। बाकी डिस्क्रिप्टर की आवश्यकता नहीं है, क्योंकि हम डिस्क्रिप्टर को uint_8 सरणियों के रूप में लाइब्रेरी में नहीं देंगे, लेकिन विशेष संरचना जिन्हें One_DESCRIPTOR कहा जाता है, जो इस मामले के लिए नीचे घोषित किए गए हैं। उनके साथ कुछ भी गलत नहीं है, यह सिर्फ दो सदस्यों की संरचना है, जिनमें से पहला फॉर्म uint8_t * में एक ही डिस्क्रिप्टर का पॉइंटर है, दूसरा इस डिस्क्रिप्टर की सोलह-बिट लंबाई है।
   अब एक नए usb_desc.c फ़ाइल को जोड़ते हुए और वहां हमारे हेडर को कनेक्ट करते हुए, डिस्क्रिप्टर पर चलते हैं।
   हम डिवाइस के एक डिस्क्रिप्टर से ही शुरू करते हैं। फ़ील्ड के बारे में सभी आवश्यक जानकारी USB इन ए नटशेल के लेख में है, मैं केवल यह नोट करूंगा कि सभी डिस्क्रिप्टर डिस्क्रिप्टर की बाइट लंबाई (जिसके कारण हम उन्हें डिफाइन में डालते हैं) से शुरू होते हैं, उसके बाद बाइट - डिस्क्रिप्टर का प्रकार।
   यह डिवाइस डिस्क्रिप्टर जैसा दिखता है:
   
   
   डिवाइस डिस्क्रिप्टर

    const uint8_t USB_DeviceDescriptor[SIZ_DEVICE_DESC] = { 0x12, /* bLength */ 0x01, /* bDescriptorType */ 0x00, 0x02, /* bcdUSB = 2.00 */ 0xFF, /* bDeviceClass: Vendor Specific */ 0x00, /* bDeviceSubClass */ 0x00, /* bDeviceProtocol */ 0x40, /* bMaxPacketSize0 */ 0xAD, 0xDE, /* idVendor*/ 0x0D, 0xF0, /* idProduct*/ 0x00, 0x01, /* bcdDevice = 2.00 */ 1, /* Index of string descriptor describing manufacturer */ 2, /* Index of string descriptor describing product */ 3, /* Index of string descriptor describing the device's serial number */ 0x01 /* bNumConfigurations */ }; 

   
   
   
   
   हम VID = 0xDEAD और PID = 0xF00D, एकल कॉन्फ़िगरेशन और 64 बाइट्स के अधिकतम पैकेट आकार के साथ एक "विक्रेता-विशिष्ट" डिवाइस (HID जैसी किसी विशेष पूर्वनिर्धारित वर्ग से संबंधित नहीं) बना रहे हैं।
   अगला, हम एक कॉन्फ़िगरेशन डिस्क्रिप्टर की घोषणा करते हैं, जिसमें इंटरफ़ेस और समापन बिंदु वर्णनकर्ता शामिल हैं:
   
   
   विन्यास विवरणक

    const uint8_t USB_ConfigDescriptor[SIZ_CONFIG_DESC] = { /*Configuration Descriptor*/ 0x09, /* bLength: Configuration Descriptor size */ 0x02, /* bDescriptorType: Configuration */ SIZ_CONFIG_DESC, /* wTotalLength:no of returned bytes */ 0x00, 0x01, /* bNumInterfaces: 1 interface */ 0x01, /* bConfigurationValue: Configuration value */ 0x00, /* iConfiguration: Index of string descriptor describing the configuration */ 0xE0, /* bmAttributes: bus powered */ 0x32, /* MaxPower 100 mA */ /*Interface Descriptor*/ 0x09, /* bLength: Interface Descriptor size */ 0x04, /* bDescriptorType: Interface */ 0x00, /* bInterfaceNumber: Number of Interface */ 0x00, /* bAlternateSetting: Alternate setting */ 0x01, /* bNumEndpoints: One endpoints used */ 0xFF, /* bInterfaceClass: Vendor Specific*/ 0x00, /* bInterfaceSubClass*/ 0x00, /* bInterfaceProtocol*/ 0x00, /* iInterface: */ /*Endpoint 1 Descriptor*/ 0x07, /* bLength: Endpoint Descriptor size */ 0x05, /* bDescriptorType: Endpoint */ 0x01, /* bEndpointAddress: (OUT1) */ 0x02, /* bmAttributes: Bulk */ 0x40, /* wMaxPacketSize: */ 0x00, 0x00 /* bInterval: */ }; 

   
   
   
   यहां आपको सावधान रहने की आवश्यकता है - पहला बाइट केवल कॉन्फिग डिस्क्रिप्टर का आकार है, जो हमेशा 0x09 बाइट्स होता है। इसके बाद इस डिस्क्रिप्टर का प्रकार आता है, लेकिन फिर पूरे वर्ण की डबल-बाइट लंबाई आती है, जिसमें कॉन्फ़िगरेशन डिस्क्रिप्टर, इंटरफेस के लिए डिस्क्रिप्टर और एंडपॉइंट शामिल हैं। इस मामले में, यह एक बाइट में फिट बैठता है, इसलिए दूसरा शून्य छोड़ दिया जाता है।
   फिर हम लिखते हैं कि हमारे पास एक इंटरफ़ेस, एक कॉन्फ़िगरेशन (इंडेक्स 0 पर स्थित) है, कि डिवाइस एक बस द्वारा संचालित है और 100 एमए से अधिक नहीं खपत करता है।
   उसी सरणी में आगे एक इंटरफ़ेस डिस्क्रिप्टर है, उसी 0x09 बाइट्स का आकार, दो इंडेक्स, दोनों शून्य, जिस पर होस्ट इस इंटरफ़ेस को विशेष रूप से एक्सेस करता है, अंतिम बिंदुओं की संख्या शून्य की गिनती नहीं करता है - हमारे पास एक होगा, डिवाइस वर्ग, फिर से "विक्रेता विशिष्ट"। , कोई उपवर्ग, कोई प्रोटोकॉल, इंटरफ़ेस के लिए कोई स्ट्रिंग डिस्क्रिप्टर (सभी संबंधित बाइट्स में शून्य)।
   अंत में, अंतिम हमारे एकमात्र बिंदु के लिए संभाल है। समापन बिंदु 0 को इसकी आवश्यकता नहीं है, इसलिए हम तुरंत बल्क एंडपॉइन का वर्णन करते हैं। 1. पता बाइट न केवल समापन बिंदु संख्या, बल्कि इसके उच्च बिट के साथ संचरण की दिशा भी निर्धारित करता है। हम पैकेट को प्रकार सेट करते हैं, पैकेट का सीमा आकार (ध्यान, इसके लिए दो बाइट्स आवंटित किए जाते हैं!) और अंतिम बाइट को शून्य के बराबर छोड़ दें, क्योंकि यह बल्क एंडपॉइंट के लिए भूमिका नहीं निभाता है।
   अगला, स्ट्रिंग डिस्क्रिप्टर घोषित करें:
   
   
   स्ट्रिंग वर्णनकर्ता

    /* USB String Descriptors */ const uint8_t USB_StringLangID[SIZ_STRING_LANGID] = { SIZ_STRING_LANGID, /* bLength */ 0x03, /* String descriptor */ 0x09, 0x04 /* LangID = 0x0409: US English */ }; const uint8_t USB_StringVendor[SIZ_STRING_VENDOR] = { SIZ_STRING_VENDOR, /* Size of Vendor string */ 0x03, /* bDescriptorType*/ /* Manufacturer: "Amon-Ra" */ 'A', 0, 'm', 0, 'o', 0, 'n', 0, '-', 0, 'R', 0, 'a', 0 }; const uint8_t USB_StringProduct[SIZ_STRING_PRODUCT] = { SIZ_STRING_PRODUCT, /* bLength */ 0x03, /* bDescriptorType */ /* Product name: "USB LCD" */ 'U', 0, 'S', 0, 'B', 0, ' ', 0, 'L', 0, 'C', 0, 'D', 0 }; uint8_t USB_StringSerial[SIZ_STRING_SERIAL] = { SIZ_STRING_SERIAL, /* bLength */ 0x03, /* bDescriptorType */ 'U', 0, 'S', 0, 'B', 0, 'L', 0, 'C', 0, 'D', 0, '0', 0, '1', 0 }; 

   
   
   
   यूनिकोड के तारों को इच्छानुसार बदला जा सकता है।
   अंत में, पुस्तकालय द्वारा आवश्यक संरचनाओं को भरें:
   
   
   पुस्तकालय के लिए संरचनाएं

    ONE_DESCRIPTOR Device_Descriptor = { (uint8_t*)USB_DeviceDescriptor, SIZ_DEVICE_DESC }; ONE_DESCRIPTOR Config_Descriptor = { (uint8_t*)USB_ConfigDescriptor, SIZ_CONFIG_DESC }; ONE_DESCRIPTOR String_Descriptor[4] = { {(uint8_t*)USB_StringLangID, SIZ_STRING_LANGID}, {(uint8_t*)USB_StringVendor, SIZ_STRING_VENDOR}, {(uint8_t*)USB_StringProduct, SIZ_STRING_PRODUCT}, {(uint8_t*)USB_StringSerial, SIZ_STRING_SERIAL} }; 

   
   
   
   
3. Usb_conf.h में कुछ वर्णनात्मक कोड जोड़ें:
   
   
   Usb_conf.h कोड

    #define EP_NUM 0x02 #define BTABLE_ADDRESS (0x00) /* EP0 */ /* rx/tx buffer base address */ #define ENDP0_RXADDR (0x40) #define ENDP0_TXADDR (0x80) /* EP1 */ /* tx buffer base address */ #define ENDP1_RXADDR (0xC0) /* IMR_MSK */ /* mask defining which events has to be handled */ /* by the device application software */ #define IMR_MSK (CNTR_CTRM | CNTR_RESETM) 

   
   
   
   उपरोक्त सभी में से कुछ भी पुस्तकालय द्वारा आवश्यक नहीं है और केवल हमारे मुख्य मॉड्यूल में कोड की पठनीयता में सुधार करने के लिए आवश्यक है। अपवाद IMR_MSK है , एक मुखौटा जो दिखा रहा है कि यूएसबी इंटरप्ट का उपयोग किया जा रहा है। इसे सही न्यूनतम पर सेट करें - सही ट्रांसफर और रीसेट का रुकावट।
   समापन बिंदु पते तथाकथित पीएमए, पैकेट मेमोरी एरिया के एड्रेस स्पेस में सेट होते हैं, पैकेट की लंबाई को ध्यान में रखते हैं। चूंकि दोनों समापन बिंदुओं के लिए अधिकतम पैकेट आकार 64 बाइट्स पर सेट है, हम उन्हें उचित कदम के साथ रखते हैं, इन समान समापन बिंदुओं के पते की तालिका को नहीं भूलते हैं, जो वहां संग्रहीत होता है और स्थान भी लेता है।
   
4. अब हमें कॉलबैक को परिभाषित करने की आवश्यकता है जो पुस्तकालय की आवश्यकता है। ये कॉलबैक DEVICE_PROP और USER_STANDARD_REQUESTS संरचनाओं में संयुक्त हैं, और लाइब्रेरी Device_Property और User_Standard_Requests नामों के तहत उनके उदाहरणों की तलाश करेंगे ।
   यूएसबी कंट्रोलर के इनिशियलाइज़ेशन के दौरान, बहुत शुरुआत में कॉल किए गए कॉलबैक से शुरू करते हैं, जिसका कार्य USB चंक को रीसेट करना है, लाइब्रेरी के शुरुआती कार्यों को कॉल करें और यूएसबी लाइन पर पुल-अप को सक्रिय करें, जो हमें बस में होस्ट करता है।
   
   
   शून्य Device_init ()

    void Device_init() { DEVICE_INFO *pInfo = &Device_Info; pInfo->Current_Configuration = 0; _SetCNTR(CNTR_FRES); //Reset USB block _SetCNTR(0); //Deassert reset signal _SetISTR(0); //Clear pending interrupts USB_SIL_Init(); GPIO_ResetBits(GPIOC, GPIO_Pin_13); //Enable pull-up } 

   
   
   
   निम्नलिखित कॉलबैक तब कहा जाता है जब मेजबान हमारे डिवाइस के रीसेट का अनुरोध करता है:
   
   
   शून्य Device_Reset ()

    void Device_Reset() { //Set device as not configured pInformation->Current_Configuration = 0; pInformation->Current_Interface = 0; //the default Interface /* Current Feature initialization */ pInformation->Current_Feature = USB_ConfigDescriptor[7]; SetBTABLE(BTABLE_ADDRESS); /* Initialize Endpoint 0 */ SetEPType(ENDP0, EP_CONTROL); SetEPTxStatus(ENDP0, EP_TX_STALL); SetEPRxAddr(ENDP0, ENDP0_RXADDR); SetEPTxAddr(ENDP0, ENDP0_TXADDR); Clear_Status_Out(ENDP0); SetEPRxCount(ENDP0, Device_Property.MaxPacketSize); SetEPRxValid(ENDP0); SetEPType(ENDP1, EP_BULK); SetEPRxAddr(ENDP1, ENDP1_RXADDR); SetEPRxCount(ENDP1, 0x40); SetEPRxStatus(ENDP1, EP_RX_VALID); SetEPTxStatus(ENDP1, EP_TX_DIS); /* Set this device to response on default address */ SetDeviceAddress(0); } 

   
   
   
   , 0, .
   ,
   
   

    #define Device_Status_In NOP_Process #define Device_Status_Out NOP_Process 

   
   , , , , , .
   , - Control Endpoint 0, :
   
   

    RESULT Device_Data_Setup(uint8_t RequestNo) { return USB_UNSUPPORT; } RESULT Device_NoData_Setup(uint8_t RequestNo) { return USB_UNSUPPORT; } 

   
   , , , , . - , .
   , , . , USB_UNSUPPORT .
   
   

    RESULT Device_Get_Interface_Setting(uint8_t Interface, uint8_t AlternateSetting) { if (AlternateSetting > 0) { return USB_UNSUPPORT; } else if (Interface > 0) { return USB_UNSUPPORT; } return USB_SUCCESS; } 

   
   STM , :
   
   

    uint8_t *Device_GetDeviceDescriptor(uint16_t Length) { return Standard_GetDescriptorData(Length, &Device_Descriptor); } uint8_t *Device_GetConfigDescriptor(uint16_t Length) { return Standard_GetDescriptorData(Length, &Config_Descriptor); } uint8_t *Device_GetStringDescriptor(uint16_t Length) { uint8_t wValue0 = pInformation->USBwValue0; if (wValue0 > 4) { return NULL; } else { return Standard_GetDescriptorData(Length, &String_Descriptor[wValue0]); } } 

   
   
   
   , :
   
   

    DEVICE_PROP Device_Property = { Device_init, Device_Reset, Device_Status_In, Device_Status_Out, Device_Data_Setup, Device_NoData_Setup, Device_Get_Interface_Setting, Device_GetDeviceDescriptor, Device_GetConfigDescriptor, Device_GetStringDescriptor, 0, 0x40 /*MAX PACKET SIZE*/ }; 

   
   
5. , User_Standard_Requests .
   — .. HID - , , NOP_Process . , User_SetDeviceAddress – , .
   
   
   User_Standard_Requests

    #define Device_GetConfiguration NOP_Process #define Device_SetConfiguration NOP_Process #define Device_GetInterface NOP_Process #define Device_SetInterface NOP_Process #define Device_GetStatus NOP_Process #define Device_ClearFeature NOP_Process #define Device_SetEndPointFeature NOP_Process #define Device_SetDeviceFeature NOP_Process #define Device_SetDeviceAddress NOP_Process USER_STANDARD_REQUESTS User_Standard_Requests = { Device_GetConfiguration, Device_SetConfiguration, Device_GetInterface, Device_SetInterface, Device_GetStatus, Device_ClearFeature, Device_SetEndPointFeature, Device_SetDeviceFeature, Device_SetDeviceAddress }; 

   
   
   
   
6. , :
   

    __IO uint16_t wIstr; DEVICE Device_Table = { EP_NUM, 1 }; 

   
   , ( ) .
   
7. – , :
   
   
   void USB_Interrupts_Config(void) void Set_USBClock()

    void USB_Interrupts_Config(void) { NVIC_InitTypeDef NVIC_InitStructure; NVIC_PriorityGroupConfig(NVIC_PriorityGroup_1); NVIC_InitStructure.NVIC_IRQChannel = USB_LP_CAN1_RX0_IRQn; NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1; NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1; NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; NVIC_Init(&NVIC_InitStructure); NVIC_InitStructure.NVIC_IRQChannel = USB_HP_CAN1_TX_IRQn; NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1; NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0; NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; NVIC_Init(&NVIC_InitStructure); } void Set_USBClock() { /* Select USBCLK source */ RCC_USBCLKConfig(RCC_USBCLKSource_PLLCLK_1Div5); /* Enable the USB clock */ RCC_APB1PeriphClockCmd(RCC_APB1Periph_USB, ENABLE); } 

   
   
   
   .
   Low-Priority ( , ), .
   Isochronous Bulk , ( ). , .
   USB 1.5 (48 ) USB.
   
8. , , .
   
   

    void USB_HP_CAN1_TX_IRQHandler(void) { CTR_HP(); } void USB_LP_CAN1_RX0_IRQHandler(void) { wIstr = _GetISTR(); #if (IMR_MSK & ISTR_CTR) if (wIstr & ISTR_CTR & wInterrupt_Mask) { CTR_LP(); } #endif #if (IMR_MSK & ISTR_RESET) if (wIstr & ISTR_RESET & wInterrupt_Mask) { _SetISTR((uint16_t)CLR_RESET); Device_Property.Reset(); } #endif } 

   
   
   
   , – USB , USB LCD, . , Bulk Endpoint 1 , .
   
9. – , NOT_ADDRESSED TRANSFER_IN_PROGRESS . , 8 , X Y ( 16- ) , , . ( ) , , . , , , - , . , . , .
   , – , PMAToUserBufferCopy , . , - ?
   PMAToUserBufferCopy , PMAToLCDBufferCopy , :
   
   

    void PMAToLCDBufferCopy(uint16_t wPMABufAddr, uint16_t offset ,uint16_t wNBytes) { uint32_t n = (wNBytes + 1) >> 1; uint32_t i; uint32_t *pdwVal; pdwVal = (uint32_t *)(wPMABufAddr * 2 + PMAAddr+offset); for (i = n; i != 0; i--) LCD_WRITE_RAM(*pdwVal++); } 

   
   :
   
   

    void EP1_OUT_Callback(void) { uint16_t dataLen = GetEPRxCount(EP1_OUT & 0x7F); uint16_t offset=0; if(GraphicsState==NOT_ADDRESSED) { if(dataLen<=8) { SetEPRxStatus(ENDP1, EP_RX_VALID); return; } PMAToUserBufferCopy(buffer, GetEPRxAddr(EP1_OUT & 0x7F), 8); uint16_t horz = *((uint16_t*)(buffer)); uint16_t vert = *(uint16_t*)(buffer+2); dataTotal = *(uint32_t*)(buffer+4); LCD_WRITE_REGISTER(CTR_HORZ_ADDRESS,vert); //  LCD_WRITE_REGISTER(CTR_VERT_ADDRESS,horz); offset=16; dataTransfered=0x00; GraphicsState=TRANSFER_IN_PROGRESS; dataLen-=8; } LCD_BEGIN_RAM_WRITE; PMAToLCDBufferCopy(GetEPRxAddr(EP1_OUT & 0x7F), offset, dataLen); dataTransfered+=(dataLen)>>1; if(dataTransfered>=dataTotal) GraphicsState=NOT_ADDRESSED; SetEPRxStatus(ENDP1, EP_RX_VALID); } 

   
   
   , , , ( ) NOP_Process :
   
   
   समापन बिंदु कॉलबैक संरचनाएँ

    void (*pEpInt_IN[7])(void) = { NOP_Process, NOP_Process, NOP_Process, NOP_Process, NOP_Process, NOP_Process, NOP_Process, }; void (*pEpInt_OUT[7])(void) = { EP1_OUT_Callback, NOP_Process, NOP_Process, NOP_Process, NOP_Process, NOP_Process, NOP_Process, }; 

   
   
   
   

निरीक्षण

 var bytesToWrite = File.ReadAllBytes("D:\\myfile.raw");