Bonjour à tous,
Je voudrais commencer par expliquer de quoi se compose un message CAN et ce que l’on peut faire avec.
Voici l’ensemble du protocole Marklin
cs2can-protokoll-2_0 fr.pdf (982,0 Ko)
Je n’aborde pas du tout pour l’instant l’aspect matériel et réglages du matériel. C’est une procédure qui, quand on l’a faite une fois, relève du copié-collé.
Un message CAN peut être compris comme un ordre, une commande. C’est une succession de bits envoyés à n’importe quel équipement mais pour Marklin, il s’agit essentiellement des centrales, MS2 ou CSx.
Un message CAN est toujours composé d’un identifiant qui est envoyé en premier (bits de poids fort du message à gauche). Dans le protocole de Marklin, l’identifiant est toujours de 29 bits. Voici par exemple comment est constitué une trame CAN pour envoyer une commande de traction à une locomotive. C’est le § 3.4 page 43 de la documentation jointe.
Sur la partie gauche, nous avons la priorité du message sur 4 bits. J’ai toujours vu jusqu’ici que les priorités pour Marklin sont toujours à 0 (priorité la plus élevée).
A suivre, le type de commande à exécuter. On trouve dans la documentation de Marklin que la commande de traction est 4 (0x04 en Hexadécimal). Cette commande occupant 8 bits, en mode binaire, cela s’écrit 00001000
Le bit suivant vers la droite distingue si le message est une commande (bit à 0), ce qui sera toujours le cas surtout au début ou la réponse (confirmation de réception d’une commande) auquel cas le bit sera positionné à 1
Donc l’identifiant (ID) de notre message de commande de traction commence à avoir cette tête : 0000 00001000 0
Pour l’identifiant, il ne nous reste plus qu’à renseigner ce que Marklin appelle le Hash, c’est-à-dire l’identifiant unique de l’appareil qui envoie le message. Marklin a prévu une plage d’identifiants pour le DIY qui ne viendra pas en « collision » avec des appareils de la marque. Cette plage va de 0x1800 à 0x1BFF. Pour simplifier les choses nous allons prendre le premier disponible soit en binaire
Notre identifiant de 29 bits est donc celui-ci : 0000 00001000 0 1100000000000.
Ca peut paraitre un peu compliqué au début mais on s’y fait assez vite. D’autant que l’on va plutôt utiliser une présentation décimale : 137216
Ou mieux si on est un peu à l’aise, Hexadécimale 0x21800
Voila pour l’ID du message qui contient la commande que l’on souhaite voir se réaliser.
Les 4 bits suivant du message sont le nombre de datas sous forme d’octets (8 bits) seront envoyés dans la suite du message. Comme l’on souhaite envoyer l’adresse de la locomotive + la vitesse de la locomotive, cela correspond à la ligne basse du tableau soit 6 octets (6 X 8 bits).
Les 4 premiers octets contiennent l’adresse locale (Loc-ID) c’est-à-dire l’adresse attribuée après reconnaissance MFX. Bien souvent, le compteur commence à 1 et s’incrémente de 1 en 1. Si donc vous avez 6 locomotives, il y a de grandes chances que les adresses soient 1, 2, 3 etc… Cette valeur, prenons 3 par exemple, sera placée dans l’octets D3, c’est-à-dire le 4° octet de data en partant de la gauche. Dans l’octets D2, le 3° octet de data en partant de la gauche, on entre le code du protocole utilisé. Pour le MFX, c’est 0x40, pour le DCC 0xC0 et pour le SX 0x08.
Enfin, on renseigne dans D4 et D5 la vitesse souhaitée. Dans le protocole Marklin, la vitesse s’écrit sur 10 bits, les valeurs vont de 0 à 1000 soit de 0 à 100%. Pour l’exemple ici, nous allons pour simplifier nous limiter à une vitesse de 25% de telle manière que la valeur à envoyer 250 tienne dans un octet. Nous verrons plus tard comment entrer des valeurs supérieures.
Pour les datas, nous allons donc avoir ceci ;
Data[0] = 0 ;
Data[1] = 0 ;
Data[2] = 0x40 ; // protocole MFX
Data[3] = 0x03 ; // loc-ID de la locomotive
Data[4] = 0 ; // Octets de poids fort pour la vitesse non utilisé
Data[5] = 250 ; // Octets de poids faible pour la vitesse
Vous constatez que je peux saisir indistinctement des valeurs décimales ou Hexadécimales voire binaire.
Ceci est le principe qu’il est bien de connaitre, mais rassurez-vous, « dans la vraie vie », on ne saisit pas cela à la main. La vitesse par exemple est renseignée par le programme en fonction de la valeur lue à la sortie du potentiomètre.
Pour ne pas faire trop long, je vais terminer ici en vous montrant maintenant comment ces valeurs sont écrite dans le programme de l’Arduino.
frame.id = 0x21800;
frame.ext = true; // C’est un identifiant long sur 29 bits
frame.len = 5; // Nombre de champs de datas
frame.data[0] = 0x00; // Rien
frame.data[1] = 0x00; // Rien
frame.data[2] = 0x40; // Protocole MFX
frame.data[3] = 0x03; // Adresse loc-id de la loco
frame.data[4] = 250; // Vitesse 250 sur 1000 crans = 25%
Il ne reste plus qu’à envoyer le message sur le bus CAN.
can.tryToSend(frame);
Voilà pour ce premier jet, j’espère que ce n’est pas trop compliqué, mais ceci sert essentiellement à comprendre, A l’usage, c’est moins rébarbatif.
N’hésitez pas à me faire des retours sincères et je verrais ce que je peux faire.
Sinon, j’embraye sur la suite !
Christophe
