Problem with the Encoder library

Status
Not open for further replies.
On Teensy 3.2
I was using the encoder library with no problems, but suddenly they are not working properly anymore. It compiles but I get this big message
Code:
In file included from /Applications/Arduino 1.8.3.app/Contents/Java/hardware/teensy/avr/libraries/Encoder/Encoder.h:41:0,
                 from /Users/gustavosilveira/Dropbox/Arduino (sketches)/GuitarSynth/guitarSynth11_debug/guitarSynth11_debug.ino:74:
/Applications/Arduino 1.8.3.app/Contents/Java/hardware/teensy/avr/libraries/Encoder/utility/direct_pin_read.h:7:0: warning: "PIN_TO_BASEREG" redefined
 #define PIN_TO_BASEREG(pin)             (portInputRegister(digitalPinToPort(pin)))
 ^
In file included from /Applications/Arduino 1.8.3.app/Contents/Java/hardware/teensy/avr/libraries/SD/SD_t3.h:50:0,
                 from /Applications/Arduino 1.8.3.app/Contents/Java/hardware/teensy/avr/libraries/SD/SD.h:2,
                 from /Applications/Arduino 1.8.3.app/Contents/Java/hardware/teensy/avr/libraries/Audio/play_sd_raw.h:32,
                 from /Applications/Arduino 1.8.3.app/Contents/Java/hardware/teensy/avr/libraries/Audio/Audio.h:99,
                 from /Users/gustavosilveira/Dropbox/Arduino (sketches)/GuitarSynth/guitarSynth11_debug/guitarSynth11_debug.ino:1:
/Applications/Arduino 1.8.3.app/Contents/Java/hardware/teensy/avr/libraries/SD/utility/ioreg.h:46:0: note: this is the location of the previous definition
 #define PIN_TO_BASEREG(pin)             (portOutputRegister(pin))
 ^
In file included from /Applications/Arduino 1.8.3.app/Contents/Java/hardware/teensy/avr/libraries/Encoder/Encoder.h:41:0,
                 from /Users/gustavosilveira/Dropbox/Arduino (sketches)/GuitarSynth/guitarSynth11_debug/guitarSynth11_debug.ino:74:
/Applications/Arduino 1.8.3.app/Contents/Java/hardware/teensy/avr/libraries/Encoder/utility/direct_pin_read.h:8:0: warning: "PIN_TO_BITMASK" redefined
 #define PIN_TO_BITMASK(pin)             (digitalPinToBitMask(pin))
 ^
In file included from /Applications/Arduino 1.8.3.app/Contents/Java/hardware/teensy/avr/libraries/SD/SD_t3.h:50:0,
                 from /Applications/Arduino 1.8.3.app/Contents/Java/hardware/teensy/avr/libraries/SD/SD.h:2,
                 from /Applications/Arduino 1.8.3.app/Contents/Java/hardware/teensy/avr/libraries/Audio/play_sd_raw.h:32,
                 from /Applications/Arduino 1.8.3.app/Contents/Java/hardware/teensy/avr/libraries/Audio/Audio.h:99,
                 from /Users/gustavosilveira/Dropbox/Arduino (sketches)/GuitarSynth/guitarSynth11_debug/guitarSynth11_debug.ino:1:
/Applications/Arduino 1.8.3.app/Contents/Java/hardware/teensy/avr/libraries/SD/utility/ioreg.h:47:0: note: this is the location of the previous definition
 #define PIN_TO_BITMASK(pin)             (1)
 ^

In the previous versions of my code it's still working fine. I think it might be something with the Audio Library. I'm building a synthesizer.
Here is the complete code:

Code:
#include <Audio.h>
#include <Wire.h>
#include <SPI.h>
#include <SD.h>
#include <SerialFlash.h>

// GUItool: begin automatically generated code
AudioSynthWaveformDc     dc2;            //xy=3305,4372.5
AudioSynthWaveform       waveform1;      //xy=3332,4065.5
AudioSynthWaveform       waveform4;      //xy=3334,4200.5
AudioSynthWaveform       waveform3;      //xy=3336,4160.5
AudioSynthWaveform       waveform2;      //xy=3337,4119.5
AudioSynthWaveform       filterFreqMod;  //xy=3473,4298.5
AudioEffectEnvelope      envelope3;      //xy=3516,4372.5
AudioMixer4              mixer1;         //xy=3562,4132.5
AudioMixer4              mixer4;         //xy=3706.5000553131104,4260.5000648498535
AudioFilterStateVariable filter1;        //xy=3871,4139.5
AudioSynthWaveform       AMod;           //xy=3976,4334.5
AudioSynthWaveformDc     dc1;            //xy=3986,4402.5
AudioEffectMultiply      multiply1;      //xy=4109,4219.5
AudioMixer4              mixer2;         //xy=4150,4343.5
AudioEffectEnvelope      envelope1;      //xy=4347,4221.5
AudioMixer4              mixer3;         //xy=4512,4240.5
AudioOutputI2S           i2s1;           //xy=4701,4240.5
AudioOutputUSB           usb1;           //xy=4708,4300.5
AudioConnection          patchCord1(dc2, envelope3);
AudioConnection          patchCord2(waveform1, 0, mixer1, 0);
AudioConnection          patchCord3(waveform4, 0, mixer1, 3);
AudioConnection          patchCord4(waveform3, 0, mixer1, 2);
AudioConnection          patchCord5(waveform2, 0, mixer1, 1);
AudioConnection          patchCord6(filterFreqMod, 0, mixer4, 0);
AudioConnection          patchCord7(envelope3, 0, mixer4, 1);
AudioConnection          patchCord8(mixer1, 0, filter1, 0);
AudioConnection          patchCord9(filter1, 0, multiply1, 0);
AudioConnection          patchCord10(AMod, 0, mixer2, 0);
AudioConnection          patchCord11(dc1, 0, mixer2, 1);
AudioConnection          patchCord12(multiply1, envelope1);
AudioConnection          patchCord13(mixer2, 0, multiply1, 1);
AudioConnection          patchCord14(envelope1, 0, mixer3, 0);
AudioConnection          patchCord15(mixer3, 0, i2s1, 0);
AudioConnection          patchCord16(mixer3, 0, i2s1, 1);
AudioConnection          patchCord17(mixer3, 0, usb1, 0);
AudioConnection          patchCord18(mixer3, 0, usb1, 1);
AudioControlSGTL5000     sgtl5000_1;     //xy=4471,4405.5
// GUItool: end automatically generated code


/////////////////////////////////////////////
// PWM bit shifter
// You can choose the latch pin yourself.
const int ShiftPWM_latchPin = 8;

// ** uncomment this part to NOT use the SPI port and change the pin numbers. This is 2.5x slower **
#define SHIFTPWM_NOSPI
const int ShiftPWM_dataPin = 11;
const int ShiftPWM_clockPin = 13;

// If your LED's turn on if the pin is low, set this to true, otherwise set it to false.
const bool ShiftPWM_invertOutputs = true;

// You can enable the option below to shift the PWM phase of each shift register by 8 compared to the previous.
// This will slightly increase the interrupt load, but will prevent all PWM signals from becoming high at the same time.
// This will be a bit easier on your power supply, because the current peaks are distributed.
const bool ShiftPWM_balanceLoad = false;
/////////////////////////////////////////////

/////////////////////////////////////////////
// line - creates a smooth line between one value and the other
line portamentoLine; //create a line for portamento
line filterLine; //cretaes a line for the cuttof
line volumeLine; //cretaes a line for the volume

#include <ShiftPWM.h>   // include ShiftPWM.h after setting the pins!
#include <Encoder.h>  //makes all the work for you on reading the encoder
#include <Multiplexer4067.h> // Multiplexer CD4067 library >> https://github.com/sumotoy/Multiplexer4067
//#include <AnalogSmooth.h> // Smooths the analog input (avarages)

/////////////////////////////////////////////
// Multiplexer
Multiplexer4067 multiplexer = Multiplexer4067(0, 1, 22, 21, A10);

/////////////////////////////////////////////
// Oscilators
int minFreq = 40;
int maxFreq = 2000;

// OSCs
const int oscN = 4;
int oscWaveForm[oscN] = {WAVEFORM_SAWTOOTH, WAVEFORM_SQUARE, WAVEFORM_TRIANGLE, WAVEFORM_SINE}; // 0 = Saw; 1 = square; 2 = tri; 3 = sine
float oscOctave[oscN][3] = {{1, 2, 4}, {1, 2, 4}, {1, 2, 4}, {0.5, 0.25}}; //Use this numbers to multipky the frequencies, so you get different octaves
float oscFreq[oscN] = {300, 300, 300, 300};
int oscLastFreq[oscN] = {300, 300, 300, 300};
float oscLevel[oscN] = {0.1, 0.1, 0.1, 0.1};
float oscPwm[oscN] = {0.5, 0.5, 0.5, 0.5};
int oscOctaveIndex[oscN] = {0, 0, 0, 0};

/////////////////////////////////////////////
//line
byte glide = 1;
int portamentoLineTime = 10;
int filterLineTime = 20;
int volumeLineTime = 10;

/////////////////////////////////////////////
//Filter
int filterFreq = 15000;
float filterQ = 0.7; //from 0.7-5.0
float filterOctaves = 2;
//boolean filterMoved = false;

/////////////////////////////////////////////
// filterFreqMod
int filterLFOosc = WAVEFORM_SINE;
float filterLFOfreq = 2;
float filterLFOlevel = 1;

/////////////////////////////////////////////
// amplitude modulation
int AMODosc = WAVEFORM_SINE;
float AMODfreq = 7;
float AMODlevel = 0;
boolean ampModOnOff = false;

/////////////////////////////////////////////
//dc
int dcLevel = 1 + AMODlevel; //dc is used to invert the level of the AM

/////////////////////////////////////////////
// mixers
float mixer1Gain[oscN] = {0.5, 0, 0, 0};
//mixer 3 - final mix
float mixer3Gain[oscN] = {0.7, 0, 0, 0};
// Amp modulation mix
float mixer2Gain[oscN] = {0, 1, 0, 0};
// mixers
float mixer4Gain[oscN] = {0, 0, 0, 0}; // Filter's LFO - Filter's ADSR


//// feedback delay mixer 1
//float fdMixer1Gain1 = 0.7; // wet signal
//float fdMixer1Gain0 = 1 - fdMixer1Gain1; // dry signal
////mixers out LR
//float mixerOutGain = 0.6;
////mixer out mono
//float mixerOutMonoGain = 1;

/////////////////////////////////////////////
// note on/off
boolean noteIsPlaying = false; // stores if the note ins playing or not

/////////////////////////////////////////////
// delay
int delayTime = 100; // milisseconds

/////////////////////////////////////////////
// Leds
const byte ledNum = 24; // total number of leds used
unsigned char maxBrightness = 255;
unsigned char pwmFrequency = 75;
unsigned int numRegisters = 3;
unsigned int numOutputs = numRegisters * 8;
unsigned int numRGBLeds = numRegisters * 8 / 3;
unsigned int fadingMode = 0; //start with all LED's off.
byte encoderLed[ledNum] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23};

/////////////////////////////////////////////
// Encoders
const int encoderN = 8; //number of encoders
const int encoderNPins = encoderN * 2; //number of pins used by the encoders
const int banksN = 2; //number of banks
//this array stores the two pins of every encoder
Encoder encoder[encoderN] = {{2, 3}, {4, 5}, {6, 7}, {18, 9}, {10, 19}, {12, 20}, {14, 15}, {16, 17}};
int lastEncoderValue[banksN][encoderN] = {127};
int encoderValue[banksN][encoderN] = {127};

/////////////////////////////////////////////
//Buttons
const byte buttonN = 1;
const byte totalButtons = encoderN + buttonN;

byte buttonPin[totalButtons] = {0, 1, 2, 3, 4, 5, 6, 7, 14};
int buttonVal[totalButtons] = {0};
int buttonCState[totalButtons] = {0}; // estado atual da porta digital
int buttonPState[totalButtons] = {0}; // estado previo da porta digital

/////////////////////////////////////////////
// Ribbon
const byte ribbonN = 4;
byte ribbonPin[ribbonN] = {8, 9, 10, 11};
int ribbonVal[ribbonN] = {0};
float ribbonFreq[ribbonN] = {659.256, 493.883, 391.995, 293.665}; // frequencies of each ribbon

/////////////////////////////////////////////
// Potentiometers
const int NPots = 2; // *coloque aqui o numero de entradas analogicas utilizadas
const int potPin[NPots] = {12, 13}; // *neste array coloque na ordem desejada os pinos das portas analogicas utilizadas
float potCState[NPots] = {0}; // estado atual da porta analogica
float potPState[NPots] = {0}; // estado previo da porta analogica
int potVar = 0; // variacao entre o valor do estado previo e o atual da porta analogica

int midiCState[NPots] = {0}; // Current state of the midi value
int midiPState[NPots] = {0}; // Previous state of the midi value

unsigned long TIMEOUT = 300; //* Amount of time the potentiometer will be read after it exceeds the varThreshold
int varThreshold = 6; //* Threshold for the potentiometer signal variation
boolean potMoving = true; // If the potentiometer is moving
unsigned long PTime[NPots] = {0}; // Previously stored time
unsigned long timer[NPots] = {0}; // Stores the time that has elapsed since the timer was reset

/////////////////////////////////////////////
// debounce
unsigned long lastDebounceTime = 0;  // the last time the output pin was toggled
unsigned long debounceDelay = 20;    // the debounce time; increase if the output flickers

/////////////////////////////////////////////
// Midi values
int midiMax = 254;
int midiCh = 1;
int note = 36;

/////////////////////////////////////////////
// for the encoder banks
int Bank = 0;
int lastBank = 0;



/////////////////////////////////////////////
// setup
void setup() {

  Serial.begin(115200);
Serial.println("START");
  multiplexer.begin(); // initialize o multiplexer

  /////////////////////////////////////////////
  // Leds
  // Sets the number of 8-bit registers that are used.
  ShiftPWM.SetAmountOfRegisters(numRegisters);
  // SetPinGrouping allows flexibility in LED setup.
  // If your LED's are connected like this: RRRRGGGGBBBBRRRRGGGGBBBB, use SetPinGrouping(4).
  ShiftPWM.SetPinGrouping(1); //This is the default, but I added here to demonstrate how to use the funtion
  ShiftPWM.Start(pwmFrequency, maxBrightness);
  //ShiftPWM.SetAll(0);

  //  for (int i = 0; i < encoderN; i++) {
  //    ShiftPWM.SetRGB(i, encoderValue[Bank][i], 0, 255 - encoderValue[Bank][i]);
  //  }

  /////////////////////////////////////////////
  // Encoders
  for (int i = 0; i < encoderN; i++) {
    encoder[i].write(127);
  }

  for (int z = 0; z < banksN; z++) {
    for (int i = 0; i < encoderN; i++) {
      lastEncoderValue[z][i] = {127};
      encoderValue[z][i] = {127};
    }
  }

  for (int i = 0; i < encoderN; i++) { //write leds to the previous bank values
    ShiftPWM.SetRGB(i, encoderValue[Bank][i], 0, 255 - encoderValue[Bank][i]);
  }

  /////////////////////////////////////////////
  // Audio stuff

  AudioMemory(120);
  sgtl5000_1.enable(); //starts sgtl5000
  sgtl5000_1.volume(0.9); //headphones level
  sgtl5000_1.lineOutLevel(30); //line level 13-31
  //  sgtl5000_1.audioPostProcessorEnable();
  //  sgtl5000_1.surroundSoundEnable(); // enables surround
  //  sgtl5000_1.surroundSound(7, 3); // how much surround 0-7


  //start osc 1
  //  setOsc1(4); // 1 = saw; 2 = sqr; 3 = tri; 4 = sin; 5 = pulse
  //  blSaw1.begin(osc1level, osc1freq, osc1);
  //  blSaw1.begin(osc1freq, osc1level);

  //start oscs
  waveform1.begin(oscLevel[0], (oscFreq[0]*oscOctave[0][oscOctaveIndex[0]]), oscWaveForm[0]);
  waveform2.begin(oscLevel[1], (oscFreq[1]*oscOctave[1][oscOctaveIndex[0]]), oscWaveForm[1]);
  waveform3.begin(oscLevel[2], (oscFreq[2]*oscOctave[2][oscOctaveIndex[0]]), oscWaveForm[2]);
  waveform4.begin(oscLevel[3], (oscFreq[3]*oscOctave[3][oscOctaveIndex[0]]), oscWaveForm[3]);

  //start filterFreqMod
  filterFreqMod.begin(filterLFOlevel, filterLFOfreq, oscWaveForm[3]);

  //start amplitude modulation
  AMod.begin(AMODlevel, AMODfreq, oscWaveForm[3]);

  //dc - for controllinf ampMod amplitude
  dc1.amplitude(dcLevel);
  dc2.amplitude(1.0);

  //start mixer 1 - for OCSs
  for (int i = 0; i < oscN; i++) {
    mixer1.gain(i, mixer1Gain[i]);
  }
  //start mixer 2 - amp mod
  for (int i = 0; i < oscN; i++) {
    mixer2.gain(i, mixer2Gain[i]);
  }
  //start mixer 3 - atenuates signal from filter
  for (int i = 0; i < oscN; i++) {
    mixer3.gain(i, mixer3Gain[i]);
  }
  //start mixer 4 - LFO and ADSR for the filter
  for (int i = 0; i < oscN; i++) {
    mixer4.gain(i, mixer4Gain[i]);
  }


  //  //filter
  filter1.octaveControl(filterOctaves);
  filter1.frequency(filterFreq);

  // MIDI IN
  //  usbMIDI.setHandleControlChange(OnControlChange);
  //  usbMIDI.setHandleNoteOn(OnNoteOn);
  //  usbMIDI.setHandleNoteOff(OnNoteOff);
  //  usbMIDI.setHandleVelocityChange(OnVelocityChange);

  // Envelelope - Sound envelope
  envelope1.attack(5);
  envelope1.decay(5);
  envelope1.sustain(1);
  envelope1.release(5);

  // Envelelope - Filter envelope
  envelope3.attack(200);
  envelope3.decay(100);
  envelope3.sustain(1);
  envelope3.release(5);

  //Line
  volumeLine.begin();
  filterLine.begin();

  setWaveform(0);
Serial.println("END");
}

/////////////////////////////////////////////
// loop
void loop() {
//Serial.println("LOOP");
  updateButtons();
  updateEncoders();  
  updateRibbons();
  updatePotentiometers();

  //volumeLine.update();

  //  filterLine.update();
  //  filter1.frequency(filterLine.getCurrentValue());

}

/////////////////////////////////////////////
// POTENTIOMETERS
void updatePotentiometers() {

  for (int i = 0; i < NPots; i++) { // Loops through all the potentiometers

    //    float analog = analogRead(multiplexer.readChannel(potPin[i])); //reads analog pin
    //    float analogSmooth = as10.smooth(analog); //smooths analog pin
    //    potCState[i] = analogSmooth;

    potCState[i] = multiplexer.readChannel(potPin[i]); // Reads the pot and stores it in the potCState variable
    midiCState[i] = map(potCState[i], 0, 1023, 0, 127); // Maps the reading of the potCState to a value usable in midi


    potVar = abs(potCState[i] - potPState[i]); // Calculates the absolute value between the difference between the current and previous state of the pot

    if (potVar > varThreshold) { // Opens the gate if the potentiometer variation is greater than the threshold
      PTime[i] = millis(); // Stores the previous time
    }

    timer[i] = millis() - PTime[i]; // Resets the timer 11000 - 11000 = 0ms

    if (timer[i] < TIMEOUT) { // If the timer is less than the maximum allowed time it means that the potentiometer is still moving
      potMoving = true;
    }
    else {
      potMoving = false;
    }

    if (potMoving == true) { // If the potentiometer is still moving, send the change control

      if (midiPState[i] != midiCState[i]) { //sends midi cc
        usbMIDI.sendControlChange(11 + i, midiCState[i], midiCh);
      }
      if (potCState[i] != potPState[i]) { // for using with the synth
                
        //prints data if pot moves
        Serial.print("Joytick ");
        Serial.print(i);
        Serial.print(": ");
        Serial.print((int)potCState[i]);
        Serial.print("  ");
        Serial.println();
      }

      potPState[i] = potCState[i]; // Stores the current reading of the potentiometer to compare with the next
      midiPState[i] = midiCState[i];

    }

  }
}


////////////////////////////////////////////
//read ribbons
void readRibbons() {

  for (int i = 0; i < ribbonN; i++) {
    ribbonVal[i] = multiplexer.readChannel(ribbonPin[i]);
    //Serial.print(ribbonVal[i]); Serial.print("  ");
  }
  //Serial.println();
}

////////////////////////////////////////////
//update ribbons
void updateRibbons() {
  //float oscLastFreq;

  readRibbons();

  for (int i = 0; i < ribbonN; i++) {

    if (ribbonVal[i] > 10) {
      
      // chooses the frequency and multiply by the correct octave
      waveform1.frequency(map(ribbonVal[i], 0, 1023, ribbonFreq[i] * oscOctave[0][oscOctaveIndex[0]], (ribbonFreq[i] * 2.5)*oscOctave[0][oscOctaveIndex[0]]));
      waveform2.frequency(map(ribbonVal[i], 0, 1023, ribbonFreq[i] * oscOctave[1][oscOctaveIndex[1]], (ribbonFreq[i] * 2.5)*oscOctave[1][oscOctaveIndex[1]]));
      waveform3.frequency(map(ribbonVal[i], 0, 1023, ribbonFreq[i] * oscOctave[2][oscOctaveIndex[2]], (ribbonFreq[i] * 2.5)*oscOctave[2][oscOctaveIndex[2]]));
      waveform4.frequency(map(ribbonVal[i], 0, 1023, ribbonFreq[i] * oscOctave[3][oscOctaveIndex[3]], (ribbonFreq[i] * 2.5)*oscOctave[3][oscOctaveIndex[3]]));


      //just gives a note On if it got a note off before
      // this way it doesn't play a thousand note ons
      if (noteIsPlaying == false) {

        envelope1.noteOn();
        envelope3.noteOn();
        //oscLastFreq = ribbonVal[i];
        // Serial.println(oscLastFreq);
        noteIsPlaying = true;
        Serial.println("note on");
      }
    }
  }

  if ((ribbonVal[0] < 5) && (ribbonVal[1] < 5) && (ribbonVal[2] < 5) && (ribbonVal[3] < 5)) {
    if (noteIsPlaying == true) {
      //waveform1.frequency(oscLastFreq);
      //Serial.println(oscLastFreq);

      envelope1.noteOff();
      envelope3.noteOff();
      noteIsPlaying = false;
      Serial.println("note off");
    }
  }

}

////////////////////////////////////////////
//read encoder buttons
void readButtons() {

  for (int i = 0; i < totalButtons; i++) {
    buttonVal[i] = multiplexer.readChannel(buttonPin[i]);

    if (i == 8) { //inverts the joystick button value
      buttonVal[i] = 1023 - buttonVal[i];
    }
  }

  //Serial.println(buttonVal[8]);

  for (int i = 0; i < totalButtons; i++) {
    if (buttonVal[i] > 1000) {
      buttonCState[i] = HIGH;
    }
    else {
      buttonCState[i] = LOW;
    }
  }

}

/////////////////////////////////////////////
// read buttons
void updateButtons() {

  readButtons();

  for (int i = 0; i < totalButtons; i++) {

    if ((millis() - lastDebounceTime) > debounceDelay) {

      if (buttonCState[i] != buttonPState[i]) {
        lastDebounceTime = millis();

        if (buttonCState[i] == HIGH) {

          if (i < encoderN) { //encoder buttons
            Serial.print("Button: "); Serial.print(i + 1); Serial.println(" On");
            usbMIDI.sendNoteOn(note + i, 127, midiCh); // envia NoteOn(nota, velocity, canal midi)
            // Serial.print("Note: "); Serial.print(note + i); Serial.println(" On");
            buttonPState[i] = buttonCState[i];
          }
          if (i == 8) { //joystick button
            changeBank();
            buttonPState[i] = buttonCState[i];
          }

        }
        else {

          usbMIDI.sendNoteOn(note + i, 0, midiCh);
          Serial.print("Button: "); Serial.print(i + 1); Serial.println(" Off");
          //  Serial.print("Note: "); Serial.print(note + i); Serial.println(" Off");
          buttonPState[i] = buttonCState[i];
        }
      }
    }

  }

}

////////////////////////////////////////////
//read encoder values
void readEncoders() { //read encoder

  for (int i = 0; i < encoderN; i++) {
    encoderValue[Bank][i] = encoder[i].read();
  }
}

////////////////////////////////////////////
//write encoder values
void updateEncoders() { //do whatever needs to be done with the encoder values

  readEncoders();

  for (int i = 0; i < encoderN; i++) {
    if (encoderValue[Bank][i] != lastEncoderValue[Bank][i]) {

      ShiftPWM.SetRGB(i, encoderValue[Bank][i], 0, 255 - encoderValue[Bank][i]);

      checkEncoderValue(i); //check if it's > than 255, or < then 0
      sendCC(i);
      printEncoderValue(i);
      writeEncoderValue(i);
      lastEncoderValue[Bank][i] = encoderValue[Bank][i];
    }
  }

}

////////////////////////////////////////////
//sends encoder's midi cc
void sendCC(byte i)  {

  usbMIDI.sendControlChange(i, map(encoderValue[Bank][i], 0, 255, 0, 127), Bank + 1);

}

////////////////////////////////////////////
//check if it's > than 255, or < then 0
void checkEncoderValue(int i) {

  if (encoderValue[Bank][i] > 254) {
    encoderValue[Bank][i] = 254;
    encoder[i].write(254);
  }
  if (encoderValue[Bank][i] < 1) {
    encoderValue[Bank][i] = 1;
    encoder[i].write(1);
  }
}

void writeEncoderValue(byte i) {

  // float encoderValueTemp = float(encoderValue[i]);

  if (Bank == 0) {
    if(i<4) {
      mixer1Gain[i] = mapfloat(encoderValue[0][i], 1, 255, 0, 1);
      mixer1.gain(i, mixer1Gain[i]);
      Serial.print("Gain: ");
      Serial.println(mixer1Gain[i]);
    }
  }

}


////////////////////////////////////////////
//print encoder values in the serial monitor
void printEncoderValue(byte i) {
  Serial.print("Bank: "); Serial.print(Bank); Serial.print("  ");
  Serial.print("Encoder "); Serial.print(i); Serial.print(": ");
  Serial.println(encoderValue[Bank][i]);
}

////////////////////////////////////////////
// Changes the bank of the encoders
void changeBank() {

  Bank = !Bank;

  Serial.print("Bank: ");
  Serial.println(Bank);

  //  switch (Serial.read()) {
  //    case '0':
  //      Bank = 0;
  //      Serial.print("Bank: ");
  //      Serial.println(Bank);
  //      break;
  //    case '1':
  //      Bank = 1;
  //      Serial.print("Bank: ");
  //      Serial.println(Bank);
  //      break;
  //    case '2':
  //      Bank = 2;
  //      Serial.print("Bank: ");
  //      Serial.println(Bank);
  //      break;
  //    default:
  //      Serial.print("*Invalid number*");
  //      break;
  //  }

  for (int i = 0; i < encoderN; i++) {
    encoder[i].write(encoderValue[Bank][i]);
  }

  for (int i = 0; i < encoderN; i++) { //write leds to the previous bank values
    ShiftPWM.SetRGB(i, encoderValue[Bank][i], 0, 255 - encoderValue[Bank][i]);
  }

}

/////////////////////////////////////////////
// sets the waveform
int setWaveform (int a) {
  int waveForm = 0;
  
  switch (a) {
    case 0:
      waveForm = WAVEFORM_SAWTOOTH;
      break;
    case 1:
      waveForm = WAVEFORM_SQUARE;
      break;
    case 2:
      waveForm = WAVEFORM_TRIANGLE;
      break;
    case 3:
      waveForm = WAVEFORM_SINE;
      break;
  }

  return waveForm;
}

/////////////////////////////////////////////
// Map float function
float mapfloat(float x, float in_min, float in_max, float out_min, float out_max)
{
  return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;
}

Ps: I'm using an external class called "line", so you'll need to comment that to compile.
 
Last edited:
I know now that the problem is with Audio shield, with the sgtl5000. If don't enable the sgtl5000 some of my encoder start to have an erratic behavior, like going backwards and jumping to one number to another. Please, help, I really don't know how to solve that!
 
I know now that the problem is with Audio shield, with the sgtl5000. If don't enable the sgtl5000 some of my encoder start to have an erratic behavior, like going backwards and jumping to one number to another. Please, help, I really don't know how to solve that!

Double posts do not help others and are annoying.
 
Status
Not open for further replies.
Back
Top