Mise en place d'un bus CAN : Différence entre versions

Version du 23 juillet 2018 à 16:08

En cours de rédaction

Présentation et objectifs

L'objectif de ce tutoriel est de mettre en place un bus CAN entre plusieurs carte STM32 de catégorie NUCLEO-L4, grâce à l'environnement Atollic et les fonctions HAL. Le contexte ( boutons, LEDS, écran ) n'est qu'une manière d'illustrer le fonctionnement du bus CAN, et vous pouvez vous en passer si ce qui vous intéresse concerne uniquement le bus CAN. Si vous souhaitez voir une implémentation du bus CAN sur des cartes Arduino, vous pouvez en trouver ici.

Vous pouvez rajouter dans ce paragraphe des photos des croquis papier que vous avez fait pour mieux visualiser ce qu'il y avait à faire.

Pré-requis

Aucune compétence en programmation n'est requise pour mener à bien ce tutoriel, mais sera peut être nécessaire pour une implémentation du bus plus poussée.

Matériel

• 3 cartes NUCLEO-L4 ( Je me suis servi des modèles L476RG et L432KC)
• 3 drivers CAN MCP2551
• 2 résistances de 120 Ohms

Et si vous souhaitez le tester visuellement :

• des résistances de 220 et 10kOhms
• des leds et boutons poussoirs
• une bread board

Logiciels

• STM32CubeMX
• AtollicTRUESTUDIO

Tutoriel CAN

La version courte servira uniquement à mettre en place le bus CAN sans aucune implémentation autour. L'autre version proposera un petit contexte afin de mieux visualiser la connexion en CAN enter les cartes, et sera a effectuer en complément de la version courte.

Version courte : Bus CAN uniquement

Étape 1 : Configurer l'environnement de travail

Ouvrez STM32CubeMX et créez un nouveau projet. Dans l'onglet Board Selector, sélectionnez votre type de carte et son modèle (qui devra être STM32L4 pour ce tuto). Je me suis servi pour ma part du modèle Nucleo32 STM32L432KC et du modèle Nucleo64 STML476RG. Cliquez sur Start Project et acceptez que le projet soit initialisé par défaut.

Une fois dans le projet, dans l'onglet Pinout, ouvrez le menu CAN1 et sélectionnez Master Mode. Notez sur le schéma central le nom des Pins qui viennent d'apparaitre qui correspondent à CAN1_TX et CAN1_RX, ce sont ces pins dont vous devrez vous servir pour effectuer le branchement. Vérifiez ensuite dans le menu RCC, toujours dans l'onglet Pinout, que le LSE est sur la valeur Crystal/Ceramic Resonator. Dans l'onglet Clock Configuration, entrez le nombre 48 dans l'encadré entouré de bleu nommé HCLK, ce qui devrait changer la valeur de tous les autres encadrés sur 48 également.

Dans l'onglet Configuration, cliquez sur CAN1. Dans l'onglet Parameter Settings, mettez le "Prescaler" à 12, le "Time Quanta in Bit Segment 1" à 13, le "Time Quanta in Bit Segment 1" à 2 et le "ReSynchronization Jump Width" à 1. Le "Time Quantum" devrait se mettre à 250.0ns. Toujours dans cette fenêtre de configuration, dans l'onglet NVIC Settings, cochez toutes les cases pour autoriser les interruptions. Acceptez les modifications.

Vous pouvez maintenant aller le menu déroulant Project, puis Settings. Donnez un nom à votre projet et une location dédiée à vos projets que vous pourrez facilement retrouver sous Atollic. Dans le menu déroulant Toolchain / IDE, sélectionnez TrueSTUDIO. Acceptez les modifications.

Dans le menu déroulant Project, vous pouvez maintenant générer le code en cliquant sur Generate Code. Étant donné que toutes vos cartes qui serviront au bus CAN seront configurées de la même manière, vous pouvez pour plus de clarté en générer plusieurs fois le même code pour chaque carte ( à part si le modèle est différent). Sinon, vous pouvez aussi envoyer le même code dans les cartes différentes en changeant quelques ligne de code à chaque fois.

Étape 2 : Effectuer le branchement

Le montage à réaliser est le suivant :

Explications:

Les drivers CAN doivent tous être connectés entre eux via leur canaux CANH et CANL ( broches 6 et 7), c'est ce qui va constituer le bus.

La résistance de 10k sur la broche 8 (RS) est conseillée, mais le bus peux fonctionner simplement en la raccordant à la masse.

La broche 2 (VSS) doit être reliée à la masse et la broche et la broche 3 (VDD) au 5V.

La broche 1 doit être connectée à la pin CAN1_TX, et la broche 4 au CAN1_RX. Ces pins ont été configurées à la première étape dans le logiciel STM32CubeMX et pourront donc être différentes de ce schéma.

Les deux drivers en bout de ligne doivent comporter une résistance de 120 Ohms entre leurs broches CANH et CANL.

Étape 3 : Écrire le programme

Ouvrez Atollic, et sélectionnez comme workspace le dossier ou vous avez mit le projet STM32CubeMX s'il vous est demandé ou bien importez le manuellement dans le Project Explorer s'il n'y est pas. Dans le dossier Src du projet, ouvrez le fichier main.c. Vous pouvez des à présent tester avant de rajouter du code si le projet est bien configuré en le transversant dans la carte et en vérifiant qu'il n'y ai pas d'erreur de compilation ou d’exécution (A l'aide de l'outil Debug).

Vérifiez la présence de la déclaration de la variable can dans la partie Private variables de la forme

CAN_HandleTypeDef hcan1; 

Nous nous servirons de cette variable dans toutes les configurations futures. Ajoutez y à la suite les variables suivantes :

CAN_TxHeaderTypeDef   TxHeader;
CAN_RxHeaderTypeDef   RxHeader;
uint8_t               TxData[8];
uint8_t               RxData[8];
uint32_t              TxMailbox;

Créez ensuite une fonction CAN_Config() qu'il faudra appeler ensuite dans la fonction principale main() juste après l'initialisation du CAN. Dans cette fonction, nous allons commencer pour configurer le filtre :

  CAN_FilterTypeDef  sFilterConfig;

  sFilterConfig.FilterBank = 0;
  sFilterConfig.FilterMode = CAN_FILTERMODE_IDMASK;
  sFilterConfig.FilterScale = CAN_FILTERSCALE_32BIT;
  sFilterConfig.FilterIdHigh = 0x320 << 5;           // Ici, 320 est l'adresse de la carte. Il peux être différent pour chaque carte.
  sFilterConfig.FilterIdLow = 0;
  sFilterConfig.FilterMaskIdHigh = 0xFFF << 5;       // Le masque peux servir à accepter une plage d'adresse au lieu d'une adresse unique.
  sFilterConfig.FilterMaskIdLow = 0;
  sFilterConfig.FilterFIFOAssignment = CAN_RX_FIFO0;
  sFilterConfig.FilterActivation = ENABLE;
  sFilterConfig.SlaveStartFilterBank = 14;

  HAL_CAN_ConfigFilter(&hcan1, &sFilterConfig);      // Configure le filtre comme ci-dessus

Le filtrage est une notion importante du bus CAN car c'est ce qui décide quelles informations transitant sur le bus CAN un périphérique doit traiter ou non. Je vous met un lien ici de quelques exemples qui m'ont aider à mieux comprendre son fonctionnement.

A la suite, on peux ajouter :

HAL_CAN_Start(&hcan1);                                             // Démarre le périphérique CAN
HAL_CAN_ActivateNotification(&hcan1, CAN_IT_RX_FIFO0_MSG_PENDING); // Active le mode interruption

Nous reviendrons un peu plus tard sur la fonction d’interruption, et sur la possibilité de passer en mode "polling" ( Il faudra pour cela supprimer cette ligne).

Les prochaines lignes concernent la configuration de l'envoi de trames sur le bus.

  TxHeader.StdId = 0x321;      // Détermine l'adresse du périphérique au quel la trame est destiné. 
                               // Si plusieurs périphériques sur le bus comprennent cette adresse dans leur filtre, ils recevront tous la trame.
  TxHeader.ExtId = 0x01;       // Adresse étendue, non utilisée dans note cas
  TxHeader.RTR = CAN_RTR_DATA; // Précise que la trame contient des données
  TxHeader.IDE = CAN_ID_STD;   // Précise que la trame est de type Standard
  TxHeader.DLC = 2;            // Précise le nombre d'octets de données que la trame transporte ( De 0 à 8 )
  TxHeader.TransmitGlobalTime = DISABLE;
 

Vous pouvez également rajouter dans cette fonction la valeur des données envoyées si elles sont fixes, ou si vous en souhaitez par défaut, grâce à ligne suivante :

TxData[0] = valeur; // Vous pouvez changer toutes les valeurs de Txdata[0] à Txdata[TxHeader.DLC - 1] (TxHeader.DLC étant défini ci dessus)

La fonction CAN_Config est terminée, en voici un rappel complet :

void CAN_Config(void)
{
  CAN_FilterTypeDef  sFilterConfig;

  sFilterConfig.FilterBank = 0;
  sFilterConfig.FilterMode = CAN_FILTERMODE_IDMASK;
  sFilterConfig.FilterScale = CAN_FILTERSCALE_32BIT;
  sFilterConfig.FilterIdHigh = 0x320 << 5; 
  sFilterConfig.FilterIdLow = 0;
  sFilterConfig.FilterMaskIdHigh = 0xFFF << 5; 
  sFilterConfig.FilterMaskIdLow = 0;
  sFilterConfig.FilterFIFOAssignment = CAN_RX_FIFO0;
  sFilterConfig.FilterActivation = ENABLE;
  sFilterConfig.SlaveStartFilterBank = 14;

  HAL_CAN_ConfigFilter(&hcan1, &sFilterConfig); 

  HAL_CAN_Start(&hcan1); 

  HAL_CAN_ActivateNotification(&hcan1, CAN_IT_RX_FIFO0_MSG_PENDING); 

  TxHeader.StdId = 0x320; 
  TxHeader.ExtId = 0x01; 
  TxHeader.RTR = CAN_RTR_DATA; 
  TxHeader.IDE = CAN_ID_STD; 
  TxHeader.DLC = 2; 
  TxHeader.TransmitGlobalTime = DISABLE;
}

N'oubliez pas d'ajouter l'appel de cette fonction dans la fonction main(), après l'initialisation des périphériques, à cet endroit :

  /* Initialize all configured peripherals */
  MX_GPIO_Init();
  MX_USART2_UART_Init();
  MX_CAN1_Init();
  /* USER CODE BEGIN 2 */
  CAN_Config();

Nous pouvons maintenant passer à la configuration de la réception des trames. Il y a pour cela deux façons de procéder, en interruption ou en "polling".

Si vous souhaitez fonctionner par interruption ( et que vous l'avez bien ajouté dans la fonction CAN_Config()), il faudra définir la fonction suivante :

void HAL_CAN_RxFifo0MsgPendingCallback(CAN_HandleTypeDef *hcan)
{
  HAL_CAN_GetRxMessage(hcan, CAN_RX_FIFO0, &RxHeader, RxData);
}

Vous pouvez ajouter dans cette fonction, après la première ligne, des vérifications sur la trame reçue et le traitement que vous voulez en faire. Par exemple :

if (RxHeader.IDE == CAN_ID_STD && RxHeader.DLC == 1 && RxData[0] == 4)
{
    // Traitement des données
}

Vous avez accès à toutes les informations que vous pouvez vous même définir dans les envois de trame.

Si vous souhaitez fonctionner en "polling", vous devez retirer la ligne de code qui active les notifications dans la fonction CAN_Config(), et vous ne devez pas définir la fonction précédente. Il faudra en revanche constamment vérifier dans votre boucle de la fonction main() (dans le while(1)) si un message est arrivé ou non, grâce à la fonction suivante :

HAL_CAN_GetRxFifoFillLevel(&hcan1, CAN_RX_FIFO0);

Cette fonction renvoie une valeur entre 0 et 3, qui correspond au nombre de trames reçues en attente. Vous pouvez donc ajouter une condition qui ne sera vraie que si la valeur de retour est strictement positive, et le contenu de cette condition sera identique au contenu dans la fonction d'interruption précédemment décrite. Voici un exemple :

 /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
      if(HAL_CAN_GetRxFifoFillLevel(&hcan1, CAN_RX_FIFO0) > 0)
      {
          HAL_CAN_GetRxMessage(&hcan1, CAN_RX_FIFO0, &RxHeader, RxData);
	  if (RxHeader.IDE == CAN_ID_STD && RxHeader.DLC == 1 && RxData[0] == 4)
     	  {
              // Traitement des données
  	  }
      }
  /* USER CODE END WHILE */

  /* USER CODE BEGIN 3 */

  }

Attention, en mode "polling", si plus de 3 trames sont reçues sans être traitées,les plus anciennes seront effacées pour laisser de la place aux nouvelles, et donc perdues.

Enfin, pour envoyer une trame selon les configurations décrites dans la fonction CAN_Config(), il faut faire appel à cette fonction :

HAL_CAN_AddTxMessage(&hcan1, &TxHeader, TxData, &TxMailbox);

Afin que le programme soit plus flexible, on peut définir une fonction qui se chargera dans l'envoi en prenant en paramètre l'adresse et les données de la trame :

Version longue : Bus CAN dans un contexte simple

Étape 1 : Effectuer le branchement

Étape 2 : Configurer l'environnement de travail

Étape 3 : Écrire le programme

Conseils

La ligne de code de l'horloge La vitesse la collision Analyseur de trames Une seule carte

Pour aller plus loin

Que peut-on faire de plus une fois le tutoriel réalisé ?

Bibliographie

• pourquoi pas
• une liste
• de liens