Test ADC ATxmega128A4U

/*

 * ADC_Test.asm

 *

 *  Created: 03.08.2013 18:25:48

 *   Author: Christian Felix

 *

 *  testet den ADC des ATxmega128A4U

 *  konvertiert permanent die Spannung am Eingang Pin PA1 

 *  und sendet die Ergebnisse als Datenpakete von jeweils 1792 words 

 *  über USARTE0 an den PC

 *

 */ 

.def zero       = r11   ; immer 0, für 16-bit Addition

.def count     = r12

.def count2     = r13

.def count3     = r14

.def count4     = r15

.def temp       = r16

.def temp2      = r17

.def temp3      = r18

.def temp4      = r19

.def temp5     = r20

.equ DISPLAY_SIZE = 100

; setze Interrupt Sprung-Adressen:

; --------------------------------

.org 0x000        rjmp main

.org USARTE0_TXC_vect  rjmp USARTE0_TXC  ; TXC (data transmit complete) Interrupt-Adresse USARTE0

; Start Hauptprogramm:

; --------------------

main:   ; Stack initialisieren

        ldi temp, HIGH(RAMEND)

        out CPU_SPH, temp

    ldi temp, LOW(RAMEND)

        out CPU_SPL, temp

    ; initialisiere zero register:

    clr zero

    ; schalte System-Clock auf 32MHz um (zusätzlich 16,7mA, mit 2MHz sind's 3,22mA)

    rcall CLOCK_32MHZ

    ; initialisiere USARTE:

    rcall USART_INI

    ; Datenrichtung Ports, Remap, Pin Konfiguration, Ladungspumpe ein:

    rcall DEFINE_PORTS

    ; Ringspeicher / Pointer für PC-Display initialisieren:

    rcall DSP_INI

    ; ADCA kalibrieren:

    rcall ADCA_CALIBRATE

    ; setze Event-System:

    //rcall SET_EVENTSYSTEM

; ===================================================================

;

; ADC konfigurieren

;

; -------------------------------------------------------------------

    ; Conversion mode

    ldi temp, 0b10110000    ; IMPMODE = 1 = low impedance source; CURRLIMIT = 01 = LOW; CONVMODE = 1 = signed mode

                  ; FREERUN = 0; RESOLUTION = 00 = 12bit right adjusted

    sts ADCA_CTRLB, temp

    ; external voltage reference pin A0, AREF0 (1,6V):

    ldi temp, 0b00100000    ; REFSEL[2:0] = 010 = AREFA

    sts ADCA_REFCTRL, temp

    ; ADC clock setzen: 0.5MHz

//    ldi temp, 0b00000011    ; prescaler 32

    ldi temp, 0b00000100    ; prescaler 64

//    ldi temp, 0b00000101    ; prescaler 128

//    ldi temp, 0b00000111    ; prescaler 512

    sts ADCA_PRESCALER, temp

    ; Kanäle setzen:

    ; --------------

    ; Channel 0: für alle Input-Pins single ended (ADCA in signed mode):

    ldi temp, 0b00000001    ; START = 0

                  ; INPUTMODE[1:0] = 01 = Single ended

    sts ADCA_CH0_CTRL, temp

    ; Poti: Channel 0 ADC pin 1: PA1, single ended, signed mode

    ldi temp, 0b00001000    ; MUXPOS[3:0] = 0001 = PIN1 = ADC1 pin = PA1

                  ; MUXNEG[2:0] =  000

    sts ADCA_CH0_MUXCTRL, temp

    ; ADCA enablen und flushen:

    ldi temp, 0b00000011    ; no DMA, no START, FLUSH, ENABLE

    sts ADCA_CTRLA, temp

; ===================================================================

;

; Interrupt level für USART definieren

;

; -------------------------------------------------------------------

    ; enable low level interrupt für Datenübertragung zum PC:

    ldi temp, 0b00000001  ; RREN = 0: no round robin for low level interrupts

                ; IVSEL = 0: interrupt vectots are placed at the start of the application section

                ; HILVLEN = 0: high level interrupt disabled

                ; MEDLVLEN = 0: medium level interrupt disabled

                ; LOLVLEN = 1: enable low level interrupt

    sts PMIC_CTRL, temp

    ; global interrupt einschalten:

    sei

; ===================================================================

;

; ADC-Test-Start

;

; -------------------------------------------------------------------

    ; warten bis Kondensatoren aufgeladen sind:

    ldi temp3, 200

    rcall wait

ADC_repeat:

    rcall DSP_CLR_ALL

    clr count

    clr XL

    clr XH

    ldi YH, HIGH(Poti_Samples)

    ldi YL, LOW(Poti_Samples)

ADC_loop_0:

    ; warten. Hier Zahl erhöhen, falls PC zu langsam (kein Handshake mit PC).

    ldi temp3, 22

    rcall shortwait

    ; starte Channel 0:

    ldi temp, 0b00000101    ; no DMA, START CH_0, no FLUSH, ENABLE

    sts ADCA_CTRLA, temp

ADC_wait_0:

    ; prüfe, ob Konversion für Channel 0 fertig:

    lds temp, ADCA_CH0_INTFLAGS

    tst temp

    breq ADC_wait_0

    /*

    ; lösche nun Flag (nicht nötig, wenn ADC nach Warteschleifen von Hand gestartet wird):

    ldi temp, 1

    sts ADCA_CH0_INTFLAGS, temp

    */

    ; 12bit Wert direkt von channel 0 lesen:

    lds temp, ADCA_CH0_RES    ; Lo-Byte

    lds temp2, ADCA_CH0_RES+1  ; Hi-Byte

    ; Werte speichern:

    st Y+, temp

    st Y+, temp2

    adiw X, 1

    cpi XH, 7      ; 7*256 = 1792 Words

    brne ADC_loop_0

    ; Werte senden:

    ldi YH, HIGH(Poti_Samples)

    ldi YL, LOW(Poti_Samples)

ADC_send:

    ld temp, Y+

    ld temp2, Y+

    rcall DSP_WRD_0

    sbiw X, 1

    cpi XH, 0

    brne ADC_send

    tst XL

    brne ADC_send

    rjmp ADC_repeat

; ####################################################################################

; ###########################                         ################################

; ###########################    Interrupt Handler    ################################

; ###########################                         ################################

; ####################################################################################

; ====================================================================================

;

; USARTE0_TXC: Data transmit complete, nach erstem Byte alle weiteren versenden

;

; Nach Sendung des letzten Bytes wird Interrupt gestoppt.

;

; Kein Input, keine benutzten Register

;

; ------------------------------------------------------------------------------------

USARTE0_TXC:

    push temp

    in temp, CPU_SREG

    push temp

    push ZL

    push ZH

    ; sende Byte:

    ldi ZL, LOW(Display_Pointer)  ; Z: absolute Adresse für relativen Pointer auf zu sendendes Byte

    ldi ZH, HIGH(Display_Pointer)

    ld ZL, Z    ; Z ist jetzt absoluter Pointer auf zu sendendes Byte

    ld temp, Z+    ; lade das Byte und setze Z auf nächstes zu sendendes Byte ...

    sts USARTE0_DATA, temp  ; ... und senden

    cpi ZL, DISPLAY_SIZE  ; hat relativer Pointer Ende des Ringspeichers erreicht?

    brlo USARTE0_TXC_pointer_beneath_limit

    clr ZL

USARTE0_TXC_pointer_beneath_limit:

    ; speichere neuen Wert des relativen Pointers:

    mov temp, ZL

    ldi ZL, LOW(Display_Pointer)  ; Z: absolute Adresse für relativen Pointer auf zu sendendes Byte

    st Z+, temp  ; speichere neuen relativen Pointer und lade zugleich absolute Adresse Z für relativen Ende-Pointer

    ; vergleiche neuen Pointer mit Ende-Pointer: wenn gleich, Übertragung stoppen

    ld ZL, Z    ; temp ist jetzt rel. Ende-Pointer

    cp temp, ZL    ; rel. Ende-Pointer = rel. Pointer?

    brne USARTE0_TXC_end

    ; stoppe Interrupt, da gerade letztes Byte gesendet wird:

    sts USARTE0_CTRLA, zero    ; disable interrupt

USARTE0_TXC_end:

    pop ZH

    pop ZL

    pop temp

    out CPU_SREG, temp

    pop temp

    reti

; ####################################################################################

; ###########################                      ###################################

; ###########################    Unterprogramme    ###################################

; ###########################                      ###################################

; ####################################################################################

; lade Display-Programme:

.include "../DisplayLib.inc"

; ====================================================================================

;

; DEFINE_PORTS: legt Datenrichtungen aller Ports fest, konfiguriert alle Pins, remap

;

; ------------------------------------------------------------------------------------

DEFINE_PORTS:

    ; Virtuelle Ports definieren:

    ; ---------------------------

    ; Port C als virtuellen Port 0

    ; Port D als virtuellen Port 1

    ; Port E als virtuellen Port 2

    ; Port A als virtuellen Port 3

    ; definiere PORTC als virtuellen Port 0 und PORTD als virtuellen Port 1:

    ldi temp, 0b00110010      ; code für PORTC->virtuell 0 und PORTD->virtuell 1

    sts PORTCFG_VPCTRLA, temp    ; Register für virtuelle Ports 0 und 1

    ; definiere PORTE als virtuellen Port 2 und PORTA als virtuellen Port 3:

    ldi temp, 0b00000100      ; code für PORTE->virtuell 2 und PORTA->virtuell 3

    sts PORTCFG_VPCTRLB, temp    ; Register für virtuelle Ports 2 und 3

    ; Setze Port Pins auf Eingang / Ausgang je nach Bestimmung:

    ; ---------------------------------------------------------

    ; PA7: Eingang: leer (unused pin)

    ; PA6: Analog-Eingang: MUXNEG, verdrahtet mit AREF = 1,6V (=PA0)

    ; PA5: Analog-Eingang: MUXPOS, Ausgang Tiefpass Mikrofon-OpAmp MAX4488

    ; PA4: Analog-Eingang: PTC

    ; PA3: Analog-Eingang: LDR

    ; PA2: Analog-Eingang: Farbtemperatur-Poti

    ; PA1: Analog-Eingang: Helligkeits-Poti

    ; PA0: Analog-Eingang: AREF = 1,6V, verdrahtet mit MUXNEG (=PA6)

    ldi temp, 0b00000000

    sts VPORT3_DIR, temp    ; Datenrichtungen für Port A festlegen

    ; PB3: Eingang: leer (unused pin)

    ; PB2: Eingang: leer (unused pin)

    ; PB1: Eingang: leer (unused pin)

    ; PB0: Ausgang: An/Aus Stromversorgung PTC

    ldi temp, 0b00000001

    sts PORTB_DIR, temp    ; Datenrichtungen für Port B festlegen

    ; PC7: Ausgang: CLK_PER für Ladungspumpe

    ; PC6: Eingang: leer (unused pin)

    ; PC5: Ausgang: An/Aus Touch (Spannungsversorgung AT42QT1010 über 3,3V-Referenz)

    ; PC4: Eingang: Ergebnis Touch, Ausgang vom ATV42QT1010

    ; PC3: Ausgang: Timer TCC0 verdrahtet mit PC2 (Eingang), Mikrophon-Trigger 1:3

    ; PC2: Eingang: verdrahtet mit PC3, Mikrophon-Trigger 1:3

    ; PC1: Ausgang: Mikrofon-Verstärkerkreis An/Aus, enable OpAmp und 3,3V-LDO

    ; PC0: Eingang: leer (unused pin)

    ldi temp, 0b10101010

    out VPORT0_DIR, temp  ; Datenrichtungen für Port C festlegen

    ; PD7: Ausgang: Blau RGB-LED, Remap TCD0 / OC0D

    ; PD6: Eingang: leer (unused pin)

    ; PD5: Ausgang: PWM Licht Kanal B, TCD1 / OC1B

    ; PD4: Ausgang: PWM Licht Kanal A, TCD1 / OC1A

    ; PD3: Eingang: leer (unused pin)

    ; PD2: Ausgang: enable OpAmps 1 und 2: Kanäle A und B

    ; PD1: Eingang: leer (unused pin)

    ; PD0: Ausgang: Umschaltung PWM / Analog, vier FET-Gates

    ldi temp, 0b10110101

    out VPORT1_DIR, temp  ; Datenrichtungen für Port D festlegen

    ; PE3: Ausgang: USARTE0, TXD0

    ; PE2: Ausgang: USARTE0, RXD0

    ; PE1: Ausgang: Grün RGB-LED

    ; PE0: Ausgang: Rot RGB-LED

    ldi temp, 0b00001111

    sts VPORT2_DIR, temp  ; Datenrichtungen für Port E festlegen

    ; PR1: Eingang: leer (unused pin)

    ; PR0: Eingang: leer (unused pin)

    ldi temp, 0b00000000

    sts PORTR_DIR, temp    ; Datenrichtungen für Port R festlegen

    ; Lege die Eingänge nicht benutzter Pins auf Low (Port A, B, C, D, R):

    ; --------------------------------------------------------------------

    ldi temp2, 0b00010000    ; code für Totem-pole Pull-down (Pin level low)

    ; Port A:

    sts PORTA_PIN7CTRL, temp2  ; Totem-pole Pull-down

    ; Port B:

    ldi temp, 0b00001110    ; folgende PINnCTRL gilt für pins 3, 2, 1 (PB3, PB2, PB1)

    sts PORTCFG_MPCMASK, temp

    sts PORTB_PIN1CTRL, temp2  ; Totem-pole Pull-down

    ; Port C:

    ldi temp, 0b01000001    ; folgende PINnCTRL gilt für pins 6 und 0 (PC6 und PC0)

    sts PORTCFG_MPCMASK, temp

    sts PORTC_PIN0CTRL, temp2  ; Totem-pole Pull-down

    ; Port D:

    ldi temp, 0b01001010    ; folgende PINnCTRL gilt für pin 6, 3, 1 (PD6, PD3, PD1)

    sts PORTCFG_MPCMASK, temp

    sts PORTD_PIN1CTRL, temp2  ; Totem-pole Pull-down

    ; Port R:

    ldi temp, 0b00000011    ; folgende PINnCTRL gilt für pin 1 und 0 (PR1 und PR0)

    sts PORTCFG_MPCMASK, temp

    sts PORTR_PIN0CTRL, temp2  ; Totem-pole Pull-down

    ; Port A: schalte digitalen Input-Buffer für Analog-Eingänge aus:

    ; ---------------------------------------------------------------

    ldi temp2, 0b00000111    ; code für Digital input buffer disabled

    ldi temp, 0b01111111    ; folgende PINnCTRL gilt für pins 6...0 (PA6...PA0)

    sts PORTCFG_MPCMASK, temp

    sts PORTA_PIN0CTRL, temp2  ; Digital input buffer disabled

    ; Schalte Ladungspumpe für negative Spannung ein:

    ; -----------------------------------------------

    ldi temp, 0b10000000      ; slew rate limitation enable on PC7

    sts PORTC_PIN7CTRL, temp

    ldi temp, PORTCFG_CLKOUT_PC7_gc  ; CLKper, also 32MHz (manual S.154), an PC7

    sts PORTCFG_CLKEVOUT, temp

    ; Remap pin PD3/PD7, PWM Timer/Counter Output Compare D für Blau RGB:

    ; -------------------------------------------------------------------

    ldi temp, 0b00001000  ; bit 3 - TC0D from PD3 to PD7 (manual p.150)

    sts PORTD_REMAP, temp

    ret

; ====================================================================================

;

; SET_EVENTSYSTEM

;

; setzt die event channels, um ADC-Kanäle zu triggern

; 

; kein Input

;

; temp wird zerstört

; 

; ------------------------------------------------------------------------------------

SET_EVENTSYSTEM:

    ; Event channel 0 wird über die Clk_per getriggert, um ADCA-channel 0 zu

    ; triggern, an dem die Potis, PTC und LDR hängen:

    ; events sollen mit einer Taktrate von 62500 Hz getriggert werden, das

    ; ist ausreichend, um mit 1024 Hz für alle vier Pins, die an ADCA-Channel 0

    ; hängen, je 16 neue Konversionen zur Verfügung zu stellen, aus denen dann

    ; per CPU der Mittelwert gebildet werden kann.

    ldi temp, 0b10001001    ; PRESCALER M (1000) mit M = 9 (1001) = 32MHz/2e9 = 62500Hz

    ; wenn CPU mit 2MHz getaktet wird, dann diesen Wert verwenden:

    // ldi temp, 0b10000101    ; PRESCALER M (1000) mit M = 5 (0101) =  2MHz/2e5 = 62500Hz

    sts EVSYS_CH0MUX, temp

    ; Event channel 1 wird aktiv beim Flankenwechsel Pin PC2 (rising/falling edge on Pin PC2)

    ldi temp, 0b01100010    ; group configuration PORTC_PIN2 für CH1MUX

    sts EVSYS_CH1MUX, temp    ; event channel 1

    ret

; ====================================================================================

;

; CLOCK_32MHZ

;

; change of internal clock from 2MHz to 32MHz

; Stromaufnahme der MPU steigt dabei um 22mA.

; Der interne 32MHz Oszillator läuft z.B. 5% zu schnell und muss

; kalibriert werden!

; 

; ------------------------------------------------------------------------------------

CLOCK_32MHZ:

    ldi temp, (1<<OSC_RC32KEN_bp | 1<<OSC_RC32MEN_bp | 1<<OSC_RC2MEN_bp)  ; enable 32kHz and 32MHz clock and keep 2MHz clock running

    sts OSC_CTRL, temp

    ; warte bis 32MHz clock stabil läuft

CLOCK_32MHZ_clock_wait:

    lds temp, OSC_STATUS

    andi temp, (1<<OSC_RC32KRDY_bp | 1<<OSC_RC32MRDY_bp)  ; 32kHz and 32MHz clock ready bits ausmaskieren

    cpi temp, (1<<OSC_RC32KRDY_bp | 1<<OSC_RC32MRDY_bp)    ; wenn bits gesetzt, dann laufen die Oszillatoren stabil

    brne CLOCK_32MHZ_clock_wait    ; Schleife wird in der Regel nur zweimal durchlaufen

    ; 32MHz clock läuft jetzt stabil, ändere interne System clock über protected write sequence

    ldi temp, 0xD8        ; code für Zugriff auf Protected IO register

    sts CPU_CCP, temp      ; ins CPU Configuration Change Protection schreiben, ab jetzt nur 4 clock cycles write möglich

    ldi temp, 0b00000001    ; code für Auswahl interne 32MHz clock

    sts CLK_CTRL, temp      ; fertig - nach 3 clock cycles

    ; disable nun interne 2MHz clock:

    ldi temp, (1<<OSC_RC32KEN_bp | 1<<OSC_RC32MEN_bp | 0<<OSC_RC2MEN_bp)  ; keep 32kHz and 32MHz clock running and stop 2MHz clock

    sts OSC_CTRL, temp

    ; calibrate the 32MHz internal Oszillator frequency:

    ldi temp, 0

    sts OSC_DFLLCTRL, temp    ; calibration source for the 32MHz DFLL is the 32.768kHz internal oscillator

    ldi temp, 1<<DFLL_ENABLE_bp  ; this bit enables the DFLL and auto-calibration of the internal oscillator

    sts DFLLRC32M_CTRL, temp  ; the reference clock must be enabled and stable before the DFLL is enabled

    ret

; ====================================================================================

;

; ADCA_CALIBRATE

;

; ADCA kalibrieren. 

; Achtung, hier keinen Code einfügen, kein Interrupt.

; Command Register des NVM-Controllers wird verändert.

;

; kein Input

;

; zerstört temp, temp2, temp3, Z-pointer

;

; ------------------------------------------------------------------------------------

ADCA_CALIBRATE:

    ; Lo-Byte der ADCA-Kalibrierung zuerst lesen und in temp speichern

    ; Load the Z-pointer with the byte address to read (-> manuel p. 431)

    ldi ZL, PROD_SIGNATURES_START + NVM_PROD_SIGNATURES_ADCACAL0_offset

    clr ZH

    ; Load the NVM CMD register with the read user signature row / calibration row command

    ldi temp, NVM_CMD_READ_CALIB_ROW_gc

    sts NVM_CMD, temp

    ; Execute the LPM instruction

    lpm temp, Z      ; in temp liegt jetzt das Lo-Byte der Kalibrierung

    ; nun das Hi-Byte der ADCA-Kalibrierung lesen und in temp2 speichern

    ; Load the Z-pointer with the byte address to read

    ldi ZL, PROD_SIGNATURES_START + NVM_PROD_SIGNATURES_ADCACAL1_offset

    ; Execute the LPM instruction:

    lpm temp2, Z    ; in temp2 liegt jetzt das Hi-Byte der Kalibrierung

    ; NVM CMD register wieder in den Normalzustand versetzen:

    ldi temp3, NVM_CMD_NO_OPERATION_gc

    sts NVM_CMD, temp3

    ; ADC-Kalibrierungsregister beschreiben:

    sts ADCA_CAL, temp    ; Lo-Byte

    sts ADCA_CAL+1, temp2  ; Hi-Byte

    ret

; ==================================================================================

;

; USART_INI

; 

; Kommunikationseinstellungen RS485-Schnittstelle für USARTE0 @ f_CPU = 32 MHz

;

; ----------------------------------------------------------------------------------

USART_INI:

    ; schalte zunächst Receiver und Transmitter von USARTE0 aus, dadurch wird Receiver Buffer geflushed:

    ldi temp, 0

    sts USARTE0_CTRLB, temp

    ; initialize USARTE0 using initialization sequence as described in the manual p. 296:

    ldi temp, 0b00000001      ; setze Baudrate auf 1MHz

    sts USARTE0_BAUDCTRLA, temp    ; BSEL[7:0] = 1

    ldi temp, 0b00000000

    sts USARTE0_BAUDCTRLB, temp    ; BSCALE[3:0] = 0 BSEL[11:8] = 0 und => Baudrate = f_CPU/(16*(1+1)) = 1MHz

    ldi temp, 0b00100011      ; CMODE[1:0] = 00 = asynchronous mode

                    ; PMODE[1:0] = 10 = even parity

                    ; SBMODE = 0 = 1 stop bit

                    ; CHSIZE[2:0] = 011 = 8bit

    sts USARTE0_CTRLC, temp      ; set communication mode and frame format 

    ; schalte Transmitter von USARTE0 an:

    ldi temp, 0b00001000      ; RXEN = 0 = disable receiver

                    ; TXEN = 1 = enable Transmitter

                    ; CLK2X = 0 = no double transmission speed

                    ; MPCM = 0 = no multiprocessor communication mode

                    ; TXB8 = 0 = no ninth data bit

    sts USARTE0_CTRLB, temp

    ret

; ==================================================================================

;

; Warteschleifen

;

; ----------------------------------------------------------------------------------

; Aufruf von wait: Wert in Einheiten von 6,25ms muss in temp3 stehen

; maximaler Wert: 0 (=256), entspricht 1,6s, Wert 160 entspricht 1s

wait:   push temp3

    push temp4

    push count

wait1:  clr  temp4

wait2:  clr  count

wait3:  dec  count

    brne wait3

    dec  temp4

    brne wait2

    dec  temp3

    brne wait1

    pop count

    pop temp4

    pop temp3

    ret

; Aufruf von shortwait: Wert in Einheiten von 0,025ms muss in temp3 stehen

; maximaler Wert: 0 (=256), entspricht 6,5ms

shortwait:

    push temp3

    push temp4

shortwait1:

    clr  temp4

shortwait2:

    dec  temp4

    brne shortwait2

    dec  temp3

    brne shortwait1

    pop temp4

    pop temp3

    ret

; ==================================================================================

.DSEG

Poti_Samples: .BYTE 7168

.org (RAMEND-255)

; Speicherort für das Display-Memory muss mit Low-Byte 0 beginnen (neue Seite), sonst funktioniert der Code nicht

Display_Memory:  .BYTE DISPLAY_SIZE  ; Ringspeicher der Display-Daten

; relativer Pointer auf nächstes zu sendende Byte + relativer Ende-Pointer auf letztes zu sendendes Byte:

Display_Pointer: .BYTE 2