Implémentation des protocoles de communication en C / C ++

Question

Je suis en train de commencer à implémenter une pile de protocoles de communication propriétaires dans le logiciel, mais je ne sais pas par où commencer. C'est le genre de travail que je n'ai jamais fait auparavant et je cherche de l'aide en termes de ressources pour les meilleures approches / recommandées.

J'utiliserai c / c ++ et je suis libre d'utiliser des bibliothèques d'utilisation (BSD / BOOST / Apache) mais pas de GPL. J'ai beaucoup utilisé C ++, donc utiliser les fonctionnalités de C ++ n'est pas un problème.

La pile de protocoles a trois couches et elle est déjà entièrement spécifiée et formellement vérifiée. Donc, tout ce que j'ai à faire est de l'implémenter et de le tester complètement dans les langues spécifiées. Il faut également mentionner que le protocole est très simple mais peut fonctionner sur différents appareils sur une couche de transport physique fiable. Je connais les événements, les entrées, les sorties, les effets secondaires et le comportement de la ou des machines à états de protocole. En général, une interruption est reçue pour lire le message reçu de la couche physique pour le lire et l'envoyer au dispositif en attente. L'appareil récepteur peut traiter et transmettre le message de réponse à la couche de protocole pour l'envoyer sur la couche physique.

Toute aide avec des références / recommandations sera appréciée. Je suis prêt à utiliser une langue différente ne serait-ce que pour m'aider à comprendre comment les mettre en œuvre mais je devrai éventuellement recourir à la langue de mon choix.

Mise à jour: Un exemple de protocole que je souhaite implémenter est quelque chose comme SNEP .

Je n'ai pas à me soucier de la gestion des connexions. Nous pouvons supposer que la connexion est déjà établie et que le protocole le fait est un échange de données où les messages du protocole sont déjà bien définis dans les spécifications

Answer 1

Commencez par les interfaces et les messages.

Déclarez les interfaces de session qui permettent aux pairs d'échanger des messages.Déclarez les messages comme des structures C ++ avec des types simples, comme ints, doubles, std :: string et et std :: vectors.Par exemple:

// these are your protocol messages
struct HelloRequest {
    uint32_t seq_no;
    // more stuff
};
struct HelloResponse {
    uint32_t seq_no;
    // more stuff
};

// Session callback for received messages
struct SessionReceiver {
    virtual void connected(Session*) = 0;
    virtual void receive(Session* from, HelloRequest msg) = 0;
    virtual void receive(Session* from, HelloResponse msg) = 0;
    virtual void disconnected(Session*) = 0;
};

// Session interface to send messages
struct Session {
    virtual void send(HelloRequest msg) = 0;
    virtual void send(HelloResponse msg) = 0;
};

// this connects asynchronously and then calls SessionReceiver::connected() with a newly established session
struct SessionInitiator {
    virtual void connect(SessionReceiver* cb, std::string peer) = 0;
};

// this accepts connections asynchronously and then calls SessionReceiver::connected() with a newly accepted session
struct SessionAcceptor {
    virtual void listen(SessionReceiver* cb, std::string port) = 0;
};

Puis testez vos interfaces en codant la logique métier qui utilise ces interfaces.Une fois que vous êtes sûr que les interfaces vous permettent d'implémenter la logique requise, implémentez les interfaces et la sérialisation de vos messages en utilisant votre framework événementiel préféré, comme libevent ou Boost.Asio.

Modifier: Notez que les interfaces vous permettent d'avoir des implémentations simulées ou de test.De plus, le fait que la sérialisation se produit derrière l'interface signifie que pour les pairs en cours de processus, vous n'avez pas à sérialiser et désérialiser les messages, vous pouvez les transmettre tels quels.

Answer 2

Boost.ASIO est assez avancé quandil s'agit de la communication réseau asynchrone (ou synchrone) en C ++

Answer 3

Jetez un œil aux Google Protocol Buffers .

D'après la description:

Les tampons de protocole sont un mécanisme flexible, efficace et automatisé pour la sérialisation des données structurées - pensez XML, mais plus petit, plus rapide et plus simple. Vous définissez la manière dont vous souhaitez que vos données soient structurées une fois, puis vous pouvez utiliser un code source généré spécial pour écrire et lire facilement vos données structurées vers et à partir d'une variété de flux de données et en utilisant une variété de langages. Vous pouvez même mettre à jour votre structure de données sans interrompre les programmes déployés qui sont compilés avec «l'ancien» format.

Les tampons de protocole sont indépendants du langage et de la plate-forme et doivent donc s'intégrer à votre projet. Je n'ai pas trouvé la licence, mais au moins elle ne dit «GPL» nulle part que je puisse trouver.

Cela vous aidera avec les protocoles. Avec la transmission de données réelle, eh bien, à moins que vous n'écriviez vous-même le système d'exploitation, vous devriez utiliser certaines primitives. Il est difficile de donner une aide plus précise sur la mise en œuvre à moins que vous ne fournissiez un peu plus de détails. Par exemple, quel canal de communication utilisez-vous? Ethernet?

Mais en règle générale, vous devez rendre l'ISR aussi court que possible. Dans ces types de solutions, cela signifie généralement copier des données dans un tampon en anneau. De cette façon, vous n'avez pas à allouer de mémoire dans l'ISR. ISR, après avoir copié les données, doit informer les couches supérieures du paquet. Si vous pouvez utiliser DMA, utilisez-le. Dans ce cas, il peut être possible d'envoyer la notification avant même de commencer le transfert DMA.

Vous pouvez également consulter les pilotes de périphériques Linux , chapitre 10 en particulier. Découvrez la partie sur les moitiés inférieure et supérieure.