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

Un progetto mikroBasic si compone di un modulo principale ed, eventualmente, di altri 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 "Come creare un progetto".

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

Gli altri moduli iniziano con la parola "module" e NON DEVONO avere, all'interno, un'etichetta "main" perchè darebbe errore. Devono avere, invece, la parola chiave "implements", dopo la quale si potrà inserire il codice sorgente per il modulo. Il modulo terminerà con la parola chiave "End". Vedere anche "Come creare un modulo".

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 .pbp contenente le informazioni sul progetto.
I moduli vengono salvati in files con estensione .pbas 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 per creare il risultato del progetto e cioè il file .hex.
Quest'ultimo conterrà il codice macchina da inserire nel PIC con il programmatore.

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 dire a quel modulo, di andare a "cercare" nel file del modulo scritto dopo include.

module cucina 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 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\delays.pbas ma state attenti a non modificarlo.
Il modulo per LCD, a sua volta, includerà il modulo "delay" per i vari ritardi richiesti , come si vede dai grafici sulla disposizione delle routine, nella memoria del PIC.
Seguono due esempi di come potrebbero essere un modulo principale (program) ed un modulo secondario.

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)
	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 ...

' prototipi di procedure
'sub procedure nome_procedura(...)

' prototipi di funzioni
'sub function nome_funzione(...)

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

implements

' dichiarazioni di costanti
'const ...

' dichiarazioni di variabili
'dim ...

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

	if bset = 1 then
	   	var.bit = 1
	else
		var.bit = 0
	end if
	
end sub

' dichiarazioni di funzioni
sub function somma(dim a, b as byte) as word
'  [dichiarazioni locali]
	result = a + b
end sub

end.