Stm32 ईवेंट और व्यवधान


17

मैंने stm32 पर विशेष रूप से stm32f4 डिस्कवरी बोर्ड पर इंटरप्ट का अध्ययन शुरू किया। मुझे यह उदाहरण मिला जिसमें आपको रुकावट शुरू करने के लिए बटन दबाना होगा और इसे रोकने के लिए फिर से धक्का देना होगा।

इस पंक्ति में: EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt हमें इंटरप्ट मोड या ईवेंट मोड में से किसी एक को चुनना होगा। मैंने इसे ईवेंट मोड में बदल दिया, लेकिन यह काम नहीं करता है। इसलिए मैं इस निष्कर्ष के साथ आया हूं कि हैंडलर को मार दिया जाता है जो केवल बीच में रोक देता है।

अगर आप ऐसा होने पर कुछ कोड निष्पादित नहीं कर पाते हैं तो हम stm32 पर इवेंट्स का उपयोग क्यों करते हैं?

यहाँ कोड है:

        #include "stm32f4xx.h"
        #include "stm32f4xx_syscfg.h"
        #include "stm32f4xx_rcc.h"
        #include "stm32f4xx_gpio.h"
        #include "stm32f4xx_exti.h"
        #include "misc.h"



        EXTI_InitTypeDef   EXTI_InitStructure;

        void EXTILine0_Config(void);
        void LEDInit(void);


        void ExtInt(void)
        {

          LEDInit();

          /* Configure EXTI Line0 (connected to PA0 pin) in interrupt mode */
          EXTILine0_Config();

          /* Generate software interrupt: simulate a rising edge applied on EXTI0 line */
          EXTI_GenerateSWInterrupt(EXTI_Line0);

          while (1)
          {
          }
        }

        /**
          * @brief  Configures LED GPIO.
          * @param  None
          * @retval None
          */
        void LEDInit()
        {
          GPIO_InitTypeDef  GPIO_InitStructure;

          /* Enable the GPIO_LED Clock */
          RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);

          /* Configure the GPIO_LED pin */
          GPIO_InitStructure.GPIO_Pin = GPIO_Pin_12;
          GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
          GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
          GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
          GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
          GPIO_Init(GPIOD, &GPIO_InitStructure);
        }

        /**
          * @brief  Configures EXTI Line0 (connected to PA0 pin) in interrupt mode
          * @param  None
          * @retval None
          */
        void EXTILine0_Config(void)
        {

          GPIO_InitTypeDef   GPIO_InitStructure;
          NVIC_InitTypeDef   NVIC_InitStructure;

          /* Enable GPIOA clock */
          RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, ENABLE);
          /* Enable SYSCFG clock */
          RCC_APB2PeriphClockCmd(RCC_APB2Periph_SYSCFG, ENABLE);

          /* Configure PA0 pin as input floating */
          GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN;
          GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
          GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0;
          GPIO_Init(GPIOA, &GPIO_InitStructure);

          /* Connect EXTI Line0 to PA0 pin */
          SYSCFG_EXTILineConfig(EXTI_PortSourceGPIOA, EXTI_PinSource0);

          /* Configure EXTI Line0 */
          EXTI_InitStructure.EXTI_Line = EXTI_Line0;
          EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;
          EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising;
          EXTI_InitStructure.EXTI_LineCmd = ENABLE;
          EXTI_Init(&EXTI_InitStructure);

          /* Enable and set EXTI Line0 Interrupt to the lowest priority */
          NVIC_InitStructure.NVIC_IRQChannel = EXTI0_IRQn;
          NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0x01;
          NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x01;
          NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
          NVIC_Init(&NVIC_InitStructure);
        }

        /**
          * @brief  This function handles External line 0 interrupt request.
          * @param  None
          * @retval None
          */
        void EXTI0_IRQHandler(void)
        {
          if(EXTI_GetITStatus(EXTI_Line0) != RESET)
          {
            /* Toggle LED1 */
            GPIO_ToggleBits(GPIOD, GPIO_Pin_12);

            /* Clear the EXTI line 0 pending bit */
            EXTI_ClearITPendingBit(EXTI_Line0);
          }
        }

        /**
          * @}
          */

        /**
          * @}
          */

        /******************* (C) COPYRIGHT 2011 STMicroelectronics *****END OF FILE****/

        int main(void)
        {

            while(1)
            {
            }
        }

जवाबों:


14

कभी-कभी एआरएम डिवाइस के लिए इन सवालों का जवाब खोजना सरल माइक्रोकंट्रोलर की तुलना में अधिक कठिन हो सकता है क्योंकि यह जानकारी अक्सर डेटाशीट में शामिल करने के बजाय परिवार और प्रोग्रामिंग गाइडों में फैली होती है। इस मामले में उत्तर RM0090 संदर्भ मैनुअल के पृष्ठ 381 पर प्रतीत होता है :

STM32F4xx कोर (WFE) को जगाने के लिए बाहरी या आंतरिक घटनाओं को संभालने में सक्षम हैं। जाग्रत घटना या तो द्वारा उत्पन्न की जा सकती है:

  • (मैंने सामान्य बाहरी व्यवधान मोड विवरण हटा दिया है)

  • या इवेंट मोड में एक बाहरी या आंतरिक EXTI लाइन को कॉन्फ़िगर करना। जब CPU WFE से फिर से शुरू होता है, तो परिधीय बाधा लंबित बिट या NVIC IRQ चैनल को लंबित करने के लिए आवश्यक नहीं है क्योंकि इवेंट लाइन के अनुरूप लंबित बिट सेट नहीं है।

ऐसा लगता है कि मुख्य उद्देश्य सामान्य ऑपरेशन के दौरान रुकावट पैदा करने या बिना रुकावट के जवाब देने के लिए जागने को सक्षम करना है।

यह उस मार्गदर्शिका में उल्लिखित नहीं है और मुझे यकीन नहीं है कि एसटीएम 32 आर्किटेक्चर पर कितना लागू है, लेकिन कुछ अन्य उपकरणों पर समान योजनाएं एक बाधा उत्पन्न किए बिना तेजी से घटनाओं को पकड़ने के लिए उपयोगी हो सकती हैं। उदाहरण के लिए, आपके पास एक ऐसा एप्लिकेशन हो सकता है जहां पर कब्जा करना महत्वपूर्ण है कि एक उप-माइक्रोसेकंड घटना हुई है, लेकिन इसे जल्दी से जवाब देने की कोई आवश्यकता नहीं है, इसलिए आप यह देखने के लिए कि यह हो सकता है, बस एक ध्वज की जांच कर सकते हैं।

संपादित करें: (५/२०१8) आज के अनुसार, संदर्भित पाठ की पृष्ठ संख्या ३ former१ है (पूर्व में पृष्ठ ३)))


1
हाँ, PICs पर ऐसा लगता है कि मैं एक बाधा में जो कुछ करता हूं, वह झंडे सेट है। कोर्टेक्स में, उन झंडों में से अधिकांश बिना रुकावट के सेट हो जाते हैं, इसलिए मैं कम अंतराल का उपयोग करता हूं
स्कॉट सेडमन
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.