[MSP430][CCS4] Kłopocik z PWM-em jako DAC

#include  "msp430x21x2.h"



#define TEST       BIT1        // P2

#define BUZZ       BIT3        // P2

#define BUZZH      BIT4        // P2



#define DONGLEN 4530

const unsigned char dong[] = {

  2, 2, 244, 252, 24, 3, 218, 0, 52, 251, (itd...)

};



unsigned int  volatile buf_pointer = 0;           // wskaźnik w buforze

unsigned int  volatile play_sample = 0;           // stan odgrywania

unsigned char one_byte;                           // próbka do obróbki



// ##################################################################

void do_config(void)

{

  DCOCTL  = CALDCO_8MHZ;                    // DCO 8MHz

  BCSCTL1 = CALBC1_8MHZ;

  WDTCTL = WDTPW + WDTHOLD;                 // Stop watchdog

// P2 = mix

  P2DIR |=  BUZZ | BUZZH;                   // wejścia(0)-wyjścia(1)

  P2OUT  =  BUZZ;                           // stany początkowe (buzzer off)

  P2SEL  =  0x18;          // 0b00011000    // funkcja podstawowa, P2.3-P2.4 timer

// ustawienie pracy TIMER_A0 - generator dźwięku  

  TA0CCR0  = 0x00FF;                        // pełne wychylenie licznika

  TA0CCR1  = 0x00FF;                        // rejestry porównania zero wypełnienia

  TA0CCR2  = 0x0000;

  TA0CCTL1 = CM_0 | CCIS_2 | OUTMOD_2;      // ustaw PWM - wysoki->niski

  TA0CCTL2 = CM_0 | CCIS_2 | OUTMOD_6;      //             niski->wysoki

  TA0CTL   = TASSEL_2 | ID_0 | MC_1;        // szybki PWM 31kHz

// ustawienie pracy TIMER_A1 - generator czasu

  TA1CCR0 = 1500;                         

  TA1CTL  = TASSEL_2 | ID_1 | MC_1 | TAIE;  // próbkowanie ok. 2kHz

}



// ##################################################################

int main(void)

{

  do_config();                              // przeprowadź niezbędne konfiguracje peryferii

  __enable_interrupt();                     // przerwania włącz

  while(1)

  {

    if ((P2IN & TEST) == TEST)               // czy wejście aktywne?

      play_sample = 1;

  } 

}



// #######################################################################

// ISR Timer1_A1 Interrupt Vector (TAIV)

#pragma vector=TIMER1_A1_VECTOR

__interrupt void Timer1_A1(void)

{

  switch(TA1IV)

  {

    case 0x0A :                             // TA1OVF przepełnienie

      if(play_sample == 1)

      {      

        one_byte = dong[buf_pointer++];     // odczytaj jeden bajt z bufora

        if(buf_pointer == DONGLEN) 

        { 

          buf_pointer = 0;

          play_sample = 0;

          TA0CCR1  = 0x00FF;                // zeruj przebieg z DAC

          TA0CCR2  = 0x0000;          

        }   

        one_byte = one_byte + 127;          // korekcja danych

        TA0CCR1  = one_byte;                // i do DAC

        TA0CCR2  = one_byte;

      }

      break;

  }

}

// #######################################################################

#pragma vector=TIMER0_A1_VECTOR

__interrupt void Timer0_A1(void)

{

  switch(TA0IV)

  {

    case 0x0A :                             // TA0OVF przepełnienie

      TA0CCR1  = one_byte;                  // rejestr danych DAC

      TA0CCR2  = one_byte;

      break;

  } // koniec switch

        if(buf_pointer == DONGLEN) 

        { 

          buf_pointer = 0; 

          play_sample = 0; 

          TA0CCR1  = 0x00FF;                // zeruj przebieg z DAC 

          TA0CCR2  = 0x0000;          

        }  

        one_byte = one_byte + 127;          // korekcja danych 

        TA0CCR1  = one_byte;                // i do DAC 

        TA0CCR2  = one_byte;

#include <avr/io.h>

#include <avr/interrupt.h>

#include <avr/pgmspace.h>

#include <util/delay.h>



uint8_t  volatile play    = 0;

uint16_t volatile pointer = 0;

uint16_t volatile counter = 0;



#include "isospeak.h"



// dane początków i rozmiarów próbek w isospeak.h

const uint16_t wavetab[][2] = {

    {     0,  6060 },

    {  2125,  7105 }, 

    {  9369,  5469 },    // słaba bateria

    { 12295,  5538 }, 

   { 18634,  3045 }     // spadaj

};



//==================================================

ISR(INT0_vect)

{

  if(bit_is_set(PIND, 2))

  {

    cli();

   pointer = wavetab[0][0];

   counter = wavetab[0][1];

   play = 1;

   sei();

  }

  else

  {

    cli();

   pointer = wavetab[1][0];

   counter = wavetab[1][1];

   play = 1;

   sei();

  }

}



//==================================================

ISR(INT2_vect)

{

   cli();

   pointer = wavetab[2][0];

   counter = wavetab[2][1];

   play = 1;

   sei();

}

   

//==================================================

ISR(INT1_vect)

{

    cli();

   pointer = wavetab[4][0];

   counter = wavetab[4][1];

   play = 1;

   sei();

}



//==================================================

ISR(TIMER0_COMP_vect)

{

   uint8_t temp;                                      // zmienna tymczasowa

   

   if(play)                                           // jak play = 1

   {

      if(counter--)                                   // i counter nie wyzerowany

     {

       temp = pgm_read_byte(&wave[pointer++]);      // odczytaj bajt z próbki pod adresem pointer

       temp = temp + 127;                           // korekcja próbki

       OCR1A = temp;                                // niech DAC przetworzy

       OCR1B = temp;

      }

     else

     {

        OCR1A = 255;                                    // DAC wygaś

      OCR1B = 0;

      play = 0;                                     // i koniec gadania

     }

   }

}



//----------------------------------------------------

void config(void)

{

   // konfiguruj porty

   //

   DDRD  = (1<<PD5)|(1<<PD4);

           // OC1A/OC1B outputs

   PORTD = (1<<PD2)|(1<<PD3);

           // INT0/1 inputs high

   PORTB = (1<<PB2);

           // INT2 input high

 

   // konfiguracja PWMa (Timer1) nośna 30kHz

   //

   OCR1A = 255;

   OCR1B = 0;

   TCCR1A = (1<<WGM10)|(1<<COM1A1)|(0<<COM1A0)|(1<<COM1B1)|(1<<COM1B0);

   TCCR1B = (0<<WGM12)|(1<<CS10);

            // mode 1 fastpwm 8bit | oc1a clear | oc1b set | prescaler 1

   

   // konfiguracja licznika

   // generuj przerwania o częstotliwości 6kHz (160us)

   //

   OCR0 = 20;

   TCCR0 = (1<<WGM01)|(1<<CS01)|(1<<CS00);

   TIMSK = (1<<OCIE0);

           // mode 2 ctc | prescaler 64 | 20*8us | int enable

   

   // konfiguracja przerwań

   //

   MCUCR = (1<<ISC10)|(1<<ISC00);

           // int any change

   GICR  = (1<<INT1)|(1<<INT0)|(1<<INT2);

           // INT0/INT1/INT2 enable

}



//----------------------------------------------------

int main(void)

{

   config();

   sei();

   

   while(1);

  

   return 0;

}

#pragma vector=TIMER0_A1_VECTOR 

__interrupt void Timer0_A1(void) 

{ 

  switch(TA0IV) 

  { 

    case 0x0A :                             // TA0OVF przepełnienie 

      Timer0_state++;

      if (Timer0_state >= 12)

          {

          Timer0_state = 0;



          if(play_sample == 1) 

              {      

              one_byte = dong[buf_pointer++];     // odczytaj jeden bajt z bufora 

              if(buf_pointer == DONGLEN) 

                  { 

                  buf_pointer = 0; 

                  play_sample = 0; 

                  TA0CCR1  = 0x00FF;                // zeruj przebieg z DAC 

                  TA0CCR2  = 0x0000;          

                  }    

              one_byte = one_byte + 127;          // korekcja danych 

              TA0CCR1  = one_byte;                // i do DAC 

              TA0CCR2  = one_byte; 

              }

          }

      break; 

  }

}

  TA0CCTL1 = CM_0 | CCIS_2 | OUTMOD_2;      // ustaw PWM - wysoki->niski

  TA0CCTL2 = CM_0 | CCIS_2 | OUTMOD_6;      //             niski->wysoki 

unsigned int  volatile play_sample = 0;           // stan odgrywania 

unsigned char one_byte;                           // próbka do obróbki 

unsigned int one_byte;                           // próbka do obróbki