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

Erstellen Sie 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

Generieren Sie 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"

// Helper function to convert enum to 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() {
    // Buffer for encoded message
    uint8_t buffer[64];
    size_t message_length;
    
    // --- ENCODING ---
    example_EnumMessage message = example_EnumMessage_init_zero;
    
    // Set enum value
    message.status = example_Status_OK;
    
    // Create stream for encoding
    pb_ostream_t ostream = pb_ostream_from_buffer(buffer, sizeof(buffer));
    
    // Encode the message
    if (!pb_encode(&ostream, example_EnumMessage_fields, &message)) {
        printf("Encoding failed: %s\n", PB_GET_ERROR(&ostream));
        return 1;
    }
    
    message_length = ostream.bytes_written;
    printf("Encoded %zu bytes\n", message_length);
    
    // Print hex dump of encoded data
    printf("Encoded data: ");
    for (size_t i = 0; i < message_length; i++) {
        printf("%02x ", buffer[i]);
    }
    printf("\n");
    
    // --- DECODING ---
    example_EnumMessage decoded = example_EnumMessage_init_zero;
    
    // Create stream for decoding
    pb_istream_t istream = pb_istream_from_buffer(buffer, message_length);
    
    // Decode the message
    if (!pb_decode(&istream, example_EnumMessage_fields, &decoded)) {
        printf("Decoding failed: %s\n", PB_GET_ERROR(&istream));
        return 1;
    }
    
    // Print decoded value
    printf("Decoded value:\n");
    printf("  status: %s (enum value: %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"

// Helper function to convert enum to 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() {
    // Buffer for encoded message
    uint8_t buffer[64];
    size_t message_length;
    
    // --- ENCODING ---
    example_EnumMessage message = example_EnumMessage_init_zero;
    
    // Set enum value
    message.status = example_Status_OK;
    
    // Create stream for encoding
    pb_ostream_t ostream = pb_ostream_from_buffer(buffer, sizeof(buffer));
    
    // Encode the message
    if (!pb_encode(&ostream, example_EnumMessage_fields, &message)) {
        printf("Encoding failed: %s\n", PB_GET_ERROR(&ostream));
        return 1;
    }
    
    message_length = ostream.bytes_written;
    printf("Encoded %zu bytes\n", message_length);
    
    // Print hex dump of encoded data
    printf("Encoded data: ");
    for (size_t i = 0; i < message_length; i++) {
        printf("%02x ", buffer[i]);
    }
    printf("\n");
    
    // --- DECODING ---
    example_EnumMessage decoded = example_EnumMessage_init_zero;
    
    // Create stream for decoding
    pb_istream_t istream = pb_istream_from_buffer(buffer, message_length);
    
    // Decode the message
    if (!pb_decode(&istream, example_EnumMessage_fields, &decoded)) {
        printf("Decoding failed: %s\n", PB_GET_ERROR(&istream));
        return 1;
    }
    
    // Print decoded value
    printf("Decoded value:\n");
    printf("  status: %s (enum value: %d)\n", 
           status_to_string(decoded.status), decoded.status);
    
    return 0;
}

Kompilierbefehl

Kompilieren Sie das Beispiel mit NanoPB. NanoPB wird typischerweise verwendet, indem die Quelldateien direkt in Ihr 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 Ihrem Projekt kompiliert werden. Sie können diese aus dem NanoPB-GitHub-Repository beziehen.

Python-Testskript

Um die Kodierung zu überprüfen, können Sie die Python-Protobuf-Bibliothek verwenden:

test_enums.py

import enums_pb2

# Read the binary data
with open('encoded.bin', 'rb') as f:
    data = f.read()

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

print("Python decoded values:")
print(f"  status: {enums_pb2.Status.Name(msg.status)}")

import enums_pb2

# Read the binary data
with open('encoded.bin', 'rb') as f:
    data = f.read()

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

print("Python decoded values:")
print(f"  status: {enums_pb2.Status.Name(msg.status)}")

Kompilieren Sie zunächst die Python-Protobuf-Definitionen:

compile_python_enums.sh

protoc --python_out=. enums.proto

protoc --python_out=. enums.proto

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

save_encoded_enums.cpp

// After encoding, add this:
FILE *f = fopen("encoded.bin", "wb");
fwrite(buffer, 1, message_length, f);
fclose(f);

// After encoding, add this:
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("Handling status: ");
    
    switch (status) {
        case example_Status_UNKNOWN:
            printf("UNKNOWN - Default state\n");
            break;
        case example_Status_OK:
            printf("OK - Operation successful\n");
            break;
        case example_Status_ERROR:
            printf("ERROR - Operation failed\n");
            break;
        case example_Status_BUSY:
            printf("BUSY - System busy\n");
            break;
        default:
            printf("INVALID - Unknown enum value\n");
            break;
    }
}

int main() {
    uint8_t buffer[64];
    size_t message_length;
    
    // Test all enum values
    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("Encoding failed: %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("Decoding failed: %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("Handling status: ");
    
    switch (status) {
        case example_Status_UNKNOWN:
            printf("UNKNOWN - Default state\n");
            break;
        case example_Status_OK:
            printf("OK - Operation successful\n");
            break;
        case example_Status_ERROR:
            printf("ERROR - Operation failed\n");
            break;
        case example_Status_BUSY:
            printf("BUSY - System busy\n");
            break;
        default:
            printf("INVALID - Unknown enum value\n");
            break;
    }
}

int main() {
    uint8_t buffer[64];
    size_t message_length;
    
    // Test all enum values
    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("Encoding failed: %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("Decoding failed: %s\n", PB_GET_ERROR(&istream));
            return 1;
        }
        
        handle_status(decoded.status);
    }
    
    return 0;
}

Wichtige Punkte

Enum-Definition: Definieren Sie 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 Sie eine feste Menge möglicher Werte haben
Wenn Sie Typsicherheit für Zustands- oder Modusfelder wünschen
Wenn Sie selbstdokumentierenden Code wünschen
Wenn Sie zwischen verschiedenen Betriebsmodi unterscheiden müssen
Wenn Sie semantische Bedeutung in Nachrichten kodieren möchten

Erwartete Ausgabe

enums_expected_output.txt

Encoded 2 bytes
Encoded data: 08 01 
Decoded value:
  status: OK (enum value: 1)

Encoded 2 bytes
Encoded data: 08 01 
Decoded value:
  status: OK (enum value: 1)

Erwartete Ausgabe (switch-Beispiel)

enums_switch_expected_output.txt

Handling status: UNKNOWN - Default state
Handling status: OK - Operation successful
Handling status: ERROR - Operation failed
Handling status: BUSY - System busy

Handling status: UNKNOWN - Default state
Handling status: OK - Operation successful
Handling status: ERROR - Operation failed
Handling status: BUSY - System busy

Weitere NanoPB-Beiträge

Check out similar posts by category: Embedded, C/C++, Protocol Buffers

If this post helped you, please consider buying me a coffee or donating via PayPal to support research & publishing of new posts on TechOverflow

Buy me a coffee