Hallo,
Voor de CV installatie ben ik een weersafhankelijke regeling aan het ontwikkelen op basis van een atmel AVR.
Nu ben ik bezig om de formule`s voor de aanvoer temperatur te berekenen en zou ik graag willen weten hoe ik 2 registers door elkaar kan delen en met elkaar kan vermenigvuldigen.
Het type processor dat ik gebruik is nog niet bepaald.
De taal waarin in programmeer is assembler.
Alvast bedankt.
Groetjes,
Arjan
[Bericht gewijzigd door Qdevil op ]
Erelce
**** De beschikbare ruimte van een werkplek is omgekeerd evenredig met de grootte van deze werkplek **** AVR-Oefeningen op Electronics 4 Fun
op mijn site staan er veel links met tutorials....
vooral deze 3de in de lijst
http://www.avr-asm-tutorial.net/avr_en/calc/index.html lijkt mij hiervoor interessant ...
6foot6
Uitspraken die hier onder mijn naam zijn gepubliseerd, hebben niet altijd mijn instemming
dat wordt herhaald subtracten cq adden
Ben er niet zo in thuis, maar het lijkt me dat je wel wat slims met shiften en substracten (delen) kunt verzinnen. Zo is dat tenminste gebruikelijk met wat grotere (als in een paar honderd bits) getallen.
heeft die AVR geen divisor aan boord dan ?
Wat een K* controller is dat dan 
Zoek eens op Cordic Math in google.
de PIC heeft nl. hetzelfde probleem, en dmv. schuiven en optellen is er een delerroutine te vinden voor integers.
(heb helaas alleen de PIC versie, in PIC-assembler, waar je als AVR adept waarschijnlijk niet veel mee kan)
als je C zou schrijven is het nochthans zeer eenvoudig...
uitkomst = regA / regB
offe
uitkomst = regA * regB
De uitkomst kan zowel een register als een variabele zijn.
Alleen als je uitkomst toevallig uit 2 registers komt moet je die ff samenvoegen in 1 variabele alvorens een deling in te zetten...
[Bericht gewijzigd door High met Henk op ]
@HmH: en dan maar hopen dat je C-krompiler d'r geen bende van maakt
(heb d'r gezien voor de PIC16, 't was om te huilen.)
hmmm mijn C compiler vooerde de volgende formule zonder problemen uit....
uitkomst = ((((141*A*A)/1000)*A)/1000*A)/10000+(((1077*A*A)/1000)*A)/100000+(2556*A*A)/1000000+(367*A)/1000+102
dit was een 4e graad polynoom die een grafiek beschaaref. A was de uitlezing, uitkomst de waarde van wat de sensor mat.
WERKTE PERFECT!!
AVR GCC rules, maar misschien ook omdat ATMEL die zelf ondersteund...
Dat atmel de krompiler ondersteunt helpt veel, maar ik dacht meer aan de hoeveelheid machinecode die gegenereerd wordt door de krompiler.
Gezien jouw vele /1000 en hoger heb je de hele zaak als integer of als long-integer uitgevoerd.
Het kan in dit geval wel sneller zijn het als float uit te voeren, omdat je minder delingen door 1000 nodig hebt.
(aleen aan het einde misschien een vermenigvuldiging met een achterlijk groot getal, om weer op een getal groter 1 uit te komen, wat je naar een integer kunt converteren)
was mijn 1e echte C projectje.... Stond idd als long. maar dan nog werd het een idioot groot getal.... een float bevat zover ik weet niet meer bits als een long. Ik had alleen een overflow probleem.
en dan is en float geen goede oplossing. een float VREET snelheid. Aldus degene die mij bij dit project begeleid heeft. En die werkt al 20 jaar met uC's en is helemaal AVR freak.
Twee 8-bit registers vermenigvuldigen kun je gewoon met de mul instructie doen, dan moet je wel minimaal een ATmega hebben (tiny's hebben geen multiplier). Kost 2 cycles.
Deling is lastiger, dan zit je rond de 60-100 cycles. Atmel heeft een app note met kant en klare functies:
http://www.atmel.com/dyn/resources/prod_documents/doc0936.pdf
Code staat hier ergens tussen:
http://www.atmel.com/dyn/products/app_notes.asp?family_id=607
Multiplier:
http://www.atmel.com/dyn/resources/prod_documents/doc1631.pdf
Juist, de atmel heeft dus een hardware multiplier.
@hmh: Dan is het gberuik van integers inderdaad veel sneller als floats. omdat voor een integer vermenigvuldiging/deling bij meer dan 8 bits de boel in stukken gebroken kan worden.
maar als je die vermenigvuldiging dus als schuiven/optellen moet uitvoeren, kan het gebruik van float de boel wel degelijk sneller maken, omdat je in jouw formule niet zo vaak hoeft te delen om de overflows tegen te gaan.