NanoPB: Umgang mit Enums in C++

Siehe auch: C-Version: Umgang mit Enums in C

NanoPB ist eine codegrößenoptimierte Protocol-Buffers-Implementierung für Embedded-Systeme. Dieser Beitrag zeigt, wie man mit Enum-Typen in C++ unter Verwendung von NanoPB umgeht.

Proto-Definition

Erstelle zunächst eine .proto-Datei mit Enums:

enums.proto

syntax = "proto3";

package example;

enum Status {
  UNKNOWN = 0;
  OK = 1;
  ERROR = 2;
  BUSY = 3;
}

message EnumMessage {
  Status status = 1;
}

syntax = "proto3";

package example;

enum Status {
  UNKNOWN = 0;
  OK = 1;
  ERROR = 2;
  BUSY = 3;
}

message EnumMessage {
  Status status = 1;
}

NanoPB-Code generieren

Generiere den NanoPB-Code:

generate_nanopb_enums.sh

protoc --nanopb_out=. enums.proto

protoc --nanopb_out=. enums.proto

Dies erzeugt enums.pb.h und enums.pb.c.

C++-Beispiel

Hier ist ein vollständiges C++-Beispiel zum Umgang mit Enums:

enums_example.cpp

#include <stdio.h>
#include "enums.pb.h"
#include "pb_encode.h"
#include "pb_decode.h"

// Hilfsfunktion zur Konvertierung von Enum in String
const char* status_to_string(example_Status status) {
    switch (status) {
        case example_Status_UNKNOWN: return "UNKNOWN";
        case example_Status_OK: return "OK";
        case example_Status_ERROR: return "ERROR";
        case example_Status_BUSY: return "BUSY";
        default: return "INVALID";
    }
}

int main() {
    // Puffer für kodierte Nachricht
    uint8_t buffer[64];
    size_t message_length;
    
    // --- KODIERUNG ---
    example_EnumMessage message = example_EnumMessage_init_zero;
    
    // Enum-Wert setzen
    message.status = example_Status_OK;
    
    // Strom für Kodierung erstellen
    pb_ostream_t ostream = pb_ostream_from_buffer(buffer, sizeof(buffer));
    
    // Nachricht kodieren
    if (!pb_encode(&ostream, example_EnumMessage_fields, &message)) {
        printf("Kodierung fehlgeschlagen: %s\n", PB_GET_ERROR(&ostream));
        return 1;
    }
    
    message_length = ostream.bytes_written;
    printf("%zu Bytes kodiert\n", message_length);
    
    // Hex-Dump der kodierten Daten ausgeben
    printf("Kodierte Daten: ");
    for (size_t i = 0; i < message_length; i++) {
        printf("%02x ", buffer[i]);
    }
    printf("\n");
    
    // --- DEKODIERUNG ---
    example_EnumMessage decoded = example_EnumMessage_init_zero;
    
    // Strom für Dekodierung erstellen
    pb_istream_t istream = pb_istream_from_buffer(buffer, message_length);
    
    // Nachricht dekodieren
    if (!pb_decode(&istream, example_EnumMessage_fields, &decoded)) {
        printf("Dekodierung fehlgeschlagen: %s\n", PB_GET_ERROR(&istream));
        return 1;
    }
    
    // Dekodierten Wert ausgeben
    printf("Dekodierter Wert:\n");
    printf("  status: %s (Enum-Wert: %d)\n", 
           status_to_string(decoded.status), decoded.status);
    
    return 0;
}

#include <stdio.h>
#include "enums.pb.h"
#include "pb_encode.h"
#include "pb_decode.h"

// Hilfsfunktion zur Konvertierung von Enum in String
const char* status_to_string(example_Status status) {
    switch (status) {
        case example_Status_UNKNOWN: return "UNKNOWN";
        case example_Status_OK: return "OK";
        case example_Status_ERROR: return "ERROR";
        case example_Status_BUSY: return "BUSY";
        default: return "INVALID";
    }
}

int main() {
    // Puffer für kodierte Nachricht
    uint8_t buffer[64];
    size_t message_length;
    
    // --- KODIERUNG ---
    example_EnumMessage message = example_EnumMessage_init_zero;
    
    // Enum-Wert setzen
    message.status = example_Status_OK;
    
    // Strom für Kodierung erstellen
    pb_ostream_t ostream = pb_ostream_from_buffer(buffer, sizeof(buffer));
    
    // Nachricht kodieren
    if (!pb_encode(&ostream, example_EnumMessage_fields, &message)) {
        printf("Kodierung fehlgeschlagen: %s\n", PB_GET_ERROR(&ostream));
        return 1;
    }
    
    message_length = ostream.bytes_written;
    printf("%zu Bytes kodiert\n", message_length);
    
    // Hex-Dump der kodierten Daten ausgeben
    printf("Kodierte Daten: ");
    for (size_t i = 0; i < message_length; i++) {
        printf("%02x ", buffer[i]);
    }
    printf("\n");
    
    // --- DEKODIERUNG ---
    example_EnumMessage decoded = example_EnumMessage_init_zero;
    
    // Strom für Dekodierung erstellen
    pb_istream_t istream = pb_istream_from_buffer(buffer, message_length);
    
    // Nachricht dekodieren
    if (!pb_decode(&istream, example_EnumMessage_fields, &decoded)) {
        printf("Dekodierung fehlgeschlagen: %s\n", PB_GET_ERROR(&istream));
        return 1;
    }
    
    // Dekodierten Wert ausgeben
    printf("Dekodierter Wert:\n");
    printf("  status: %s (Enum-Wert: %d)\n", 
           status_to_string(decoded.status), decoded.status);
    
    return 0;
}

Kompilierbefehl

Kompiliere das Beispiel mit NanoPB. NanoPB wird typischerweise verwendet, indem die Quelldateien direkt in dein Projekt eingebunden werden:

compile_enums_example.sh

g++ -o enums_example enums_example.cpp enums.pb.c pb_common.c pb_encode.c pb_decode.c -I.

g++ -o enums_example enums_example.cpp enums.pb.c pb_common.c pb_encode.c pb_decode.c -I.

Hinweis: NanoPB-Quelldateien (pb_common.c, pb_encode.c, pb_decode.c) müssen direkt mit deinem Projekt kompiliert werden. Du kannst diese aus dem NanoPB-GitHub-Repository beziehen.

Python-Testskript

Um die Kodierung zu überprüfen, kannst du die Python-Protobuf-Bibliothek verwenden:

test_enums.py

import enums_pb2

# Binärdaten lesen
with open('encoded.bin', 'rb') as f:
    data = f.read()

# Dekodieren
msg = enums_pb2.EnumMessage()
msg.ParseFromString(data)

print("Python dekodierte Werte:")
print(f"  status: {enums_pb2.Status.Name(msg.status)}")

import enums_pb2

# Binärdaten lesen
with open('encoded.bin', 'rb') as f:
    data = f.read()

# Dekodieren
msg = enums_pb2.EnumMessage()
msg.ParseFromString(data)

print("Python dekodierte Werte:")
print(f"  status: {enums_pb2.Status.Name(msg.status)}")

Kompiliere zunächst die Python-Protobuf-Definitionen:

compile_python_enums.sh

protoc --python_out=. enums.proto

protoc --python_out=. enums.proto

Modifiziere dann das C++-Beispiel, um die kodierten Daten in einer Datei zu speichern:

save_encoded_enums.cpp

// Nach der Kodierung, dies hinzufügen:
FILE *f = fopen("encoded.bin", "wb");
fwrite(buffer, 1, message_length, f);
fclose(f);

// Nach der Kodierung, dies hinzufügen:
FILE *f = fopen("encoded.bin", "wb");
fwrite(buffer, 1, message_length, f);
fclose(f);

Beispiel mit Enum in switch-Anweisung

Hier ist ein Beispiel, das zeigt, wie man Enums in switch-Anweisungen verwendet:

enums_switch_example.cpp

#include <stdio.h>
#include "enums.pb.h"
#include "pb_encode.h"
#include "pb_decode.h"

void handle_status(example_Status status) {
    printf("Status behandeln: ");
    
    switch (status) {
        case example_Status_UNKNOWN:
            printf("UNKNOWN - Standardzustand\n");
            break;
        case example_Status_OK:
            printf("OK - Operation erfolgreich\n");
            break;
        case example_Status_ERROR:
            printf("ERROR - Operation fehlgeschlagen\n");
            break;
        case example_Status_BUSY:
            printf("BUSY - System beschäftigt\n");
            break;
        default:
            printf("INVALID - Unbekannter Enum-Wert\n");
            break;
    }
}

int main() {
    uint8_t buffer[64];
    size_t message_length;
    
    // Alle Enum-Werte testen
    example_Status test_values[] = {
        example_Status_UNKNOWN,
        example_Status_OK,
        example_Status_ERROR,
        example_Status_BUSY
    };
    
    for (size_t i = 0; i < 4; i++) {
        example_EnumMessage message = example_EnumMessage_init_zero;
        message.status = test_values[i];
        
        pb_ostream_t ostream = pb_ostream_from_buffer(buffer, sizeof(buffer));
        
        if (!pb_encode(&ostream, example_EnumMessage_fields, &message)) {
            printf("Kodierung fehlgeschlagen: %s\n", PB_GET_ERROR(&ostream));
            return 1;
        }
        
        message_length = ostream.bytes_written;
        
        example_EnumMessage decoded = example_EnumMessage_init_zero;
        pb_istream_t istream = pb_istream_from_buffer(buffer, message_length);
        
        if (!pb_decode(&istream, example_EnumMessage_fields, &decoded)) {
            printf("Dekodierung fehlgeschlagen: %s\n", PB_GET_ERROR(&istream));
            return 1;
        }
        
        handle_status(decoded.status);
    }
    
    return 0;
}

#include <stdio.h>
#include "enums.pb.h"
#include "pb_encode.h"
#include "pb_decode.h"

void handle_status(example_Status status) {
    printf("Status behandeln: ");
    
    switch (status) {
        case example_Status_UNKNOWN:
            printf("UNKNOWN - Standardzustand\n");
            break;
        case example_Status_OK:
            printf("OK - Operation erfolgreich\n");
            break;
        case example_Status_ERROR:
            printf("ERROR - Operation fehlgeschlagen\n");
            break;
        case example_Status_BUSY:
            printf("BUSY - System beschäftigt\n");
            break;
        default:
            printf("INVALID - Unbekannter Enum-Wert\n");
            break;
    }
}

int main() {
    uint8_t buffer[64];
    size_t message_length;
    
    // Alle Enum-Werte testen
    example_Status test_values[] = {
        example_Status_UNKNOWN,
        example_Status_OK,
        example_Status_ERROR,
        example_Status_BUSY
    };
    
    for (size_t i = 0; i < 4; i++) {
        example_EnumMessage message = example_EnumMessage_init_zero;
        message.status = test_values[i];
        
        pb_ostream_t ostream = pb_ostream_from_buffer(buffer, sizeof(buffer));
        
        if (!pb_encode(&ostream, example_EnumMessage_fields, &message)) {
            printf("Kodierung fehlgeschlagen: %s\n", PB_GET_ERROR(&ostream));
            return 1;
        }
        
        message_length = ostream.bytes_written;
        
        example_EnumMessage decoded = example_EnumMessage_init_zero;
        pb_istream_t istream = pb_istream_from_buffer(buffer, message_length);
        
        if (!pb_decode(&istream, example_EnumMessage_fields, &decoded)) {
            printf("Dekodierung fehlgeschlagen: %s\n", PB_GET_ERROR(&istream));
            return 1;
        }
        
        handle_status(decoded.status);
    }
    
    return 0;
}

Wichtige Punkte

Enum-Definition: Definiere Enums in der .proto-Datei mit expliziten Werten
Generierte Typen: NanoPB generiert Enum-Typen mit der Namenskonvention package_EnumName
Kodierung: Enum-Wert direkt dem Feld zuweisen
Dekodierung: Enum-Werte werden automatisch dekodiert
Standardwerte: Der erste Enum-Wert (typischerweise 0) ist der Standardwert
switch-Anweisungen: Enums funktionieren natürlicherweise in switch-Anweisungen
Typsicherheit: Enums bieten Typsicherheit gegenüber rohen Integer-Werten
Unbekannte Werte: Ungültige Enum-Werte können als ihr numerischer Wert dekodiert werden

Wann man Enums verwendet

Wenn du eine feste Menge möglicher Werte hast
Wenn du Typsicherheit für Zustands- oder Modusfelder wünschst
Wenn du selbstdokumentierenden Code wünschst
Wenn du zwischen verschiedenen Betriebsmodi unterscheiden musst
Wenn du semantische Bedeutung in Nachrichten kodieren möchtest

Erwartete Ausgabe

enums_expected_output.txt

2 Bytes kodiert
Kodierte Daten: 08 01 
Dekodierter Wert:
  status: OK (Enum-Wert: 1)

2 Bytes kodiert
Kodierte Daten: 08 01 
Dekodierter Wert:
  status: OK (Enum-Wert: 1)

Erwartete Ausgabe (switch-Beispiel)

enums_switch_expected_output.txt

Status behandeln: UNKNOWN - Standardzustand
Status behandeln: OK - Operation erfolgreich
Status behandeln: ERROR - Operation fehlgeschlagen
Status behandeln: BUSY - System beschäftigt

Status behandeln: UNKNOWN - Standardzustand
Status behandeln: OK - Operation erfolgreich
Status behandeln: ERROR - Operation fehlgeschlagen
Status behandeln: BUSY - System beschäftigt

Weitere NanoPB-Beiträge

Ähnliche Beiträge nach Kategorie: Embedded, C/C++, Protocol Buffers

Wenn dieser Beitrag dir geholfen hat, erwäge, mir einen Kaffee zu spendieren oder per PayPal zu spenden, um die Recherche und Veröffentlichung neuer Beiträge auf TechOverflow zu unterstützen

Buy me a coffee