Étape 6: Le Code
Je vais coller les instructions ici une section à la fois et expliquer brièvement ce qu’ils font. N’oubliez pas de « Programmation en C des microcontrôleurs » pour obtenir un didacticiel plus détaillée expliquant l’utilisation des opérateurs et autres. La feuille de données de ATMega328P est aussi une bonne référence pour l’apprentissage de l’objet d’un registre ou bit. Je vais essayer de garder cette partie courte, mais instructif. L’apprentissage C est un projet en soi, donc ne vous découragez pas si vous êtes complètement perdu dans un premier temps ! Je sais que j’ai fait.
Le code réel sur cette page sera en gras pour le rendre plus facile à discerner de texte... Commentaires vont être mis en italique.
/*
* Speed_measurement.c
*
* Création : 15/09/2012 20:50:23
* Auteur : Thomas L
*/
#define F_CPU 14.7456E6 #include < avr/io.h >
#include < util/delay.h >
#include < avr/interrupt.h >
Ces premières lignes juste donnent le compilateur quelques informations sur quels fichiers il besoins et la vitesse d’horloge CPU. Nous aurons besoin d’utiliser des retards plus tard de faire l’AVR juste attendre, alors il faut inclure le fichier util/delay.h. Ce fichier contient les fonctions de délai réel que nous appellerons dans le programme principal. Les fonctions de retard livrent un retard temporisé, afin qu’ils nous obligent à fournir la vitesse d’horloge CPU. Le #define F_CPU indique au compilateur de la vitesse de l’oscillateur à quartz, et puis, ce nombre est fourni pour toutes les fonctions qui ont besoin de l’utiliser.
/************************************************************************/
/ * déclarer des variables globales * /
/************************************************************************/
unsigned int résultat = 0 ;
int interruptcount = 0 ;
temps d’int = 0 ;
long int resetcount = 0 ;
Voici les déclarations de variables globales. Si nous voulons assigner une valeur à une variable, il faut affecter la variable d’un type tout d’abord. Par exemple « int » est pour entier et est un nombre entier représenté par 16 bits (bits numéros 15 et un bit de signe). « Unsigned int » est aussi un entier, mais avec aucun bit de signe. Autrement dit, il ne peut être positif, mais il peut être deux fois plus grand à cause de la mèche extra numéro. Ces variables sont nécessaires dans la fonction main() ainsi que les routines d’interruption, donc j’ai déclaré à eux ici avant le début de la fonction main(). Ce qui rend ces variables globales, ce qui signifie qu’ils peuvent être consultés et modifiés par n’importe quelle partie du programme.
En outre, à ce stade, il est important de noter que chaque EXPRESSION doit fin avec un point-virgule!!! J’ai oublié ces tout le temps, et le compilateur me donne des erreurs... tout le temps.
int main (void) DDDR = 0 X 00 ;
{
DDRC = 0xDF ; //portc sortie pour 7 segment multiplexage et 1 entrée pour l’affichage de la distance
DDRB = 0xFF ; //portb sortie fot 7 segments données en bcd
PORTD | = 0xFF ; //Enable portd tirer vers le haut de résistances
//(int0 and int1 require external pull up resistors or 1 interrupt will be triggered at reset)
Maintenant, nous avons la fonction main(). C’est le début du programme réel, et il commence en configurant quelques choses. Les déclarations de DDRn ci-dessus assigne des valeurs à la Direction enregistre les données pour les 3 ports. Ces registres de 8 bits configurer les broches e/s comme entrées ou sorties. Un 1 en position de bit fera le pin correspondant à une sortie, et un 0 il ferait une entrée. Les valeurs assignées peuvent être en décimal, binaire ou hexadécimal. Nombres décimaux sont écrits normalement, comme 255. Binaire et hexadécimal ont un préfixe pour indiquer au compilateur quel numéro c’est. Binaire serait 0b11111111. Hex serait 0xFF. Ces trois sont égaux à 255, et le compilateur ne soucie pas que vous utilisez. Hex est normalement le système de numération de choix car il est plus facile à lire que le binaire et plus facile de relier binaire à décimal... L’équivalent binaire du nombre assigné à n’importe quel DDR est 8 bits représentant la direction de données des 8 broches du port. Le PORTD | = FF ; permet les résistances de pull-up sur les broches d’entrée. Si PORTD ont été configuré en tant que sortie, puis l’affectation changerait les États de sortie de ces broches
Découvrez votre HEX conversions binaire et les mémorisent ! Il est très pratique...
Pour obtenir un didacticiel HEX : http://www.microbuilder.eu/Tutorials/Fundamentals/Hexadecimal.aspx ***
EICRA | = (1 << ISC11) | (1 << ISC01) ; //configure interruptions externes
EIMSK | = (1 << INT1) | (1 << INT0) ;
TCCR1B | = (1 << CS12) ; //set prescaling de timer1 256
Cette la partie où j’ai habituellement pour retirer la feuille de données pour l’AVR et faire creuser un peu. EICRA est l’a interrompre contrôle Registre externe. Ce registre a 4 bits que nous pouvons définir pour configurer comment les interruptions sont déclenchées par les broches externes interruption INT0 et INT1. Chacun des 4 bits a un nom unique pour l’identifier en définissant ou en désactivant les morceaux. ISC00 et ISC01 sont contrôle sens interruption pour INT0. Règlent le type de modification nécessaire sur la broche de INT0 pour déclencher l’interruption. ISC10 et ISC11 sont le même contrôle pour la broche INT1. Vérifier la fiche technique indique qu’en affectant à ISC01 et ISC11, nous avons configuré les deux broches d’interruption pour déclencher sur le bord du négatif va seulement. L’expression (1 << ISC11) est un peu les opérateur de décalage pour définir le bit ISC11. Voir « Programmation en C des microcontrôleurs » pour tout savoir sur les opérateurs et de manipulation de bits ; C’est un peu trop d’aller ici.
Le registre EIMSK (masque d’interrompre externe) a deux bits pour activer ou désactiver les interruptions externes. Deux de ces bits doivent être fixés ou les routines d’interruption ne seront exécutera jamais.
TCCR1B (Timer/compteur contrôle Register 1 B) a plusieurs bits qui peuvent configurer le comportement de la minuterie. Tout ce que nous avons besoin de s’inquiéter ici est la valeur prescaling. Cela signifie simplement, combien l’horloge CPU impulsions seront pris en compte avant que la minuterie est incrémentée de 1. Dans ce cas, j’ai choisi une valeur prescale de 256, représenté en définissant le bit CS12 (cocher la feuille de données.) Cela divise l’horloge du CPU par 256 avant de l’appliquer au timer/compteur aidant à prévenir les débordements de compteur dans le laps de temps, que nous essayons de mesurer.
/************************************************************************/ SEI() ;
/ * déclarer des variables pour le calcul et l’affichage * /
/************************************************************************/
unsigned int ceux = 0 ;
unsigned int dizaines = 0 ;
unsigned int centaines = 0 ;
unsigned int x = 0 ;
double ticsfoot = 0 ;
double fps = 0 ;
double fph = 0 ;
double m/h = 0 ;
double km/h = 0 ;
double mps = 0 ;
distance de l’int = 0 ;
OK, une section facile ! Il s’agit de quelques déclarations plus variables et cette chose sei(). « sei() » est une commande connue du compilateur pour signifier « activer les interruptions globales. » Sans interruptions déclenchera si ce bit n’est pas défini. « cli() » efface le bit de désactivation des interruptions globales. Nous allons utiliser celui-là plus tard pour éviter les problèmes.
while(1)
{
/************************************************************************/
/ * capteur de distance en pieds en retire pind 0,1,4,5 * /
/************************************************************************/
int distanceinput = (~ PIND & 0 x 33) ;
int hibits = (distanceinput >> 2) ; //getting pind bits 0,1 et 4,5 ensemble pour être
int lobits = (distanceinput & 0 x 03) ; //distance valeur en BCD. bits 2, 3 sont les
distance = (hibits + lobits) ; //ext goupilles d’interruption déjà en cours d’utilisation.
si (distance == 0) distance = 16 ;
Cette petite section lit le statut des 4 commutateurs dip qui permettent à l’utilisateur de choisir la distance entre les capteurs. Il y a quelques manipulation de bits passe ici parce que les 4 entrées ne sont pas consécutifs. Les variables « hibits » et « lobits » sont des lieux de stockage juste temporaire pour trier les petits bouts. La première ligne isole les bits que nous voulons avec les & opérateur. La deuxième ligne décale les bits plus 2 places l’EEG le Salut mèches dans la position correcte. La troisième ligne isole seulement le lo mèches. Ensuite, dans la quatrième ligne du lo et hi des morceaux sont ajoutés pour les rendre un seul numéro. L’instruction « if » il à la fin empêche l’utilisateur de choisir « 0 » et provoquant un état de « division par zéro » plus tard. /************************************************************************/
/* 'ready' indicator LED */
/************************************************************************/
Si (interruptcount == 0)
{
PORTC | = (1 << 3) ;
}
d’autre
{
PORTC & = (0 << 3) ;
}
Cette section apprend si il y a une mesure en cours et les lumières le ready LED si pas. La variable interruptcount est incrémentée dans les routines d’interruption pour aider le programme à garder une trace de quelle partie de la mesure se déroule actuellement. Nous allons voir les routines d’interruption vers la fin du code.
/************************************************************************/
/ * calculs pour trouver la vitesse à 4 unités * /
/************************************************************************/
si (interruptcount == 2) //only calculer lorsque les deux interruptions ont eu lieu
{
CLI() ; //disable interruptions global
ticsfoot = (temps / distance) ; //distance est la distance entre les capteurs en pieds - ticsfoot est compteur tics/pied
fps = (57600 / ticsfoot) ; //57600 est compteur tics/sec (cpu clk/diviseur)
fph = (fps * 60 * 60) ;
m/h = (fph / 5280) ;
km/h = (m/h * 1.609344) ;
MPS = (fps * 0,3048) ;
EIMSK | = (1 << INT1) | (1 << INT0) ;
SEI() ; //re-enable interruptions externes et les interruptions globales
}
Si la variable interruptcount est incrémentée deux fois (cela arrive plus tard dans les routines d’interruption,) cela signifie que les deux interruptions intervenues et la valeur mesurée est prête à être utilisé dans les calculs. Ici, nous voyons l’instruction cli() qui désactive les interruptions. Il est conseillé de le faire lors de la lecture d’une variable à laquelle une interruption est la capacité de changer. Pourquoi ? Les variables normales « int », par exemple, sont de longueur de 16 bits, ou deux octets. L’AVR est un système de 8 bits, il faut deux instructions pour lire les octets 2 d’une valeur unique. Ensuite, il est possible, pour une interruption après le premier octet est lu, mais avant la seconde. Si vous tentez de lire une variable, mais l’interruption se produit après avoir lu le premier octet, la routine d’interruption peut changer la valeur de la variable avant qu’il ait fini en cours de lecture ! Le programme reprendra où il était arrêté et lire le deuxième octet de la variable avec des données qui ne correspondant pas au premier octet ! Puis la valeur que vous avez chargé n’est pas ce qui devrait et peut causer des problèmes.
Ici, le calcul n’est pas trop compliqué. Les observations devraient suffire à comprendre ce qui se passe. C’est où nous utilisons la variable distance des interrupteurs dip. La variable temps vient plus tard les routines d’interruption.
La première interruption se désactive dans sa routine de sorte qu’il peut fonctionner seulement une fois avant que la mesure est terminée. C’est pourquoi l’instruction EIMSK est là. Il réactive les deux interruptions externes afin que celui qu’on était premier et a obtenu handicapés seront activés à nouveau.
/************************************************************************/
/* choose output options */
/************************************************************************/
if (!( PIND & (1 << PIND6)) & & (PIND & (1 << PIND7))) //choose pieds/sec Si (résultat > = 999) résultat = 999 ;
{
Round(FPS) ;
résultat = fps ;
}
ElseIf (PIND & (1 << PIND6) & &! () PIND & (1 << PIND7))) //choose m/s
{
Round(MPS) ;
résultat = députés ;
}
ElseIf (PIND & (1 << PIND6) & & (PIND & (1 << PIND7))) //choose kilomètres/heure
{
Round(KPH) ;
résultat = km/h ;
}
else //default miles/hr
{
Round(mph) ;
résultat = mi/h ;
}
Cette section entière est lire les deux derniers interrupteurs dip pour déterminer les unités de sortie désirée. Puis il faut quelle que soit la valeur est stockée dans la variable résultat.
La fonction round() est un moyen facile d’obtenir des valeurs entières comme notre sortie sans introduire trop d’erreur. Cette fonction est incluse dans le fichier math.h qui est déjà inclus dans le programme par le fichier delay.h que nous avons inclus manuellement. Si vous regardez à la fenêtre de l’Explorateur de solution sur le côté droit dans le Studio d’ATMEL, vous verrez le projet nom suivi de "Dépendances" (marqués sur la photo). Après que vous générez la solution pour la première fois (cliquez sur Build >> générer la Solution,) tous les fichiers inclus dans le programme seront listées ici. Vous pouvez ensuite ouvrir le fichier delay.h qui nous comprenait au début du code et avoir un coup d’oeil. Si vous faites défiler à travers elle, vous devriez trouver l’instruction #include < math.h > près du sommet. Plus loin vers le bas, vous trouverez la fonction de _delay_ms() que nous appelons pour créer le 1ms retarder plus tard.
Le « si » à la fin empêche tente d’afficher un nombre qui ne tient pas sur nos 3 écrans.
/************************************************************************/
/ * délai d’arrêter plusieurs « 2ème interruption » déclenche * /
/ * sans retarder l’exécution de code principal * /
/************************************************************************/
ResetCount ++ ;
Si ((resetcount > = 0x00FF) & & (interruptcount > = 2)) //resetcount limite supérieure détermine le délai
{ //before reset. 0x00FF approx. 3 sec
interruptcount = 0 ;
ResetCount = 0 ;
}
Cette partie est (sorte de) une minuterie faite hors de la boucle principale while(1). Chaque fois que le programme effectue une boucle au-delà de ce point, resetcount est incrémenté. Les calculs se produisent uniquement si interruptcount est exactement 2 ; ainsi, si la deuxième interruption se produit encore une fois il ne sera pas gâcher les maths. Si l’interruptcount est de 2 ou plus, rien d’autre peut être mesurée jusqu'à ce que les incréments de resetcount jusqu'à 0x00FF donnant environ 3 secondes retardent pour l’objet cible de quitter la zone du capteur. Nous ne pouvons pas utiliser un délai normal ici parce que nous devons les affichages à nous montrer la valeur mesurée. Lorsque interruptcount est réinitialisé à 0, le prêt est allumée et la prochaine mesure est possible.
/********************************************************************************/
/ * affichage int résultat sur 3 chiffre sept segment affichage * /
/ * délai donne sept temps de décodeur de segment pour décoder et afficher les chiffres * /
/********************************************************************************/
if (!( PINC & (1 << PINC5))) //to réglage de la distance sur l’écran d’affichage
{ //only while button is pressed
résultat = distance ;
}
d’autre
Cette « if » montres juste le bouton poussoir qui est une demande afin que le point de réglage de distance indiqué sur les écrans. Le dernier calcul de vitesse est stocké dans le résultat, chaque fois que la section d’unités de sortie (ci-dessus) est exécutée dans la boucle, donc résultat équivaut seulement à distance tandis que le bouton est enfoncé.
des centaines = (résultat / 100); //Get 100 ' s place à chiffres des dizaines = (x / 10) ; Ones = x ;
x = (résultat 100 %) ;
PORTB = (0x00|hundreds) ;
PORTC | = (1 << 2) ; / / écriture des chiffres
_delay_ms(1) ;
PORTC & = (0 << 2) ;
x = x % 10 ;
PORTB = (0x00|tens) ;
PORTC | = (1 << 1) ; / / écriture des chiffres
_delay_ms(1) ;
PORTC & = (0 << 1) ;
PORTB = (0x00|ones) ;
PORTC | = (1 << 0) ; / / écriture des chiffres
_delay_ms(1) ;
PORTC & = (0 << 0) ;
}
}
Enfin ! à l’affichage ! Maintenant que « resultat » est égal à un nombre décimal valide à 3 chiffres, nous devons casser vers le haut en chiffres uniques et envoyez-les à l’affiche à son tour. Nous allons obtenir chaque chiffre et stockez-le dans une variable appelée, des dizaines ou des centaines. Les centaines de placer le chiffre est facile ; simplement diviser par 100. La variable est un type « int », donc rien après la virgule décimale est stocké. « x » est une variable temporaire pour stocker la valeur requise suivante. L’opérateur « % » fait de la division, mais renvoie le reste à « x ». Cela nous donne le chiffre des dizaines et unités à traiter. Diviser par 10 et répéter pour les grands. C’est un moyen facile de séparer tous vos chiffres d’aller vers les écrans et peuvent très simplement être développé pour fonctionner avec un plus grand nombre.
Les instructions PORTB écrivent les chiffres sur les broches de sortie allant vers le décodeur 7 segments. À peu près le même moment, les instructions PORTC activer la sortie à transistor au sol de l’écran correspondant à la lumière des chiffres. Le retard tient alors l’affichage pour 1ms avant arrière-éteindre le transistor et passer au chiffre suivant. Plutôt cool.
Les accolades de clôture finissent du bloc de code de boucle de While(1) et terminent le bloc de code de fonction main().
/************************************************************************/ }
/* sensor 1 interrupt */
/************************************************************************/
ISR(INT0_vect)
{
Si (interruptcount == 0)
{
TCNT1 = 0 X 0000 ; //reset compteur à 0
interruptcount ++ ; //increment interruption comte
EIMSK & = (1 << INT1) | (0 << INT0) ; //disable INT0
}
ElseIf (interruptcount == 1)
{
temps = TCNT1 ; valeur du compteur //capture
interruptcount ++ ; //increment interruption comte
}
else resetcount = 0 ;
/************************************************************************/
/* sensor 2 interrupt */
/************************************************************************/
ISR(INT1_vect)
{
Si (interruptcount == 0)
{
TCNT1 = 0 X 0000 ; //reset compteur à 0
interruptcount ++ ; //increment interruption comte
EIMSK & = (0 << INT1) | (1 << INT0) ; //disable INT1
}
ElseIf (interruptcount == 1)
{
temps = TCNT1 ; valeur de compteur //capture
interruptcount ++ ; //increment interruption comte
}
else resetcount = 0 ;
}
Maintenant, les deux interrompent routines... Ils sont exactement les mêmes à l’exception d’une seule instruction, donc je vais juste parler de l’un.
Tout d’abord, Notez que les routines d’interruption ne relèvent pas de la fonction main(). Le programme s’arrête à ce que son poids complètement, quitte la fonction main() et exécute la routine d’interruption. Après l’interruption routine est terminée, il retourne à la fonction main() où elle s’était arrêtée.
La première ligne, ISR(INT0_vect), est le nom de l’interruption de la feuille de données. Si l’interruption est activée dans le registre EIMSK et global interruptions sont activées, le programme va sauter cette ligne lorsque l’interruption est déclenchée.
Vous verrez que les routines d’interruption sont essentiellement constitués d’un composé ' IF... ELSE IF' instruction qui ne fait que quelques petites choses. Habituellement, il est préférable de garder les routines d’interruption très court, changeant que ce qui doit être changé et rapidement pour en revenir à la fonction main(). À l’aide de la variable interruptcount pour suivre le nombre d’interruptions qui ont eu lieu nous permet d’effectuer les routines identiques et permet également des capteurs de « voir » les objets cibles venant de n’importe quelle direction.
Quelle que soit l’interruption exécute tout d’abord réinitialise le minuteur de TCNT1 (l’un nous avons mis le Prédiviseur au début,) puis incrémente la variable interruptcount, puis se désactive afin qu’il ne peut pas être déclenché une fois supplémentaire par un objet de cible de forme irrégulière.
Puisque la première interruption incrémentée interruptcount, l’autre se déroulera les prochaines lignes de couple. Cette fois nous capturer la valeur dans la minuterie TCNT1 et stocker dans la variable « temps » à utiliser dans les calculs. Alors interruptcount est incrémentée à nouveau.
Avec interruptcount maintenant égal à 2, les calculs sont effectués et le resetcount compte jusqu'à 0x00FF avant il se réinitialise tout pour la prochaine mesure. Si la deuxième interruption est déclenchée à nouveau pour une raison quelconque, resetcount est défini sur 0 et l’attente commence à nouveau. Voilà comment j’ai empêché plusieurs déclencheurs de la 2e interruption pour aussi longtemps que nécessaire pour l’objet cible être à l’écart.
Ouf, j’espère qu’au moins un peu de sens... Dans l’étape suivante, nous chargera le programme dans notre puce et tester le circuit breadboarded !
