next topic »

[on:]

is it possible to "repair" a code? upon doing a project for college i had to download the libraries and upload that code onto the board. in doing so, multiple errors arose such as:
void setup() {
  setupIO();
 
  //set initial values
  j = 50;
  value50 = 50;
  value300 = 300;
  value10000 = 1000;
  delayed = 0;
}

void loop() {
 
    //check status of the effect potentiometer and rotary switch
    readKnobs();
 
    // *************
    // ***bitcrush**
    // *************
    if(mode == 6){
      value300 = 1 + ((float) fx / (float) 3);       
      if(delayed > value300) { 
        byte input = analogRead(left);
        input = (input >> 6 << 6);
        output(left, input);
        delayed = 0;
       }
       delayed++;

    }
 

dsp.ccp:3:21: error: Arduino.h: no such file or directory
dsp.ccp: in function 'void setupIO() ' :
dsp.ccp: 8: error: 'analogWrite' was not declared in this scope
dsp.ccp:16: error: 'INTERNAL' was not declared in this scope [/i][/i]

etc.
perhaps i am uploading the libraries incorrectly? i am using both the Arduino 1.0.3 program and the Arduino 0020 program for the code as the author of the project suggested an older program might work better. It hasn't changed anything   
As the code is for the actual project surely it should work no problem?

any input would be greatly appreciated!

[Reply #1 on:]

If you post your real code, we could help. That snippet won't compile on any version of Arduino.

[Reply #2 on:]

oh sorry here it is there are multiple bits of code for the whole thing which are broken up into separate files, i thought that the whole thing would have been in one file? ...

Code:

#include "dsp.h"

// create an array for the delay
byte array[2000];

//define variables
int j;
int fx;
int mode;
int value50;
int value300;
int value10000;
int delayed;

void setup() {
  setupIO();
 
  //set initial values
  j = 50;
  value50 = 50;
  value300 = 300;
  value10000 = 1000;
  delayed = 0;
}

void loop() {
 
    //check status of the effect potentiometer and rotary switch
    readKnobs();
 
    // *************
    // ***bitcrush**
    // *************
    if(mode == 6){
      value300 = 1 + ((float) fx / (float) 3);       
      if(delayed > value300) { 
        byte input = analogRead(left);
        input = (input >> 6 << 6);
        output(left, input);
        delayed = 0;
       }
       delayed++;

    }
   
   
    // ***************
    // ***Overdrive***
    // ***************
    if(mode == 7){
      value50 = 1 + ((float) fx / (float) 20);   
      byte input = analogRead(left);
      input = (input * value50);
      output(left, input);

    }


    //  *************************
    //  ***short crunchy delay***
    //  *************************

    if(mode == 9){
      for(int i = 0; i < 2000; i ++) { // set up a loop   
        //array[i] = array[i] + array[i - 1]; //removes noise and some delay
        output(left, array[i]);
        array[i] = analogRead(left);
      }
    }


    //  **********************
    //  ***clean helicopter***
    //  **********************
    if(mode == 10){
      value10000 = fx * 10; 
      if(delayed > value10000) {
        for(int i = 0; i < 2000; i ++) { // set up a loop   
          array[i] = array[i] + array[i - 1]; //removes noise and delay
          output(left, array[i]);
          array[i] = analogRead(left);
        }
        delayed = 0;
      }
      delayed++;
    }
   
    //  ********************
    //  ***ring modulator***
    //  ********************
    if(mode == 11){
     value50 = 1 + ((float) fx / (float) 20);   
     byte input = analogRead(left);
     input = (input * j);
     output(left, input);
     
     j = j - 1;
     if (j <= 0) {
       j = value50;
     }

    }
   
    //  ************************
    //  ***YOUR AWESOME SOUND***
    //  ************************
    if(mode == 12){
         
      //************************************
      //insert your awesome effect code here
      //************************************
 
    }
   
}

void readKnobs(){
  //read the rotary switch
  //and determine which effect is selected
  //dividing by 75 ensures proper discrete values
  //for if statements above
  mode = analogRead(2);
  mode = mode / 75;
   
  //reads the effects pot to adjust
  //the intensity of the effects above 
  fx = analogRead(3);

}


#include "dsp.h"
#include "timers.h"
#include "WProgram.h"

void setupIO() {
  // prepare left
  waveformGenerationMode(3, fastPWM);
  timerPrescale(3, 1);
  analogWrite(3, 0);
 
  // prepare right
  waveformGenerationMode(5, fastPWM);
  timerPrescale(5, 1);
  analogWrite(5, 0);
 
  // faster input
  analogReference(INTERNAL);
  analogPrescale(analogPrescale32);
}
 
void output(int channel, short value) {
  if(channel == left) {
    pwm3 = value >> 2;
    pwm11 = (value & B11) << 6;
  } else if(channel == right) {
    pwm5 = value >> 2;
    pwm6 = (value & B11) << 6;
  }
}


#define left 0
#define right 1

void setupIO();
void output(int channel, short value);


#include "timers.h"
#include "WConstants.h"

int getTimer(int pin) {
  switch(pin) {
    case 5: case 6: return 0;
    case 9: case 10: return 1;
  }
  return 2; // 3, 11
}

int getChannel(int pin) {
  switch(pin) {
    case 6: case 10: case 11: return 0;
  }
  return 1; // 3, 9, 5
}

// - - -- timer settings

void waveformGenerationMode(int pin, int type) {
  int timer = getTimer(pin);
  int wgm = type == phaseCorrect ? B001 : B011;
  if(timer == 0) {
    TCCR0B &= ~(B1 << 3); // clear WGM02
    TCCR0A &= ~B11; // clear WGM01 and WGM00
    TCCR0A |= wgm; // set WGM01 and WGM00
  } else if(timer == 2) {
    TCCR2B &= ~(B1 << 3); // clear WGM23
    TCCR2A &= ~B11; // clear WGM21 and WGM20
    TCCR2A |= wgm; // set WGM21 and WGM20
  }
}

void waveformGenerationMode(int pin, int type, int bits) {
  int timer = getTimer(pin);
  if(timer == 1) {
    TCCR1B &= ~(B11 << 3); // clear WGM13 and WGM12
    TCCR1A &= ~B11; // clear WGM11 and WGM10
    TCCR1B |= (type << 3); // set WGM12
    TCCR1A |= (bits - 7);
  }
}

void timerPrescale(int pin, int prescale) {
  int timer = getTimer(pin);
  if(timer == 0) {
    TCCR0B &= ~B111; // clear CS02 CS01 CS00
    TCCR0B |= getPrescale01(prescale);
  } else if(timer == 1) {
    TCCR1B &= ~B111; // clear CS12 CS11 CS10
    TCCR1B |= getPrescale01(prescale);
  } else if(timer == 2) {
    TCCR2B &= ~B111; // clear CS22 CS21 CS20
    TCCR2B |= getPrescale2(prescale);
  }
}

int getPrescale01(int prescale) {
  switch(prescale) {
    case 1: return B001;
    case 8: return B010;
    case 64: return B011;
    case 256: return B100;
    case 1024: return B101;
    default: return B000;
  }
}

int getPrescale2(int prescale) {
  switch(prescale) {
    case 1: return B001;
    case 8: return B010;
    case 32: return B011;
    case 64: return B100;
    case 128: return B101;
    case 256: return B110;
    case 1024: return B111;
    default: return B000;
  }
}

// - - -- analog prescaling

void analogPrescale(int divisionFactor) {
  ADCSRA &= ~B111; // clear analog prescale
  ADCSRA |= divisionFactor;
}

[Reply #3 on:]

Code:

byte array[2000];

On a 328-based Arduino, that is all of SRAM. No room for anything else. Are we to presume that this code is not for 328-based Arduinos?

Code:

  //set initial values
  j = 50;
  value50 = 50;
  value300 = 300;
  value10000 = 1000;

Why isn't value10000 assigned a value to match its name?

Code:

#include "WProgram.h"

This is for 0023 and earlier. Are you using 0023 or earlier? Or, are you using 1.0+?

[Reply #4 on:]

the chip is a ATMEGA328 and i changed the code you indicated to the correct value, also instead of using the code on the 1.0.3 version, i just downloaded and switched to the earlier version of 0020. i just uploaded the code there and it is working perfectly so far. Thanks a million for your help i really appreciate it!

[Reply #5 on:]

so far.

That's the key. That array is far to big for a 328-based Arduino. If you ever actually fill it, you'll have all kinds of unpredicatable behavior that will drive you crazy.

Use a reasonable sized array.

[Reply #6 on:]

i am only new to the whole programming idea, but when you mention using a reasonable array size what do you refer to? on different IDE programs is there certain array sizes to suit the program or even a limit for such?

[Reply #7 on:]

on different IDE programs is there certain array sizes to suit the program or even a limit for such?

The IDE used to program the Arduino has nothing to do with the physical limitations of the Arduino.

Each Arduino model has a set amount of memory, of three different kinds - flash, where the code goes, SRAM where variables, stack, heap, etc. go, and EEPROM where you can persist data between power cycles.

The 328-based Arduinos have 2048 bytes of SRAM. All of your variables, the stack, and the heap need to fit in that space.

A size 2000 shoe is not a reasonable size, considering the size 2048 closet it needs to fit in, along with all the other clothes.

[Reply #8 on:]

ah ok i think i'm getting the jist! so if i were to try and limit the code to fit at a reasonable size to the SRAM so that its not overloaded, how could i go about doing that?

[Reply #9 on:]

ah ok i think i'm getting the jist! so if i were to try and limit the code to fit at a reasonable size to the SRAM so that its not overloaded, how could i go about doing that?

There are various methods for determining the amount of free memory available on the forum. Find one. Measure the amount of free memory when setup() runs. Don't use more than about 90% of memory.

Given your code, an array of 1000 is probably OK.