Émetteur récepteur BUS CAN piloté par Arduino Nano, schéma électronique et programme logiciel, pour apprendre l'électronique en débutant

Projet éducatif : « émetteur / récepteur BUS CAN »
(communication entre Arduino, via shield MCP2515 / TJA1050)

Qui n’a pas eu un jour envie d’utiliser le Bus CAN pour pouvoir faire dialoguer des Arduino entre eux ? Oui mais voila, les ressources en français viennent parfois à manquer, dès lors qu’il s’agit de passer à la pratique ! Pourtant, tout ceci n’est pas si compliqué à mettre en œuvre, une fois qu’on a compris quoi utiliser, et comment faire pour y arriver ! Et le but de cet article est justement de vous initier à cela. Alors c’est parti 😉

Avant de commencer, dites vous que tout ce qui est présenté ici ne sera ni parfait, ni optimisé. D’ailleurs, je ne suis ni ingénieur, ni formateur, mais simplement un passionné d’électronique ! Aussi, gardez bien cela à l’esprit : le but de cet article est avant tout éducatif. Il est partagé ici afin de vous permettre de vous familiariser avec le Bus Can, et comprendre comment pouvoir assurer le dialogue entre plusieurs Arduino, en créant son propre protocole de communication.

Je vous prie de bien vouloir m’excuser par avance si certains termes ou certaines de mes explications vous paraissent trop techniques, flous, ou pas assez étoffés. Dans tous les cas, j’essaierai d’apporter un maximum de détails, tout en essayant de rester le plus simple possible, afin de faciliter la compréhension ! Mais encore une fois : gardez bien à l’esprit qu’il s’agit là d’un projet éducatif, et que je ne suis ni un spécialiste, ni même un expert sur le sujet. Ici, j’avais juste à coeur de vous partager un exemple de communication entre arduino par Bus Can, avec des composants tout simples. J’espère donc que tout cela vous plaira, et vous servira dans vos projets à venir ! Alors en route !

1 – Le projet « Communication entre Arduino : émetteur-récepteur BUS CAN » en quelques mots …


Pour ce projet de communication entre arduino, j’ai imaginé des cartes électroniques branchées en parallèle sur un Bus Can, avec en leur coeur, un Arduino. Tout simplement ! Ainsi, au niveau schématique, cela donne quelque chose comme ça :

Schéma raccordement bus can cartes arduino, avec shield MCP2515 et TJA1050, puce nano avec débutant électronique pour apprendre comment

En synthèse, chaque carte est en fait équivalente à un arduino, muni de périphériques d’entrées / sorties (boutons poussoirs, potentiomètres, affichage, …). Ainsi, la communication entre Arduino se matérialise ici comme étant une communication entre cartes électroniques à base d’arduino.

Chacune de ces « cartes Arduino » sera construite de la même manière. Leurs circuits imprimés seront donc identiques, et seuls leurs programmes différeront. Donc sur le plan physique, on retrouvera les éléments suivants sur chacune d’elle :

  • 1 x arduino Nano
  • 1 x écran LCD 4 lignes de 20 caractères
  • 4 x boutons poussoirs
  • 4 x leds
  • 2 x potentiomètres
  • 1 x haut-parleur

Chaque carte électronique permet de symboliser une « interface homme machine », idéale pour « voir » le dialogue entre Arduino, et ainsi faire ses premiers pas avec le bus CAN, de manière plus concrète. Et ce sont les programmes chargés sur ces cartes qui définiront les bases de comportement de chaque carte : Qui parle à qui ? De quelle manière ? Qui demande quoi ? Qui répond ? Qui affiche quoi ? Qui retourne telle ou telle valeur ? etc. Comme vous l’aurez compris, les possibilités sont infinies, et on peut, au final, faire tout ce qu’on veut ! … ou presque 😉

Résumé : pour ce projet, il y aura donc plusieurs cartes électroniques raccordées en parallèle, sur un Bus CAN. Leurs circuits imprimés (PCB) seront physiquement identiques, et tous équipés des mêmes composants électroniques (afficheur, boutons poussoirs, leds, haut-parleur, …). Chaque carte aura son propre programme (logiciel sous Arduino), et pourra aussi bien « donner des ordres » à d’autres cartes, tout comme en recevoir (puisque le Bus CAN marche dans les deux sens !). Les composants figurant sur ces cartes sont pour la plupart tout ce qu’il y a de plus commun, comme l’Arduino Nano, le module Can MCP2515, ou encore l’afficheur i2c LCD (tous achetables « tout prêt » dans le commerce). Si j’ai fait ce choix ici, c’est pour faciliter l’assemblage, et la compréhension de chaque partie de ces cartes électronique, à travers une « approche modulaire » (c’est à dire « bloc par bloc », plutôt que d’avoir à comprendre une carte compliquée, où tout sera mêlé et enchevêtré).

2 – Une vidéo montrant le résultat final, pour mettre en appétit !


Afin que vous ne perdiez pas votre temps à savoir si la suite correspond ou non à ce que vous recherchez, voici une petite vidéo rapide que j’ai fait, vous montrant le résultat final du projet ! En outre, vous verrez ici :

  • le pilotage de LEDS sur une carte, depuis les BOUTONS POUSSOIRS d’une autre
  • l’affichage de VALEURS sur un écran lcd, suivant la position des curseurs des POTENTIOMETRES situés sur une autre carte

Ainsi, vous allez visualiser le résultat des infos envoyés d’un arduino à l’autre, avec des commandes telles que : « allume telle ou telle LED », « éteint moi celle-là », ou encore « affiche telle valeur sur telle ligne de ton afficheur ». Et tout ça de manière personnalisable, bien sûr, si vous modifiez le code, ou l’adaptez à vos besoin. C’est d’ailleurs toute la beauté de ce montage, dont le comportement est définit par le programme qu’il contient. Ainsi, on peut créer son propre « protocole de communication », et faire faire les actions qu’on veut, d’un arduino à l’autre. Et tout ça, simplement via les 2 fils du Bus CAN. Sympa, non ?

Sur cette vidéo, je vous ai montré ici 2 platines électroniques Arduino s’échangeant des ordres, et y répondant de manière visuelle. Bien évidemment, en pratique, on pourrait raccorder bien plus de carte que ça, car on n’est absolument pas limité à deux cartes. D’ailleurs, c’est comme ça que sont conçus les réseaux de périphériques CAN, tels qu’on en trouve en domotique (maisons « intelligentes »), ou dans l’automobile récente (« voitures communicantes » en interne). Du coup, une chose est sûre : une fois que vous aurez maîtrisé la pratique de la communication entre Arduino via Bus Can, vous verrez que les possibilités deviendront infinies. Car vous pourrez ainsi imaginer et créer tout ce qui vous passe par la tête… ou presque !

Le saviez-vous ? en mode « normal » (dit Standard), le bus can permet d’identifier jusqu’à 2032 adresses différentes sur son réseau. Cela correspond à 2048 combinaisons possibles, provenant de l’IDentifiant codé sur 11 bits (211 = 2048), auxquelles on soustrait 16 « numéros interdits ». Il y a donc 2048-16 possibilités, soit 2032 adresses (identifiants réseau) possibles, en utilisation standard. Par contre, en pratique, on est limité à un nombre inférieur de connexions sur un Bus CAN (110 nœud ici, avec la puce TJA1050). Car, au delà de ce nombre maxi de connexions, les courants devant être mis en œuvre pour assurer le bon fonctionnement normal seraient tels que, sans composants additionnels, ils dépasseraient leur capacité propre. Ainsi, on est donc limité ici à une centaine de nœuds réseau (110 cartes « branchables » sur ce bus, avec la puce TJA1050 utilisée ici), et non de 2032 ! Comme quoi, la théorie et la pratique sont vraiment deux choses différentes 😉

Documentation :
Pour ceux qui voudraient creuser le sujet, les modules « shield BUS CAN » utilisés ici, et achetables tout prêt dans le commerce, fonctionnent en fait autour de 2 composants principaux :
le TJA 1050 (émetteur-récepteur CAN haute vitesse) : https://www.nxp.com/docs/en/data-sheet/TJA1050.pdf
le MCP2515 (contrôleur CAN avec interface SPI) : https://ww1.microchip.com/downloads/en/DeviceDoc/MCP2515-Stand-Alone-CAN-Controller-with-SPI-20001801J.pdf

3 – Le protocole de communication CAN que j’ai imaginé


Ici, je vais vous partager le protocole de communication que j’ai conçu, pour ce projet. Bien entendu, vous pourrez vous en inspirer, vous l’approprier, ou le copier pour créer votre propre protocole de communication. Car, comme je vous le disais en introduction, on peut tout faire ici (ou presque !), avec pour seule limite, celle de son imagination 😉

Tout d’abord, un mot sur l’adressage des cartes physiques en lui-même :

  • chaque carte aura une adresse codée sur 11 bits, telle que définit dans la norme ISO 11898 (« standard frame format ») ; et comme vu précédemment, cela fait 2032 adresses utilisables, si l’on retire les combinaisons « interdites »
  • ces adresses seront en fait l’identifiant réseau de chaque carte sur le bus can. Ici, dans ce projet, cet identifiant sera diffusé dans chaque message au sein du « champ d’arbitrage » de la « trame de données » (ne vous inquiétez pas si ces termes ne vous parlent pas ; retenez simplement que chaque carte électronique aura simplement un IDentifiant propre à elle, et que cet ID sera diffusé dans chacun de ses messages)
  • sur le plan technique, dans ce projet, je me suis limité à 4 cartes maxi raccordables ensembles sur ce bus CAN. Car je voulais que des micro-switch matérialisent physiquement cet ID (comme visible en bas à gauche de chaque platines électroniques), et que les entrées de l’arduino nano étaient déjà toutes utilisées…

Hormis cette adresse à 11 bits de longueur, il faut savoir qu’on peut transmettre jusqu’à 64 bits de données (soit 8 octets), dans chaque message. Et c’est ce message qui est personnalisable comme on le souhaite. Pour ma part, voici le protocole de communication CAN que j’ai imaginé, pour qu’un arduino puisse donner des ordres à un autre, et vice-versa :

  • 1er octet : adresse de la carte cible. Ici, je transmets le numéro identifiant de la carte à qui j’envoie les ordres. Par exemple, si je souhaite que la carte n°3 allume une de ses LEDS, je mettrai la valeur « 3 » dans ce premier octet de message.
  • 2ème octet : la commande à effectuer. Ici, je précise quelle commande je souhaite voir effectuer, par la carte cible. J’ai donc arbitrairement dressé un tableau de valeurs, avec des ordres précis :
    • si la valeur = 0, alors c’est que je souhaite que la cible ALLUME UNE LED
    • si la valeur = 1, alors c’est que je souhaite que la cible ÉTEIGNE UNE LED
    • si la valeur = 2, alors c’est que je souhaite que la cible AFFICHE UNE VALEUR SUR SON ÉCRAN LCD dans la partie nommée « A » (la 3ème ligne de l’afficheur LCD, pour ce projet)
    • si la valeur = 3, alors c’est que je souhaite que la cible AFFICHE UNE VALEUR SUR SON ÉCRAN LCD dans la partie nommée « B » (la 4ème ligne de l’afficheur LCD, pour ce projet)
    • si la valeur = 4, alors c’est que je souhaite que la cible ÉFFACE SON ÉCRAN
  • 3ème octet : un paramètre pour préciser la commande. Par exemple, si je souhaite que la carte n°3 allume sa 4ème LED, alors je mettrai le chiffre « 4 » pour préciser que l’ALLUMAGE DE LED par la carte numéro 3 doit se faire sur la quatrième led, et pas une autre.
  • 4ème octet : un second paramètre ou une valeur. Ici, je mets par exemple la valeur du potentiomètre « lu » sur ma carte, afin que cette valeur s’affiche sur l’écran LCD d’une autre carte. Par exemple, si mon potentiomètre est à la valeur 930 (pour info, elle sera toujours comprise entre 0 et 1023), alors je vais transmettre la valeur 930 sur cet octet (ou plus exactement, à cheval sur cet octet et le suivant, car 930 est supérieur à la valeur maxi d’un octet, qui est 255).
  • 5ème octet : autre valeur. Je complète ici les informations à envoyer, avec d’autres valeurs éventuelles.
  • 6ème, 7ème, et 8ème octet : non attribué. La valeur transmise sera arbitrairement mise à zéro, tout simplement, car non utilisée ici !

Vous l’aurez compris, j’ai décidé de faire ainsi, mais rien ne vous empêche de faire autrement ! Et c’est d’ailleurs ce que je vous encourage à faire. Par exemple, si vous avez un projet domotique à base d’arduino dans votre maison, vous pourriez très bien définir que le 1er octet serait la pièce visée, le 2ème pour dire si l’on souhaite piloter une lampe ou prise de courant, et le 3ème pour dire s’il faut alimenter, ou la couper ! En bref, appropriez-vous tout cela, et créez votre propre langage de communication entre Arduino !

Le saviez-vous ? la longueur maximale des fils d’un bus can est en fait fonction de la vitesse de transmission qu’on utilise dessus. Pour info, on peut tirer jusqu’à 30m de long pour les fils, pour un débit maximal de 1 Mbits/sec, tout comme on peut aller jusqu’à 5 km de long, avec un débit limité de 10 kbits/seconde (ce qui est largement suffisant pour les applications simples, et pas trop consommatrices en bande passante). Vous retrouvez pas mal d’infos sur ça dans la norme ISO 11898-2 (CAN « high-speed »). Pour ce projet, je me suis fixé à une vitesse de 500 Kbits/s, compte tenu des besoins limités. mais vous pouvez très bien changer cette valeur, selon vos besoins !

4 – Le schéma de la carte électronique (faisant aussi bien ÉMETTEUR que RÉCEPTEUR)


Pour la réalisation du schéma électronique, j’ai décidé de le faire via un logiciel gratuit. Il s’agit d’EasyEDA. Et si j’ai fait ce choix, parmi tous les logiciels gratuits qui existent, c’est simplement parce qu’il est directement relié à deux autres services de choix :

  • LCSC.COM pour acheter des composants électroniques pas cher
  • et surtout, JLCPCB.COM, pour faire fabriquer vos circuits imprimés pour pas cher, comme un PRO !

Mais trêve de blabla, et voyons sans plus attendre le schéma électronique de toutes ces cartes !

Alors… comme vous en doutez, le coeur du montage électronique sera un Arduino. Pour ma part, je suis parti sur un Arduino Nano, car il est petit, compact, facile à intégrer, et pas cher ! Voici d’ailleurs un aperçu du schéma global (téléchargeable à la fin), qui pour rappel, sera identique sur toutes les cartes (car seuls les programmes informatiques différeront, d’une carte à l’autre).

Schéma électronique émetteur récepteur bus can piloté par arduino nano, et shield MCP2515, avec écran LCD pour débutant en programmation

Comme vous le voyez, j’ai utilisé toutes ses entrées/sorties de l’Arduino Nano, aussi bien logiques, qu’analogiques. Au niveau des pins, voici les affectations que j’ai faites :

  • les broches RX/TX sont réservées pour la communication sérielle avec l’ordi (moniteur série)
  • 2 micro-switch, définissant l’ID de la carte, sont quant à eux raccordés sur les entrées D3 et D4 (avec résistance de pull-up ; les signaux sont donc inversées, alors attention lors de la programmation)
  • 4 leds sont branchées sur les sorties D5, D6, D7, et D8
  • 1 petit haut-parleur est raccordé à la sortie D9
  • 4 boutons poussoirs sont branchés sur les entrées analogiques A1, A2, A6, et A7 (ces entrées sont là aussi inversées, avec des résistances de pull-up)
  • 2 résistances variables sont reliées aux entrées analogiques A0 et A1
  • les broches SDA et SCL de l’interface i2c sont quant à elles raccordées sur un écran LCD 4 lignes 20 caractères (avec module de communication I2C)
  • les broches de l’interface SPI (MOSI, MISO, SCK, et CS) sont reliées au module CAN (shield MCP2515)

En somme, rien de bien compliqué ! Car tous ces éléments ont leur place autour de l’arduino, et sont pour ainsi dire, indépendants les uns des autres (hormis leur alimentation commune, bien entendu).

Une subtilité à ne pas oublier, si vous faites un programme Arduino avec ce type de câblage : attention aux micro-switch et boutons poussoirs, qui sont par défaut reliés au +Vcc, grâce aux résistances de pull-up. Ainsi, lorsqu’ils seront appuyés, leur valeur basculera à 0 volts. Ces signaux sont donc inversés (actifs à 0, et inactifs à +5V).

Du reste, j’ai rajouté quelques borniers supplémentaires : un raccordement XT60, pour ceux qui aiment les branchements type modélisme, et des bornes de test à 1 picot, pour y brancher un fil Dupont dessus, si besoin.

Le saviez-vous ? l’Arduino NANO peut aussi bien être alimenté en +5V via son câble USB de programmation, tout comme être alimenté en externe, en fournissant du 5V à ses bornes VCC et GND (respectivement, ses broches n° 27 et 4).

Nomenclature :
– 1 x puce arduino nano v3
– 1 x module shield bus can MCP2515 + TJA1050
– 1 x afficheur écran LCD 4 lignes 20 caractères i2c
– 1 x haut-parleur speaker 8 ohms 0,50W
– 1 x interrupteur micro switch double ON/OFF
– 2 x mini résistances variables à plat de 10k
– 1 x réseau de 8 résistances pull-up de 10k chacune
– le reste pouvant se trouver facilement n’importe où 😉

5 – La librairie Arduino utilisée, pour communiquer entre plusieurs arduino (avec exemples de code)


Tout d’abord, pour la gestion du Bus CAN, j’ai choisi de prendre un petit circuit tout prêt, trouvable facilement dans le commerce, pour quelques euros seulement. Il s’agit d’un Shield Bus Can MCP2515 et TJA1050 utilisant le protocole SPI. Je vous le montre ici en photo, tel qu’il sera enfiché sur la carte (à l’envers, en fait, face contre terre !).

Shield bus can MCP2515 TJA1050 pour gestion émetteur récepteur via SPI sur Arduino, via broches MISO MOSI SCK et CS, avec résistance 120 ohms

Et pour dialoguer entre ce shield can bus et l’arduino, rien de plus simple ! Pour cela, je me suis servi d’une librairie déjà toute prête, et qui permet de gérer l’émission et la réception de données via le Bus Can en toute simplicité. Cette librairie s’appelle « CAN-BUS Shield ». Elle est accessible ici : librairie Seeed Studio pour Shield CAN BUS, et retrouvable directement dans l’IDE arduino, via le gestionnaire de bibliothèques :

Librairie bus can arduino, bibliothèque logiciel IDE pour gestion shield CAN BUS, pour contrôle émission réception via Nano, Uno, Mega, ou autre

Au niveau de son utilisation, rien de plus simple également. Je vais d’ailleurs vous mettre 2 exemples de programmes, fonctionnant en émetteur pour le premier, et en récepteur pour le second. Vous allez voir, le code de programme n’est pas si compliqué que ça 😉

> Exemple ÉMETTEUR : programme d’émission de valeurs sur le Bus CAN

#include <SPI.h>
#include <mcp_can.h>

const int spiCSPin = 10;
MCP_CAN CAN(spiCSPin);

void setup()
{
    Serial.begin(9600);

    while (CAN_OK != CAN.begin(CAN_500KBPS))
    {
        Serial.println("Echec initialisation BUS CAN");
        delay(100);
    }
    Serial.println("Shield BUS CAN initialisé !");
}

unsigned char stmp[8] = {1, 2, 3, 4, 5, 6, 7, 8};
    
void loop()
{   
  Serial.println("Boucle infinie ...");
  CAN.sendMsgBuf(0x40, 0, 8, stmp);			// envoi d'un message de 8 octets, égal à : 1,2,3,4,5,6,7,8 avec "40" comme identifiant (ID arbitraire ici)
  delay(1000);				// pause de 1 seconde entre chaque envoi
}

Comme vous avez pu le voir, ce programme est assez simple, en fait. Mais histoire de vous apporter quelques lumières sur ces lignes de code, voici quelques explications complémentaires :

  • Pour commencer, on déclare les librairies dont on a besoin :
    • SPI.h (car la liaison Arduino <-> MCP2515 se fait en SPI, via les broches nommées MISO, MOSI, SCK, et CS)
    • mcp_can.h (qui regroupe tout le code « compliqué » servant à échanger avec le shield bus can, depuis le logiciel arduino)
  • Puis, dans la routine « setup() », on réalise les opérations suivantes :
    • le démarrage de la communication série, pour avoir un retour d’infos sur l’ordi
    • la connexion au shield CANBUS (avec boucle infinie en cas d’échec, pour réessayer de temps en temps)
  • Et enfin, la classique boucle « loop() » où se déroule le programme principal :
    • on envoie un message faisant 8 octets de long, contenant, dans cet exemple, les chiffres 1 à 8 (au passage, ce message est envoyé avec l’identifiant « 40 », qui est un numéro que j’ai pris au hasard ; en pratique, ce sera le numéro de votre carte, donc son identifiant/adresse sur le réseau)

> Exemple RÉCEPTEUR : programme de réception de valeurs transmises via le Bus CAN

#include <SPI.h>
#include <mcp_can.h>

const int spiCSPin = 10;
MCP_CAN CAN(spiCSPin);

void setup()
{
    Serial.begin(9600);

    while (CAN_OK != CAN.begin(CAN_500KBPS))
    {
        Serial.println("Echec initialisation BUS CAN");
        delay(100);
    }
    Serial.println("Shield BUS CAN initialisé !");
}

void loop()
{
    unsigned char len = 0;
    unsigned char buf[8];

    if(CAN_MSGAVAIL == CAN.checkReceive())
    {
        CAN.readMsgBuf(&len, buf);

        unsigned long canId = CAN.getCanId();

        Serial.println("*** Nouveau message");
        Serial.print("Provenant de ID = 0x");
        Serial.println(canId, HEX);
        Serial.print("Données = ");

        for(int i = 0; i<len; i++)
        {
            Serial.print(buf[i]);
            Serial.print("\t");
        }
        Serial.println();
    }
}

Voici ce qui se passe ici, lors de l’exécution de ce programme Arduino :

  • Au démarrage, on fait appel aux librairies dont on aura besoin ici :
    • SPI, pour assurer le dialogue entre l’arduino et le shield Bus CAN fonctionnant en SPI (puce MCP2515)
    • MCP_CAN, pour nous fournir les fonctions simplifiées d’accès au réseau CAN (initialisation, envoi de message, écoute, filtrage, …)
  • La partie « setup » :
    • On démarre la communication sérielle, pour avoir un retour sur le Moniteur Série du logiciel Arduino IDE
    • On initialise la liaison CAN (ou on attend qu’elle soit prête, avant de passer à la suite)
  • La boucle « loop » :
    • On regarde si un nouveau message est arrivé
    • Et en cas de nouveau message : on le charge dans une variable, et on l’affiche à l’écran de l’ordi via le moniteur série (on en profitera pour afficher le numéro IDentifiant de celui qui a envoyé le message, soit son adresse sur le réseau)

Donc rien de bien sorcier, pour faire ses premiers pas avec cette librairie bien pratique 😉

6 – La carte électronique en elle-même (circuit imprimé PCB)


J’ai fait réaliser la carte électronique du projet chez jlcpcb.com, parce que leurs tarifs étaient de loin l’un des meilleurs au moment de la réalisation de cette carte. Et compte tenu du résultat, aussi bien au niveau des parties cuivrées que de la sérigraphie, je ne regrette absolument pas mon choix ! Mais tout d’abord, voyons le circuit imprimé (PCB), côté composant, et en sous face.

Carte bus can piloté par arduino et shield MCP2515, pour débuter en électronique, côté composant pour débutant communication élec
Carte électronique bus can côté cuivre, avec arduino nano et afficheur LCD, y compris shield MCP2515 et terminaison CAN 120 ohms élec

Pour info, j’ai commandé un lot de 5 plaquettes (circuit imprimé) sur ce site, et en ai eu pour environ 9 €, hors frais de port. Concernant les frais de port justement, j’ai pris la méthode d’envoi la moins chère (quelques euros seulement, selon le poids, la taille, et la quantité).

J’ai reçu ces circuits imprimés 15 jours après, parfaitement bien emballés, et dans une boîte en carton bien costaude ! Bien sûr, j’aurais pu recevoir ces PCB bien plus rapidement, via des méthodes d’expéditions rapide (DHL, …), mais compte tenu du prix élevé que demande ce type de transport, je pense que c’est plutôt à réserver pour les besoins urgents, uniquement. Là, dans le cadre de ce projet, quinze jours d’attente n’étaient pas la fin du monde 😉

Pour ceux qui voudraient le fichier de fabrication GERBER pour réaliser cette platine, sans avoir à tout refaire, je vous mettrai un lien en fin d’article pour télécharger cela.

Côté soudure, il n’y a aucune difficulté particulière, si ce n’est les potentiomètres plats, qui sont un peu « courts sur pattes » ! Il faudra donc bien prendre soin de laisser couler la soudure d’un côté à l’autre du circuit imprimé, afin de bien les faire tenir en place (mais sans trop insister, sinon vous risquez d’endommager ces composants). Aussi, je vous recommande de fixer l’afficheur LCD en dernier, afin de pouvoir ajuster le contraste de celui-ci préalablement, car il est situé dessous dans mon cas 😉

Nomenclature :
– 1 x microcontrôleur Arduino Nano v3
– 1 x shield module bus can MCP2515 / TJA1050
– 1 x écran afficheur LCD i2c de 4 x 20 caractères
– 1 x petit haut-parleur 8 ohms de 0,50 W
– 1 x micro switch double inter ON/OFF (4 adresses)
– 2 x résistances potentiomètre variable plat 10k ohms
– 1 x réseau de résistances de pull-up (réseau 8 x 10k)
– le reste des composants pouvant se trouver assez facilement, un peu partout !

7 – Les sources à télécharger (schéma électronique, fichier Gerber PCB, et deux programmes de communication entre Arduino BUS CAN)


Voici les fichiers sources de ce projet Bus Can :

  • le schéma électronique de cet émetteur-récepteur Bus Can réalisé sous Easy EDA
  • le fichier Gerber contenant le dossier de fabrication PCB exporté depuis JLCPCB
  • le code de programmation de la carte n°1 de ce projet permettant de réaliser les opérations comme visible dans la vidéo d’intro (à venir)
  • le code arduino de la carte n°2 communiquant aussi sur Bus CAN tel que visible en vidéo, au début de cet article (à venir)

Nous voici au terme de ce projet éducatif ! J’espère que vous aurez pu y trouver tout un tas d’infos pour mener à bien vos projets personnels. N’hésitez pas à me contacter via la page contact si besoin de plus d’infos ! Et pour ma part, je vous dis à très bientôt 😉

Jérôme.

(*) Article mis à jour le 07/11/2020

You cannot copy content of this page