Open Music Labs Forums

guest wrote:feedback is a great idea. there are 2 ways to do this. one is digitally. you just take your output variable and add it back in with your input variable before you do any math. the downside to this is that it takes up more processor resources. you can also do it in analog with a potentiometer. just connect the top of the pot to HP_L, or HP_R which are the headphone outputs. connect the bottom of the pot to HP_C, which is ground. then connect the wiper to IN_L or IN_R. the pot will then allow you to control the level of feedback. a 10k pot should be fine, a log taper would be best, but probably doesnt matter too much.

#define SAMPLE_RATE 22 // 44.1kHz sample rate
#define ADCS 1 // only 1 ADC used here -> MOD0
#define LINVOL 20
// include necessary libraries
#include <Wire.h>
#include <SPI.h>
#include <AudioCodec.h>

// create data variables for audio transfer
// even though the function is mono, the codec requires stereo data
int left_in = 0; // in from codec (LINE_IN)
int right_in = 0;
int left_out = 0; // out to codec (HP_OUT)
int right_out = 0;

// create variable for ADC result
// it only has positive values -> unsigned
unsigned int mod0_value =0;

// create a delay buffer in memory
#define SIZE 800 // buffer size is limited by microcontroller SRAM size
int delaymem[SIZE]; // 800 positions x 2 bytes = 1600 bytes of SRAM
unsigned int location = 0; // buffer location to read/write from
unsigned int boundary = 0; // end of buffer position

void setup() {
  // call this last if you are setting up other things
  
  Serial.begin(9600);
  AudioCodec_init(); // setup codec and microcontroller registers
}

void loop() {
  while (1){
  int sensorValue = mod0_value;
  //Serial.println(sensorValue); //if this isnt commented out then the program freezes
  
  };
  // reduces clock jitter
}

// timer1 interrupt routine - all data processed here
ISR(TIMER1_COMPA_vect, ISR_NAKED) { // dont store any registers

  // &'s are necessary on data_in variables
  AudioCodec_data(&left_in, &right_in, left_out, right_out);
  
  // pass left input to right output
  right_out = left_out;

  //fetch data from buffer and put it into output register
  left_out = delaymem[location];
  // put new data in same location for maximal delay time
  delaymem[location++] = left_in + (left_out * .95); // post increment location to go to next memory location
  // check if location has gotten bigger than buffer size
  //left_in = left_out;
  if (location >= boundary) {
    location = 0; // reset location
  }

  // & is required before adc variable
  AudioCodec_ADC(&mod0_value);

  // scale ADC value to match buffer size
  // note the use of the fancy fast math function
  // you can read about these in the readme file
  unsigned int scale = SIZE;
  unsigned int newmod;
  if (mod0_value > 30000) 
      {
      newmod = 11000;
      }
  if (mod0_value < 30000) 
    {
     if (mod0_value > 10000) 
         {
      newmod = 16500;//low?
         }
         else 
         {
      newmod = 22000;}
      
    }
 // if (mod0_value < 1)
   //  {newmod = 44000;}
  MultiU16X16toH16(boundary, newmod, scale);

  reti(); // dont forget to return from the interrupt
}

guest wrote:ok, so here is probably what the problem is: mod0_value gets modified only in the interrupt, so the main code has no idea that it is changing, and therefore compiles out the (aparantly) non-used code. to fix this, mod0_value needs to become volatile, which tells the compiler that it might be changing elsewhere. but, its not defined that way in the library, so it cant be declared volatile directly. to work around this, do the following:

volatile unsigned int serial_out = 0;

void loop() {
  if (Serial.available() > 0) {
    Serial.println(serial_out)
   }
}

and then in the interrupt:

serial_out = mod0_value;

void loop() {
if (Serial.available() > 0) {
Serial.println(88);
Serial.println(serial_out);
}}

#include <mult16x16.h>
#include <mult16x8.h>
#include <mult32x16.h>

/*
variable_delay.pde
guest openmusiclabs 6.22.11
this program takes input from the left channel, and delays it
by a variable amount, set by the MOD0 knob.  it then presents
this delayed data on the left channel, with the non-delayed
data coming out of the right channel.
*/

// setup codec parameters
// must be done before #includes
// see readme file in libraries folder for explanations
#define SAMPLE_RATE 44 // 44.1kHz sample rate
#define ADCS 2 // only 1 ADC used here -> MOD0
#define LINVOL 22
//#define RHPVOL 127
//#define LHPVOL 127
// include necessary libraries
#include <Wire.h>
#include <SPI.h>
#include <AudioCodec.h>

// create data variables for audio transfer
// even though the function is mono, the codec requires stereo data
int left_in = 0; // in from codec (LINE_IN)
int right_in = 0;
int left_out = 0; // out to codec (HP_OUT)
int right_out = 0;

// create variable for ADC result
// it only has positive values -> unsigned
unsigned int mod0_value =0;
unsigned int mod1_value =0;
//int vol = 0;
// create a delay buffer in memory
#define SIZE 800 // buffer size is limited by microcontroller SRAM size
int delaymem[SIZE]; // 800 positions x 2 bytes = 1600 bytes of SRAM
unsigned int location = 0; // buffer location to read/write from
unsigned int boundary = 0; // end of buffer position

void setup() {
  // call this last if you are setting up other things
  
  Serial.begin(1200);
  Serial.println(88);
  AudioCodec_init(); // setup codec and microcontroller registers
}

volatile unsigned int serial_out = 0;

void loop() {
  if (Serial.available() > 0) {
    Serial.println(88);
    Serial.println(serial_out);
   }}



// timer1 interrupt routine - all data processed here
ISR(TIMER1_COMPA_vect){//, ISR_NAKED) { // dont store any registers
  serial_out = mod0_value;
  // &'s are necessary on data_in variables
  AudioCodec_data(&left_in, &right_in, left_out, right_out);
  unsigned int vol;
  unsigned int off = 1;
  // pass left input to right output
  right_out = left_out;
 
      
  //Serial.println(sensorValue);
  //fetch data from buffer and put it into output register
  left_out = delaymem[location];
  // put new data in same location for maximal delay time

  MultiSU16X16toH16(vol, left_out, mod1_value);
  delaymem[location++] = (left_in + (vol))*off; // post increment location to go to next memory location
  // check if location has gotten bigger than buffer size
  //left_in = left_out;
  if (location >= boundary) {
    location = 0; // reset location
  }

              
  // & is required before adc variable
  AudioCodec_ADC(&mod0_value,&mod1_value);
  
  if (mod1_value < 60000) {
         off = 1;
          } 
          else 
          {
          off = 0;
          }
  // scale ADC value to match buffer size
  // note the use of the fancy fast math function
  // you can read about these in the readme file
  unsigned int scale = SIZE;
  unsigned int newmod;
  
  if (mod0_value > 30000) 
      {
        if (mod0_value < 60000)
        {
      newmod = 11000;
        }
        else
        {
      newmod = 8250;
        }  
    }
  if (mod0_value < 30000) 
    {
     if (mod0_value > 10000) 
         {
      newmod = 16500;//low?
         }
         else 
         {
      newmod = 22000;}
      
    }
     
 // if (mod0_value < 1)
   //  {newmod = 44000;}
  MultiU16X16toH16(boundary, newmod, scale);

  //reti(); // dont forget to return from the interrupt
}

guest wrote:wow, congrats on getting it working with the mega. was there anything extra you had to do, that isnt documented in the mega thread? it would be good info for others.

i dont think i know chris hatfield.