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

 

 

Example

'-----------------------------------------------------------------------------------------
'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" ' specify the used micro
$crystal = 4000000 ' used crystal frequency
$baud = 19200 ' use baud rate
$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
 
 
' First the SUB programs must be declared
 
'Try a SUB without parameters
Declare Sub Test2
 
'SUB with variable that can not be changed(A) and
'a variable that can be changed(B1), by the sub program
'When BYVAL is specified, the value is passed to the subprogram
'When BYREF is specified or nothing is specified, the address is passed to
'the subprogram
 
Declare Sub Test(byval A As Byte , B1 As Byte)
Declare Sub Testarray(byval A As Byte , B1 As Byte)
'All variable types that can be passed
'Notice that BIT variables can not be passed.
'BIT variables are GLOBAL to the application
Declare Sub Testvar(b As Byte , I As Integer , W As Word , L As Long , S As String)
 
'passing string arrays needs a different syntax because the length of the strings must be passed by the compiler
'the empty () indicated that an array will be passed
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 'strng array
 
For Bb = 1 To 10
Sar(bb) = Str(bb) 'fill the array
Next
Bb = 1
'now call the sub and notice that we always must pass the first address with index 1
Call Teststr(bb , Sar(1))
 
 
Call Test2 'call sub
Test2 'or use without CALL
'Note that when calling a sub without the statement CALL, the enclosing parentheses must be left out
Bb = 1
Call Test(1 , Bb) 'call sub with parameters
Print Bb 'print value that is changed
 
'now test all the variable types
Call Testvar(bb , I , W , L , S )
Print Bb ; I ; W ; L ; S
 
'now pass an array
'note that it must be passed by reference
Testarray 2 , Ar(1)
Print "ar(1) = " ; Ar(1)
Print "ar(3) = " ; Ar(3)
 
$notypecheck ' turn off type checking
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
 
'End your code with the subprograms
'Note that the same variables and names must be used as the declared ones
 
Sub Test(byval A As Byte , B1 As Byte) 'start sub
 Print A ; " " ; B1 'print passed variables
 B1 = 3 'change value
 'You can change A, but since a copy is passed to the SUB,
 'the change will not reflect to the calling variable
End Sub
 
Sub Test2 'sub without parameters
 Print "No parameters"
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 'assign local
 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 'print passed variables
 B1 = 3 'change value of element with index 1
 B1(1) = 3 'specify the index which does the same as the line above
 B1(3) = 3 'modify other element of array
 'You can change A, but since a copy is passed to the SUB,
 'the change will not reflect to the calling variable
End Sub
 
'notice the empty() to indicate that a string array is passed
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