[ASM] USI tiny SPI Slave im Interrupt Mode

[Steffen H. (avrsteffen)]

Hallo werte µC-Gemeinde


Einen tiny2313 für eine vollständige SPI Kommunikation zu verwenden ist
keine so gute Idee. Wenn man allerdings auf das zurücksenden von Daten
per 'DO' verzichten kann, dann hab ich da was für euch.

Ich verwende es in einer Positionsanzeige mit 3x8 7-Segmentanzeigen. Der 
tiny2313 arbeitet hierbei als Slave und nimmt die Daten vom SPI 
entgegen.
Momentan läuft der SPI Takt des Masters mit 16Mhz/64 = 250kHz. Der SPI
Slave ala tiny2313 hat einen /CS Eingang (PC_INT). Die SPI Auswertung 
erfolgt im Interrupt. Und wenn alle Bytes empfangen wurden, wird ein 
Flag im GPIOR0-Register gesetzt welches man in der Hauptschleife 
abfragen kann.
Der Vorteil der Interruptbehandlung des SPI liegt darin, dass man wärend
des SPI-Transfers weiterhin andere Aufgaben erledigen kann.

Hier die Defines:

;***** Register-Variablen
.def  SREG_SAVE     = r0 ; Sicherungskopie des SREG-Registers im Interrupt

; Konstanten
.equ  SPI_RD_BYTES = 12 ; zu empangene Bytes per SPI

; Flags in GPOIR0
.equ  SPI_ON       = 2  ; 0= SPI Off  |  1= SPI On
.equ  SPI_OVERRUN  = 3  ; 0= kein SPI Data OverRun  |  1= SPI Data OverRun
.equ  SPI_UNDERRUN = 4  ; 0= kein SPI Data UnderRun |  1= SPI Data UnderRun
.equ  NEW_SPI_DATA = 7  ; Flag zeigt an, dass neue Daten von dem USI-SPI zur Verfuegung stehen

; Port defines
.equ  USI_SPI_PORT = PORTB ; fest vorgeschrieben
.equ  usi_SPI_SCK  = 7     ; fest vorgeschrieben
.equ  usi_SPI_DO   = 6     ; fest vorgeschrieben
.equ  usi_SPI_DI   = 5     ; fest vorgeschrieben
.equ  usi_SPI_CS   = 4     ; 0..4 von PORTB frei waehlbar

; Variablen im SRAM
.dseg
  SPI_pRD_BUFFER:  .BYTE 2             ; SPI read pointer
  SPI_RD_BUFFER:   .BYTE SPI_RD_BYTES  ; SPI read buffer
  MEM_BUFFER:      .BYTE SPI_RD_BYTES  ; Arbeitspeicher

Hier mal noch ein hilfreiches Makro um einen Pointer zu laden:

;--- Macros -------------------------------------------------------
.macro   load_p         ; lädt 16Bit @1 nach @0 High und @0 Low
   ldi     @0H,HIGH(@1)
   ldi     @0L,LOW(@1)
.endmacro

Hier die Interruptvektoren:

.cseg            ;Beginn eines Code-Segmentes
.org $000         rjmp  RESET          ; Startadresse 
.org PCIaddr      rjmp  PCINT          ; Pin Change Interrupt Handler
.org USI_OVFaddr  rjmp  USI_OVERFLOW   ; USI Overflow Handler

Wenn die /CS Leitung vom Master auf Low gezogen wurde wird dies erkannt
und dem SPI Interrupt das abspeichern der empfangenen Bytes angewiesen.
Im SPI Interrupt wird geprüft, dass nicht zuviel Bytes gesendet werden.
(festgelegte Anzahl zu empfangender Bytes per Frame in 'SPI_RD_BYTES')
Andernfalls wird das 'OVERRUN'-Flag gesetzt und das SPI Frame verworfen.
Sollte nun vom Master die /CS Leitung wieder auf High gezogen, dann wird
dies wieder im Pin-Change-Interrupt erkannt und geprüft, ob auch schon
alle Bytes eines SPI-Frames empfangen wurde. Sollte das der Fall sein,
wird das 'NEW_SPI_DATA'-Flag im GPOIR0 gesetzt und damit angezeigt, dass
ein neuer Datensatz im 'SPI_RD_BUFFER' im SRAM liegt. Darauf kann dann
die Hauptschleife reagieren.

Hier der Pin Change Interrupt der /CS Leitung:

.org INT_VECTORS_SIZE
; Programm Code follows from here
PCINT:
   in    SREG_SAVE,SREG
   push  r16
   sbic  USI_SPI_PORT-2,usi_SPI_CS
   rjmp  usi_spi_transfer_end
usi_spi_transfer_start:
   sbi   GPIOR0,SPI_ON          ; SPI Auswertung einschalten
   in    r16,USI_SPI_PORT-1
   sbr   r16,(1<<usi_SPI_DO)
   out   USI_SPI_PORT-1,r16
   rjmp  pcint_end
usi_spi_transfer_end:
   cbi   GPIOR0,SPI_ON           ; SPI Auswertung ausschalten
   in    r16,USI_SPI_PORT-1
   cbr   r16,(1<<usi_SPI_DO)
   out   USI_SPI_PORT-1,r16  
   push  r17
   push  XL
   push  XH
   lds   XL,(SPI_pRD_BUFFER+0)   ; LSB
   lds   XH,(SPI_pRD_BUFFER+1)   ; MSB
   ldi   r16,byte1(SPI_RD_BUFFER); SPI_RD_BUFFER initialisieren
   ldi   r17,byte2(SPI_RD_BUFFER)
   sts   (SPI_pRD_BUFFER+0),r16
   sts   (SPI_pRD_BUFFER+1),r17
   sbis  GPIOR0,SPI_OVERRUN
   rjmp  usi_spi_transfer_complied
   cbi   GPIOR0,SPI_OVERRUN
   rjmp  usi_spi_end
usi_spi_transfer_complied:
   sbic  GPIOR0,NEW_SPI_DATA
   rjmp  usi_spi_end
   ldi   r16,byte1(SPI_RD_BUFFER+SPI_RD_BYTES)
   ldi   r17,byte2(SPI_RD_BUFFER+SPI_RD_BYTES)
   cp    XL,r16    ; Überpruefung auf Data underrun
   cpc   XH,r17    ; Überpruefung auf Data underrun
   brlo  usi_spi_end
   sbi   GPIOR0,NEW_SPI_DATA
   rjmp  usi_spi_end
usi_spi_end:
   pop   XH
   pop   XL
   pop   r17
pcint_end:
   pop   r16
   out   SREG,SREG_SAVE
   reti

Hier der USI Overflow Interrupt für ein empfangenes Byte:

USI_OVERFLOW:
   in    SREG_SAVE,SREG
   sbi   USISR,USIOIF
   push  r16
   push  r17
   push  XL
   push  XH
   sbis  GPIOR0,SPI_ON
   rjmp  usi_overflow_end
   lds   XL,(SPI_pRD_BUFFER+0)    ; LSB
   lds   XH,(SPI_pRD_BUFFER+1)    ; MSB
   ldi   r16,byte1(SPI_RD_BUFFER+SPI_RD_BYTES)
   ldi   r17,byte2(SPI_RD_BUFFER+SPI_RD_BYTES)
   cp    XL,r16     ; Überpruefung auf Data overrun
   cpc   XH,r17     ; Überpruefung auf Data overrun
   brsh  usi_spi_rd_overun
;store spi data byte
   in    r16, USIDR
   st    X+,r16
   sts   (SPI_pRD_BUFFER+0),XL     ; LSB
   sts   (SPI_pRD_BUFFER+1),XH     ; MSB
   rjmp  usi_overflow_end

usi_spi_rd_overun:
   sbi   GPIOR0,SPI_OVERRUN
   cbi   GPIOR0,SPI_ON

usi_overflow_end:
   pop   XH
   pop   XL
   pop   r17
   pop   r16
   out   SREG,SREG_SAVE
   reti

Hier die USI SPI Initialisierung:

init_usi_spi:
   cbi    GPIOR0,SPI_ON
   cbi    GPIOR0,SPI_OVERRUN
   cbi    GPIOR0,SPI_UNDERRUN
   cbi    GPIOR0,NEW_SPI_DATA
;Port und Pins für USI SPI initialisieren
   in      r16,USI_SPI_PORT-1
   cbr     r16, (1<<usi_SPI_SCK)|(1<<usi_SPI_DI)|(1<<usi_SPI_CS)|(1<<usi_SPI_DO)
   out     USI_SPI_PORT-1,r16
   in      r16,USI_SPI_PORT
   sbr     r16, (1<<usi_SPI_CS)
   out     USI_SPI_PORT,r16
; Pointer auf SPI_RD_BUFFER initialisieren  
   load_p  X,(SPI_RD_BUFFER)
   sts     (SPI_pRD_BUFFER+0),XL
   sts     (SPI_pRD_BUFFER+1),XH
; USI SPI einschalten    
   in      r16, USICR
   sbr     r16, (1<<USIOIE)|(1<<USIWM0)|(1<<USICS1)
   cbr     r16, (1<<USIWM1)|(1<<USICS0)|(1<<USICLK)
   out     USICR, r16
; Pin-Cange-Interrupt Pin auswaehlen
   in      r16, PCMSK
   sbr     r16, (1<<usi_SPI_CS)
   out     PCMSK, r16
; Pin-Change-Interrupt einschalten
   in      r16, GIMSK
   sbr     r16, (1<<PCIE)
   out     GIMSK, r16
   ret

Jetzt noch das Unterprogramm 'memcpy' zur Speicherkopie. Die sollte man
machen, da ja der 'SPI_RD_BUFFER' in einem weiteren SPI-Interrupt wieder
verändert werden kann. So kann man mit der Kopie erstmal ganz beruhigt
arbeiten.

memcpy:
   ldi      r17,SPI_RD_BYTES
   load_p   X,(SPI_RD_BUFFER)
   load_p   Y,(MEM_BUFFER)
   cli      ; Atomarer Zugriff begin
memcpy_loop:
   ld       r16,X+
   st       Y+,r16
   dec      r17
   brne  memcpy_loop
   sei      ; Atomarer Zugriff ende
   cbi      GPIOR0,NEW_SPI_DATA
   ret

Und so kommt man nun an die SPI Daten ran:

; RESET = Programmbeginn
RESET:
   rcall   init_usi_spi    ; USI SPI initialisieren (PORTs, INTs und SRAM)
; Hauptschleife
main:
   sbic    GPIOR0,NEW_SPI_DATA
   rcall   new_spi_data_receive
;  .....
;  ..... tue irgendwas in der Hauptschleife
;  .....
   rjmp    main

new_spi_data_receive:
   rcall   memcpy    ; ab hier stehen die SPI Data Bytes im 'MEM_BUFFER'
;  ......            ; zur weiteren Verarbeitung bereit

   ret

Ich glaub dass ist jetzt ganz schön lang geworden. Wenn noch Fragen sind
oder Ihr Anregungen/Verbesserungen habt, nur her damit.

Grüße Steffen