Lab 10

Namn:
Laborationen godkänd:
Laboration 10
Digitala system 10 p
LTH Ingenjörshögskolan vid Campus Helsingborg
Datorteknik, laboration 3.
Avbrottshantering, klocka.
Schemat från föregående laboration
är nu kompletterat med två anslutningar
till displayen.
LE (Latch Enable)
Om LE dvs bit 7 i PORTC sätts = 0,
så är D1 och D2 öppna för data från
PORTB.
BL (Blanking)
Om BL (Blanking) dvs bit 3 i PORTA
sätts = 1, så släcks displayen.
I nästan alla konstruktioner med enchipsdatorer låter man vissa programavsnitt köras
med regelbundet återkommande intervall. Ibland behöver man göra regelbundna
avläsningar av givare eller ha en exakt tidbas för en klocka. I denna laboration
ska vi se hur man använder ett periodiskt avbrott. Vi ska använda alla fyra siffrorna i
displayen för att göra en klocka med hjälp av det interna avbrottet OC2.
Förberedelser:
Läs i kompendiet kap 4 (Avbrottshantering) och 5.4 (Output Compare).
Använd också databoken kap 5.4 och 9.3.
Till laborationen måste du bl.a. känna till följande begrepp:
Avbrottsvektor, avbrottsrutin, lokal avbrottsmask, kvittering av avbrott.
Stefan Nyman 2006-02-03

Förbered laborationsuppgifterna 2, 4 och 5.
Med hjälp av tipsen du får på föreläsningarna, kan göra det mesta före laborationen.
Hemuppgift:
Skriv en funktion countSeconds som utför följande:
1. Öka variabeln seconds med ett.
2. Justera värdet så att det ser decimalt ut.
3. Nollställ det om det skulle bli = 60.
4. Returnera värdet som ändrats så man lätt kan testa om det blivit = 0.
Här är skalet till funktionen countSeconds.
char countSeconds()
{
; // Öka variabeln seconds
; // Decimaljustering
; // Nollställ om det blivit 60 60
return seconds;
}
Laborationsuppgifter:
Laborationens mål är att få displayen att visa timmar och minuter
eller minuter och sekunder.
Klockan ska styras med timeravbrottet OC2, som ska ge avbrott var 10:e ms utan att
påverka någon utgång.
Den ska kunna ställas genom att man trycker på knapparna:
• Klockan går normalt om ingen knapp trycks ner
• Klockans timmar bläddras upp med hjälp av en knapp.
• Klockans minuter bläddras upp med en annan knapp.
2
Digitala system , Lab10 2006-02-03

Uppgift 1.
Skapa ett nytt projekt Klocka.prj. Utgå från inställningarna i Lab3.prj så slipper du
göra om dom.
Projektet ska innehålla:
‣ cstartup.s07
‣ Clock.c
Uppgift 2.
Denna fil skriver du i denna laboration. Enklast tar du den
föregående laborationens Logik.c och kopierar och döper om
den. Spara funktionerna initL1 och main. De andra funktionerna
kan du ta bort!
Funktioner för att initiera och sköta avbrott med periodiskt intervall. Avbrottet
OC2 ska startas och styras så att det kommer exakt var 10:e ms.
Funktionen initOC2 ska innehålla de programrader som initierar OC2 så att det
genereras avbrott utan att påverka någon utgång.
Fyll först i hur dessa två register ska programmeras:
TCTL1
TMSK1
Skriv funktionen!
Avbrottsfunktionen OC2_interrupt skrivs nästan som en vanlig funktion.
Definitionen måste föregås av ordet ”interrupt” och funktionens namn måste vara
exakt det som återfinns i Vectors.h
Avbrottsflaggan måste kvitteras och tiden för nästa Output Compare laddas i
TOC2. Skriv en avbrottsfunktion som sköter dessa saker, dvs gör så att OC2 inträffar
exakt var 10:e ms.
TFLG1
TOC2 Decimalt: ..............
Observera att du inte kan skriva samma värde i OC2 varje gång, utan egentligen ska
skriva in den tidpunkt då nästa avbrott ska ske.
3
Digitala system , Lab10 2006-02-03

Här är skalet till dessa två funktioner:
// OC2 ska ge avbrott utan att påverka några utgångar.
void initOC2 (void)
{
;
}
// Avbrottsfunktion OC2 kommer var 10:e ms.
interrupt void OC2_interrupt(void)
{
; // Kvittera avbrottet
; // Återladda TOC2
}
Uppgift 3.
Genom att skriva ett minimalt huvudprogram, kan du testa att avbrottet fungerar.
Initiering
initL1
initOC2
Huvudprogram
OC2_interrupt
Här har du hela skalet till Clock.c.
// Clock.c
#include "IO-reg.h" // Definitioner av alla registeradresser.
#include "Vectors.h" // Ser till att avbrottsvektorer initieras.
#include "intr6811.h" // Deklarationer av specialare, t.ex.
// enable_interrupt().
// Funktionerna: initL1, initOC2 och OC2_interrupt skriver du här.
main(void)
{
initL1();
initOC2();
enable_interrupt();
while (1)
{
}
}
4
Digitala system , Lab10 2006-02-03

Det kan vara svårt att testa att avbrottet kommer med exakt 10 ms intervall, men
man kan ändå se att det kommer ofta. Lägg t.ex till raden
PORTB++;
i avbrottsfunktionen.
Uppgift 4.
I avbrottsfunktionen ska nu en klocka räkna upp displayen med sekunder och minuter.
Avbrottsfunktionen för OC2 körs ju nu automatiskt var 10:e ms. Skriv en
funktion, clock(), som gör följande:
clock
Öka räknare med 1
= 100
Ja
Nollställ
räknaren
countSeconds
Nej
= 0
Ja
countMinutes
Nej
= 0
Ja
countHours
Nej
newtime = 1
klart
Härovan har du clock i form av flödesplan.
Funktionen clock ska anropas från avbrottsrutinen som kommer var 10.e ms och
räkna upp variablerna counter, seconds, minutes och hours enligt flödesplanen ovan.
Dessutom ska en variabel newtime användas som flagga att klockan ändrat värde.
Variablerna ska fungera såhär:
• counter: En räknare som räknar 100 avbrott. När counter = 100 ska den nollställas
och sekunderna ska räknas upp.
5
Digitala system , Lab10 2006-02-03

• seconds: Räknas upp med ett och decimaljusteras varje gång. Om sekunderna
fått värdet 60 (efter decimaljustering) ska de nollställas och minuterna ska räknas
upp.
• minutes: Räknas upp och nollställs på samma sätt som sekunderna.
• newtime: Ettställs varje gång klockan ändrat värde.
clock använder funktionerna countSeconds, countMinutes och countHours som
var och en returnerar värdet 0 om resp. räknevärde blivit = 0.
Försök att själv komma på hur decimaljustering ska kunna göras.
Testa programmet!
Hitta själv på hur du ska sätta brytpunkter för att konstatera att programmet går
rätt. Passa också på att titta på variablerna seconds och minutes t.ex.
Uppgift 5.
Vi ska komplettera med en funktion display som ska skriva ut innehållet i en 16-
bitarsvariabel till displayen.
// display
// Skriver ut värdet av en 16-bitarsvariabel på displayen.
void display(int siffror) // Funktionens lokala variabel: siffror
{
; // Nollställ stroben
; // Skriv höga halvan av Siffror till PORTB
; // Ettställ stroben
; // Skriv låga halvan av Siffror till PORTB
}
Funktionen anropas med ett 16-bitarsvärde som parameter.
T.ex. om A och B är två 8-bitarsvariabler så gör anropet
display (A*256 + B);
att värdet av A syns till vänster och B till höger.
6
Digitala system , Lab10 2006-02-03

Uppgift 6.
main
Initieringar
newtime
=0
Ja
Nej
Skriv ut
tiden
newtime = 0
Komplettera nu huvudprogrammet så att det skriver ut minuter och sekunder varje
gång newtime inte är = 0.
Vad händer om man inte testar newtime utan skriver ut hela tiden
....................................................................
Varför......................................................................................................................
Observara att innan du anropar display ska minuter och sekunder kombineras ihop
till en 16-bitarsvariabel.
Efter utskriften nollställs newtime.
Tips: om man vill testa om newtime är skilt från 0, kan man helt enkelt skriva:
if (newtime)
{
;
}
Det ser ju rätt lättläst ut.
7
Digitala system , Lab10 2006-02-03

Uppgift 7.
Det är bra om klockan kan ställas. Komplettera funktionen clock så att timmar och
minuter kan stegas upp.
Varje sekund testas knapparna:
• Om ingen är nere: normal gång.
• Om en av knapparna är nere (välj själv): Räkna upp timmarna.
• Om en annan är nere: Räkna upp minuterna och nollställ sekunderna.
Om man håller nere en knapp kommer uppräkningen att ske med ett varje sekund.
Om man tycker det går för långsamt, så kan man också passa på att tvångsställa variabeln
counter till ett mindre värde än 100.
I nästa laboration kommer vi att bland annat se hur man på ett bättre sätt kan ställa
klockan. Man vill ju t.ex. bläddra upp tiden med knapparna i sin egen takt.
8
Digitala system , Lab10 2006-02-03