Effizienter Rechnen?

**BASTIUniversal** · 02.01.2008, 12:16

Hi!
Ich habe das Problem, dass zwei neue Sensoren von meinem Mega8 so einiges an Rechenleistung bzw. Speicherplatz abverlangen.
Es handelt sich hier um einen Lufttemperatur und -druck Sensor und einen Luftfeuchte Sensor.

Beim Druck/Temperatur Sensor müssen aus einem integrierten ROM elf Variablen ausgelesen werden und die eigentlichen Werte damit verrechnet werden.

Code:

'Dim C(7) As Word, A(4) As Byte, Vas(3) As Single, Var(1) As Word, D2cs As Long

Function Dut(byval D2 As Word)        'As Integer

   D2c5 = D2 - C(5)
   Vas(1) = D2c5 * D2c5
   Vas(2) = Vas(1) / 16384
   Var(1) = 2 ^ A(3)

   If D2 < C(5) Then                                        
      Vas(2) = Vas(2) * A(2)
      Vas(2) = Vas(2) / Var(1)
      Vas(2) = D2c5 - Vas(2)
      Dut = Vas(2)
   Elseif D2 >= C(5) Then
      Vas(2) = Vas(2) * A(1)
      Vas(2) = Vas(2) / Var(1)
      Vas(2) = D2c5 - Vas(2)
      Dut = Vas(2)
   End If

End Function

Function Dbr(byval D1 As Word , Dutb As Integer)     'As Word

   Local Offset As Integer
   Local Sens As Integer
   Local Xb As Integer

   Var(1) = C(4) - 1024
   Vas(1) = Var(1) * Dutb
   Vas(1) = Vas(1) / 16384
   Vas(1) = Vas(1) + C(2)
   Vas(1) = Vas(1) * 4
   Offset = Vas(1)

   Vas(1) = C(3) * Dutb
   Vas(1) = Vas(1) / 1024
   Vas(1) = Vas(1) + C(1)
   Sens = Vas(1)

   Vas(1) = D1 - 7168
   Vas(1) = Vas(1) / 16384
   Vas(1) = Sens * Vas(1)
   Vas(1) = Vas(1) - Offset
   Xb = Vas(1)

   Vas(1) = Xb * 10
   Vas(1) = Vas(1) / 32
   Vas(1) = Vas(1) + C(7)
   Dbr = Vas(1)

End Function

Function Tbr(dutb As Integer)        'As Integer

   Vas(1) = Dutb * C(6)
   Vas(1) = Vas(1) / 65535
   Vas(2) = 2 ^ A(4)
   Vas(2) = Dutb / Vas(2)
   Vas(3) = Vas(1) - Vas(2)
   Vas(3) = 250 + Vas(3)
   Tbr = Vas(3)

End Function

Diese drei Funktionen brauchen bestimmt 40-50% vom Flash des Mega8 und die Berechnung dauert auch ne ganze Weile. Da ich gerne noch ein paar andere Sensoren und eine Funkübertragung einbauen wollte, brauche ich mehr Platz.
Wie kann ich also am besten die Rechnungen umstellen, verändern, durch andere Rechenoperationen schlanker gestalten? Sind Local-Variablen hier besser geeignet als "Globale"?

Danke!
Basti

**Johnes** · 02.01.2008, 13:05

Ist ja schön und gut, wenn du die Werte jedesmal auf dem Chip ausliest, aber warum?

Die Werte sind doch fest ins ROM gebrannt! Da reicht es diese einmal zu lesen und dann die Kompensation extern (von Hand mit dem Taschenrechner, etc.) zu errechnen und dann als Festwert ins Flash zu schreiben. Da braucht der Atmel die Werte dann nicht mehr errechnen!

Nur der Sensorwert der sich ändern KANN muss dann noch mit dem FEST ins ROM gebrennten Wert verrechnet werden.

MfG

**BASTIUniversal** · 02.01.2008, 13:40

Hi!
Im Prinzip hast du recht, aber der Code soll so Universell wie möglich werden, damit ihn auch andere ohne viel Aufwand Benutzen können.

Außerdem will ich ja auch noch was dazulernen, damit mein Code im Allgemeinen Effizienter wird.

Basti

**MrNiemand** · 02.01.2008, 15:18

das /32 , /1024 und /16384 kann man mit einem shift genauso gut machen, und geht deutlich schneller... Über das /65535 wunder ich mich, das passt nicht ins Schema

Ich vermute auch mal Array Zugriffe kosten mehr Performance wie normale Variablen?

**PicNick** · 02.01.2008, 15:54

...Array Zugriffe kosten mehr Performance ...

Mächtig. besser temporäre variable und dann erst wieder ins Array

Wenn die Funktionen nicht reentrant sein müssen, dann eher globale Variable statt call-Argumente

../32 , /1024 und /16384 kann man mit einem shift

UNBEDINGT

**PicNick** · 02.01.2008, 16:10

Weitergesponnen, weil jede Rechnung zählt

Code:

Das da, z.b.
   Var(1) = C(4) - 1024 
   Vas(1) = Var(1) * Dutb 
   Vas(1) = Vas(1) / 16384 
   Vas(1) = Vas(1) + C(2) 
   Vas(1) = Vas(1) * 4 

Ist doch eigentlich :
   Vas(1) = ( (C(4) - 1024 ) * Dutb /  16384   + C(2) ) * 4

Aufgedröselt:
   C(4)  * Dutb * (4 / 16384)  - Dutb * (1024 * 4  / 16384)   +  C(2) * 4

Sowas:

(4 / 16384) 
(1024 * 4  / 16384) 

kannst du schon beim kompilieren ausrechnen lassen 

const factor = (1024 * 4  / 16384)

OHNE GEWÄHR

PS: und möglichst wenig typenumwandlungen (long->single etc)
also eher alles gleich

**stefan_Z** · 02.01.2008, 17:49

Man kann in Bascom auch Konstanten mit Produkten anderer Konstanten festlegen. Die werden dann beim Compilen errechnet und entsprechend gespeichert.
CONST A = B / C
Wobei B/C auch Konstanten sind!