LOCODUINO

La bibliothèque ACAN

La bibliothèque ACAN (1)

Prise en main

Le 12 avril 2020.
Par : Jean-Luc

DIFFICULTÉ :★★☆

Rappelons rapidement que le bus CAN est particulièrement bien adapté au modélisme ferroviaire et est à la fois simple, robuste et économique. Sa mise en œuvre sur le réseau est aisée. S’agissant d’un bus, il suffit d’une simple paire de câbles torsadés pour relier les contrôleurs entre eux et étendre le réseau. On insère un nouveau contrôleur en coupant le câble existant et en le reliant au nouveau contrôleur.

En CAN, tous les appareils sont en capacité de recevoir l’ensemble des messages circulants sur le bus mais aussi de communiquer des messages à destination de tous les autres appareils. Il y a donc une économie en termes de matériel et d’infrastructure.

En contrepartie, il faut connaître et maîtriser la messagerie propre au CAN. Ce qui est l’objet de cette série d’articles.

Nous allons donc examiner la bibliothèque ACAN et notamment son incarnation pour le MCP2515 dont on trouve des modules facilement et à petit prix sur eBay ou Aliexpress [1]. Je veux parler des modules comme celui présenté à la figure 1 qui est sans doute la façon la moins chère (moins de 1€50) et la plus facile pour ajouter une interface CAN à un Arduino et je dirais même pour mettre des Arduino en réseau de manière générale. Ça sera également l’occasion de voir la façon de concevoir plusieurs petites applications exploitant le bus CAN.

Figure 1 : Module CAN

Ce module embarque un contrôleur CAN MCP2515 (U2) et un transceiver CAN TJA1050 (U1), il s’agit d’un circuit d’interface entre les niveaux logiques (0 correspond à 0V, 1 correspond à 5V) et le bus qui lui est en différentiel (0 correspond à VH - VL = 5V et 1 correspond à VH = VL). Le quartz (X1) est à 8MHz, ce qui limite la vitesse du bus à 512kbits/s.

Le MCP2515 est un contrôleur CAN qui communique avec l’Arduino via le bus SPI et une ligne d’interruption qui permet au MCP2515 de signaler à l’Arduino qu’un message vient d’arriver ou vient de partir, deux événements que l’Arduino doit prendre en charge. La connexion à l’Arduino est simple et est donnée à la table 1 et la figure 2 ci-dessous.

Table 1 : Connexion à l’Arduino du module CAN

Broche du module	Nom de la broche Arduino	Broche Uno/Nano	Broche Mega
INT	-	2 ou 3	2, 3, 18, 19, 20 ou 21
SCK	SCK	13	52
SI	MOSI	11	51
SO	MISO	12	50
CS	SS	Au choix	Au choix
GND	GND	GND	GND
VCC	5V	5V	5V

Il faut noter que ce module CAN n’est pas adapté aux Arduino alimentés en 3,3V car le bus est alimenté par la même tension que le contrôleur et il est préférable d’avoir une tension de 5V sur le bus, d’autant plus que la documentation du TJA1050 recommande une tension comprise entre 4,75V et 5,25V.

Figure 2 : Connexions entre l’Arduino Uno et le module CAN

Ici, le CS est sur la broche 10 et INT sur la broche 2.

Pour ce premier article et pour les deux premiers programmes, un seul Uno et un seul module CAN suffisent car nous allons exploiter la capacité des contrôleurs CAN à recevoir ce qu’ils émettent, le loopback. Ceci permet de jouer avec le bus CAN sans déployer effectivement un réseau. En revanche, pour la dernière application de cet article ainsi que pour celles proposées dans les articles suivants, il vous faudra disposer de deux modules CAN et deux Arduino, voire 3 pour certains. Le bus en lui même est constitué de deux fils que l’on vissera dans le bornier du module en reliant les H aux H et les L aux L entre les modules CAN et en constituant une chaine. Les deux modules situés aux extrémités de cette chaine reçoivent un cavalier sur le connecteur J1 afin de mettre en œuvre les résistances de terminaison de 120Ω. Ces résistances servent à empêcher la réflexion du signal à l’extrémité de la ligne.

Démarrage rapide

Venons en a la bibliothèque ACAN, écrite par Pierre Molinaro, et plus précisément l’ACAN2515. La première étape est de l’installer. Comme elle est disponible dans le gestionnaire de bibliothèque, l’installation est très simple. Ouvrez le gestionnaire et tapez « ACAN » dans la case de recherche, identifiez celle pour le 2515 puis cliquez « installer ». On peut également la télécharger sur github.

Premier programme

Le premier programme ne nécessite donc qu’un seul Arduino Uno et un module MCP2515. Nous allons exploiter la capacité du MCP2515 de recevoir ce qu’il émet et par conséquent notre programme va donc à la fois émettre et recevoir. Le message que nous envoyons ne contient aucune donnée.

Tout d’abord il faut procéder à quelques déclarations en commençant par l’inclusion de la bibliothèque.

#include <ACAN2515Settings.h> /* Pour les reglages  */
#include <ACAN2515.h>         /* Pour le controleur */
#include <CANMessage.h>       /* Pour les messages  */

Il faut ensuite décider des broches pour le CS et l’INT. Ici nous avons choisi les broches 10 [2] et 2. Pour la broche INT, il est impératif qu’il s’agisse d’une broche d’interruption externe, la table 1 donne les broches valides.

static const uint8_t MCP2515_CS  = 10;
static const uint8_t MCP2515_INT = 2;

Un objet de type ACAN2515 est instancié pour gérer le MCP2515, les arguments pour le construire sont la broche du CS, le SPI utilisé [3] et la broche INT.

ACAN2515 controleurCAN(MCP2515_CS, SPI, MCP2515_INT);

Tant qu’à faire, et comme il est toujours préférable de déclarer des constantes pour les valeurs numériques plutôt que de les noyer dans le code en dur, on déclare la fréquence du quartz du MCP2515, ici 8MHz et la fréquence du bus, ici 125kb/s. La fréquence du bus est choisie de manière parfaitement arbitraire et peut être différente sans excéder 512kb/s avec un quartz à 8MHz.

static const uint32_t FREQUENCE_DU_QUARTZ = 8ul * 1000ul * 1000ul;
static const uint32_t FREQUENCE_DU_BUS_CAN = 125ul * 1000ul;

Il y a ici une subtilité qui demande quelques explications.

 

Pourquoi les constantes ci-dessus sont-elles suffixées par ul ?

 

Sur un Arduino à base d’AVR, donc un microcontrôleur 8 bits, les entiers font 16 bits, y compris lorsqu’ils sont spécifiés sous forme littérale. Par conséquent écrire 125 * 1000 fait que le compilateur calcule cette multiplication sur 16 bits car 125 et 1000 sont tous deux des entiers 16 bits. Or 125000 est trop grand pour être codé sur 16 bits et la valeur serait fausse. Le ul indique au compilateur que ces constantes sont des entiers 32 bits non signés et le calcul est juste.

On pourra trouver curieux d’avoir besoin d’une fréquence pour un bus qui ne sert à rien puisque nous somme en loopback mais cette fréquence est nécessaire pour initialiser le contrôleur CAN.

Enfin, deux messages, l’un pour l’émission et l’autre pour la réception.

CANMessage messageCANEmission;
CANMessage messageCANReception;

C’est tout pour les déclarations. Passons maintenant à setup où nous allons initialiser le MCP2515. Tout d’abord, il faut démarrer le SPI. En effet, la bibliothèque ACAN ne le fait pas elle même car le SPI peut être utilisé par plusieurs dispositifs et les bibliothèques conçus pour ces dispositifs feraient des initialisations redondantes du SPI. La connexion série est également démarrée pour pouvoir afficher des informations.

void setup()
{
  SPI.begin();
  Serial.begin(115200);

Ensuite, on construit un objet de type ACAN2515Settings qui permet de fixer les paramètres de fonctionnement. Le constructeur de cet objet prend ici comme arguments la fréquence du quartz et la fréquence du bus. Appelons cet objet configuration.

ACAN2515Settings configuration(FREQUENCE_DU_QUARTZ, FREQUENCE_DU_BUS_CAN);

Il faut ensuite se mettre en mode de fonctionnement loopback.

configuration.mRequestedMode = ACAN2515Settings::LoopBackMode;

Puis démarrer le contrôleur CAN. Le premier argument est la configuration que l’on vient de construire et le second une fonction qui prend en charge l’interruption du contrôleur. ACAN s’occupe presque de tout et cette fonction est toujours l’appel de la méthode isr() du contrôleur. Ici nous utilisons une syntaxe particulière appelée closure qui permet d’insérer au vol le contenu de la fonction et de la passer comme argument.

const uint32_t codeErreur = controleurCAN.begin(configuration, [] { controleurCAN.isr(); });

codeErreur sera différent de 0 si un problème est survenu. Il convient donc de se bloquer dans ce cas, ce que fait le while(1);.

  if (codeErreur != 0) {
    Serial.print("Erreur : 0x");
    Serial.println(codeErreur, HEX);
    while (1);
  }
  else {
    Serial.println("OK !");
  }
}

Voilà, le CAN est prêt à fonctionner. Il faut ensuite, dans loop(), l’exploiter. Commençons par traiter la réception.

void loop()
{
  if (controleurCAN.receive(messageCANReception)) {
    /* Message recu */
    Serial.println("recu !");
  }

receive prend comme argument le message CAN destination. Il retourne true si un message est arrivé et a été copié dans le message CAN passé en argument et false sinon et, dans ce cas, le message passé en argument n’est pas modifié.

Enfin, l’envoi se fait toutes les 2 secondes, nous avons donc une variable permettant de mémoriser la date d’un envoi et une donnant un numéro d’ordre pour l’affichage.

  static uint32_t dateDenvoi = 0;
  static uint32_t compte = 0;

Puis l’envoi en lui-même.

  uint32_t dateCourante = millis();
  if (dateCourante - dateDenvoi >= 2000) {
    if (controleurCAN.tryToSend(messageCANEmission)) {
      Serial.print("envoi ");
      Serial.println(compte++);
      dateDenvoi = dateCourante;
    }
  }
}

tryToSend effectue l’envoi du message et retourne true en cas de succès. L’envoi peut échouer parce que la file d’attente d’émission est pleine. Dans ce cas, tryToSend retourne false.

Le code complet de ce premier programme est téléchargeable ci-dessous.

Second programme, ajoutons une donnée

Tout cela est très bien, mais le but de la communication est de véhiculer de l’information. Il faut donc pouvoir envoyer des messages comportant des données. Un message CAN peut inclure au maximum 8 octets de données.

La classe CANMessage

Nous avons jusqu’ici utilisé des objets de type CANMessage mais sans détailler ce que l’on y trouve. Cette classe regroupe tous les attributs d’un message :

• id : l’identifiant sur 11 ou 29 bits selon que le message est standard ou étendu. id est initialisé à 0 ;
• ext : un booléen qui est à false pour une trame standard et à true pour une trame étendue. ext est initialisé à false ;
• rtr : un booléen qui est à false pour un message de données et à true pour un message remote [4]. rtr est initialisé à false ;
• len : un entier qui est le nombre d’octets de données du message. len est initialisé à 0 ;
• data : un tableau de 8 octets non signés, donc de data[0] à data[7] qui est également accessible en tant que tableau de 4 mots de 16 bits non signés via data16[0] à data16[3], en temps que tableau de deux mots de 32 bits non signés via data32[0] et data32[1] et enfin en tant qu’entier de 64 bits non signé via data64. Tous les éléments du tableau data sont initialisés à 0.

Le programme avec loopback sans donnée est modifié pour envoyer la variable compte. Tout d’abord, compte est un entier de 32 bits, donc occupant 4 octets. La longueur du message messageCANEmission est donc renseignées en conséquence à la fin de loop().

messageCANEmission.len = 4;

Il suffit ensuite, au moment de l’envoi du message de placer compte dans data32[0], ligne 3 dans la portion de code qui suit.

  uint32_t dateCourante = millis();
  if (dateCourante - dateDenvoi >= 2000) {
    messageCANEmission.data32[0] = compte;
    if (controleurCAN.tryToSend(messageCANEmission)) {
      Serial.print("envoi ");
      Serial.println(compte++);
      dateDenvoi = dateCourante;
    }
  }

En ce qui concerne la réception, il suffit de récupérer la donnée et la longueur et d’afficher le tout.

  if (controleurCAN.receive(messageCANReception)) {
    Serial.print("recu : ");
    Serial.print(messageCANReception.data32[0]);
    Serial.print(", longueur : ");
    Serial.println(messageCANReception.len);
  }

Le code complet est disponible en téléchargement ci-dessous.

Du concret

Terminé pour le loopback, passons à des choses plus concrètes. L’application que je vous propose d’examiner nécessite 2 Arduino et 2 modules CAN. Sur le premier Arduino nous mettons deux boutons poussoir et sur le second 2 LED. Un bouton est associé à une LED et appuyer sur le bouton change l’état de la LED correspondante via, bien entendu, un message CAN. La figure 3 donne les connexions à réaliser.

Figure 3 : Connexion de l’émetteur et du récepteur via le bus CAN

Les connecteurs J1 des modules CAN doivent recevoir un strap.

La base de départ est le programme 2 en séparant la réception de l’émission. L’émission prend place sur le premier Arduino et la réception sur le second. Par conséquent le CANMessage messageCANEmission; se retrouve dans le programme de l’émetteur et le CANMessage messageCANReception; se retrouve dans le programme du récepteur.

L’émetteur

Comme il s’agit de transmettre un numéro de LED, 0 ou 1, 1 octet de données suffira. Il nous faut également gérer nos deux boutons poussoir. Pour cela, nous utilisons la bibliothèque Bounce2 qui permet de mettre en œuvre un anti-rebond et de gérer les boutons simplement. Les deux boutons sont connectés sur les broches 3 et 4 et deux objets Bounce. Le plus simple est d’utiliser des tableaux.

static const uint8_t NB_BOUTONS = 2;
static const uint8_t brocheBouton[NB_BOUTONS] = { 3, 4 };
Bounce poussoir[NB_BOUTONS];

Dans setup(), les broches sont programmées et attachées aux objets Bounce et la taille de données du message est fixée.

  for (uint8_t bouton = 0; bouton < NB_BOUTONS; bouton++) {
    pinMode(brocheBouton[bouton], INPUT_PULLUP);
    poussoir[bouton].attach(brocheBouton[bouton]);
  }

  messageCANEmission.len = 1;

Dans loop(), les deux boutons sont lus et si l’un d’entre eux ou les deux sont pressés, le message correspondant est envoyé.

  for (uint8_t bouton = 0; bouton < NB_BOUTONS; bouton++) {
    poussoir[bouton].update();

    if (poussoir[bouton].fell()) {
      messageCANEmission.data[0] = bouton;
      const bool ok = controleurCAN.tryToSend(messageCANEmission);
      if (ok) {
        Serial.print("message ");
        Serial.print(bouton);
        Serial.println(" envoye !");
      }
    }
  }

Le récepteur

Du côté du récepteur, il faut gérer 2 LED, ce qui est très simple. Tout d’abord les deux broches sont déclarées.

static const uint8_t NB_LED = 2;
const uint8_t brocheLED[NB_LED] = { 3, 4 };

Dans setup(), les deux broches sont programmées en sortie.

  for (uint8_t led = 0; led < NB_LED; led++) {
    pinMode(brocheLED[led], OUTPUT);
  }

Enfin, dans loop() le message est reçu, la donnée est extraite et l’état de la LED correspondante est changé.

  if (controleurCAN.receive(messageCANReception)) {
    /* Un message CAN est arrive */
    static uint32_t numero = 0;
    controleurCAN.receive(messageCANReception) ;
    Serial.print("Recepteur: ");
    Serial.print(++numero);
    Serial.print(" message recu : ") ;
    Serial.println(messageCANReception.data[0]);
    /* l'etat de la LED correspondante est change */
    const uint8_t led = messageCANReception.data[0];
    if (led < NB_LED) {
      digitalWrite(brocheLED[led], !digitalRead(brocheLED[led]));
    }
    else {
      Serial.println("donnee incorrecte");
    }
  }

Les deux programmes sont téléchargeables ci-dessous.

La prochaine fois nous verrons l’usage des identifiants et des filtres sur des applications de commande de dispositifs, LEDs, servo-moteurs, via le bus CAN.

35 Messages

• La bibliothèque ACAN (1) 12 avril 2020 18:07, par Jerome

  Bonjour

  Je n’ai pas encore lu, Jean Luc

  Mais Merci beaucoup !!

  signé : le "membre du forum" concerné :)

  Répondre

• La bibliothèque ACAN (1) 13 avril 2020 18:18, par jean

  Ah que ces choses sont clairement dites, félicitations :-)

  petite typo dans Configuration, l’IDE n’aime pas la FRENQUENCE

  Répondre

  • La bibliothèque ACAN (1) 15 avril 2020 18:30, par Jean-Luc

    C’est corrigé, merci :-)

    Répondre

• La bibliothèque ACAN (1) 14 avril 2020 12:51, par DDEFF

  Merci Jean-Luc,

  Voilà l’article clair et très détaillé que j’attendais.
  Peut-on envisager une bibliothèque du même genre si on a des sorties directes CAN (Arduino DUE, ESP32) ? Je sais, c’est un peu prématuré...

  Denis

  Répondre

  • La bibliothèque ACAN (1) 15 avril 2020 09:24, par bobyAndCo

     

    Bonjour Denis,

     

    Pour que les choses soient claires pour tout le monde, tu parles de cartes qui disposent déjà d’un contrôleur CAN d’origine mais il faudra de toutes les façons y ajoute un transceiver extérieur pour pouvoir constituer l’infrastructure matérielle nécessaire pour le CAN.

     

    C’est ce que l’on voit sur cette photo avec un ESP32 et un transceiver CJMCV230.

     

    

     

    Il suffit, pourrait on dire, de relier les broches CAN TX et CAN RX de l’ESP32 ( D5 et D4 ) au RX et au TX du transceiver. Par ailleurs, les deux cartes fonctionnant sous 3,3V, il n’y a pas à se préoccuper de conversion de courant.

     

    Mais la bibliothèque que présente ici Jean-Luc ne fonctionne qu’avec un MCP2515 et ce n’est pas ce qui équipe d’origine un ESP32 (je ne sais pas pour le DUE).

     

    Cette bibliothèque ACAN2515 peut être utilisée sur un ESP32 si l’on utilise une carte extérieure avec un contrôleur MCP2515 et un transceiver via le bus SPI. Donc une configuration matérielle comme présentée ci-dessus par Jean-Luc.

     

    On peut peut-être regretter de ne pas pouvoir tirer profit du contrôleur déjà existant sur l’ESP32. Mais d’un autre côté, renvoyer l’ensemble des traitements sur une carte extérieure n’est t’il pas un moyen de soulager l’ESP32 de certains traitements ?

     

    Mais il existent aussi des bibliothèques qui utilisent le contrôleur de l’ESP32 comme la bibliothèque ESP32CAN. Sans doute moins abouties que l’ACAN2515 présentée ici mais que j’ai moi-même testée et qui fonctionne bien..

     

    Christophe

    Répondre

  • La bibliothèque ACAN (1) 15 avril 2020 18:55, par Jean-Luc

    ACAN existe également pour les Teensy et pour le MCP2717/MCP2518. Mon petit doigt me dit qu’elle pourrait venir pour les STM32. Pour l’ESP32, c’est un peu compliqué car dans le manuel il n’y a pas de trace du contrôleur CAN excepté dans les vecteurs d’interruption. Il y a par contre des fonctions fournies dans le kit de dev d’ESPRESSIF mais elles ne sont pas intégrées dans arduino-esp32. À priori l’ESP32 intègre un contrôleur compatible avec le SJA1000 (NXP ex Phillips). Les codes exemples existants semble avoir été faits plus ou moins à partir de la datasheet du SJA1000 et par reverse engineering.

    • http://www.barth-dev.de/can-driver-...
    • https://github.com/eerimoq/simba/tr...

    Répondre

• La bibliothèque ACAN (1) 15 avril 2020 10:17, par DDEFF

  Merci Christophe,
   
  J’avais bien compris que la bibliothèque décrite dans cet article ne fonctionne qu’avec un MCP2515. On est bien d’accord. D’ailleurs, elle s’appelle bien ACAN2515 et ce n’est pas pour rien.
   
  Par ailleurs, soulager l’ESP32 ne peut que lui faire du bien. Je suis d’accord aussi, évidemment.
   
  Mon raisonnement, c’est que, de toutes façons, il faudra une bibliothèque spécifique pour l’ESP32.
  Ce qui serait bien, c’est qu’elle ait les mêmes commandes que l’ACAN2515.
   
  En attendant, on utilise les bibliothèques existantes pour l’ESP32.
  Il n’est vraiment pas urgent de développer une bibliothèque spécifique. On a largement de quoi s’occuper d’ici là...
   
  Denis

  Répondre

  • La bibliothèque ACAN (1) 15 avril 2020 10:30, par bobyAndCo

    Non justement, je me suis sans doute mal exprimé mais il n’y a pas besoin de bibliothèque spécifique pour l’ESP32. ACAN2515 fait parfaitement le boulot sur ESP32 à condition d’avoir un MCP2515 !!!

    Répondre

    • La bibliothèque ACAN (1) 15 avril 2020 10:41, par DDEFF

      Pour voir si j’ai bien compris : il faudrait (plus tard, si on a le temps...) une bibliothèque "ACANCJMCV230".

      Répondre

      • La bibliothèque ACAN (1) 15 avril 2020 23:03, par Dominique

        Et ben on peut dire que tu n’as pas compris, j’essaye d’expliquer :
        Pour communiquer en protocole CAN il faut 2 composants : le contrôleur CAN (par exemple le MCP2515 ou 2517/2518) ET le driver de ligne, c’est à dire un bête ampli de courant pour sortir et un ampli différentiel en entrée, par exemple le MCP2551 en 5V ou le SN65HVD230 en 3,3V, sur le module module CJMCU-230 utilisé avec le Due ou l’ESP32).
        Ce driver de ligne n’a pas besoin d’une bibliothèque car ce n’est pas un contrôleur CAN ! C’est le contrôleur CAN qui en a besoin.
        Donc comme l’ESP32 (et le Due) ont leur propre contrôleur intégré, ils ont besoin de leur bibliothèque CAN propre. Ou alors, comme le dit Christophe, il faut s’en passer et brancher un MCP 2515/17/18 à l’extérieur et alors on peut utiliser la bibliothèque ACAN2515 via le port SPI.

        Répondre

        • La bibliothèque ACAN (1) 16 avril 2020 20:07, par Jean-Luc

          A l’examen de la discussion, j’ai plutôt l’impression que c’est Christophe et toi qui ne comprenez pas ce que veux dire Denis 😃. Il voudrait une bibliothèque CAN pour le contrôleur intégré à l’ESP32 qui ait l’API de ACAN.

          Répondre

          • La bibliothèque ACAN (1) 16 avril 2020 20:58, par DDEFF

            Merci Jean-Luc.
            Je n’ai, certes, pas employé les bons termes, mais c’est ça l’idée.
            Qu’on soit dans l’ESP32 ou dans un satellite/module, qu’on emploie les mêmes commandes.
            Mais ça a l’air dur.
            Denis

            Répondre

• La bibliothèque ACAN (1) 16 avril 2020 18:29, par Jerome

  Bonjour

  Voici les caractéristiques de mon module CAN de marque JoyIT

  Puce : MCP2515, TJA1050
  Spécification : CAN V2.0B
  Vitesse de communication : 1 Mb/s
  Oscillateur : oscillateur à quartz 16 MHz
  Résistance de terminaison : 120 ohms avec adaptation d’impédance
  Interface : SPI, CAN
  Tension d’entrée : 5 V
  Consommation d’énergie : 5 mA
  Courant de service : 1 µA
  Température de service : -40 ... 85 °C

  Ils fonctionnent correctement avec les exemples de Mise en oeuvre du Bus CAN entre modules Arduino
  qui utilise la bibliothèque mcp-can.h.

  Avec la bibliothèque ACAN cela ne fonctionne pas, des le programme loopback sans donnée :
  Voici le message d’erreur : Configuration du MCP2515 erreur : 0x1

  J’essaie de modifier les fréquences du quartz en 16 et la vitesse en 1000 mais .. cela ne marche pas non plus.
  Pourquoi ?

  Répondre

  • La bibliothèque ACAN (1) 16 avril 2020 18:30, par Jerome

    Laisser des lignes vides ne permet pas d’aérer le texte :)

    Répondre

    • La bibliothèque ACAN (1) 16 avril 2020 19:14, par Jerome

      Re bonjour
       
      Je me réponds à moi-même, cela pourra peut-être aider d’autres débutants.
       
      Pour faire fonctionner ces modules avec la bibliothèque ACAN, il faut relier les broches vcc ET vcc1 au 5v. Alors que ce n’est pas nécessaire avec la bibliothèque mcp-can.
       
      Je n’ai pas compris pourquoi. Mais c’est indiqué dans le mode d’emploi du module :) .
       
      Lors des tests précédents, avec la mcp-can, j’avais bien suivi ces prérogatives, mais j’avais aussi trouvé que brancher ces deux pins, n’était pas nécessaire, donc j avais enlevé le fil du vcc1 :) et réalisé mes branchements fixes en conséquences.
       
      Scrongneugneu maintenant il me manque un fil !
       
      Et j’ai aussi trouvé comment aerer mes messages :)

      Répondre

      • La bibliothèque ACAN (1) 16 avril 2020 19:26, par Jerome

        Et c’est dommage de ne pouvoir éditer .
         
        En fait, ne brancher que la vcc sur le 5 v semble fonctionner..
         
        Ce n’est pas le vcc1 que j’avais enlevé mais le vcc tout court :(

        Répondre

        • La bibliothèque ACAN (1) 16 avril 2020 19:53, par Jean-Luc

          Bonsoir.
          bon je vais vous répondre quand même. Votre description du module joy it, ainsi que leur page web d’ailleurs, est fausse. Le transceiver n’est pas un TJA1050 mais un MCP2562. On le voit tout à fait sur la photo à gauche de leur description erronée.

          

          Ce transceiver est bi-tension, une pour la logique et, sur cette carte, pour le MCP2515 et une pour le bus. Dans la doc, on voit que VCC est l’alimentation pour la logique (5V sur un Uno, 3,3V sur un RPi ou un ESP) et VCC1 est l’alimentation pour le bus (toujours 5V).

           

          Par conséquent, laisser VCC1 non connecté n’est pas bon pour le 2562 (oui, un circuit non alimenté n’apprécie pas que ses entrées soient à une tension quelconque) d’une part et ne permettra pas de faire autre chose que du loop back d’autre part !

          Répondre

          • La bibliothèque ACAN (1) 16 avril 2020 21:29, par Jerome

            Merci jean luc

            En effet , cela ne fonctionne pas avec le programme suivant, celui avec les deux Arduino.
             
            J’espère ne rien avoir grillé.

            Encore merci

            Jerome

            Répondre

            • La bibliothèque ACAN (1) 17 avril 2020 20:00, par Jerome

              Bonsoir
              .
              Juste un petit message pour confirmer que tout fonctionne.
              Y compris le programme avec les 2 Arduino.
              Il suffisait de lire et d’appliquer le mode d’emploi.
              .
              A ce stade, j’ai encore plein de questions .
              Mais je les garde pour plus tard, si les futurs articles attendus avec impatience n’y répondent pas avant
              Et ce sera sur le forum.
              .
              Jerome, assez confus de ne pas avoir trouvé tout seul.
              Je n’étais pourtant pas loin, mais j’ai cumulé :
              En plus de ce problème de vcc, le fil de connexion sur l’int était brisé . :)

              Répondre

• La bibliothèque ACAN (1) 16 avril 2020 19:15, par Didier44

  Merci Jean Luc pour cette approche très didactique.. comme d’habitude !
  Je suis en plein dans le traitement de signaux CAN (UNO et ESP32) et tes précisions vont m’être très utile.
  Didier

  Répondre

  • La bibliothèque ACAN (1) 16 avril 2020 20:23, par Jean-Luc

    Merci Didier 😉

    Répondre

• La bibliothèque ACAN (1) 16 avril 2020 21:37, par jeelet

  oui VCC et VCC1 les relier... et un strap c pas bon, j’ai griller une carte hier.
  (sûrement mauvais contact ??)
   
  sinon les exemples de la lib. ACAN2515 tourne bien.
   
  et un big bravo, super Tuto sur le CAN .... la suite la suite.
   
  https://nsm09.casimages.com/img/202...

  Répondre

• La bibliothèque ACAN (1) 12 mai 2020 22:11, par Hervé BLOREc

  Bonsoir,

  D’abord un grand merci à Jean -Luc pour toutes ces explications claires et ordonnées qui me sont d’un grand recours.
  je n’arrive pas à charger les fichiers zip, y aurait-il un pb
  Merci
  Cdt

  Répondre

  • La bibliothèque ACAN (1) 13 mai 2020 00:07, par Jean-Luc

    Bonsoir,
    Merci !
    Il y avait un problème, c’est corrigé.

    Répondre

• La bibliothèque ACAN (1) 15 juillet 2020 17:51, par Philippe S

  Bonjour Jean-Luc,

  Me voilà à fond sur les deux articles ACAN et je reprends à mon compte ce qui a été dit, c’est pédagogique, bien progressif, tout est bien amené, super bien présenté en plus, accompagné de sketchs de mise en pratique commentés. Quel énorme boulot !!!

  C’est donc clair et net... mais avec une petite bavure je crois dans les explications du deuxième exemple :

  La longueur du message messageCANEmission est donc renseignées en conséquence à la fin de loop()

  En réalité il faut lire qu’elle est renseignée à la fin du setup().

  Grands merci et bravos

  Répondre

• La bibliothèque ACAN (1) 9 septembre 2021 16:58, par tony04

  Bonjour Jean-Luc,

  après plusieurs années de fidélité à la librairie mcp-can, je me décide enfin à tester cette petite merveille tant appréciée semble-t-il.

  J’utilise les modules classiques comme dans tes exemples et avec une vitesse de BUS de 125KHz tout se passe bien.

  Mais dès que je passe à 256 ou à 512KHz je me retrouve avec le code erreur 2. Pourtant toutes mes cartes fonctionnent en 512KHz avec l’ancienne librairie.

  Faut-il changer autre chose que la constante FREQUENCE_DU_QUARTZ ?

  Merci par avance pour ta réponse et félicitations pour ce magnifique tutoriel.

  Bien cordialement
  Antoine

  Répondre

  • La bibliothèque ACAN (1) 9 septembre 2021 18:24, par msport

    Bonjour Antoine,

    on s’intéresse aussi à ACAN ?
    Sur quel contrôleur l’installes tu ?
    As tu l’erreur après :
    if (Can0.begin(CAN_BPS_500K)) ?
    qui fonctionne avec ACAN_ESP32 sur ESP32 bien sur.

    Cordialement

    Répondre

    • La bibliothèque ACAN (1) 10 septembre 2021 09:03, par tony04

      Hé oui, il ne faut pas rester à la traine...

      J’ai fait mes essais avec un MEGA d’un coté et un NANO de l’autre.
      Je n’ai pas cette instruction "if (Can0.begin(CAN_BPS_500K))", j’ai le message "Problème de connexion" avec un code 2.

      J’ai utilisé ton exemple 2 émetteurs 1 récepteur pour mes essais.

      Répondre

• La bibliothèque ACAN (1) 20 février 2022 16:02, par Jeanmi67

  Bonjour,

  Pour connecter deux cartes Arduino qui doivent échanger des informations sur mon réseau, j’étais parti de votre exemple "2-boutons-2-leds" et ça fonctionnait très bien.
  Ayant eu besoin ponctuellement de récupérer la carte Nano "Emetteur" pour autre chose, j’essaie maintenant de réinstaller le programme "Emetteur" sur cette même carte Nano. Problème : il y a eu entre temps une mise à jour de la librairie ACAN2515 et un des éléments de celle-ci (ACANBuffer16.h) qui est appelé dans le programme n’existe plus :-(.

  /*
   * Inclusions pour acan2515
   */
  #include <ACANBuffer16.h>
  #include <ACANBuffer.h>
  #include <ACAN2515Settings.h>
  #include <ACAN2515.h>
  #include <CANMessage.h>

  Ayant une sauvegarde de ce fichier, je l’ai copié dans le répertoire de la librairie ACAN2515, la compilation ne plante plus, mais le programme reste bloqué sur "Probleme de connexion".
  Comment puis-je retrouver ce BUS CAN fonctionnel ?

  Merci :-)
  Jean-Michel

  Répondre

• La bibliothèque ACAN (1) 20 février 2022 16:45, par msport

  ... mais je vois un ACAN2515_Buffer16.h : adaptation du programme à faire ?

  Répondre

  • La bibliothèque ACAN (1) 20 février 2022 20:29, par Jeanmi67

    ... Effectivement, simplement en modifiant le nom de la librairie appelée dans le programme, tout refonctionne !
    L’erreur "Probleme de connexion" était simplement due à un câble déconnecté problablement lors des manipulations de l’Arduino.
    Merci :-)

    Répondre

• La bibliothèque ACAN (1) 18 avril 2022 12:23, par JeeLet

  Bonjour les anciens

  comprend le changement sur la modif de "ACAN2515_Buffer16.h" ??
  j’ai "No such file or directory" à la compilation :(

  sur https://github.com/pierremolinaro/a...
  je trouve pas de changement !
  une piste ????

  Merci

  Répondre

• La bibliothèque ACAN (1) 18 avril 2022 12:57, par JeeLet

  ... oui suis grave de grave :) ;(

  renommer ACANBuffer16.h en ACAN2515_Buffer16.h est c’est bon !

  voili voila , histoire de vous dire Bonjour quoi.

  Répondre

• La bibliothèque ACAN (1) 22 septembre 2023 18:56, par Phenixpopol

  Je me suis donc lancé dans le locoduinodrome en commençant par le bus CAN.
  J’utilise un arduino UNO R3 qui n’est pas un clone et 2 HailegeMCP2515 CAN bus module TJA 1050 Receiver SPI for Arduino AVR.
  J’ai les mêmes problèmes que Jérome (cf ci-dessus). Dans le programme loopback avec donnees j’ai le même message d’erreur « Erreur 0x1 ».
  J’ai réalisé le programme ’application de commande deux LED via le bus CAN « J’ai le message d’erreur « probleme de connexion » sur les deux arduino. J’ai corrigé la bibliothèque :
  #include <ACAN2515_Buffer16.h>
  #include <ACANBuffer.h>
  #include <ACAN2515Settings.h>
  Mais les deux premières lignes n’apparaissent pas en rouge. Elles sont pourtant bien dans le dossier bibliothèque de ACAN2515.
  J’ai vérifié et revérifié toutes mes connexions. J’ai ponté J1.
  Toujours idem

  Répondre

  • La bibliothèque ACAN (1) 28 septembre 2023 17:14, par Phenixpopol

    Bonjour et merci à Pierre Molinaro qui m’a répondu car cela fait plusieurs jours que je cherchais l’erreur. J’avais beau refaire les connexions !!

    En fait, je n’avais pas remarqué que SO et SI se croisent entre Arduino et le module (pourtant visible sur l’illustration de locoduino) ; J’avais fait une tresse de 4 fils et je ne vérifiais que les extrémités.
    Les premiers essais marchent avec une fréquence à 8 MgH.

    Répondre

Réagissez à « La bibliothèque ACAN (1) »

Bibliothèque Accessories (1)

Bibliothèque Accessories (2)

Un décodeur d’accessoires universel (1)

Un décodeur d’accessoires universel (2)

Un décodeur d’accessoires universel (3)

Bibliothèque LcdUi (1)

Bibliothèque LcdUi (2)

Bibliothèque LightEffect

La bibliothèque ACAN (2)

La bibliothèque ACAN (1)

Bibliothèque DcDccNanoController

Bibliothèque DCCpp

Bibliothèque Commanders

La bibliothèque SlowMotionServo

Bibliothèque EEPROMextent

Bibliothèque MemoryUsage

La bibliothèque ScheduleTable

Bibliothèque LCD

Bibliothèque Wire : I2C

Bibliothèque EEPROM

Bibliothèque Serial

Bibliothèque SoftWare Serial

La bibliothèque Servo

Bibliothèque LightEffect

14 octobre 2020
Christian

La bibliothèque ACAN (2)

4 mai 2020
Jean-Luc

La bibliothèque ACAN (1)

12 avril 2020
Jean-Luc

La bibliothèque SlowMotionServo

3 mars 2018
Jean-Luc

Bibliothèque DCCpp

24 décembre 2017
Thierry

Bibliothèque DcDccNanoController

1er octobre 2017
Thierry

Bibliothèque LcdUi (2)

27 avril 2017
Thierry

Bibliothèque LcdUi (1)

12 mars 2017
Thierry

Bibliothèque Accessories (2)

8 décembre 2016
Thierry

Bibliothèque Accessories (1)

19 novembre 2016
Thierry

Bibliothèque Wire : I2C

Bibliothèque DCCpp

La bibliothèque Servo

Un décodeur d’accessoires universel (1)

La bibliothèque ACAN (1)

Bibliothèque EEPROM

Bibliothèque SoftWare Serial

Un décodeur d’accessoires universel (2)

Un décodeur d’accessoires universel (3)

Bibliothèque DcDccNanoController