Vous êtes sur la page 1sur 23

REPUBLIQUE TUNISIENNE

Ministère de l’Enseignement Supérieur et de la Recherche


Scientifique
Institut Supérieur des systèmes industriels de Gabès

FASCICULE DE TRAVAUX PRATIQUE


Réseaux locaux Industriels : Bus CAN

LF EEA 3
&
SM1

Préparé par :
Mr. Haythem Ameur &
Mr. Mohamed Hedi Gmiden

ISSIG 2018/2019
Atelier Réseaux locaux : Bus CAN

I. Introduction :
Le bus de données CAN (Controller Area Network) est un bus série très utilisé dans l’'industries,
notamment dans le secteur d'automobile. Il intègre une approche connue sous le nom
de multiplexage, qui consiste à joindre à un même câble (un bus) un grand nombre
de calculateurs qui communiqueront par tour de rôle. L'insertion des bus multiplexés
(principalement le bus CAN) dans l'automobile avait pour objectif de réduire la quantité de
câbles dans les véhicules (il y avait jusqu'à 2 km de câbles par voiture), mais elle a surtout
permis l'explosion du nombre de calculateurs et capteurs distribués dans tout le véhicule, tout
en diminuant les longueurs câblées.

Fig.1
II. Caractéristiques :
- Bus série asynchrone
- Jusqu’à 1 Mbps (réseaux < 40 m) et 125 kbps (réseau < 500 m).
- Un seul message à la fois
- Tous les nœuds peuvent envoyer des messages
- Tous les nœuds reçoivent les messages
- Les conflits (collisions) et les erreurs sont gérés automatiquement
- Chaque message possède un identifiant
- Un nœud peut filtrer les identifiants pour ne conserver que certains messages
- Couches 1 et 2 du modèle OSI (Physique et liaison de données)
- Bus Multi-Maîtres

ISSIG 2018/2019
- Bidirectionnel
- Différentielle : moins sensible aux perturbations(Bruits)

III. Objectif :
A travers cet atelier, nous allons essayer d’implémenter ce protocole de communication sur une
plateforme électronique.

ISSIG 2018/2019
TP1 : Infinitisation sur STM32f4 : fonctionnement du GPIO et
d’interruption

I. But :
L’objectif de ce TP est de se familiariser avec la carte STM32f407 (Fig. 2) et ces périphériques. La
famille des microprocesseurs STM32f4 de ST Microelectronics fournit une vaste gamme de
périphériques autour d’un coeur ARM®Cortex®-M4 32-bit. Dans ce TP, on considère la carte
STM32f407VG illustrée par la figure 2. Les caractéristiques et les fonctionnalités de cette carte sont
accessibles depuis ses 100 ports broches (Pins) ainsi que d’autres périphériques de liaisons, allant
des simples GPIOs et des interfaces de communication série synchrone (SPI) ou asynchrone (RS232)
jusqu’aux interfaces plus complexes comme l’USB, l'Ethernet et le HDMI, etc. Nous allons
s’intéresser précisément, à ses entrées/sorties générales (LED, Bouton poussoir…) et quelques
fonctionnalités possibles notamment les fonctions d’interruption. Pour y faire, nous allons
exploiter certaines sections de la datasheet de la plateforme présentée (Fig. 2) afin d’acquérir le
nécessaire pour mener à bien cette manipulation.

Fig.1 La carte STM32f407

Ce TP vise les objectifs suivants:


 Compiler et exécuter un programme à partir des Environnements de Développement
Intégré (IDE) STM32CubeMX et MDK (ARM V5).
 Contrôler les entrées/sorties digitales du microcontrôleur.
 Utiliser la fonction d’interruption externe GPIO_EXTIO pour faire clignoter une LED.
II. MANIPULATION :
1. Programmation de STM32F407 dans un kit d’évaluation STM32F4-Discovery pour
clignoter les LED du kit.

ISSIG 2018/2019
Faire clignoter des LEDs est un programme basique très élémentaire et assez simple qui vise à la
fois de découvrir l’univers de la carte STM32 et de s’assurer du bon fonctionnement et de la
bonne synchronisation entre le Software et le Hardware. Les deux environnements de
développement intégré qu’on va l’utiliser sont le STM32CubeMX et le MDK (ARM V5).
STM32Cube
Avec la carte STM32, STMicroelectronics fournit un outil logiciel complet, réduisant
considérablement les efforts de développement, le temps et les coûts.
Le STM32CubeMX est un outil graphique qui permet une configuration très simple des
microcontrôleurs et la génération du code C d'initialisation correspondante.

- Pour commencer, ouvrir le logiciel STM32CubeMX et créer un nouveau projet comme il


est illustré sur la figure 1.

Fig. 2

- Sélectionner la plateforme d’évaluation (Board) STM32F4-Discovery, et la référence du


processeur STM32F407 VGTx comme il est montré dans la figure 2.

ISSIG 2018/2019
Fig. 3

- Une fois vous avez bien sélectionné la plateforme enjeu, cliquez sur l’onglet star Project.
Vous pouvez réinitialiser la configuration des pines du microcontrôleur en cliquant sur
l’onglet Pinout Clear Pinouts :

Fig. 4

- L’étape suivante consiste à configurer les pines d’entrées/sorties de la plateforme. On va


utiliser le bouton poussoir de l’utilisateur comme entrée et les 4 LED (LED 3, LED 4, LED 5
et LED 6) comme sorties. En pratique, le bouton poussoir est lié au Pin PA0 et les LED 3,
4, 5 et 6 sont liées respectivement aux Pin PD12, PD13, PD14 et PD15. Vous pouvez
vérifier les connexions des pines sur la figure 4, extrait à partir datasheet de la
plateforme.

ISSIG 2018/2019
Fig. 5 Les pines d’entrées/sorties de la plateforme
- Dans la branche des pines, faire les configurations graphiques suivantes pour PA0, PD12,
PD13, PD14, PD15.

Fig. 5 Les configurations graphiques de la carte STM2

- Avec la configuration des entrées/ sorties, nous aurons besoin de sélectionner un type
d’horloge pour notre microcontrôleur, sous l’onglet RCC, sélectionner le type
7

ISSIG 2018/2019
Crystal/Ceramic Resonator.

Fig. 6
A ce stade, nous avons configuré graphiquement toutes les pines nécessaires pour faire
clignoter les LED de la plateforme STM32. La dernière étape, avant de migrer vers à
l’environnement de programmation Keil MDK μ5, consiste à paramétrer les options d’intégration
du projet à savoir : le nom du projet, l’emplacement, l’outil IDE (Toolcchain/IDE) et la version de
la bibliothèque utilisée (Firmware Package). La figure 6 présente les paramètres à introduire
dans l’onglet Project Settings.

ISSIG 2018/2019
Fig. 7

Il ne reste maintenant que la génération du Code C équivalent à la configuration graphique


réalisée. Pour y faire, cliquer sur l’onglet Project puis Generate Code.

Fig. 8

ISSIG 2018/2019
Après la réussite de la génération du code par STM32CubeMX vous aurez l’interface suivante
(Fig. 9) qui contient le code généré automatiquement. Il est temps, donc, de se déplacer vers
l’environnement Keil MDK μvision afin de personnaliser ce code.

Fig. 9
Keil MDK μvision
Keil MDK est un environnement complet de développement de logiciels pour une large gamme de
microcontrôleurs à bras Cortex-M. MDK comprend le μVision IDE et le débogueur, le compilateur
Arm C / C ++ et les composants essentiels du middleware. Il contient également de nombreux
exemples pratiques prêts à exécuter pour les cartes utilisant des processeurs ST.
Sous le fichier Application/User ouvrir les deux sous-fichiers Main.c et STM32.it. Le code
(Main.c) généré automatiquement par Keil MDK contient les fonctions suivantes:
- l’entête du fichier (nom du programme, la bibliothèque utilisé), exemple :
o /* Includes ------------------------------------------------------------------*/
o #include "main.h"
o #include "stm32f4xx_hal.h"

- les fonctions de configuration équivalentes à la configuration graphique réalisé sur


STM32CubeMX , exemple
o /* Private function prototypes -----------------------------------------------*/
o void SystemClock_Config(void); /* pour la configuration du Clock
o static void MX_GPIO_Init(void); /* pour la configuration des E/S GPIO
10

ISSIG 2018/2019
- la fonction main principale
o int main(void)
o {
o ….
o ….
o }
- Des zones délimitées par les commentaires "/* USER CODE BEGIN ...*/" et "/* USER
CODE END...*/" allouer à l’utilisateur pour ajouter des codes personnalisés.
o /* USER CODE BEGIN 1 */
o ….
o ….
o /* USER CODE END 1 */

Remarque :
Il est très important d'ajouter votre code dans les zones délimitées par les commentaires "/*
USER CODE BEGIN ...*/" et "/* USER CODE END...*/" car si vous retournez dans cube pour
modifier la configuration du microcontrôleur, la régénération automatique du code écrasera le
code qui n'a pas été écrit dans ces zones.

Fig. 10

Pour faire clignoter des LEDs 12, 13, 14 et 15 de la plateforme, ajouter les deux instructions
suivantes dans la boucle while du programme principale main(void). Attention le code ajouté
doit être introduit dans la zone allouée à l’utilisateur.
- HAL_GPIO_TogglePin (GPIOD, GPIO_PIN_12| GPIO_PIN_13| GPIO_PIN_14| GPIO_PIN_15);
- HAL_Delay (2000) ;

La fonction TogglePin de la bibliothèque HAL permet le clignotement de LED.


L’instruction GPIOD permet la sélection du bloc D de la plateforme STM32.
La fonction "HAL_Delay(2000)" permet de faire une temporisation de sec (2000 ms).

11

ISSIG 2018/2019
2. Programmer le STM32F407 dans un kit d’évaluation STM32F4-Discovery de telle
sorte que la LED 6 du kit s’allume lorsqu’on appuie sur le bouton du kit (bouton «
User » bleu). La lumière s’éteint lorsqu’on relâche le bouton.
a. A partir de la Figure 5, vérifier le numéro du Pin auquel il devra se connecter le
bouton poussoir du Kit.
b. Pour tester l’état logique du bouton poussoir, vous pouvez utiliser l’instruction
suivante :
HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0);
c. Pour commander la LED6, vous pouvez utiliser l’instruction suivante:
HAL_GPIO_writePin(GPIOD,GPIO_PIN_15);

Exécuter le programme et tester son fonctionnement en appuyant rapidement sur le bouton


poussoir de l’utilisateur.
- Qu’est-ce que vous remarquez ?
- Quelle est la cause de cette anomalie de fonctionnement ?
- Proposer une solution pour avoir un fonctionnement correct.
STM32F4 a 23 interruptions externes. Ces lignes d’interruptions externes sont composées de 2
sections. Les premières sections (line0 à line15) concernent les interruptions externes des
broches GPIO (P0 à P15). L'autre section concerne les événements liés aux périphériques (RTC,
Ethernet, USB). Une autre chose que nous devons configurer lors de l’utilisation d’interruption
sur STM32F4 est NVIC (Nested Vector Interrupt Controller). La fonction de NVIC est de
configurer quelle interruption est la plus importante et d’activer ou de désactiver l’interruption.
Il supporte jusqu'à 256 vecteurs d'interruption différents. Une valeur de priorité inférieure
indique une interruption de priorité supérieure.

3. Refaire le même travail demandé dans (2), mais cette fois en utilisant la fonction
d’interruption GPIO_EXTIO.

a. Revenez à l’environnement STM32CubeMX et changez la configuration de


Pin PA0 pour supporter les interruptions extérieures
(GPIO_InputGPIO_EXTIO)
b. Activer l'interruption EXTI0 dans la fenêtre NVIC et la donner une priorité
égale à 1 comme il est montrer sur la figure 11.

12

ISSIG 2018/2019
Fig. 11

c. Régénérer le code sur Keil MDK V5 puis ouvrir les deux sous-fichiers Main.c et
STM32.it

Fig. 12

d. Dans la routine d'interruption EXTI Line 0, sous le fichier STM32.it, écrire le code
qui sert à allumer la diode LED6 si on appuie sur le bouton poussoir
13

ISSIG 2018/2019
Fig. 13

e. Exécuter le programme et tester le fonctionnement en appuyant rapidement sur


le bouton poussoir de l’utilisateur. Qu’est-ce que vous remarquez ?

14

ISSIG 2018/2019
TP2 : Implémentation de bus CAN sur STM32F4

I. Introduction:
Le bus CAN (Control Area Network) est un moyen de communication série qui supporte des
systèmes embarqués temps réel avec un haut niveau de fiabilité. Ses domaines d’application
s’étendent des réseaux moyens débits aux réseaux de multiplexages faibles coûts.
La transmission des données est effectuée sur une paire filaire différentielle. La ligne est donc
constituée de deux fils :
• CAN L (CAN LOW),
• CAN H (CAN HIGH).
Le CAN est un bus de terrain, soumis à des parasites importants. La transmission en paire
différentielle permet de s'affranchir de ces problèmes.

Fig. 1 High speed CAN 125kps- 1Mbps

1. Structure de réseau CAN

Pour envoyer ou recevoir un message à partir d’un microcontrôleur, il faut que les données
transitent par différents modules. La figure 2 représente un schéma structurel d’un réseau CAN.

15

ISSIG 2018/2019
Fig. 2 Structure d’un réseau CAN

2. Nœud de réseau CAN


Un nœud CAN généralement est formé d'un
- Un microcontrôleur
- Contrôleur CAN: les contrôleurs CAN permettent de gérer le bus de manière hardware.
On distingue deux types de contrôleurs :
Les contrôleurs reliés aux microcontrôleurs par une liaison du type SPI, comme par exemple le
MCP2515 de chez Microchip, sont utilisés lors de l’absence d’un contrôleur intégré. Les
contrôleurs intégrés aux microcontrôleurs qui disposent donc, d'un module CAN avec les lignes
TXCAN et RXCAN reportés sur les pins et destinés à être reliés au transceiver CAN.
- Transceiver CAN: le protocole CAN ne spécifie pas la couche physique, c'est pourquoi la
plupart des contrôleurs CAN ne possèdent pas de circuits permettant de les connecter à
un bus, qu'il soit filaire, à fibre optique ou tout autre mode de transmission possible. Un
transceiver permet de faire l'interface entre le contrôleur CAN et le bus physique.

II. Réseau CAN à base de STM32F4Discovery

Le processeur de la carte STM32F4 Discovery possède deux contrôleurs CAN mais il ne possède
pas un émetteur-récepteur. On peut utiliser un transceiver MCP2551 comme un
émetteur_recépteur .

Un nœud CAN à base de STM32F discovery comme un microcontrôleur peut être illustré sur le
schéma de la figure 3.

16

ISSIG 2018/2019
Fig. 3 Nœud CAN à base de STM32Fdiscovery

III. Manupilation

1. Objectifs:

- Etudier comment configurer un réseau CAN dans l’environnement CubeMX , générer le


code associé et l’exécuter sur la carte STM32Discovery
- Savoir les différentes fonctions de la bibliothèque HAL permettant l’implémentation de
bus CAN

2. Méthodes :

- Développer une application permettant d’envoyer et recevoir des messages à travers le


bus CAN
- Créer une interruption déclenchée par l'appui sur le bouton poussoir du nœud N° 1 et
allumer une diode LED du port D du nœud N°2.

3. Manipulation :

 Commencer par la création d’un nouveau projet sur STM32CubeMX


 Sélectionner la plateforme d’évaluation (Board) STM32F4-Discovery, et la référence du
processeur STM32F407 VGTx
 Dans la liste des périphériques, sélectionner Master Model pour CAN1.

 Configurer les pines PB8 et PB9 comme étant l’émetteur TX et le récepteur RX du bus

17

ISSIG 2018/2019
CAN1

 Configurer une pine du port D comme une sortie GPIO_Output pour commander la LED.
 Dans l’onglet Configuration, selectionner CAN peripheral et ajuster les paramètres
suivants :

Fig. 4

 Sélectionner le paramètre «Settings tab » et changer le mode d’opération en normal


 Modifier les paramètres Bit Timing du bus CAN comme le suivant:

18

ISSIG 2018/2019
Fig. 5

 Sélectionner l’onglet NVIC Settings tab et activer l’interruption TX et Rx du bus CAN1

Fig.6
19

ISSIG 2018/2019
Pareille au TP précédent, paramétrer les options d’intégration du projet à savoir : le nom du
projet, l’emplacement, l’outil IDE (Toolcchain/IDE) et la version de la bibliothèque utilisée
(Firmware Package). Ensuite générer le code associé.

•Menu > Project > Project Settings


•Set the project name
•Project location
•Type of toolchain
•Menu > Project > Generate Code

Après la génération du code par STM32CubeMX, ouvrir le projet dans l’environnement Keil MDK
μvision. Il faut maintenant introduire quelques instructions relatives à la configuration des
adresses des nœuds, les filtres associés, le type de donnée à transmettre etc. Faite attention, il
faut introduire les instructions suivantes dans le correct emplacement du programme principal.
Etape 1:

Ajouter les instructions suivantes à fin de :


i. Définir les variables privées à utiliser.
ii. Créer la structure de la supervision du bus CAN (filters, transmission message, reception
message).
iii. Configurer les filtres des nœuds CAN de telle façon que tous les messages reçus sont
acceptés.

/* USER CODE BEGIN PV */


/* Private variables ---------------------------------------------------------
*/ CAN_FilterTypeDef sFilterConfig;
CAN_TxHeaderTypeDef TxHeader;
CAN_RxHeaderTypeDef RxHeader;
uint8_t TxData[8];
uint8_t RxData[8];
uint32_t TxMailbox;
/* USER CODE END PV */

/* USER CODE BEGIN 2 */


/* configuration de la structure de filtre CAN

sFilterConfig.FilterBank=0;
sFilterConfig.FilterMode=CAN_FILTERMODE_IDMASK;
sFilterConfig.FilterScale=CAN_FILTERSCALE_32BIT;
sFilterConfig.FilterIdHigh=0x0000;
sFilterConfig.FilterIdLow=0x0000;
sFilterConfig.FilterMaskIdHigh=0x0000;
sFilterConfig.FilterMaskIdLow=0x0000;
sFilterConfig.FilterFIFOAssignment=CAN_RX_FIFO0;
sFilterConfig.FilterActivation=ENABLE;
20

ISSIG 2018/2019
sFilterConfig.SlaveStartFilterBank=14;

/* configuration des function d’appel du filter CAN

if(HAL_CAN_ConfigFilter(&hcan1,&sFilterConfig)!=HAL_OK)
{
/* Filter configuration Error */
Error_Handler();
}

Etape 2:

Ajouter les instructions suivantes à fin de :


i. Initialiser le CAN.
ii. Activer la notification des interruptions.
iii. Compléter les données du message TX.

/* CAN start
if
if(HAL_CAN_Start(&hcan1)!=HAL_OK)
{
/* Start Error */
Error_Handler();
}

/*CAN notifications(interrupts)
if(HAL_CAN_ActivateNotification(&hcan1,CAN_IT_RX_FIFO0_MSG_PENDING
|CAN_IT_TX_MAILBOX_EMPTY)!=HAL_OK)
{
/* Notification Error */
Error_Handler();
}

/*CAN TX message
TxHeader.StdId=0x321;
TxHeader.ExtId=0x01;
TxHeader.RTR=CAN_RTR_DATA;
TxHeader.IDE=CAN_ID_STD;
TxHeader.DLC=8;
TxHeader.TransmitGlobalTime=DISABLE;
TxData[0]=1;
TxData[1]=2;
TxData[2]=3;
TxData[3]=4;
TxData[4]=5;
TxData[5]=6;
TxData[6]=7;
TxData[7]=8;
/* USER CODE END 2 */

21

ISSIG 2018/2019
Etape 3:

Ajouter les instructions suivantes à fin d’envoyer le message dans une boucle infinie :
/*CAN send message

/* Infinite loop */
/* USER CODE BEGIN WHILE */
while(1)
{
/* USER CODE END WHILE */
/* USER CODE BEGIN 3 */
HAL_CAN_AddTxMessage(&hcan1, &TxHeader, TxData, &TxMailbox);
HAL_Delay(500);
TxData[7]=TxData[7]+1;
}
/* USER CODE END 3 */

Etape 4:

/*CAN TX callback
/*
/* USER CODE BEGIN 4 */
voidHAL_CAN_TxMailbox0CompleteCallback(CAN_HandleTypeDef *hcan)
{
HAL_GPIO_TogglePin(GPIOd,GPIO_PIN_15);
}
/*CAN RX callback
voidHAL_CAN_RxFifo0MsgPendingCallback(CAN_HandleTypeDef *hcan)
{
HAL_CAN_GetRxMessage(&hcan1, CAN_RX_FIFO0, &RxHeader, RxData);
HAL_GPIO_TogglePin(GPIOD,GPIO_PIN_15);
}
/* USER CODE END 4 */

A ce stade, nous avons terminé toute la configuration du Bus CAN sur la plateforme STM32. Il
reste la connexion physique entre deux nœuds au plus,

 Connecter les bornes TX et RX de deux cartes. N’oublier pas de mettre les résistances
(120 hom) entre l’émetteur et le récepteur de la même carte. La figure 4 représente
deux fils et deux résistances 120 Ω utilisés comme une couche physique relie les deux
nœuds CAN.

22

ISSIG 2018/2019
Fig.7 Câble relie deux nœuds CAN

 Compiler puis implémenter le code sur deux cartes.

Fig. 8

 Initialiser la routine d’exécution du programme sur le processeur de la carte STM32 en


appuyant sur le bouton reset (bouton noir). Si tout est bien fait, un deuxième appui sur
le bouton de la première carte allume la LED (LED indicative du bus CAN) de la deuxième
carte.

 Modifier le programme pour créer une interruption déclenchée par l'appui sur le bouton
poussoir du nœud N° 1 et allumer une diode LED du port D (LED 6 par exemple) du
nœud N°2.

23

ISSIG 2018/2019