Qu'apportent les périphériques indépendants du cœur (CIP) à une application ? Ils permettent aux utilisateurs d'automatiser certaines tâches généralement exécutées par l'unité de traitement centrale selon des instructions écrites au sein du logiciel. Les CIP réduisent également la quantité de code qu'un développeur doit écrire, tout en créant un système de faible puissance plus réactif. Cette vidéo de Microchip explique en détail ce que sont les CIP, de quelle manière les utiliser et ce qu'ils apportent à votre projet.
Bonjour à tous, ici Marc McComb, aujourd'hui, je vous propose de découvrir plus en détail les périphériques indépendants du cœur.
Vous n'êtes certainement pas sans savoir que les architectures de microcontrôleurs PIC et AVR sont chargées via des périphériques. Nombre de ceux-ci sont appelés périphériques indépendants du cœur, ou CIP. Ces périphériques ont été développés afin d'automatiser certaines tâches traditionnellement exécutées par l'unité de traitement ou le cœur, selon des instructions écrites par le développeur au sein du logiciel.
Les périphériques indépendants du cœur possèdent des avantages intrinsèques tels que la réduction de la quantité de code qu'un développeur doit écrire, tout en aidant en parallèle à créer un système de faible puissance plus réactif. Dans cette vidéo, je souhaite vous fournir une idée générale de ce que les périphériques indépendants du cœur apportent à une application.
Pour cela, je vais utiliser un exemple basique dans lequel je veux basculer entre les états haut et bas d'une broche E/S d'un port, créant ainsi une onde de forme carrée. Afin d'obtenir ce signal carré, j'ai écrit des lignes de code permettant de faire basculer la sortie de l'état haut vers l'état bas, et vice-versa, avec un système de boucle présenté sur cet organigramme.
Permettez-moi maintenant d'ajouter une autre tâche à cette application. Considérons qu'à chaque fois qu'un bouton-poussoir connecté à une autre broche du microcontrôleur est pressé, nous voulons conduire une impulsion de sortie sur une autre broche, durant environ deux millisecondes, un peu à la manière d'un one-shot ou multivibrateur monostable.
Si nous avions un microcontrôleur doté de périphériques rudimentaires, nous aurions besoin d'implémenter cette tâche supplémentaire à l'aide d'interruptions, comme ceci. Ici, j'utilise un périphérique d'horloge basique et un port entrée/sortie ordinaire connectés au bouton-poussoir. La plupart de ces périphériques sont capables de générer des interruptions communes que vous pouvez retrouver sur les microcontrôleurs les plus modernes.
La première interruption que je vais utiliser peut être générée par le périphérique E/S lorsqu'une variation de tension a lieu sur une broche associée. Ainsi, lorsque l'on presse le bouton-poussoir, la tension de la broche passe à zéro volt car le bouton est ici à l'état haut et une interruption est déclenchée. Lorsque le cœur est notifié qu'une interruption de port E/S a été déclenchée, il effectue un contrôle de priorité d'interruption logicielle, ou bien matérielle si le microcontrôleur est équipé.
Cela nous permet de nous assurer qu'aucune autre interruption ayant la priorité sur celle du port E/S n'ait lieu en même temps. Dans le cas contraire, le cœur fait appel à la routine d'interruption du port E/S. Durant cette routine, le cœur a pour instruction de réinitialiser l'horloge, de la charger à une valeur spécifique afin de lui permettre de déborder à précisément 2 millisecondes. L'horloge commence alors son décompte.
Le cœur a également pour instruction de passer notre broche de sortie à l'état haut. Cela génère la courbe montante de notre signal monocoup. Lorsque la routine d'interruption prend fin, le cœur peut revenir à ses tâches précédentes, c'est-à-dire faire basculer notre signal carré dans le cas présent. Le cœur continue donc à faire basculer ce signal jusqu'à ce que l'horloge déborde une fois les deux millisecondes configurées passées, déclenchant ainsi une interruption, comme dans le cas de la priorité d'interruption de port E/S implémentée dans le matériel ou le logiciel. Lorsqu'aucune autre interruption n'est prioritaire, la routine d'interruption de l'horloge se déclenche.
Lorsque le code en donne l'ordre, le cœur réinitialise et stoppe l'horloge puis fait descendre notre signal monocoup. Ce code n'a donc rien de très compliqué, mais nous ne devons pas oublier que toutes ces étapes durant lesquelles l'interruption a lieu, est ensuite reconnue, priorisée, avant que la routine matérielle associée ne soit exécutée, prennent du temps. Temps durant lequel le cœur ne peut pas faire basculer notre signal carré.
Démontrons ceci. J'ai écrit les lignes de code pour cette application et je les ai téléchargées sur un microcontrôleur. Un oscilloscope est connecté aux deux broches de sortie. Le signal bleu correspond à la génération par le cœur de notre signal carré, faisant à chaque fois basculer la broche via la boucle. Regardons ce qu'il se passe lorsque j'appuie sur le bouton-poussoir et que je déclenche l'interruption de port. Vous pouvez voir qu'il manque des impulsions dans notre signal carré, à la fois avant et après la courbe montante de l'impulsion monocoup, et durant une courte période avant et après la courbe descendante de celle-ci.
Le bouton-poussoir a été pressé à ce moment-là. Le décalage avant la première courbe de l'impulsion monocoup provient de divers éléments, dont la latence d'interruption correspondant à la période dont le cœur a besoin pour détecter qu'une interruption a eu lieu. L'ampleur de ce décalage vient de notre priorité d'interruption et du code d'exécution à l'intérieur de nos sous-routines d'interruption.
Vous pouvez également observer un décalage suivant la montée de l'impulsion monocoup avant que le cœur ne recommence à faire basculer notre signal carré. Nous avons donc ici quelques impulsions supplémentaires, puis l'horloge s'arrête après deux millisecondes. De nouveau, suite à la petite quantité de temps nécessaire pour que le cœur détecte l'interruption, ce dernier arrête de générer le signal carré et s'attelle à l'exécution de l'évènement prioritaire avant de lancer la routine d'interruption de l'horloge et fini par faire passer notre broche monocoup à l'état bas.
Il s'agit vraiment d'une application basique permettant de faire basculer une E/S dans un logiciel. Imaginez une seconde qu'au lieu de faire basculer un signal carré, le cœur doive détecter une sorte de signal d'entrée. Pourquoi pas une entrée utilisateur, telle qu'un capteur à effleurement capacitif ou un évènement plus urgent comme un signal détectant une surchauffe dans le système ou un danger potentiel pour l'utilisateur.
Pour faire court, le cœur peut mal exécuter certaines interruptions et totalement rater ce signal, pouvant entraîner une légère nuisance pour l'utilisateur ou avoir un effet catastrophique sur le système. Nous pourrions minimiser cela en augmentant notre vitesse de fonctionnement afin que les interruptions soient prises en charge plus rapidement par le cœur. Mais n'oubliez pas que cela augmenterait notre consommation d'énergie. De plus, un fonctionnement plus rapide ne fera que minimiser cette interruption du signal carré, il ne la supprimera pas totalement.
Nous pouvons aussi demander à notre concepteur d'application de consacrer plus de temps à l'étape de test en écrivant différentes routines logicielles ou à la configuration d'autres composants système pour améliorer la situation. Mais le temps, c'est de l'argent. Devoir passer encore plus de temps à coder ou à essayer différentes configurations de systèmes secondaires connectés à notre microcontrôleur pourrait bien s'avérer coûteux.
Jetons donc un œil à une solution alternative utilisant les périphériques indépendants du cœur. Voici l'ATTINY817, c'est un appareil AVR qui possède, entre autres, un temporisateur nommé TCB et un autre périphérique appelé système d'évènements. Ce dernier peut utiliser un évènement généré à un endroit du microcontrôleur afin de déclencher un autre évènement sur le même microcontrôleur.
Par exemple, si une tension connectée à l'une des broches d'entrée de notre comparateur dépasse un seuil prédéterminé, la sortie du comparateur pourrait être configurée pour passer à l'état haut. Avec le système d'évènements, nous pouvons utiliser la sortie de ce comparateur pour déclencher une conversion analogique-numérique d'une tension sur une autre broche.
Nous pouvons aussi effectuer une variation de signal externe, par exemple lorsqu'un bouton-poussoir connecté à une broche de port est pressé et déclenche un compteur. Un compteur tel que le temporisateur 16 bits, ou périphérique TCB, sur l'ATTINY817 possède un mode de génération « single shot » qui génère une impulsion d'une durée définie par l'utilisateur lorsqu'il est déclenché.
Je vais donc utiliser ce système pour générer notre sortie monocoup. Le port E/S connecté au bouton-poussoir dans notre conception va être dirigé à l'aide du système d'évènements vers le TCB afin qu'une variation sur l'entrée de cette broche déclenche cette sortie « single shot ». L'implémentation de ces capacités dans notre application donnera ceci.
Encore une fois, le cœur du microcontrôleur est utilisé afin de faire basculer le signal carré sur la broche E/S. Cependant, cette fois, au lieu de compter sur les interruptions dans le cœur pour conduire une impulsion monocoup, nous allons diriger la variation sur notre broche de port connectée au bouton-poussoir via le système d'évènements et la relier à notre TCB afin que celui-ci déclenche une impulsion de sortie de deux millisecondes.
Comme le montre ce diagramme de définition de bloc, le cœur est actuellement libéré de toute tâche associée à la détection de la pression du bouton-poussoir ou à l'exécution de sortie monocoup étant donné que tout ce processus se fait dans le matériel à l'aide des capacités du périphérique. J'ai poursuivi en programmant l'ATTINY817 avec cette application, jetons donc un œil à nos ondes.
De nouveau, nous voyons notre broche E/S contrôlée par le cœur. Cependant, lorsque j'appuie sur le bouton-poussoir connecté à l'entrée, l'impulsion de sortie de deux millisecondes désormais gérée dans le matériel par les périphériques n'affecte par le signal carré étant donné que le cœur ne subit jamais d'interruption. La gestion des tâches dans le matériel à l'aide de périphériques plutôt que par logiciel signifie que le cœur peut désormais effectuer d'autres tâches en parallèle, comme exécuter du code pour notre signal ou même passer dans un mode de consommation plus bas.
Plus important encore, nous n'avons pas simplement amélioré la réactivité de notre système en se débarrassant du logiciel et des interruptions qui occupent le cœur, nous avons également pu conserver notre vitesse de fonctionnement à un niveau plus bas afin d'économiser de l'énergie. Dernière chose, souvenez-nous que nous souhaitions que l'impulsion de sortie dure exactement deux millisecondes.
Cependant, jetez un œil à la version basée sur interruption du logiciel de cette application. Nous configurons l'horloge pour qu'elle génère une interruption exactement à deux millisecondes. Cependant, avec les latences d'interruption et le temps nécessaire à l'exécution du code associé à la routine d'interruption et tout ce qui s'en suit, vous pouvez voir que notre impulsion de sortie dure actuellement environ 300 microsecondes de plus que ce que nous souhaitons.
Observez notre onde lorsque nous utilisons les périphériques de l'ATTINY817. Comme vous pouvez le voir, la sortie dure deux millisecondes étant donné que cette tâche est gérée dans le matériel sans subir les conséquences inhérentes au logiciel et aux interruptions. Cette version périphérique matérielle a en fait été développée assez rapidement à l'aide de certains outils de programmation graphique de Microchip Technology qui propose des périphériques de très haut niveau afin de faciliter le développement d'applications avec microcontrôleurs PIC et AVR.
Je parlerai de ces outils et de bien d'autres éléments dans de prochaines vidéos. En attendant, pour obtenir plus d'informations sur ce sujet ou d'autres, veuillez consulter www.microchip.com/8bit. C'était Marc McComb, merci de votre attention.