AVR Assembler handledning 10 (3 / 10 steg)

Steg 3: Testa displayen

Nu när vi har flyttat vår 4-siffrig display till dess egen styrelse måste vi testa den så att det fungerar (och fixar de oundvikliga problem). Detta innebär att vi vill skriva en enkel förare som kommer att bara visa vissa nummer och kontrollera alla segmenten på varje siffra. När vi är övertygade om att allt fungerar som det ska då vi kan arbeta på vår kommunikation kod.

Vi kommer att skriva provet koden är så att vi kan fortsätta att använda den senare genom att lägga till rutinerna som kommunikation. Så vi kopiera vår 4-siffriga-display kod från den sista läraren och ta bort alla saker som hade att göra med ADC eftersom vi inte kommer att använda det längre. Vi ändrade också anod stiften så att de använder PC0 genom PC3 eftersom det gör ledningar och kodning lättare.

Jag har bifogat koden och en bild av drift av yttre displayen.

Jag behöver inte gå igenom alla de koden rad för rad eftersom det är mest bara enkla ändringar av de saker vi redan har gjort. Det finns dock en sak jag bör notera.

Vi kommer så småningom att behöva visa tal från 0000 till 9999 på våra 4-siffrig display. Detta innebär att vi behöver utrymme för 10.000 nummer. Ett 8-bitars register går dock bara upp till 255. Så vi kommer för att behöva fler bitar ägnas åt numret vi vill visa. Låt oss göra en snabb kalkyl att räkna ut hur många bitar vi behöver. Varje siffra är en makt 2 och så vi vill se vilken kraft av två ger oss 10 000. För detta använder vi den "naturliga logaritmen":

2 ^ x = 10000
x ln(2) = 4 ln(10)
x = 4 ln(10)/ln(2) = 13.288

Detta säger mig att vi behöver mer än 13 bitar för att Visa 10000. Så om jag använder 14 bitar har jag mer än tillräckligt. Som en kontroll (eller bara göra det i första hand om du inte tycker matte är kul), bara att gå till "matte är kul" hemsida automatisk omvandlare här:

http://www.mathsisfun.com/binary-decimal-hexadecim...

och lista ut genom att helt enkelt konvertera. Hittar att 14 siffror kan Visa siffror på upp till 16383 och 13 siffror endast upp till 8191. Så är våra beräkningar korrekta, vi behöver mer än 13 siffror och mindre än 14. Så använder vi 14. I själva verket 9999 i binär är: 0b10011100001111 som är 14 bitar, men behöver inte alla av dem på.

Okej, så långt vi lösa dilemmat att behöva mer än 1 registrera är att använda 2 av dem. Detta ger oss 16 bitar och är därför mycket att visa alla nummer vi kasta på 4-siffrig display.

Men när vi skickar siffrorna över våra kommunikationsgränssnitt som de kommer att vara i binär. Hur vi omvandla ett binärt tal till decimaler ska visas? Detta är inte alls så lätt som man kan tro vid första anblicken. Låt oss lista ut.

Vi börjar med en siffra mellan 0 och 9999 och vi vill ha de 4 siffrorna i detta nummer så vi kan visa dem. Det finns ingen funktion i assembler som kommer att göra det för oss så vi måste göra en oss. Numret börjar som ett binärt tal 2-byte. Låt oss kalla det X för nu. Vi skulle vilja räkna ut varje siffra i sin tur från högsta till lägsta. Det sätt vi finner den högsta är som i denna kod disposition:

siffra = 0
start:
X > 1000?
Ja:
X = X - 1000
siffriga ++
gå till start:
Nej:
returnera siffra

Som ni ser, ser detta ganska enkelt. Vi tar bara bort 1000-tals en i taget och varje gång vi öka värdet av "siffra". När X är inte längre större än 1000 vi antalet 1000-tals lagras i "siffra" och vi returnera den. Detta ger oss den första siffran för vår visning. Då vi kan göra samma sak som ovan att det resterande värdet av X utom med 100-tals istället för 1000-tals och detta får oss hur många 100-tals, då vi gör det igen med 10: or, och slutligen när det finns ingen 10-talet kvar, återstående i X belopp kommer att vara mellan 0 och 9, och således blir det vår sista siffran. Så är det hur vi kan få våra 4 siffror.

Men! Det är inte alls så enkelt i assembler! En enorm skiftnyckel kastas in i denna plan på grund av att vi behöver två byte att representera våra 14 binära siffror. Hur vi subtrahera 1000? I 2-byte ord, 1000 representeras av 0b0000001111101000 och du ser att en del av det är i den första byten och en del av det är i den andra byten. Så i stället för X = X-1000 vi kunde skriva X som två byte XH och XL så att X = XH:XL och gör våra subtraktion enligt följande:

XH = XH - high(1000)
XL = XL - low(1000)

Det verkar enkelt nog rätt? Jo det blir ännu värre! Antag att vi började med X = 2001 och hittar vi vår första siffran (2) genom att dra ifrån 1000-tals. Låt oss se hur det skulle fungera:

Vi testar X och finner att det är > 1000 och så vi subtraherar, våra subtraktion sedan 2001 = 0b0000011111010001 i binärt skulle fungera enligt följande (sätta siffrorna):

XH = high(0b0000011111010001) - high(0b0000001111101000)
XL = low(0b0000011111010001) - low(0b0000001111101000)

som blir

XH = 0b00000111 - 0b00000011 = 7-3 = 4
XL = 0b11010001 - 0b11101000 = 209-232 = - 23

Vi har ett problem! Den låga byten innehåller inte tillräckligt för att hantera subtraktion! Du kanske tror att detta är inte ett problem eftersom assembler kan hantera negativ, men det kan bara hantera upp till nummer -128 och det blir definitivt gånger när resultatet av XL subtraktion är mer negativa än så. Så vad gör vi?

Tja, är det sätt vi hanterar detta på samma sätt som vi gör det i någon subtraktion från årskurs 5. Vi måste ta en av siffrorna från XH. Kom ihåg att varje binär siffra i XH är faktiskt lika med 256. Vi gör detta med kommandot "sbc" som subtraherar med bär.

Sedan, när vi har blivit av de 1000-tals vi gå vidare till de 100-tals och gör samma sak. I så fall har vi samma problem i att vi kommer att behöva låna 1 från den höga byten tills våra resultat är mindre än 256 så vi fortsätter att använda SBC: en till subract den höga byten.

Slutligen, när vi får de 10: or och 1: s ställen har vi inte längre oroa dig låna siffror längre och saker är enklare, vi kan bara dra av från låga register.

Så nu när du ser hur vi tvingas göra saker tar en titt på koden och nu bör du kunna räkna ut hur det fungerar. Märke att det finns vissa saker som vi behövde göra för att visa tal mellan 768 och 999. Kan du komma på varför det kan vara? I alla fall, börjar vi med bara ge det en rad ska visas så vi kan testa våra display. Vi kommer helt enkelt använda 9876. Senare skulle vi vilja nummer och kommer från en annan microcontroller via två-wire kommunikationsgränssnitt.

Övning 1: Räkna ut hur koden fragmentet nedan fungerar.

Här är explicit koden jag använder för att konvertera den binära två byten till decimal för display siffror:

loadCash:; Detta beräknar siffran för varje 7-seg av display < br > cli; Inaktivera avbrott medan lastning siffror < br > driva playercashH; lagra övre byte av playercash < br > push playercashL; butiken låg byte av playercash < br > ldi tempH,high(1000); Ange tempH:L till 1000 < br > ldi tempL,low(1000) < br > rcall computeDigit; hitta den 3: e siffran < br > mov digit3, siffran. lagra den nya 3: e siffran < br > ldi tempH, 0; Ange tempH:L till 100 < br > ldi tempL, 100 < br > rcall computeDigit; hitta den 2: a siffran < br > mov digit2, siffran. lagra den nya 2: a siffran < br > ldi tempH, 0; Ange tempH:L till 10 < br > ldi tempL, 10 < br > rcall computeDigit; hitta den 1: a siffran < br > mov digit1, siffran. Store nya 1: a siffran < br > mov digit0, playercashL; resterande är 0: e siffran < br > pop playercashL; återställa låg byte av playercash < br > pop playercashH; återställa övre byte av playercash < br > sei; Återaktivera Avbryter < br > ret

computeDigit:; avbryter är redan inaktiverad medan här < br > clr siffra
compareHigh:
CPI playercashH, 0; om båda playercashH
brne PC + 3
CPI playercashL, 0; och playercashL är noll då gjort
breq returnDigit
CP playercashH, tempH; annars Fortsätt
brlo returnDigit; om mindre sedan flyttar till nästa power 10
brne PC + 3. om hög är större då subtrahera
CP playercashL, tempL; om toppar är lika och dalar är mindre,
brlo returnDigit; då är playercash mindre så gå till nästa power 10
CLC
sub playercashL, tempL; annars subtrahera med 10
SBC playercashH, tempH; annars subtrahera med 10
Inc siffran. och öka den nuvarande siffran
rjmp compareHigh; och gå tillbaka till testa igen
returnDigit:; siffran kommer nu vara den att visa i denna plats
ret

Nästa kommer att vi införa något nytt--TWI kommunikation.