Tránh các biến toàn cục khi sử dụng ngắt trong các hệ thống nhúng

Có cách nào tốt để thực hiện giao tiếp giữa ISR và phần còn lại của chương trình cho một hệ thống nhúng để tránh các biến toàn cục không?

Dường như mô hình chung là có một biến toàn cục được chia sẻ giữa ISR và phần còn lại của chương trình và được sử dụng làm cờ, nhưng việc sử dụng các biến toàn cục này đi ngược lại với tôi. Tôi đã bao gồm một ví dụ đơn giản sử dụng ISR kiểu avr-libc:

volatile uint8_t flag;

int main() {
    ...

    if (flag == 1) {
        ...
    }
    ...
}

ISR(...) {
    ...
    flag = 1;
    ...
}

Tôi không thể nhìn thấy xung quanh những gì thực chất là một vấn đề phạm vi; bất kỳ biến nào có thể truy cập được bởi cả ISR và phần còn lại của chương trình phải là toàn cầu, chắc chắn? Mặc dù vậy, tôi thường thấy mọi người nói những điều dọc theo "các biến toàn cầu là một cách để thực hiện giao tiếp giữa các ISR và phần còn lại của chương trình" (nhấn mạnh của tôi), dường như ngụ ý rằng có các phương pháp khác; Nếu có các phương pháp khác, chúng là gì?

Có một cách tiêu chuẩn thực tế để làm điều này (giả sử lập trình C):

• Ngắt / ISR ở mức độ thấp và do đó chỉ nên được thực hiện bên trong trình điều khiển liên quan đến phần cứng tạo ra ngắt. Họ không nên được đặt ở bất cứ nơi nào khác ngoài tài xế đó.
• Tất cả các giao tiếp với ISR ​​chỉ được thực hiện bởi người lái xe và người lái xe. Nếu các phần khác của chương trình cần truy cập vào thông tin đó, nó phải yêu cầu nó từ trình điều khiển thông qua các hàm setter / getter hoặc tương tự.
• Bạn không nên khai báo các biến "toàn cầu". Biến phạm vi tập tin ý nghĩa toàn cầu với liên kết bên ngoài. Đó là: các biến có thể được gọi bằng externtừ khóa hoặc đơn giản là do nhầm lẫn.
• Thay vào đó, để buộc đóng gói riêng bên trong trình điều khiển, tất cả các biến như vậy được chia sẻ giữa trình điều khiển và ISR sẽ được khai báo static. Một biến như vậy không phải là toàn cục mà chỉ giới hạn ở tệp được khai báo.
• Để ngăn chặn các vấn đề tối ưu hóa trình biên dịch, các biến đó cũng nên được khai báo là volatile. Lưu ý: điều này không cung cấp quyền truy cập nguyên tử hoặc giải quyết quyền truy cập lại!
• Một số cách của cơ chế nhập lại thường là cần thiết trong trình điều khiển, trong trường hợp ISR ghi vào biến. Ví dụ: vô hiệu hóa ngắt, mặt nạ ngắt toàn cầu, semaphore / mutex hoặc đọc nguyên tử được bảo đảm.

việc sử dụng các biến toàn cầu này đi ngược lại với tôi

Đây thực sự là vấn đề. Hãy vượt qua nó.

Bây giờ trước khi những kẻ đầu gối lập tức phát cuồng về việc điều này là ô uế, hãy để tôi đủ điều kiện một chút. Chắc chắn có nguy hiểm trong việc sử dụng các biến toàn cầu để vượt quá. Nhưng, chúng cũng có thể tăng hiệu quả, đôi khi là vấn đề trong các hệ thống hạn chế tài nguyên nhỏ.

Điều quan trọng là suy nghĩ về thời điểm bạn có thể sử dụng chúng một cách hợp lý và không có khả năng khiến bản thân gặp rắc rối, thay vì một lỗi chỉ chờ xảy ra. Luôn có sự đánh đổi. Mặc dù nói chung tránh các biến toàn cục để giao tiếp giữa mã ngắt và tiền cảnh là một hướng dẫn có thể thực hiện được, việc đưa nó, giống như hầu hết các hướng dẫn khác, đến cực đoan của tôn giáo là phản tác dụng.

Một số ví dụ đôi khi tôi sử dụng các biến toàn cục để truyền thông tin giữa mã ngắt và tiền cảnh là:

1. Đồng hồ đánh dấu quầy được quản lý bởi hệ thống ngắt đồng hồ. Tôi thường có một ngắt đồng hồ định kỳ chạy cứ sau 1 ms. Điều đó thường hữu ích cho thời gian khác nhau trong hệ thống. Một cách để đưa thông tin này ra khỏi thói quen gián đoạn đến nơi mà phần còn lại của hệ thống có thể sử dụng nó là giữ một bộ đếm đồng hồ toàn cầu. Thói quen ngắt làm tăng bộ đếm mỗi tích tắc. Mã tiền cảnh có thể đọc quầy bất cứ lúc nào. Thường thì tôi làm điều này trong 10 ms, 100 ms và thậm chí là 1 giây.

   Tôi chắc chắn rằng các dấu 1 ms, 10 ms và 100 ms có kích thước từ có thể được đọc trong một hoạt động nguyên tử duy nhất. Nếu sử dụng ngôn ngữ cấp cao, hãy đảm bảo thông báo cho trình biên dịch rằng các biến này có thể thay đổi không đồng bộ. Trong C, bạn khai báo chúng extern volility , ví dụ. Tất nhiên đây là thứ đi vào một tệp bao gồm đóng hộp, vì vậy bạn không cần phải nhớ nó cho mọi dự án.

   Đôi khi, tôi làm cho bộ đếm 1 giây của bộ đếm thời gian đã trôi qua, vì vậy hãy làm cho nó rộng 32 bit. Điều đó không thể được đọc trong một hoạt động nguyên tử duy nhất trên nhiều vi mô nhỏ mà tôi sử dụng, do đó không được thực hiện trên toàn cầu. Thay vào đó, một thói quen được cung cấp để đọc giá trị nhiều từ, xử lý các cập nhật có thể có giữa các lần đọc và trả về kết quả.

   Tất nhiên là có thể có các thói quen để có được các bộ đếm nhỏ hơn 1 ms, 10 ms, v.v. Tuy nhiên, điều đó thực sự rất ít đối với bạn, thêm rất nhiều hướng dẫn thay cho việc đọc một từ duy nhất và sử dụng hết một vị trí ngăn xếp cuộc gọi khác.

   Nhược điểm là gì? Tôi cho rằng ai đó có thể tạo ra một lỗi đánh máy vô tình ghi vào một trong các quầy, sau đó có thể làm rối loạn thời gian khác trong hệ thống. Viết thư cho một bộ đếm có chủ ý sẽ không có ý nghĩa, vì vậy loại lỗi này sẽ cần phải là một thứ gì đó không chủ ý như một lỗi đánh máy. Có vẻ rất khó xảy ra. Tôi không nhớ rằng đã từng xảy ra trong hơn 100 dự án vi điều khiển nhỏ.

2. Các giá trị A / D được lọc và điều chỉnh cuối cùng. Một điều phổ biến cần làm là có một bài đọc xử lý thường xuyên ngắt từ A / D. Tôi thường đọc các giá trị tương tự nhanh hơn mức cần thiết, sau đó áp dụng một bộ lọc thông thấp. Cũng thường có tỷ lệ và bù được áp dụng.

   Ví dụ, A / D có thể đang đọc đầu ra 0 đến 3 V của bộ chia điện áp để đo nguồn cung cấp 24 V. Nhiều bài đọc được chạy qua một số bộ lọc, sau đó thu nhỏ lại để giá trị cuối cùng tính bằng millivolts. Nếu nguồn cung ở mức 24,015 V, thì giá trị cuối cùng là 24015.

   Phần còn lại của hệ thống chỉ nhìn thấy một giá trị được cập nhật trực tiếp cho biết điện áp cung cấp. Nó không biết và cũng không cần quan tâm khi chính xác nó được cập nhật, đặc biệt là vì nó được cập nhật thường xuyên hơn nhiều so với thời gian giải quyết bộ lọc thông thấp.

   Một lần nữa, một thói quen giao diện có thể được sử dụng, nhưng bạn nhận được rất ít lợi ích từ đó. Chỉ cần sử dụng biến toàn cục bất cứ khi nào bạn cần điện áp nguồn sẽ đơn giản hơn nhiều. Hãy nhớ rằng sự đơn giản không chỉ dành cho máy, nhưng đơn giản hơn cũng có nghĩa là ít có khả năng xảy ra lỗi của con người.

Bất kỳ gián đoạn cụ thể sẽ là một nguồn tài nguyên toàn cầu. Tuy nhiên, đôi khi, có thể hữu ích khi có một vài ngắt chia sẻ cùng một mã. Ví dụ, một hệ thống có thể có một số UART, tất cả đều nên sử dụng logic gửi / nhận tương tự.

Một cách tiếp cận tốt để xử lý đó là đặt những thứ được sử dụng bởi trình xử lý ngắt, hoặc con trỏ tới chúng, trong một đối tượng cấu trúc, và sau đó có các trình xử lý ngắt phần cứng thực tế giống như:

void UART1_handler(void) { uart_handler(&uart1_info); }
void UART2_handler(void) { uart_handler(&uart2_info); }
void UART3_handler(void) { uart_handler(&uart3_info); }

Các đối tượng uart1_info, uart2_infov.v. sẽ là các biến toàn cục, nhưng chúng sẽ là duy nhất biến toàn cục được sử dụng bởi các trình xử lý ngắt. Mọi thứ khác mà những người xử lý sẽ chạm vào sẽ được xử lý trong những người đó.

Lưu ý rằng bất cứ điều gì được truy cập bởi cả trình xử lý ngắt và mã dòng chính đều phải đủ điều kiện volatile. Có thể đơn giản nhất là chỉ cần khai báo là volatiletất cả mọi thứ sẽ được sử dụng bởi trình xử lý ngắt, nhưng nếu hiệu suất là quan trọng, người ta có thể muốn viết mã sao chép thông tin vào các giá trị tạm thời, vận hành theo chúng, sau đó viết lại chúng. Ví dụ: thay vì viết:

if (foo->timer)
  foo->timer--;

viết:

uint32_t was_timer;
was_timer = foo->timer;
if (was_timer)
{
  was_timer--;
  foo->timer = was_timer;
}

Cách tiếp cận trước đây có thể dễ đọc và dễ hiểu hơn, nhưng sẽ kém hiệu quả hơn phương pháp sau. Cho dù đó là một mối quan tâm sẽ phụ thuộc vào ứng dụng.

Đây là ba ý tưởng:

Khai báo biến cờ là tĩnh để giới hạn phạm vi trong một tệp duy nhất.

Đặt biến cờ riêng tư và sử dụng các hàm getter và setter để truy cập giá trị cờ.

Sử dụng một đối tượng báo hiệu như semaphore thay vì biến cờ. ISR sẽ thiết lập / đăng semaphore.

Một ngắt (tức là vectơ chỉ đến trình xử lý của bạn) là một tài nguyên toàn cầu. Vì vậy, ngay cả khi bạn sử dụng một số biến trên ngăn xếp hoặc trên heap:

volatile bool *flag;  // must be initialized before the interrupt is enabled

ISR(...) {
    *flag = true;
}

hoặc mã hướng đối tượng có chức năng 'ảo':

HandlerObject *obj;

ISR(...) {
    obj->handler_function(obj);
}

Bước đầu tiên phải liên quan đến một biến toàn cầu thực tế (hoặc ít nhất là tĩnh) để tiếp cận dữ liệu khác đó.

Tất cả các cơ chế này thêm một sự gián tiếp, vì vậy điều này thường không được thực hiện nếu bạn muốn nén chu trình cuối cùng ra khỏi trình xử lý ngắt.

Hiện tại tôi đang mã hóa cho Cortex M0 / M4 và cách tiếp cận chúng tôi đang sử dụng trong C ++ (không có thẻ C ++, vì vậy câu trả lời này có thể lạc đề) như sau:

Chúng tôi sử dụng một lớp CInterruptVectorTablecó chứa tất cả các thói quen dịch vụ ngắt được lưu trữ trong vectơ ngắt thực tế của bộ điều khiển:

#pragma location = ".intvec"
extern "C" const intvec_elem __vector_table[] =
{
  { .__ptr = __sfe( "CSTACK" ) },           // 0x00
  __iar_program_start,                      // 0x04

  CInterruptVectorTable::IsrNMI,            // 0x08
  CInterruptVectorTable::IsrHardFault,      // 0x0C
  //[...]
}

Lớp CInterruptVectorTablethực hiện một sự trừu tượng hóa các vectơ ngắt, vì vậy bạn có thể liên kết các hàm khác nhau với các vectơ ngắt trong thời gian chạy.

Giao diện của lớp đó trông như thế này:

class CInterruptVectorTable  {
public :
    typedef void (*IsrCallbackfunction_t)(void);                      

    enum InterruptId_t {
        INTERRUPT_ID_NMI,
        INTERRUPT_ID_HARDFAULT,
        //[...]
    };

    typedef struct InterruptVectorTable_t {
        IsrCallbackfunction_t IsrNMI;
        IsrCallbackfunction_t IsrHardFault;
        //[...]
    } InterruptVectorTable_t;

    typedef InterruptVectorTable_t* PinterruptVectorTable_t;


public :
    CInterruptVectorTable(void);
    void SetIsrCallbackfunction(const InterruptId_t& interruptID, const IsrCallbackfunction_t& isrCallbackFunction);

private :

    static void IsrStandard(void);

public :
    static void IsrNMI(void);
    static void IsrHardFault(void);
    //[...]

private :

    volatile InterruptVectorTable_t virtualVectorTable;
    static volatile CInterruptVectorTable* pThis;
};

Bạn cần tạo các hàm được lưu trữ trong bảng vectơ staticvì bộ điều khiển không thể cung cấp một con thistrỏ vì bảng vectơ không phải là một đối tượng. Vì vậy, để giải quyết vấn đề đó, chúng ta có con pThistrỏ tĩnh bên trong CInterruptVectorTable. Khi nhập một trong các hàm ngắt tĩnh, nó có thể truy cập vào pThis-pulum để có quyền truy cập vào các thành viên của một đối tượng CInterruptVectorTable.

Bây giờ trong chương trình, bạn có thể sử dụng SetIsrCallbackfunctionđể cung cấp một con trỏ hàm cho một statichàm được gọi khi xảy ra gián đoạn. Các con trỏ được lưu trữ trongInterruptVectorTable_t virtualVectorTable .

Và việc thực hiện một chức năng ngắt trông như thế này:

void CInterruptVectorTable::IsrNMI(void) {
    pThis->virtualVectorTable.IsrNMI(); 
}

Vì vậy, nó sẽ gọi một staticphương thức của một lớp khác (có thể là private), sau đó có thể chứa một con static thistrỏ khác để có quyền truy cập vào các biến thành viên của đối tượng đó (chỉ một).

Tôi đoán bạn có thể xây dựng và giao diện thích IInterruptHandlervà lưu trữ các con trỏ tới các đối tượng, vì vậy bạn không cần con trỏ static thistrong tất cả các lớp đó. (có lẽ chúng tôi thử điều đó trong lần lặp lại tiếp theo của kiến ​​trúc của chúng tôi)

Cách tiếp cận khác hoạt động tốt đối với chúng tôi, vì các đối tượng duy nhất được phép thực hiện trình xử lý ngắt là những đối tượng bên trong lớp trừu tượng phần cứng và chúng tôi thường chỉ có một đối tượng cho mỗi khối phần cứng, do đó, nó hoạt động tốt với các con static thistrỏ. Và lớp trừu tượng phần cứng cung cấp một sự trừu tượng hóa khác cho các ngắt, được gọi ICallbacklà lớp sau đó được triển khai trong lớp thiết bị phía trên phần cứng.

Bạn có truy cập dữ liệu toàn cầu? Chắc chắn bạn làm như vậy, nhưng bạn có thể làm cho hầu hết các dữ liệu toàn cầu cần thiết ở chế độ riêng tư như các con thistrỏ và các hàm ngắt.

Nó không chống đạn, và nó có thêm chi phí. Bạn sẽ đấu tranh để thực hiện ngăn xếp IO-Link bằng cách sử dụng phương pháp này. Nhưng nếu bạn không quá chặt chẽ với thời gian, điều này hoạt động khá tốt để có được sự trừu tượng hóa linh hoạt của các ngắt và giao tiếp trong các mô-đun mà không sử dụng các biến toàn cục có thể truy cập từ mọi nơi.