Signale

In diesem RTOS Revealed werde ich mir Signale ansehen, die die einfachste Methode der Inter-Task-Kommunikation sind, die von Nucleus SE unterstützt wird. Sie bieten eine sehr kostengünstige Möglichkeit, einfache Nachrichten zwischen Aufgaben zu übertragen.

Signale verwenden

Signale unterscheiden sich von allen anderen Typen von Kernel-Objekten darin, dass sie nicht autonom sind – Signale sind mit Aufgaben verbunden und haben keine unabhängige Existenz. Wenn Signale für eine Anwendung konfiguriert sind, hat jede Task einen Satz von acht Signalflags.

Jede Task kann die Signale einer anderen Task setzen. Nur die Owner-Task kann die Signale lesen. Das Lesen ist destruktiv – d. h. die Signale werden durch den Lesevorgang gelöscht. Keine andere Aufgabe kann die Signale einer Aufgabe lesen oder löschen.

Es gibt eine Funktion in Nucleus RTOS, die es einem Task ermöglicht, eine Funktion zu benennen, die ausgeführt wird, wenn ein anderer Task eines oder mehrere seiner Signalflags setzt. Dies ist etwas analog zu einer Interrupt-Service-Routine. Diese Funktion wird in Nucleus SE nicht unterstützt; Tasks müssen ihre Signal-Flags explizit abfragen.

Konfigurieren von Signalen

Wie bei den meisten Aspekten von Nucleus SE wird die Konfiguration der Signale hauptsächlich durch #define . gesteuert Anweisungen in nuse_config.h . Die Schlüsseleinstellung ist NUSE_SIGNAL_SUPPORT , die die Einrichtung (für alle Aufgaben in der Anwendung) aktiviert. Dabei kommt es nicht darauf an, die Anzahl der Signale anzugeben – es gibt einfach einen Satz von acht Flags für jede Task in der Anwendung.

Das Setzen dieses Freigabeparameters ist die „Masterfreigabe“ für Signale. Dadurch wird eine Datenstruktur definiert und entsprechend dimensioniert, davon später in diesem Artikel mehr. Es aktiviert auch die API-Aktivierungseinstellungen.

API aktiviert

Jede API-Funktion (Dienstaufruf) in Nucleus SE hat eine aktivierende #define Symbol in nuse_config.h . Für Signale sind dies:

NUSE_SIGNALS_SENDNUSE_SIGNALS_RECEIVE 

Standardmäßig sind beide auf FALSE eingestellt , wodurch jeder Dienstaufruf deaktiviert und die Aufnahme jeglichen Implementierungscodes verhindert wird. Um Signale für eine Anwendung zu konfigurieren, müssen Sie die API-Aufrufe auswählen, die Sie verwenden möchten, und ihre Aktivierungssymbole auf TRUE setzen .

Hier ist ein Auszug aus der standardmäßigen nuse_config.h Datei:

#define NUSE_SIGNAL_SUPPORT FALSE /* Aktiviert die Unterstützung von Signalen */#define NUSE_SIGNALS_SEND FALSE /* Service Call Enabler */#define NUSE_SIGNALS_RECEIVE FALSE /* Service Call Enabler */ 

Ein Kompilierzeitfehler tritt auf, wenn eine Signal-API-Funktion aktiviert ist und die Signalfunktion nicht aktiviert wurde. Wenn Ihr Code einen nicht aktivierten API-Aufruf verwendet, kommt es zu einem Linkzeitfehler, da kein Implementierungscode in die Anwendung eingefügt wurde. Natürlich ist die Aktivierung der beiden API-Funktionen etwas redundant, da es keinen Sinn macht, die Signalunterstützung zu aktivieren und diese APIs nicht verfügbar zu haben. Die Freigaben sind aus Gründen der Kompatibilität mit anderen Nucleus SE-Funktionen enthalten.

Signalisiert Dienstaufrufe

Nucleus RTOS unterstützt vier Serviceaufrufe, die sich auf Signale beziehen und die folgende Funktionalität bieten:

• Sende Signale an eine bestimmte Aufgabe. Implementiert von NUSE_Signals_Send() in Nucleus SE.

• Empfang Signale. Implementiert von NUSE_Signals_Receive() in Nucleus SE.

• Registrieren Sie einen Signalhandler. Nicht in Nucleus SE implementiert.

• Aktivieren/Deaktivieren von (Kontroll-)Signalen. Nicht in Nucleus SE implementiert.

Die Implementierung jedes dieser Service Calls wird im Detail untersucht.

Signale Sende- und Empfangsdienste

Die grundlegenden Operationen, die an den Signalen einer Task ausgeführt werden können, sind das Senden von Daten (was von jeder Task durchgeführt werden kann) und das Lesen von Daten daraus (und damit das Löschen der Daten, was nur vom Eigentümer durchgeführt werden darf). . Nucleus RTOS und Nucleus SE bieten jeweils zwei grundlegende API-Aufrufe für diese Operationen, die hier besprochen werden.

Da Signal-Flags Bits sind, werden sie am besten als Binärzahlen visualisiert. Da Standard C historisch keine Darstellung von binären Konstanten (nur oktal und hexadezimal) unterstützt, enthält die Nucleus SE-Distribution eine nützliche Header-Datei – nuse_binary.h – enthält #define Symbole der Form b01010101 für alle 256 8-Bit-Werte. Hier ist ein Auszug aus der nuse_binary.h Datei:

#define b00000000 ((U8) 0x00)#define b00000001 ((U8) 0x01)#define b00000010 ((U8) 0x02)#define b00000011 ((U8) 0x03)#define b00000100 ((U8) 0x04)#define b000000101 ((U8) 0x05)

Sendesignale

Jede Task kann Signale an jede andere Task in der Anwendung senden. Das Senden von Signalen beinhaltet das Setzen eines oder mehrerer der Signal-Flags. Dies ist eine ODER-Operation, die keine Auswirkungen auf zuvor gesetzte Flags hat.

Nucleus RTOS API-Aufruf zum Senden von Signalen

Prototyp für Serviceruf:

STATUS NU_Send_Signals(NU_TASK *Aufgabe, UNSIGNED Signale);

Parameter:

Aufgabe – Zeiger auf Steuerblock der Task, der die zu setzenden Signalflags besitzt

Signale – der Wert der zu setzenden Signalflags

Rückgabe:

NU_SUCCESS – der Anruf wurde erfolgreich abgeschlossen

NU_INVALID_TASK – der Aufgabenzeiger ist ungültig

Nucleus SE API-Aufruf zum Senden von Signalen

Dieser API-Aufruf unterstützt die Schlüsselfunktionalität der Nucleus RTOS API.

Prototyp für Serviceruf:

STATUS NUSE_Signals_Send(NUSE_TASK-Aufgabe, U8-Signale);

Parameter:

Aufgabe – der Index (ID) der Task, die die zu setzenden Signalflags besitzt

Signale – der Wert der zu setzenden Signalflags

Rückgabe:

NUSE_SUCCESS – der Anruf wurde erfolgreich abgeschlossen

NUSE_INVALID_TASK – der Aufgabenindex ist ungültig

Nucleus SE-Implementierung von Sendesignalen

Hier ist der vollständige Code für NUSE_Signals_Send() Funktion:

STATUS NUSE_Signals_Send(NUSE_TASK-Aufgabe, U8-Signale){ #if NUSE_API_PARAMETER_CHECKING if (Aufgabe>=NUSE_TASK_NUMBER) { return NUSE_INVALID_TASK; } #endif NUSE_CS_Enter(); NUSE_Task_Signal_Flags[Aufgabe] |=Signale; NUSE_CS_Exit(); NUSE_SUCCESS zurückgeben;} 

Der Code ist sehr einfach. Nach jeder Parameterüberprüfung werden die Signalwerte mit den Signal-Flags der angegebenen Task ODER-verknüpft. Das Blockieren von Aufgaben ist für Signale nicht relevant.

Empfang von Signalen

Eine Task darf nur ihren eigenen Satz von Signalflags lesen. Der Prozess des Lesens ist destruktiv; d.h. es führt auch dazu, dass die Flags gelöscht werden.

Nucleus RTOS API-Aufruf zum Empfangen von Signalen

Prototyp für Serviceruf:

UNSIGNED NU_Receive_Signals(VOID);

Parameter:keine

Rückgabe:der Wert der Signalflaggen

Nucleus SE API-Aufruf zum Empfangen von Signalen

Dieser API-Aufruf unterstützt die Schlüsselfunktionalität der Nucleus RTOS API.

Prototyp für Serviceruf:

U8 NUSE_Signals_Receive(void);

Parameter:keine

Rückgabe:der Wert der Signalflagge

Nucleus SE-Implementierung von Empfangssignalen

Hier ist der vollständige Code für NUSE_Signals_Receive() Funktion:

U8 NUSE_Signals_Receive(void){ U8-Signale; NUSE_CS_Enter(); Signale =NUSE_Task_Signal_Flags[NUSE_Task_Active]; NUSE_Task_Signal_Flags[NUSE_Task_Active] =0; NUSE_CS_Exit(); Rücksignale;} 

Der Code ist sehr einfach. Der Flags-Wert wird kopiert, der ursprüngliche Wert gelöscht und die Kopie von der API-Funktion zurückgegeben. Das Blockieren von Aufgaben ist für Signale nicht relevant.