Ladda ner rapporten... - EIT - Lunds Tekniska Högskola

Väderstation 

Projektrapport, Digitala projekt HT 04 

Institutionen för Informationsteknologi 

Utfört av: John Kaber och Marcus Ekerhult 

Handledare: Bertil Lindvall 

Datum: 2004-12-07

Sammanfattning 

Vårt projekt inriktar sig på styrning och avläsning av sensorer, vilket vi anser blir ett mer 

och mer attraktivt område inom industrin. Väderstationen har två stycken 

temperatursensorer och själva kärnan i systemet är uppbyggt runt den välkända 

processorn 68008 från Motorola. Nu valde vi temperatursensorer, men i praktiken hade vi 

kunnat välja sensorer för tryck, fuktighet, acceleration, m.m. Det är bara fantasin och 

naturligtvis pengarna som avgör användningsområdet. 

Väderstationen har en alfanumerisk LCD-display, samt en 16-knappars knappsats för 

styrning av systemet. 

Sida 2 av 43

Innehållsförteckning 

Väderstation.........................................................................................................................1 

Sammanfattning ...................................................................................................................2 

Innehållsförteckning.............................................................................................................3 

Inledning ..............................................................................................................................4 

Genomförande......................................................................................................................5 

Ritning..............................................................................................................................5 

Virning .............................................................................................................................5 

Test av hårdvaran med it-68.............................................................................................5 

Utveckling och test av mjukvaran med it-68 ...................................................................6 

Bortkoppling av it-68 .......................................................................................................6 

Beskrivning av användargränssnitt ......................................................................................7 

Ställ klocka.......................................................................................................................7 

Visa Temperatur ...............................................................................................................8 

Visa sparad data ...............................................................................................................8 

Visa min och max ............................................................................................................9 

Ställ alarm........................................................................................................................9 

Resultat...............................................................................................................................11 

Diskussion..........................................................................................................................12 

Appendix A: Programkod ..................................................................................................13 

Appendix B: PAL ..............................................................................................................40 

Appendix C: Hårdvara - En sammanfattning av kopplingsschemat..................................42 

Processor: Motorola 68008 ............................................................................................42 

SRAM: 43256 ................................................................................................................42 

EPROM: 27C256 ...........................................................................................................42 

PAL: PAL22V10 ...........................................................................................................42 

Knappsats: 16 knappars telefontangentbord ..................................................................42 

Knappsatsavkodare: 74C922..........................................................................................42 

Temperaturgivare: LM335 .............................................................................................42 

A/D-omvandlare: ADC0804 ..........................................................................................42 

Spänningsreferenser: LM336 .........................................................................................43 

Realtidsklocka: ICM7170 ..............................................................................................43 

LCD display:..................................................................................................................43 

Sida 3 av 43

Inledning 

Denna rapport är en del av kursen Digitala Projekt vilken ges av Institutionen för 

Informationsteknologi vid Lunds Tekniska Högskola. 

Kursen är som namnet antyder projektbaserad och går i stora drag ut på att man skall 

realisera en applikation med hjälp av hårdvara, samt dokumentera och redovisa sina 

resultat. 

Vi har valt att bygga en Väderstation och har satt upp följande krav på vår konstruktion: 

Två analoga signaler (från temperaturgivare) ska avläsas och presenteras kontinuerligt i 

hela grader Celsius. Varje sekund skall det aktuella värdet tillfälligt sparas undan för att 

var 60:de sekund, det vill säga varje minut, bilda medelvärdet av den aktuella 

temperaturen. 

När så önskas skall dygnets max- och minimitemperatur kunna presenteras i hela grader 

Celsius samt även dygnsmedeltemperaturen. 

Mätinsamling med tidsangivelse (mån, dag, tim, min) skall kunna presenteras. 

Via knappsatsen skall två larmgränser kunna programmeras in (till en av mätarna). 

När någon av larmgränserna överskrids ska varning ske. 

Temperaturintervallet väderstationen skall kunna mäta inom är det normala svenska 

medelklimatet. 

Rapporten behandlar den hårdvara vi valde samt de problem som uppstod vid 

genomförandet. 

Institutionen tillhandahåller två olika plattformar att utveckla på; AVR ATMega16, samt 

Motorola mc68008, 

Vi valde att an mc68 eftersom vi skulle spara undan en relativt stor mängd data och 

mc68 kan adressera en större rymd at ATMega16. 

Sida 4 av 43

Genomförande 

Genomförandet av väderstationen kan sammanfattas under fem huvudpunkter: 

• Ritning av kretsschema i programmet PowerLogic 

• Virning och lödning av komponenter. 

• Test av hårdvara med it-68 

• Utveckling och test av mjukvara med it-68 

• Bortkoppling av it-68 

Ritning 

Ritningen påbörjades strax efter första laborationen och pågick en dryg vecka. En del 

modifieringar har tillkommit efter hand. 

Schemat är ritat i programmet PowerLogic. Vi fick hjälp av vår handledare Bertil med 

tips och trix, men mycket av problemen vid ritningen löstes med hjälp av databladen. 

Virning 

När vi ritat klart på datorn var det dags att börja bygga. Lite komponenter, verktyg samt 

ett experimentbord från Bertil var det som behövdes för att komma igång. 

Att vira var ett arbete som till en början var både tidsödande och lite knepigt. Nu i slutet 

känns det naturligt och fort går det dessutom. Det är lätt att göra ändringar, om felen 

upptäcks dvs. Att etsa ett kort till ett sådant här projekt vore helt otänkbart med tanke på 

alla de logiska fel som gjordes från början. All drivspänning till kretsarna löddes fast med 

lite grövre kopplingsråd, då det inte är säkert att wiretråd klarar det strömuttag som kan 

uppstå. De båda oscillatorerna byggdes upp på ”sk lödsocklar” för att få ett kompakt 

format då detta är högst önskvärt när det gäller oscillatorer. 

Test av hårdvaran med it-68 

Bertil introducerade oss till hur testning av hårdvaran går till. Genom att på ett metodiskt 

sätt koppla in en komponent i taget, kan man isolera de problem som uppstår. Hade vi 

istället pluggat in alla komponenter på en gång och sedan direkt börjat felsöka, hade vi 

med största sannolikhet inte hittat enstaka fel. 

Displayen hade vi relativt stora problem med att få initierad. Till slut visade det sig att vi 

både hade vänt den upp och ner, samt vänt på MSB och LSB i databussen. Det var ett 

stort steg att få igång displayen, då den gav oss möjlighet att visuellt visa olika värden 

från kringkomponenter såsom RTC och ADC. 

RTC:n fick vi snabbt igång, med tillägg att vi inte förstod hur den skulle ställas in på rätt 

tid. Efter ett par timmar med det lite torftiga databladet och it-68: an, tickade den igång 

med rätt tid i registrena, samt genererade ett avbrott varje sekund. 

ADC kretsarna fick vi komplettera med två stycken spänningsreferenser på 2.5V för att 

begränsa spänningssvinget och på så vis öka upplösningen. 

Sida 5 av 43

Utveckling och test av mjukvaran med it-68 

För att konstruktionen skall fungera krävs att parametrar som t.ex. stackpekare initieras i 

assembler. Vi fick från början ett färdigt programskelett att jobba med. Detta var en 

lättnad, då ingen av oss var någon höjdare på vare sig C eller Motorola-assembler. Vi fick 

dessutom låna en bra handbok i C av Bertil, så nu när projektets är slut är vi självfallet 

mästare på C. 

För att kunna utveckla programkod på ett effektivt sätt har en utvecklingsmiljö (ICE, In 

Circuit Emulation) tagits fram på IT-avdelningen. Den heter it-68 och arbetar seriellt via 

terminalprogram gentemot en PC. Istället för att processorn sätts i väderstationen, 

kopplas en kabel via en adapter till it-68 hårdvara. 

Detta förenklar avsevärt utvecklingen, eftersom man då inte behöver bränna ett EPROM 

varje gång ny kod skall testas. Programkoden skickas istället via RS-232 till it-68 som i 

sin tur är kopplad rätt in i vår väderstation. 

It-68 har bland annat följande funktioner. 

• Test av minne och I/O enheter 

• Minnesarea för exekvering av program 

• Brytpunkter samt singelhopp 

Vi har utvecklat ett intuitivt menysystem i C där man kan välja vilka data som skall 

presenteras på displayen med hjälp av en knappsats. 

Som nämnts tidigare har processorn 2 avbrottsnivåer, vilka va använder till tangentbordet 

och RTC:n. RTC:n genererar ett avbrott varje sekund och ligger således på den högsta 

prioritetsnivån. Tangentbordet ligger då på den lägsta. Vi använder autovektoriserade 

avbrott vilket betyder att processorn har ett i förväg bestämt register där den skall leta 

efter en startadress då ett avbrott sker. 

Vi valde att allokera ADC etc. på ganska höga adresser, bit 20-17. 

Vilket syns i allokeringstabellen nedan. 

Komponent: EPROM SRAM ADC_1 ADC_2 KEY_CTRL RTC DISP_DATA DISP_COM 

Adress: 0x00000 0x08000 0x20000 0x40000 0x80000 0xA0000 0xE0004 0xE0000 

- - 

- 

0x07FFF 0x0FFFF 

0xA0011 

Bortkoppling av it-68 

När programkoden till slut var färdigskriven och genomtestad var det dags att slutföra 

projektet genom att koppla loss vår hårdvara från it-68. För att ersätta utvecklingsmiljön 

måste vårt projekt kompletteras med två saker; processor samt ett eprom med 

programkoden inbränt i sig. Detta ledde till en del problem då minnesarean där epromet 

ligger inte går att testa med it-68. Detta löstes genom en funktion i it-68, som kopierar 

hela epromet till it-68 och sedan exekverar det därifrån. Detta var dock inte heller helt 

smärtfritt då kopieringen från epromet till it-68 inte fungerade som det skulle. Som med 

de flesta fel som uppstod, så var det fel virat. 

Sida 6 av 43

Beskrivning av användargränssnitt 

Väderstationens program är uppbyggt kring ett menysystem där man kan navigera mellan 

olika menyer som representerar varsin funktion. 

Figur 1: Diagram over väderstationens menysystem 

I texten nedan beskrivs vidare hur man kan navigera mellan systemets menyer med hjälp 

av knappsatsen. 

Vid uppstart av systemet behöver klockan ställas för att data skall kunna sparas med 

tidsangivelse. ”Ställ klocka” är därför alltid den första menyn som presenteras. 

Ställ klocka 

(yy) mata in årtal 

tryck för att spara , för att mata in igen 

mata sedan på liknade sätt in: 

Sida 7 av 43

(mm) mata in månad 

(dd) mata in dag 

(hh) mata in timme 

(mm) mata in minut 

(ss) mata in sekund 

När sekund har matats in och kvitterats via ställs klockan till den angivna tiden och 

systemet hoppar till menyn ”Visa temperatur”. 

Visa Temperatur 

Denna meny visar aktuell temperatur samt dygnsmedeltemperaturen. 

Genom att trycka på knappsatsen hopar systemet till menyn ”Ställ larm” Genom 

att trycka på hoppar systemet till menyn ”Visa sparad data” 

Visa sparad data 

Genom att trycka på eller kan man bläddra bland de sparade data värdena 

Och en skärm liknande den nedan presenteras. 

Sida 8 av 43

Genom att trycka på knappsatsen hoppar systemet till menyn ”Visa Temperatur”. 

Genom att trycka på hoppar systemet till menyn ”Visa min och max” 

Visa min och max 

Max- och min- temperatur presenteras omväxlande för givare a och givare b var femte 

sekund. 

Genom att trycka på knappsatsen hoppar systemet till menyn ”Visa sparad data” 

Genom att trycka på hoppar systemet till menyn ”Ställ alarm” 

Ställ alarm 

Skriv in den nedre larmgränsen (ll) för givare a genom att trycka på en knapp mellan 0-9 

två gånger. 

Tryck för att spara detta värde 

Sida 9 av 43

Tryck om du vill mata in ett nytt värde 

Tryck om du vill spara detta värde negativt, dvs om man knappar in 20 och trycker 

kommer talet –20 att sparas. Detta för att enkelt kunna sätta negativa 

larmgränser. 

Efter att ha knappat in den lägre larmgränsen för givare a får du knappa in den höga 

larmgränsen (hh) för givare a, följt av samma procedur för givare b. 

Efter att alla larmgränser är inknappade återgår systemet till menyn ”Visa temperatur” 

6.Alarm 

Om någon av larmgränserna passeras kommer följande skärm att presenteras: 

Displayen visar vilken givare och larmgräns som passerats. 

Genom att trycka på kommer larmgränserna att tas bort. 

Genom att trycka på återgår systemet till att visa aktuell temperatur och 

larmgränserna sparas. 

Observera att om man trycker på och temperaturen fortfarande är över eller under en 

larmgräns kommer systemet omedelbart att larma igen och man hamnar återigen vid 

”Alarm” menyn 

Sida 10 av 43

Resultat 

Konstruktionen uppfyller följande krav: 

Två temperaturer kan presenteras kontinuerligt i hela grader celcius 

Max och min samt dygnsmedeltemperatur kan presenteras 

Mätinsamling med tidsangivelse kan presenteras 

Två larmgränser kan programmeras in per givare 

Mätområde svenska medelklimatet 

Enligt kravspecifikationen skulle mätinsamling med tidsangivelse (mån,dag,tim,min) 

kunna presenteras. I skrivande stund uppfyller konstruktionen dock inte detta, utan 

presenterar endast sparade data med tidsangivelse i form av (dag,tim,min). Detta främst 

på grund av att displayen är för liten för att presentera all data på en skärm och vi inte har 

hunnit konstruera en alternativ lösning. I skrivande stund sparas således inte heller 

månadsangivelsen för respektive data. 

Förutom ovanstående uppfyller konstruktionen kravspecifikationen. 

Sida 11 av 43

Diskussion 

Under kursens gång har vi stött på en rad problem, vilka I och för sig ofta har varit på 

grund av våra egna tillkortakommanden. Våran handledare, Bertil, har dock alltid varit 

tillgänglig och har kommit med tips, råd och lösningar som har gjort att vi alltid har 

kunnat fortskrida. 

Med största sannolikhet hade vi inte kunnat genomföra projektet på så kort tid om det inte 

vore för hjälpen. 

Ett par mindre problem kvarstår i konstruktionen: 

Genom att koppla in en 2.5V referens på AD omvandlarnas V ref / 2 ingång försökte vi öka 

upplösningen från 20mV till 10mV. Detta innebär att en inspänning på 2.5V borde 

generera ett max värde (0xFF) på AD omvandlarens datautgång. Så är dock inte fallet, 

utan en spänning på 2.9V som genereras vid rumstemperatur ger runt 0x89 på 

datautgången. I skrivande stund har vi inte hunnit utreda varför. 

Vi har inte kunnat testa konstruktionen utan att it68 varit inkopplad, då vi får ett 

felmeddelande när vi försöker kopiera programmet från EPROM till minnet på it68. 

Detta innebär att vi inte heller har kunnat testa systemet med en processor och vår 

oscillator till denna. 

Knappsatsen ”studsar” även oönskat mycket, vilket vi försökte lösa genom att koppla in 

en kondensator på knappsatsavkodaren. Det gav en viss förbättring, men studsningar 

uppträder fortfarande lite för ofta för att vi skall vara nöjda. 

Eftersom våra kunskaper om konstruktion innan kursen var väldigt begränsade är vi 

mycket nöjda med vårat resultat och vad vi har lärt oss. Kursen har varit väldigt givande 

och vi har fått många praktiska kunskaper om konstruktion av digitala system, med 

betoning på just praktiska kunskaper, som annars är väldigt frånvarande i utbildningen. 

Sida 12 av 43

Appendix A: Programkod 

/*********************************************************************** 

** 

test.c 

------ 

Detta ar huvudprogrammet som ar skrivet i ANSI C. Exekveringen av 

hela 

programpaketet borjar i pmain.68k (lage __main). 

exp4() anropas fran assemblyprogrammet exp4.68k vid avbrott. 

_avben() anropar avben.68k vilket tillater avbrott fran PI/T. 

************************************************************************ 

****/ 

#include "variables.h" 

#include "display.c" 

#include "rtc.c" 

#include "int5.c" 

unsigned short int dispVal; 

unsigned short int *whichData,*alarm; 

main() 

{ 

rtc = (unsigned short int *) 0x000a0000; /*Timer Control register*/ 

keyb = (unsigned short int *) 0x00080000; /*Keyboard Control register*/ 

disp = (unsigned short int *) 0x000e0000; /*Display base register*/ 

ad1 = (unsigned short int *) 0x00020000; /*AD Converter 1 register*/ 

ad2 = (unsigned short int *) 0x00040000; /*AD Converter 2 register*/ 

init(); /* kör init() sätter upp 

allting */ 

_avben(); /* tillåt avbrott */ 

} 

dispWelcome(); /*skriv ut "welcome"*/ 

setDispCursor(0,1); 

dispPressKey(); 

while(1) { 

} 

void init(void) 

{ 

tid=50; /* tidskonstant */ 

status=2; /* Startläge */ 

subStatus=0; 

nbrRep=0; 

Sida 13 av 43

} 

savedDataCtr=0; 

alarm1Low=-50; 

alarm2Low=-50; 

alarm1High=50; 


Max_ad1=0; 

Max_ad2=0; 

Min_ad1=1000; 

Min_ad2=1000; 

mean_array_pek = 0; 

data_array_pek = 0; 

mean_all_Ctr = 0; 

/*Stoppa RTC */ 

*(rtc + 0x11)=0x00; 

wait(tid); 

*(rtc + 0x10)=0x00; 

wait(tid); 

/*Initsiera Display */ 

*disp=0x30; 

wait(tid); 

*disp=0x30; 

wait(tid); 

*disp=0x30; 

wait(tid); 

*disp=0x01; 

wait(tid); 

*disp=0x3c; 

wait(tid); 

*disp=0x0f; 

wait(tid); 

*disp=0x06; 

void mainProg(void){ 

if (status==1) /* power on, sätt klocka, etc */ 

{ 

setClock(); 

} 

else if (status==2) /* klockan är ställd, visa nu temperatur*/ 

{ 

dispTemp(); 

} 

else if (status==3) /* ställ in larmgränser */ 

{ 

setAlarm(); 

} 

else if (status==4) /* visa sparade mätdata */ 

{ 

showSavedData(); 

Sida 14 av 43

} 

else if (status==5) 

{ 

dispMinMax(); 

} 

else if (status==6) 

{ 

dispTrigAlarm(adAlarm); 

} 

return; 

} 

void wait(int time) { 

int i,j; 

for(i = 0; i < time; i++) { 

for(j = 0; j < 100; j++) ; 

} 

} 

void exp2(void) /* avbrottsprogram Keyb*/ 

{ 

wait(tid); 

key = *keyb; 

mainProg(); 

return; 

} 

void exp5(void) /* avbrottsprogram RTC*/ 

{ 

kvittera = *(rtc + 0x10); /*Kvittera avbrottet*/ 

/*Följande kod måste ta mindre än 1 sek att utföra, ty annars 

kommer nytt avbrott mitt i. */ 

dispMinMax_Cnt=(dispMinMax_Cnt+1)%10; /*Används för att växla 

mellan ad1 & ad2 i dispMinMax */ 

UpdClock(); /*Uppdatera klockvariablerna*/ 

UpdTemp(); /*Uppdatera aktuella temperaturen */ 

UpdMean(); /*Uppdatera medelvärdet */ 

UpdMinMax(); /*Uppdatera Min och Max */ 

} 

if(status==2 && subStatus==1){ 

intDispTemp(); 

alarmChk(); 

} 

else if (status==5 && subStatus>=1){ 

} 

return; 

void setClock(void){ 

if(dispMinMax_Cnt < 6){ 

intDispMinMax(Min_ad1,Max_ad1,1); 

} 

else{ 

intDispMinMax(Min_ad2,Max_ad2,2); 

} 

Sida 15 av 43

int tmp; 

switch(subStatus){ 

case 0: /* sätt år*/ 

dispVal=0x79; /*"y"*/ 

whichData = &year; 

break; 

case 1: /* sätt månad*/ 

dispVal=0x6d; /*"m"*/ 

whichData = &month; 

break; 

case 2: /* sätt dag*/ 

dispVal=0x64; /*"d"*/ 

whichData = &day; 

break; 

case 3: /* sätt timme*/ 

dispVal=0x68; /*"h"*/ 

whichData = &hour; 

break; 

case 4: /* sätt minut*/ 

dispVal=0x6d; /*"m"*/ 

whichData = &minute; 

break; 

case 5: /* sätt sekund*/ 

dispVal=0x73; /*"s"*/ 

whichData = &second; 

break; 

default: 

break; 

} 

switch(nbrRep){ /* vid vilken repetition kommer vi 

in i subrutinen */ 

case 0: 

clearDisp(); 

dispEnter(); 

writeToDisp(0x20); /* blankspace */ 

writeToDisp(0x28); /* (*/ 

writeToDisp(dispVal); /* bokstav beroende på 

vad vi skall ställa, även första inmatningfältet*/ 

writeToDisp(dispVal); /*bokstav beroende på 

vad vi skall ställa*/ 

writeToDisp(0x29); /*)*/ 

setDispCursor(7,0); /* flytta markör till 

platsen för första inmatningfältet på displayen*/ 

case 1: 

nbrRep+=1; 

break; 

dispKey(key); 

*whichData=10*getKey(); /*10tal gånger värdet (0-f)h 

som returneras av getKey() */ 

nbrRep+=1; 

Sida 16 av 43

variabeln*/ 

break; 

case 2: 

dispKey(key); 

*whichData+=getKey(); /* entals året adderas till 


dispYN(); /*skriv ut y/n*/ 

nbrRep+=1; 

break; 

case 3: 

if(key==0xFA) { /*key = "Y" */ 

nbrRep=0; 

if(subStatus==0){ 

RtcYEAR_RAM(*whichData); 

subStatus+=1; 

setClock(); 

break; 

} 

else if (subStatus==1) 

{ 

RtcMONTH_RAM(*whichData); 

subStatus+=1; 

setClock(); 

break; 

} 


{ 

RtcDATE_RAM(*whichData); 

subStatus+=1; 

setClock(); 

break; 

} 


{ 

RtcHOUR_RAM(*whichData); 

subStatus+=1; 

setClock(); 

break; 

} 


{ 

RtcMINUTE_RAM(*whichData); 

subStatus+=1; 

setClock(); 

break; 

} 


{ 

subStatus=0; 

RtcSECOND_RAM(*whichData); 

/*Starta RTC*/ 

tmp= *rtc; 

Sida 17 av 43

klockan! */ 

igen*/ 

} 

} 

} 

else{ 

} 

*(rtc + 0x11)=0x1c; 

wait(tid); 

*(rtc + 0x10)=0x08; 

wait(tid); 

status=2; 

dispTemp(); 

break; 

/* kör även rutinen som skirver till 

subStatus+=1; 

setClock(); 

break; 

} 

else if (key==0xFB) /*key = "n"*/ 

{ 

nbrRep=0; /*nästa gång skall vi göra om allt 

} 

else 

break; 

void setAlarm(void){ /*status == 3*/ 

int tempChar; 

int adChar; 

switch(nbrRep){ 

nbrRep=0; /* något är fel, vi gör om */ 

break; 

case 0: 

alarm = &alarm1Low; 

adChar=0x61; 

tempChar=0x6C; 

break; 

case 1: 

alarm= &alarm1High; 

adChar=0x61; 

tempChar=0x68; 

break; 

case 3: 

alarm = &alarm2Low; 

adChar=0x62; 

tempChar=0x6C; 

break; 

case 4: 

alarm = &alarm2High; 

Sida 18 av 43

} 


case 0: 

adChar=0x62; 

tempChar=0x68; 

break; 

clearDisp(); 

dispEnter(); 


writeToDisp(adChar); 


writeToDisp(0x28); /* (*/ 

writeToDisp(tempChar); /* "n" */ 

writeToDisp(tempChar); /* "n" */ 

writeToDisp(0x29); /*)*/ 

setDispCursor(9,0); /* flytta markör till 

platsen för första inmatningfältet på displayen*/ 

subStatus+=1; 

break; 

case 1: 

dispKey(key); 

*alarm=10*getKey(); /*10tal gånger värdet (0-f)h 

som returneras av getKey() */ 

subStatus+=1; 

break; 

case 2: 

dispKey(key); 

*alarm+=getKey(); /* entals värder adderas till 

variabeln*/ 


dispYNMinus(); /*skriv ut y/n*/ 

subStatus+=1; 

break; 

case 3: 

if(key==0xFA) { /*key = "Y" */ 

subStatus=0; 

if(nbrRep

igen*/ 

larmgräns!) */ 

} 

} 

} 

else if (key==0xFB) /*key = "n"*/ 

{ 

subStatus=0; 

nbrRep=0; /*nästa gång skall vi göra om allt 

setAlarm(); 

break; 

} 

else if (key==0xFD){ /*key = "

writeToDisp(0x20); /* blank*/ 

writeToDisp(0x64); /* d*/ 

writeToDisp(0x6f); /* o" */ 

writeToDisp(0x77); /* w */ 

writeToDisp(0x6e); /* n */ 

subStatus+=1; 

break; 

case 1: 

if(key==0xFD) /* key = "" = move 

right dispMinMax */ 

{ 

subStatus=0; 

nbrRep=0; 

status=5; 

dispMinMax(); 

break; 

} 

else if (key==0xFE) /* pil upp*/ 

{ 

dispSavedData(savedDataCtr%60); 

savedDataCtr+=1; 

break; 

} 

else if (key==0xFF) /*pil ned*/ 

{ 

dispSavedData(savedDataCtr%60); 

savedDataCtr-=1; 

break; 

} 

else { 

break; 

} 

} 

} /*end switch*/ 

void forceClock(void){ 

int tmp; 

year=04; 

month=11; 

day=28; 

hour=14; 

minute=49; 

second=00; 

Sida 21 av 43

} 

RtcYEAR_RAM(year); 

RtcMONTH_RAM(month); 

RtcDATE_RAM(day); 

RtcHOUR_RAM(hour); 

RtcMINUTE_RAM(minute); 

RtcSECOND_RAM(second); 

/*Starta RTC*/ 

tmp= *rtc; 

*(rtc + 0x11)=0x1c; 

wait(tid); 

*(rtc + 0x10)=0x08; 

wait(tid); 

return; 

int getKey(void){ 

if (key==0xF1) /* key = 1x1 */ 

return 0x00; 

else if (key==0xF0) /* key = 1x2 */ 

return 0x01; 


return 0x02; 


return 0x03; 


return 0x04; 


return 0x05; 


return 0x06; 


return 0x07; 


return 0x08; 


return 0x09; 

else if (key==0xFA) /* key = 3x3 */ 

return 0x0a; 

else if (key==0xFB) /* key = 3x4 */ 

return 0x0b; 

else if (key==0xFD) /* key = 4x1 */ 

return 0x0c; 

else if (key==0xFC) /* key = 4x2 */ 

return 0x0d; 

else if (key==0xFE) /* key = 4x3 */ 

return 0x0e; 

else if (key==0xFF) /* key = 4x4 */ 

return 0x0f; 

else return 0xff; 

} 

/*********************************************************************** 

** 

display.c 

Sida 22 av 43

------ 

kod som skriver ut en massa saker på displayen, typiskt en massa 

konstanta 

värden. 

************************************************************************ 

****/ 


void writeToDisp(int writeChar){ 

int time=1; 

wait(time); 

*(disp + 0x04)=writeChar; 

return; 

} 

void dispTrigAlarm(int whichAlarm){ 

int whichAD; 

int whichTemp; 

switch (whichAlarm) 

{ 

case 0: 

whichAD=0x61; /*a*/ 

whichTemp=temp_ad1; 

break; 

case 1: 

whichAD=0x61; /*a*/ 


break; 

case 2: 

whichAD=0x62; /*b*/ 


break; 

case 3: 

whichAD=0x62; /*b*/ 


break; 

} 


case 0: 

clearDisp(); 


writeToDisp(0x54); /* "T" */ 

writeToDisp(0x65); /* "e" */ 

writeToDisp(0x6d); /* "m" */ 

writeToDisp(0x70); /* "p" */ 

writeToDisp(0x20); /* "blank" */ 

writeToDisp(whichAD); /* "vilken AD" */ 


printTemp(whichTemp); 


Sida 23 av 43

dispReset(); 

writeToDisp(0x20); /*blank*/ 

dispYN(); 

subStatus+=1; 

break; 

case 1: 

if(key==0xFA) { /*key = "Y" */ 

alarm1Low=0; 

alarm2Low=0; 



subStatus=0; 

nbrRep=0; 

status=2; 

dispTemp(); 

break; 

} 

else if (key==0xFB) { /*key = "n"*/ 

} 

else{ 

break; 

} 

subStatus=0; 

nbrRep=0; 

status=2; 

dispTemp(); 

break; 

} 

} 

void dispSavedData(int time){ 

clearDisp(); 

dispArrows(); 

nbrRep=0; /* något är fel, vi gör om */ 


writeVal(savedDataCtr%60); /*vilken saved data position*/ 

writeToDisp(0x61); /* "a " */ 

writeToDisp(0x3A); /* ":" */ 

printTemp(ad1_data[time].temperatur); 

writeToDisp(0x20); /*blanksteg*/ 

/*writeToDisp(ad2_data[time].temperatur); */ 

printTemp(ad1_data[time].dag); 


printTemp(ad1_data[time].timme); 


printTemp(ad1_data[time].minut); 


Sida 24 av 43

eturn; 

} 

writeVal(savedDataCtr%60); /*vilken saved data position*/ 

writeToDisp(0x62); /* "b " */ 


printTemp(ad2_data[time].temperatur); 


/*writeToDisp(ad2_data[time].temperatur);*/ 

printTemp(ad2_data[time].dag); 


printTemp(ad2_data[time].timme); 


printTemp(ad2_data[time].minut); 

void setDispCursor(int x,int y){ 

} 

int t2=2; 

int t=1; 

int i=0; 

int j=0; 

*disp=0x0c; /* set cursor display off*/ 

wait(t2); 

*disp=0x02; /*return cursor to home */ 

wait(t2); 

switch(y){ 

case 0: 

for(i=0;i

} 

printTemp(temp_ad2); /* Temp för AD2*/ 

if (mean_all_Ctr != 0) 

{ 


printTemp(dygnsmedel_ad1); /*Dygnsmedel AD1*/ 


printTemp(dygnsmedel_ad2); /*Dygnsmedel AD2*/ 

} 

return; 

void intDispMinMax(int min,int max,int ad){ 

if(ad==1) 

{ 

} 

if(ad==2) 

{ 

} 

} 

void dispTemp(void){ 


case 0: 






printTemp(max); /* MAX för AD1*/ 


printTemp(min); /* MIN för AD1*/ 






printTemp(max); /* MAX för AD1*/ 


printTemp(min); /* MIN för AD1*/ 

clearDisp(); 




writeToDisp(0x20); /* skriv blanksteg*/ 



writeToDisp(0xDF); /* " grader tecknet" */ 

writeToDisp(0x43); /* " C" */ 

Sida 26 av 43













dispArrows(); 

subStatus+=1; 

break; 

case 1: 


} 

} 





break; 

} 

void dispArrows(void){ 


Sida 27 av 43

writeToDisp(0x7f); /* skriv vänster pil i vänster 

hörn*/ 


writeToDisp(0x7e); /* skriv häger pil i höger hörn*/ 

} 

void clearDisp(void){ 

wait(tid); 

*disp=0x01; 

wait(tid); 

return; 

} 

void dispKey(int key){ 

if (key==0xF1) /* key = 1x1 */ 

writeToDisp(0x30); 



















else if (key==0xFA) /* key = 3x3 */ 


else if (key==0xFB) /* key = 3x4 */ 


else if (key==0xFD) /* key = 4x1 */ 


else if (key==0xFC) /* key = 4x2 */ 


else if (key==0xFE) /* key = 4x3 */ 


else if (key==0xFF) /* key = 4x4 */ 


return; 

} 

void dispWelcome(void){ 

wait(tid); 

writeToDisp(0x57); /* "W" */ 

wait(tid); 


Sida 28 av 43

} 

wait(tid); 

writeToDisp(0x6c); /* "l" */ 

wait(tid); 

writeToDisp(0x63); /* "c" */ 

wait(tid); 

writeToDisp(0x6f); /* "o" */ 

wait(tid); 

writeToDisp(0x6d); /* "m" */ 

wait(tid); 


wait(tid); 

return; 

void dispPressKey(void){ 

wait(tid); 

writeToDisp(0x50); /* "P" */ 

wait(tid); 

writeToDisp(0x72); /* "r" */ 

wait(tid); 


wait(tid); 

writeToDisp(0x73); /* "s" */ 

wait(tid); 

writeToDisp(0x73); /* "s" */ 

wait(tid); 


wait(tid); 

writeToDisp(0x61); /* "a" */ 

wait(tid); 


wait(tid); 

writeToDisp(0x6b); /* "k" */ 

wait(tid); 


wait(tid); 

writeToDisp(0x79); /* "y" */ 

wait(tid); 

return; 

} 

void dispEnter(void){ 

writeToDisp(0x45); /* "E" */ 

writeToDisp(0x6e); /* "n" */ 

writeToDisp(0x74); /* "t" */ 


writeToDisp(0x72); /* "r" */ 

} 

void dispYN(void){ 

writeToDisp(0x28); /* "(" */ 


writeToDisp(0x2F); /* " /" */ 


writeToDisp(0x29); /* ")" */ 

Sida 29 av 43

} 

void dispYNMinus(void){ 

writeToDisp(0x28); /* "(" */ 





writeToDisp(0x7F); /* "

Max_ad1 = temp_ad1; 

} 

/*Kolla Max_ad2*/ 

if(temp_ad2 >= Max_ad2) 

{ 

Max_ad2 = temp_ad2; 

} 

/*Kolla Min_ad1*/ 

if(temp_ad1

*Skriv ut texten Min/Max för AD2*/ 

clearDisp(); 










} 

break; 








dispArrows(); 

subStatus=2; 

case 1: 


{ 

subStatus=0; 

nbrRep=0; 

status=3; 

setAlarm(); 

break; 

} 

else{ 


printTemp(Max_ad1); /* MAX för AD1*/ 


printTemp(Min_ad1); /* MIN för AD1*/ 

subStatus=0; 

break; 

Sida 32 av 43

} 

case 2: 


right setAlarm */ 

{ 

subStatus=0; 

nbrRep=0; 

status=3; 

setAlarm(); 

break; 

} 

else{ 

} 

} 


printTemp(Max_ad2); /* MAX för AD2*/ 


printTemp(Min_ad2); /* MIN för AD2*/ 

subStatus=0; 

break; 

} 

Sida 33 av 43

********************************************************************* 

rtc.c 

------ 

Programmering av RTC. 

**********************************************************************/ 


/*SKRIVER NUMERA TILL COUNT REGISTRENA*/ 

/*Skriv till År*/ 

void RtcYEAR_RAM(int YEAR) 

{ 

*(rtc + 0x06)=YEAR; 

wait(tid); 

} 

/*Skriv till Månad*/ 

void RtcMONTH_RAM(int MONTH) 

{ 

*(rtc + 0x04)=MONTH; 

wait(tid); 

} 

/*Skriv till Datum*/ 

void RtcDATE_RAM(int DATE) 

{ 

*(rtc + 0x05)=DATE; 

wait(tid); 

} 

/*Skriv till Timmar*/ 

void RtcHOUR_RAM(int HOUR) 

{ 

*(rtc + 0x01)=HOUR; 

wait(tid); 

} 

/*Skriv till Minuter*/ 

void RtcMINUTE_RAM(int MINUTE) 

{ 

*(rtc + 0x02)=MINUTE; 

wait(tid); 

} 

/*Skriv till Sekunder*/ 

void RtcSECOND_RAM(int SECOND) 

{ 

*(rtc + 0x03)=SECOND; 

wait(tid); 

} 

Sida 34 av 43

********************************************************************* 

int5.c 

------ 

Vad som skall göras vid ett interupt från klockan. 

*********************************************************************/ 

/* 

VAD SOM SKALL GÖRAS: 

- Updatera klockan... 

UpdClock(); 

- Mäta båda tempgivarna, lagra deras värde i varsin array: 

int mean_arr1[60] 

int mean_arr2[60] 

Om arrayen är full, ta medelvärdet av allihoppa och spara undan 

det med tidsangivelse. 

- Kolla om temperaturen ligger under/över larmgränserna... i så 

fall, VARNA! 

*/ 


void UpdClock() 

{ 

/* 

Läs först 1/100 sekund registret: temp=*(rtc) 

Detta för att latcha ut aktuell tid i counter-registrena. 

*/ 

kvittera=*(rtc); 

wait(tid); 

/* 

Uppdatera klockvariablerna... (year,month,day,hour,minute,second) 

*/ 

year = *(rtc + 0x06); 

wait(tid); 

month = *(rtc + 0x04); 

wait(tid); 

day = *(rtc + 0x05); 

wait(tid); 

hour = *(rtc + 0x01); 

wait(tid); 

minute = *(rtc + 0x02); 

wait(tid); 

second = *(rtc + 0x03); 

wait(tid); 

} /*UpdClock End*/ 

void UpdTemp() 

{ 

temp_ad1=(*(ad1)-132); 

Sida 35 av 43

temp_ad2=(*(ad2)-133); 

}/*UpdTemp End*/ 

void UpdMean() 

{ 

mean_arr1[mean_array_pek]=temp_ad1; 

mean_arr2[mean_array_pek]=temp_ad2; 

if (mean_array_pek==59) /* Har det gått en minut? */ 

{ 

/*Roppar på MeanCount för att räkna ut medlet.*/ 

mean_ad1=MeanCount(mean_arr1); 

mean_ad2=MeanCount(mean_arr2); 

/*Spara undan minutmedlet i en array */ 

mean_all_arr_ad1[mean_all_Ctr]=mean_ad1; 

mean_all_arr_ad2[mean_all_Ctr]=mean_ad2; 

/*Ta medel på alla minutmedel*/ 

dygnsmedel_ad1 = mean_all_arr_ad1[mean_all_Ctr]; /*Test*/ 

dygnsmedel_ad2 = mean_all_arr_ad2[mean_all_Ctr]; 

/*Spara undan mean_ad1 med tidsangivelse... */ 

ad1_data[data_array_pek].temperatur = mean_ad1; 

/*Måste fixa till temperaturen på något sätt... hexadecimalt nu.*/ 

ad1_data[data_array_pek].dag = day; 

ad1_data[data_array_pek].timme = hour; 

ad1_data[data_array_pek].minut = minute; 

/*Spara undan mean_ad1 med tidsangivelse... */ 

ad2_data[data_array_pek].temperatur = mean_ad2; 

/*Måste fixa till temperaturen på något sätt... hexadecimalt nu.*/ 

ad2_data[data_array_pek].dag = day; 

ad2_data[data_array_pek].timme = hour; 

ad2_data[data_array_pek].minut = minute; 

mean_all_Ctr = (mean_all_Ctr+1)%1439; /*Räknaren för totala 

dygnsmedlet, håller reda på minutplatsen.*/ 

data_array_pek = (data_array_pek+1)%60; /*Uppdaterar arrayen för 

nästa värde, (modulus 60, hänger samman med antalet minuter...).*/ 

} 

mean_array_pek = (mean_array_pek+1)%60; /*Uppdaterar arrayen för nästa 

värde, (modulus 60).*/ 

}/*UpdMean End*/ 

void alarmChk(void) 

{ 

if(temp_ad1

} 

else if(temp_ad1>=alarm1High) 

{ 

status=6; 

subStatus=0; 

nbrRep=0; 

adAlarm=1; 


/* 

clearDisp(); 


} 

else if(temp_ad2=alarm2High) 

{ 

} 

else{ 

} 

status=6; 

subStatus=0; 

nbrRep=0; 

adAlarm=3; 


/* 

clearDisp(); 

writeToDisp(0x70); /* "p" */ 

return; 

} 

/*AlarmChk End*/ 

/*Räkna ut medel och returnera en int... */ 

int MeanCount(int array[]) 

{ 

int i = 0; 

int fisk=0; 

int hund=0; 

while(i < sizeof(mean_array_pek)) 

Sida 37 av 43

{ 

fisk=fisk+array[i]; 

i++; 

} 

if(mean_array_pek > 0) 

{ 

hund=fisk/sizeof(mean_array_pek); 

return hund; 

} 

else 

{ 

return 0; 

} 

} /*MeanCount End*/ 

Sida 38 av 43

********************************************************************* 

variables.h 

----------- 

**********************************************************************/ 

unsigned short int *rtc; 

unsigned short int *keyb; 

unsigned short int *disp; 

unsigned short int *ad1; 

unsigned short int *ad2; 

unsigned short int kvittera, key,tid, status,subStatus, nbrRep; 

unsigned short int year,month,day,hour,minute,second; 

signed short int alarm1Low,alarm1High,alarm2Low,alarm2High,adAlarm; 

unsigned short int savedDataCtr,mean_all_Ctr; 

int mean_all_arr_ad1[1439]; /*Medel för ett dygn */ 

int mean_all_arr_ad2[1439]; /*Medel för ett dygn */ 

int dygnsmedel_ad1; 

int dygnsmedel_ad2; 

/*int BuzyFlag=0; */ 

int Max_ad1, Max_ad2, Min_ad1, Min_ad2; 

int dispMinMax_Cnt; 

int temp_ad1,temp_ad2; /*Aktuell temp för ad1 & ad2*/ 

int mean_arr1[59]; /*Array med temp under den 

senaste min för ad1*/ 

int mean_arr2[59]; /*Array med temp under den 

senaste min för ad1*/ 

int mean_ad1,mean_ad2; /*Aktuell medeltemp för ad1 & ad2*/ 

int mean_array_pek; /*Håller reda på aktuell 

position i de två medeltemp arrayerna */ 

unsigned int data_array_pek; /*Håller reda på aktuell position i de två 

data arrayerna */ 

/*Array struktor för datalagringen (60 minuters lagring.)*/ 

typedef struct datab AD1; 

typedef struct datab AD2; 

struct datab 

{ 

int temperatur; 

int dag; 

int timme; 

int minut; 

}; 

AD1 ad1_data[59]; 

AD2 ad2_data[59]; 

Sida 39 av 43

Appendix B: PAL 

Title templog 

Patten INT 

Revison 0.1 

Author J o M 

Company LTH it 

Date 16-11-04 

device 22V10 

IRQKEYB 2 

IRQRTC 3 

FC2 4 

FC0 5 

FC1 6 

IPL1 14 

IPL02 15 

VPA 16 

start 

IPL1 /=IRQKEYB * IRQRTC; 

IPL02 /=/IRQRTC; 

VPA /=FC0*FC1*FC2; 

end 

Sida 40 av 43

Title templog 

Patten Minne o IO 

Revison 0.1 

Author J o M 

Company LTH it 

Date 16-11-04 

device 22V10 

A14 1 

A15 2 

A16 3 

A17 4 

A18 5 

A19 6 

RW 8 

DS 9 

AS 10 

OEEPROM 14 

CSSRAM 15 

DTACK 16 

OEKEYB 17 

CSAD1 18 

CSAD2 19 

CSRTC 20 

OESRAM 21 

WESRAM 22 

EDISP 23 

start 

OEEPROM /=/A14*/A15*/A16*/A17*/A18*/A19*/AS; 

CSSRAM /=A15*/A16*/A17*/A18*/A19*/AS; 

DTACK /=/OEEPROM+/CSSRAM+/OEKEYB+/CSAD1+/CSAD2+/CSRTC+ EDISP; 

OEKEYB /= A19*/A18*/A17*/AS; 

CSAD1 /=/A19*/A18*A17* RW */DS; 

CSAD2 /=/A19*A18*/A17* RW */DS; 

CSRTC /=A19*/A18*A17*/AS; 

OESRAM /=/DS*RW; 

WESRAM /=/DS*/RW; 

EDISP =A19*A18*A17*/A16*/DS; 

end 

Sida 41 av 43

Appendix C: Hårdvara - En sammanfattning av 

kopplingsschemat 

Processor: Motorola 68008 

Denna processor är släkt med Motorolas 68000, fast med en lite mer begränsad databuss 

på 8-bitar samt färre avbrottsnivåer än storebror, nämligen endast två stycken. På den 

högst prioriterade vill vi ha vår RTC och på den lägre knappsatsen. 

Processorn kan allokera upp till 1 MByte RAM och använder således en 14-bitars 

adressbuss. Vi har en harmonisk kristalloscillator på 10MHz som matar processorn med 

klockpulser. 68008 har en maximal hastighet på 10MHz. 

SRAM: 43256 

Som internminne använder vi oss utav ett 32 Kbyte stort SRAM. 

EPROM: 27C256 

Vi använder oss av ett 32 KByte stort EPROM, där vi lagrar programvaran för systemet i 

form av kompilerad C-kod. 

PAL: PAL22V10 

För att få ihop de olika delarna i systemet behövs en del logik. Detta kan man få till på 

två sätt; antingen med standardkomponenter ur 74-serien, eller vara steget före och 

använda sig av programmerbar logik, sk PAL. Vi har två stycken PAL22V10 där den ena 

främst tar hand om Chip Enable samt LCD-logiken. Den andra har hand om 

avbrottsgenereringen till processorn. 

Knappsats: 16 knappars telefontangentbord 

Standardtangentbord med anslutningar för rader och kolumner. 

Knappsatsavkodare: 74C922 

En smart liten krets som sköter vår knappsats genom att avkoda, avstuddsa, ge avbrott, 

samt lägga data på databussen. Till dess hjälp har den en 74HC74 (D-vippa med Set och 

Reset), som hjälper till vid avbrottsgenereringen. Dess uppgift är att hålla kvar avbrottet 

till dess att vi kvitterar det via reset. 

Temperaturgivare: LM335 

Vi använder oss av två stycken linjära LM335 temperatursensorer. De ska enligt 

databladen ge ut 10 mV/K. 

A/D-omvandlare: ADC0804 

ADC0804 är en trevlig 8-bitars A/D som vi kör i sk. ”Free Running Mode.” 

I vårt system finns det två stycken, en till va rje sensor. Chip Select har vi kopplat direkt 

till jord vilket kan uppfattas märkligt, men istället styr vi den via Read (RD). Avbrottet är 

direkt återkopplat till Write (WR), detta för att få den i FRM. 

Sida 42 av 43

Spänningsreferenser: LM336 

Två stycken LM336 förser de två ADC0804 med +2,5V referens för att minska området 

för ADC och därmed öka dess noggrannhet. De kopplas in på VREF på ADC0804. 

Realtidsklocka: ICM7170 

En realtidsklocka som efter inställning av år, datum och tid, sköter sig helt autonomt. Den 

kan förses med en batteribackup, vilket uteslöts i detta projekt. 

I systemet vill vi att den genererar ett avbrott varje sekund. Den klockas med en extern 

oscillator på 37kHz. Oscillatorn är trimbar för att uppnå en hög noggrannhet. 

LCD display: 

Vi har valt en hederlig alfanumerisk LCD med 16 tecken á två rader. Genom att koppla 

RS (Register Select) till adressbit 2 delar vi upp registrena (data och kommando) på två 

minnesplatser. Dvs. genom att ge displayen data på adress e0000 skickas data till 

kommandoregistret och via adress e0004 till dataregistret. En trimpotentiometer förser 

V0 med en spänning (0-5V) och via den ändrar man kontrasten. 

Sida 43 av 43

Ladda ner rapporten... - EIT - Lunds Tekniska Högskola

Create successful ePaper yourself

Delete template?

Save as template?