Bus CAN Qt

Un réseau CAN (Controller Area Network) est une norme de bus automobile conçue pour permettre aux microcontrôleurs et aux périphériques de communiquer entre eux dans des applications ne disposant pas d’ordinateur hôte.

Présentation

Il s'agit d'un protocole basé sur des messages, conçu à l'origine pour le câblage électrique multiplexé dans les automobiles, mais qui est également utilisé dans de nombreux autres contextes.

L'API du bus CAN fournit des interfaces communes pour accéder aux périphériques CAN :

• QCanBus fournit une API permettant de créer une instance d'QCanBusDevice à partir d'un plugin choisi.
• QCanBusDeviceInfo fournit des informations sur les périphériques CAN disponibles.
• QCanBusDevice fournit une API permettant d'accéder directement au périphérique CAN.
• QCanBusFrame définit une trame CAN pouvant être écrite et lue à partir d'QCanBusDevice.

À partir de Qt 6.5, le module fournit des API permettant de décoder les valeurs réelles des signaux à partir de trames CAN brutes, ainsi que d'encoder des données utilisateur dans des trames CAN :

• QCanSignalDescription fournit des règles pour traiter les signaux CAN.
• QCanMessageDescription fournit des règles pour traiter les messages CAN. Une description de message contient généralement plusieurs descriptions de signaux.
• QCanUniqueIdDescription fournit des règles pour traiter un identifiant unique au sein d’une trame CAN.
• QCanFrameProcessor utilise les descriptions fournies par les classes ` QCanMessageDescription`, ` QCanSignalDescription` et ` QCanUniqueIdDescription ` pour encoder ou décoder des trames CAN.
• QCanDbcFileParser fournit une API permettant d’extraire des descriptions de messages à partir de fichiers DBC.

Plug-ins de bus CAN

Plusieurs fournisseurs proposent des périphériques CAN dotés d’API d’accès variées. Le module QtSerialBus prend en charge les ensembles suivants de plugins de bus CAN :

Implémentation d’un plug-in CAN personnalisé

Si les plug-ins fournis par Qt ne sont pas adaptés à la plate-forme cible requise, il est possible d’implémenter un plug-in de bus CAN personnalisé. L’implémentation suit la procédure standard d’implémentation des plug-ins Qt. Le plug-in personnalisé doit être déployé sur $QTDIR/plugins/canbus.

Chaque plugin doit définir une clé, qui sert à charger le plugin. Cela s'effectue via un petit fichier JSON. Par exemple, le plugin socketcan utilise la clé suivante : plugin.json:

{
    "Key": "socketcan"
}

Cette clé doit être transmise à ` QCanBus::createDevice()` avec le nom de l’interface de l’adaptateur de bus CAN. ` QCanBus ` charge et instancie le plug-in à l’aide de l’interface `QCanBusFactoryV2`, que chaque plug-in doit implémenter en tant que point d’entrée central. L’interface fait office d’usine et son seul but est de renvoyer une instance de ` QCanBusDevice `. Le nom d’interface mentionné ci-dessus est transmis via la méthode ` QCanBusFactory::createDevice()` de l’usine. Voici l’implémentation de l’usine du plugin socketcan:

class SocketCanBusPlugin : public QObject, public QCanBusFactory
{
    Q_OBJECT
    Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QCanBusFactory" FILE "plugin.json")
    Q_INTERFACES(QCanBusFactory)

public:
    QList<QCanBusDeviceInfo> availableDevices(QString *errorMessage) const override
    {
        Q_UNUSED(errorMessage);
        return SocketCanBackend::interfaces();
    }

    QCanBusDevice *createDevice(const QString &interfaceName, QString *errorMessage) const override
    {
        Q_UNUSED(errorMessage);
        auto device = new SocketCanBackend(interfaceName);
        return device;
    }
};

L'étape suivante consiste à fournir une implémentation de ` QCanBusDevice`. Au minimum, les fonctions virtuelles pures suivantes doivent être implémentées :

• QCanBusDevice::open()
• QCanBusDevice::close()
• QCanBusDevice::writeFrame()
• QCanBusDevice::interpretErrorFrame()

Les méthodes ` open()` et ` close()` sont utilisées respectivement en conjonction avec ` QCanBusDevice::connectDevice()` et ` QCanBusDevice::disconnectDevice()`. Consultez la documentation des fonctions pour plus de détails sur leur implémentation.

QCanBusDevice::writeFrame() est chargée des vérifications de cohérence, telles que la validité de l'QCanBusFrame et la connexion du périphérique. Si les vérifications sont réussies, elle écrit la trame sur le bus CAN. En cas de succès, elle émet le signal QCanBusDevice::framesWritten() ; dans le cas contraire, la fonction QCanBusDevice::setError() est appelée avec un message d’erreur approprié. Cette fonction peut également être utilisée pour implémenter une opération d’écriture asynchrone. Il incombe aux développeurs du plugin d’émettre les signaux appropriés au moment opportun.

Enfin, la fonction ` QCanBusDevice::interpretErrorFrame ` offre un moyen pratique de traduire le contenu d’une trame d’erreur du bus CAN en une chaîne d’erreur lisible par l’utilisateur.