Die ganze Wahrheit über RTOS. Artikel 28. Software-Timer

Die Idee der Software-Timer wurde in einem früheren Artikel vorgestellt . Es handelt sich um Kernelobjekte, die Aufgaben eine einfache Möglichkeit bieten, Ereignisse rechtzeitig auszulösen, oder meistens eine Möglichkeit, Aktionen regelmäßig auszuführen. Alle Details der zeitbezogenen Funktionalität (Genauigkeit, Interrupt-Behandlung usw.) in Nucleus SE wurden in einem früheren Artikel erörtert.

Timer verwenden

Programm-Timer können so konfiguriert werden, dass sie einmal ausgelöst werden, dh sie starten und nach einer bestimmten Zeit einfach den Zyklus beenden. Oder der Timer kann so konfiguriert werden, dass er neu startet: Nach Abschluss der Zählung wird der Timer automatisch neu gestartet. Die Betriebszeit nach einem Neustart kann von der anfänglichen Betriebszeit abweichen. Zusätzlich kann der Timer optional so konfiguriert werden, dass er eine spezielle Beendigungsfunktion ausführt, die ausgeführt wird, wenn (oder jedes Mal) der Timer den Arbeitszyklus abschließt.

Timer-Einstellungen

Anzahl der Timer

Wie bei den meisten Aspekten von Nucleus SE werden die Timer-Einstellungen von den Anweisungen #define in nuse_config.h gesteuert . Der Hauptparameter ist NUSE_TIMER_NUMBER , der die in der Anwendung konfigurierten Timer definiert. Standardmäßig ist dieser Wert Null (dh Timer werden in der Anwendung nicht verwendet) und kann Werte bis zu 16 annehmen. Ein falscher Wert führt zu einem Kompilierungsfehler, der durch Einchecken der Datei nuse_config_check.h (diese Datei ist in nuse_config.c enthalten und kompiliert) generiert wird zusammen mit ihm), wodurch die Direktive #error ausgelöst wird .

Die Auswahl eines Werts ungleich Null ist der Hauptaktivator des Timers. Dieser Parameter wird beim Definieren von Datenstrukturen verwendet und ihre Größe hängt von ihrem Wert ab. Darüber hinaus aktiviert ein Wert ungleich Null die API-Einstellungen.

Aktivierung der Abschlussfunktion

In Nucleus SE habe ich versucht, die Möglichkeit zu finden, die Funktionalität optional zu machen, wodurch Speicherplatz gespart wird. Ein gutes Beispiel ist die Unterstützung von Timer-Abschlussfunktionen. Zusätzlich zu der Tatsache, dass diese Funktion für jeden Timer optional ist, kann der Mechanismus für die gesamte Anwendung mithilfe des Parameters NUSE_TIMER_EXPIRATION_ROUTINE_SUPPORT in nuse_config.h aktiviert werden (oder nicht). Wenn Sie diesen Parameter auf FALSE setzen , wird die Definition von zwei Datenstrukturen im ROM blockiert, die in diesem Artikel ausführlich beschrieben werden.

API-Aktivierung

Jede API-Funktion (Dienstprogrammaufruf) in Nucleus SE verfügt über die Direktive #define enable in nuse_config.h. Für Timer umfassen diese Symbole:
NUSE_TIMER_CONTROL
NUSE_TIMER_GET_REMAINING
NUSE_TIMER_RESET
NUSE_TIMER_INFORMATION
NUSE_TIMER_COUNT

Standardmäßig sind alle Aktivatoren auf FALSE gesetzt , sodass alle Serviceaufrufe deaktiviert sind und die Aufnahme von Code, der sie implementiert, blockiert wird. Um Timer in der Anwendung einzurichten, müssen Sie die erforderlichen API-Serviceaufrufe auswählen und auf TRUE setzen .

Das Folgende ist ein Codeausschnitt aus der Standarddatei nuse_config.h .

#define NUSE_TIMER_NUMBER 0/*      0-16 */ /*    */ #define NUSE_TIMER_CONTROL FALSE #define NUSE_TIMER_GET_REMAINING FALSE #define NUSE_TIMER_RESET FALSE #define NUSE_TIMER_INFORMATION FALSE #define NUSE_TIMER_COUNT FALSE 

Wenn die timerbezogene API-Funktion aktiviert ist und keine konfigurierten Timer in der Anwendung vorhanden sind (mit Ausnahme der Funktion NUSE_Timer_Count () , die immer aktiviert ist), tritt ein Kompilierungsfehler auf. Wenn Ihr Code einen API-Aufruf verwendet, der nicht aktiviert wurde, tritt ein Layoutfehler auf, da der Implementierungscode nicht in der Anwendung enthalten war.

Timer-Serviceanrufe

Nucleus RTOS unterstützt acht timerbezogene Dienstprogrammaufrufe, die die folgenden Funktionen bieten:

• Management-Timer (Start / Stopp). Nucleus SE ist in der Funktion NUSE_Timer_Control () implementiert.
• Abrufen der verbleibenden Timerzeit. In Nucleus SE, implementiert in NUSE_Timer_Get_Remaining () .
• Wiederherstellen des ursprünglichen Zustands des Timers (Zurücksetzen). Nucleus SE in NUSE_Timer_Reset () implementiert.
• Bereitstellung von Informationen zu einem bestimmten Timer. Nucleus SE ist in NUSE_Timer_Information () implementiert.
• Gibt die Anzahl der konfigurierten (derzeit) Timer in der Anwendung zurück. Nucleus SE ist in NUSE_Timer_Count () implementiert.
• Hinzufügen eines neuen Timers zur Anwendung (Erstellung). Nucleus SE ist nicht implementiert.
• Entfernen eines Timers aus der Anwendung. Nucleus SE ist nicht implementiert.
• Rückgabe von Zeigern auf alle Timer in der Anwendung. Nucleus SE ist nicht implementiert.

Die Implementierung jedes Serviceabrufs wird nachstehend ausführlich erläutert.

Timer-Dienste

Die grundlegenden Operationen, die mit einem Timer ausgeführt werden können, sind die Steuerung (Start und Stopp) und das Lesen des aktuellen Werts. Nucleus RTOS und Nucleus SE bieten zwei grundlegende API-Dienstprogrammaufrufe für diese Vorgänge.

Timer-Steuerung

Durch einen Dienstprogrammaufruf an die Nucleus RTOS-API zur Steuerung des Timers können Sie den Timer aktivieren und deaktivieren (Start und Stopp). Nucleus SE bietet ähnliche Funktionen.

Timer Control Challenge in Nucleus RTOS
Prototyp eines Serviceabrufs:

STATUS NU_Control_Timer (NU_TIMER * Timer, OPTION aktivieren);

Parameter:
Timer - Zeiger auf den vom Benutzer bereitgestellten Timer-Steuerblock;
enable ist die erforderliche Funktion und kann die Werte NU_ENABLE_TIMER oder NU_DISABLE_TIMER annehmen .

Rückgabewert:
NU_SUCCESS - Der Anruf wurde erfolgreich abgeschlossen.
NU_INAVLID_TIMER - ungültiger Timerzeiger ;
NU_INAVLID_ENABLE - ungültige Funktion.

Timer Control Challenge in Nucleus SE
Dieser API-Aufruf unterstützt die volle Funktionalität der Nucleus RTOS-API.

Prototyp eines Serviceabrufs:
STATUS NUSE_Timer_Control (NUSE_TIMER-Timer, OPTION-Aktivierung);

Parameter:
Timer - Index (ID) des verwendeten Timers;
enable ist die erforderliche Funktion und kann die Werte NUSE_ENABLE_TIMER oder NUSE_DISABLE_TIMER annehmen .

Rückgabewert:
NUSE_SUCCESS - Der Anruf wurde erfolgreich abgeschlossen.
NUSE_INCALID_TIMER - ungültiger Timer-Index;
NUSE_INVALID_ENABLE ist eine ungültige Funktion.

Implementieren Sie das Timer-Management in Nucleus SE
Der API-Funktionscode NUSE_Timer_Control () (nach Überprüfung der Parameter) ist recht einfach:

 NUSE_CS_Enter(); if (enable == NUSE_ENABLE_TIMER) { NUSE_Timer_Status[timer] = TRUE; if (NUSE_Timer_Expirations_Counter[timer] == 0) { NUSE_Timer_Value[timer] = NUSE_Timer_Initial_Time[timer]; } else { NUSE_Timer_Value[timer] = NUSE_Timer_Reschedule_Time[timer]; } } else /* enable == NUSE_DISABLE_TIMER */ { NUSE_Timer_Status[timer] = FALSE; } NUSE_CS_Exit(); 

Wenn die Funktion NUSE_DISABLE_TIMER angegeben wurde, wird der Timer-Status (Parameter NUSE_Timer_Status [] ) auf FALSE gesetzt , wodurch der Timer vom Interrupt-Handler ignoriert wird.

Wenn Sie die Funktion NUSE_ENABLE_TIMER auswählen , wird der Timer-Zähler ( NUSE_Timer_Value [] ) auf NUSE_Timer_initial_Time [] gesetzt , sofern der Timer seit dem letzten Zurücksetzen nie angehalten hat. Andernfalls wird ihm der Wert NUSE_Timer_Reschedule_Time [] zugewiesen. Dann wird der Timer-Status (Parameter NUSE_Timer_Status [] ) auf TRUE gesetzt , wodurch der Timer vom Interrupt-Handler verarbeitet wird.

Timer lesen

Um die verbleibende Zeitgeberzeit abzurufen, gibt der Nucleus RTOS API-Serviceaufruf die Anzahl der Kennzahlen zurück, bis er abläuft. Nucleus SE bietet ähnliche Funktionen.

Rufen Sie an, um die verbleibende Zeit in Nucleus RTOS abzurufen

Prototyp eines Serviceabrufs:
STATUS NU_Get_Remaining_Time (NU_TIMER * Timer, UNSIGNED * verbleibende_Zeit);

Parameter:
Timer - Zeiger auf den vom Benutzer bereitgestellten Timer-Steuerblock;
verbleibende Zeit - ein Zeiger auf die Speicherung des verbleibenden Zeitwerts, der eine Variable vom Typ UNSIGNED ist .

Rückgabewert
NU_SUCCESS - Der Anruf wurde erfolgreich abgeschlossen.
NU_INVALID_TIMER - ungültiger Timerzeiger .

Rufen Sie an, um die verbleibende Zeit in Nucleus SE zu erhalten
Dieser API-Aufruf unterstützt die volle Funktionalität der Nucleus RTOS-API.

Prototyp eines Serviceabrufs:
STATUS NUSE_Timer_Get_Remaining (NUSE_TIMER-Timer, U16 * verbleibende_Zeit);

Parameter:
Timer - Index (ID) des verwendeten Timers;
verbleibende Zeit - ein Zeiger auf die Speicherung des verbleibenden Zeitwerts, der eine Variable vom Typ U16 ist .

Rückgabewert:
NUSE_SUCCESS - Der Anruf wurde erfolgreich abgeschlossen.
NUSE_INVALID_TIMER - ungültiger Timer-Index;
NUSE_INVALID_POINTER - Nullzeiger auf die verbleibende Zeit ( NULL ).

Implementieren eines Timers Read in Nucleus SE
Die API-Funktionscodevariante NUSE_Timer_Get_Remaining () (nach Überprüfung der Parameter) ist trivial einfach. Der Wert NUSE_Timer_Value [] wird abgerufen und dann im kritischen Abschnitt zurückgegeben.

Auxiliary Timer Services

Nucleus RTOS verfügt über vier API-Aufrufe, die Zusatzfunktionen für Timer bereitstellen: Zurücksetzen eines Timers, Abrufen von Timerinformationen, Abrufen der Anzahl der Timer in einer Anwendung und Abrufen von Zeigern auf alle Timer in einer Anwendung. Die ersten drei Funktionen sind in Nucleus SE implementiert.

Timer zurückgesetzt

Dieser API-Aufruf setzt den Timer auf seinen ursprünglichen, nicht verwendeten Zustand zurück. Der Timer kann nach Beendigung dieses Anrufs aktiviert oder deaktiviert werden. Es kann nur verwendet werden, nachdem der Timer deaktiviert wurde (mit NUSE_Timer_Control () ). Wenn der Timer das nächste Mal aktiviert wird, wird er mit dem Parameter NUSE_Timer_Initial_Time [] initialisiert. Mit Nucleus RTOS können Sie einen neuen Anfangszustand bereitstellen und die Zeit neu planen sowie die Abschlussfunktion angeben, wenn der Timer zurückgesetzt wird. In Nucleus SE werden diese Werte während des Setups festgelegt und können nicht geändert werden, da sie im ROM gespeichert sind.

Aufruf zum Zurücksetzen eines Timers in Nucleus RTOS

Prototyp eines Serviceabrufs:
STATUS NU_Reset_Timer (NU_TIMER * Timer, VOID (* Ablaufdatum) (UNSIGNED), UNSIGNED initial_time, UNSIGNED reschedule_time, OPTION enable);

Parameter:
Timer - ein Zeiger auf einen zurücksetzbaren Timer;
expiration_routine - gibt die Funktion an, die ausgeführt wird, wenn die Schleife endet.
initial_time - Die anfängliche Anzahl der Timer-Ticks bis zum Ende der Schleife.
reschedule_time - Die Anzahl der Timer- Ticks bis zum Abschluss des zweiten und der folgenden Zyklen.
enable - Der erforderliche Status des Timers nach einem Reset kann die Werte NU_ENABLE_TIMER oder NU_DISABLE_TIMER annehmen .

Rückgabewert:
NU_SUCCESS - Der Anruf wurde erfolgreich abgeschlossen.
NU_INVALID_TIMER - ungültiger Zeiger auf die Timer-Steuereinheit;
NU_INVALID_FUNCTION - Nullzeiger auf die Abschlussfunktion ( NULL );
NU_INVALID_ENABLE - Der angegebene Status ist falsch.
NU_NOT_DISABLED - Der Timer läuft bereits (er sollte vor dem Aufruf dieser Funktion gestoppt werden).

Rufen Sie an, um den Timer in Nucleus SE zurückzusetzen
Dieser API-Serviceaufruf unterstützt eine vereinfachte Version der Kernfunktionalität der Nucleus RTOS-API.

Prototyp eines Serviceabrufs:
STATUS NUSE_Timer_Reset (NUSE_TIMER-Timer, OPTION-Aktivierung);

Parameter:
Timer - Index (ID) des Reset-Timers;
enable - Der erforderliche Status nach dem Zurücksetzen kann die Werte NUSE_ENABLE_TIMER oder NUSE_DISABLE_TIMER annehmen .

Rückgabewert:
NUSE_SUCCESS - Der Anruf wurde erfolgreich abgeschlossen.
NUSE_INVALID_TIMER - ungültiger Timer-Index;
NUSE_INVALID_ENABLE - Der angegebene Status ist falsch.
NUSE_NOT_DISABLED - Der Timer läuft bereits (er sollte vor dem Aufruf dieser Funktion gestoppt werden).

Implementieren eines Timer-Resets in Nucleus SE
Die Version des API-Funktionscodes NUSE_Timer_Reset () (nach Überprüfung der Parameter und des aktuellen Status) ist recht einfach:

 NUSE_CS_Enter(); NUSE_Init_Timer(timer); if (enable == NUSE_ENABLE_TIMER) { NUSE_Timer_Status[timer] = TRUE; } /*  enable == NUSE_DISABLE_TIMER    FALSE */ NUSE_CS_Exit(); 

Ein Aufruf von NUSE_Init_Timer () initialisiert den Zeitwert und löscht den Abschlusszähler. Danach wird bei Bedarf der Wert des erforderlichen Status überprüft und ob der Timer eingeschaltet ist.

Timer-Informationen

Mit diesem Serviceabruf können Sie eine Reihe von Timerinformationen abrufen. Die Implementierung von Nucleus SE unterscheidet sich von Nucleus RTOS darin, dass weniger Informationen zurückgegeben werden, da die Objektbenennung nicht unterstützt wird.

Rufen Sie Timer-Informationen in Nucleus RTOS an

Prototyp eines Serviceabrufs:
STATUS NU_Timer_Information (NU_TIMER * Timer, CHAR * Name, OPTION * aktivieren, UNSIGNED * Ablauf, UNSIGNED * ID, UNSIGNED * initial_time, UNSIGNED * reschedule_time);

Parameter:
Timer - ein Zeiger auf einen Timer, über den Informationen angefordert werden;
name - Zeiger auf den 8-stelligen Bereich für den Timernamen;
enable - Zeiger auf eine Variable, die den aktuellen Status des Timer-Aktivators annimmt : NU_ENABLE_TIMER oder NU_DISABLE_TIMER ;
Ablaufdatum - ein Zeiger auf eine Variable, die einen Zähler für die Anzahl der Abschlüsse des Zeitgeberzyklus seit seinem letzten Zurücksetzen verwendet;
id - Zeiger auf eine Variable, die den Wert des Parameters annimmt, der an die Endfunktion des Zeitgeberzyklus übergeben wird;
initial_time - ein Zeiger auf eine Variable, die einen Wert annimmt, in den der Timer nach einem Reset initialisiert wird;
reschedule_time - Ein Zeiger auf eine Variable, die einen Wert annimmt, in den der Timer nach Abschluss initialisiert wird.

Rückgabewert:
NU_SUCCESS - Der Anruf wurde erfolgreich abgeschlossen.
NU_INVALID_TIMER - ungültiger Timerzeiger .

Rufen Sie in Nucleus SE nach Timer-Informationen
Dieser API-Aufruf unterstützt die Kernfunktionalität der Nucleus RTOS-API.

Prototyp eines Serviceabrufs:
STATUS NUSE_Timer_Information (NUSE_TIMER-Timer, OPTION * aktivieren, U8 * Ablauf, U8 * ID, U16 * initial_time, U16 * reschedule_time);

Parameter:
Timer - Index des Timers, über den Informationen angefordert werden;
enable - ein Zeiger auf eine Variable, die den Wert TRUE oder FALSE annimmt, je nachdem, ob der Timer aktiviert ist oder nicht;
Ablaufzeiten - ein Zeiger auf eine Variable vom Typ U8 , die den Wert der Anzahl der Timer-Abschlüsse seit ihrem letzten Zurücksetzen annimmt;
id - Zeiger auf eine Variable vom Typ U8 , die den Wert des an die Timer-Abschlussfunktion übergebenen Parameters annimmt (gibt einen leeren Wert zurück, wenn die Abschlussfunktionen deaktiviert sind);
initial_time - ein Zeiger auf eine Variable vom Typ U16 , die einen Wert annimmt, mit dem der Timer nach einem Zurücksetzen initialisiert wird;
reschedule_time - Ein Zeiger auf eine Variable vom Typ U16 , der den Wert annimmt, mit dem der Timer nach Abschluss initialisiert wird.

Rückgabewert:
NUSE_SUCCESS - Der Anruf wurde erfolgreich abgeschlossen.
NUSE_INVALID_TIMER - ungültiger Timer-Index;
NUSE_INVALID_POINTER - Ein oder mehrere Zeigerparameter sind falsch.

Implementieren von Timer-Informationen in Nucleus SE
Die Implementierung dieses API-Aufrufs ist ziemlich einfach:

 NUSE_CS_Enter(); if (NUSE_Timer_Status[timer]) { *enable = NUSE_ENABLE_TIMER; } else { *enable = NUSE_DISABLE_TIMER; } *expirations = NUSE_Timer_Expirations_Counter[timer]; #if NUSE_TIMER_EXPIRATION_ROUTINE_SUPPORT *id = NUSE_Timer_Expiration_Routine_Parameter[timer]; #endif *initial_time = NUSE_Timer_Initial_Time[timer]; *reschedule_time = NUSE_Timer_Reschedule_Time[timer]; NUSE_CS_Exit(); 

Die Funktion gibt den Status des Timers zurück. Der Parameterwert der Beendigungsfunktion wird nur zurückgegeben, wenn deren Unterstützung in der Anwendung aktiviert wurde.

Abrufen der Anzahl der Timer

Dieser Dienstprogrammaufruf gibt die Anzahl der in der Anwendung konfigurierten Timer zurück. In Nucleus RTOS kann sich dieser Wert im Laufe der Zeit ändern, und der Rückgabewert zeigt die aktuelle Anzahl von Timern an. In Nucleus SE wird der Rückgabewert während der Montagephase festgelegt und kann nicht geändert werden.

Fordern Sie einen Timer-Zähler in Nucleus RTOS an

Prototyp eines Serviceabrufs:
UNSIGNED NU_Established_Timers (VOID);

Parameter: keine

Rückgabewert: Die Anzahl der im System erstellten Timer.

Aufruf des Timer-Zählers in Nucleus SE
Dieser API-Aufruf unterstützt die Kernfunktionalität der Nucleus RTOS-API.

Prototyp eines Serviceabrufs:
U8 NUSE_Timer_Count (nichtig);

Parameter: keine

Rückgabewert:
Die Anzahl der konfigurierten Timer in der Anwendung

Implementierung des Timer-Zählers

Die Implementierung dieses API-Aufrufs ist recht einfach: Der Wert des Symbols #define NUSE_TIMER_NUMBER wird zurückgegeben .

Datenstrukturen

Timer verwenden fünf oder sieben Datenstrukturen (im RAM oder ROM), die (wie andere Nucleus SE-Objekte) eine Reihe von Tabellen sind, deren Größe und Anzahl der Anzahl der konfigurierten Timer und ausgewählten Parameter entspricht.

Ich empfehle dringend, dass der Anwendungscode keinen direkten Zugriff auf diese Datenstrukturen verwendet, sondern über die bereitgestellten API-Funktionen auf sie verweist. Dies vermeidet Inkompatibilität mit zukünftigen Versionen von Nucleus SE und unerwünschte Nebenwirkungen und vereinfacht die Portierung von Anwendungen auf Nucleus RTOS. Das Folgende ist eine detaillierte Übersicht über Strukturen, um das Verständnis von Serviceabruf- und Debugging-Code zu vereinfachen.

RAM-Daten

Diese Daten haben folgende Struktur:
NUSE_Timer_Status [] ist ein Array vom Typ U8 , das einen Eintrag für jeden konfigurierten Timer hat und den Status des Timers speichert (läuft oder gestoppt: TRUE oder FALSE ).
NUSE_Timer_Value [] ist ein Array vom Typ U16 , das einen Eintrag für jeden konfigurierten Timer hat und den aktuellen Wert des Timer-Zählers speichert.
NUSE_Timer_Expirations_Counter [] - Ein Array vom Typ U8 , das einen Zähler für die Anzahl der Fälle enthält, in denen die Timer das Ende des Zyklus seit ihrem letzten Zurücksetzen erreicht haben.

Alle diese Datenstrukturen werden beim Start von Nucleus SE von der Funktion NUSE_Init_Timer () initialisiert. Einer der folgenden Artikel enthält eine vollständige Beschreibung der Startvorgänge für Nucleus SE.

Im Folgenden sind die Definitionen dieser Datenstrukturen in der Datei nuse_init.c aufgeführt :
RAM U8 Timer_Status [NUSE_TIMER_NUMBER];
RAM U16 NUSE_Timer_Value [NUSE_TIMER_NUMBER];
RAM U8 NUSE_Timer_Expirations_Counter [NUSE_TIMER_NUMBER];

ROM-Daten

Die Struktur dieser Daten:
NUSE_Timer_Initial_Time [] ist ein Array vom Typ U16 , das einen Eintrag für jeden konfigurierten Timer enthält und den Wert jedes Timers speichert.
NUSE_Timer_Reschedule_Time [] - Ein Array vom Typ U16 , das einen Eintrag für jeden konfigurierten Timer enthält und den Wert speichert, in dem der Timer nach Abschluss eingestellt wird. Ein Wert von Null zeigt an, dass der Timer "einmalig" ist und nicht automatisch neu gestartet werden sollte.
NUSE_Timer_Expiration_Routine_Address [] - Ein Array vom Typ ADDR, das die Adresse der Ablaufvorgänge des Timers enthält. Dieses Array ist nur vorhanden, wenn die Unterstützung für das Ablaufdatum des Timers aktiviert wurde.
NUSE_Timer_Expiration_Routine_Parameter [] - Ein Array vom Typ U8, das die Werte des Parameters enthält, der an die Timer-Abschlussfunktion übergeben wird. Dieses Array ist nur vorhanden, wenn die Unterstützung für Abschlussfunktionen aktiviert wurde.

Diese Datenstrukturen werden (statisch) in der Datei nuse_config.c deklariert und initialisiert.

 ROM U16 NUSE_Timer_Initial_Time[NUSE_TIMER_NUMBER] = { /*   ------ */ }; ROM U16 NUSE_Timer_Reschedule_Time[NUSE_TIMER_NUMBER] = { /*      ------ */ }; #if NUSE_TIMER_EXPIRATION_ROUTINE_SUPPORT || NUSE_INCLUDE_EVERYTHING /*    */ ROM ADDR NUSE_Timer_Expiration_Routine_Address[NUSE_TIMER_NUMBER] = { /*     ------ */ /*   NULL */ }; ROM U8 NUSE_Timer_Expiration_Routine_Parameter[NUSE_TIMER_NUMBER] = { /*     ------ */ }; #endif 

Die Speichermenge für den Timer

Wie bei allen anderen Nucleus SE-Objekten ist die für Timer erforderliche Datenmenge vorhersehbar.

Die Datenmenge im RAM (in Byte) für alle Timer in der Anwendung kann wie folgt berechnet werden:
NUSE_TIMER_NUMBER * 4

Die Datenmenge im ROM (in Byte) für alle Timer in der Anwendung kann wie folgt berechnet werden, wenn die Unterstützung für Abschlussfunktionen deaktiviert ist:
NUSE_TIMER_NUMBER * 4

Ansonsten ist es gleich:
NUSE_TIMER_NUMBER * (Größe von (ADDR) + 5)

Nicht realisierte API-Aufrufe

Nucleus SE implementiert die drei API-Aufrufe, die in RTOS enthalten sind, nicht.

Timer-Erstellung

Dieser API-Aufruf erstellt einen Timer. Nucleus SE benötigt es nicht, da Timer statisch erstellt werden.

Prototyp eines Serviceabrufs:
STATUS NU_Create_Timer (NU_TIMER * timer, CHAR * name, VOID (* expiration_routine) (UNSIGNED), UNSIGNED id, UNSIGNED initial_time, UNSIGNED reschedule_time, OPTION enable);

Parameter:
Timer - Zeiger auf den vom Benutzer bereitgestellten Timer-Steuerblock; Es wird verwendet, um Timer in anderen API-Aufrufen zu steuern.
name - Zeiger auf den 7-stelligen Namen des Timers mit einer abschließenden Null;
expiration_routine - gibt die Funktion an, die nach Ablauf des Timers ausgeführt werden soll.
id - ein Datenelement vom Typ UNSIGNED, das an die Beendigungsfunktion übergeben wird: Dieser Parameter kann verwendet werden, um Timer mit derselben Beendigungsfunktion zu identifizieren;
initial_time - gibt die anfängliche Anzahl von Timer-Ticks an, bevor der Timer endet;
reschedule_time - Gibt die Anzahl der Timer- Ticks an, bis der zweite und die folgenden Zyklen abgeschlossen sind. Wenn dieser Parameter gleich Null ist, stoppt der Timer nur einmal.
enable - Dieser Parameter kann die Werte NU_ENABLE_TIMER und NU_DISABLE_TIMER annehmen . NU_ENABLE_TIMER aktiviert einen Timer, nachdem er erstellt wurde. NU_DISABLE_TIMER lässt den Timer deaktiviert. Mit dem Parameter NU_DISABLE_TIMER erstellte Timer müssen durch Aufrufen von NU_Control_Timer aktiviert werden.

Rückgabewert:
NU_SUCCESS - Der Anruf wurde erfolgreich abgeschlossen.
NU_INVALID_TIMER - ein Nullzeiger auf eine Timer-Steuereinheit ( NULL ) oder die Steuereinheit wird bereits verwendet;
NU_INVALID_FUNCTION - Nullzeiger auf das Abschlussprogramm ( NULL );
NU_INVALID_ENABLE - ungültiger Aktivierungsparameter ;
NU_INVALID_OPERATION - Der Parameter initial_time war Null.

Timer löschen

Dieser API-Aufruf löscht einen zuvor erstellten Timer. Nucleus SE benötigt es nicht, da Timer statisch erstellt werden und nicht gelöscht werden können.

Prototyp eines Serviceabrufs:
STATUS NU_Delete_Timer (NU_TIMER * Timer);

Parameter:
Timer - Zeiger auf den Timer-Steuerblock.

Rückgabewert:
NU_SUCCESS - Der Anruf wurde erfolgreich abgeschlossen.
NU_INVALID_TIMER - ungültiger Timerzeiger ;
NU_NOT_DISABLED - Der angegebene Timer ist nicht deaktiviert.

Timer-Zeiger

Dieser API-Aufruf bildet eine sequentielle Liste von Zeigern auf alle Timer im System. Nucleus SE benötigt es nicht, da die Timer durch einen einfachen Index und nicht durch einen Zeiger bestimmt werden.

Prototyp eines Serviceabrufs:
UNSIGNED NU_Timer_Pointers (NU_TIMER ** Zeigerliste, UNSIGNED Maximum_Pointers);

Parameter:
pointer_list - Zeiger auf ein Array von Zeigern NU_TIMER ; Es wird mit Zeigern auf im System konfigurierte Timer gefüllt.
Maximum_Pointers - Die maximale Anzahl von Zeigern im Array.

Rückgabewert:
Die Anzahl der im Array platzierten NU_TIMER- Zeiger.

Nucleus RTOS-kompatibel

Wie bei allen anderen Nucleus SE-Objekten war es mein Ziel, die Kompatibilität des Anwendungscodes mit Nucleus RTOS zu maximieren. Timer sind keine Ausnahme und werden aus Anwendersicht auf die gleiche Weise wie in Nucleus RTOS implementiert.Es gibt auch eine gewisse Inkompatibilität, die ich für zulässig hielt, da der Code dadurch verständlicher und effizienter in Bezug auf den erforderlichen Speicher wird. Andernfalls können Nucleus RTOS-API-Aufrufe fast direkt auf Nucleus SE portiert werden.

Objektkennungen

In Nucleus RTOS werden alle Objekte durch eine Datenstruktur beschrieben - einen Steuerblock mit einem bestimmten Datentyp. Ein Zeiger auf diese Steuereinheit ist eine Zeitgeberkennung. Ich entschied, dass in Nucleus SE ein anderer Ansatz für eine effiziente Speichernutzung erforderlich ist: Alle Kernelobjekte werden durch eine Reihe von Tabellen im RAM und / oder ROM beschrieben. Die Größe dieser Tabellen wird durch die Anzahl der konfigurierten Objekte jedes Typs bestimmt. Die Kennung eines bestimmten Objekts ist der Index in dieser Tabelle. Also habe ich NUSE_TIMER als das Äquivalent von U8 definiertEine Variable (kein Zeiger) dieses Typs dient als Kennung des Timers. Diese leichte Inkompatibilität ist leicht zu handhaben, wenn der Code von Nucleus SE nach Nucleus RTOS und umgekehrt portiert wird. In der Regel werden keine anderen Operationen an Objektkennungen als Verschieben und Speichern ausgeführt.
Nucleus RTOS unterstützt auch die Benennung von Timern. Diese Namen werden nur zum Debuggen verwendet. Ich habe sie von Nucleus SE ausgeschlossen, um Speicherplatz zu sparen.

Timergröße

In Nucleus RTOS werden Timer mithilfe von 32-Bit-Zählern implementiert. Ich habe beschlossen, diesen Wert in Nucleus SE auf 16 Bit zu reduzieren. Dies hat zu erheblichen Verbesserungen der Speichereffizienz und der Laufzeit geführt. Nucleus SE kann geändert werden, wenn die Anwendung eine längere Laufzeit erfordert.

Abschlussfunktionen

Nucleus SE implementiert Terminierungsfunktionen ähnlich wie Nucleus RTOS, nur können sie vollständig deaktiviert werden (wodurch Sie Speicherplatz sparen können) und sie werden auch statisch bestimmt. Die Endfunktion kann nicht geändert werden, wenn der Timer zurückgesetzt wird.

Nicht realisierte API-Aufrufe

Nucleus RTOS unterstützt acht Timer-Serviceanrufe. Von diesen sind drei in Nucleus SE nicht implementiert. Eine ausführliche Beschreibung dieser Aufrufe sowie die Gründe für diese Entscheidung finden Sie weiter oben in diesem Artikel im Abschnitt "Nicht realisierte API-Aufrufe".

Der folgende Artikel untersucht Unterbrechungen.