mikroBasic - Subroutines, procedure, funzioni (2)

sub function nome_funzione (lista_parametri) as tipo_dato_ritorno
[ dichiarazioni locali ]
  corpo della funzione 
end sub

Sub function

Una funzione è simile ad una procedura, ma che però ritorna un valore quando viene eseguita, mentre la procedura non lo fa.

program prova_funz

dim pere as byte
dim mele as byte
dim ricavo as word

sub function somma(dim x, y as byte) as word
    result = x + y
end sub

main:
    trisB = 0
    while true
        ricavo = somma(10, 35)
        pere = 25
        mele = 30
        if somma(pere, mele) > 50 then
            portB.0 = 1
        end if
    wend
End.

Esempio di sub-function

Definisco le variabili globali pere e mele di tipo byte e ricavo di tipo word.

Definisco la funzione somma con 2 parametri formali (x, y) di tipo byte e il risultato di tipo word.

Result è una variabile locale della funzione, creata automaticamente da mikroBasic, perciò non serve definirla. E' la variabile che riceverà il risultato della funzione
(result = x + y). In questo caso, il compito che deve fare la funzione, è quello di fare la somma dei 2 valori passati nei parametri.

Nella main assegno a ricavo il risultato della funzione somma, chiamata passandole i parametri attuali (10, 35) (in pratica
ricavo = result).

Poi assegno dei valori alle variabili pere e mele e, se la somma di queste, è maggiore di 50 (risultato della funzione somma), imposto ad 1 il bit portB.0.

La parola stack in inglese significa "catasta, pila" e su questa catasta e' possibile depositare, uno sull'altro, piu' indirizzi e poi recuperarli quando servono.

Questo tipo di memorizzazione viene anche denominata LIFO dall'inglese Last In First Out, in cui l'ultimo elemento inserito (last in) deve necessariamente essere il primo ad uscire (first out).

Grazie a questa caratteristica, è possibile effettuare più chiamate a sottoprogrammi annidate e mantenere sempre traccia del punto in cui proseguire l'esecuzione, nel momento in cui si incontra la fine del sottoprogramma.

program prova_nested
.....
.....

sub procedure ritardo
    delay_ms(10)
end sub

sub procedure proc_due
    ritardo
end sub

sub procedure proc_uno
    proc_due
end sub

main:
    .....
    .....
    proc_uno
    .....
    .....
    goto main
End.

Limitazioni di chiamate annidate

La chiamata annidata rappresenta, ad esempio, una chiamata, all'interno del corpo procedura, ad un'altra procedura o funzione.

Nell'esempio vediamo nella main

1) la chiamata a proc_uno, la quale, a sua volta,
2) chiama la proc_due, che a sua volta
3) chiama ritardo, che a sua volta
4) chiama delay_ms.

Tutte queste chiamate si dice che sono annidate ed i loro indirizzi di ritorno saranno impilati nello stack per essere presi al ritorno di ognuna di esse.

In questo caso, le richieste sono 3, perchè delay_ms, essendo inline, non ha effetto sullo stack.

Program prova_byval
dim limone as byte

sub procedure pausa_ms(dim ms as word)
    dim i as word
    for i = 1 to ms
        delay_ms(1)
    next i
end sub

sub procedure gelato(dim banana as byte)
    limone = banana + 3
    banana = limone
end sub

main:
    trisB = 0
    while true
        limone = 2
        portB = 5
        pausa_ms(2000)
        gelato(portB)
        pausa_ms(2000)
    wend
end.

Per valore (byval).

Quando dobbiamo passare delle variabili ai parametri delle procedure e funzioni, queste, per impostazione predefinita, vengono passate "per valore" e la parola chiave byval non è necessaria.

Quando, in un parametro di una procedura, si trova scritto ad es: gelato(dim banana as byte) è come se fosse scritto: gelato(dim byval banana as byte) perché, per default, è sott'inteso il passaggio per valore.

Ecco, a sinistra, un esempio che non fa niente, ma è solo per spiegare la differenza del passaggio per valore e per riferimento.

N.B.
Ho inserito un ritardo di 2 secondi per poter vedere il risultato sui LED connessi a portB.

Program prova_byref
dim limone as byte

sub procedure pausa_ms(dim ms as word)
    dim i as word
    for i = 1 to ms
        delay_ms(1)
    next i
end sub

sub procedure gelato(dim byref banana as byte)
    limone = banana + 3
    banana = limone
end sub

main:
    trisB = 0
    while true
        limone = 2
        portB = 5
        pausa_ms(2000)
        gelato(portB)
        pausa_ms(2000)
    wend
end.

Per riferimento (byref).

Se, invece, dobbiamo passare la variabile per riferimento dobbiamo usare la parola chiave byref.

Byref indica che la variabile viene presa per riferimento e cioè, si fa riferimento al suo indirizzo in memoria.

Vediamo con un'altro esempio, simile a quello di prima, le differenze.

N.B.
Anche qui, ho inserito un ritardo di 2 secondi per poter vedere il risultato sui LED connessi a portB.

program prova_param

dim testo_str as string[3]
dim num_byte as byte

sub procedure pausa_ms(dim ms as word)
    dim i as word
    for i = 1 to ms
        delay_ms(1)
    next i
end sub

sub function somma(dim x, y as byte) as byte
    result = x + y
end sub

Main:
    Lcd_Init(portB)
    Lcd_Cmd(Lcd_Cursor_Off)
    while true
        Lcd_Cmd(Lcd_Clear)
        num_byte = somma(105, 41)
        ByteToStr(num_byte, testo_str)
        Lcd_Out(1, 1, "Num_Byte e' :")
        Lcd_Out(2, 1, testo_str)
        pausa_ms(2000)
        Lcd_Cmd(Lcd_Clear)
        ByteToStr(somma(155, 34), testo_str)
        Lcd_Out(1, 1, "Somma e' :")
        Lcd_Out(2, 1, testo_str)
        pausa_ms(2000)
    wend

End.

Iniziamo definendo la variabile testo_str, di tipo string di 3 caratteri e la variabile num_byte, di tipo byte.
Poi definiamo la procedura pausa_ms (che abbiamo già visto) e la funzione somma (anch'essa già vista prima).

Nella main, inizializziamo il display LCD (Lcd_init) ed escludiamo la visualizzazione del cursore (Lcd_cursor_off), dopodichè entriamo in un ciclo infinito (while-wend).
Azzeriamo il display (Lcd_clear) ed assegnamo alla variabile num_byte, il risultato della funzione somma.

Ora vogliamo visualizzare il valore di num_byte e, per fare questo, dobbiamo convertire il valore numerico in una stringa di caratteri per trasferirla, poi, al display LCD il quale accetta solo caratteri.
Questo compito lo esegue la procedura ByteToStr e quindi passiamo, al primo parametro, il valore da convertire, num_byte.
Al secondo parametro passiamo, invece, il nome della variabile stringa che dovrà ricevere il risultato della conversione, testo_str; non passiamo il valore ma il riferimento alla variabile (l'indirizzo in memoria).

Adesso visualizziamo sul display (Lcd_out), nella prima riga, un messaggio e, nella seconda riga, la stringa testo_str indicante il valore di num_byte.
Attendiamo 2 secondi e riazzeriamo il display.

Adesso vediamo un'altro modo di passare parametri. Nella procedura ByteToStr, invece di passare il valore di una variabile di tipo byte nel primo parametro, possiamo passare il risultato (di tipo byte) di una funzione, in questo caso somma.
Il resto è uguale a quello che abbiamo visto prima e ripetiamo in un ciclo infinito.

sub procedure proc_1
    dim errore as byte
    ... 'qui facciamo qualcosa
    if errore = true then	
        exit
    end if
    ... 'codice che non verrà 
        'eseguito se errore è vero
end sub

Saltare fuori da una procedura o funzione

Se fosse necessario uscire da una procedura o funzione, senza eseguire parte del codice, esiste una istruzione apposita, exit.

Exit esegue un salto alla fine della procedura o funzione e torna al punto seguente la chiamata.

Uscendo da una funzione, il valore di ritorno sarà quello della variabile locale result, al momento dell'uscita.