Caricare documenti e articoli online  
INFtube.com è un sito progettato per cercare i documenti in vari tipi di file e il caricamento di articoli online.
Meneame
 
Non ricordi la password?  ››  Iscriviti gratis
 

Programmazione STL

informatica


Inviare l'articolo a Facebook Inviala documento ad un amico Appunto e analisi gratis - tweeter Scheda libro l'a yahoo - corso di



ALTRI DOCUMENTI

Il Software Applicativo
Trasformare i DvD in VCD o DIVX
Guida passo passo per settare ICProg per Windows XP
MICROSOFT ACCESS 2.0 - LA GUIDA IN LINEA - FINESTRA DI AVVIO MICROSOFT ACCESS
ESERCIZI HTML (FRAMES E FORMS)
Architettura di un microprocessore - Esame dei singoli blocchi (registri) del microprocessore
Relazione di informatica per la risoluzione di un'equazione con il metodo della BISEZIONE
COOPERAZIONE TRA PROCESSI CONCORRENTI
GUIDA ALLA CONVERSIONE DEI NUMERI DECIMALI NEL SITEMA BINARIO - CONVERSIONE DECIMALE- BINARIO
Arbitraggio dei colloqui

Corso

In queste pagine verranno fornite alcune informazioni base utili per chi vuole iniziare a programmare i micro ST6, ma non sa da dove cominicare....
Verr descritto come va impostato un programma, come vanno scritte le istruzioni e verranno descritti alcuni semplicissimi programmi di esempio.
Questo sicuramente non e' sufficiente... ci vuole anche tanta pazienza e tanta pratica, ma quella dovete metterla voi....


SOMMARIO

1.      Impostare un programma



2.      Formato delle istruzioni 232b18c

3.      Assemblare un programma

4.      Set di istruzioni dei micro ST6

5.      Un piccolo programma di esempio (comando LED)

Impostare un programma

In questo capitolo verra' descritto dettagliatamente il programma START. Questo programma e' un esempio tipico di come va impostato un programma per micro ST6. L'esempio si riferisce ai micro ST621x e 2x, ma e' valido anche per altri modelli.

  • Inizio del programma
  • Direttive assembler
  • Definizione registri
  • Variabili del programma
  • Impostazioni iniziali
  • Subroutine di interrupt
  • Subroutine
  • Programma principale
  • Vettori di interrupt
  • Fine del programma

Inizio del programma

;*********************************************************************
;* *
;* FILE SORGENTE DI BASE PER I MICRO ST6210/16/20/25 *
;* *
;*********************************************************************
; by Giuseppe Di Paolo 1996/98
; gdipaolo@mail2.clio.it

Tutte queste righe sono dei COMMENTI, perche' iniziano con il segno di punto e virgola ; e quindi verranno ignorate dall'assemblatore. E' molto utile inserire questi commenti in tutte le parti del programma, per descrivere il funzionamento delle singole parti e anche delle singole istruzioni. In questo caso, all'inizio del programma viene inserito il titolo, l'autore e una breve descrizione. E' utilissimo anche descrivere qui le connessioni delle porte di I/O del micro, le varie modifiche e aggiunte apportare durante lo sviluppo del programma e tutte le informazioni che ritenete utili per rendere piu' facile una comprensione e una lettura del programma anche a distanza di tempo.


Direttive assembler

 .title "TITOLO DEL PROGRAMMA"
 .vers "ST62E20" ; TIPO DI MICROPROCESSORE USATO

Le direttive .title e .vers permettono di specificare il titolo del programma e la vesione di micro da usare. In questa parte di programma si possono inserire anche altre direttive come ad esempio .w_on per usare la DRW. Notate che la scritta "TIPO DI MICROPROCESSORE USATO" e' un commento perche' e' preceduto dal punto e virgola.


Registri del micro

;**********************************************************************
;* VARIABILI DEL MICRO *
;**********************************************************************
 .input "st62reg.inc"

Qui vengono definiti tutti i registri interni del micro che sono indispensabili in qualsiasi programma. Poiche' i registri sono sempre uguali per qualsiasi programma, sono stati definiti all'interno di un altro file chiamato st62reg.inc che viene incluso nel nostro programma tramite la direttiva .input. Per i micro ST626x c'e' un altro file chiamato invece st626reg.inc. Questi files possono essere prelevati nella pagina degli esempi, oppure alla pagina http://www.geocities.com/SiliconValley/Way/7521/st6/files/st62reg.zip


Variabili del programma

;**********************************************************************
;* VARIABILI DEL PROGRAMMA *
;**********************************************************************
prova .def 084h ;DEFINISCE LA VARIABILE 'PROVA'
tempo .def 085h ;DEFINISCE LA VARIABILE 'TEMPO'

Le variabili sono delle celle di memoria RAM contenenti i dati che vengono elaborati e manipolati all'interno del programma. In questo esempio la variabile "prova" corrisponde alla cella di memoria RAM con indirizzo 084h. Non si possono usare due variabili con lo stesso nome.


Impostazioni iniziali

;*********************************************************************
;* SETTAGGIO INIZIALE *
;*********************************************************************
; PER I MICRO ST6210/15 CON 2Kbyte DI ROM/EPROM USATE L'ISTRUZIONE :
 .org 0880h 
; PER I MICRO ST6220/25/60/65 CON 4Kbyte DI ROM/EPROM USATE :
 .org 080h
inizio ; INIZIALIZZAZIONE DELLE PERIFERICHE
 ldi wdog,0ffh ; RICARICA IL WATCH DOG
; ************* IMPOSTAZIONE DELLE PORTE I/O *******************
 ldi pdir_a,11111111b 
 ldi popt_a,11111111b 
 ldi port_a,00000000b ; porta A come uscita push-pull
 ldi pdir_b,00000000b 
 ldi popt_b,00000000b 
 ldi port_b,00000000b ; porta B come input pull-up
 ldi pdir_c,11111111b
 ldi popt_c,00000000b
 ldi port_c,00000000b ; porta C come uscita OC
 ldi adcr,0  ;DISABLE A/D INTERRUPT
 ldi tscr,0  ;DISABLE TIMER INTERRUPT
 ldi ior,0  ;DISABLE ALL INTERRUPT
 reti  ;RIPRISTINA I FLAG PRINCIPALI
 jp main ;SALTA AL PROGRAMMA PRINCIPALE

La direttiva .org specifica l'indirizzo di partenza del programma all'interno della ROM/EPROM del micro a va modificata a seconda della dimensione della memoria del micro usato. Quando il micro ST6 viene resettato o viene alimentato, il programma salta automaticamente all'etichetta "inizio" per cui le successive istruzioni servono ad inizializzare il microprocessore. Vengono definite le configurazioni delle porte di I/O in funzione dell'uso che poi dovrete farne all'interno del programma. Andate alla pagina "Porte di I/O" per maggiori informazioni. Le successive istruzioni servono a disabilitare tutti gli interrupt. L'istruzione "jp main" serve poi per saltare al programma principale.


Subroutine di interrupt

;**********************************************************************
;* SUBROUTINE DI INTERRUPT *
;**********************************************************************
ad_int   ;INTERRUPT DEL CONVERTITORE A/D
 reti
tim_int ;INTERRUPT DEL TIMER
 reti
BC_int ;INTERRUPT DELLE PORTE A e B
 reti
A_int ;INTERRUPT DELLA PORTA A
 reti
nmi_int ;INTERRUPT NON MASCHERABILE
 reti

Quando si verifica un interrupt durante l'esecuzione del programma, il micro salta ad una di queste subroutine in funzione del tipo di interrupt. Notate che tutte queste subroutine devono terminare con l'istruzione "reti".


Subroutine

;********************************************************************
;* SUBROUTINE *
;********************************************************************
; ESEMPIO
clock ; subroutine CLOCK
 " " "   ; ISTRUZIONI DELLA SUBROUTINE
 " " "
 " " "
 ret ; esce dalla subroutine

Le subroutine sono dei pezzi di programma che vengono richiamati dal programma principale o da altre subroutine tramite l'istruzione "call". Tutte le subroutine devono sempre iniziare con una etichetta (esempio "clock") e terminare con l'istruzione "ret". E' bene suddidere tutto il programma in subroutine, ognuna con una specifica funzione, in modo da rendere piu' facile la lettura e la correzione del programma e permettendo di riutilizzare alcune parti del programma anche in altre future applicazioni. Inoltre e' consigliabile inserire all'interno delle subroutine delle parti di programma che devono essere richiamate frequentemente durante il funzionamento in modo da non riscrivere piu' volte le stesse istruzioni.


Programma principale

;*******************************************************************
;* PROGRAMMA PRINCIPALE *
;*******************************************************************
main  ; INIZIO DEL PROGRAMMA PRINCIPALE
 ldi wdog,0feh  ;RICARICA IL WATCH DOG
 call clock  ;RICHIAMA LA SUBROUTINE 'clock' (ESEMPIO)
; ...  ;ALTRE ISTRUZIONI
; ...  ; " " "

Questo e' il programma principale che deve iniziare sempre con l'etichetta "main".


Vettori di interrupt

;*********************************************************************
;* VETTORI DI INTERRUPTS *
;*********************************************************************
; Questa parte deve essere riportata alla fine del MAIN e prima della
; istruzione finale .END .
; Queste istruzioni non dovranno essere modificate.
 .org 0ff0h
 jp ad_int ;INTERRUPT DEL CONV. A/D vector #4
 jp tim_int ;INTERRUPT DEL TIMER vector #3
 jp BC_int ;INTERRUPT PORTE A e B vector #2
 jp A_int ;INTERRUPT PORTA A vector #1
 .org 0ffch
 jp nmi_int ;INTERRUPT NON MASCHERABILE vector #0
 jp inizio ;INTERRUZIONE PER IL SETTAGGIO INIZIALE

Queste istruzioni vanno inserire alla fine del programma MAIN per definire tutti i vettori di interrupt. In pratica queste righe specificano a quali etichette il micro deve saltare in corrispondenza di un interrupt. Notate la presenza dell'etichetta "inizio" che corrisponde al vettore di RESET (quando il micro viene resettato o alimentato salta a "inizio").




Fine del programma

 .end ; Termine del programma

La direttiva .end specifica la fine del programma, per cui questa e' sempre l'ultima riga da inserire.

Formato delle istruzioni

 

Alcune note su come va scritta una tipica riga di un programma per micro ST6.

1 CAMPO
 |___
 | ETICHETTA; massimo 8 caratteri. Deve iniziare sempre con una
 | lettera e deve partire dalla PRIMA COLONNA. Per passare
 | al campo successivo e' preferibile usare il tasto TABULAZIONE.
 2 CAMPO
 |______
 | ISTRUZIONI; sono le istruzioni da far eseguire al
 | micro.
 | Per passare al campo successivo usare il
 | tasto TABULATORE.
 3 CAMPO
 |____
 | OPERANDI; sono gli operandi delle
 | istruzioni.
 4 CAMPO
 |____
 | COMMENTI; non e' obbligatorio
 | posizionarli proprio in questa
 | posizione, ma in tal modo 
| consentono di spiegare
 | il significato delle varie
 | operazioni.


Esempio di una riga con etichetta e commento:

pippo ldi wdog,0ffh ; RICARICA IL WATCH DOG

In questa riga:
pippo e' l'etichetta
ldi e' l'istruzione
wdog,0ffh e' l'operando
; RICARICA IL WATCH DOG e' il commento


Se la riga non ha etichetta, e' necessario comunque lasciare lo spazio vuoto usando il tasto TAB:

 ldi wdog,0ffh ; RICARICA IL WATCH DOG

L'etichetta puo' anche essere scritta da sola, senza nessuna istruzione:

pippo 
 ldi wdog,0ffh ; RICARICA IL WATCH DOG

Assemblare un programma

 

I programmi scritti per i micro ST6 vengono salvati su disco in files di testo con estensione .ASM. Questi programmi non possono essere inseriti direttamente nel micro, in quanto necessario ASSEMBLARLI, cio trasformarli in un file .HEX contentente tutte le istruzioni in formato esadecimale che possono essere lette dal programmatore e inserite nella memoria programma dell'ST6.
Per questa conversione, necessario usare un programma fornito dalla ST che si chiama AST6.EXE, funzionante sotto DOS.

Esempio:

Se abbiamo un file CLOCK.ASM contentente il nostro programma, per assemblarlo sufficiente aprire una finestra di MS-DOS e scrivere:

AST6 CLOCK.ASM


Se il programma non contiene errori, l'AST6 crea il files CLOCK.HEX da inserire nel micro. Ovviamente in questo esempio sottointeso che ci troviamo nella directory in cui presente il file AST6.EXE e che il programma CLOCK.ASM si trovi nella stessa directory. Inoltre viene automaticamente creato anche un file CLOCK.DSD, contenente le informazioni di debug che vengono usate durante l'eventuale simulazione del programma.

Se l'assemblatore non trova errori e completa l'operazione, ci visualizza questo messaggio:

ST6 MACRO-ASSEMBLER version 4.20 - September 1994
*** SUCCESS ***
Execution time: 0 second(s)

Altrimenti, in caso di errore, ci segnala il tipo di errore e la riga del programma in cui si trova:

ST6 MACRO-ASSEMBLER version 4.20 - September 1994
Error files\std.asm 155: (11) 5-bit displacement overflow
Execution time: 0 second(s)
One error detected
No object created

In questo esempio c' errore di overflow su una istruzione di salto alla riga 155.


Altre funzioni

In realt l'AST6 un programma potente che dispone di molte altre funzioni attivabili sempre dalla linea di comando. Riprendendo come esempio il file CLOCK.ASM, ecco un elenco delle funzioni disponibili con una breve descrizione:

AST6 -L CLOCK.ASM

Crea anche un file .LIS contenente tutto il listato del programma

AST6 -E CLOCK.ASM

Crea un file .ERR contentente la descrizione degli errori eventualmente presenti nel programma

AST6 -X CLOCK.ASM

Crea un file .X contenente l'elenco delle etichette e delle variabili del programma con indicazione delle righe in cui queste vengono usate.

AST6 -M -L CLOCK.ASM

Genera una mappa di memoria del programma e la colloca alla fine del file .LIS. Infatti l'opzione -M va usata sempre insieme a -L. La mappa di memoria indica il numero di locazioni usate nelle varie pagine di memoria programma.

AST6 -S CLOCK.ASM

Genera un file .SYM contenente l'elenco delle etichette e delle costanti utilizzate nel programma. Anche questo file utile principalmente durante la simulazione del programma

AST6 -O CLOCK.ASM

Genera un programma rilocabile in formato -OBJ, e non genera i files .HEX e .DSD. Questi files .OBJ possono essere incorporati in altri programmi usando il linker LST6.EXE creando un unico programma eseguibile.

AST6 -Dxx CLOCK.ASM

Quando si compila un programma, i bytes di memora non usati vengono riempiti con un valore 0FFh. L'istruzione -D seguita da un valore numerico, permette di riempire queste locazioni inutilizzate con un determinato valore esadecimale (xx).

AST6 -F CLOCK.ASM

Usando questo comando, in presenza di errori nel programma, nel messaggio di errore viene specificato l'intero perrcorso (path) nel quale si trova il programma ASM.

AST6 -Wx CLOCK.ASM

Gli errori di un programma si dividono in due tipi: WARNING (meno gravi, che in molti casi non compromettono il funzionamento del programma) e ERROR (piu' gravi che non permettono il funzionamento del programma). Il comando W seguito da un numero da 0 a 2 specifica quale tipo di WARNING deve essere segnalato dall'AST6.


Set di istruzioni dei micro ST6

 


ADD

ADDI

AND

ANDI

CALL

CLR

COM

CP

CPI

DEC

INC

JP

JRC

JRNC

JRNZ

JRR

JRS

JRZ

LD

LDI

NON

RES

RET

RETI

RLC

SET

SLA

STOP

SUB

SUBI

WAIT


ADD -- somma

Il contenuto di una variabile viene sommato al contenuto dell'accumulaore ed il risultato e' memorizzato nell'accumulatore. Formati possibili:

        ADD A,A

        ADD A,X

        ADD A,Y

        ADD A,V

        ADD A,W

        ADD A,(X)

        ADD A,(Y)

        ADD A,rr

A = registro accumulatore
X,Y,V,W = registri del micro
rr = indirizzo della variabile (1 byte)
Cicli macchina = 4
Il flag Z e' settato se il risultato e' 0, resettato se diverso da 0
Il flag C e' settato se l'operazione da un riporto, cioe' se e' maggiore di 255 (FFh)



ADDI -- somma immediata

Un numero viene sommato al contenuto dell'accumulatore ed il risultato e' memorizzato nell'accumulatore. Formati possibili:

  • ADDI A,nn

A = registro accumulatore
nn = numero da 0 a 255 (FFh)
Cicli macchina = 4
Il flag Z e' settato se il risultato e' 0, resettato se diverso da 0
Il flag C e' settato se l'operazione da un riporto, cioe' se e' maggiore di 255 (FFh)


AND -- funzione logica AND

Funzione logica AND tra l'accumulatore ed una variabile. Il risultato e' memorizzato nell'accumulatore. Formati possibili:

  • AND A,A
  • AND A,X
  • AND A,Y
  • AND A,V
  • AND A,W
  • AND A,(X)
  • AND A,(Y)
  • AND A,rr

A = registro accumulatore
X,Y,V,W = registri del micro
rr = indirizzo della variabile (1 byte)
Cicli macchina = 4
Il flag Z e' settato se il risultato e' 0, resettato se diverso da 0
Il flag C non e' influenzato





ANDI -- funzione logica AND immediata

Funzione logica AND tra l'accumulatore ed un numero. Il risultato e' memorizzato nell'accumulatore. Formati possibili:

  • ANDI A,nn

A = registro accumulatore
nn = numero da 0 a 255 (FFh)
Cicli macchina = 4
Il flag Z e' settato se il risultato e' 0, resettato se diverso da 0
Il flag C non e' influenzato


CALL -- chiama subroutine

Richiama una subroutine. Formati possibili:

  • CALL nomesub

nomesub = etichetta della subroutine da eseguire
Cicli macchina = 4
I flag Z e C non sono influenzati


CLR -- azzera byte

Resetta l'accumulatore, un registro o una variabile. Formati possibili:

  • CLR A
  • CLR X
  • CLR Y
  • CLR V
  • CLR W
  • CLR rr

A = registro accumulatore
X,Y,V,W = registri del micro
rr = indirizzo della variabile (1 byte)
Cicli macchina = 4
Il flag Z e' settato
Il flag C e' resettato


COM -- complemento byte

Calcola il complemento del contenuto dell'accumulatore e memorizza il risultato nell'accumulatore. Formati possibili:

  • COM A

A = registro accumulatore
Cicli macchina = 4
Il flag Z e' settato se il risultato e' 0, resettato se diverso da 0
Il flag C e' settato se prima della funzione COM il bit 7 di A e' 1



CP -- compara

Compara il contenuto di un registro o di una variabile con l'accumulatore. Formati possibili:

  • CP A,A
  • CP A,X
  • CP A,Y
  • CP A,V
  • CP A,W
  • CP A,(X)
  • CP A,(Y)
  • CP A,rr

A = registro accumulatore
X,Y,V,W = registri del micro
rr = indirizzo della variabile (1 byte)
Cicli macchina = 4
Il flag Z e' settato se i numeri sono uguali, resettato se diversi
Il flag C e' settato se l'accumulatore e' minore del registro o della variabile, resettato se maggiore o uguale


CPI -- compara immediato

Compara il contenuto dell'accumulatore con un numero. Formati possibili:

  • CPI A,nn

A = registro accumulatore
nn = numero da 0 a 255 (FFh)
Cicli macchina = 4
Il flag Z e' settato se i numeri sono uguali, resettato se diversi
Il flag C e' settato se l'accumulatore e' minore del numero, resettato se maggiore o uguale


DEC -- decrementa

Decrementa di 1 il contenuto dell'accumulatore, di un registro o di una variabile. Formati possibili:

  • DEC A
  • DEC X
  • DEC Y
  • DEC V
  • DEC W
  • DEC (X)
  • DEC (Y)
  • DEC rr

A = registro accumulatore
X,Y,V,W = registri del micro
rr = indirizzo della variabile (1 byte)
Cicli macchina = 4
Il flag Z e' settato se il risultato e' 0, resettato se diverso da 0
Il flag C non e' influenzato


INC -- incrementa

Incrementa di 1 il contenuto dell'accumulatore, di un registro o di una variabile. Formati possibili:

  • INC A
  • INC X
  • INC Y
  • INC V
  • INC W
  • INC (X)
  • INC (Y)
  • INC rr

A = registro accumulatore
X,Y,V,W = registri del micro
rr = indirizzo della variabile (1 byte)
Cicli macchina = 4
Il flag Z e' settato se il risultato e' 0, resettato se diverso da 0
Il flag C non e' influenzato


JP -- salta

Effettua un salto incondizionato ad una etichetta. Formati possibili:

  • JP abc

abc = etichetta
Cicli macchina = 4
I flag Z e C non sono influenzati


JRC -- salta se c' riporto

Salta ad una etichetta se il Flag Carry e' settato. Formati possibili:

  • JRC e

e = numero che rappresenta la distanza in byte dell'etichetta di salto rispetto all'istruzione JRC
Cicli macchina = 2
I flag Z e C non sono influenzati

JRNC -- salta se non c' riporto

Salta ad una etichetta se il Flag Carry e' resettato. Formati possibili:

  • JRNC e

e = numero che rappresenta la distanza in byte dell'etichetta di salto rispetto all'istruzione JRNC
Cicli macchina = 2
I flag Z e C non sono influenzati


JRNZ -- salta se l'operazione non d 0

Salta ad una etichetta se il Flag Zero e' resettato. Formati possibili:

  • JRNZ e

e = numero che rappresenta la distanza in byte dell'etichetta di salto rispetto all'istruzione JRNZ
Cicli macchina = 2
I flag Z e C non sono influenzati


JRR -- salta se bit 0

Salta ad una etichetta se un determinato bit di una variabile e' resettato. Formati possibili:

  • JRR b,rr,ee

b = numero del bit da testare (da 0 a 7)
rr = byte di indirizzo della variabile
ee = numero che rappresenta la distanza in byte dell'etichetta di salto rispetto all'istruzione JRR
Cicli macchina = 5
Il flag Z non e' influenzato Il flag C contiene il valore del bit testato


JRS -- salta se bit 1

Salta ad una etichetta se un determinato bit di una variabile e' settato. Formati possibili:

  • JRS b,rr,ee

b = numero del bit da testare (da 0 a 7)
rr = byte di indirizzo della variabile
ee = numero che rappresenta la distanza in byte dell'etichetta di salto rispetto all'istruzione JRS
Cicli macchina = 5
Il flag Z non e' influenzato Il flag C contiene il valore del bit testato


JRZ -- salta se l'operazione d 0

Salta ad una etichetta se il Flag Zero e' settato. Formati possibili:

  • JRZ e

e = numero che rappresenta la distanza in byte dell'etichetta di salto rispetto all'istruzione JRZ
Cicli macchina = 2
I flag Z e C non sono influenzati


LD -- carica registro

Serve per caricare il valore contenuto in una variabile, in un registro o nell'accumulatore. Per questa istruzione va sempre usato l'accumulatore. Formati possibili:

  • LD A,X
  • LD A,Y
  • LD A,V
  • LD A,W
  • LD X,A
  • LD Y,A
  • LD V,A
  • LD W,A
  • LD A,(X)
  • LD A,(Y)
  • LD (X),A
  • LD (Y),A
  • LD A,rr
  • LD rr,A

A = registro accumulatore
X,Y,V,W = registri del micro
rr = indirizzo della variabile (1 byte)
Cicli macchina = 4
Il flag Z e' settato se il risultato e' 0, resettato se diverso da 0
Il flag C non e' influenzato


LDI -- carica registro immediato

Serve per caricare un numero in una variabile, in un registro o nell'accumulatore. Formati possibili:

  • LDI A,nn
  • LDI X,nn
  • LDI Y,nn
  • LDI V,nn
  • LDI W,nn
  • LDI rr,nn

A = registro accumulatore
X,Y,V,W = registri del micro
rr = indirizzo della variabile (1 byte)
nn = numero di 1 byte
Cicli macchina = 4
Il flag Z e' settato se il risultato e' 0, resettato se diverso da 0
Il flag C non e' influenzato


NOP -- nessuna operazione

Esegue 2 cicli macchina a vuoto. Viene usata per creare dei piccoli ritardi. Formati possibili:

  • NOP

Cicli macchina = 2
I flag Z e C non sono influenzati


RES -- resetta bit

Resetta uno degli 8 bit di una variabile o dell'accumulatore. Formati possibili:

  • RES b,A
  • RES b,rr

A = registro accumulatore
rr = indirizzo della variabile (1 byte)
b = numero del bit da resettare (da 0 a 7)
Cicli macchina = 4
I flag Z e C non sono influenzati


RET -- ritorna da una subroutine

Esce dalla subroutine e ritorna al punto della chiamata CALL. Formati possibili:

  • RET

I flag Z e C non sono influenzati

RETI -- ritorna da un interrupt

Esce dalla subroutine di interrupt e ritorna al punto precedente all'evento di interrupt. Formati possibili:

  • RETI

I flag Z e C vengono riportati alla condizione in cui si trovavano prima dell'interrupt


RLC -- ruota a sinistra con riporto

Ruota a sinistra i bit dell'accumulatore. Trasferisce il bit 7 nel Carry, mentre il contenuto precedente del carry passa nel bit 0 dell'accumulatore. Formati possibili:

  • RLC A

A = registro accumulatore
Clicli macchina = 4
Il flag Z e' settato se il risultato e' 0, resettato se diverso da 0
Il flag C riporta il valore del bit 7


SET -- setta bit

Setta uno degli 8 bit di una variabile o dell'accumulatore. Formati possibili:

  • SET b,A
  • SET b,rr

A = registro accumulatore
rr = indirizzo della variabile (1 byte)
b = numero del bit da settare (da 0 a 7)
Cicli macchina = 4
I flag Z e C non sono influenzati


SLA -- ruota a sinistra senza riporto

Ruota a sinistra i bit dell'accumulatore. Trasferisce il bit 7 nel Carry cancellando il valore precedente. Equivale a una moltiplicazione per 2. Formati possibili:

  • SLA A

A = registro accumulatore
Clicli macchina = 4
Il flag Z e' settato se il risultato e' 0, resettato se diverso da 0
Il flag C riporta il valore del bit 7




STOP -- blocca il funzionamento del micro

Blocca l'oscillatore di clock mettendo in standby tutto il microprocessore. Formati possibili:

  • STOP

Clicli macchina = 2
I flag Z e C non sono influenzati


SUB -- sottrazione

Il contenuto di una variabile viene sottratto al contenuto dell'accumulatore ed il risultato e' memorizzato nell'accumulatore. Formati possibili:

  • SUB A,A
  • SUB A,X
  • SUB A,Y
  • SUB A,V
  • SUB A,W
  • SUB A,(X)
  • SUB A,(Y)
  • SUB A,rr

A = registro accumulatore
X,Y,V,W = registri del micro
rr = indirizzo della variabile (1 byte)
Cicli macchina = 4
Il flag Z e' settato se il risultato e' 0, resettato se diverso da 0
Il flag C e' settato se il contenuto dell'accumulatore e' minore della variabile o del registro, resettato se maggiore o uguale.


SUBI -- sottrazione immediata

Un numero viene sottratto al contenuto dell'accumulatore ed il risultato e' memorizzato nell'accumulatore. Formati possibili:

  • SUBI A,nn

A = registro accumulatore
nn = numero di 1 byte
Cicli macchina = 4
Il flag Z e' settato se il risultato e' 0, resettato se diverso da 0
Il flag C e' settato se il contenuto dell'accumulatore e' minore del numero, resettato se maggiore o uguale.


WAIT -- stato di attesa

Mette in standby il microprocessore, ma l'oscillatore di clock rimane attivo. Formati possibili:

  • WAIT

Clicli macchina = 2
I flag Z e C non sono influenzati

Un piccolo programma di esempio (comando LED)

 

Viene qui descritto un semplicissimo programma che permette di accendere un LED collegato alla porta PB0 del micro quando viene premuto un pulsante collegato alla porta PA0 del micro. E' possibile prelevare il programma di esempio alla pagina http://www.geocities.com/SiliconValley/Way/7521/st6/files/testled1.zip


Descrizione del programma

Analizziamo le parti principali del programma TESTLED1

 .title "COMANDOLED"
 .vers "ST62E20" ; Funziona su qualsiasi ST6

Qui viene solo definito il nome e il tipo di micro usato.


 .input "st62reg.inc"

Definizione di tutti i registri interni del micro tramite un file esterno chiamato st62reg.inc


 copia_b .def 084h ;COPIA DEL REGISTRO DATI PORTA B

Viene usata solo una variabile chiamata copia_b che corrisponde alla cella di memoria RAM con indirizzo 084h. Questa variabile serve per comandare correttamente le uscite senza usare le istruzioni SET e RES direttamente sui registri delle porte (port_b).


 .org 0880h 
inizio 
 ldi wdog,0ffh ; RICARICA IL WATCH DOG
 ldi pdir_a,00000000b ;PA0 E' UN INGRESSO PULL-UP
 ldi popt_a,00000000b ;LE LINEE NON USATE SONO INGRESSI
 ldi port_a,00000000b
 ldi pdir_b,00000001b ;PB0 E' UN'USCITA PUSH-PULL
 ldi popt_b,00000001b 
 ldi port_b,00000000b
 ldi pdir_c,00000000b ;NON USATA
 ldi popt_c,00000000b
 ldi port_c,00000000b
 ldi adcr,0  ;DISABLE A/D INTERRUPT
 ldi tscr,0  ;DISABLE TIMER INTERRUPT
 ldi ior,0  ;DISABLE ALL INTERRUPT
 reti  ;RIPRISTINA I FLAG PRINCIPALI
 jp main ;SALTA AL PROGRAMMA PRINCIPALE

Imposta le porte di I/O (PA0 ingresso e PB0 uscita) e disabilita tutti gli interrupt.


ad_int   ;INTERRUPT DEL CONVERTITORE A/D
 reti
tim_int ;INTERRUPT DEL TIMER
 reti
BC_int ;INTERRUPT DELLE PORTE A e B
 reti
A_int ;INTERRUPT DELLA PORTA A
 reti
nmi_int ;INTERRUPT NON MASCHERABILE
 reti

Questo programma non usa alcun interrupt, per cui le routine di interrupt non sono presenti.


led
 jrr 0,port_a,ledon ; se PA0=0 allora tasto premuto
 ; salta a ledon e accendi led
ledoff
 res 0,copia_b ; resetta bit 0 di copia_b 
 ld a,copia_b ; trasferisce copia_b in A
 ld port_b,a ; trasferisce A in port_b
 ; e comanda led
 jp fine ; esce dalla routine
ledon 
 set 0,copia_b ; setta bit 0 di copia_b 
 ld a,copia_b ; trasferisce copia_b in A
 ld port_b,a ; trasferisce A in port_b
 ; e comanda led
fine
 ret ; esce dalla routine

Questa e' la subroutine pricipale che effettua tutte le funzioni del programma.

Analizziamo ora le singole righe di questa routine.

led

Questa e' l'etichetta che indentifica l'inizio della routine.

 jrr 0,port_a,ledon ; se PA0=0 allora tasto premuto
 ; salta a ledon e accendi led

L'istruzione jrr (jump relative if reset) controlla lo stato della linea PA0 cioe' del BIT 0 del registo port_a e salta all'etichetta "ledon" solo se questo bit e' 0, cioe' se PA0 e' a massa. Questa condizione corrisponde alla pressione del tasto. Se invece il tasto non e' premuto e quindi PA0 e' a livello 1 questa istruzione non compie nessuna azione e quindi il programma prosegue con la prossima riga (etichetta "ledoff").

ledoff
 res 0,copia_b ; resetta bit 0 di copia_b 
 ld a,copia_b ; trasferisce copia_b in A
 ld port_b,a ; trasferisce A in port_b
 ; e comanda led
 jp fine ; esce dalla routine

Queste righe servono per spegnere il led. La prima riga resetta, cioe' pone a livello logico 0 il bit 0 (LSB) della variabile "copia_b" che come sappiamo e' la copia del registro port_b.
La seconda riga trasferisce il contenuto della variabile "copia_b" nell'accumulatore A del micro usando l'istruzione ld (load).
La successiva istruzione "ld" trasferisce il contenuto dell'accumulatore (che e' uguale a copia_b) nel registro dati della porta b (port_b) andando quindi a spegnere il led collegato a PB0.
L'istruzione "jp" serve per saltare direttamente all'etichetta "fine" per cui il micro non eseguira' le istruzioni contenute nelle righe successive, ma saltera' direttamente all'etichetta specificata.

ledon 
 set 0,copia_b ; setta bit 0 di copia_b 
 ld a,copia_b ; trasferisce copia_b in A
 ld port_b,a ; trasferisce A in port_b
 ; e comanda led

Queste istruzioni sono identiche a quelle commentate qui sopra. L'unica cosa che cambia e' la prima riga dove c'e' una istruzione "set" al posto dell'istruzione "res". Questa istruzione pone a livello logico 1 il bit 0 della variabile copia_b. Le successive 2 rige come sappiamo servono per trasferire il contenuto della variabile copia_b nel registro della porta b (port_b) andando in questo caso ad accendere il LED. Notate che non si possono sostituire le ultime 2 righe con una singola istruzione del tipo:

 ld port_b,copia_b ; trasferisce copia_b in port_b
 ; e comanda led

In teoria potrebbe funzionare, ma in realta' questo e' un grave errore, perche' il trasferimento di dati tra variabili deve avvenire sempre passando per l'accumulatore A. Assemblando una istruzione di questo tipo l'assemblatore segnala un errore.

fine
 ret ; esce dalla routine

L'istruzione "ret" permette di uscire dalla subroutine "led" e di tornare al programma principale, cioe' al punto in cui questa subroutine e' stata richiamata tramite il comando "call".


main  ;IDENTIFICA L'INIZIO DEL PROGRAMMA PRINCIPALE
 ldi wdog,0feh ;RICARICA IL WATCH DOG
 call led ; RICHIAMA SUBROUTINE LED
 jp main ; ripete a ciclo continuo

Il programma principale in questo caso e' semplicissimo, in quanto tutte le funzioni del programma si trovano nella subroutine appena vista.
La prima riga ricarica il WATCH DOG. Si tratta di un timer particolare che serve per resettare il micro nel caso in cui il programma si blocca per qualche disturbo esterno. Questa riga deve essree inserita frequentemente all'interno del programma per evitare un reset indesiderato del micro. In pratica e' consigliabile metterla ogni 20-30 istruzioni del programma.
La riga successiva come sappiamo serve a richiamare la subroutine "led". In corrispondenza di questa istruzione il micro salta all'etichetta "led" ed esegue tutte le istruzioni della subroutine.
Quando all'interno della subroutine il micro trova l'istruzione "ret", ritorna al programma principale eseguendo l'istruzione successiva a "call".
In questo caso l'istruzione successiva e' "jp main" che salta nuovamente all'etichetta main e riesegue tutto il ciclo in modo continuo.


.org 0ff0h
 jp ad_int ;INTERRUPT DEL CONV. A/D vector #4
 jp tim_int ;INTERRUPT DEL TIMER vector #3
 jp BC_int ;INTERRUPT PORTE A e B vector #2
 jp A_int ;INTERRUPT PORTA A vector #1
 .org 0ffch
 jp nmi_int ;INTERRUPT NON MASCHERABILE vector #0
 jp inizio ;INTERRUZIONE PER IL SETTAGGIO INIZIALE

Queste sono righe standard per i micro ST621x e 2x e non vanno mai modificate.


 .end ; Termine del programma

Questa riga indentifica la fine del programma.







Privacy

Articolo informazione


Hits: 1187
Apprezzato: scheda appunto

Commentare questo articolo:

Non sei registrato
Devi essere registrato per commentare

ISCRIVITI

E 'stato utile?



Copiare il codice

nella pagina web del tuo sito.


Copyright InfTub.com 2019