d3 a0 - multipower...les onglets permettent de commuter entre les différentes zones de proteus...

MULTIPOWER – 83, Avenue d'Italie – 75013 PARIS – : 01 53 94 79 90 – www.multipower.fr

Document propriété de Multipower. Toute reproduction, même partielle, formellement interdite sans autorisation. 1

Proteus 8.5

Visual Designer V1.0

10uF1k

A22

1

4

3

Grove Luminance Sensor

2,3

1

APDS-9002

Grove LED

LED-GREEN

330

D32

1

4

3 A02

1

4

321.0

VO1

VCC3

GND2

GP2Y0A21YK0F

Grove Infrared Proximity Sensor



Sommaire

1 INTRODUCTION ............................................................................................................................ 3

1.1 Qu’est-ce qu’Arduino™ / Genuino™? ..................................................................................... 3

1.2 Qu’est-ce que Grove? ............................................................................................................. 4

2 VISITE GUIDEE .............................................................................................................................. 5

2.1 Généralités .............................................................................................................................. 5

2.2 Environnement Visual Designer .............................................................................................. 5

2.3 Menus, Icônes et Onglets ........................................................................................................ 6

2.4 Arbre de projet ......................................................................................................................... 7

2.5 Blocs d’algorigramme .............................................................................................................. 9

2.6 Fenêtre d’édition ...................................................................................................................... 9

2.7 Fenêtre de sortie.................................................................................................................... 10

2.8 Panneau de contrôle de la simulation ................................................................................... 10

2.9 Pop-ups actives ..................................................................................................................... 11

2.10 Fenêtre des variables ............................................................................................................. 12

3 Manipuler un algorigramme .......................................................................................................... 13

3.1 Généralités ............................................................................................................................ 13

3.2 Navigation .............................................................................................................................. 13

3.3 Placement, sélection et suppression des blocs ..................................................................... 14

3.3.1 Pour placer un bloc d’algorigramme .............................................................................. 14

3.3.2 Pour sélectionner un bloc d’algorigramme .................................................................... 15

3.3.3 Pour sélectionner plusieurs blocs .................................................................................. 15

3.3.4 Pour supprimer un bloc ................................................................................................. 15

3.3.5 Attacher, déplacer, détacher les blocs .......................................................................... 15

3.4 Editer un bloc ......................................................................................................................... 18

3.5 Connecter des blocs .............................................................................................................. 20

3.6 Commandes presse-papier ................................................................................................... 21

3.7 Ajouter, utiliser et supprimer des périphériques .................................................................... 22

3.8 Ajouter, utiliser ou supprimer des variables .......................................................................... 23

4 Simulation et débogage ................................................................................................................ 25

4.1 Généralités ............................................................................................................................ 25

4.2 Simulation du système .......................................................................................................... 26

4.3 Maîtrise du débogage ............................................................................................................ 28



1 INTRODUCTION Le Visual Designer est un outil de développement unique qui utilise des blocs d’algorigrammes en relation avec des portions de schémas de modules Arduino® pour permettre la création de systèmes enfouis par glisser-déposer.

Débogage pas à pas d’une carte d’extension moteur Adafruit dans le Visual Designer Ce document présente les différentes fonctionnalités du Visual Designer et présente plusieurs exemples de projets.

1.1 Qu’est-ce qu’Arduino® / Genuino™?

Arduino est un projet open-source matériel et logiciel basé sur une communauté d’utilisateurs et des fabricants de kits microcontrôleurs qui permettent de développer des modules numériques interactifs qui interagissent avec le monde réel.

Le projet est basé sur des cartes à microcontrôleurs fabriquées par plusieurs sociétés. Ces systèmes disposent de broches d’entrées-sorties numériques et analogiques qui s’interfacent à de nombreuses cartes d’extension (shields) et à d’autres circuits.



1.2 Qu’est-ce que le matériel Grove?

Grove est une plateforme de prototypage électronique rapide. Chaque module correspond à une fonction, tel qu’un capteur tactile, un effet audio, etc. Il suffit de connecter les modules à une carte de base pour tester vos idées.

Le starter kit Grove est l’outil idéal pour les débutants et étudiants afin de se lancer dans le monde Arduino. La carte Grove Base Shield permet de relier jusqu’à 16 modules Grove à une carte processeur Arduino.



2 VISITE GUIDEE

2.1 Généralités

Le Visual Designer est un outil pour concevoir des systèmes enfouis grâce à un simple algorigramme, puis le simuler et déboguer le système global. L’environnement de développement fournit à la fois l’outil d’édition de l’algorigramme et l’outil de débogage.

2.2 Environnement Visual Designer

La fenêtre d’édition

Lors de la conception, le système enfoui est créé en ajoutant à la fois des cartes ‘shields’ et une logique de contrôle. L’environnement Visual Designer est composé de 10 zones représentées ci-dessous.

L’environnement Visual Designer pendant la phase de conception d’un algorigramme.

1) Menus, Icônes et Onglets 2) Arbre de projet

3) Blocs d’algorigramme 4) Fenêtre d’édition

5) Fenêtre de sortie 6) Panneau de contrôle de la simulation



La fenêtre de débogage

Pendant la simulation et le débogage, l’environnement s’adapte pour présenter les outils nécessaires.

L’environnement pendant le débogage de la simulation en pas à pas.

7) Fenêtre code source 8) Fenêtre pop-up des périphériques

9) Pop-ups actives 10) Fenêtre des variables et débogage

2.3 Menus, Icônes et Onglets

Les commandes du menu de la partie supérieure sont classiques et les fonctionnalités plus spécifiques seront présentées dans le document lorsque nécessaire. Les onglets permettent de commuter entre les différentes zones de Proteus Design Suite. Nous travaillerons principalement avec le Visual Designer, mais nous nous référerons également au schéma car nous créerons un système enfoui (embedded system) qui nécessite la création d’un schéma. Le schéma sera automatiquement dessiné au fur et à mesure de l’ajout de périphériques ou de cartes d’extensions (shields) dans le Visual Designer. Il est possible de commuter à tout instant entre les onglets ‘Visual Designer’ et ‘schéma’ afin de visualiser le hardware virtuel. Vous pouvez également glisser-déposer un onglet sur un autre écran lorsque vous voulez voir les deux modules simultanément.

Transfert sur un second écran



2.4 Arbre de projet

L’arbre du projet du Visual Designer a trois rôles :

Il contrôle les feuilles de l’algorigramme

Il contrôle les ressources du système enfoui

Il contrôle les périphériques hardware du système enfoui

Contrôle des feuilles de l’algorigramme

Lorsque vous démarrez un nouveau projet, vous obtiennez une seule feuille dans la fenêtre d’édition qui s’appelle ‘Main’. Vous pouvez ajouter d’autres feuilles si la taille de votre programme le nécessite.

Ajouter et renommer une seconde feuille dans l’algorigramme. Lorsque vous avez plus d’une feuille dans votre projet, vous pouvez passer de l’une à l’autre par un double-clic sur le nom de la feuille dans l’arbre du projet. Il est également possible de sélectionner la feuille grâce aux onglets placés en haut de la fenêtre d’édition. Contrôle des fichiers ressources

Les fichiers ressource fournissent une façon pratique d’inclure des fichiers images et audios dans vos projets. Vous pouvez ajouter/retirer des fichiers ressources par un clic droit dans l’arbre du projet. Lorsque vous avez défini un fichier ressource, vous pouvez le glissez-déposer directement dans la fonction SETUP de votre algorigramme avec de lui associer un gestionnaire (handle).



Contrôle des périphériques du matériel (hardware)

Le Visual Designer est un environnement de développement pour systèmes enfouis, donc le bloc périphérique regroupe à la fois les périphériques du CPU et les périphériques externes (extension Arduino ou capteurs Grove) nécessaires à la conception du système.

Au lancement d’un nouveau projet, vous obtiendrez deux ou trois périphériques tel que le cœur CPU et le Timer lié au cœur du processeur. Vous pouvez ajouter des périphériques grâce au menu contextuel qui s’ouvre par un clic droit dans l’arbre du projet

Lorsqu’un périphérique est ajouté, vous verrez toutes les fonctions (méthodes) disponibles qui permettent de l’animer. Vous pourrez donc interagir avec le matériel par un glisser-déposer de la méthode dans l’algorigramme où elle apparaitra sous la forme d’un bloc périphérique I/O.

Ajout d’un capteur de lumière dans le projet Il est possible de renommer les périphériques ajoutés. Ceci est utile pour, par exemple, renommer plusieurs boutons ou LEDs afin de leur associer un nom représentatif de leur rôle. Cliquez droit sur le périphérique et choisissez l’option ‘renommer’ dans le menu contextuel.

Glissez-déposez la méthode directement dans l’éditeur d’algorigramme.



2.5 Blocs d’algorigramme

Les blocs d’algorigramme sont des briques de base qui permettent de construire votre programme. L’algorigramme s’enrichit par glisser-déposer depuis l’arbre de projet et par glisser-déposer de blocs d’algorigramme. Certains blocs, tels les blocs attente, boucle ou gestionnaire d’événement ne sont présents que dans cette colonne.

Icône Description Icône Description

Bloc événement ‘début’. Il s’utilise en relation avec un bloc événement ‘fin’ pour définir un sous-programme ou un gestionnaire d’événement.

Délai d’attente : Une attente dans l’exécution du programme.

Bloc événement ‘fin’. Il s’utilise en relation avec un bloc événement ‘début’ pour définir un sous-programme ou un gestionnaire d’événement.

Bloc ‘décision’: Une décision booléenne dans l’algorigramme.

Bloc ‘affectation’ à utiliser pour affecter une valeur à une variable.

Boucle : Utilisé pour définir les différents types de boucles.

Bloc ‘appel d’un sous-programme’.

Interconnecteur : Utilisé par paire afin de relier des séquences de blocs présentes dans des colonnes séparées de l’éditeur.

Bloc ‘données sauvegardées’. Utilisé pour spécifier une action sur un objet sauvegardé (telle une carte SD).

Commentaires : Permet d’ajouter du texte.

Bloc ‘opération I/O’ (périphérique): Utilisé pour spécifier une action sur la matériel, soit interne au CPU (t.q. le timer) ou externe (t.q. LCD).

2.6 Fenêtre d’édition

La fenêtre d’édition est l’endroit où vous concevez votre algorigramme pour créer le programme résultant. Lorsque le programme à créer est important, il nécessitera plusieurs feuilles qu’il est possible de parcourir grâce aux onglet de la partie supérieure.

Trois feuilles dans le programme avec la fenêtre d’édition qui montre la feuille ‘Main’.

La taille de la feuille que vous visualisez est représentée par une grille d’une certaine largeur et hauteur. La dimension des blocs et des autres objets de l’algorigramme s’adapte par rapport à cette grille. La commande ‘Configuration page’ du menu ‘Projet’ permet d’ajuster le nombre de points visibles de la grille. Ceci assure un ajustement de la taille relative des blocs de l’algorigramme à l’écran. Par exemple, si vous souhaitez que les blocs soient plus gros, réduisez le nombre de points dans la grille.



Lorsque vous imprimez l’algorigramme sur un papier, celui-ci s’adaptera automatiquement à la taille de la feuille de papier.

Vous pouvez zoomer avant ou arrière dans la fenêtre d’édition via la molette de la souris, en utilisant les touches F6 et F7 du clavier ou grâce aux icônes de la barre d’outils.

2.7 Fenêtre de sortie

La fenêtre de sortie est une zone d’information. Les erreurs y sont listées, notamment celles liées à la construction de l’algorigramme ou à la programmation du matériel physique.

2.8 Panneau de contrôle de la simulation

Les simulations interactives sont contrôlées par un simple panneau situé en bas et à gauche de l’écran. Il contient quatre boutons.

Le bouton JOUER (PLAY) lance le simulateur.

Le bouton PAS A PAS (STEP) avance la simulation d’un pas. Si le bouton est appuyé puis relâché, la simulation avance d’un pas temporel ; s’il est maintenu appuyé, la simulation avance continument jusqu’à ce qu’il soit relâché. Le pas d’incrément temporel peut être ajusté depuis la boite de dialogue de contrôle des circuits animés du menu ‘Système’.

Le pas temporel est pratique pour contrôler précisément le comportement des circuits.

Le bouton PAUSE suspend l’animation qui reprend lorsqu’on appuie à nouveau sur le bouton PAUSE, ou en pas à pas grâce au bouton STEP. Le simulateur est également placé en pause lorsqu’un point d’arrêt est rencontré.

Le simulateur est déchargé de la mémoire. Tous les indicateurs sont réinitialisés à leurs états inactifs mais les actionneurs (switchs, etc) conservent leurs états.

La fenêtre code source

La fenêtre code source est l’outil principal de débogage de votre projet dans Proteus. Elle permet d’avancer votre programme en pas à pas pour mettre à jour la totalité de votre système enfoui.

Lorsque la simulation est en pause, la simulation affiche en rouge le bloc de l’algorigramme en cours d’exécution.



Exécution de la simulation puis mise en pause avec affichage du programme pour un débogage en pas à pas.

Vous pouvez aussi décider de déboguer le code source plutôt que l’algorigramme. Pour cela il faut, en premier, sélectionner l’option ‘Déboguer le code généré’ depuis le menu contextuel de l’arbre de projet.

Fenêtre pop-up des périphériques

Certains périphériques affichent une fenêtre (popup) pendant la simulation. Par exemple, si vous ajoutez le module terminal Grove, vous obtiendrez une fenêtre terminal virtuel qui s’ouvrira pendant la simulation pour vous permettre de lire ou d’écrire du texte.

Terminal virtuel qui sert de console pour afficher la position du servo moteur

Les fenêtres pop-up des périphériques sont visibles pendant la simulation pour que vous puissiez interagir avec elles. Elles peuvent être fermées à tout instant par un clic sur la croix en haut et à droite de la fenêtre et peuvent être ré-ouvertes depuis le menu ‘Débogage’ lorsque la simulation est en pause.

2.9 Pop-ups actives

Les pop-ups actives sont des zones d’intérêts placées sur le schéma et qui apparaissent dans la partie droite du Visual Designer pendant le débogage. Elles ont deux rôles principaux :

1. Vous pouvez voir des portions de hardware pendant le débogage (par exemple, le texte qui s’affiche sur un LCD).



2. Vous pouvez interagir avec des éléments pendant le débogage (par exemple, appuyer sur un bouton ou ajuster un capteur).

Ces pop-ups actives évitent de devoir permuter entre le schéma et le firmware pendant le débogage. Vous concentrez ainsi toute l’information utile dans un seul onglet.

2.10 Fenêtre des variables

La fenêtre des variables est un outil de débogage qui liste les variables du programme pendant le débogage.

Accès aux types composés

La fenêtre des variables admet également les types composés (structures, unions, énumérations) et les pointeurs, en offrant un arbre qui affiche le contenu du type ou le pointeur déréférencé.

Notification de modification et valeurs précédentes

Une variable de la fenêtre des variables sera mise en surbrillance lorsqu’elle est modifiée et que la simulation est en pause. Vous pouvez aussi voir la valeur précédente de la variable en choisissant l’option ‘Voir valeur précédente’ du menu contextuel (clic droit dans la fenêtre des variables).



Lorsque vous visualisez un type composé (une structure par exemple) et qu’un élément du type change, alors seul cet élément sera mis en surbrillance. Ceci signifie que si l’arbre de ce type n’est pas déroulé (ouvert), nous ne verrez pas la modification de l’élément.

Ajouter dans la fenêtre de suivi (Watch)

La fenêtre des variables n’est pas visible pendant une simulation en roue libre contrairement à la fenêtre de suivi. Vous pouvez ajouter une variable dans la fenêtre de suivi par un clic droit dans le menu contextuel. Le menu ‘Débogage’ permet d’ouvrir la fenêtre de suivi des variables.

3 Manipuler un algorigramme

3.1 Généralités

Ce chapitre explique comment interagir avec l’éditeur d’algorigramme. Vous allez apprendre comment utiliser l’outil pour créer un programme. La simulation et le débogage sont traités dans des parties différentes

3.2 Navigation

Zoom avant ou arrière

Vous pouvez :

1) Utiliser la molette de la souris pour zoomer autour de la position de la souris.

2) Utiliser les icônes zoom pour provoquer un zoom par rapport au centre de la fenêtre d’édition.

3) Presser la touche F6 pour un zoom avant ou la touche F7 pour un zoom arrière. Le zoom s’effectue par rapport à la position de la souris. La touche F8 permet de visualiser la totalité de la feuille.

4) Pour définir un zoom autour d’une zone, maintenez la touche SHIFT enfoncée et étirez un rectangle avec le bouton gauche de la souris. Lorsque vous relâchez le bouton gauche, le rectangle défini sera zoomé pour occuper la totalité de la fenêtre d’édition.



Panoramique dans la feuille

Vous pouvez indifféremment :

1) Utiliser la molette de la souris en zoom arrière, vous déplacer à la position désirée puis utiliser à nouveau la molette pour faire un zoom avant.

2) Maintenir la touche SHIFT enfoncée et, avec la souris, venir cogner sur un bord de la fenêtre d’édition. Ceci provoquera un panoramique.

3.3 Placement, sélection et suppression des blocs

3.3.1 Pour placer un bloc d’algorigramme

Bloc d’action sur un périphérique :

Ajoutez le périphérique via un clic droit dans l’arbre de projet pour appeler le menu contextuel, puis glissez-déposez la méthode souhaitée dans la fenêtre d’édition.

Bloc sauvegarde de données :

Ajoutez la ressource via un clic droit dans l’arbre de projet pour appeler le menu contextuel, puis glissez-déposez dans la fenêtre d’édition.



Tout bloc d’algorigramme :

Glissez-déposez l’icône dans la fenêtre d’édition.

3.3.2 Pour sélectionner un bloc d’algorigramme

Cliquez gauche sur le bloc.

3.3.3 Pour sélectionner plusieurs blocs


1) Etirer un rectangle avec le bouton gauche de la souris sur les blocs à sélectionner.

2) Maintenir la touche SHIFT enfoncée puis cliquer sur les bocs individuellement.

3.3.4 Pour supprimer un bloc


1) Cliquer droit sur le bloc et choisir ‘Supprimer’ dans le menu contextuel.

2) Cliquer gauche pour sélectionner le bloc et utiliser la touche supprimer du clavier.

3.3.5 Attacher, déplacer, détacher les blocs

Pour déplacer un bloc non connecté

Sélectionnez le bloc par un clic gauche et déplacez-le.

Pour déplacer un bloc connecté

Sélectionnez et déplacez le bloc. Lorsque le bloc rencontre un autre bloc, l’ensemble s’adapte pour laisser la place nécessaire.

Vous pouvez utiliser cette technique pour faire de la place en déplaçant les blocs en haut et en bas.



Pour déplacer une série de blocs connectés

Si les blocs concernés incluent les blocs début et fin, il suffit d’étirer un rectangle autour d’eux et de les déplacer à l’endroit souhaité.

Déplacer la totalité d’une fonction

Déplacer la totalité d’une fonction

Si vous souhaitez déplacer une fonction sur une autre feuille, vous pouvez utiliser les possibilités de couper/coller du presse-papier entre deux feuilles.

Si vous souhaitez déplacer une série de blocs connectés qui font partie d’une fonction, vous pouvez les déconnecter pour les déplacer ailleurs.



Pour lier un bloc à l’algorigramme

Lorsque vous voulez insérer un bloc, il suffit de le glisser puis de le déposer à l’endroit souhaité. Pendant l’étape de glissement du bloc, des nœuds de connexions apparaissent lorsqu’il se superpose au lien. Relâchez pour que la connexion se fasse.

Les nœuds de connexion sont des indicateurs visuels qui signalent que vous pouvez relâcher la souris – la connexion se fera automatiquement.

Si vous devez insérer un bloc alors qu’il n’y a pas de place, vous pouvez déplacer un bloc existant vers le haut ou le bas afin qu’il pousse les autres éléments.

Détacher un bloc de l’algorigramme

Vous pouvez détacher ou déconnecter un bloc de deux façons :

1) Cliquez droit sur le bloc et sélectionnez la commande ‘Déconnecter’ du menu contextuel.

2) Sélectionnez le bloc et maintenez la touche CTRL enfoncée tout en déplaçant le bloc. Ceci le déconnectera et vous permettra de le positionner à un autre endroit.



Pour attacher une série de blocs

1) Prévoyez un espace suffisant pour insérer vos blocs.

2) Sélectionnez les blocs à insérer.

3) Déplacez-les à l’emplacement souhaité en vérifiant que les nœuds de connexions supérieur et inférieur sont bien visibles.

4) Relâchez la souris pour valider l’insertion.

Pour détacher une série de blocs

1) Sélectionnez les blocs à détacher.

2) Maintenez la touche CTRL enfoncée et déplacez les blocs en dehors de l’algorigramme ou utilisez la commande ‘Déconnecter’ du menu ‘Editer’.

3.4 Editer un bloc

Pour éditer un bloc vous pouvez cliquer droit et choisir la commande ‘Editer’ du menu contextuel ou double-cliquer sur le bloc.

Liste des variables et des fonctions

Lorsqu’elles existent, toutes les variables sont affichées en bas et à gauche de la boite de dialogue alors que les fonctions sont visibles en bas et à droite. Un double-clic sur la variable ou la fonction l’ajoute à l’expression.

Vous pouvez très simplement créer, éditer ou supprimer des variables via les boutons sous la zone d’affichage des variables.



Auto Complete

Le système d’auto-complétion s’activera lors d’une entrée, ce qui permet de compléter automatiquement les noms de variables ou d’apporter une aide sur l’utilisation d’une fonction. Utilisez les touches TAB ou ENTREE pour compléter automatiquement.

Auto complétion

Aide fonction

Contrôle de la syntaxe et des types

Une explication de la syntaxe et un contrôle des types interviennent lorsque vous entrez une expression. Le status sur l’expression est indiqué à droite et une icône rouge d’information fournit le détail des erreurs rencontrées.

Obtenir des informations sur les erreurs liées à une expression



3.5 Connecter des blocs

Les blocs sont reliés entre eux par des lignes de flux et le Visual Designer dispose d’un routeur de connexion. La règle d’or est que vous devez connecter une sortie à une entrée.

Nous recommandons de connecter les lignes du haut vers le bas pour rendre les boucles plus claires. Evitez les connexions du bas vers le haut !

Pour relier des blocs par une ligne de flux

1) Cliquez sur le nœud de sortie.

2) Déplacer la souris vers le nœud de destination (entrée).

3) Cliquez pour terminer la liaison.

Pour ajuster/déplacer une ligne de flux

1) Cliquez pour sélectionner la ligne de flux.

2) Le curseur souris changera pour indiquer la direction possible.

3) Etirez avec le bouton gauche de la souris.

Pour supprimer une ligne de flux

1) Cliquez droit sut la ligne de flux et validez la commande ‘Supprimer’ du menu contextuel.

Scinder l’algorigramme en plusieurs colonnes

Lorsque l’algorigramme d’une fonction risque de dépasser le bas de page, vous pouvez le découper pour le répartir sur plusieurs blocs interconnectés.

1) Cliquez droit sur une ligne de flux proche du bas de page et choisissez la commande ‘Scinder’ du menu contextuel.

2) Déplacez les blocs de la partie basse vers le haut et à droite.



3) Faites de la place.

4) Poursuivez votre conception en insérant d’autres blocs.

Pour modifier le flux d’un bloc de décision

1) Placez deux lignes de flux qui correspondent au deux chemins de sortie du bloc de décision.

2) Si les chemins OUI et NON doivent être intervertis, cliquez droit sur le bloc de décision et validez la commande ‘Permuter Oui/Non’.

3.6 Commandes presse-papier

Les commandes presse-papier du Visual Designer fonctionnent de la même manière que celles disponibles dans les applications Windows.

CTRL+X : Couper dans le presse-papier.

CTRL+C : Copier dans le presse-papier.

CTRL+V : Coller depuis le presse-papier.

Icônes.

Commandes du menu ‘Editer’.



Le presse-papier sert habituellement à organiser l’algorigramme et, en particulier, à déplacer les fonctions entre feuilles.

Souvenez-vous que si vous copiez-collez des blocs qui incluent de périphériques (hardware), le collage ne créera pas de nouveau hardware dans le schéma. Si c’est ce que vous souhaitez faire, vous devez ajouter un périphérique puis associer au bon bloc la méthode du nouveau périphérique.

3.7 Ajouter, utiliser et supprimer des périphériques

Pour ajouter un périphérique

1) Cliquez droit dans l’arbre de projet et choisissez la commande ‘Ajouter périphérique’ du menu contextuel.

2) Sélectionnez la carte d’extension (shield) ou le périphérique Grove dans le visionneur.

3) Si vous utilisez un périphérique Grove, il est possible que vous deviez modifier, dans le schéma, le label du connecteur, qui doit être unique.

Dans l’univers Arduino, il est facile d’ajouter deux shields incompatibles entre eux.

Par exemple, si deux shields utilisent le même timer CPU, il est peu probable que le programme fonctionne.

Vous devez vérifier cette compatibité vous-même, car le Visual Designer n’interfère pas avec les drivers Arduino.



Pour utiliser un périphérique

1) Développez l’arbre du projet pour accéder aux méthodes du périphérique.

2) Glissez-déposez la méthode dans l’algorigramme.

Pour supprimer un périphérique

1) Cliquez droit sur le périphérique dans l’arbre de projet et choisissez la commande ‘Retirer périphérique’ du menu contextuel.

2) Confirmez votre choix dans la boite de dialogue qui apparaît.

Si vous supprimez un périphérique, vous ne supprimerez pas les blocs qui référencent ce module. Vous devrez adapter ou supprimer ces blocs manuellement.

3.8 Ajouter, utiliser ou supprimer des variables

Les variables sont créées et utilisées dans des boites de dialogue qui manipulent les objets. Les variables sont toujours globales au projet. Les types suivants sont supportés :

Booléen (Boolean - VRAI / FAUX - TRUE / FALSE)

Entier (Integer - nombre entier)

Flottant (Float - nombre à virgule flottante)

Chaîne (String – Chaîne de caractères)

Handle (Handle – Gestionnaire de ressource).

L’éditeur d’expression contrôlera les types automatiquement.

Pour créer une nouvelle variable

1) Editez le bloc sur lequel vous travaillez.

2) En bas et à gauche, utilisez le bouton ‘Nouveau’ pour créer une variable.

3) Entrez le nom de la variable et affectez un type.



4) Cliquez sur OK pour sortir.

1 : Clic sur Nouveau. 2 : Définir la variable et clic sur OK. Pour utiliser une variable existante

Editez le bloc sur lequel vous travaillez puis indifféremment :

1) Utilisez la liste déroulante des variables pour choisir celle qui vous convient.

2) Entrez le nom et servez-vous de l’auto complétion pour terminer la saisie.

3) Double cliquez sur le nom de variable dans la liste pour l’insérer dans l’expression.



Pour éditer une variable

1) Editez un bloc de l’algorigramme.

2) Sélectionnez la variable dans la liste à gauche.

3) Cliquez sur le bouton ‘Editer’ puis modifiez le nom et/ou le type.

Pour supprimer une variable

1) Editez un des blocs de l’algorigramme.

2) Sélectionnez la variable dans la liste à gauche.

3) Cliquez sur ‘Supprimer’ pour retirer cette variable.

4 Simulation et débogage

4.1 Généralités

Lors du développement de votre système enfoui, vous souhaiterez certainement tester votre programme pendant sa conception ou lorsqu’il sera terminé. Il est exceptionnel de concevoir un programme sans erreur du premier coup, c’est pourquoi vous aurez besoin d’outils de débogage pour trouver et corriger les erreurs.

Le Visual Designer rend ce processus très simple car il contient tous les outils pour simuler, déboguer et mesurer.



4.2 Simulation du système

Lorsque vous ajoutez des périphériques pour les contrôler dans votre algorigramme, vous construisez un système enfoui. De façon générale, il y aura une carte à microcontrôleur et quelques éléments hardware qui représentent les périphériques.

Pouvoir simuler le système global est une des grandes forces de Proteus car vous pouvez simuler le microcontrôleur connecté à de l’électronique analogique et numérique. Vous pourrez interagir avec le système, le tester et le déboguer dans totalité.

Pour lancer la simulation

Pour lancer la simulation appuyez sur le raccourci clavier F12 ou utilisez le bouton Jouer (Play) du panneau de contrôle. Le programme sera compilé et l’avancement de la simulation sera indiqué dans la barre de status.

Le temps qui s’écoule est montré dans la barre de status.

Pour arrêter la simulation Pour arrêter la simulation appuyez sur le raccourci clavier ECHAPPEMENT ou utilisez le bouton Stop du panneau de contrôle. Le programme se termine et le Visual Designer revient en mode édition.

Arrêter la simulation.

Pour mettre la simulation en pause

Le concept de Pause dans Proteus est essentiel ; vous arrêtez le temps en conservant l’état du système. Par exemple, les condensateurs ne se déchargeront pas et un moteur conservera sa position angulaire et son moment. Ceci vous permettra d’inspecter à la fois votre programme et votre hardware virtuel. Lorsque vous avancerez d’un pas temporel, le système global évoluera synchronisme. Votre système enfoui est synchrone de l’horloge de la barre de status, pas de celle sur le mur, et vous avez la charge de cette horloge ! C’est extrêmement puissant et nous allons présenter toutes les possibilités liées à ce concept.

Pour mettre en pause appuyez sur le raccourci clavier PAUSE ou utilisez le bouton Pause du panneau de contrôle.

Simulation en pause

Une simulation sera également mise en pause automatiquement lorsqu’un point d’arrêt est rencontré. Lorsque la simulation est en pause, le Visual Designer sera dans un mode de débogage et l’algorigramme ainsi que différentes fenêtres de débogage deviendront disponibles.



La pause prépare le débogage.

Vous ne verrez pas l’algorigramme lors d’une exécution libre car le programme s’exécute si rapidement qu’il est impossible de montrer la position courante.

Pour interagir avec la simulation

Lorsque la simulation est lancée vous verrez le Visual Designer en mode débogage avec tous les éléments interactifs alignés dans la partie droite. Ce seront certainement un mélange d’indicateurs (led’s, LCD’s, etc) qui fourniront un retour sur l’état du système et des actionneurs (boutons, clavier, etc) qui permettront d’interagir avec la simulation.

Voici un exemple dans lequel nous ajustons un capteur de proximité infrarouge.

1) Lancez la simulation

2) Déplacez la souris au-dessus des flèches d’ajustement du capteur.

3) Cliquez vers le haut ou le bas.

Cliquer sur les dispositifs d’ajustement du capteur imite le comportement d’un test réel.

Vous pouvez également commuter sur le schéma pour interagir avec cet écran si vous préférez.

Cependant il est plus commode d’avoir tout au même endroit, particulièrement pendant une session de débogage lorsque vous voulez voir le hardware pendant le pas à pas de l’algorigramme.



4.3 Maîtrise du débogage

Pour définir un point d’arrêt logiciel

Cliquez droit sur le bloc de l’algorigramme soit avant la simulation ou lorsque la simulation est en pause par sélection de la commande ‘Commuter point d’arrêt’ du menu contextuel.

Pour avancer le débogage d’un pas

Lorsque la simulation est en pause, utilisez les commandes de pas à pas situées en haut de la fenêtre ou les raccourcis clavier F10 and F1.

Pour avancer jusqu’à un bloc

Pour avancer directement jusqu’à un bloc spécifique de l’algorigramme, commencez par mettre la simulation en pause, puis cliquez droit sur le bloc et validez la commande ‘Pas à pas jusqu’à’ du menu contextuel.

Pour définir un point d’arrêt temporel

Il peut être utile de mettre la simulation en pause après un certain temps. Pour ce faire, sélectionnez la commande ‘Lancer la simulation (point d’arrêt temporel)’ du menu ‘Débogage’.



Pour définir un point d’arrêt matériel

Vous pouvez également définir un point d’arrêt sur une condition matérielle par opposition à une condition logicielle. Voici la procédure :

1) La simulation doit être arrêtée. Commutez sur l’onglet du schéma.

2) Placez une sonde de tension sur le fil d’intérêt.

3) Editez la sonde et configurez le point d’arrêt temps réel. 4) Lancez la simulation.

Pour ajouter une variable à la fenêtre de suivi (watch)

La fenêtre de suivi est la seule fenêtre de débogage disponible lorsque la simulation est lancée en roue libre. Il est donc possible d’y ajouter une variable du programme pour contrôler sa valeur pendant l’exécution. Pour cela :

1) Lorsque la simulation est en pause, ouvrez la fenêtre de suivi depuis le menu ‘Débogage’. Par défaut, le fenêtre est ancrée dans le bas de l’écran.



2) Validez l’onglet fenêtre des variables, cliquez droit sur la variable et sélectionnez le choix 'Ajouter à la fenêtre de suivi’.

3) Revenez sur la fenêtre de suivi (watch) et lancez la simulation.

Attention : Les variables sont identifiées par adresses dans la fenêtre de suivi. Ceci signifie que, si vous modifiez votre programme entre deux simulations, il est possible que le compilateur réaffecte les adresses. Dans ce cas vous ne pourrez pas suivre correctement les valeurs de la variable. Ceci peut être source de confusion, aussi est-il préférable de supprimer et ajouter à nouveau la variable dans la fenêtre de suivi après avoir modifié votre programme.

Pour ajouter d’autres items à la fenêtre de suivi

La fenêtre de suivi permet de surveiller la mémoire, donc vous pouvez ajouter les registres AVR et d’autres adresses programme. Par exemple, pour ajouter un registre :

1) Avec la simulation en pause, assurez-vous que la fenêtre de suivi (watch) est ouverte dans le menu ‘Débogage’.



2) Cliquez droit dans la fenêtre de suivi et sélectionnez ‘Ajouter items par nom’.

3) Sélectionnez le registre à suivre et ajoutez-le.

Pour définir un point d’arrêt conditionnel

Un point d’arrêt conditionnel (un point de suivi) permet de définir une condition sur un item de la fenêtre de suivi qui provoquera une pause dans l’exécution. Par exemple, vous pouvez mettre en pause chaque fois que le timer déborde. Pour définir une condition point de suivi :

1) Utilisez les méthodes décrites plus haut pour ajouter une variable ou un registre dans la fenêtre de suivi.

2) Cliquez droit sur l’item dans la fenêtre de suivi et sélectionnez la commande ‘Condition point de suivi’ du menu contextuel.

3) Configurer comme nécessaire.

4) Lancez la simulation

Il existe une option qui indique si le point de suivi est une condition globale (Global Break Condition). Ceci précise si la simulation est suspendue lorsque n’importe quelle expression sur un des items est vraie, ou uniquement lorsque toutes les points de suivi sont vrais.



Pour ouvrir une fenêtre de débogage

En plus des fenêtres source, variables et de suivi (watch) nous vous recommandons d’explorer les autres fenêtres disponibles. Plus vous vous familiariserez avec les outils disponibles, plus vous améliorerez votre capacité à trouver des solutions.

1) Mettez la simulation en pause.

2) Lancez la fenêtre de débogage qui vous intéresse depuis le menu ‘Débogage’.

d3 a0 - multipower...les onglets permettent de commuter entre les différentes zones de proteus...

Documents