[C][ASM] Programmazione PIC 16F84A

[vbextreme]

no hai due banchi di memoria "RAM",0 e 1 che puoi selezionare. Quindi invece di avere un'unica RAM da 128 byte ne hai due da 64, per non dovere saltare da un banco all'altro alcuni registri del banco 0 sono copiati nel banco 1.
Il codice va solo nella flash.

[ubuntumate]

Leggo che in BANK 1 risiedono alcuni registri per modificare il comportamento della MCU,mentre in Bank 0 viene usato per i dati dell'utente (programmatore).
Ho scritto una schifezza in ASM,ma non avendo mai scritto nulla in nessun assembly non ho idea della struttura di un programma scritto in questo linguaggio.
Io ci ho buttato istruzioni a caso leggendo il datasheet.

Codice: Seleziona tutto

   MAIN CODE
list p=16F84A
    bcf	    03h,5	    ;seleziono BANK 1
    movlb   00h,85h	    ; RA0 = output
    bsf	    03h,5	    ;seleziono BANK 0
    movlb   01h,85h	    ;RA0 -> High
    end

Qual è l'equivalente ASM per PIC di

Codice: Seleziona tutto

int main(void)
{
      return EXIT_SUCCESS;
}

?
E poi perchè non mi lascia usare STATUS,RP0 etc al posto degli indirizzi in esadecimale?

[vbextreme]

devi includere l'header del Pic.
qui è spiegato bene.

Nei chip embedded la funzione main non ha return!
quel codice C diventa quindi

Codice: Seleziona tutto

main goto main

[ubuntumate]

So che con EQU potrei definire manualmente STATUS come 3 etc ma con l'INCLUDE sarebbe tutto più comodo,solo che mi dice che non può aprire il file 16F84A.INC . Ho anche cambiato maiuscolo/minuscolo ma nulla. Forse lo devo scaricare?
EDIT: va in minuscolo diversamente da quanto scritto nella guida. INCLUDE "p16f84a.inc"

[ubuntumate]

No cioè ho acceso il LED in assembly Della seria "sembrava impossibile me ce l'abbiamo fatta"
EDIT: ora lo devo far lampeggiare,ma non va ovviamente

Codice: Seleziona tutto

;-----------------------------------------------------------------------
   ; DEFINIZIONI
   ;-----------------------------------------------------------------------
              PROCESSOR       16F84a    ;clock  4 Mhz
              RADIX           DEC
              INCLUDE         "p16f84a.inc"
              __CONFIG        11101010b

   #define    Bank0   bcf STATUS,RP0
   #define    Bank1   bsf STATUS,RP0
   #define    COUNT1  0Ch
   #define    COUNT2  0Dh
   #define    COUNT3  0Eh
   ;-----------------------------------------------------------------------
   ; PROGRAMMA
   ;-----------------------------------------------------------------------
              ORG     0
              goto inizio

   ;----------INTERRUPT HANDLER (se usato)
              ORG     4

              ...                     ;qui vanno le eventuali istruzioni
              ...                     ;per la gestione degli interrupt
 

   ;----------PREDISPOSIZIONE HARDWARE

   inizio     Bank1                   ;attiva il banco 1
              clrf TRISB              ;Predispone porta B come uscite
	      clrf TRISA
	      
              Bank0                   ;attiva il banco 0
 

   ;----------CICLO PRINCIPALE DEL PROGRAMMA

   mainloop   movlw 01h
	      movwf PORTA     ;Mostra Due
	      call Delay
	      movlw 00h
	      movwf PORTA
    	      call Delay
	      goto mainloop           ;ripete il ciclo
	      
   ;-----------------------------------------------------------------------
   Delay      movlw 255
	      movwf COUNT1
   Delay_1    decfsz COUNT1
	      movlw 255
	      movwf COUNT2
   Delay_2    decfsz COUNT2
	      goto Delay_2
	      goto Delay_1
	      return
		
   END

[Claudio_F]

Nell'istruzione DECFSZ va indicata anche la destinazione (accumulatore o registro):

Codice: Seleziona tutto

DECFSZ COUNT1,F    ==      COUNT1 = COUNT1 - 1
DECFSZ COUNT1,W    ==      W = COUNT1 - 1

Non ne sono sicuro ma credo che omettendola venga per default usato W, e quindi i valori di COUNT1 e COUNT2 non cambiano mai.

Suggerimento: i loop ottenibili con un counter a 8 bit vanno da 1 a 256, dove il 256 si ottiene con il valore iniziale 0.

non ho idea della struttura di un programma scritto in questo linguaggio

Normalmente label nella prima colonna, poi opcode (tutti incolonnati tra loro), operandi, ed eventuali commenti.

- La memoria flash da 1K è quella per i programmi che gli carico col programmatore.

Si, sono 1024 indirizzi per le word di programma di 14 bit ciascuna (questa è la memoria programma dell'architettura Harvard)

- Quella da 64 byte è la RAM per le istruzioni
- Quella da 68 byte è la memoria per i dati
Per il resto vorrei capire cosa sono BANK0 e BANK1 e quando li devo selezionare quando scrivo in ASM. Infine,ma anche no,dovrei capire il funzionamento di SFR e GPR.

Questa invece è la memoria dati dell'architettura Harvard, organizzata in celle da 8 bit, che normalmente dovrebbe contenere solo dati, poi ci dovrebbe essere un ulteriore spazio di indirizzamento per le porte di input/output. Nelle MCU però, per semplificare l'hardware, l'I/O viene mappato in una parte della memoria dati. Nei PIC la parte di memoria dati in cui sono mappati i registri delle periferiche si chiama SFR (registri a funzione speciale), il resto per uso dati generale GPR.

A complicare il tutto, non solo le periferiche sono mappate in memoria, ma lo spazio indirizzabile è suddiviso in pagine (due nel 16F84, di più in altri PIC), e queste pagine (i banchi) si selezionano con il bit apposito del registro STATUS.

In pratica sempre indirizzando da 0 a 127, accediamo ai primi 128 indirizzi se il banco attivo è lo zero, e ai secondi 128 se il banco attivo è l'uno. Poi quali di questi indirizzi siano utilizzabili e a cosa servano è specificato nel datasheet. Alcuni registri (come STATUS) sono visibili in entrambi i banchi, TRISA e TRISB solo nel banco 1, PORTA e PORTB solo nel banco 0. Lo spazio per i dati va da 0ch a 4fh ed è comune ai due banchi, cioè non ci sono 68 byte usabili in un banco e altri 68 nell'altro, sono sempre e solo gli stessi 68.

Il fatto di chiamarli "registri" invece di memoria è dovuto al fatto che dal punto di vista delle istruzioni dei PIC ogni singola cella della memoria dati può essere considerata e usata come un registro (ma in una CPU CISC "convenzionale" i registri sono cose ben diverse, come l'accumulatore W dei PIC per intenderci, mentre la memoria è "la fuori"). Al vantaggio di poterla usare come registri si somma lo svantaggio di un accesso molto limitato tramite puntatori (un solo registro puntatore di nome FSR... da non confondere con il nome di gruppo dei registri SFR... ed è solo l'inizio dell'incubo ).

[ubuntumate]

Bene,sei stato chiaro Claudio_F,ti ringrazio per la spiegazione. Picchiandoci la testa avevo capito già qualche cosa. Per quantoriguarda l'istruzione DECFSZ,devo dire che hai ragione. Ho controllato il datasheet al capitolo 7 ed è come dici tu. Se il secondo argomento viene omesso o vale 0,il contenuto viene salvato in W,altrimenti in F.
Devo chiedere un paio di cose:
1) l'assembly,per convenzione,si scrive in minuscolo o maiuscolo?
2) Questa è un più rognosa: se ho un oscillatore al quarzo da 4 Mhz,il periodo vale 2,5 * 10^ -7 secondi. Stando al datasheet la maggior parte delle istruzioni vengono eseguite in un singolo ciclo,che per l'appunto dovrebbe richiedere il periodo calcolato sopra. Fanno eccezioni le istruzioni che alterano PC (Program Counter),le quali richiedono due cicli per essere eseguite. Ora,se voglio implementare un ritardo,come calcolo il numero di nop che devo eseguire per ottenere un secondo di attesa? Se tutte le istruzioni fossero atomiche(si dice così?) richiederebbero tutte lo stesso tempo,ma GOTO richiede due cicli dato che effettua un salto altera il program counter e dunque tutto si complica nel calcolo del numero di istruzioni da eseguire.
Se scrivo qualcosa del genere,quanto volte lo devo ripetere per arrivare a un secondo?

Codice: Seleziona tutto

BANK0
           movlw  255
          movwf 0Ch
delay decfsz 0Ch,F
            goto delay

[vbextreme]

ricordati che un clock codice richiede 4 colpi di clock dell'oscillatore. questo vale per i Pic
quindi hai 4mhz/4

[ubuntumate]

Hai ragione @vb,ho letto male

All instructions are executed within one single instruc-
tion cycle, unless a conditional test is true or the pro-
gram counter is changed as a result of an instruction.
In this case, the execution takes two instruction cycles
with the second cycle executed as a NOP. One instruc-
tion cycle consists of four oscillator periods. Thus, for
an oscillator frequency of 4 MHz, the normal instruction
execution time is 1 s. If a conditional test is true or the
program counter is changed as a result of an instruc-
tion, the instruction execution time is 2 s.

Come posso calcolare il numero di istruzioni dato che i salti richiedono 8 colpi clock e le istruzioni standard 4?

Ho fatto un tentativo ma non funzia. Ho sbagliato a fare i conti? O magari è il simulatore che non supporta il led lampeggiante?

Codice: Seleziona tutto

 ;-----------------------------------------------------------------------
   ; DEFINIZIONI
   ;-----------------------------------------------------------------------
              PROCESSOR       16F84a    ;clock  4 Mhz
              RADIX           DEC
              INCLUDE         "p16f84a.inc"
              __CONFIG        11101010b

   #define    Bank0   bcf STATUS,RP0
   #define    Bank1   bsf STATUS,RP0
   #define    COUNT1  0Ch
   #define    COUNT2  0Dh
   #define    COUNT3  0Eh
   ;-----------------------------------------------------------------------
   ; PROGRAMMA
   ;-----------------------------------------------------------------------
              ORG     0
              goto inizio

   ;----------INTERRUPT HANDLER (se usato)
              ORG     4

              ...                     ;qui vanno le eventuali istruzioni
              ...                     ;per la gestione degli interrupt
 

   ;----------PREDISPOSIZIONE HARDWARE

   inizio     Bank1                   ;attiva il banco 1
              clrf TRISB              ;Predispone porta B come uscite
              Bank0                   ;attiva il banco 0
 

   ;----------CICLO PRINCIPALE DEL PROGRAMMA

   mainloop   movlw 01h		      ;W = 1
	      movwf PORTB             ;RB0 = H
	      movlw 4                 ;W = 4
	      movwf 0Fh               ;0Fh = 4
    repeat    decfsz 0Fh,F            ;attende 1 secondo
	      call wait_qsec_0        ;routine che ritarda di 250ms
	      goto repeat             ;ripete
	      movlw 00h		      ;W = 0
	      movwf PORTB	      ;RB0 = L
    repeat_1  decfsz 0Fh,F            ;attende 1 secondo
	      call wait_qsec_0        ;routine che ritarda di 250ms
	      goto repeat_1           ;ripete     
	      goto mainloop           ;ripete il ciclo
	      
   ;-----------------------------------------------------------------------
   delay_0    movlw 250
	      movwf COUNT1
   delay_1    decfsz COUNT1,F
	      goto delay_1
	      return
	      
    wait_ms_0 movlw 4
	      movwf COUNT2
	      call delay_0
    wait_ms_1 decfsz COUNT2,F
	      goto wait_ms_1
	      return
	      
    wait_qsec_0 movlw 250
	        movwf COUNT3
    wait_qsec_1 decfsz COUNT3,F
                call wait_ms_0
		goto wait_qsec_1
		return
                
		
   END

RIEDIT:
Ma questo non è un ciclo infinito?

Codice: Seleziona tutto

        movlw FAh 
        movwf 0Ch
loop decfsz 0Ch,F
          call una_routine
         goto loop

Se 0Ch > 0 viene chiamata "una_routin" e poi goto riporta a decfsz. Quando però 0Ch vale zero,call viene saltata e si va al goto,ma 0Ch vale zero e si torna ancora a decfsz.

EDIT 3:
Ce l'ho fatta Era proprio un ciclo infinito. Adesso ho sistemato e funziona.

Codice: Seleziona tutto

 ;-----------------------------------------------------------------------
   ; DEFINIZIONI
   ;-----------------------------------------------------------------------
              PROCESSOR       p16f84a    ;clock  4 Mhz
              RADIX           DEC
              INCLUDE         "p16f84a.inc"
              __CONFIG        11101010b

   #define    Bank0   bcf STATUS,RP0
   #define    Bank1   bsf STATUS,RP0
   #define    COUNT1  0Ch
   #define    COUNT2  0Dh
   #define    COUNT3  0Eh
   #define    COUNT4  0Fh
   #define    COUNT5  10h
   #define    COUNT6  11h
   #define    COUNT7  12h
   #define    COUNT8  13h
   #define    COUNT9  14h
   #define    COUNT10 15h
   ;-----------------------------------------------------------------------
   ; PROGRAMMA
   ;-----------------------------------------------------------------------
              ORG     0
              goto inizio

   ;----------INTERRUPT HANDLER (se usato)
              ORG     4

              ...                     ;qui vanno le eventuali istruzioni
              ...                     ;per la gestione degli interrupt
 

   ;----------PREDISPOSIZIONE HARDWARE

   inizio     Bank1                   ;attiva il banco 1
              clrf TRISB              ;Predispone porta B come uscite
              Bank0                   ;attiva il banco 0
 

   ;----------CICLO PRINCIPALE DEL PROGRAMMA

   mainloop   movlw 0x01		      ;W = 1
	      movwf PORTB             ;RB0 = H
              call delay_qsec
	      movlw 0x00
	      movwf PORTB
	      call delay_qsec
	      goto mainloop           ;ripete il ciclo
	      
   ;-----------------------------------------------------------------------
   delay_250us movlw 0xFA		      ;W = 250
	       movwf COUNT1		      ;COUNT1 = 250
    loop       decfsz COUNT1,F              ;Se COUNT1 = 0,esce
	       goto loop
	       return
    ;---------------------------------------------------------------------
    delay_1ms  movlw 0x04
	       movwf COUNT2
    redo       call delay_250us
	       decfsz COUNT2,F
	       goto redo
	       return
    ;----------------------------------------------------------------------
    delay_qsec movlw 0xFA
	       movwf COUNT3
    again      call delay_1ms
               decfsz COUNT3,F
	       goto again
	       return
                
		
   END

Adesso posso dormire felice

[gila75]

Controllando con mplab non sbagli i tempi.

[ubuntumate]

Ciao Gila,hai provato l'ultimo codice? Ti risulta che qsec produce un ritardo di 250 millisecondi?

[DoctorStrange]

Nel mio messaggio ti spiegavo abbastanza bene come produrre ritardi, usando i timer interni.
Sei certo di voler ottenere il medesimo risultato usando ennemila cicli annidati?

[gila75]

@ubuntumate

sono anni che non apro mplab e tocco un pic...potrei copiare il programma e provare. Magari domani vedo.
comunque 250 ms di ritardo sono molti usando un loop.
In quei 250 ms il micro è "sordo" può fare solo quello.
Mentre con i timer e relativi prescaler puoi fare altro nel frattempo. Essendo il tmr0 un modulo hardware se ne va per i fatti suoi.
Cavolo mi sono reso conto vedendo i programmi che mi sono dimenticato molte cose.
Avrei una voglia di riprendere....

[Claudio_F]

Ti risulta che qsec produce un ritardo di 250 millisecondi?

Con un quarzo da 4 MHz calcolare i tempi è comodo perchè un ciclo macchina (4 cicli di clock) dura esattamente 1 µs. A me viene fuori 0.760003 secondi

Parti da qui:

Codice: Seleziona tutto

delay_250us movlw  250          ; 1
            movwf  COUNT1       ; 1
loop        decfsz COUNT1,F     ; 1*249 + 2
            goto   loop         ; 2*249
            return              ; 2

Totale: 753µs

Le CALL meglio usarle con parsimonia, abbiamo solo 8 livelli di profondità per lo stack.

l'assembly,per convenzione,si scrive in minuscolo o maiuscolo?

Non credo ci sia una convenzione, salvo seguire più o meno i suggerimenti del costruttore o adattarsi al codice già scritto.

[ubuntumate]

Devo sempre entrare nell'ottica della programmazione dei PIC. Ho mille libri da leggere dalle infinite bibliografie di @MAW,studiare i PIC e imparare LaTex.Troppo cose,decisamente :si si: Tra una cosa e l'altra andrò avanti col microcontrollore studiando i timer.

[vbextreme]

@claudio ti sei dimenticato dei 2us della chiamata alla stessa delay.
Totale: 755µs

[ubuntumate]

Brutto errore! 750 uS circa contro i 250 uS (circa) che mi aspettavo.

[gila75]

@ubuntu: non ho capito se stai usando mplab o altro

[ubuntumate]

Uso MPLAB X @gila

[ubuntumate]

Ho studiato un po' il TMR0 e il prescaler. Ho capito quali sono i bit utili per il timer e fino a qui tutto bene. Il problema sorge quando devo usare il timer senza alterare il conteggio perché non so come fare a controllare il timer senza usare btfsc che fa sballare il timer.Any hint?