Programmare in mikroBasic PRO
 
  Box pubblicitario
Composizione di un progetto mikroBasic PRO

Vedere anche:

Per le informazioni riferite a questo argomento e per compilare i programmi è stata usata la
vers. 5.01 di mikroBasic Pro for PIC.

Altre versioni del compilatore potrebbero avere comportamenti diversi o non funzionare.

program Prova_1
' Dichiarazioni (globali)
 
main:
' scrivete qui il vostro codice
End.

Un progetto mikroBasic PRO si compone di un file principale (detto modulo principale) ed, eventualmente, di altri files aggiuntivi (detti moduli aggiuntivi) opzionali.
I moduli aggiuntivi non sono obbligatori mentre il principale sì.
Il modulo principale inizia con la parola "program" ed è il solo che DEVE avere, all'interno, l'etichetta "main:".
Il modulo terminerà con la parola chiave "End.".
Vedere anche "Creare un progetto mikroBasic PRO".

module modulo_uno
' Interfaccia (globale)
 
implements
' scrivete qui il vostro codice
End.

I moduli aggiuntivi iniziano con la parola "module" e NON DEVONO avere, all'interno, un'etichetta "main" perchè darebbe errore.

Devono contenere, invece, la parola chiave "implements", dopo la quale si potrà inserire il codice sorgente per il modulo.
Anche il modulo aggiuntivo terminerà con la parola chiave "End.".
Vedere anche "Creare un nuovo modulo mikroBasic PRO".

Nel modulo principale, l'etichetta "main" indica la procedura principale, che è il cuore del progetto, quella che decide le principali cose da fare.
Nei moduli aggiuntivi ci saranno soltanto procedure e/o funzioni, costanti e/o variabili.

Il progetto viene salvato in un file con estensione .mbppi contenente le informazioni sul progetto.

L'impostazione dei bit di configurazione (fuses) viene salvata in un file con estensione .cfg.

I moduli vengono salvati in files con estensione .mbas contenenti il codice sorgente.

Ogni modulo verrà compilato singolarmente e salvato in un file con estensione .mcl (non leggibile con un editor di testo).

Se un utente vuole rendere disponibile a tutti un certo modulo, senza però rendere pubblico il codice sorgente, lo fa in questa maniera, allegando soltanto il file .mcl.

I moduli compilati saranno collegati dal Linker e mandati al generatore dei files di uscita.

Tra questi, ci sarà un file .log coi risultati della compilazione, ci potrà essere un file .lst con il listato in assembly del progetto compilato, un file .dbg con informazioni per il debug, un eventuale file .cof per fare il debug con il programma MPLAB di Microchip ed, infine, il più importante di tutti e cioè il file .hex.

Quest'ultimo conterrà il codice macchina da inserire nel PIC con un programmatore adatto a programmare il tipo di microcontroller del nostro progetto.

program Prova_Moduli
include "modulo_uno"
include "modulo_due"
.
.
End.
                oppure
 
module modulo_uno
include "modulo_due"
include "modulo_trenta"
.
.
End.

Per includere un modulo, si deve inserire la parola chiave "include", seguita dal nome del file del modulo da includere, racchiuso tra virgolette, subito sotto alla riga della parola chiave program o module.

Non è necessario inserire l'estensione del file.

Si può inserire solo un nome per ogni parola "include".

Si possono inserire quante "include" si vuole per ogni modulo, purchè siano inserite subito sotto alle parole chiave program o module.

Quando si aggiunge la riga "include", si vuole indicare che, alcune variabili o procedure, non sono nel modulo corrente, ma si trovano nel file scritto dopo "include".

module cucina

' prototipi di procedure e funzioni
sub function mangia_banana (x, y as byte) as byte
sub function spremi_arancia (a, b as byte) as word
sub function cioccolata (x, y as byte) as word

implements
sub function mangia_banana (x, y as byte) as byte
....codice
end sub
sub function spremi_arancia (a, b as byte) as word
....codice
end sub
sub function cioccolata (x, y as byte) as word
    result = x + y
end sub
End.

Se quel modulo "incluso", ad esempio, contiene le funzioni "mangia_banana", "spremi_arancia" e "cioccolata", e il modulo, che ha la riga "include", vuole chiamare la funzione "cioccolata", lo farà normalmente così:

mangiare = cioccolata (calda, dolce)

Il compilatore andrà a vedere, nel file del modulo incluso, se trova "cioccolata" e, una volta trovata, la aggiungerà al codice del modulo principale.

program Colazione
include "cucina"

dim mangiare as word
dim calda, dolce as byte
 
main:
    mangiare = cioccolata (calda, dolce)
End.

Le altre funzioni del modulo precedente, se non chiamate, non vengono aggiunte.

Lo scopo di tutto questo è dividere un programmone, in modo che, ogni procedura, non superi le 2000 istruzioni di codice (asm), che è la lunghezza di una pagina di memoria programma del PIC.

I moduli vengono visti come "contenitori chiusi", perciò le variabili usate, per essere visibili anche dagli altri moduli (dichiarazioni globali o public), dovranno essere dichiarate nella parte "interfaccia", che sarebbe la parte che precede la parola chiave "implements".
Tutto quello che verrà inserito dopo la parola "implements" sarà invisibile agli altri moduli (dichiarazioni locali o private).
I moduli sono blocchi di programma che eseguono qualcosa autonomamente ed indipendentemente dal tipo di programma in cui sono inclusi (ma devono comunque essere inclusi).
Ma cosa si intende per blocco? Si intende "un contenitore" nel quale c'è tutto il necessario per eseguire una cosa.
Per "tutto il necessario" si intendono variabili e costanti che saranno usate solo nel modulo.
Il modulo, di solito, è un blocco indipendente da un progetto particolare.
Un esempio sono le funzioni già predisposte (per LCD, EEPROM, Usart, ecc.) che sono dei moduli che vengono inclusi automaticamente da mikroBasic (tramite un modulo che si trova nella cartella \USES).
Trovate un esempio di modulo nella cartella USES\P16\__Lib_Delays.mbas ma state attenti a non modificarlo.
Seguono due esempi di come potrebbero essere un modulo principale (program) ed un modulo secondario (module).

program Prova_Moduli
include "modulo1"
'include [inclusione di altri moduli]

'********************************************************
'* Dichiarazioni (globali):
'********************************************************

' dichiarazioni di simboli
'symbol ...

' dichiarazioni di costanti
'const ...

' dichiarazioni di variabili
    dim beta as word

' dichiarazioni di procedure
'sub procedure nome_procedura(...)
'  [dichiarazioni locali]
'  ...
'end sub

' dichiarazioni di funzioni
'sub function nome_funzione(...)
'  [dichiarazioni locali]
'  ...
'end sub

'********************************************************
'* Corpo del programma:
'********************************************************
main:
' scrivete qui il vostro codice
    beta = somma(2,3)
    alfa = 2
    set_bit_var(portb,5,1)
    goto main
End.

module  modulo1
'include [inclusione di altri moduli]

'********************************************************
'* Interfaccia (globale):
'********************************************************

' dichiarazioni di simboli
'symbol ...

' dichiarazioni di costanti
'const ...

' dichiarazioni di variabili
    dim alfa as byte

' dichiarazioni di procedure
sub procedure set_bit_var(dim byref variab as byte, dim nbit, bset as byte)

' dichiarazioni di funzioni
sub function somma(dim a, b as byte) as word

'********************************************************
'* Implementazione:
'********************************************************

implements

' dichiarazioni di costanti
'const ...

' dichiarazioni di variabili
'dim ...

' dichiarazioni di procedure
sub procedure set_bit_var(dim byref variab as byte, dim nbit, bset as byte)
' variab è una variabile qualsiasi alla quale si vuole settare un bit
' nbit è il numero del bit da settare (da 0 a 7)
' bset è il valore 1 oppure zero

    if bset = 1 then
        variab.nbit = 1
    else
        variab.nbit = 0
    end if
        
end sub

' dichiarazioni di funzioni
sub function somma(dim a, b as byte) as word

    alfa = 1
    result = a + b

end sub

end.

 

Importare un progetto mikroBasic standard in PRO

Impostare i bit di configurazione

Bibliografia:
Manuale mikroBasic PRO

 

Ultima modifica