Table des matières
Introduction générale ........................................................................................................................................................... 3
Formation 1: LabVIEW Embarqué et Acquisition .............................................................................................................. 4
Introduction : ................................................................................................................................................................... 4
1- Définition ................................................................................................................................................................. 6
2- Machine d’état ......................................................................................................................................................... 6
3- Application .............................................................................................................................................................. 6
Conclusion ....................................................................................................................................................................... 7
Formation 2: TIA PORTAL ................................................................................................................................................ 7
Introduction...................................................................................................................................................................... 7
1- Présentation de l’environnement : ........................................................................................................................... 7
1-1 Création d’un projet sous TIA PORTAL : ........................................................................................................... 8
1-2 Configuration des appareils ................................................................................................................................. 8
1-3 Table de variables API et adressage : .................................................................................................................. 9
1-4 Les blocs de programme utilisé ......................................................................................................................... 10
1-5 Programme en langage LADDER : ................................................................................................................... 10
Conclusion ..................................................................................................................................................................... 11
Formation 3: STM32 ......................................................................................................................................................... 11
Introduction : ................................................................................................................................................................. 11
1. Définition ............................................................................................................................................................... 11
2. Applications ........................................................................................................................................................... 11
2-1 Allumer une LED............................................................................................................................................... 12
2-2 Allumer une LED avec le ‘User button’ .............................................................................................................. 8
Conclusion : ................................................................................................................................................................... 13
Formation 4: Deep et Machine learning sous NVIDIA .................................................................................................... 13
Introduction : ................................................................................................................................................................. 13
1- Installation & configuration PYTHON ,OPEN CV , KERAS(deep learning) ...................................................... 14
2- Installation & configuration sur CLOUD .............................................................................................................. 15
Conclusion ..................................................................................................................................................................... 16
Formation 5: Les formations de ACTIA ........................................................................................................................... 16
Introduction : ................................................................................................................................................................. 16
1- Formation sur L’impression 3D ................................................................................................................................ 16
2- Formation RUST ............................................................................................................................................... 16
2-1 Définition ........................................................................................................................................................... 17
2-2 Pourquoi choisir Rust pour les systémes embarqués ......................................................................................... 17
Conclusion : ................................................................................................................................................................... 17
Conclusion générale........................................................................................................................................................... 18
1
Table des figures :
Figure 1: Interfaçe de Labview ............................................................................................................................................ 4
Figure 2: Palette de Fonction ............................................................................................................................................... 5
Figure 3: Palette de contrôle ................................................................................................................................................ 5
Figure 4: Structure d'une machine d'état .............................................................................................................................. 6
Figure 5: Bloc diagramme ................................................................................................................................................... 6
Figure 6: Front panel ........................................................................................................................................................... 6
Figure 7: Création de projet ................................................................................................................................................. 7
Figure 8: Fenetre d'accueil ................................................................................................................................................... 7
Figure 9: choix de CPU ....................................................................................................................................................... 8
Figure 10: Les modules E/S ................................................................................................................................................. 8
Figure 11: Table de variables............................................................................................................................................... 9
Figure 12 : Les différents blocs de programme ................................................................................................................... 9
Figure 13 : Configuration des pins .................................................................................................................................... 11
Figure 14: Le Code ............................................................................................................................................................ 12
Figure 15: Configuration des pins ..................................................................................................................................... 12
Figure 16: Le code ............................................................................................................................................................. 12
Figure 17: Installation python ............................................................................................................................................ 13
Figure 18: Version installée ............................................................................................................................................... 13
Figure 19: Création d'un nouveau note book ..................................................................................................................... 14
Figure 20: configuration de l'environnement GPU ............................................................................................................ 14
Figure 21: Installation de bibliothéques............................................................................................................................. 14
Figure 22: Téléchargement de datasets depuis Google Drive ........................................................................................... 15
Figure 23: L'impression 3D ............................................................................................................................................... 16
Figure 24: RUST................................................................................................................................................................ 17
2
Introduction générale
À l’École Nationale d’Ingénieurs de Monastir, nous avons l’opportunité de profiter d’une période inter
semestre, durant laquelle nous pouvons choisir entre effectuer un stage ou participer à une série de sessions de
formation encadrées par le chef de département. Ces deux options constituent des compléments enrichissants à
notre parcours : l’une nous immerge dans le monde professionnel, l’autre nous permet de renforcer nos
compétences grâce à des intervenants qualifiés issus du domaine.
Chaque année, le contenu et les animateurs des formations varient, apportant une diversité précieuse à chaque
promotion. Dans ce rapport, je présenterai les sessions de formation proposées à ma cohorte, en tant
qu’étudiante en deuxième année de génie électrique. Ces formations contribuent grandement à notre
développement académique et professionnel, en nous ouvrant à de nouvelles perspectives et en consolidant
des compétences clés dans le domaine de l’ingénierie.
Parmi les thématiques abordées cette année figurent : LabVIEW, TIA Portal, STM32, etc…
3
Formation 1 : LabVIEW Embarqué et
Acquisition
Introduction :
Pour la première semaine de l'intersession, nous avons consacré notre temps à une formation sur
LabVIEW. Dans cette section, nous allons passer en revue en détail les bénéfices de cette semaine de
formation LabVIEW.
1 - Définition :
La première session de LabVIEW a été une révision, car nous avions déjà suivi cette formation au cours de
notre première année. Ainsi, nous avons commencé par actualiser nos connaissances avec des informations
de base sur l'interface de LabVIEW. Pendant cette séance, nous avons revisité les principes fondamentaux
de LabVIEW, en passant en revue les concepts clés et les fonctionnalités de l'interface. C'était l'occasion de
se remémorer les principes de la programmation graphique, les structures de contrôle, ainsi que les outils
de mesure disponibles dans LabVIEW.
Figure 1 : Interface de LABVIEW
La figure 1 dépeint l'interface de LabVIEW, constituée de deux fenêtres distinctes : le panneau frontal et le
diagramme de blocs.
Le Panneau Frontal : Cette première fenêtre visible dans la figure est l'espace où nous disposons nos
éléments de conception. Le panneau frontal agit comme l'interface utilisateur de notre programme,
affichant les contrôles et indicateurs que nous utilisons pour interagir avec notre application. Il est
également l'endroit où nous pouvons observer en temps réel les résultats et les données générés par notre
programme.
Le Diagramme de Blocs : La deuxième fenêtre dans la figure représente le diagramme de blocs. C'est ici
que se déroule notre programmation réelle. Dans cette fenêtre, nous connectons les éléments de conception
du panneau frontal en utilisant des connexions graphiques. Ces connexions définissent le flux de données et
d'instructions à travers notre programme. Le diagramme de blocs utilise une représentation graphique
intuitive pour illustrer la logique de notre application.
4
Figure 1: Palette de fonction Figure 2: Palette de contrôle
Les figures suivantes présentent la palette de contrôles et la palette de fonctions pour chaque panneau
respectivement. Elles regroupent tous les éléments nécessaires pour répondre à l'ensemble de nos besoins
en programmation.
- Palette de Fonctions: La Figure 2 montre la palette de fonctions. Cette palette contient un ensemble
complet d'outils fonctionnels que nous pouvons utiliser dans le diagramme de blocs pour construire la
logique de notre programme. Elle englobe des opérations mathématiques, des structures de contrôle, des
fonctions de manipulation de données, et bien plus encore. En sélectionnant et connectant ces fonctions
dans le diagramme de blocs, nous définissons le comportement et la logique de notre application
LabVIEW.
- Palette de Contrôles: La Figure 3 affiche la palette de contrôles. Cette palette regroupe une variété
d'éléments graphiques comme des boutons, des cadrans, des interrupteurs, des indicateurs numériques, et
d'autres éléments interactifs. En sélectionnant et plaçant ces contrôles sur le panneau frontal, nous
définissons la manière dont les utilisateurs interagiront avec notre programme.
La facilité d'accès à ces palettes simplifie la création d'applications complexes en offrant une large
sélection d'éléments préconstruits et d'outils fonctionnels. Cette approche facilite la mise en place efficace
de la conception et de la logique de contrôle, ce qui renforce l'accessibilité de LabVIEW pour les
ingénieurs et les programmeurs.
5
2- La machine d’état :
La machine d'état dans LabVIEW est une méthode graphique efficace pour concevoir des applications qui
impliquent divers états. Elle fait usage de structures telles que la "Structure de cas" et la "Structure
d'événements". Chaque état représente un comportement particulier, avec des transitions déclenchées par
des événements. Cette approche simplifie le processus de développement et de compréhension des
systèmes, ce qui la rend idéale pour les applications d'automatisation et de contrôle industriel.
Figure 3: Structure d'une machine d'état
3- Application :
Pratiquement chaque session de formation nous met au défi de développer une nouvelle application :
Nous avons conçu un programme basique qui vise à collecter la température entrée par l'utilisateur. À
chaque répétition, le programme compare cette valeur avec des seuils prédéfinis (maximum et minimum),
et affiche un message approprié en conséquence. Nous avons utilisé la structure de boucle "while", comme
démontré dans le code ci-dessous.
Figure 4: Bloc diagramme Figure 5: Front panel
Conclusion :
En récapitulant, cette formation enrichissante nous a permis de développer les compétences et les
connaissances approfondies nécessaires pour concevoir avec succès des programmes complexes et
efficaces en utilisant LabVIEW.
6
Formation 2 : TIA PORTAL
Introduction :
Dans cette section, nous explorerons l'environnement de programmation du TIA Portal, passerons en revue
les diverses procédures et règles d'automatisation, et effectuerons plusieurs exercices pour consolider notre
compréhension tout au long du processus.
1- Présentation de l’environnement :
1-1 Création d’un projet sous TIA PORTAL :
Dès que le logiciel est lancé, une fenêtre s'ouvre (voir Figure 9) permettant de créer un nouveau projet ou
d'ouvrir un projet déjà existant.
Figure 7: Création du projet
Passant par la création d’un nouveau projet, une autre page (figure 10) se déclenche.
Figure 8: Fenêtre d'accueil
7
Dans cette fenêtre, vous trouverez les éléments suivants :
- Choix de thème
- Bloc des tâches
- Blocs de mise en route :
En sélectionnant "Configurer un appareil", une liste de contrôleurs, d'IHM et de systèmes PC s'affiche, vous
permettant de choisir l'appareil à programmer, comme illustré dans la figure 11.
Figure 9 : Choix de CPU
1-2 Configuration des appareils :
Avant de commencer un programme, il est crucial de sélectionner les modules d'E/S à connecter à notre
appareil, comme indiqué dans la figure 12.
Figure 6: Les modules E/S
1-3 Table de variables API et adressage :
Il est indispensable d'intégrer les entrées et les sorties dans la table des variables, où l'on spécifie les
entrées/sorties du Grafcet. Les entrées sont identifiées par %I suivie de l'adresse de la variable, tandis que les
sorties sont désignées par %Q suivie de l'adresse de la variable. Quant aux étapes, elles sont définies par une
adresse mémoire précédée de %M. Chaque variable possède un type défini (Bool, Byte, Char, Int).
8
Figure 11 : Table de variables
1-4 Les blocs de programme utilisé :
Après avoir défini la table des variables, nous entamons la programmation en utilisant des blocs pour gérer
des tâches spécifiques. L'automate propose différents types de blocs, chacun contenant des programmes et
des données correspondantes. Selon les exigences et la complexité, il est possible de diviser le programme
en différents blocs :
- OB : Les blocs d'organisation assurent la liaison entre le système d'exploitation de la CPU S7 et le
programme utilisateur. Ainsi, dans ce bloc, nous pouvons définir la séquence d'exécution des blocs de
programme utilisateur.
- FB : Les blocs fonctionnels sont des blocs de code statique avec mémoire, permettant d'accéder à leurs
paramètres depuis n'importe quelle position du programme utilisateur. Ils sont généralement utilisés pour
des tâches répétitives telles que l'acquisition de données à partir de compteurs, de convertisseurs
analogiques, etc.
- FC : Les fonctions sont des blocs de code sans mémoire.
- DB : Les blocs de données sont des espaces du programme utilisateur contenant des données utilisateur.
Figure 12 : Les différents blocs de programme
9
1-5 Programme en langage LADDER :
Après la conception du Grafcet, nous passons à la traduction en langage LADDER, un langage de programmation
couramment utilisé pour les automates industriels. Dans ce langage, les fonctions ET sont représentées par des
contacts en série, tandis que les fonctions OU sont représentées par des contacts en parallèle. Les bobines sont
généralement notées 'S’pour le SET et 'R' pour le RESET.
3- Conclusion
En résumé, la formation sur TIA Portal nous a permis de nous familiariser avec cet environnement de
développement d'automatisation et d'illustrer comment il peut être exploité pour concevoir des solutions
d'automatisation efficaces et novatrices dans différents secteurs industriels.
10
Formation 3 : STM32
Introduction :
L'objectif de cette formation sur STM32 est de fournir les connaissances et les compétences nécessaires pour
maîtriser le développement et la programmation de systèmes embarqués en utilisant la famille de
microcontrôleurs STM32.
1- Définition :
STM32, développé par STMicroelectronics, représente une famille de microcontrôleurs qui a acquis une
reconnaissance mondiale dans le domaine des systèmes embarqués. Dotés d'une architecture avancée, de
fonctionnalités polyvalentes et d'une vaste gamme d'options, ces microcontrôleurs sont au cœur de nombreux
projets de développement d'applications embarquées.
En ce qui concerne STM32CubeIDE, il s'agit de l'environnement de développement intégré (IDE) dédié aux
microcontrôleurs STM32. Conçu pour simplifier et accélérer le processus de développement,
STM32CubeIDE regroupe des outils puissants, des bibliothèques de périphériques, ainsi qu'une interface
conviviale pour faciliter la programmation, la simulation, le débogage et le déploiement des applications sur
les microcontrôleurs STM32.
2- Applications :
Au cours de cette formation, on a appris à manipuler plusieurs fonctionnalités du microcontrôleur STM32,
principalement :
2-1 Allumer Une LED :
Figure 13 : Configuration des pins
11
Figure 14 : Le code
2-2 Allumer une led avec le ‘ user button’ :
Figure 15 : Configuration des pins
Figure 16 : Le code
Conclusion :
En résumé, l'objectif de cette formation était de nous fournir les compétences techniques nécessaires pour
concevoir et mettre en œuvre des solutions embarquées innovantes en utilisant la carte STM32.
12
Formation 4 : Deep et Machine Learning
sous NVIDIA
Introduction :
NVIDIA est une entreprise américaine spécialisée dans la conception de processeurs graphiques (GPU), de
technologies de calcul haute performance et d’intelligence artificielle. Elle est surtout connue pour ses cartes
graphiques GeForce utilisées dans les jeux vidéo, mais elle joue également un rôle majeur dans des domaines
comme le deep learning, les voitures autonomes, et les data centers grâce à ses GPU puissants et sa plateforme
CUDA
1- Installation & Configuration : Python, Open CV, Keras (Deep Learning) :
Télécharger python à partir du lien suivant : [Link]
Figure 17 : installation Python
Installer python en double clic sur l’exécutable de l’installation de python téléchargé
Figure 18 : Version Installée
13
Bibliothèques Python pour l'apprentissage automatique et l'apprentissage profond :
Python est l’un des langages les plus populaires pour l’apprentissage automatique et l’apprentissage profond,
grâce à son écosystème riche en bibliothèques spécialisées. Ces outils permettent de simplifier la création,
l’entraînement et l’évaluation de modèles complexes. Dans cette section, nous explorerons les principales
bibliothèques utilisées dans ces domaines : Jupyter Notebook, Numpy, Matplotlib, Scikit-learn, Pandas, Keras et
TensorFlow
2- Installation & Configuration sur Cloud
Pour exécuter des projets en apprentissage automatique sans configuration locale, des plateformes cloud
comme Google Colab et Kaggle offrent des environnements prêts à l'emploi. Dans ce TP, nous nous
concentrerons sur Google Colab, qui propose un accès gratuit à des GPU et une intégration facile avec Python
et ses bibliothèques
Figure 19 : Création d’un nouveau notebook
Figure 20 : Configuration de l’environnement GPU
14
Figure 21 : Installation de bibliothèques
Figure 22 : Téléchargement de datasets depuis GOOGLE DRIVE
Conclusion :
La formation sur le Deep Learning et le Machine Learning animée sous l’écosystème NVIDIA nous a permis
de découvrir les fondements et les applications pratiques de l’intelligence artificielle à travers des outils
puissants. Elle nous a offert une introduction concrète aux réseaux de neurones, à l'entraînement de modèles
sur GPU, ainsi qu’à l’optimisation des performances de calcul.
15
Chapitre 5 : Les formations de ACTIA
Introduction :
Dans le cadre de l’inter semestre, nous avons suivi une formation encadrée par l’entreprise ACTIA,
spécialisée dans les systèmes électroniques embarqués. Cette session nous a permis de découvrir des
technologies industrielles avancées et d’approfondir nos connaissances pratiques en lien avec notre spécialité
en génie électrique.
1- Formation sur l’impression 3D :
1-1 Définition :
L’impression 3D, aussi appelée fabrication additive, est un procédé de fabrication qui permet de créer un objet
physique en superposant des couches successives de matériau à partir d’un modèle numérique en trois
dimensions (fichier 3D). Cette technologie est utilisée dans de nombreux domaines comme l’ingénierie, la
médecine, l’aéronautique ou encore le design.
1-2 Rôle :
Le rôle de l’impression 3D est de permettre la fabrication rapide, personnalisée et économique de prototypes,
de pièces techniques ou d’objets finis, tout en réduisant les déchets, les coûts de production et les délais de
développement dans divers secteurs industriels.
Figure : L’imprimante 3D
16
2- Formation RUST :
2-1 Définition :
Rust est un langage de programmation compilé, moderne et sécurisé, conçu pour offrir à la fois performance,
sécurité mémoire et concurrence sans recourir à un ramasse-miettes (garbage collector). Développé
initialement par Mozilla, Rust est particulièrement apprécié pour sa capacité à prévenir les erreurs de
segmentation et les conditions de concurrence à la compilation.
2-2 Pourquoi choisir Rust pour les systèmes embarqués ?
Rust est particulièrement adapté aux systèmes embarqués grâce à sa capacité à offrir des performances
proches du C/C++ tout en garantissant une sécurité mémoire stricte sans garbage collector. Il permet de
développer du code fiable, sans erreurs de segmentation, et d'exploiter pleinement les ressources limitées des
microcontrôleurs, ce qui en fait un excellent choix pour les applications critiques en temps réel.
Figure 24 : RUST
17
Conclusion Générale
Les formations proposées à l’École Nationale d’Ingénieurs de Monastir durant la période intersemestre
constituent une réelle valeur ajoutée à notre parcours académique. En nous exposant à des outils modernes,
des technologies avancées et des intervenants du monde industriel, elles nous permettent de compléter notre
formation théorique par des compétences pratiques essentielles.
18