The dsp-G1 Analog Modeling Synthesizer Source Code

dspG1.c

/*
Copyright 2016 DSP Synthesizers Sweden.
Author: Jan Ostman 
This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 
See the GNU General Public License for more details.
*/
　
#include "wiring.h"
#include "LPC8xx.h"
#include "sct_fsm.h"
　
/* Control register bit definition. */
#define MRT_INT_ENA          (0x1<<0)
#define MRT_REPEATED_MODE    (0x00<<1)
#define MRT_ONE_SHOT_INT     (0x01<<1)
#define MRT_ONE_SHOT_STALL   (0x02<<1)
　
/* Status register bit definition */
#define MRT_STAT_IRQ_FLAG    (0x1<<0)
#define MRT_STAT_RUN         (0x1<<1)
　
#define SPI_CFG_ENABLE (0x1)
#define SPI_CFG_MASTER (0x4)
#define SPI_STAT_RXRDY (0x1)
#define SPI_STAT_TXRDY (0x2)
#define SPI_STAT_SSD (0x20)
#define SPI_STAT_MSTIDLE (0x100)
#define SPI_TXDATCTL_SSEL_N(s) ((s) << 16)
#define SPI_TXDATCTL_EOT (1 << 20)
#define SPI_TXDATCTL_EOF (1 << 21)
#define SPI_TXDATCTL_RXIGNORE (1 << 22)
#define SPI_TXDATCTL_FLEN(l) ((l) << 24)
　
//-------- Synth parameters --------------
uint32_t FREQ[15]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; //OSC pitches
volatile int32_t CUTOFF=65535;     //freq 0-65535
volatile int32_t CFREQ=65535;      //freq 0-65535
volatile int32_t RESONANCE=0;      //reso=0-65535
volatile uint8_t TRIG=1;           //MIDItrig 1=note ON
volatile uint32_t ATTACK0=0xFFFF;  //Attackrate in 30mS steps
volatile uint32_t DECAY0=0xFFFF;       //Decayrate in 30mS steps
volatile int32_t SUSTAIN0=0xFFFF;  //Sustainlevel 0-65535
volatile uint32_t RELEASE0=0xFFFF;    //Releaserate in 30mS steps
volatile uint32_t ATTACK1=0xFFFF;	   //Attackrate in 30mS steps
volatile uint32_t DECAY1=0xFFFF;       //Decayrate in 30mS steps
volatile int32_t SUSTAIN1=0xFFFF;  //Sustainlevel 0-65535
volatile uint32_t RELEASE1=0xFFFF;      //Releaserate in 30mS steps
volatile uint32_t DETUNE=1;		   //Osc spread or detune
volatile uint32_t RANGE=64;		   //Osc range
volatile uint8_t ENVMOD=0;		   //Filter ENVMOD
volatile uint8_t LFOMOD=0;		   //Filter LFOMOD
volatile uint8_t WAVEFORM=255;	   //OSC Waveform
volatile uint8_t WRAP=0;		   //OSC Wrap
volatile uint8_t LFORATE=0;		   //LFO frequency
volatile uint8_t LFOWAVE=0;		   //LFO waveform
volatile int32_t MASTERVOL=65535;  //Master volume
volatile uint8_t CHORUSRATE=0;     //Chorus rate
volatile uint8_t CHORUSMOD=0;      //Chorus modlevel
volatile int32_t CHORUSMIX;        //Chorus mix level
volatile int32_t CHORUSFB;         //Chorus feedback level
//-----------------------------------------
　
volatile uint8_t GATED=0;
　
volatile uint16_t DACL=1;
volatile uint16_t DACR=1;
uint32_t DCOPH[15];
　
volatile uint8_t state0=0;    //needs to be reset on a new trig
volatile uint8_t state1=0;    //needs to be reset on a new trig
volatile int32_t volume0=0;
volatile int32_t volume1=0;
volatile uint16_t envstat=1;
volatile uint16_t lfostat=1;
　
int32_t t[9];
　
int32_t vi;
int32_t vo;
　
int16_t DCO;
int16_t DCF;
int32_t ENV;
　
int32_t ENVsmoothing;
　
uint8_t lfocounter=0;
uint32_t next = 1;
volatile uint8_t shrandom;
uint8_t chrcounter=0;
uint8_t pwmcounter=0;
　
int8_t waveform[256];
const uint32_t NOTES[12]={208065>>2,220472>>2,233516>>2,247514>>2,262149>>2,277738>>2,294281>>2,311779>>2,330390>>2,349956>>2,370794>>2,392746>>2};
　
volatile uint8_t MIDISTATE=0;
volatile uint8_t MIDIRUNNINGSTATUS=0;
volatile uint8_t MIDINOTE;
volatile uint8_t MIDIVEL;
uint8_t OSCNOTES[5];
const uint16_t ENVRATES[32] = {65535>>2,61540>>2,57544>>2,53548>>2,49552>>2,45556>>2,41560>>2,37564>>2,33568>>2,29572>>2,25576>>2,21580>>2,17584>>2,13588>>2,9592>>2,5596>>2,1600>>2,1503>>2,1407>>2,1311>>2,1215>>2,1119>>2,1022>>2,926>>2,830>>2,734>>2,638>>2,541>>2,445>>2,349>>2,253>>2,157>>2 };
　
/*int8_t delayline[2048];
volatile uint16_t writeptr = 0;
volatile uint16_t delayL = 0;
volatile uint16_t delayR = 1023;
volatile int16_t leftCH;
volatile int16_t rightCH;
volatile int32_t chmixL;
volatile int32_t chmixR;
*/
　
　
//---------------- Get the base frequency for the MIDI note ---------------
uint32_t MIDI2FREQ(uint8_t note) {
  uint8_t key=note%12;
  if (note<36) return (NOTES[key]>>(1+(35-note)/12));
  if (note>47) return (NOTES[key]<<((note-36)/12));
  return NOTES[key];
}
//-------------------------------------------------------------------------
　
void MRT_IRQHandler(void) {
  if ( LPC_MRT->Channel[0].STAT & MRT_STAT_IRQ_FLAG ) {
    LPC_MRT->Channel[0].STAT = MRT_STAT_IRQ_FLAG;      /* clear interrupt flag */
　
    uint8_t i;
　
    //-------------------- 15 DCO block ------------------------------------------
    DCO=0;
    for (i=0;i<15;i++) {
    	DCOPH[i] += FREQ[i];              //Add freq to phaseacc's
    		DCO += waveform[(DCOPH[i]>>15)&255];  //Add DCO's to output
    }
    DCO = DCO<<4;
    //---------------------------------------------------------------------------
　
    //---------------- DCF block ---------------------------------------
    //C implementation for a 4pole lowpass DCF with resonance:
　
    vi=DCO;
    for (i=0;i<8;i++) {
    t[i] = ((t[i] * (65536 - CFREQ)) + (t[i+1] * CFREQ))>>16;  //+3dB per iteration
    }
    t[8] = vi-((t[0]*RESONANCE)>>16);  //resonance feedback
    DCF=t[0];
    //-----------------------------------------------------------------
　
    //--------------------- ENV block ---------------------------------
    if (!envstat--) {
    envstat=256;
    if (TRIG) {
　
    	if (state0==1) {
    		volume0 -= DECAY0;
    		if (SUSTAIN0>volume0) {
    			volume0=SUSTAIN0;
    			state0++;
    		}
    	}
    	if (state0==0) {
    		volume0 += ATTACK0;
    		if (volume0>0xFFFF) {
    			volume0=0xFFFF;
    			state0++;
    		}
    	}
    	if (state1==1) {
    		volume1 -= DECAY1;
    	    if (SUSTAIN1>volume1) {
    	        volume1=SUSTAIN1;
    	        state1++;
    	    }
    	}
　
    	if (state1==0) {
    		volume1 += ATTACK1;
    	    if (volume1>0xFFFF) {
    	    	volume1=0xFFFF;
    	    	state1++;
    	    }
    	}
    }
    if (!TRIG) {
    		volume0 -= RELEASE0;
    		if (volume0<0) {
    			volume0=0;
    		}
　
    		volume1 -= RELEASE1;
    		if (volume1<0) {
    		    volume1=0;
    		}
　
    }
    }
　
    //ENV=(volume0*DCF)>>16;
    ENVsmoothing += (volume0-ENVsmoothing)>>8;
    ENV=(ENVsmoothing*DCF)>>16;
　
    if (!lfostat--) {
        lfostat=1024;
　
    //-------------------- LFO block ----------------------------------
    int8_t TRILFO;
    lfocounter+=LFORATE;
    TRILFO=(lfocounter&127);
    if (lfocounter&128) TRILFO=127-(lfocounter&127);
    TRILFO=127-(TRILFO<<1);
    if (LFOWAVE<64) {
    	CFREQ=(int32_t)((TRILFO*LFOMOD)+((volume1>>8)*ENVMOD));
    	CFREQ=CFREQ+CUTOFF;
    	if (CFREQ>65535) CFREQ=65535;
    	if (CFREQ<0) CFREQ=0;
    }
    else {
    	if (lfocounter&128) {
    		CFREQ=(int32_t)((shrandom*LFOMOD)+((volume1>>8)*ENVMOD));
    		CFREQ=CFREQ+CUTOFF;
    		if (CFREQ>65535) CFREQ=65535;
    		if (CFREQ<0) CFREQ=0;
    		lfocounter=0;
    	}
    }
　
　
    /*
    chrcounter+=CHORUSRATE;
    uint8_t chrlfo=(chrcounter&127);
    if (chrcounter&128) chrlfo=127-(chrcounter&127);
    chrlfo=chrlfo<<1;
    //Set right & left delayline taps
    delayR=(CHORUSMOD*chrlfo)>>6;
    delayL=(CHORUSMOD*(255-chrlfo))>>6;
    */
	}
    //-----------------------------------------------------------------
　
　
　
    //-----------------------------------------------------------------
　
    //---------------- Stereo Chorus/Flanger block ---------------------
    /*
    //Right & left delay line taps
    leftCH=delayline[(delayL+writeptr)&0x7FF]<<8;
    rightCH=delayline[(delayR+writeptr)&0x7FF]<<8;
    //Dry & wet mix level
    chmixL=((leftCH*CHORUSMIX)>>16)+((ENV*(65535-CHORUSMIX))>>16);
    chmixR=((rightCH*CHORUSMIX)>>16)+((ENV*(65535-CHORUSMIX))>>16);
    //Delay line feedback
    delayline[writeptr++]=(ENV-(leftCH*CHORUSFB)-(rightCH*CHORUSFB))>>8;
    writeptr&=0x7FF;
    */
    //-------------------------------------------------------------------
　
    ENV=(MASTERVOL*ENV)>>16;
    //chmixR=(MASTERVOL*ENV)>>16;
　
    DACL=513+(ENV>>6);
    //DACR=513+(chmixR>>6);
	LPC_SCT->MATCHREL[1].L  = DACL; //Left Audio Output
	//LPC_SCT->MATCHREL[1].H  = DACR; //Right Audio Output
　
  }
　
  return;
}
　
void handleMIDICC(uint8_t CC,uint8_t value) {
	uint8_t i;
　
　
	/*
	 MIDI CCs:
　
	 CUTOFF       = CC#74
	 RESONANCE    = CC#71
	 FILTER A     = CC#82
	 FILTER D     = CC#83
	 FILTER S     = CC#28
	 FILTER R     = CC#29
	 FILTER ENV M = CC#81
	 FILTER LFO M = CC#01
　
	 WAVEFORM     = CC#76
	 WRAP		  = CC#04
	 RANGE        = CC#21
	 DETUNE       = CC#93
	 OSCENV A     = CC#73
	 OSCENV D     = CC#75
	 OSCENV S     = CC#31
	 OSCENV R     = CC#72
　
	 MASTERVOL    = CC#07
	 LFORATE      = CC#16
	 LFOWAVE      = CC#20
　
	 CHORUS		  = CC#12
　
	 My keyboard:
	 Filter Resonance (Timbre/Harmonic Intensity) (cc#71)
     Release Time (cc#72)
	 Attack time (cc#73)
	 Brightness/Cutoff Frequency (cc#74)
	 Decay Time (cc#75)
	 Vibrato Rate (cc#76)
	 Vibrato Depth (cc#77)
     Vibrato Delay (cc#78)
　
	 */
	switch(CC) {
	case 74:
		CUTOFF=value<<9;
	break;
	case 71:
		RESONANCE=value<<9;
	break;
	case 82:
		ATTACK1=ENVRATES[value>>2];
	break;
	case 83:
		DECAY1=ENVRATES[value>>2];
	break;
	case 28:
		SUSTAIN1=value<<9;
	break;
	case 29:
		RELEASE1=ENVRATES[value>>2];
	break;
	case 73:
		ATTACK0=ENVRATES[value>>2];
	break;
	case 75:
		DECAY0=ENVRATES[value>>2];
	break;
	case 31:
		SUSTAIN0=value<<9;
	break;
	case 72:
		RELEASE0=ENVRATES[value>>2];
		GATED=value;
	break;
	case 93:
		DETUNE=value;
		for (i=0;i<5;i++) {
		  if (FREQ[i*3]) {
			  FREQ[i*3+1]=FREQ[i*3]+((FREQ[i*3]/50)*DETUNE/127)+((FREQ[i*3]/2)*RANGE/32);
			  FREQ[i*3+2]=FREQ[i*3]-((FREQ[i*3]/50)*DETUNE/127)+((FREQ[i*3]/2)*RANGE/32);
		  }
		}
	break;
	case 21:
		RANGE=value;
		for (i=0;i<5;i++) {
		  if (FREQ[i*3]) {
			  FREQ[i*3+1]=FREQ[i*3]+((FREQ[i*3]/50)*DETUNE/127)+((FREQ[i*3]/2)*RANGE/32);
			  FREQ[i*3+2]=FREQ[i*3]-((FREQ[i*3]/50)*DETUNE/127)+((FREQ[i*3]/2)*RANGE/32);
		  }
		}
	break;
	case 81:
		ENVMOD=value<<1;
	break;
	case 01:
		LFOMOD=value<<1;
	break;
	case 16:
		LFORATE=(value>>1)+1;
	break;
	case 76:
		WAVEFORM=value<<1;
	break;
	case 04:
		WRAP=value<<1;
	break;
	case 20:
		LFOWAVE=value;
	break;
	case 07:
		MASTERVOL=value<<9;
	break;
	}
　
}
　
void handleMIDINOTE(uint8_t status,uint8_t note,uint8_t vel) {
	uint8_t i;
	//uint8_t trigflag=0;
	uint32_t freq;
	if ((!vel)&&(status==0x90)) status=0x80;
	if (status==0x80) {
	      for (i=0;i<5;i++) {
	    	  if (OSCNOTES[i]==note) {
	    		  if (!GATED) {
	    		  FREQ[i*3]=0;
	    		  FREQ[i*3+1]=0;
	    		  FREQ[i*3+2]=0;
	    		  }
	    		  OSCNOTES[i]=0;
	    	  }
	    	  //trigflag+=OSCNOTES[i];
	      }
	      if (!(OSCNOTES[0]|OSCNOTES[1]|OSCNOTES[2]|OSCNOTES[3]|OSCNOTES[4])) TRIG=0;
	      return;
	}
　
	if (status==0x90) {
		if ((!TRIG)&&(GATED)) {
			for (i=0;i<14;i++) {
				FREQ[i]=0;
			}
		}
		i=0;
		while (i<5) {
	      if (!OSCNOTES[i]) {
    		  freq=MIDI2FREQ(note);
    		  FREQ[i*3]=freq;
			  FREQ[i*3+1]=FREQ[i*3]+((FREQ[i*3]/50)*DETUNE/127)+((FREQ[i*3]/2)*RANGE/32);
			  FREQ[i*3+2]=FREQ[i*3]-((FREQ[i*3]/50)*DETUNE/127)+((FREQ[i*3]/2)*RANGE/32);
	    	  OSCNOTES[i]=note;
	    	  if (!TRIG) {
	    		  TRIG=1;
	    		  state0=0;
	    		  state1=0;
	    	  }
	    	  return;
	      }
	      i++;
		}
	}
　
}
　
void UART0_IRQHandler(void) {
      uint8_t MIDIRX;
	  while (!(LPC_USART0->STAT & UART_STATUS_TXRDY));
	  MIDIRX = LPC_USART0->RXDATA;
　
	  /*
	  Handling "Running status"
	  1.Buffer is cleared (ie, set to 0) at power up.
	  2.Buffer stores the status when a Voice Category Status (ie, 0x80 to 0xEF) is received.
	  3.Buffer is cleared when a System Common Category Status (ie, 0xF0 to 0xF7) is received.
	  4.Nothing is done to the buffer when a RealTime Category message is received.
	  5.Any data bytes are ignored when the buffer is 0.
	  */
　
	  if ((MIDIRX>0xBF)&&(MIDIRX<0xF8)) {
		  MIDIRUNNINGSTATUS=0;
		  MIDISTATE=0;
		  return;
	  }
　
	  if (MIDIRX>0xF7) return;
　
	  if (MIDIRX & 0x80) {
		  MIDIRUNNINGSTATUS=MIDIRX;
		  MIDISTATE=1;
		  return;
	  }
　
	  if (MIDIRX < 0x80) {
	  	  if (!MIDIRUNNINGSTATUS) return;
	  	  if (MIDISTATE==1) {
	  		  MIDINOTE=MIDIRX;
	  		  MIDISTATE++;
	  		  return;
	  	  }
	  	  if (MIDISTATE==2) {
	  		  MIDIVEL=MIDIRX;
	  		  MIDISTATE=1;
	  		  if ((MIDIRUNNINGSTATUS==0x80)||(MIDIRUNNINGSTATUS==0x90)) handleMIDINOTE(MIDIRUNNINGSTATUS,MIDINOTE,MIDIVEL);
	  		  if (MIDIRUNNINGSTATUS==0xB0) handleMIDICC(MIDINOTE,MIDIVEL);
　
	  		  return;
	  	  }
	  	  }
　
	  return;
}
　
　
void mrtInit(uint32_t delay)
{
  /* Enable clock to MRT and reset the MRT peripheral */
  LPC_SYSCON->SYSAHBCLKCTRL |= (0x1<<10);
  LPC_SYSCON->PRESETCTRL &= ~(0x1<<7);
  LPC_SYSCON->PRESETCTRL |= (0x1<<7);
　
  LPC_MRT->Channel[0].INTVAL = delay;
  LPC_MRT->Channel[0].INTVAL |= 0x1UL<<31;
　
  LPC_MRT->Channel[0].CTRL = MRT_REPEATED_MODE|MRT_INT_ENA;
　
  /* Enable the MRT Interrupt */
#if NMI_ENABLED
  NVIC_DisableIRQ( MRT_IRQn );
  NMI_Init( MRT_IRQn );
#else
  NVIC_EnableIRQ(MRT_IRQn);
#endif
  return;
}
　
/*
for(uint8_t bit = 0x80; bit; bit >>= 1) {
      if(c & bit) *dataport |=  datapinmask;
      else        *dataport &= ~datapinmask;
      *clkport |=  clkpinmask;
      *clkport &= ~clkpinmask;
    }
*/
　
int main(void)
{
  /* Initialise the GPIO block */
	  /* Enable AHB clock to the GPIO domain. */
	  LPC_SYSCON->SYSAHBCLKCTRL |=  (1 << 6);
	  LPC_SYSCON->SYSAHBCLKCTRL |=  (1 << 11); //Enable SPI0 clk
	  LPC_SYSCON->PRESETCTRL    &= ~(1 << 10);
	  LPC_SYSCON->PRESETCTRL    |=  (1 << 10);
	  LPC_SYSCON->PRESETCTRL    &= ~(1); //Reset SPI0
	  LPC_SYSCON->PRESETCTRL    |=  (1); //Reset SPI0
      LPC_SWM->PINENABLE0 = 0xffffffffUL; //All 6 GPIO enabled
　
      LPC_SYSCON->SYSAHBCLKCTRL |= (1 << 8); // enable the SCT clock
      LPC_SCT->CTRL_L |= ((0 << 5) | (1<<3)); // set pre-scalar, SCT clock, clear counter
      LPC_SCT->CTRL_H |= ((0 << 5) | (1<<3)); // set pre-scalar, SCT clock, clear counter
　
      sct_fsm_init();
      LPC_SCT->CTRL_L &= ~(1<<2); // unhalt the SCT by clearing bit 2 in CTRL
      LPC_SCT->CTRL_H &= ~(1<<2); // unhalt the SCT by clearing bit 2 in CTRL
      LPC_SWM->PINASSIGN6 = 0x03ffffffUL; /* CTOUT_0 = P0_3*/
      LPC_SWM->PINASSIGN7 = 0x0fffff02UL; /* CTOUT_1 = P0_2*/
　
      /* Set Switch matrix for SPI0 here
      LPC_SWM->PINASSIGN3 = 0x**ffffffUL; //CLK
      LPC_SWM->PINASSIGN4 = 0xffffff**UL; //MOSI
      LPC_SWM->PINASSIGN4 = 0xffff**ffUL; //MISO
      LPC_SWM->PINASSIGN4 = 0xff**ffffUL; //SSEL
      */
　
      LPC_SPI0->DIV=1; //24MHz SPI CLK
　
      /* Pin Assign 8 bit Configuration */
      /* U0_TXD */
      /* U0_RXD */
      LPC_SWM->PINASSIGN0 = 0xffff0004UL;
　
      /* Initialise the UART0 block for printf output */
      uart0Init(31250);
　
      //SystemCoreClockUpdate();
　
      /* Configure the multi-rate timer for 44.1K ticks */
      //mrtInit(__SYSTEM_CLOCK/42188);
      mrtInit(48000000/42188);
　
      uint16_t i;
      for (i=0;i<256;i++) {
    	waveform[i]=(i-127);
      }
      for (i=0;i<5;i++) {
        FREQ[i] = 0;
      }
      i=0;
	  int8_t TRI;
	  int8_t SQR;
	  int8_t SAW;
	  int16_t SUM;
      while(1) {
    	  for (i=0;i<256;i++) {
    		  shrandom=i&255;
    	    SUM=0;
    	    TRI=(i&127);
    	    if (i&128) TRI=127-(i&127);
    	    if (i&128) {
    	      SQR=127;
    	    }
    	    else {
    	      SQR=-127;
    	    }
    	    SAW=i-127;
    	    if (WAVEFORM<128) {
    	    	SUM+=TRI*((127-WAVEFORM)*2);
    	    	SUM+=SQR*(WAVEFORM*2);
    	    }
    	    if (WAVEFORM>127) {
    	    	SUM+=SQR*((255-WAVEFORM)*2);
    	    	SUM+=SAW*((WAVEFORM-128)*2);
    	    }
    	    if (i<=WRAP) {
    	      waveform[i]=(waveform[i]+(-SUM>>8))>>1;
    	    }
    	    else {
    	      waveform[i]=(waveform[i]+(SUM>>8))>>1;
    	    }
    	    //shrandom=LPC_MRT->Channel[0].TIMER & 255;
    	  }
      }
}
　
　
　
　
　
　
　
　
　
　
　

hi! im very new to electronics so, my basic question is this...
this code was writen for an LPC810 chip ARM M0
is it possible to upload it on some type of another chip?
traslate it n stuff? sorry for my lack of knowledge!