Programmation en langage assembleur pour débutants avec des exemples de programmes. Feu de circulation sur PIC12F629 avec "mauvais" programme Ajout de deux nombres sur assembleur

Salut!
Je veux montrer comment un programme est écrit pour contrôler un équipement technologique sur un automate.
La plupart du temps, j'avais affaire à un automate de Schneider Electric. Le Quantum que j'ai choisi pour cette tâche est l'automate le plus puissant et le plus cher de ce constructeur. Il peut contrôler des équipements avec des milliers de signaux ; naturellement, personne ne l'utilisera pour un feu de circulation dans la vraie vie.

Je n'ai jamais travaillé sur l'automatisation des feux de circulation, j'ai donc créé l'algorithme moi-même. C'est ici:
1. Feu de circulation pour passage piéton réglementé. Celles. feu de circulation pour les voitures, feu de circulation pour les piétons et un bouton pour les piétons, en appuyant sur lequel, un piéton notifie le désir de traverser la route.
2. Après le début du programme, les lumières vertes s'allument pour les voitures et rouges pour les piétons.
3. Une fois que le piéton a appuyé sur le bouton, le vert pour les voitures clignote, puis le jaune, puis le rouge. Après cela, le vert s'allume pour les piétons, après un temps prédéterminé, il commence à clignoter, le rouge s'allume pour les piétons, puis le jaune et le rouge pour les voitures s'allument, puis le vert.
4. Pendant une période de temps spécifiée après un feu vert à un feu de circulation piéton, l'appui sur le bouton par un piéton ne démarre pas l'algorithme de franchissement. Dans ce cas, l'algorithme de transition ne démarre qu'une fois le temps spécifié écoulé.
La programmation des automates s'effectue dans l'environnement de programmation Unity dans les langages de la norme IEC 61131-3. Cette norme comprend 5 langues. Par exemple, j'ai choisi le langage des blocs fonctions - FBD.
Voici le navigateur de projet dans Unity :

Configuration de l'automate :

L'API se compose d'un panneau de montage, d'une alimentation (1), d'un contrôleur (2), d'un module d'entrée numérique pour 32 signaux de 24V DC (4), d'un module d'entrée numérique pour 32 signaux de 24V DC (5). Dans un projet réel, il peut y avoir des dizaines de panneaux de montage connectés à un contrôleur via différents réseaux, et il peut y avoir des centaines de modules d'E/S.
Nous créons des variables des types requis dans l'éditeur de variables :

Les variables associées aux voies des modules d'E/S ont une adresse qui indique à quel rack, module et voie le signal est lié.
Le programme se compose de sections qui sont exécutées à chaque cycle de scrutation du contrôleur dans l'ordre.
Le cycle d'analyse du contrôleur simplifié ressemble à ceci :
1. Lecture des signaux d'entrée du module d'entrée dans des variables avec des adresses.
2. Exécution des sections.
3. Écriture de valeurs à partir de variables avec adresses vers les signaux de sortie des modules de sortie.
4. Allez à l'élément 1.
Créez une section Horloge avec un générateur d'impulsions de 0,5 seconde. Le bloc TP, lorsque le signal d'entrée passe de 0 à 1, délivre une impulsion d'une durée donnée.

Ici et ci-dessous, les captures d'écran des sections sont affichées en mode animation, pas en mode édition. Ils affichent les valeurs des variables à l'instant courant lorsqu'ils sont connectés à un automate avec un programme chargé (chiffres pour les variables numériques, vert (1) -rouge (0) pour les booléens).
La section Main gère la logique principale.
Le bloc SR met la sortie à 1 lorsque S1 = 1 et réinitialise la sortie à 0 lorsque R = 1.
Le bloc R_TRIG définit la sortie pour 1 cycle de scrutation à 1 lorsque l'entrée passe de 0 à 1 (détecteur de front montant).
Le bloc F_TRIG définit la sortie pour 1 cycle de scrutation sur 1 lorsque l'entrée passe de 1 à 0 (détecteur de front descendant).
La variable inButton liée au canal du bouton a été remplacée dans la section par inButtonForTest afin que vous puissiez modifier sa valeur sur le simulateur de contrôleur sans matériel réel.

La section Sorties génère des signaux de sortie pour contrôler les feux de circulation.

Chargez le projet dans le simulateur de contrôleur :

La signification de toutes les variables peut être consultée dans la table d'animation :

Mais pour la commodité du débogage, vous pouvez créer un écran d'opérateur avec des graphiques simples, dont l'animation est liée à des variables :

Essayer de traverser la route :

Je ne m'attendais pas à ce qu'il faille 30 blocs pour contrôler un objet aussi simple qu'un feu de circulation.
Dans le prochain article je montrerai comment écrire ce programme en utilisant tous les langages de la norme IEC 61131-3 en même temps.

UPD. Correction d'une erreur dans le nom de la norme.

Lorsque mon fils collait un mannequin de feu de circulation en papier pour l'école, la pensée est venue : "Pourquoi ne pas assembler un modèle fonctionnel d'un feu de circulation pour lui sur un microcontrôleur." Sur Internet, il existe de nombreux schémas et programmes pour eux qui mettent en œuvre le principe du feu de circulation le plus simple. Mais ils sont soit trop compliqués pour un jouet (convertisseur DC-DC, registres à décalage, etc.) soit présentés uniquement comme un exemple de programme en langage assembleur le plus simple. Je souhaite présenter un programme de langage schématique et d'assemblage pour un feu de signalisation de jouet complet avec des fonctionnalités supplémentaires. De plus, il est assemblé sur un microcontrôleur "penny" selon le schéma le plus simple, ce qui est important pour les débutants. Espérons que ce circuit simple deviendra la première véritable conception basée sur PIC pour ceux qui commencent à apprendre à programmer des microcontrôleurs PIC. Simple, mais contenant en même temps les techniques de base et les attributs de la programmation, le programme le rendra facile à comprendre et à expérimenter.

Tous ceux qui s'occupent de la programmation de microcontrôleurs connaissent les principes de base de l'écriture de gestionnaires d'interruption : temps d'exécution et code court aussi courts que possible, pas de boucles et d'appels du gestionnaire d'autres sous-programmes, etc. Dans ce cas, les interruptions ne sont autorisées que sur les changements de niveau (on ne peut pas sauter d'autres interruptions, car elles n'existent tout simplement pas) et j'ai, pour simplifier le programme et sa perception, considéré qu'il était possible de déroger à ces principes. Ici, dans le gestionnaire d'interruptions, il y a des boucles et un appel à un autre sous-programme, et (oh horreur!) Même une transition vers le mode SLEEP. Par conséquent, dans le titre, le programme est appelé "mauvais". Dans ce cas, le gestionnaire d'interruption est utilisé comme un sous-programme normal, cependant, dans d'autres cas, les principes ci-dessus restent bien sûr valables.

Brèves caractéristiques de l'appareil :

L'appareil est un modèle de feu de circulation avec une simulation fiable de son fonctionnement (couleurs changeantes, vert clignotant) et possède des fonctions supplémentaires: modification de la fréquence de commutation en appuyant sur un bouton, mode jaune clignotant, passage en mode veille en manuel et automatique modes, suivi de la mise en marche en appuyant sur un bouton. Cet appareil peut être utilisé comme jouet pour enfants, ainsi qu'une aide visuelle dans les établissements préscolaires pour apprendre aux enfants à se comporter sur les routes.

Passons donc à la description et à la considération du circuit.

Le circuit est assemblé sur un microcontrôleur PIC12F629 bon marché. Les sorties GP0-GP2, GP4, GP5 (broches 7, b, 5, 3, 2), programmées en sorties, servent directement à piloter les LED. Les LED dans chaque direction sont combinées en série afin de minimiser la consommation de courant. Les résistances R3-R8 limitent les courants des LED. En cas de forte différence dans la sortie des LED de couleurs différentes, vous devrez sélectionner les résistances appropriées. Pour moi, par exemple, deux groupes jaunes sont connectés en parallèle et connectés à une résistance, et de même valeur que les autres et brillent encore un peu plus que les autres (le recul est plus important).

Dans ce circuit, 1,5 V est fourni aux LED plus qu'au microcontrôleur à partir d'un élément supplémentaire (dans ce cas, lorsque la sortie est éteinte, le courant ne passe pas à la sortie du microcircuit, car une tension beaucoup plus élevée est requise pour ouvrir les transitions de deux LED (au moins 2,5 B).Et même avec les deux LED perforées (ce qui est peu probable), le courant traversant la diode de protection interne vers le plus de l'alimentation sera d'environ 7,5 mA, ce qui est beaucoup moins Il est établi expérimentalement que, malgré une diminution du courant traversant les LED lorsque la batterie est déchargée, la luminosité de leur éclat reste à un niveau acceptable dans toute la plage de tension de la batterie, ce qui a permis pour abandonner l'interrupteur d'alimentation (consommation de courant en mode veille - 1-3 m kA).

Le bouton de contrôle des modes de fonctionnement de l'appareil est connecté à la broche GP3 (broche 4), qui est déclarée comme entrée numérique dans les bits de configuration. Lorsque le bouton est enfoncé, une interruption se produit, dans le gestionnaire de laquelle se produit ce qui suit. En cas d'appui prolongé (plus de 4 s), l'appareil passe en mode veille. Avec des appuis plus courts, il y a une commutation séquentielle de la vitesse du feu de circulation dans un cercle avec l'indication de la vitesse actuelle selon la figure.

Dans ce dernier mode (les LED rouges sont allumées), le signal clignotant jaune est activé. Avec un appui long sur le bouton (confirmé par l'extinction de toutes les LED), on passe en fonctionnement normal avec un changement de mode vers un nouveau, si le bouton n'est pas appuyé plus de 6 secondes, le mode de fonctionnement reste le comme avant d'appuyer sur le bouton.

Une charge de piles AA en mode veille durera au moins un an, c'est pourquoi l'appareil n'a pas d'interrupteur d'alimentation. L'appareil passe également en mode veille après 0,5 à 1 heure (selon la vitesse de changement de couleur) sans affecter le bouton. Le mode SLEEP est quitté par n'importe quelle pression sur un bouton. L'alimentation est fournie au microcontrôleur via les broches 1 et 8. Pour économiser les broches et simplifier la conception, le mode du générateur interne sans éléments externes est activé.

Petites explications pour le programme, qui est donné en pièce jointe.

Le traitement des clics sur les boutons est effectué dans des sous-programmes : wait_butt __- attend l'appui et l'enregistrement pendant 6 secondes. sans appui, push_butt __- enregistrement de la durée d'appui, wait_nobutt __- attente d'un bouton non enfoncé. Lorsque l'état du feu de circulation change (jaune et vert clignotant), les valeurs du port de sortie sont lues à partir du tableau du sous-programme tact__ (petits grignotages faibles ou élevés). De même, l'indication d'état lorsque le bouton est enfoncé provient du sous-programme ind__. Pour passer en mode veille après l'expiration du temps de fonctionnement, une transition forcée vers la routine de traitement d'interruption se produit par le paramétrage logiciel de l'indicateur d'interruption. En modifiant les constantes CONST_MIN, CONST_REG, CONST_SL, vous pouvez modifier la période de clignotement vert, le mode initial lorsque la batterie est connectée, le temps de fonctionnement sans impact jusqu'au passage en mode SLEEP.

La carte de circuit imprimé est en fibre de verre recouverte d'une feuille d'aluminium sur une face et a des dimensions de 22x87 mm. Les LED les plus à l'extérieur sont installées parallèlement à la carte dans différentes directions. Ceux du milieu sont installés l'un du côté de l'installation des pièces, et l'autre du côté des pistes en enfilant les fils dans les trous de la carte et en les fixant du côté des pièces avec une goutte de soudure, et du côté des pistes par soudure aux pistes correspondantes.

Toutes les résistances d'une puissance de 0,125 W. Les LED peuvent être prises n'importe quel domestique ou importé, de préférence du même type avec une chute de tension directe à un courant de 10 mA d'environ 2 Volts. Bouton - tout sans fixation. Le microcontrôleur est installé sur le bloc.

Le mot de configuration est entré en mémoire automatiquement lors du chargement du firmware (le "birdie" est installé uniquement dans l'élément "PWRT", le reste des éléments est "effacé", le "intOSC GP4" est défini dans l'"oscillateur" colonne). Tout d'abord, il est nécessaire de lire le firmware à partir d'un microcircuit propre et d'écrire la valeur du mot à la fin de la mémoire de programme à 03FF, ce qui est nécessaire pour ajuster la fréquence du générateur interne d'une instance de microcircuit particulière. Après avoir chargé le fichier HEX dans le programme, cette valeur doit être saisie manuellement à 03FF. Dans cet appareil, l'écart de fréquence n'est pas critique, mais il faut quand même savoir que ce microcircuit nécessite une telle procédure. En dernier recours, si la valeur d'usine est perdue, vous ne pouvez rien faire - le programme a pris des mesures pour un fonctionnement correct dans ce cas.

L'appareil est placé dans une boîte en plastique appropriée. Les trous correspondants sont réalisés sous les LED dans la boîte et le couvercle. Dans ma version, le feu de circulation lui-même et la base avec le bouton et la batterie sont reliés par un morceau de tuyau d'eau en plastique d'un diamètre de 20 mm.

L'application contient : modèle, circuit imprimé au format LAY, programme assembleur MPASM, fichier firmware HEX.

Liste des radioéléments

La désignation	Type de	Dénomination	Quantité	Noter	Mon cahier
IC1	MK PIC 8 bits	PIC12F629	1	TREMPER	Dans le bloc-notes
R1	Résistance	3 kΩ	1	0,125 W	Dans le bloc-notes
R2	Résistance	100 ohms	1	0,125 W	Dans le bloc-notes
R3-R8	Résistance	200 ohms	6	0,125 W	Dans le bloc-notes
HL1, HL2, HL9, HL10	Diode électro-luminescente	AL307A	4	ROUGE	Dans le bloc-notes
HL3, HL4, HL11, HL12	Diode électro-luminescente

But du travail. Le but du travail de laboratoire est de déboguer des applications C pour le microcontrôleur AVR à l'aide du compilateur CVAVR et du simulateur VMLAB.

Programme de travail

1. Installer dans le répertoire C: \ CVAVR version gratuite du compilateur CodeVisionAVR. Dans le répertoire C:\CVAVR créez un dossier z1(tâche 1) pour les fichiers du premier projet.

Démarrez le compilateur. Pour créer un fichier de projet, appuyez sur : Fichier -> nouveau -> projet -> OK -> Non- aller dans le dossier créé pour le projet z1 et entrez dans le champ "nom de fichier": z1 - cliquez sur "enregistrer" - la fenêtre de configuration du projet s'ouvrira

Allez dans l'onglet "Avec compilateur"

Sélectionnez MK (puce) ATmega16

Réglez la fréquence d'horloge de MK (Clock) 4.0 MHz

Cliquer sur d'accord.

Un fichier texte ouvert apparaîtra devant vous Notes de projet - z1.prj où vous pouvez écrire vos commentaires et réflexions sur le projet.

Maintenant, nous devons créer le fichier texte principal pour nous pour taper le texte source en C - son extension. C

Cliquez sur: Fichier -> Nouveau -> Source -> OK

le fichier est apparu sans titre.c- presse: Fichier - Enregistrer sous- entrez dans le champ "nom de fichier": z1.c et appuyez sur sauvegarder.

Vous devez ajouter le fichier créé z1.c à la liste des fichiers du projet - ouvrez le menu de configuration du projet : Projet -> Configurer.

Dans la boîte de dialogue qui s'ouvre, vous devez sélectionner le raccourci "Fichiers" et cliquer sur le " Ajouter". Dans la nouvelle boîte de dialogue, sélectionnez le fichier" z1.c" et appuyez sur " Ouvert". Le fichier est maintenant inclus dans le projet.

Cliquez sur: d'accord

Maximiser (développer) la fenêtre du fichier - z1.c

Maintenant, tout est prêt pour la programmation proprement dite, c'est-à-dire à la création du texte du programme en langage C. Le tableau ci-dessous contient le texte du programme pour la tâche 1, qui met en œuvre la tâche technique suivante : Développer un appareil basé sur le microcontrôleur ATmega16, qui affichera un nombre de 8 bits sous forme binaire avec des LED allumées, à partir de 0 et avec un augmentation constante de 1. L'appareil est alimenté par une tension stabilisée constante de 4 à 5,5 volts. Le MC est cadencé à partir d'un résonateur à quartz avec une fréquence de 4 MHz. Un total de 8 LED est connecté à partir des broches du port UNEà travers des résistances de limitation de courant à l'alimentation du MK. La commutation des LED doit être effectuée avec des pauses de 65 ms.

#comprendre / * Insérer à la place de cette ligne le texte du fichier mega16.h contenant la description des registres MK * /

#define PA_OUT DDRA = 0xFF/ * Remplacer partout dans le texte du programme

PA_OUT sur DDRA = 0xFF * /

// ++++ Fonction d'initialisation MK ++++ void initialisation (void) ( PA_OUT; // faire toute la sortie PORTA TCCR0 = 0x05 ;/ * activer le compte à rebours, en faisant un compte toutes les 1024 oscillations sur la jambe XTAL1 * / }

Carboniserpar=0;

// ++++ Fonction principale ++++ vide principal (vide) ( initialisation ();/ * Appelez la fonction d'initialisation MK - c'est-à-dire paramètres des appareils MK dont nous avons besoin en fonction de la tâche * /

//Cycle sans fin tandis que (1) (// Toujours faire

PORTA = ~ (par++);

tandis que (! (TIFR & 0x01));// attend que l'indicateur de débordement timer0 soit défini TIFR = 0x01 ;// efface l'indicateur de débordement timer0 }; // boucle terminée

} // parenthèse pour main()

Écrivez (sans commentaires) le programme dans la fenêtre source du programme. Sauvegarder les modifications: déposer -> sauvegarderTous.

Pour compiler le programme, cliquez sur le " Fairelesprojet".

Jetez un oeil au dossier de notre projet - z1. À la suite de la compilation, de nombreux nouveaux fichiers y sont apparus. Les principaux pour nous :

z1.hex - fichier de firmware pour le "chargement" dans MK ;

z1 __.с - copie du fichier z1.c pour les simulateurs ;

z1.cof - informations liant le contenu des fichiers z1 __.c et z1.hex. Ces informations vous permettent d'observer le mouvement du programme directement via le code C lors de la simulation dans VMLAB. Les fichiers spécifiés seront utilisés dans le simulateur VMLAB. Seul le fichier du firmware est requis pour un vrai MK.

Les quatre fichiers suivants contiennent notre programme écrit en assembleur AVR standard en référence au texte C : z1.asm, z1.lst, z1.vec, z1.inc. Le reste des fichiers est pratiquement inintéressant.

2. Démarrez VMLAB et ouvrez le projet créé : Projet -> Ouvrir le projetDéposer

Allez dans le dossier de la tâche 1 C:\CVAVR\z1\ et tapez le nom de fichier z1_vm.prj du projet pour VMLAB. Une fois que la phrase apparaît qu'un tel fichier n'existe pas, VMLAB vous proposera de le créer, avec lequel vous êtes d'accord. Dans la fenêtre qui apparaît, notez le fichier texte ci-dessous dans le tableau sans commentaires.

; Dossier de projet z1_vm.prj pour la simulation de la tâche 1.

; Les commentaires sont écrits dans VMLAB en une seule ligne

; après le point-virgule ; MK comme si "cousu" avec un fichier - z1.hex. Après avoir allumé le MK

; les LED allumées affichent sous forme binaire des nombres à partir de 0

.MICRO "ATmega16"; MC simulé .TOOLCHAIN "GENERIQUE" .CIBLE "z1.hex"; qu'est-ce qui est "cousu" dans MK .COFF "z1.cof"

.SOURCE "z1 __. C" .POWER VDD = 5 VPP = 0; Alimentation +5 volts; VSS est GND MK - fil "commun" du circuit ; Les tensions sont mesurées par rapport à elle .HORLOGE 4meg; fréquence du quartz 4 MHz; Plus précisément, c'est la fréquence d'horloge du MK

; Saisie d'un schéma d'appareil pour la tâche 1 ; 8 LED sont connectées par des cathodes à travers des résistances

: nominale 560 Ohm à MK jambes de 33 à 40

; connectez la résistance R1 au nœud D1_NODE et à la broche PA0 du MK ; anode de la LED au circuit +5 V. Les 7 LED restantes

; sont connectés de la même manière

D1 VDD D1_NODE R1 D1_NODE PA0 560 D2 VDD D2_NODE R2 D2_NODE PA1 560 D3 VDD D3_NODE R3 D3_NODE PA2 560 D4 VDD D4_NODE R4 D4_NODE PA3 560 D5 VDD D5_NODE D5_NODE PA R6 D5_DNODE6 PA7 VDD D8_NODE R8 D8_NODE PA7 560

; Signaux sur les pattes PA0 PA1 PA2; nous observerons dans la fenêtre de l'oscilloscope virtuel - "Scope" .PLOT V (PA0) V (PA1) V (PA2); Tracez des graphiques de tension dans les nœuds répertoriés du circuit

Depuis le menu Projet, exécutez Tout reconstruire ...

Dans le menu Affichage, ouvrez deux composants : SCOPE est l'oscilloscope de stockage virtuel du simulateur et le Panneau de configuration est un panneau qui contient les LED dont nous avons besoin et bien plus dont nous n'avons pas encore besoin.

Ouvrez la fenêtre Code à l'aide du menu Fenêtre (généralement, il s'ouvre immédiatement à l'ouverture du projet) - dans cette fenêtre, vous verrez le texte du programme simulé.

Faites attention à la fenêtre Messages - les messages de service du simulateur y apparaissent pendant que vous travaillez. Un message devrait apparaître dans la fenêtre Messages indiquant qu'il a réussi et que tout est prêt à fonctionner (Success! All ready to run). De plus, un feu vert sur la barre d'outils s'allumera - c'est un bouton avec lequel vous pouvez démarrer la simulation.

Appuyer sur le feu vert équivaut à appliquer un "1" à la broche RESET du MC lorsque l'appareil est sous tension, mais pas encore en train d'exécuter le programme.

Trois graphiques sont apparus dans la fenêtre Scope pour les signaux que nous allons observer. Réglez l'échelle verticale sur 2 volts par division et l'échelle horizontale sur 50 ms.

Dans la fenêtre Code, un champ gris à gauche et des carrés verts sont apparus en face des lignes exécutables du code du programme en C - en cliquant sur un tel carré, nous pouvons définir un point d'arrêt pour le programme.

Placez les trois fenêtres et le Panneau de configuration sur l'écran de l'ordinateur afin que vous puissiez les voir tous.

Cliquez sur "feux de circulation" pour démarrer le programme de simulation. Le programme démarre et s'arrête - un message apparaît dans la fenêtre Messages. Cliquez à nouveau sur le "feu tricolore". Le simulateur s'arrête à nouveau et signale qu'il y a eu une réinitialisation de la "minuterie du chien de garde MK" - nous n'avons pas dit au simulateur que nous ne l'utilisions pas. Cliquez à nouveau sur le "feu de circulation" - maintenant le programme fonctionnera en continu jusqu'à ce que nous l'arrêtions.

Laissez le programme simuler, et vous regardez ce qui se passe dans les fenêtres ci-dessus. Qu'est-ce qui est affiché dans la fenêtre du Panneau de configuration à part les LED ?

Regarder les fenêtres PORTÉE et Code et derrière les LED. Dans la fenêtre Code pendant la simulation, des bandes jaunes apparaissent et grossissent, mettant en évidence les lignes du programme exécutable. Les longueurs de ces reflets sont proportionnelles au temps pendant lequel le programme exécute le code de ces lignes.

Quelle quantité de courant le microcontrôleur tire-t-il de l'alimentation électrique ? Arrêtez la simulation en appuyant sur l'octogone rouge « Stop » et mesurez la durée de la période d'impulsion sur la jambe PA2 MK. Comment correspond-elle à la valeur calculée ? Pour mesurer l'intervalle de temps dans la fenêtre SCOPE du simulateur VMLAB, vous devez définir les curseurs verticaux 1 et 2 aux limites de l'intervalle mesuré et la valeur de temps entre les deux curseurs apparaîtra dans le champ Cursor delta time.

Lors de la mesure de courts intervalles répétitifs vous pouvez mesurer le temps de plusieurs à la fois, puis diviser le résultat par le nombre de ces intervalles entre les curseurs de mesure.

Redémarrez MK en cliquant sur le bouton avec flèche bleu foncé circulaire... Vous éteignez en quelque sorte puis remettez le MK sous tension, mais créez un "0" sur la jambe RESET du MK - à la suite de quoi le programme ne démarre pas !

Quelle est la fonction de la commande PORTA=~(par++); ?

Fournissez dans le rapport le schéma de connexion des LED au MK.

3. Modifier le programme. Basculez les LED sur le port C. Réduisez le temps de pause entre les LED de commutation de 2 fois.

Pour changer le code C d'un programme, il suffit de lancer le compilateur CodeVisionAVR (vous n'avez pas besoin de désactiver VMLAB !) et d'apporter les modifications nécessaires, puis de compiler le projet. Ensuite, allez dans VMLAB, faites redémarrage en profondeur puis Ré-buid tout. Tout! Les modifications sont effectuées et tout est à nouveau prêt pour la simulation. Ainsi, le compilateur et le simulateur fonctionnent simultanément dans le même dossier de projet et n'interfèrent pas, mais s'entraident. Incluez les fichiers z1.c et z1_vm.prj du projet modifié dans le rapport.

4. Dans le prochain projet, nous afficherons les données sur un écran LCD à caractères (indicateur à cristaux liquides). Le schéma de sa connexion au port A du microcontrôleur est illustré à la Fig. 9.1 (la source d'information y est également indiquée, dans laquelle vous pouvez vous familiariser avec le problème en cours de résolution plus en détail).

Exécuter le compilateur CodeVisionAVR, puis le générateur de code de départ " Assistant de codeAVR" - en cliquant engrenage grisà gauche du bug rouge... Sélectionnez ATmega16 et fréquence cristal de 4 MHz. Allez dans l'onglet LCD et spécifiez PORTA et 16 caractères.

Après avoir complété Fichier ->produire, sauvegarderetSortir, créez un dossier dans le répertoire C:\CVAVR z2(tâche 2) pour les fichiers d'un nouveau projet. Enregistrez les fichiers z2.c, z2.prj et z2.cwp en appuyant trois fois sur z2. Regardez le fichier du code initial du programme généré par l'assistant z2. c... Quelles commandes sont utilisées pour initialiser l'écran LCD ? Est-il possible de supprimer du programme les commandes qui implémentent l'initialisation des périphériques qui ne sont pas utilisés dans cette tâche ?

Riz. 9.1 - Schéma de câblage type pour l'afficheur LCD

Après la commande

lcd_ init(16); // LCD 16 caractères par ligne

ajouter deux lignes :

lcd_ gotoxy(5,0); // affiche les caractères à partir de la 6ème position dans la première ligne lcd_ putsf(" Bonjour! "); // le comptage des lignes et des caractères commence à zéro !

Enregistrez (Fichier -> Enregistrer tout) et compilez le programme.

Sans fermer le compilateur, ouvrez VMLAB... Dans la fenêtre OuvertProjetDéposer entrez le nom de fichier z2_vm et ouvrez le fichier de projet pour le simulateur z2_ vm. prj... Entrez le texte ci-dessous dans la case et exécutez Ré- construiretous... Un feu de signalisation allumé indique que le programme est prêt pour la simulation. Ouvrez la fenêtre du Panneau de configuration et cliquez trois fois sur le feu de circulation pour obtenir une simulation continue. L'inscription tant attendue sur l'écran LCD n'apparaîtra pas immédiatement (le processus d'initialisation de l'écran LCD prend beaucoup de temps). Pourquoi le feu de circulation s'allume-t-il après un certain temps ?

Sans fermeture VMLAB retourner au compilateur CVAVR.Après la commande #comprendre ajouter la commande

#comprendre // fonctions d'organisation des délais

Après la commande lcd_ putsf(" Bonjour! "); ajoutez les commandes :

retard_ Mme(200);

lcd_ dégager(); // efface l'écran LCD

délai_ms (200);

lcd_gotoxy (5,1) ;

lcd_putsf ("FINISSEZ !");

Dans le dernier cycle du programme avant le commentaire // Endroittoncodeici ajouter la commande # asm(" wdr") et recompiler le projet.

Retournez dans VMLAB. Faites un redémarrage en profondeur et exécutez Ré- construiretous... Comment les informations sont-elles affichées sur le tableau d'affichage maintenant ? Pourquoi le feu tricolore ne s'allume-t-il pas après l'exécution d'une simulation continue ?

5. Mener une étude sur le fonctionnement de l'ADC. Dans le dossier C:\CVAVR\z3, utilisez le compilateur pour créer des fichiers de projet de tâche 3 basés sur le programme z3. c, dont le texte est donné ci-dessous dans l'encadré (il est commenté en détail dans la section 7).

Utilisez ensuite le simulateur pour écrire le fichier Z3_vm.prj.

; déposer Z3_ vm. prj

. MICRO " ATmega16"

. CHAÎNE À OUTILS " GÉNÉRIQUE"

. CIBLE " z3. hexagone" ; firmware émulé MK

. COFFRE " z3. café" ; le fichier contient la liaison

; contenu [.hex] au code dans [__.c]

. LA SOURCE " z3__. c" ; la source C vers laquelle le fichier [.cof] est orienté.

; ce CodeVision ajoute "__" lors de la compilation

. TRACE; afficher les informations de débogage dans une fenêtre

; PORTÉE - rose (voir AIDE de l'émulateur)

. L'HORLOGE 4 meg; fréquence du quartz utilisé

; Désignations des points MK auxquels vous pouvez

; émulateur "connect" : RESET, AREF, PA0-PA7, PB0-PB7, PC0-PC7, PD0-PD7, ACO, TIM1OVF

; Pour utiliser le MK ADC, vous devez appliquer une tension de référence à la broche AREF - nous fournirons 5 volts de la puissance MK. Mais dans VMLAB

; vous ne pouvez pas connecter deux nœuds directement. Prenez une résistance de 1 ohm.

R1 VDDAREF 1 ; la résistance R1 est connectée à

; Nœuds VDD et AREF via une résistance de 1 Ohm

; la tension de référence Vref nous avons 5 volts -

; signifie lors de l'application de 5 volts à l'entrée ADC

; on obtient le résultat : 1111111111 (ADC 10 bits)

; Input0 de l'ADC (c'est la sortie de PA0 MK) nous allons nous connecter à

; résistance variable à contact mobile

; (Curseur 1 dans la fenêtre "Panneau de configuration") -

; pour changer la tension à l'entrée ADC pendant l'émulation.

V1 PA0 VSS SLIDER_1 (0 5)

; aux extrémités de la résistance variable 0 et 5 volts

; L'émulateur a 8 LED -

; nous les connectons aux broches du port B

D1 VDD PB0

D2 VDD PB1

D3 VDD PB2

D4 VDD PB3

D5 VDD PB4

D6 VDD PB5

D7 VDD PB6

D8 VDD PB7

; L'émulateur permet la connexion directe de LED à

; au plus de l'alimentation et des conclusions du MC - en fait, il faut

; résistance de limitation de courant 430-910 Ohm

; en série avec chaque LED !

.PARCELLE V (PA0); vers l'écran de l'oscilloscope (fenêtre "SCOPE")

; afficher la tension sur le curseur du potentiomètre

Après avoir démarré le projet de simulation, observez les LED et l'oscilloscope en modifiant la position du curseur du potentiomètre. Quelle est la tension correspondant à celle du bit le moins significatif de l'ADC ? Ouvrez la fenêtre Périphériques et observez les registres ADC lorsque vous modifiez la position du curseur du potentiomètre S1. Comparez les lectures des LED et le contenu des registres ADCH et ADCL.

Affichez le contenu de la mémoire du programme et du programme en langage assembleur. Combien de cellules le programme prend-il ? À quelle adresse se trouve le vecteur d'interruption à la fin du processus de conversion analogique-numérique ?

6. Exécuter pour simulation le projet préparé dans le dossier z4 (tâche 4). Le projet a été mis en œuvre sur MK ATmega16.

Dans la fenêtre PORTÉE(il s'agit d'un oscilloscope virtuel) vous pouvez voir les changements de tensions sur les jambes MK spécifiées dans le fichier de projet - vmlab.prj... L'oscillogramme supérieur est le signal sur la jambe TXD (PD1) port série USART, à travers lequel le MC transmet les données au port COM du PC via l'interface RS232 - ce que le MC transmet, nous le voyons dans le terminal virtuel ATS panneaux ContrôlerPanneau... La valeur y est affichée PWM (PWM) du signal généré sur la broche PD5. Le signal lui-même est visible dans la fenêtre PORTÉE- voir comment cela change en fonction des valeurs numériques rapportées. Sur la jambe PD4 des impulsions de même fréquence avec une durée constante sont formées.

Dans le dossier du projet vmlab.prjà la jambe PD5 le filtre passe-bas (LPF) le plus simple d'une résistance et d'un condensateur est connecté - il convertit Signal PWM en une tension constante visible dans la fenêtre PORTÉE(signal CAD).

Le format de transmission des données dans l'exemple est 8N1 (c'est le format par défaut pour un PC). Dans ce format, la transmission d'octets commence par un "bit de départ" - il s'agit d'un journal. "0" sur la patte TXD pour USART MK et +5 ... + 15 V pour le port COM du PC. Ensuite, les 8 bits de l'octet transmis sont sortis vers la branche TXD, en commençant par zéro. Lors de la transmission d'un bit, le récepteur doit déterminer et mémoriser ce niveau. Vient ensuite le "bit d'arrêt" - c'est le journal. "1" sur la patte TXD pour USART MK et -5 ...- 15 V pour le port COM du PC. Un adaptateur MAX232 est inclus pour la correspondance de niveau entre le MCU et le PC.

7 ... Testez le travail du programme, dont le texte est donné ci-dessous. Développez un programme qui implémente un effet de lumière courante sans utiliser le langage assembleur.

#comprendre

vide principal (vide) (

#asm ("ldi r20,1")

#asm ("lsl r20")

#asm ("out 0x18, r20")

#asm ("ldi r20,1")); Contrôlerdes questions

Quelle est la capacité de charge des lignes du port AVR ?

Quelles insertions d'assembleur peuvent être utilisées pour activer et désactiver globalement les interruptions dans un programme C pour AVR ?

Notez le résultat des opérations arithmétiques : 245/37 et 245% 37.

Quelles commandes pouvez-vous organiser un délai d'une seconde dans un programme C pour AVR ?

Commentez la commande PORTA = ~ (par ++);

Déclarez une variable mnogo si elle peut aller de zéro à un million.

Commentez le résultat de la commande ADCSRA | = 0x40;

Beaucoup de gens pensent qu'Assembler est déjà obsolète et n'est utilisé nulle part, mais ce sont principalement des jeunes qui ne sont pas impliqués professionnellement dans la programmation de systèmes. Le développement de logiciels, bien sûr, c'est bien, mais contrairement aux langages de programmation de haut niveau, Assembler vous apprendra à comprendre en profondeur le fonctionnement d'un ordinateur, à optimiser le travail avec les ressources matérielles et à programmer n'importe quelle technique, se développant ainsi dans le sens de l'apprentissage automatique. . Pour comprendre cet ancien PL, il vaut la peine de s'entraîner avec des programmes simples qui expliquent au mieux les fonctionnalités d'Assembler.

IDE pour assembleur

La première question est : dans quel environnement de développement programmer en assembleur ? La réponse est sans équivoque - MASM32... C'est le programme standard qui est utilisé pour cette PL. Vous pouvez le télécharger sur le site officiel masm32.com sous la forme d'une archive, qu'il faudra décompresser puis exécuter le programme d'installation install.exe. Alternativement, vous pouvez utiliser FASM, mais le code sera très différent.

Avant de commencer le travail, l'essentiel est de ne pas oublier d'ajouter la ligne suivante à la variable système PATH :

C:\masm32\bin

Programme d'assemblage "Hello world"

Il est considéré comme un programme de base en programmation, que les débutants écrivent d'abord lorsqu'ils se familiarisent avec le langage. Peut-être que cette approche n'est pas tout à fait correcte, mais d'une manière ou d'une autre elle vous permet de voir immédiatement un résultat visuel :

386 .model flat, casemap de l'option stdcall : aucune n'inclut /masm32/include/windows.inc include /masm32/include/user32.inc include /masm32/include/kernel32.inc includelib /masm32/lib/user32.lib includelib / masm32 / lib / kernel32.lib .data msg_title db "Title", 0 msg_message db "Hello world", 0 .code start : invoquer MessageBox, 0, addr msg_message, addr msg_title, MB_OK invoquer ExitProcess, 0 end start

Tout d'abord, exécutez l'éditeur qeditor.exe dans le dossier où MASM32 est installé et écrivez le code du programme dedans. Après cela, nous l'enregistrons en tant que fichier avec l'extension ".asm" et construisons le programme en utilisant l'élément de menu "Projet" → "Construire tout". S'il n'y a pas d'erreurs dans le code, le programme se compilera avec succès et à la sortie, nous obtiendrons un fichier exe prêt qui affichera une fenêtre Windows avec l'inscription "Hello world".

Ajouter deux nombres en assembleur

Dans ce cas, nous cherchons à voir si la somme des nombres est nulle ou non. Si c'est le cas, un message correspondant apparaît à l'écran, et sinon, une autre notification apparaît.

486 .model flat, casemap de l'option stdcall : aucune n'inclut /masm32/include/windows.inc include /masm32/include/user32.inc include /masm32/include/kernel32.inc includelib /masm32/lib/user32.lib includelib / masm32 / lib / kernel32.lib include /masm32/macros/macros.asm uselib masm32, comctl32, ws2_32 .data .code start: mov eax, 123 mov ebx, -90 add eax, ebx test eax, eax jz zero invoquer MessageBox, 0, chr $ ("In eax not 0!"), chr $ ("Info"), 0 jmp lexit zero : invoque MessageBox, 0, chr $ ("In eax 0!"), chr $ ("Info"), 0 lexit : invoquer ExitProcess, 0 end start

Ici, nous utilisons des étiquettes et des commandes spéciales qui les utilisent (jz, jmp, test). Regardons de plus près:

test - utilisé pour la comparaison logique de variables (opérandes) sous forme d'octets, de mots ou de doubles mots. A titre de comparaison, la commande utilise la multiplication logique, et regarde les bits : s'ils sont égaux à 1, alors le bit de résultat sera égal à 1, sinon - 0. Si nous avons 0, les drapeaux sont définis avec ZF (indicateur zéro ), qui sera égal à 1 Les résultats sont ensuite analysés sur la base du ZF.
jnz - si le drapeau ZF n'a été défini nulle part, un saut est effectué sur cette étiquette. Cette commande est souvent utilisée lorsque le programme contient des opérations de comparaison qui affectent d'une manière ou d'une autre le résultat ZF. Ceux-ci incluent test et cmp.
jz - si le drapeau ZF était toujours défini, l'étiquette est sautée.
jmp - qu'il y ait ou non ZF, l'étiquette est sautée.

Programme d'assemblage pour additionner des nombres

Un programme primitif qui montre le processus d'ajout de deux variables :

486 .model flat, casemap de l'option stdcall : aucune n'inclut /masm32/include/windows.inc include /masm32/include/user32.inc include /masm32/include/kernel32.inc includelib /masm32/lib/user32.lib includelib / masm32 / lib / kernel32.lib include /masm32/macros/macros.asm uselib masm32, comctl32, ws2_32 .data msg_title db "Title", 0 A DB 1h B DB 2h buffer db 128 dup (?) format db "% d", 0 .code start : MOV AL, A ADD AL, B invoquer wsprintf, addr buffer, addr format, eax invoquer MessageBox, 0, addr buffer, addr msg_title, MB_OK invoquer ExitProcess, 0 end start

En assembleur, pour calculer la somme, il faudra beaucoup d'actions, car le langage de programmation travaille directement avec la mémoire système. Ici, nous manipulons principalement les ressources et indiquons indépendamment combien allouer à une variable, sous quelle forme percevoir les nombres et où les mettre.

Obtenir une valeur à partir de la ligne de commande en assembleur

L'une des étapes de base les plus importantes de la programmation consiste à obtenir des données de la console pour un traitement ultérieur. Dans ce cas, nous les récupérons depuis la ligne de commande et les affichons dans la fenêtre Windows :

486 .model flat, casemap de l'option stdcall : aucune n'inclut /masm32/include/windows.inc include /masm32/include/user32.inc include /masm32/include/kernel32.inc includelib /masm32/lib/user32.lib includelib / masm32 / lib / kernel32.lib include /masm32/macros/macros.asm uselib masm32, comctl32, ws2_32 .data .code start : appelez GetCommandLine ; le résultat sera placé dans eax push 0 push chr $ ("Command Line") push eax; nous prenons le texte pour la sortie de eax push 0 call MessageBox push 0 call ExitProcess end start

Vous pouvez également utiliser une méthode alternative :

486 .model flat, casemap de l'option stdcall : aucune n'inclut /masm32/include/windows.inc include /masm32/include/user32.inc include /masm32/include/kernel32.inc includelib /masm32/lib/user32.lib includelib / masm32 / lib / kernel32.lib include /masm32/macros/macros.asm uselib masm32, comctl32, ws2_32 .data .code start : appelez GetCommandLine ; le résultat sera placé dans eax invoquer GetCommandLine invoquer MessageBox, 0, eax, chr $ ("Command Line"), 0 invoquer ExitProcess, 0 push 0 appeler ExitProcess end start

Il utilise invoke, une macro spéciale qui simplifie le code du programme. Au moment de la compilation, les macro-commandes sont converties en commandes assembleur. D'une manière ou d'une autre, nous utilisons une pile - un moyen primitif de stocker des données, mais en même temps très pratique. Par convention, stdcall, dans toutes les fonctions WinAPI, les variables sont passées dans la pile, uniquement dans l'ordre inverse, et placées dans le registre eax correspondant.

Boucles d'assembleur

Cas d'utilisation:

Data msg_title db "Title", 0 A DB 1h buffer db 128 dup (?) Format db "% d", 0 .code start: mov AL, A .REPEAT inc AL .UNTIL AL == 7 invoke wsprintf, addr buffer, addr format, AL invoquer MessageBox, 0, addr buffer, addr msg_title, MB_OK invoquer ExitProcess, 0 end start .data msg_title db "Title", 0 buffer db 128 dup (?) format db "% d", 0 .code start : mov eax, 1 mov edx, 1 .WHILE edx == 1 inc eax .IF eax == 7 .BREAK .ENDIF .ENDW invoquer wsprintf, addr buffer, addr format, eax invoquer MessageBox, 0, addr buffer, addr msg_title, MB_OK invoquer ExitProcess, 0

La commande repeat est utilisée pour créer une boucle. Ensuite, en utilisant inc, la valeur de la variable est augmentée de 1, qu'elle soit dans la RAM ou dans le processeur lui-même. Afin d'interrompre le travail du cycle, la directive ".BREAK" est utilisée. Il peut à la fois arrêter le cycle et poursuivre son action après une "pause". Vous pouvez également interrompre l'exécution du code du programme et vérifier la condition de répétition et de mise en attente à l'aide de la directive ".CONTINUE".

Somme des éléments du tableau sur l'assembleur

Ici, nous résumons les valeurs des variables du tableau à l'aide d'une boucle for :

486 .model flat, casemap de l'option stdcall : aucune n'inclut /masm32/include/windows.inc include /masm32/include/user32.inc include /masm32/include/kernel32.inc includelib /masm32/lib/user32.lib includelib / masm32 / lib / kernel32.lib include /masm32/macros/macros.asm uselib masm32, comctl32, ws2_32 .data msg_title db "Title", 0 A DB 1h x dd 0,1,2,3,4,5,6,7, 8,9,10,11 n dd 12 buffer db 128 dup (?) Format db "% d", 0 .code start: mov eax, 0 mov ecx, n mov ebx, 0 L: add eax, x add ebx, type x dec ecx cmp ecx, 0 jne L invoquer wsprintf, addr buffer, addr format, eax invoquer MessageBox, 0, addr buffer, addr msg_title, MB_OK invoquer ExitProcess, 0 end start

La commande dec, comme inc, change la valeur de l'opérande de un, uniquement dans le sens opposé, de -1. Mais cmp compare les variables par la méthode de soustraction : il soustrait une valeur de la seconde et, en fonction du résultat, définit les indicateurs appropriés.

La commande jne parcourt l'étiquette en fonction du résultat de la comparaison des variables. S'il est négatif, une transition se produit, et si les opérandes ne sont pas égaux, la transition n'est pas effectuée.

L'assembleur est intéressant pour sa représentation des variables, qui permet d'en faire ce que l'on veut. Un spécialiste qui comprend toutes les subtilités de ce langage de programmation a des connaissances vraiment précieuses qui ont de nombreuses façons de l'utiliser. Un problème peut être résolu de différentes manières, le chemin sera donc épineux, mais non moins excitant.

Affichage des messages : 767

Brèves caractéristiques de l'appareil :

Passons donc à la description et à la considération du circuit :

Le circuit est monté sur un microcontrôleur peu coûteux. Les sorties GP0-GP2, GP4, GP5 (broches 7, b, 5, 3, 2), programmées en sorties, servent directement à piloter les LED. Les LED dans chaque direction sont combinées en série afin de minimiser la consommation de courant. Les résistances R3-R8 limitent les courants des LED. En cas de forte différence dans la sortie des LED de couleurs différentes, vous devrez sélectionner les résistances appropriées. Pour moi, par exemple, deux groupes jaunes sont connectés en parallèle et connectés à une résistance, et de même valeur que les autres et brillent encore un peu plus que les autres (le recul est plus important).

Le bouton de contrôle des modes de fonctionnement de l'appareil est connecté à la broche GP3 (broche 4), qui est déclarée comme entrée numérique dans les bits de configuration. Lorsque le bouton est enfoncé, une interruption se produit, dans le gestionnaire de laquelle se produit ce qui suit. En cas d'appui prolongé (plus de 4 s), l'appareil passe en mode veille. Avec des appuis plus courts, il y a une commutation séquentielle de la vitesse du feu tricolore dans un cercle avec l'indication de la vitesse actuelle selon la figure :

Petites explications pour le programme, qui est donné en pièce jointe :

Le mot de configuration est automatiquement entré en mémoire lors du chargement du firmware (dans IC-Prog, le « birdie » est installé uniquement dans l'élément « PWRT », le reste des éléments est « effacé », « intOSC GP4 » est défini dans la colonne « oscillateur »). Tout d'abord, il est nécessaire de lire le firmware à partir d'un microcircuit propre et d'écrire la valeur du mot à la fin de la mémoire de programme à 03FF, ce qui est nécessaire pour ajuster la fréquence du générateur interne d'une instance de microcircuit particulière. Après avoir chargé le fichier HEX dans le programme, cette valeur doit être saisie manuellement à 03FF. Dans cet appareil, l'écart de fréquence n'est pas critique, mais il faut quand même savoir que ce microcircuit nécessite une telle procédure. En dernier recours, si la valeur d'usine est perdue, vous ne pouvez rien faire - le programme a pris des mesures pour un fonctionnement correct dans ce cas.