Étape 7: Génération de la solution ; chargement du programme.
À ce stade, vous verrez un tas de trucs à passer dans la fenêtre de sortie en bas, et si il y a des erreurs du compilateur vous les verrez ici aussi. Si vous avez tapé le code exactement comme je l’ai dans la dernière étape, vous ne devriez pas avoir des erreurs. Juste au cas où, je vais copier et coller le code dans son intégralité directement à partir de mon fichier à la fin de cette étape. J’ai juste trouvé que je peux télécharger des fichiers aussi, c’est pourquoi j’ai inclus un fichier ZIP avec tous les fichiers d’ATMEL Studio.
À ce stade, vous devez vous connecter le Dragon au port USB sur votre ordinateur.
Sur la 2e photo, en haut à droite, vous verrez « ISP sur AVR Dragon » hilighted. Cliquez ici pour ouvrir une fenêtre pour configurer les paramètres de l’outil tout comme lorsque nous avons mis les bits de fusible. Sûr que AVR Dragon est sélectionnée et ISP pour l’interface et cocher l’ISP horloge. Au-dessous, les paramètres de programmation devrait déjà ont « effacer toute puce » sélectionné et « préserver l’EEPROM » décochée. Alimenter votre circuit de maquette, connectez le câble ruban de 6 broches du Dragon, et nous voilà prêt à partir.
Maintenant, pour charger le programme à la puce. Vous pouvez cliquer sur Outils >> Programmation appareil >> dossier de production et puis recherchez le fichier et le programme. Mais ! Il est beaucoup plus facile à déboguer, cliquez simplement sur >> Exécuter sans débogage (photo 3). Cela automatiquement RECOMPILE le programme et le charge de la puce sans un autre mot tant qu’il n’y a aucun rerrors de compilation.
C’est elle ! Si cela a fonctionné, vous devriez avoir un chronographe fonctionne sur une maquette ! Vous pouvez jouer avec lui en touchant 12VDC aux entrées capteur (les circuits transistor ; pas les broches d’entrée) avec un fil de raccordement. En outre, jouer avec les interrupteurs DIP et tester le bouton « afficher la distance ». Une fois que vous obtenez un certain nombre en tant que sortie, vous pouvez tester les commutateurs DIP "sélection d’unités de sortie" et vérifier les calculs.
Maintenant serait aussi un très bon moment pour s’assurer que vos capteurs fonctionnent correctement avec le circuit. Je suis en supposant que probablement personne n’utilisera les mêmes capteurs que j’ai, donc test vôtre maintenant avant de commencer à penser à une Commission permanente de gravure... mieux d’apporter des changements maintenant alors que le circuit est libre d’étain.
Ensuite, nous aurons un regard sur la création de la présentation schématique et Conseil avec ExpressPCB...
CODE COMMENCE AU-DESSOUS DE CETTE LIGNE ***
/*
* 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 >
/************************************************************************/
/ * déclarer des variables globales * /
/************************************************************************/
unsigned int résultat = 0 ;
int interruptcount = 0 ;
temps d’int = 0 ;
long int resetcount = 0 ;
int main (void)
{
DDDR = 0 X 00 ; portd entrée pour interruptions externes
DDRC = 0XDF ; portc sortie pour 7 segment multiplexage et 1 entrée pour l’affichage de la distance
DDRB = 0XFF ; PORTB sortie données segment fot 7 en bcd
PORTD | = 0XFF ; activez portd tirer vers le haut de résistances
(int0 et int1 nécessitent externe tirer vers le haut de résistances ou 1 interruption sera déclenchée au reset)
EICRA | = (1 << ISC11) | (1 << ISC01) ; configurer les interruptions externes
EIMSK | = (1 << INT1) | (1 << INT0) ; //
TCCR1B | = (1 << CS12) ; la valeur prescaling de timer1 256
/************************************************************************/
/ * 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 ;
SEI() ; activer les interruptions globales
while(1)
{
/************************************************************************/
/ * capteur de distance en pieds en retire pind 0,1,4,5 * /
/************************************************************************/
int distanceinput = (~ PIND & 0 x 33) ;
int hibits = (distanceinput >> 2) ; obtenir des bits pind 0,1 et 4,5 ensemble pour être
int lobits = (distanceinput & 0 x 03) ; valeur de la distance en BCD. bits 2, 3 sont les
distance = (hibits + lobits) ; goupilles d’interruption ext déjà en cours d’utilisation.
Si (distance == 0) distance = 16 ;
/************************************************************************/
/ * « prêt » indicateur LED * /
/************************************************************************/
Si (interruptcount == 0)
{
PORTC | = (1 << 3) ;
}
d’autre
{
PORTC & = (0 << 3) ;
}
/************************************************************************/
/ * calculs pour trouver la vitesse à 4 unités * /
/************************************************************************/
Si (interruptcount == 2) //only calculer quand les deux interruptions ont eu lieu
{
CLI() ; désactiver les interruptions globales
ticsfoot = (temps / distance) ; la 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() ; ré-activer les interruptions externes et les interruptions globales
}
/************************************************************************/
/ * choisir les options de sortie * /
/************************************************************************/
Si (! () PIND & (1 << PIND6)) & & (PIND & (1 << PIND7))) //choose pieds/sec
{
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 km/hr
{
Round(KPH) ;
résultat = km/h ;
}
d’autre //default miles/h
{
Round(mph) ;
résultat = mi/h ;
}
Si (résultat > = 999) résultat = 999 ;
/************************************************************************/
/ * 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)) la limite supérieure de //resetcount détermine le délai
{//before reset. 0x00FF env. 3 secondes
interruptcount = 0 ;
ResetCount = 0 ;
}
/************************************************************************/
/ * 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 * /
/************************************************************************/
Si (! () PINC & (1 << PINC5))) //to paramètre de distance affichage sur écran
{//only tandis que la touche
résultat = distance ;
}
d’autre
des centaines = (résultat / 100) ; obtenir 100 ' s place à chiffres
x = (résultat 100 %) ;
PORTB = (0x00|hundreds) ;
PORTC | = (1 << 2) ; écrire les chiffres
_delay_ms(1) ;
PORTC & = (0 << 2) ;
des dizaines = (x / 10) ; Obtenez 10 ' s place à chiffres
x = x % 10 ;
PORTB = (0x00|tens) ;
PORTC | = (1 << 1) ; écrire les chiffres
_delay_ms(1) ;
PORTC & = (0 << 1) ;
Ones = x ; Get de 1 place à chiffres
PORTB = (0x00|ones) ;
PORTC | = (1 << 0) ; écrire les chiffres
_delay_ms(1) ;
PORTC & = (0 << 0) ;
}
}
/************************************************************************/
/ * interruption du capteur 1 * /
/************************************************************************/
ISR(INT0_vect)
{
Si (interruptcount == 0)
{
TCNT1 = 0 X 0000 ; réinitialiser le compteur à 0
interruptcount ++ ; incrément interruption comte
EIMSK & = (1 << INT1) | (0 << INT0) ; désactiver INT0
}
ElseIf (interruptcount == 1)
{
temps = TCNT1 ; saisir la valeur du compteur
interruptcount ++ ; incrément interruption comte
}
else resetcount = 0 ;
}
/************************************************************************/
/ * interruption du capteur 2 * /
/************************************************************************/
ISR(INT1_vect)
{
Si (interruptcount == 0)
{
TCNT1 = 0 X 0000 ; réinitialiser le compteur à 0
interruptcount ++ ; incrément interruption comte
EIMSK & = (0 << INT1) | (1 << INT0) ; désactiver INT1
}
ElseIf (interruptcount == 1)
{
temps = TCNT1 ; saisir la valeur du compteur
interruptcount ++ ; incrément interruption comte
}
else resetcount = 0 ;
}
