Eseguire programmi da MicroSD su ATmega

[giacky98]

hai di sicuro un registro che punta all' istruzione da interpretare (chiamiamolo program counter)

Certo

ed uno stack software per le chiamate a subroutines

Non so se è quello che intendi, comunque ho semplicemente un'array che contiene gli indirizzi a cui deve andare il program counter quando trova un'istruzione 'jump'. Prima di eseguire il programma, l'interprete fa una scansione di tutto il bytecode e cerca i 'label', aggiungendoli all'array.

Nulla ti vieta di avere più program counter (uno per ogni task) e far interpretare un' istruzione al primo task, poi un' istruzione al secondo ... e così via.

Lo so, non è questo il problema, infatti precedentemente ho scritto che se avessi tutti i programmi caricati in RAM non sarebbe un problema, ma il problema è leggere dalla SD due programmi contemporaneamente.
Comunque una mezza idea di come fare mi sta venendo, ho in mente di creare un array bidimensionale per il buffer, in cui la prima dimensione rappresenta il programma, e la seconda l'indirizzo del buffer.

Mi metterò tra un po' a trafficare
Prima però devo sistemare il discorso dei label che dicevo prima, non mi piace che prima di eseguire ogni programma l'interprete faccia la scansione di tutto il bytecode per cercarli, penso che inserirò gli indirizzi dei label nel file eseguibile durante la compilazione, in modo che l'interprete gli carichi subito.

[TardoFreak]

Ok per l' array delle label (anche se sarebbe meglio usare un' allocazione dinamica) ma come fai a chiamare le subroutines?
Per chiamare una subroutine (una funzione o chiamala come vuoi) devi per forza ricordarti dove è stata chiamata per riprendere l' esecuzione al ritorno.
O forse non hai previsto l' uso di subroutines?

[giacky98]

anche se sarebbe meglio usare un' allocazione dinamica

Cosa intendi esattamente?
Magari ho anche presente, ma non capisco cosa intendi con allocazione dinamica...

ma come fai a chiamare le subroutines?

Allora, nel codice si può inserire un'istruzione 'label 0' o 'label 1' o 'label 14' o qualsiasi numero, per definire un punto dove ritornare quando si chiama l'istruzione 'jump' + il numero della label.

Per chiamare una subroutine devi per forza ricordarti dove è stata chiamata per riprendere l' esecuzione al ritorno?

Ho previsto un'istruzione 'ret' (return), che ritorna all'istruzione dopo l'ultimo jump, in modo da implementare delle piccole "subroutine", che ritornano al punto dov'erano state chiamate. Solo che c'è solo un "indirizzo di ritorno" (insomma, quello a cui punta l'istruzione 'ret'), quindi non si possono "incatenare" più chiamate di subroutines.

Comunque, il codice l'ho mantenuto molto semplice, è molto simile ad assembly, BASIC e MS-DOS batch. Per farti un esempio, un programma che scrive i numeri da 0 a 9 è scritto così:

Codice: Seleziona tutto

assign _t0 0

label 0
debug _t0
incr _t0
low _t0 10 _t1
cmpjump _t1 1 0

exit 0


Tradotto sarebbe:

Codice: Seleziona tutto

assign _t0 0 -> assegno 0 alla variabile t0

label 0 -> label 0 qui
debug _t0 -> scrivo la variabile t0 sullo stream di debug (definito nell'interprete)
incr _t0 -> incremento la variabile t0
low _t0 10 _t1 -> se t0 è minore di 10, t1 = 1, altrimenti t1 = 0
cmpjump _t1 1 0 -> se t1 è uguale a 1 ritorna alla label 0

exit 0 -> esci dal programma (raggiunto quando t0 >= 10)


[TardoFreak]

L' allocazione dinamica si usa quando hai strutture dati di cui non puoi conoscerne a priori le dimensioni. Con il C si usano le varie funzioni tipo malloc, calloc e compagnia cantante.
Vedo che hai previsto un livello di subroutine. Un buon esercizio sarebbe implementarne più di uno utilizzando un' array per tenere gli indirizzi di ritorno.

[giacky98]

implementarne più di uno utilizzando un' array per tenere gli indirizzi di ritorno

Ecco, una delle prossime caratteristiche da aggiungere

Secondo te è meglio usare un'array dinamico o uno statico? Suppongo che un array statico di 16 indirizzi sia più che sufficiente per concatenare un po' di subroutines.

[TardoFreak]

16 livelli sono già un bel numero. Ci fai un bel po' di cose.
Io li terrei statici.
Per le label implementerei l' allocazione dinamica anche perché non mi pare che debbano essere rimosse ma solo aggiunte man mano che vengono incontrate, quindi non incorrerei nel pericolo della frammentazione dell' heap.

[giacky98]

Giusto hai ragione per le label

Quando avrò tempo mi metto a scrivere la 0.3, in particolare aggiungo gli indirizzi delle label all'inizio del programma (così evito varie scansioni), uso un array dinamico per queste e aggiungo l'array per gli indirizzi di ritorno.

[giacky98]

Ok, ho aggiunto le label all'inizio del programma, usato un'array dinamico per queste e messo un'array per tenere gli indirizzi di ritorno per implementare delle "subroutines".
Il tutto nella versione 0.3 che ho caricato poco fa su SourceForge.

Adesso volevo, per la prossima versione, oltre a implementare il multitasking, anche una piccola gestione degli interrupt.

Qui volevo chiedere il parere di TardoFreak. L'idea è quella di chiamare una funzione della libreria quando accade un'interrupt. Questa funzione va a spostare il program counter all'indirizzo di una label definita dall'utente. Ma la mia domanda è: nel caso io abbia più task, come si deve comportare l'interprete quando viene generato un'interrupt?

Deve cercare una label apposita in ogni task o deve esserci solo un task che supporta gli interrupt?
Non mi è molto chiaro se mi sai chiarire le idee te ne sarei molto grato

[TardoFreak]

Ci deve essere una sola routine di servizio dell' interrupt.
Anche perché non avrebbe senso averne più di una.

[giacky98]

E come faccio a essere sicuro che non ci siano più task che contengano una routine per lo stesso interrupt?