signal.c

This project is created using the Keil ARM CA Compiler. The Logic Analyzer built into the simula

/*
 *
 *  Signal.C:  Demonstrates Signal Processing
 *             with ARM-powered ADuC7024
 *  Copyright KEIL ELEKTRONIK GmbH and KEIL SOFTWARE, Inc. 2003 - 2004
 *
 *  This file may be compiled in ARM or Thumb Mode
 */

#include <aduc7024.h>
#include <math.h>

// CPU Clock
#define CLOCK  22544384   // CPU configured for 22.544384 MHz clock

#define T0_CON  0xC0      // Enable Timer 0, Mode: periodic

//   <o> Reload Frequency (Hz) for Mode periodic <1-1000000>
#define T0_RlFreq  8000   // Timer 0 Reload Frequency

#if   ((T0_CON & 3) == 0)
  #define T0_Pres 1
#elif ((T0_CON & 3) == 1)
  #define T0_Pres 16
#elif ((T0_CON & 3) == 2)
  #define T0_Pres 256
#else
  #error "Illegal Prescale Value for Timer 0"
#endif

#define T0_LD ((unsigned int )(CLOCK / (T0_Pres*T0_RlFreq)))


// ----- Parameters and Variables for Sine Wave Generator ----- 
#define OutFreq 400       // Output Frequency (Range  1Hz - 4000Hz)
#define OutAmpl 200       // Output Amplitute (Range  0 - 0.99)
#define PI  3.1415926

struct tone  {            // struct for Sine Wave Generator Signal
  int  cos;               // cosine factor
  long y1;                // y[-1] value
  int  y2;                // y[-2] value
};

short tval;
signed char cval;
struct tone Tone;

/*
 * Generate Sine Wave Tone
 */
static void Generate_Sine (struct tone *t)  {
  int y;

  y     = (t->cos * (t->y1 >> 14)) - t->y2;
  t->y2 = t->y1;
  t->y1 = y;
  tval = t->y1 >> 16;
  cval = tval;
} 

extern volatile int T0_ticks;
                int T0_last; 


/*
 * Read Analog Input of Channel 'ch'
 */
unsigned long AdcRead (unsigned int ch)  {
  REFCON = 0x01;          //  Power up internal reference
  ADCCP  = ch;            //  Select Channel defined by ch

  ADCCON = 0x0A3;         //  Begin Single Conversion in Single Ended Mode
  while (ADCSTA == 0x01); //  wait for conversation ready
  return ADCDAT >> 16;    //  Return ADC Data resident in bits 27-16
}

int iADCAverage0 = 0;

int main (void) {
  int iADC0;
  unsigned long analog;
    
  DAC0CON = 0x13;                  // Configure DACs Range as AVdd
  DAC1CON = 0x13;

// Configure PWM
 
#define PWM_DEAD 	(0.000005 * (CLOCK/2))  // PWM Dead Time: 5 uSec

  GP3CON  = 0x11;                  // output PWM on P3.0 & P3.1
  PWMDAT0 = CLOCK / (2 * 8000);    // 8 KHz PWM Switching Frequency
  PWMDAT1 = PWM_DEAD;              // Switching Dead Time
  PWM0    = 0;
  PWM1    = 0;
  PWM2    = 0;
  PWMEN   = 0x100;                 // enable 0L/0H output + crossover
  PWMSTA0 = 0x200;
  PWMCON  = 3;                     // enable PWM

  IRQEN = 0x00000004;              // Configure Timer 0
  T0LD  = T0_LD;
  T0CON = T0_CON;

// Initialize Sine Generator
  Tone.cos = (cos (2*PI*((float)OutFreq/T0_RlFreq))) * 32768;
  Tone.y1  = 0;
  Tone.y2  = (sin (2*PI*((float)OutFreq/T0_RlFreq)) * OutAmpl) * 32768;

  while (1) {
    while (T0_ticks == T0_last);      // Synchronize to Timer Interrupt
    T0_last = T0_ticks;
    Generate_Sine (&Tone);            // Generate Sine Wave Output

											     // Output PWM Signal
    PWM0 = ((Tone.y1 >> 8) & 0xFF) + PWM_DEAD;

    analog = ((unsigned long) ((Tone.y1 << 7) + 0x80000000)) >> 4;
    DAC0DAT = analog & 0x0FFF0000;    // Output Sine Wave Output
    iADC0 = AdcRead(0);               // Read ADC0 Value

    // Average is the current average, minus 10th of the current average
    // plus 10th of the new ADC value 
    iADCAverage0 = iADCAverage0 - iADCAverage0 / 10 + iADC0 / 10;
    DAC1DAT = (iADCAverage0 << 16) & 0x0FFF0000;
  }
}