1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:

.
//*************************************************************************
// OscRender: Quad saw or pwm (mit aliasing)
//*************************************************************************
void OscRender_PAD(uint8_t osc_nr)
{
    uint8_t block_size = 40;
    uint8_t shape = Osc.shape[osc_nr];
    uint8_t parameter = Osc.prm[osc_nr];
    uint8_t *buffer;    // pointer name
    uint8_t i = 0;
       
    if (osc_nr == 0)
    {
        if (Voice.buffer_nr == 0)
        {
            buffer = Voice.Buffer2a;
        }
        else {buffer = Voice.Buffer1a;}
    }
    else
    {
        if (Voice.buffer_nr == 0)
        {
            buffer = Voice.Buffer2b;
        }
        else {buffer = Voice.Buffer1b;}
    }
   
    uint16_t phase_increment_ = (Osc.phase_increment[osc_nr] >> 8);
    uint16_t phase_spread = (uint32_t)(phase_increment_ * parameter) >> 13;
   
    // Test phase_spread with/without random value
    if (Osc.Test_flag == 0)
    {
        ++phase_spread;
    }
    else {phase_spread += (Noise.sample >> 7);}
   
   
    uint16_t increments[3];
    for (uint8_t i = 0; i < 3; ++i) {
        phase_increment_ += phase_spread;
        increments[i] = phase_increment_;
    }

    //BEGIN_SAMPLE_LOOP ---------------------------------------------------
    if (shape == OSC_SAW_PAD) {
        do
        {
            // update Phase
            Osc.phase[osc_nr] += Osc.phase_increment[osc_nr];
           
            if (SREG & 0b00000001) // test overflow
            {
                Osc.phase[osc_nr] = 0;
            }
               
            uint16_t phase_intergral = Osc.phase[osc_nr] >> 8;
            uint8_t value = (phase_intergral >> 10);
           
            // Osc1
            if (osc_nr == 0)
            {
                Osc1.data_qs_phase[0] += increments[0];
                Osc1.data_qs_phase[1] += increments[1];
                Osc1.data_qs_phase[2] += increments[2];
                value += (Osc1.data_qs_phase[0] >> 10);
                value += (Osc1.data_qs_phase[1] >> 10);
                value += (Osc1.data_qs_phase[2] >> 10);
            }
            else // Osc2
            {
                Osc2.data_qs_phase[0] += increments[0];
                Osc2.data_qs_phase[1] += increments[1];
                Osc2.data_qs_phase[2] += increments[2];
                value += (Osc2.data_qs_phase[0] >> 10);
                value += (Osc2.data_qs_phase[1] >> 10);
                value += (Osc2.data_qs_phase[2] >> 10);
            }
           
            // write sample in sound-buffer
            buffer[i++] = ~value;
           
        } while (--block_size);
    }
}

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:

//*************************************************************************
// DMA init
//*************************************************************************
void dma_init(void){
    DMA.CTRL = DMA_CH_ENABLE_bm | DMA_DBUFMODE_CH01CH23_gc; // set Double Buffer and enabled
    
    // DMA Channel 0 (Audio-Buffer A)    
    DMA.CH0.ADDRCTRL = DMA_CH_SRCRELOAD_TRANSACTION_gc | DMA_CH_SRCDIR_INC_gc
    | DMA_CH_DESTRELOAD_BURST_gc | DMA_CH_DESTDIR_INC_gc;
    DMA.CH0.TRIGSRC = DMA_CH_TRIGSRC_DACB_CH0_gc; // DACB CH0 is trigger Quelle
    DMA.CH0.DESTADDR0 = (((uint32_t)(&DACB.CH0DATAH))>>0*8) & 0xFF;
    DMA.CH0.DESTADDR1 = (((uint32_t)(&DACB.CH0DATAH))>>1*8) & 0xFF;
    DMA.CH0.DESTADDR2 = (((uint32_t)(&DACB.CH0DATAH))>>2*8) & 0xFF;
    DMA.CH0.TRFCNT = 128;
    DMA.CH0.SRCADDR0 = (((uint32_t)(&Voice.Buffer_A))>>0*8) & 0xFF;
    DMA.CH0.SRCADDR1 = (((uint32_t)(&Voice.Buffer_A))>>1*8) & 0xFF;
    DMA.CH0.SRCADDR2 = (((uint32_t)(&Voice.Buffer_A))>>2*8) & 0xFF;
    DMA.CH0.CTRLA = 0xA4;   // Aktivieren, Wiederholen, 1 Byte, Single
    
    // DMA Channel 1 (Audio-Buffer B)
    DMA.CH1.ADDRCTRL = DMA_CH_SRCRELOAD_TRANSACTION_gc | DMA_CH_SRCDIR_INC_gc
    | DMA_CH_DESTRELOAD_BURST_gc | DMA_CH_DESTDIR_INC_gc;
    DMA.CH1.TRIGSRC = DMA_CH_TRIGSRC_DACB_CH0_gc; // DACB CH0 is trigger Quelle
    DMA.CH1.DESTADDR0 = (((uint32_t)(&DACB.CH0DATAH))>>0*8) & 0xFF;
    DMA.CH1.DESTADDR1 = (((uint32_t)(&DACB.CH0DATAH))>>1*8) & 0xFF;
    DMA.CH1.DESTADDR2 = (((uint32_t)(&DACB.CH0DATAH))>>2*8) & 0xFF;
    DMA.CH1.TRFCNT = 128;
    DMA.CH1.SRCADDR0 = (((uint32_t)(&Voice.Buffer_B))>>0*8) & 0xFF;
    DMA.CH1.SRCADDR1 = (((uint32_t)(&Voice.Buffer_B))>>1*8) & 0xFF;
    DMA.CH1.SRCADDR2 = (((uint32_t)(&Voice.Buffer_B))>>2*8) & 0xFF;
    DMA.CH1.CTRLA = 0xA4;   // Aktivieren, Wiederholen, 1 Byte, Single
    
    // DMA Channel 2 (Audio-Buffer C)
    DMA.CH2.ADDRCTRL = DMA_CH_SRCRELOAD_TRANSACTION_gc | DMA_CH_SRCDIR_INC_gc
    | DMA_CH_DESTRELOAD_BURST_gc | DMA_CH_DESTDIR_INC_gc;
    DMA.CH2.TRIGSRC = DMA_CH_TRIGSRC_DACA_CH0_gc; // DACA CH0 is trigger Quelle
    DMA.CH2.DESTADDR0 = (((uint32_t)(&DACA.CH0DATAH))>>0*8) & 0xFF;
    DMA.CH2.DESTADDR1 = (((uint32_t)(&DACA.CH0DATAH))>>1*8) & 0xFF;
    DMA.CH2.DESTADDR2 = (((uint32_t)(&DACA.CH0DATAH))>>2*8) & 0xFF;
    DMA.CH2.TRFCNT = 128;
    DMA.CH2.SRCADDR0 = (((uint32_t)(&Voice.Buffer_C))>>0*8) & 0xFF;
    DMA.CH2.SRCADDR1 = (((uint32_t)(&Voice.Buffer_C))>>1*8) & 0xFF;
    DMA.CH2.SRCADDR2 = (((uint32_t)(&Voice.Buffer_C))>>2*8) & 0xFF;
    DMA.CH2.CTRLA = 0xA4;   // Aktivieren, Wiederholen, 1 Byte, Single
    
    // DMA Channel 3 (Audio-Buffer D)
    DMA.CH3.ADDRCTRL = DMA_CH_SRCRELOAD_TRANSACTION_gc | DMA_CH_SRCDIR_INC_gc
    | DMA_CH_DESTRELOAD_BURST_gc | DMA_CH_DESTDIR_INC_gc;
    DMA.CH3.TRIGSRC = DMA_CH_TRIGSRC_DACA_CH0_gc; // DACA CH0 is trigger Quelle
    DMA.CH3.DESTADDR0 = (((uint32_t)(&DACA.CH0DATAH))>>0*8) & 0xFF;
    DMA.CH3.DESTADDR1 = (((uint32_t)(&DACA.CH0DATAH))>>1*8) & 0xFF;
    DMA.CH3.DESTADDR2 = (((uint32_t)(&DACA.CH0DATAH))>>2*8) & 0xFF;
    DMA.CH3.TRFCNT = 128;
    DMA.CH3.SRCADDR0 = (((uint32_t)(&Voice.Buffer_D))>>0*8) & 0xFF;
    DMA.CH3.SRCADDR1 = (((uint32_t)(&Voice.Buffer_D))>>1*8) & 0xFF;
    DMA.CH3.SRCADDR2 = (((uint32_t)(&Voice.Buffer_D))>>2*8) & 0xFF;
    DMA.CH3.CTRLA = 0xA4;   // Aktivieren, Wiederholen, 1 Byte, Single
}


//*************************************************************************
// Timer0 Interrupt: DAC Task 40KHz/25usec
//*************************************************************************
ISR(TCC0_OVF_vect)
{    
    // DMA Interrupt ------------------------------------------------------
    
    // if Channel Transaction Complete Interrupt Flag set
    if (DMA.INTFLAGS & DMA_CH0TRNIF_bm)
    {
        // set buffer_nr
        Voice.buffer_nr = 0;
        
        // set buffer_fill interrupt
        TCE1.INTCTRLA = 0b00000010;
        
        // clear DMA Interrupt (set one)
        DMA.INTFLAGS |= DMA_CH0TRNIF_bm;
    }
    else if (DMA.INTFLAGS & DMA_CH1TRNIF_bm)
    {
        // set buffer_nr
        Voice.buffer_nr = 1;
        
        // set buffer_fill interrupt
        TCE1.INTCTRLA = 0b00000010;
        
        // clear DMA Interrupt (set one)
        DMA.INTFLAGS |= DMA_CH1TRNIF_bm;
    }

....

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:

uint16_t RNG_16;
uint8_t RNG_8;

static inline Noise8(void) {
    asm volatile (
    "lds r30, RNG_16+0" "\n\t"
    "lds r31, RNG_16+1" "\n\t"
    "lsr r31" "\n\t"
    "ror r30" "\n\t"
    "brsh xxor" "\n\t"
    "ldi r17, 0xb4" "\n\t"
    "xxor: eor r31, r17" "\n\t"
    "sts RNG_8, r30" "\n\t"
    "sts RNG_16+0, r30" "\n\t"
    "sts RNG_16+1, r31" "\n\t"
    ::: "r17", "memory"
    );
}