Bar: /* Løsning med reducering ved skift af bit */

2022-11-15T09:44:09Z

Løsning med reducering ved skift af bit

← Ældre version		Versionen fra 15. nov. 2022, 11:44
Linje 346:		Linje 346:
	31 portc = 0b0000_0001 << (porta & 0b0000_0111)		31 portc = 0b0000_0001 << (porta & 0b0000_0111)
	Det sjove er at denne løsning ikke sparer hverken hukommelse eller data-areal, selvom man skulle tro det. Grunden er at den mere komplicerede beregning kræver at den opretter midlertidig hukommelse, og at det kodemæssigt ikke gør nogen forskel, når der alligevel skal bruges midlertidig hukommelse. Denne løsning er ikke med i ZIP-filen.		Det sjove er at denne løsning ikke sparer hverken hukommelse eller data-areal, selvom man skulle tro det. Grunden er at den mere komplicerede beregning kræver at den opretter midlertidig hukommelse, og at det kodemæssigt ikke gør nogen forskel, når der alligevel skal bruges midlertidig hukommelse. Denne løsning er ikke med i ZIP-filen.

			{{PIC}}


			{{Opgaver}}

	[[Kategori:PIC_Opgave_Løsninger]]		[[Kategori:PIC_Opgave_Løsninger]]

Bar: 1 version importeret

2022-11-15T07:09:08Z

1 version importeret

← Ældre version	Versionen fra 15. nov. 2022, 09:09
(Ingen forskel)

_htx>Bar: Oprettede siden med 'Denne side gennemgår løsningen for PIC Opgave 4 - Kombinatorik ==Løsningsforslag for Kombinatoriske opgaver.== Generelt er alle løsningerne lavet med den sædvanli...'

2013-08-20T10:31:15Z

Oprettede siden med 'Denne side gennemgår løsningen for PIC Opgave 4 - Kombinatorik ==Løsningsforslag for Kombinatoriske opgaver.== Generelt er alle løsningerne lavet med den sædvanli...'

Ny side

Denne side gennemgår løsningen for [[PIC Opgave 4 - Kombinatorik]]

==Løsningsforslag for Kombinatoriske opgaver.==

Generelt er alle løsningerne lavet med den sædvanlig opstartskode til en [[PIC16F684]], og selve funktionen realiseret i et forever loop.

Opstartskoden kan ses generelt gennemgået i [[Kategori:PIC_Opgave_Løsninger|PIC Opgave Løsninger]]

===Koden som jal-filer===

Alle eksemplerne kan hentes [[Media:PIC-opg-4.zip|i denne ZIP-fil]].

==Den binære Adder==
Addition af tal sker mange steder, men specielt inde i en mikroprocessor.

Denne opgave præsenterer princippet i det.

==Den 1 bits binære full-adder==
Til den simple adder anvendes to bit-indgange (de to bits der skal adderes) og en udgang med resultatet og en udgang med carry. Til en full adderskal der også en carry-indgang til.

Indgange og udgange til programmet defineres som følger:
<pre>
porta_direction = all_input
alias bit0 is pin_a0 -- De 2 bit der skal adderes
alias bit1 is pin_a1
alias carry_in is pin_a2 -- Carry ind fra inputtet

portc_direction = all_output
alias res0 is pin_c0 -- Resultatet på den bit der kommer ud
alias carry_out is pin_c3 -- Carry ud på resultatet
</pre>

I programmet udregnes resultatet af half-adderen som et mellemresultat. Dette resultat placeres i en bit, der defineres som følger:
var bit res_ha -- mellemresultat, der er half adder-sum

Hele koden inde i forever-loopet ser ud som følgende:
<pre>
37 res_ha = bit0 ^ bit1 -- Først regnes en half-adder
38 carry_out = (bit0 & bit1) | (res_ha & carry_in) -- så beregnes carry_out
39 res0 = res_ha ^ carry_in -- og derefter selve resultatet på full-adderen
</pre>

Linje 37 beregner summen af de to indgangsbit, og gemmer det i den interne variabel.

Linje 38 beregner carry out ud fra begge indgangsbit, mellemresultatet og den carry der kommer ind - resultatet placeres direkte på udgangen.

Linje 38 beregner summen af både de to indgangsbit og carry in - igen lægges det direkte ud på resultat-udgangen.

Koden ligger som opg-4a-full-add.jal [[Media:PIC-opg-4.zip|i denne ZIP-fil]].

===2x3 bits full adder===
Ideen med full-adders er at de kan lægge større tal sammen, og for at illustrere det, så er der her realiseret en full-adder der tager en carry id og 2 stk. 3 bits tal ind, og lægger dem sammen til et 3 bits tal samt en carry ud.

Indgange og udgange til programmet defineres som følger:
<pre>
porta_direction = all_input
alias tal1_bit0 is pin_a0 -- De 3 bit der bliver til tal1
alias tal1_bit1 is pin_a1
alias tal1_bit2 is pin_a2

alias tal2_bit0 is pin_a3 -- De 3 bit der bliver til tal2
alias tal2_bit1 is pin_a4
alias tal2_bit2 is pin_a5

portc_direction = all_output
alias res_bit0 is pin_c0 -- Resultatet på de 3 bit der kommer ud
alias res_bit1 is pin_c1
alias res_bit2 is pin_c2
alias carry_out is pin_c3 -- Carry ud på resultatet
--
alias carry_in is pin_c5 -- Carry ind fra inputtet

pin_c5_direction = input
</pre>

Hen gennem de 2 x 3 bit der skal adderes anvendes igen et mellemresultat som er en halfadder. Mellem 1. og 2. fulladder kommer der en carry ud af den første fulladder, som, skal virke som carry ind på den 2. fulladder. Til dette anvendes en intern variabel som mellemresultat. Den samme variabel kan anvendes mellem 2. og 3. fulladder.
<pre>
var bit res_ha -- mellemresultat, der er half adder-sum
var bit carry_mel -- Mellemresultat på carry
</pre>

Hele koden inde i forever-loopet ser ud som følgende:
<pre>
48 -- Først beregnes full-adder på de to lave bit, der giver et output og en intern carry
49 res_ha = tal1_bit0 ^ tal2_bit0 -- Først regnes en half-adder
50 carry_mel = (tal1_bit0 & tal2_bit0) | (res_ha & carry_in) -- så beregnes carry mellemresultat
51 res_bit0 = res_ha ^ carry_in -- og derefter selve resultatet på full-adderen
52 -- Dernæst regnes på de to næste bit, der igen giver et output og en intern carry
53 res_ha = tal1_bit1 ^ tal2_bit1 -- Først regnes en half-adder
54 res_bit1 = res_ha ^ carry_mel -- så selve resultatet på full-adderen
55 carry_mel = (tal1_bit1 & tal2_bit1) | (res_ha & carry_mel) -- og derefter beregnes carry mellemretultat
56 -- Dernæst regnes på de to sidste bit, der igen giver et output og den endelige carry out
57 res_ha = tal1_bit2 ^ tal2_bit2 -- Først regnes en half-adder
58 carry_out = (tal1_bit2 & tal2_bit2) | (res_ha & carry_mel) -- så beregnes carry_out
59 res_bit2 = res_ha ^ carry_mel -- og derefter selve resultatet på full-adderen
</pre>

Linje 49-51 regner de første to bit sammen med carry ind, og lægger summen direkte på udgangen, mens den carry der kommer ud af det gemmes, så den kan bruges ved beregning af de næste to bit.

Linje 53-55 regner de næste to bit sammen med carryen der ligger som mellemresultat, og lægger summen direkte på udgangen, mens den carry der kommer ud af det gemmes, så den kan bruges ved beregning af de sidste to bit.

Linje 57-59 regner de sidste to bit sammen med carryen der ligger som mellemresultat, og lægger summen direkte på udgangen. Den carry der kommer ud af det placeres direkte ud på carry out.

Koden ligger som opg-4a-bit.jal [[Media:PIC-opg-4.zip|i denne ZIP-fil]].

===Binær addition som tal===
Ved at betragte indgangene som binære tal, så kan det laves noget enklere. Til dette formål defineres to variabler:
<pre>
var byte tal1
var byte tal2
</pre>
Disse to variabler læses ind fra indgangene

Hele koden inde i forever-loopet ser ud som følgende:
<pre>
46 tal1 = porta & 0b0000_0111 -- Hent det ene 3 bits tal over i tal1
47 tal2 = (porta & 0b0011_1000) >> 3 -- Hent det andet 3 bits tal over i tal2
48 tal1 = tal1 + tal2 -- Læg tallene sammen (det sker som bit i variablerne)
49 if carry_in then
50 tal1 = tal1 + 1 -- Læg carry til, hvis den er der
51 end if
52 portc = tal1 -- output resultatet, hvor carry ligger i det 4. bit
</pre>

Linje 46 læser det ene 3 bits tal ind, og sikrer ved en AND-maske, at det kun er fra de 3 bit der kommer noget.

Linje 47 gør det tilsvarende, bare med 3 bit der ligger et andet sted i porta. Der anvendes igen en AND-maske, og derefter skiftes de 3 bit ned på position 2, 1 og 0, så det er et tal fra 0 til 7.

Linje 48 lægger de to tal sammen (det kan give 0-14, så carry er nu placeret i bit position 3 inde i tal1

Linje 49-51 lægger en carry-bit til fra carry in, hvis den er der, så tallet nu kan være 0-15.

Linje 52 lægger resultatet ud på portc. De 3 bit i tallet kommer ud på pin_c0 - pin_c2 og carryen kommer ud på pin_c3.

Koden ligger som opg-4a.jal [[Media:PIC-opg-4.zip|i denne ZIP-fil]].
==Binær comperator==
Denne opgave handler om at sammenligne to tal
===Kun sammenligning af tal===
I disse to løsninger sammenlignes 2 sæt 3 bit tal, og der sættes 3 udgange ud fra det.

Indgange og udgange til programmet defineres som følger:
<pre>
porta_direction = all_input
-- De to tal der læses ind ligger på hhv. A0-A2 og A3-A5
portc_direction = all_output
-- Definition af de 3 udgange
alias greater is pin_c0
alias equal is pin_c1
alias smaller is pin_c2
</pre>

De to binære tal læses ind i 2 variabler:
<pre>
var byte tal1
var byte tal2
</pre>

Hele koden inde i forever-loopet ser ud som følgende:
<pre>
38 tal1 = porta & 0b0000_0111 -- Læs det første 3 bit tal fra A0-A2
39 tal2 = (porta & 0b0011_1000) >> 3 -- Læs det andet 3 bit tal fra A3-A5
40 if tal1 > tal2 then -- Sammenlign de to tal, og sæt
41 greater = high -- de relevante udgange
42 equal = low
43 smaller = low
44 elsif tal1 < tal2 then
45 greater = low
46 equal = low
47 smaller = high
48 else
49 greater = low
50 equal = high
51 smaller = low
52 end if
</pre>

Linje 38-39 læser de 2 x 3 bit ind i variablerne tal1 og tal2

Linje 40-43 sætter udgange op, hvis tal1 er større end tal2 - de resterende linjer håndterer mindre end og lig med.

Koden ligger som opg-4b.jal [[Media:PIC-opg-4.zip|i denne ZIP-fil]].

Et program der løser det samme kan skrives som:
<pre>
38 tal1 = porta & 0b0000_0111 -- Læs det første 3 bit tal fra A0-A2
39 tal2 = (porta & 0b0011_1000) >> 3 -- Læs det andet 3 bit tal fra A3-A5
40 greater = tal1 > tal2
41 equal = tal1 == tal2
42 smaller = tal1 < tal2
</pre>

Her løser linje 40-42 det der blev lavet i en elsif struktur.

Koden ligger som opg-4b1.jal [[Media:PIC-opg-4.zip|i denne ZIP-fil]].

===Sammenligning med cascading input===
Kigger man på databladet for en binær comperator som digital kreds, så vil den have 3 input mere, der kan påvirke resultatet.
Ideen i det er at man kan sammenligne 2 x 8 med to kredse der hver kan håndtere 2 x 4 bit, og man kan ekspandere til det antal bit man ønsker, ved at lægge flere kredse til.

Der skal defineres nogle indgange der tager imod inputtene:
<pre>
alias in_greater is pin_c3
alias in_equal is pin_c4
alias in_smaller is pin_c5
pin_c3_direction = input
pin_c4_direction = input
pin_c5_direction = input
</pre>

Ekspanderingen kan ske to veje - enten at outputtet går til en kreds med mindre betydende bit, eller at de går til en kreds med mere betydende bit.
====Ekspandering mod mindre betydende cifre====
Hvis outputtet går til en kreds med mindre betydende cifre, så kan koden skrives på følgende måde:
<pre>
47 tal1 = porta & 0b0000_0111 -- Læs det første 3 bit tal fra A0-A2
48 tal2 = (porta & 0b0011_1000) >> 3 -- Læs det andet 3 bit tal fra A3-A5
49 if in_greater then -- Sæt Greater, hvis det højere ciffer siger Greater
50 greater = high
51 equal = low
52 smaller = low
53 elsif in_smaller then -- Sæt Smaller, hvis det højere ciffer siger Smaller
54 greater = low
55 equal = low
56 smaller = high
57 elsif in_equal then -- Hvis det højere tal siger Equal
58 portc = tal1 > tal2 -- Sammenlign de to tal, og sæt
59 portc = tal1 < tal2 -- udgangene derefter
60 portc = tal1 == tal2
61 else -- Sæt ikke noget hvis det højere ciffer ikke siger noget
62 greater = low
63 equal = low
64 smaller = low
65 end if
</pre>

Linje 47-48 læser de to tal ind.

Linje 49-56 håndterer hvis det større tal siger større eller mindre.

Linje 57-60 håndterer hvis det større tal siger lig med - her anvendes løsningen fra før.

Linje 61-65 håndterer hvis det større tal ikke indikerer noget fornuftigt, så sættes alle udgange lave, som en fejltilstand.

Koden ligger som opg-4b2.jal [[Media:PIC-opg-4.zip|i denne ZIP-fil]].

====Ekspandering mod mere betydende cifre====
Hvis outputtet går til en kreds med mere betydende cifre, så kan koden skrives på følgende måde:
<pre>
47 tal1 = porta & 0b0000_0111 -- Læs det første 3 bit tal fra A0-A2
48 tal2 = (porta & 0b0011_1000) >> 3 -- Læs det andet 3 bit tal fra A3-A5
49 greater = tal1 > tal2 -- Sammenlign de to tal, og sæt
50 smaller = tal1 < tal2 -- de relevante udgange
51 if tal1 == tal2 then -- tag fra cascading input, hvis tallene er ens
52 greater = in_greater
53 equal = in_equal
54 smaller = in_smaller
55 end if
</pre>

Linje 47-48 læser de to tal ind.

Linje 49-50 laver sammenligningen på større end eller mindre end.

Linje 51-55 håndterer hvis de to tal er ens, så sendes cascading input videre til næste ciffer, eller ud som resultat.

Koden ligger som opg-4b3.jal [[Media:PIC-opg-4.zip|i denne ZIP-fil]].

==Dekoder 3 bit binær til 8==

Dekoderen tager 3 bit ind, og fra det tal de danner sættes en udgang, så kombinationerne 0-7 kommer ud på 8 udgangen, hvor den første bliver høj, når der kommer 0 ind, den næste bliver høj når der kommer 1 ind osv.

Indgange og udgange til programmet defineres som følger
<pre>
porta_direction = all_input
portc_direction = all_output
</pre>

Her anvendes de 3 lave bit i porta til tallet ind, og hele portc er udgangene

Der anvendes 2 variabler. tal1 indeholder det tal der læses ind, og tal2 anvendes til at behandle det der skal ud på udgangen.
var byte tal1
var byte tal2

===Løsning med for-løkke===

I den første løsning, der anvendes en for-løkke til at finde den rigtige udgang.

Hele koden inde i forever-loopet ser ud som følgende:
<pre>
32 tal1 = porta & 0b0000_0111
33 tal2 = 0b0000_0001
34 for tal1 loop
35 tal2 = tal2 * 2
36 end loop
37 portc = tal2
</pre>

Linje 32 læser tallet ind fra porta ind i tal1 - tallet begrænses til 3 bit, så det kun kan være 0-7.

Linje 32 sætter det tal op der skal ende med at komme ud på udgangen - det starter med at ligge med en høj i bit 0, så hvis der ikke ændres på det, så er det pin_c0 der går høj.

Linje 34-36 er det for-loop der sætter bittet hen på den ønskede udgang. Loopet gennemløbes det antal gange der er i tal1, og i linje 35 rykkes bittet en tak ad gangen, det kan gøres ved at gange tallet med 2, eller man kunne også have anvendt en skifte-operator << 1 til det.

I linje 37 lægges resultatet ud på porten.

Koden ligger som opg-4c.jal [[Media:PIC-opg-4.zip|i denne ZIP-fil]].

===Løsning med skift af bit===

I stedet for at anvende et for-loop, så kan man bruge skiftefunktionen direkte.

Hele koden inde i forever-loopet ser ud som følgende:
<pre>
32 tal1 = porta & 0b0000_0111
33 tal2 = 0b0000_0001
34 tal2 = tal2 << tal1
35 portc = tal2
</pre>

Linje 32 læser tallet som før.

Linje 33 sætter tallet der skal skiftes op.

Linje 34 laver selve skifteoperationen, hvor tal2 skiftes fra 0 til 7 gange. Hvis det skiftes 0 gange, så bliver det som det oprindelige, og pic_c0 sættes høj. Hvis der skiftes 7 gange, så skulle det være pin_c7 der bliver sat høj, men da en [[PIC16F684]] ikke har dette ben, så er alle 6 bit der er i porten bare lave. Hvis man vil teste de to sidste bit i portc, så skal man vælge en anden PIC, som f.x. en [[PIC16F690]] der har 8 bit i portc.

Linje 35 er der hvor tallet faktisk lægges ud på porten.

Koden ligger som opg-4c2.jal [[Media:PIC-opg-4.zip|i denne ZIP-fil]].

===Løsning med reducering ved skift af bit===

Dette er blot en reduktion af det ovenstående eksempel, hvor der er sparet en variabel (tal2) væk, og tingene bliver gjort mere direkte.

Hele koden inde i forever-loopet ser ud som følgende:
<pre>
31 tal1 = porta & 0b0000_0111
32 portc = 0b0000_0001 << tal1
</pre>

Linje 31 læser tallet som før.

Linje 32 udfører skifteoperationen, og lægger resultatet ud på portc.

Koden ligger som opg-4c3.jal [[Media:PIC-opg-4.zip|i denne ZIP-fil]].

Koden kan også skrives sammen på en linje, hvor man slet ikke bruger en variabel som vist her:
31 portc = 0b0000_0001 << (porta & 0b0000_0111)
Det sjove er at denne løsning ikke sparer hverken hukommelse eller data-areal, selvom man skulle tro det. Grunden er at den mere komplicerede beregning kræver at den opretter midlertidig hukommelse, og at det kodemæssigt ikke gør nogen forskel, når der alligevel skal bruges midlertidig hukommelse. Denne løsning er ikke med i ZIP-filen.

[[Kategori:PIC_Opgave_Løsninger]]

PIC Opg 4 Løsning - Versionshistorie

Bar: /* Løsning med reducering ved skift af bit */

Bar: 1 version importeret

_htx>Bar: Oprettede siden med 'Denne side gennemgår løsningen for PIC Opgave 4 - Kombinatorik ==Løsningsforslag for Kombinatoriske opgaver.== Generelt er alle løsningerne lavet med den sædvanli...'