Ragazzi ho bisogno di aiutoapete per caso come si svolge questo programma?scrivere un programma in assembly 68000 che sostituisce ad ogni elemento il cui valore è 100 il valore 0 e restituisce il numero di elementi azzerati.Lo scambio di parametri è tramite stack.
Grazie mille
Sto un po in crisi,aspetto una risposta

hai controllato gli esercizi della prof?? io non ricordo come si fa...avendolo fatto troppo tempo addietro...ma quegli esercizi mi pare che contenessero un esempio del genere....

no non ci sono negli esercizi della prof..questo esercizio l ho preso da una prova d esame ke uscì parecchio tempo fa

Mi sembra fattibile, proverò a risolvertelo appena ho tempo. Immagino che i parametri su cui operare siano quelli di un vettore di valori in ingresso, giusto?

Mi pare di capire che si tratti di fare un ciclo di loop con un if all'interno per effettuare le comparazioni e ricavare il vettore d'uscita (usando gli stessi elementi di quello d'ingresso o il valore 0 se l'elemento esaminato è 100) ed eventualmente incrementare l'accumulatore da cui ottenere il numero di elementi azzerati.

non si potrebbe usare una and??no eh?

Potresti postare l'intera traccia? L'unica cosa che non mi è chiara è se si riferisca all'uso di una subroutine che faccia tutto o se debba essere utilizzata all'interno del ciclo di loop.

La prova in questione era stata data da Casola o da un altro docente?

la traccia è proprio quella che ho scritto..nè una parola in meno nè una in +...mi dissero che era di Casola anche se non mi sembra che lei da questi tipi di esercizi allo scritto no?

Veramente sì, allo scritto c'è sempre un esercizio assembly e bisogna spesso trattare dei vettori di valori su cui effettuare comparazioni, usando un passaggio di parametri tramite stack. In genere si deve passare come input nello stack la dimensione del vettore e il suo indirizzo di memoria, mentre in uscita si ottiene un valore riguardante i vettori (ad esempio quante volte i valori nella stessa posizione di due vettori sono uguali).

In questo caso la traccia mi sembra un pò ambigua e insolita, perchè facendo tutto nella subroutine bisogna andare a scrivere il vettore d'uscita direttamente sulla memoria (semplicemente si dà in input anche l'indirizzo del vettore d'uscita), in ogni caso questo procedimento che ho usato mi sembra abbastanza valido.
Lo svolgimento tipico coi costrutti del tipo while e if è di sicuro quello che ho usato.

Ho aggiunto dei commenti per renderlo più chiaro.
Ho usato l'istruzione _link_ perchè ci sono abituato, ma non è quasi mai richiesta e si può usare anche direttamente il "_base_d addressing" tramite SP.

Visto che visualizzata qui sul forum esce un pò sformata per via delle andate a capo, la metto anche a questo _link_

https://www.dropbox.com/s/7wltfosbbibuhio/Programma%20assembly%20per%20CdP.txt


ORG $8000
START ADDA.L #-2,SP Riservo spazio per l'uscita RES sullo stack
MOVE.L #B,-(SP) Sposto l'indirizzo dove inserire il vettore B con un push nello stack
MOVE.L #A,-(SP) Sposto l'indirizzo del vettore A con un push nello stack
MOVE.W DIM,-(SP) Sposto la dimensione del vettore con un push nello stack
JSR SUBR Chiamata al sottoprogramma
ADDA.L #10,SP Sommo 10 a SP per farlo puntare all'indirizzo sullo stack che ora contiene il valore di RES
MOVE.W (SP)+,RES

FINE JMP FINE Loop finale per visualizzare i dati sul simulatore


* Sottoprogramma

ORG $8100
SUBR _link_ A6,#0 Uso A6 come _frame_ Pointer
MOVE.W DIMOFF(A6),D0 Carico la dimensione del vettore in D0
MOVE.L AOFF(A6),A0 Carico l'indirizzo del vettore A in A0
MOVE.L BOFF(A6),A1 Carico l'indirizzo del vettore B in A1

SUBQ.W #1,D0 Sottraggo 1 a D0, in modo da usarlo poi come contatore con l'istruzione DBRA

CLR.w D1 Azzero D1 per usarlo come accumulatore del risultato RES (inteso come il numero di 100 trovati nel vettore A)


LOOP MOVE.B (A0),D2 Sposto l'elemento i-esimo del vettore A in D2
CMP.B #100,D2 Effettuo la comparazione
BNE NOTF Se l'elemento analizzato non è 100, passa all'istruzione NOTF

ADDQ.W #1,D1 Incremento l'accumulatore D1, visto che è stato trovato un 100
MOVE.B #0,(A1)+ Sposto il valore 0 nel vettore B e uso l'autoincremento per puntare sul byte successivo
ADDA.L #1,A0 Incremento A0 di 1 per farlo puntare all'elemento successivo di A

JMP ENDCYC Salto incondizionato a ENDCYC

NOTF MOVE.B (A0)+,(A1)+ Non è stato trovato 100, quindi copio il valore di A nel vettore B e uso gli autoincrementi per puntare ai byte successivi

ENDCYC DBRA D0,LOOP Finchè D0 non diventa -1 (cioè finchè non finiscono gli elementi del vettore A), si ripete il ciclo tornando all'istruzione LOOP

MOVE.W D1,RESOFF(A6) Sposto il numero di volte in cui è stato trovato 100 nello spazio lasciato appositamente libero sullo stack per l'uscita RES

UNLK A6

RTS


*Offset della subroutine

DIMOFF EQU 8
AOFF EQU 10
BOFF EQU 14
RESOFF EQU 18


* Area dati

ORG $8200
A DC.B 1,2,100,3,100,4 Vettore d'ingresso A
DIM DC.W 6 Dimensione del vettore d'ingresso A


ORG $8210
RES DS.W 1 Spazio per il risultato RES (il numero di volte in cui è stato trovato 100)
B DS.B 6 Spazio per il vettore d'uscita B

END START

Gentilissimo,grazie...

scusate ancora il disturbo...per chi deve fare calcolatori da 9 crediti c'è anche la parte relativa alle macchine sequenziali:mi potete spiegare come si ricava lo schema di un flip flop(ad esempio R-S) edge triggered?
sulle slides della prof sta una tabella con tutti stati all interno..la versione latch l ho capita ma quella rdge triggered no...mi aiutate?
grazie

Devi semplicemente considerare il funzionamento pratico del flip flop e distinguere gli stati indicati come Q00, Q01, Q11, Q10, ricordando che il cambiamento di Q può avvenire solo col fronte attivo (negli esempi è il passaggio di A da 0 a 1).

Q00 vuol dire che il Q memorizzato è 0 e rimarrà tale anche al prossimo fronte attivo (negli esempi sui lucidi è il fronte di salita) del clock.

Q01 vuol dire che il Q memorizzato è ancora 0, ma che potrà andare ad 1 col prossimo fronte attivo del clock.

Q11 vuol dire che il Q memorizzato è 1 e che rimarrà ancora 1 anche col prossimo fronte attivo del clock

Q10 vuol dire che il Q memorizzato è 1 e che potrà andare a 0 col prossimo fronte attivo del clock.


Nel caso del flip flop RS: consideriamo di essere allo stato Q00 con A=0, cioè il Q memorizzato è 0 e rimarrà tale anche all'arrivo del fronte attivo. Se in ingresso abbiamo RS=00 (cioè sia S che R sono bassi), il funzionamento del FF RS prevede di mantenere lo stato precedente, quindi è evidente che lo stato deve permanere a Q00; altrettanto accade se RS=10, visto che appunto reset è alto.
Se invece RS=01, cioè se Set diventa alto, allora si passa da Q00 a Q01, cioè il flip flop si predispone a passare alla memorizzazione di 1. Se a questo punto, si mantiene ancora RS=01 e A passa da 0 a 1, si passa allo stato Q11, cioè si passa a Q=1 in uscita. In tutti gli altri casi, invece si torna a Q00, perchè non si ha RS=01 prima del fronte attivo del clock e quindi lo stato memorizzato deve rimanere 0.

Il caso opposto del passaggio da Q=1 a Q=0 è speculare, si parte da Q11 e si passa per Q10 mantenendo RS=01 (cioè reset diventa alto), quindi, sempre mantenendo RS=01, col passaggio al fronte attivo del clock si passa a Q00.

sulle slides tutto questo non sta scritto..dove posso studiarlo?

Io controllai solo le audio-lezioni di Fadini su Federica (sono proprio realizzate per quelle slide). Non sono proprio esaurientissime in realtà e alla fine devi comunque ricavare il funzionamento delle tabelle da solo, ma almeno chiariscono quella questione sugli stati Q00,Q01, ecc.

http://www.federica.unina.it/ingegneria/reti-logiche/i-flip-flop/

capito..posso chiederti un ultimo favore dato che per l'ennesima volta l esame è andato male?
potresti spiegarmi con un esempio,passo passo l algoritmo del partizionamento che è uscito all'esame?
Grazie e scusa

all esame invece di uscire effettuare la minimizzazione con il metodo di Paul e Unger è uscito effettuare la minimizzazione con l algoritmo del partizionamento...dalle slide non capisco nulla..non è che mi faresti un esempio e me lo spiegheresti passo passo?
Grazie mille in anticipo