Funktionen in Assembler?

Hallo Jens,
>Es gibt ja einige vorgefertigte ...Funktionen... in Studio4
Wo gibts denn in Studio4 solche Funktionen?

Funktionen, wie z.B. in C, Visual Basic oder PHP gibt es in Assembler
nicht. So was ähnliches wie Funktionen sind in Assembler die
Unterprogramme/Subroutinen. Gebe in der Studio4-HTML-Hilfe mal RCALL
ein. Dort steht näheres zu Subroutinen.

MfG

Wolfram Hubert

>Wo gibts denn in Studio4 solche Funktionen?


Zum Beispiel diese hier:

LOW(expression) returns the low byte of an expression
  HIGH(expression) returns the second byte of an expression
  BYTE2(expression) is the same function as HIGH
  BYTE3(expression) returns the third byte of an expression
  BYTE4(expression) returns the fourth byte of an expression
  LWRD(expression) returns bits 0-15 of an expression
  HWRD(expression) returns bits 16-31 of an expression
  PAGE(expression) returns bits 16-21 of an expression
  EXP2(expression) returns 2^expression
  LOG2(expression) returns the integer part of log2(expression)

Ich dachte, daß man nun auch eigene Funktionen (ähnlich wie in Delphi
oder C, natürlich auf Assemblerebene) schreiben könnte, um die
Assemblerprogrammierung übersichtlicher zu gestalten.

Gruß

Jens

das sind zwar letztendlich Funktionen, die werden und können aber nicht
vom MC zur Laufzeit benutzt werden, sondern ausschließlich vom
Assembler und arbeiten auch nur mit Konstanten. Wenn du sowas suchst,
würde mich mal interessieren, welche Funktionen du noch brauchst.

Hallo Jens,

das sieht mir mehr nach Makros aus. Die machen das Programmieren
allerdings übersichtlicher. Da Makros ein Feature des Assemblers sind,
würde ich mal in dessen Doku nachsehen.

MfG
Andreas Jäger

Hallo Jens,


>LOW(expression) returns the low byte of an expression
>HIGH(expression) returns the second byte of an expression
>...

Danke. Tatsächlich schreibt die Online-Hilfe von "Functions"

Ich verstehe unter Funktionen wie folgt:

Rückgabe = Funktionsname(Parameter,...)

Also gebe ich der Funktion hight() mal einen Parameter mit, dessen Wert
erst zur Laufzeit bekannt ist:
-------------------------------------
.def parameter = r16
.def rueckgabe = r17

   ldi parameter, 256
   ldi rueckgabe, high(zahl)
-------------------------------------

Beim Übersetzen meckert Studio4 wie folgt:
C:\Programme\Atmel\AVR
Tools\AvrStudio4\functions\functions.asm(5) : error : Undefined
variable referenced
Assembly complete with 1 error

Erkenntnis: Die Funktion high() erlaubt keinen Ausdruck, dessen Wert
erst zur Laufzeit bekannt ist. Daher ist diese Funktion nur so
einsetzbar:
-------------------------------------
.def rueckgabe = r16

   ldi rueckgabe, high(256)
-------------------------------------

Im Diassembler steht folgendes:
----------------------------------------------------------------
+00000000:   E001        LDI     R16,0x01         Load immediate
----------------------------------------------------------------
Beim Übersetzen wird

ldi rueckgabe, high(256)

nach

ldi r16, 1

übersetzt. Die Funktionen in Studio4 sind daher, wie von Andreas Jäger
schon erwähnt, eigentlich Makros.

MfG

Wolfram Hubert

@Jens
du kannst macros als funktionen verbraten...
... aber du zahlst dann den preis in worten.
greetX, [int]

Danke für Eure Bemühungen,

mit Makros arbeite ich ja. Ich dachte nur, daß es im Studio4 vielleicht
gewisse Neuerungen gibt.
Idee oder Gedanke: Man kann ja in C auch Assemblercodes angeben.
Vielleicht wäre es ja auch umgekehrt möglich. Man erstellt in Assembler
Prozeduren oder Funktionen, reserviert einige Register und SRAM
Speicherplätze generell dafür, und ruft diese jedesmal auf, wenn man
sie braucht, ohne Rücksicht auf Definitionen von Registern usw..
Ich habe mir zum Teil schon solche Sachen eingerichtet. Z.B.
Mididaten-Senden, Eeprom - Routinen, Monoflops, Tastenabfragen usw..
Ziel ist es, bei jedem neuen Projekt auf vorhandene Unterprogramme
zuzugreifen und dabei die schnelle Rechengeschwindigkeit von
Assemblercode zu nutzen.
Ich habe einen 3-stimmigen Sampler mit 22kHz gebaut usw. --- geht nur
in Assembler!!

Grüße von Jens-Erwin

Nichts leichter als Funktionen in Assembler zu schreiben: Parameter
einfach in festgelegten Registern (oder im SRAM, wenn es etwas mehr
sein darf!) übergeben und zugehöriges Unterprogramm aufrufen.
Rückübergabe der Ergebnisse auf demselben Weg.

Makros sind dafür ziemlich ungeeignet. Sie eignen sich aber sehr schön
dafür, sein ganzes Sammelsurium an Codefetzen in eine Include-Datei zu
packen und durch Aufruf des Makros nur den Code in die Source zu
übernehmen, den man bei der jeweiligen Aufgabe gerade braucht. Im
Gegensatz zum Include von ganzen Bibliotheken verschwendet das dann
keinen Platz und stört nicht weiter.

MfG
Gerd