AVR Chronograph från koncept till PCB (7 / 13 steg)

Steg 7: Bygga lösningen; Laddar programmet.

När all kod skrivs (faktiskt du skulle göra detta mycket tidigare under utveckling) du behöver för att bygga lösningen. Detta är när kompilatorn översätter all kod till en HEX-fil. HEX filen är vad faktiskt får lastades på chipet och är enda chip kan förstå. Om du någonsin sett en HEX-fil, du vet att det är helt un-kan läsas av människor, så tacka kompilatorn. Första bilden visar menyalternativet klicka: bygga >> Build Solution.

Här ser du en massa saker gå i utdatafönstret i botten, och om det finns någon Kompilatorfel ser du dem här också. Om du har angett koden exakt som jag har i det sista steget inte bör du ha några fel. Bara i fall jag kopiera och klistra in koden i sin helhet direkt från min fil i slutet av detta steg. Jag listat bara ut att jag kan ladda upp filer också, så jag inkluderat en ZIP-fil med alla filer som ATMEL Studio.

På denna punkt bör du ansluta draken till USB-porten på din dator.

I 2: a pic ser i det övre högra, du "ISP på AVR Dragon" hilighted. Klicka här för att få upp ett fönster konfigurera verktygsinställningar precis som när vi anger fuse bitar. Se till att AVR Dragon är markerat, och ISP för gränssnittet, och kontrollera Internet-leverantören klocka. Under dessa, programmering inställningar bör redan ha "radera hela chip" markerad och "bevara EEPROM" oskyddad. Driva din skärbräda krets, Anslut flatkabeln 6 pin från draken och vi är bra att gå.

Nu laddar programmet till chipet. Du kan klicka på Tools >> enhet Programmering >> produktion filen och bläddra till filen och programmet. Men! Det är mycket lättare att helt enkelt klicka på Debug >> Starta utan felsökning (3: e bild.) Detta kompilerar programmet automatiskt och laddar det till chip utan ett annat ord så länge det finns ingen sammanställa rerrors.

Thats det! Om det fungerade bör du ha en fungerande kronograf på en skärbräda! Du kan spela med det genom att röra vid 12VDC till sensoringångar (transistor kretsar, inte input stiften) med en jumper tråd. Även spela med DIP-switchar och testa knappen "Visa avstånd". När du får några nummer som en utgång, kan du testa "output enheter urval" DIP-switchar och kontrollera matten.

Nu skulle också vara en ganska bra tid att se till att din sensorer fungera korrekt med kretsen. Jag antar att kommer antagligen använda samma sensorer som jag har, så testa din nu innan vi börja tänka på etsning en permanent styrelse... bättre för att göra ändringar nu medan kretsen är gratis lödtenn.

Nästa, vi har en titt på att skapa schematiska och styrelsen layouten med ExpressPCB...

KODEN BÖRJAR UNDER DENNA LINJE ***

/*
* Speed_measurement.c
*
* Skapat: 9/15/2012 8:50:23 PM
* Författare: Thomas L
*/

#define F_CPU 14.7456E6

#include < avr/io.h >
#include < util/delay.h >
#include < avr/interrupt.h >

/************************************************************************/
/ * förklara globala variabler * /
/************************************************************************/
unsigned int resultatet = 0;
int interruptcount = 0;
långa int tid = 0;
långa int resetcount = 0;

int main(void)
{

DDRD = 0X00; portd ingång för extern avbryter
DDRC = 0XDF; portc utgång för 7 segment multiplexing och 1 ingång för avstånd visning
DDRB = 0XFF; portb utgång fot 7 segment data i bcd
PORTD | = 0XFF; Aktivera portd dra upp motstånd
(int0 och int1 kräver extern dra upp motstånd eller 1 avbrott kommer att utlösas vid reset)

EICRA | = (1 << ISC11) | (1 << ISC01); Konfigurera externa avbryter
EIMSK | = (1 << INT1) | (1 << INT0); //
TCCR1B | = (1 << CS12); Ange prescaling för timer1 256

/************************************************************************/
/ * deklarera variabler för beräkning och * /
/************************************************************************/

unsigned int de = 0;
unsigned int tior = 0;
unsigned int hundratals = 0;
unsigned int x = 0;
Double ticsfoot = 0;
dubbel fps = 0;
dubbel fph = 0;
dubbel mph = 0;
dubbel km/h = 0;
Dubbelrum m/s = 0;
int avstånd = 0;

SEI(); Aktivera global avbryter

While(1)
{

/************************************************************************/
/ * få sensorn avståndet i fötter från pind 0,1,4,5 * /
/************************************************************************/

int distanceinput = (~ PIND & 0x33);
int hibits = (distanceinput >> 2); att få pind bitar 0,1 och 4,5 tillsammans för att
int lobits = (distanceinput & 0x03); avståndet värdet i BCD. bitar 2,3 är den
avståndet = (hibits + lobits); ext-avbrott stift bruk redan i.

om (avstånd == 0) avstånd = 16.

/************************************************************************/
/ * "redo" indikator LED * /
/************************************************************************/

om (interruptcount == 0)
{
PORTC | = (1 << 3);
}
annat
{
PORTC & = (0 << 3);
}

/************************************************************************/
/ * beräkningar för att hitta hastigheten i 4 enheter * /
/************************************************************************/

om (interruptcount == 2) //only beräkna när båda avbrott har inträffat
{
CLI(); Inaktivera globala avbryter

ticsfoot = (tid / avstånd); avståndet är avståndet mellan sensorer i fot - ticsfoot är counter tics eller foten
FPS = (57600 / ticsfoot); 57600 är counter tics/SEK (cpu clk/prescaler)
FPH = (fps * 60 * 60);
mph = (fph / 5280);
km/h = (km/h * 1.609344);
m/s = (fps * 0.3048);

EIMSK | = (1 << INT1) | (1 << INT0); //
SEI(); Re-möjliggöra extern avbrott och globala avbryter
}

/************************************************************************/
/ * välja utmatningsalternativ * /
/************************************************************************/

om (! () PIND & (1 << PIND6)) & & (PIND & (1 << PIND7))) //choose fot per sekund
{
Round(fps);
resultat = fps;
}
annars om (PIND & (1 << PIND6) & &! () PIND & (1 << PIND7))) //choose meter/sekund
{
Round(MPS);
resultat = mps;
}
annars om (PIND & (1 << PIND6) & & (PIND & (1 << PIND7))) //choose kilometer i timmen
{
Round(KPH);
resultat = km/h;
}
annat //default miles/tim
{
Round(mph);
resultat = mph;
}

om (resultat > = 999) resultatet = 999;

/************************************************************************/
/ * dröjsmål att stoppa flera "2nd avbrott" utlöser * /
/ * utan att försena viktigaste kod * /
/************************************************************************/

ResetCount ++;

om ((resetcount > = 0x00FF) & & (interruptcount > = 2)) //resetcount övre gräns bestämmer dröjsmål
{//before reset. 0x00FF ca 3 SEK
interruptcount = 0;
ResetCount = 0;
}

/************************************************************************/
/ * Visa int resultatet på 3 siffrig sju segment display * /
/ * försening ger sju segment dekoder tid att avkoda och Visa siffror * /
/************************************************************************/

om (! () PINC & (1 << PINC5))) //to avstånd inställningen på displayen
{//only när knappen är nedtryckt
resultat = avstånd;
}
annat

hundra = (resultatet / 100); få 100-tals plats siffriga
x = (resultatet % 100).
PORTB = (0x00|hundreds);
PORTC | = (1 << 2); skriva siffror
_delay_ms(1);
PORTC & = (0 << 2);

TENS = (x / 10); få 10 's plats siffriga
x = x % 10.
PORTB = (0x00|tens);
PORTC | = (1 << 1); skriva siffror
_delay_ms(1);
PORTC & = (0 << 1);

de = x; få 1: s plats siffriga
PORTB = (0x00|ones);
PORTC | = (1 << 0); skriva siffror
_delay_ms(1);
PORTC & = (0 << 0);

}
}

/************************************************************************/
/ * sensor 1 avbrott * /
/************************************************************************/
ISR(INT0_vect)
{
om (interruptcount == 0)
{
TCNT1 = 0X0000; Återställ räknaren till 0
interruptcount ++; Increment avbrott räknas
EIMSK & = (1 << INT1) | (0 << INT0); Inaktivera INT0

}
annat if (interruptcount == 1)
{
tid = TCNT1; fånga räknarvärdet
interruptcount ++; Increment avbrott räknas

}
annat resetcount = 0;

}

/************************************************************************/
/ * sensor 2 avbrott * /
/************************************************************************/
ISR(INT1_vect)
{
om (interruptcount == 0)
{
TCNT1 = 0X0000; Återställ räknaren till 0
interruptcount ++; Increment avbrott räknas
EIMSK & = (0 << INT1) | (1 << INT0); Inaktivera INT1

}
annat if (interruptcount == 1)
{
tid = TCNT1; fånga räknarvärdet
interruptcount ++; Increment avbrott räknas

}
annat resetcount = 0;
}