DECLARE SUB/de

Funktion

Deklariert eine Subroutine.

 

 

Syntax

DECLARE SUB test[( [BYREF/BYVAL/BYLABEL] var AS type)]

 

 

Anmerkungen

test	Name der Prozedur.
var	Name der Variablen.
type	Datentyp der Variablen. Byte, Word, Dword, Integer, Long, Single, Double oder String.

 

ARRAYS

Arrays können nur 'by reference' übergeben werden. Man muss leere Klammern () nach der Variablen schreiben um anzugeben, dass man ein Array übergibt.

Innerhalb der Sub/Funktion muss man ebenfalls die Klammern () benutzen wenn die Variable zugegriffen wird.

Beispiel:

 

Declare Sub TestArray(ar() as byte, b as byte)

Dim a(10) as byte , q as byte

TestArray a(1) , q

 

Wie man sieht schreibt man () nach der Variablen um anzuzeigen, dass ein Array übergeben wird.

Beim Aufruf des Unterprogramms übergibt man die erste Adresse/Basisadresse des Arrays. In diesem Fall ist das a((1).

Im Unterprogramm verwenden wir die Variable ebenfalls mit ().

 

Sub TestArray(ar() as byte, b as byte)

 print ar(1)

 print ar(b)

End Sub

 

Im älteren BASCOM-Versionen war es nicht erforderlich, () zu benutzen. Man musste nur die Basisadresse übergeben. Dies ist aber eine mögliche Fehlerquelle. Wenn man eine Variable als Array referenziert während sie eigentlich eine einzelne Variable ist dann kann an eine falsche Adresse geschrieben werden. Wenn man () schreibt dann weiß der Compiler, dass ein Array erwartet wird und kann über mögliche Fehler informieren.

Wenn man alten Programmcode hat dann kann man CONFIG ERROR=IGNORE,380=IGNORE benutzen um Fehler durch die neue Syntax zu ignorieren.

 

 

Wenn BYREF oder BYVAL nicht angegeben ist dann wird der Parameter 'by reference' übergeben.

Benutzen Sie BYREF um eine Variable durch Referenzierung ihrer Adresse zu übergeben. Bei Benutzung der referenzierten Adresse arbeitet man mit der originalen Variablen. Ein Ändern der Variablen innerhalb der Subroutine ändert die Variable auch außerhalb der Routine.

 

Benutzen Sie BYVAL um eine Kopie der Variablen zu übergeben. Übergabe der Kopie einer Variablen erlaubt das Ändern der Variablen in der Subroutine ohne dass die Original-Variable verändert wird. BYVAL verändert nicht die Original-Variable aber es erfordert mehr Code weil eine Kopie der Variablen erstellt werden muss.

 

Benutzen Sie BYLABEL um die Adresse eines Labels zu übergeben. BYLABEL übergibt die Word-Adresse. Es funktioniert nicht für Mikrocontroler mit 'Multiple 64k Pages'.

 

Die Benutzung von BYLABEL für EEPROM ist möglich aber das EEPROM Abbild muss vor dem Aufruf mit dem Labelnamen stehen.

 

Siehe auch READEEPROM, LOADLABEL und Memory usage

 

Wenn eine Zeichenkette (string) übergeben wird dann kann man die Länge der Zeichenkette angeben. Das ist dann die maximale Länge, die die Zeichenkette haben kann. Das ist wichtig wenn eine Zeichenkette mit BYVAL übergeben wird.

Wenn zum Beispiel eine Zeichenkette "ABC" an eine Subroutine/Funktion mit BYVAL übergeben wird dann erzeugt der Compiler eine Kopie der Länge 3. Das ist ausreichend für die Übergabe an die Subroutine.

Wenn die Zeichenkette aber in der Subroutine verlängert wird dann passt es nicht mehr weil die Zeichekette zu kurz ist. In so einem Fall kann man die Länge angeben. s as string * 10 erzeugt eine Zeichenkette der Länge.

 

 

Siehe auch beim CALL Befehl für weitere Details.

 

 

 Man muss jede Funktion deklarieren bevor man sie benutzt und die Deklaration muss der Funktion entsprechen. Optional kann man CONFIG SUBMODE=NEW benutzen und DECLARE ist dann nicht erforderlich.

Bits sind global und können nicht an Funktionen oder Subroutinen übergeben werden.  

 

Siehe auch

CALL , SUB , FUNCTION , CONFIG SUBMODE

 

 

Beispiel

'-----------------------------------------------------------------------------------------
'name : declare.bas
'copyright : (c) 1995-2005, MCS Electronics
'purpose : demonstrate using declare
'micro : Mega48
'suited for demo : yes
'commercial addon needed : no
' Note that the usage of SUBS works different in BASCOM-8051
'-----------------------------------------------------------------------------------------
 
$regfile = "m48def.dat" ' Mikrocontroller
$crystal = 4000000 ' Taktfrequenz
$baud = 19200 ' Baudrate
$hwstack = 32 ' default use 32 for the hardware stack
$swstack = 10 ' default use 10 for the SW stack
$framesize = 40 ' default use 40 for the frame space
 
 
' Erst müssen die SUB-Routinen deklariert werden
 
'SUB ohne Parameter
Declare Sub Test2
 
'SUB mit einer Variablen, die nicht durch das Unterprogramm geändert werden kann(A) und
'einer Variablen die geändert werden kann(B1).
'Wenn BYVAL angegeben wird dann wird der Wert an das Unterprogramm übergeben
'Wenn BYREF oder gar nichts angegeben wird dann wird die Adresse an das Unterprogramm übergeben
 
Declare Sub Test(byval A As Byte , B1 As Byte)
Declare Sub Testarray(byval A As Byte , B1 As Byte)
'Alle Variablen-Typen können übergeben werden.
'BIT Variablen können nicht übergeben werden.
'BIT Variables sind GLOBAL für das gesamte Programm
Declare Sub Testvar(b As Byte , I As Integer , W As Word , L As Long , S As String)
 
'Die Übergabe von Zeichenketten erfordert eine andere Syntax weil die Länge der Zeichenkette vom Compiler übergeben werden muss.
'Die leeren Klammern () zeigen an, dass ein Array übergeben wird.
Declare Sub Teststr(b As Byte , Dl() As String)
 
Dim Bb As Byte , I As Integer , W As Word , L As Long , S As String * 10 'dim used variables
Dim Ar(10) As Byte
Dim Sar(10) As String * 8 'Zeichenketten-Array
 
For Bb = 1 To 10
Sar(bb) = Str(bb) 'Array befüllen
Next
Bb = 1
'Jetzt Aufruf der Sub mit Angabe der ersten Adresse mit dem Index 1.
Call Teststr(bb , Sar(1))
 
 
Call Test2 'call sub
Test2 'oder Benutzung ohne CALL
'Beim Aufruf ohne CALL müssen die Klammern weggelassen werden
Bb = 1
Call Test(1 , Bb) 'Aufruf mit Parametern
Print Bb 'Ausgabe des geänderten Wertes
 
'Test mit verschiedenen Datentypen
Call Testvar(bb , I , W , L , S )
Print Bb ; I ; W ; L ; S
 
'Arrayübergabe
'Übergabe muss 'by reference' geschehen
Testarray 2 , Ar(1)
Print "ar(1) = " ; Ar(1)
Print "ar(3) = " ; Ar(3)
 
$notypecheck ' TYpe-Checking ausschalten
Testvar Bb , I , I , I , S
'you can turn off type checking when you want to pass a block of memory
$typecheck 'turn it back on
End
 
'Am Ende des Programms die Subroutinen
'Es müssen dieselben Variablen und Namen benutzt werden wie bei der Deklaration
 
Sub Test(byval A As Byte , B1 As Byte) 'start sub
 Print A ; " " ; B1 'Ausgabe der übergebenen Variablen
 B1 = 3 'Wert ändern
 'Man kann A ändern aber weil es eine Kopie ist
 'wirken sich die Änderungen nicht auf die Originalvariable aus.
End Sub
 
Sub Test2 'Sub ohne Parameter
 Print "Keine Parameter"
End Sub
 
 
 
Sub Testvar(b As Byte , I As Integer , W As Word , L As Long , S As String)
 Local X As Byte
 X = 5 'lokale Zuweisung
 B = X
 I = -1
 W = 40000
 L = 20000
 S = "test"
End Sub
 
Sub Testarray(byval A As Byte , B1 As Byte) 'start sub
 Print A ; " " ; B1 'Ausgabe der übergebenen Variablen
 B1 = 3 'Verändern des Elementes mit dem Index 1
 B1(1) = 3 'Angabe des Index - macht das Gleiche wie in der Zeile davor
 B1(3) = 3 'Verändern eines anderen Array-Elementes
 'Man kann A ändern aber weil es eine Kopie ist
 'wirken sich Änderungen nicht auf die Originalvariable aus.
End Sub
 
'Die leeren Klammern () zeigen an, dass ein String-Array übergeben wird
Sub Teststr(b As Byte , Dl() As String)
Dl(b) = Dl(b) + "add"
End Sub
 
 
 
Example BYLABEL
$regfile = "m88def.dat"
$hwstack = 40
$swstack = 80
$framesize = 80
 
Dim B As Byte , W As Word
 
Declare Sub Somesub(bylabel Mylabel As Word)
Somesub Alabel
End
 
 
Sub Somesub(bylabel Mylabel As Word)
 W = Mylabel ' this points to the BYTE address of the data
 lds _dptrl,{W } ' point to
 LDS _dptrh,{W+1}
 Read B : Print B
End Sub
 
Alabel:
Data 1 , 2 , 3

Languages	English • Deutsch