100 एमबीपीएस पर माइक्रोकंट्रोलर्स के बीच डेटा ट्रांसफर कैसे करें

मुझे इस तरह की समस्या मिली: मुझे दो माइक्रोकंट्रोलर्स STM32F407 के बीच कम से कम 100 एमबीपीएस की गति से डेटा ट्रांसफर करने की आवश्यकता है। ईथरनेट (मैक-टू-मैक) का उपयोग करना संभव होगा, लेकिन परेशानी यह है कि यह व्यस्त है, यह इस डेटा से है कि उन्हें लिया गया है ...
निष्क्रिय परिधि से शायद केवल एसपीआई है - लेकिन यह केवल 42 एमबीपीएस है।

अजीब तरह से पर्याप्त है, नेटवर्क पर कुछ भी तैयार नहीं पाया गया। और मैंने एक समानांतर 8-बिट क्लॉक रजिस्टर को लागू करने का निर्णय लिया। और क्या - आवृत्ति को 10 मेगाहर्ट्ज पर सेट किया जा सकता है (अर्थात, घड़ी अपने आप में दो बार तेज है, लेकिन 20 मेगाहर्ट्ज कुछ जटिल नहीं है) - इसलिए इस तरह की कम आवृत्ति के साथ आपको बोर्ड की वायरिंग के बारे में चिंता करने की ज़रूरत नहीं है। और स्पीड 100 एमबीपीएस होगी।

जल्दी से नहीं कहा। सामान्य तौर पर, सिस्टम इस तरह दिखता है। हम ट्रांसमिटिंग साइड पर एक टाइमर का उपयोग करते हैं, तुलना संकेतों में से एक पिन के लिए आउटपुट है - यह एक घड़ी सिग्नल होगा, और दूसरा डीएमए के लिए एक फट शुरू करने के लिए उपयोग किया जाएगा।

मेरे पास 82 मेगाहर्ट्ज पर एक बस है (उच्च आवृत्ति पर वर्तमान खपत के कारण :), एक ही आवृत्ति पर एक टाइमर: ताकि एआरआर = 8 की अवधि के साथ यह लगभग 10 मेगाहर्ट्ज निकला (इसलिए यह लगभग 80 एमबीपीएस होगा, ठीक है, ठीक है)।

DMA मेमोरी से एक बाइट (ऑटो-इन्क्रीमेंट के साथ, निश्चित रूप से) को सीधे रजिस्टर आउटपुट पोर्ट में ट्रांसफर कर देगा - मेरे मामले में, PORTE आया - इसके पहले 8 बिट्स सिर्फ DMA रिसीवर के पते के रूप में फिट होते हैं।

प्राप्त होने पर, हम टाइमर को देखने के लिए दोनों किनारों पर घड़ी सिग्नल का उपयोग करेंगे, 1 की अवधि के साथ, और हम डीएमए के लिए अग्रेषण शुरू करने के लिए अपडेट सिग्नल का उपयोग करेंगे, जो पोर्ट से डेटा पढ़ता है (PORTE पोर्ट फिर से आ गया और ऑटो-इंक्रीमेंट के साथ मेमोरी में लिखता है।

अब यह सब कुछ सही ढंग से कॉन्फ़िगर करने (नीचे कोड) और चलाने के लिए बना हुआ है। दोनों पक्षों पर समाप्ति डीएमए से बाधित होने से निर्धारित होती है।

हालांकि, पूर्णता के लिए, निश्चित रूप से, आपको ट्रांसमिशन देरी और कोड में त्रुटि से निपटने के लिए चेक शामिल करने की आवश्यकता है, लेकिन मैं इसे छोड़ देता हूं।

नीचे दिए गए कोड में, TIM8 टाइमर सिग्नल को आउटपुट करने के लिए CC2 चैनल का उपयोग करता है - यह देखने के लिए कि क्या होता है।

volatile int transmit_done; volatile int receive_done; void DMA2_Stream1_IRQHandler(void) { TIM8->CR1 &= ~TIM_CR1_CEN; DMA2->LIFCR |= 0b1111 << 8; receive_done = 1; } void DMA2_Stream4_IRQHandler(void) { TIM1->CR1 &= ~TIM_CR1_CEN; TIM1->EGR |= TIM_EGR_BG; DMA2->HIFCR |= 0b1111101; transmit_done = 1; } void ii_receive(uint8_t *data, int len) { GPIOE->MODER = (GPIOE->MODER & 0xFFFF0000) | 0x0000; DMA2_Stream1->PAR = (uint32_t) &(GPIOE->IDR); DMA2_Stream1->M0AR = (uint32_t) data; DMA2_Stream1->NDTR = len; TIM8->CNT = 0; TIM8->BDTR |= TIM_BDTR_MOE; receive_done = 0; DMA2_Stream1->CR |= DMA_SxCR_EN; TIM8->CR1 |= TIM_CR1_CEN; } void ii_transmit(uint8_t *data, int len) { GPIOE->MODER = (GPIOE->MODER & 0xFFFF0000) | 0x5555; DMA2_Stream4->PAR = (uint32_t) &(GPIOE->ODR); DMA2_Stream4->M0AR = (uint32_t) data; DMA2_Stream4->NDTR = len; TIM1->CNT = 6; transmit_done = 0; DMA2_Stream4->CR |= DMA_SxCR_EN; TIM1->SR |= TIM_SR_BIF; TIM1->BDTR |= TIM_BDTR_MOE; TIM1->CR1 |= TIM_CR1_CEN; } // tx: TIM1 CH4 on DMA2/stream4/channel6, CH1 on output clock in PE9 // rx: TIM8 CH2 on DMA2/stream3/channel7, CH1 on input clock in PC6 void ii_init() { __HAL_RCC_GPIOC_CLK_ENABLE(); __HAL_RCC_GPIOE_CLK_ENABLE(); __HAL_RCC_TIM1_CLK_ENABLE(); __HAL_RCC_TIM8_CLK_ENABLE(); __HAL_RCC_TIM2_CLK_ENABLE(); __HAL_RCC_DMA2_CLK_ENABLE(); GPIOC->MODER |= (0b10 << GPIO_MODER_MODE6_Pos) | (0b10 << GPIO_MODER_MODE7_Pos); GPIOC->PUPDR |= (0b10 << GPIO_PUPDR_PUPD7_Pos); GPIOC->AFR[0] |= (GPIO_AF3_TIM8 << 24) | (GPIO_AF3_TIM8 << 28); GPIOE->MODER |= (0b10 << GPIO_MODER_MODE9_Pos); GPIOE->OSPEEDR |= GPIO_OSPEEDER_OSPEEDR9 | 0xFFFF; GPIOE->AFR[1] |= GPIO_AF1_TIM1 << 4; GPIOE->PUPDR |= (0b10 << GPIO_PUPDR_PUPD9_Pos); TIM1->ARR = 8; TIM1->CCR1 = 5; TIM1->CCR4 = 1; TIM1->EGR |= TIM_EGR_CC4G; TIM1->DIER |= TIM_DIER_CC4DE; TIM1->CCMR1 |= (0b110 << TIM_CCMR1_OC1M_Pos); TIM1->CCER |= TIM_CCER_CC1E; TIM1->EGR |= TIM_EGR_BG; TIM8->ARR = 1; TIM8->CCR2 = 1; TIM8->EGR |= TIM_EGR_UG; TIM8->DIER |= TIM_DIER_UDE; TIM8->SMCR |= (0b100 << TIM_SMCR_TS_Pos) | (0b111 << TIM_SMCR_SMS_Pos); TIM8->CCMR1 = (0b01 << TIM_CCMR1_CC1S_Pos) | (0b110 << TIM_CCMR1_OC2M_Pos); TIM8->CCER |= (0b11 << TIM_CCER_CC1P_Pos) | TIM_CCER_CC2E; DMA2_Stream1->CR = DMA_CHANNEL_7 | DMA_PRIORITY_VERY_HIGH | DMA_MINC_ENABLE | (0b00 << DMA_SxCR_DIR_Pos) | DMA_SxCR_TCIE | DMA_SxCR_TEIE | DMA_SxCR_DMEIE; DMA2_Stream1->FCR |= DMA_FIFOMODE_ENABLE; DMA2_Stream4->CR = DMA_CHANNEL_6 | DMA_PRIORITY_VERY_HIGH | DMA_MINC_ENABLE | (0b01 << DMA_SxCR_DIR_Pos) | DMA_SxCR_TCIE | DMA_SxCR_TEIE | DMA_SxCR_DMEIE; DMA2_Stream4->FCR |= DMA_FIFOMODE_ENABLE; HAL_NVIC_SetPriority(DMA2_Stream1_IRQn, 0, 0); HAL_NVIC_EnableIRQ(DMA2_Stream1_IRQn); HAL_NVIC_SetPriority(DMA2_Stream4_IRQn, 0, 0); HAL_NVIC_EnableIRQ(DMA2_Stream4_IRQn); } 

परीक्षणों के लिए, एक ही बोर्ड का उपयोग किया गया था, बस PE9 घड़ी आउटपुट PC6 इनपुट से जुड़ा था। मुख्य लूप इस तरह दिखता था:

  ii_receive(rdata, 256); ii_transmit(tdata, 256); while (!transmit_done); while (!receive_done); 

परिणामों के अनुसार: डेटा पूरी तरह से बिना नुकसान के 30-31 माइक्रोसेकंड के लिए भेजा गया था। संकेत कुछ इस तरह दिखते हैं:


यहाँ, सफेद TIM8 टाइमर का उत्पादन है, लाल घड़ी संकेत (TIM1) है, और नारंगी कम से कम महत्वपूर्ण बिट डेटा (0-1-0-1 -...) है।

इस बारे में मुझे क्या पसंद नहीं है कि आप GPIO इनपुट से व्यवधान से DMA शुरू नहीं कर सकते, आपको टाइमर के साथ काम करना होगा। शायद कोई आपको दूसरा रास्ता बताएगा?

PS नए प्रयोगों के परिणामस्वरूप, यह पता चला कि आवृत्ति को 168 MHz तक बढ़ाकर स्वाभाविक रूप से गति 2 गुना बढ़ा दी गई है और डेटा को 14 माइक्रोसेकंड (यानी 150 एमबीपीएस) में प्रसारित किया गया था, लेकिन जब मास्टर टाइमर 7 से कम हो गया, तो प्राप्त पक्ष गड़बड़ होना शुरू हो गया - टाइमर का समय नहीं है TIM8। 7 पर यह अभी भी काम करता है, लेकिन 6 पर यह पहले से ही चला गया है, और आखिरकार यह 200 एमबीपीएस होगा ...