👼🏿 🌲 👩🏻‍🎤 UART पार्ट 2 द्वारा ARM कॉर्टेक्स-एम माइक्रोकंट्रोलर्स को डीबग करना 🌵 🤙🏼 📁

पिछले लेख में, मैंने डिबगमन के व्यवधान और उससे जुड़े रजिस्टर के बारे में बात की थी।

इस लेख में हम UART के लिए डिबगर के कार्यान्वयन को लिखेंगे।

निम्न स्तर का हिस्सा

यहां और यहां GDB सर्वर के अनुरोधों और प्रतिक्रियाओं की संरचना का विवरण है। हालांकि यह सरल लगता है, हम इसे निम्नलिखित कारणों से माइक्रोकंट्रोलर में लागू नहीं करेंगे:

बड़ा डेटा अतिरेक। पते, रजिस्टर के मूल्य, चर हेक्स-स्ट्रिंग के रूप में एन्कोड किए गए हैं, जो संदेश की मात्रा को 2 गुना बढ़ाता है
संदेशों को पार्स करने और एकत्रित करने से अतिरिक्त संसाधन प्राप्त होंगे
पैकेट के अंत को ट्रैक करना या तो टाइमआउट (टाइमर व्यस्त हो जाएगा), या एक जटिल स्वचालित मशीन द्वारा आवश्यक है, जो UART में बिताए समय को बढ़ाएगा

सबसे आसान और सबसे तेज़ डिबगिंग मॉड्यूल प्राप्त करने के लिए, हम नियंत्रण अनुक्रमों के साथ एक बाइनरी प्रोटोकॉल का उपयोग करेंगे:

0xAA 0xFF - फ़्रेम की शुरुआत
0xAA 0x00 - फ़्रेम का अंत
0xAA 0xA5 - इंटरप्ट
0xAA 0xAA - 0xAA द्वारा प्रतिस्थापित

रिसेप्शन के दौरान इन दृश्यों को संसाधित करने के लिए, 4 राज्यों के साथ एक ऑटोमेटन की आवश्यकता होती है:

ईएससी चरित्र की प्रतीक्षा की जा रही है
फ्रेम सीक्वेंस की शुरुआत के दूसरे किरदार का इंतजार
डेटा का स्वागत
पिछली बार एक Esc चरित्र स्वीकार किया गया था

लेकिन राज्यों को भेजने के लिए, आपको पहले से ही 7 की जरूरत है:

फ़्रेम की पहली बाइट प्रारंभ करना
फ़्रेम का दूसरा बाइट प्रारंभ करना
डेटा भेज रहा है
फ्रेम के अंत प्रस्तुत करना
Esc चरित्र प्रतिस्थापन भेज रहा है
पहला इंटरप्ट बाइट भेजना
दूसरा इंटरप्ट बाइट भेजना

आइए हम उस संरचना की परिभाषा लिखते हैं जिसके अंदर सभी मॉड्यूल चर स्थित होंगे:

typedef struct 
{    
  // disable receive data
  unsigned tx:1;
  // program stopped
  unsigned StopProgramm:1;
  union {
    enum rx_state_e 
    {
      rxWaitS = 0, // wait Esc symbol
      rxWaitC = 1, // wait Start of frame
      rxReceive = 2, // receiving
      rxEsc = 3, // Esc received
    } rx_state;
    enum tx_state_e 
    {
      txSendS = 0, // send first byte of Start of frame
      txSendC = 1, // send second byte
      txSendN = 2, // send byte of data
      txEsc = 3,   // send escaped byte of data
      txEnd = 4,   // send End of frame
      txSendS2 = 5,// send first byte of Interrupt
      txBrk = 6,   // send second byte
    } tx_state;
  };
  uint8_t pos; // receive/send position
  uint8_t buf[128]; // offset = 3
  uint8_t txCnt; // size of send data
} dbg_t;
#define dbgG ((dbg_t*)DBG_ADDR) //   ,

प्राप्त करने और संचार करने वाली मशीनों की अवस्थाओं को एक चर में संयोजित किया जाता है क्योंकि काम को आधे डुप्लेक्स मोड में किया जाएगा। अब आप खुद को एक बाधा हैंडलर के साथ ऑटोमेटा लिख सकते हैं।

UART के हैंडलर

void USART6_IRQHandler(void)
{
  if (((USART6->ISR & USART_ISR_RXNE) != 0U)
      && ((USART6->CR1 & USART_CR1_RXNEIE) != 0U))
  {
    rxCb(USART6->RDR);
    return;
  }

  if (((USART6->ISR & USART_ISR_TXE) != 0U)
      && ((USART6->CR1 & USART_CR1_TXEIE) != 0U))
  {
    txCb();
    return;
  }
}

void rxCb(uint8_t byte)
{
  dbg_t* dbg = dbgG; // debug vars pointer
  
  if (dbg->tx) // use half duplex mode
    return;
  
  switch(dbg->rx_state)
  {
  default:
  case rxWaitS:
    if (byte==0xAA)
      dbg->rx_state = rxWaitC;
    break;
  case rxWaitC:
    if (byte == 0xFF)
      dbg->rx_state = rxReceive;
    else
      dbg->rx_state = rxWaitS;
    dbg->pos = 0;
    break;
  case rxReceive:
    if (byte == 0xAA)
      dbg->rx_state = rxEsc;
    else
      dbg->buf[dbg->pos++] = byte;
    break;
  case rxEsc:
    if (byte == 0xAA)
    {
      dbg->buf[dbg->pos++] = byte;
      dbg->rx_state  = rxReceive;
    }
    else if (byte == 0x00)
    {
      parseAnswer();
    }
    else
      dbg->rx_state = rxWaitS;
  }
}

void txCb()
{
  dbg_t* dbg = dbgG;
  switch (dbg->tx_state)
  {
  case txSendS:
    USART6->TDR = 0xAA;
    dbg->tx_state = txSendC;
    break;
  case txSendC:
    USART6->TDR = 0xFF;
    dbg->tx_state = txSendN;
    break;
  case txSendN:
    if (dbg->txCnt>=dbg->pos)
    {
      USART6->TDR = 0xAA;
      dbg->tx_state = txEnd;
      break;
    }
    if (dbg->buf[dbg->txCnt]==0xAA)
    {
      USART6->TDR = 0xAA;
      dbg->tx_state = txEsc;
      break;
    }
    USART6->TDR = dbg->buf[dbg->txCnt++];
    break;
  case txEsc:
    USART6->TDR = 0xAA;
    dbg->txCnt++;
    dbg->tx_state = txSendN;
    break;
  case txEnd:
    USART6->TDR = 0x00;
    dbg->rx_state = rxWaitS;
    dbg->tx = 0;
    CLEAR_BIT(USART6->CR1, USART_CR1_TXEIE);
    break;
  case txSendS2:
    USART6->TDR = 0xAA;
    dbg->tx_state = txBrk;
    break;
  case txBrk:
    USART6->TDR = 0xA5;
    dbg->rx_state = rxWaitS;
    dbg->tx = 0;
    CLEAR_BIT(USART6->CR1, USART_CR1_TXEIE);
    break;
  }
}

यहाँ सब कुछ बहुत सरल है। घटित हुई घटना के आधार पर, इंटरचेंज हैंडलर या तो एक रिसीविंग मशीन या ट्रांसमिशन मशीन कहलाता है। यह सत्यापित करने के लिए कि सब कुछ काम करता है, हम एक पैकेट हैंडलर लिखते हैं जो एक बाइट के साथ प्रतिक्रिया करता है:

void parseAnswer()
{
  dbg_t* dbg = dbgG;
  dbg->pos = 1;
  dbg->buf[0] = 0x33;
  dbg->txCnt = 0;
  dbg->tx = 1;
  dbg->tx_state = txSendS;
  SET_BIT(USART6->CR1, USART_CR1_TXEIE);
}

संकलन, सीना, चलाना। परिणाम स्क्रीन पर दिखाई देता है, इसने काम किया।

विनिमय विनिमय

अगला, आपको GDB सर्वर प्रोटोकॉल से कमांड एनालॉग लागू करने की आवश्यकता है:

मेमोरी रीडिंग
मेमोरी रिकॉर्ड
कार्यक्रम बंद करो
निरंतर निष्पादन
गिरी रजिस्टर पढ़ा
गिरी रजिस्टर प्रविष्टि
ब्रेकपॉइंट सेट करना
विराम बिंदु हटाएँ

कमांड को डेटा के पहले बाइट के साथ एन्कोड किया जाएगा। टीमों के कोड उनके कार्यान्वयन के क्रम में संख्याएँ हैं:

2 - मेमोरी पढ़ें
3 - मेमोरी रिकॉर्ड
4 - बंद करो
5 - जारी रखा
6 - मामला पढ़ा
7 - ब्रेकपॉइंट स्थापित करें
8 - ब्रेकिंग क्लियरिंग
9 - कदम (लागू करने में विफल)
10 - रजिस्टर एंट्री (लागू नहीं)

पैरामीटर डेटा के निम्नलिखित बाइट्स में प्रेषित किए जाएंगे।

उत्तर में कमांड संख्या नहीं होगी, जैसा कि हम पहले से ही जानते हैं कि किस टीम ने भेजा है।

पढ़ने / लिखने के संचालन के दौरान बसफॉल्ट अपवादों को बढ़ाने से मॉड्यूल को रोकने के लिए, आपको इसे M3 या उच्चतर पर उपयोग करने पर मास्क करना होगा, या M0 के लिए हार्डफॉल्ट हैंडलर लिखना होगा।

सुरक्षित यादगार

int memcpySafe(uint8_t* to,uint8_t* from, int len)
{
    /* Cortex-M3, Cortex-M4, Cortex-M4F, Cortex-M7 are supported */
    static const uint32_t BFARVALID_MASK = (0x80 << SCB_CFSR_BUSFAULTSR_Pos);
    int cnt = 0;

    /* Clear BFARVALID flag by writing 1 to it */
    SCB->CFSR |= BFARVALID_MASK;

    /* Ignore BusFault by enabling BFHFNMIGN and disabling interrupts */
    uint32_t mask = __get_FAULTMASK();
    __disable_fault_irq();
    SCB->CCR |= SCB_CCR_BFHFNMIGN_Msk;

    while ((cnt<len))
    {
      *(to++) = *(from++);
      cnt++;
    }

    /* Reenable BusFault by clearing  BFHFNMIGN */
    SCB->CCR &= ~SCB_CCR_BFHFNMIGN_Msk;
    __set_FAULTMASK(mask);

    return cnt;
}

ब्रेकपॉइंट सेटिंग पहले निष्क्रिय रजिस्टर FP_COMP की खोज करके कार्यान्वित की जाती है।

कोड स्थापित ब्रेकप्वाइंट

	
  dbg->pos = 0; //  -    0
    addr = ((*(uint32_t*)(&dbg->buf[1])))|1; //    FP_COMP
    for (tmp = 0;tmp<8;tmp++) //      breakpoint 
      if (FP->FP_COMP[tmp] == addr)
        break;
    
    if (tmp!=8) //  , 
      break;
    
    for (tmp=0;tmp<NUMOFBKPTS;tmp++) //   
      if (FP->FP_COMP[tmp]==0) // ?
      {
        FP->FP_COMP[tmp] = addr; // 
        break; //  
      }
    break;

सेट ब्रेकपॉइंट की खोज करके सफाई की जाती है। वर्तमान पीसी पर निष्पादन सेट विराम बिंदु को रोकना। UART के बीच से बाहर निकलने पर, कर्नेल तुरंत DebugMon_Handler में प्रवेश करता है।

डीबगमैन हैंडलर अपने आप में बहुत सरल है:

1. निष्पादन को रोकने के लिए ध्वज सेट किया गया है।
2. सभी सेट ब्रेकप्वाइंट को मंजूरी दे दी जाती है।
3. uart में कमांड को जवाब भेजने के पूरा होने का इंतजार करना (अगर उसके पास जाने का समय नहीं था)
4. इंटरप्ट अनुक्रम भेजना शुरू होता है
5. लूप में, प्रेषित और प्राप्त मशीनों के हैंडलर्स को स्टॉप फ्लैग को कम करने तक कहा जाता है।

डिबगमन हैंडलर कोड

void DebugMon_Handler(void)
{
  dbgG->StopProgramm = 1; //   
  
  for (int i=0;i<NUMOFBKPTS;i++) //  breakpoint
    FP->FP_COMP[i] = 0;
  
  while (USART6->CR1 & USART_CR1_TXEIE) //    
    if ((USART6->ISR & USART_ISR_TXE) != 0U)
      txCb();

  
  dbgG->tx_state = txSendS2; //   Interrupt 
  dbgG->tx = 1;
  SET_BIT(USART6->CR1, USART_CR1_TXEIE);

  while (dbgG->StopProgramm) //       
  {
  	//   UART  
    if (((USART6->ISR & USART_ISR_RXNE) != 0U)
        && ((USART6->CR1 & USART_CR1_RXNEIE) != 0U))
      rxCb(USART6->RDR);

    if (((USART6->ISR & USART_ISR_TXE) != 0U)
        && ((USART6->CR1 & USART_CR1_TXEIE) != 0U))
      txCb(); 
  }
}

जब कार्य समस्याग्रस्त हो तो C-Syshny से कर्नेल रजिस्टर पढ़ें, इसलिए मैंने ASM पर कोड में से कुछ को फिर से लिखा। इसका परिणाम यह है कि न तो डीबगमन_हैंडलर, न ही यूएआरटी बाधा हैंडलर, न ही मशीनें स्टैक का उपयोग करती हैं। इसने कर्नेल रजिस्टर मानों की परिभाषा को सरल बनाया।

Gdb सर्वर

डीबगर का माइक्रोकंट्रोलर हिस्सा काम करता है, अब आइडी और हमारे मॉड्यूल के बीच लिंक लिखें।

स्क्रैच से, डिबग सर्वर लिखने का कोई मतलब नहीं है, इसलिए चलो एक आधार के रूप में एक तैयार किए गए को लें। चूंकि मुझे .net पर विकासशील कार्यक्रमों में सबसे अधिक अनुभव है, इसलिए मैंने इस परियोजना को एक आधार के रूप में लिया और इसे अन्य आवश्यकताओं के लिए फिर से लिखा। ओपनओसीडी में नए इंटरफ़ेस के लिए समर्थन जोड़ना अधिक सही होगा, लेकिन इसमें अधिक समय लगेगा।

स्टार्टअप पर, प्रोग्राम पूछता है कि किस COM पोर्ट के साथ काम करना है, फिर TCP पोर्ट 3333 पर सुनना शुरू कर देता है और GDB क्लाइंट से कनेक्ट होने का इंतजार करता है।

सभी GDB प्रोटोकॉल कमांड एक बाइनरी प्रोटोकॉल में अनुवादित हैं।

परिणामस्वरूप, एक व्यावहारिक UART डिबगिंग कार्यान्वयन जारी किया गया था।

अंतिम परिणाम

निष्कर्ष

यह पता चला कि नियंत्रक को डीबग करना स्वयं सुपर जटिल नहीं है।
सैद्धांतिक रूप से, इस मॉड्यूल को एक अलग मेमोरी सेक्शन में रखकर, इसका उपयोग कंट्रोलर को फ्लैश करने के लिए भी किया जा सकता है।

स्रोत फ़ाइलों को GDB सर्वर के

माइक्रोकंट्रोलर भाग के सामान्य अध्ययन के लिए GitHub पर पोस्ट किया गया था

UART पार्ट 2 द्वारा ARM कॉर्टेक्स-एम माइक्रोकंट्रोलर्स को डीबग करना

निम्न स्तर का हिस्सा

Gdb सर्वर

निष्कर्ष

More articles: