#include <Wire.h>
#define ASD1115_1 0x48 // adc1
#define ASD1115_2 0x49 // adc 2

// Data types for ADC
const byte numPot = 8;
unsigned long ADC_val[numPot];
byte set_ADC_REG[numPot][3]; 
byte ADC_data_BUFFER[numPot][3];

// Data types for averaging
const byte  WINDOW_SIZE = 8; // stores n adc values to average
unsigned long INDEX[numPot]; // index for window
unsigned long VALUE[numPot]; // variable to pass adc value
unsigned long SUM[numPot]; // sum of average
unsigned long AVERAGED[numPot]; //average variable
unsigned long READINGS[numPot][WINDOW_SIZE]; //array for adc readings

float cv_OUT[numPot]; //converts mapped averaged value to decimal value

long average_map[numPot]; // maps range -5.00 - +5.00

void setup() {
  Serial.begin(9600); 
  Wire.begin(); // begin I2C
  // ASD1115
  // set config register and start conversion
  
  set_ADC_REG[0][0] = 1;    // config register 
  set_ADC_REG[0][1] = 0b01000010; // input 0 from adc 1

  set_ADC_REG[1][0] = 1;    // config register 
  set_ADC_REG[1][1] = 0b01010010; // input 1 from adc 1

  set_ADC_REG[2][0] = 1;    // config register 
  set_ADC_REG[2][1] = 0b01100010; // input 2 from adc 1

  set_ADC_REG[3][0] = 1;    // config register 
  set_ADC_REG[3][1] = 0b01110010; // input 3 from adc 1

  set_ADC_REG[4][0] = 1;    // config register 
  set_ADC_REG[4][1] = 0b01000010; // input 0 from adc 2

  set_ADC_REG[5][0] = 1;    // config register 
  set_ADC_REG[5][1] = 0b01010010; // input 1 from adc 2

  set_ADC_REG[6][0] = 1;    // config register 
  set_ADC_REG[6][1] = 0b01100010; // input 2 from adc 2

  set_ADC_REG[7][0] = 1;    // config register 
  set_ADC_REG[7][1] = 0b01110010; // input 3 from adc 2
  
  // bit 15 flag bit for single shot
  // Bits 14-12 input selection:
  // 100 ANC0; 101 ANC1; 110 ANC2; 111 ANC3
  // Bits 11-9 Amp gain. Default to 010 here 001 P19
  // Bit 8 Operational mode of the ADS1115.
  // 0 : Continuous conversion mode
  // 1 : Power-down single-shot mode (default)

  set_ADC_REG[0][2] = 0b10000111; // bits 7-0  0x85

  set_ADC_REG[1][2] = 0b10000111; // bits 7-0  0x85

  set_ADC_REG[2][2] = 0b10000111; // bits 7-0  0x85

  set_ADC_REG[3][2] = 0b10000111; // bits 7-0  0x85

  set_ADC_REG[4][2] = 0b10000111; // bits 7-0  0x85

  set_ADC_REG[5][2] = 0b10000111; // bits 7-0  0x85

  set_ADC_REG[6][2] = 0b10000111; // bits 7-0  0x85

  set_ADC_REG[7][2] = 0b10000111; // bits 7-0  0x85
  // Bits 7-5 data rate default to 111 for 860SPS
  // Bits 4-0  comparator functions see spec sheet.
}

void loop() 
{
//ADC_1 
  ADC_data_BUFFER[0][0] = 0;
  Wire.beginTransmission(ASD1115_1);  // ADC 
  Wire.write(set_ADC_REG[0][0]); 
  Wire.write(set_ADC_REG[0][1]);
  Wire.write(set_ADC_REG[0][2]);
  Wire.endTransmission(); 
  delay(3);

  Wire.beginTransmission(ASD1115_1);  // writes register of ADC
  Wire.write(ADC_data_BUFFER[0][0]);  
  Wire.endTransmission();
  delay(3);

  Wire.requestFrom(ASD1115_1, 2); // reads data from ADC
  while(Wire.available() < 2);
  ADC_data_BUFFER[0][1] = Wire.read();  
  ADC_data_BUFFER[0][2] = Wire.read(); 
  Wire.endTransmission(); 
  delay(3);

  ///////////////////////////////////////////////////////////
  
  ADC_data_BUFFER[1][0] = 0;
  Wire.beginTransmission(ASD1115_1);  // ADC 
  Wire.write(set_ADC_REG[1][0]); 
  Wire.write(set_ADC_REG[1][1]);
  Wire.write(set_ADC_REG[1][2]);
  Wire.endTransmission(); 
  delay(3);

  Wire.beginTransmission(ASD1115_1);  // writes register of ADC
  Wire.write(ADC_data_BUFFER[1][0]);  
  Wire.endTransmission();
  delay(3);

  Wire.requestFrom(ASD1115_1, 2); // reads data from ADC
  while(Wire.available() < 2);
  ADC_data_BUFFER[1][1] = Wire.read();  
  ADC_data_BUFFER[1][2] = Wire.read(); 
  Wire.endTransmission(); 
  delay(3);

  ///////////////////////////////////////////////////////////

  ADC_data_BUFFER[2][0] = 0;
  Wire.beginTransmission(ASD1115_1);  // ADC 
  Wire.write(set_ADC_REG[2][0]); 
  Wire.write(set_ADC_REG[2][1]);
  Wire.write(set_ADC_REG[2][2]);
  Wire.endTransmission(); 
  delay(3);

  Wire.beginTransmission(ASD1115_1);  // writes register of ADC
  Wire.write(ADC_data_BUFFER[2][0]);  
  Wire.endTransmission();
  delay(3);

  Wire.requestFrom(ASD1115_1, 2); // reads data from ADC
  while(Wire.available() < 2);
  ADC_data_BUFFER[2][1] = Wire.read();  
  ADC_data_BUFFER[2][2] = Wire.read(); 
  Wire.endTransmission(); 
  delay(3);

  ///////////////////////////////////////////////////////////

  ADC_data_BUFFER[3][0] = 0;
  Wire.beginTransmission(ASD1115_1);  // ADC 
  Wire.write(set_ADC_REG[3][0]); 
  Wire.write(set_ADC_REG[3][1]);
  Wire.write(set_ADC_REG[3][2]);
  Wire.endTransmission(); 
  delay(3);

  Wire.beginTransmission(ASD1115_1);  // writes register of ADC
  Wire.write(ADC_data_BUFFER[3][0]);  
  Wire.endTransmission();
  delay(3);

  Wire.requestFrom(ASD1115_1, 2); // reads data from ADC
  while(Wire.available() < 2);
  ADC_data_BUFFER[3][1] = Wire.read();  
  ADC_data_BUFFER[3][2] = Wire.read(); 
  Wire.endTransmission(); 
  delay(3);

  ///////////////////////////////////////////////////////////

  //ADC_2

  ADC_data_BUFFER[4][0] = 0;
  Wire.beginTransmission(ASD1115_2);  // ADC 
  Wire.write(set_ADC_REG[4][0]); 
  Wire.write(set_ADC_REG[4][1]);
  Wire.write(set_ADC_REG[4][2]);
  Wire.endTransmission(); 
  delay(3);

  Wire.beginTransmission(ASD1115_2);  // writes register of ADC
  Wire.write(ADC_data_BUFFER[4][0]);  
  Wire.endTransmission();
  delay(3);

  Wire.requestFrom(ASD1115_2, 2); // reads data from ADC
  while(Wire.available() < 2);
  ADC_data_BUFFER[4][1] = Wire.read();  
  ADC_data_BUFFER[4][2] = Wire.read(); 
  Wire.endTransmission();
  delay(3); 

  ///////////////////////////////////////////////////////////
  
  ADC_data_BUFFER[5][0] = 0;
  Wire.beginTransmission(ASD1115_2);  // ADC 
  Wire.write(set_ADC_REG[5][0]); 
  Wire.write(set_ADC_REG[5][1]);
  Wire.write(set_ADC_REG[5][2]);
  Wire.endTransmission(); 
  delay(3);

  Wire.beginTransmission(ASD1115_2);  // writes register of ADC
  Wire.write(ADC_data_BUFFER[5][0]);  
  Wire.endTransmission();
  delay(3);

  Wire.requestFrom(ASD1115_2, 2); // reads data from ADC
  while(Wire.available() < 2);
  ADC_data_BUFFER[5][1] = Wire.read();  
  ADC_data_BUFFER[5][2] = Wire.read(); 
  Wire.endTransmission(); 
  delay(3);

  ///////////////////////////////////////////////////////////

  ADC_data_BUFFER[6][0] = 0;
  Wire.beginTransmission(ASD1115_2);  // ADC 
  Wire.write(set_ADC_REG[6][0]); 
  Wire.write(set_ADC_REG[6][1]);
  Wire.write(set_ADC_REG[6][2]);
  Wire.endTransmission(); 
  delay(3);

  Wire.beginTransmission(ASD1115_2);  // writes register of ADC
  Wire.write(ADC_data_BUFFER[6][0]);  
  Wire.endTransmission();
  delay(3);

  Wire.requestFrom(ASD1115_2, 2); // reads data from ADC
  while(Wire.available() < 2);
  ADC_data_BUFFER[6][1] = Wire.read();  
  ADC_data_BUFFER[6][2] = Wire.read(); 
  Wire.endTransmission();
  delay(3);
  

  ///////////////////////////////////////////////////////////

  ADC_data_BUFFER[7][0] = 0;
  Wire.beginTransmission(ASD1115_2);  // ADC 
  Wire.write(set_ADC_REG[7][0]); 
  Wire.write(set_ADC_REG[7][1]);
  Wire.write(set_ADC_REG[7][2]);
  Wire.endTransmission(); 
  delay(3);

  Wire.beginTransmission(ASD1115_2);  // writes register of ADC
  Wire.write(ADC_data_BUFFER[7][0]);  
  Wire.endTransmission();
  delay(3);

  Wire.requestFrom(ASD1115_2, 2); // reads data from ADC
  while(Wire.available() < 2);
  ADC_data_BUFFER[7][1] = Wire.read();  
  ADC_data_BUFFER[7][2] = Wire.read(); 
  Wire.endTransmission(); 
  delay(3);

  ///////////////////////////////////////////////////////////


  // pass results onto variable
  ADC_val[0] = ADC_data_BUFFER[1][1] << 8 | ADC_data_BUFFER[1][2]; 
  ADC_val[1] = ADC_data_BUFFER[2][1] << 8 | ADC_data_BUFFER[2][2]; 
  ADC_val[2] = ADC_data_BUFFER[3][1] << 8 | ADC_data_BUFFER[3][2]; 
  ADC_val[3] = ADC_data_BUFFER[0][1] << 8 | ADC_data_BUFFER[0][2];

  ADC_val[4] = ADC_data_BUFFER[5][1] << 8 | ADC_data_BUFFER[5][2]; 
  ADC_val[5] = ADC_data_BUFFER[6][1] << 8 | ADC_data_BUFFER[6][2]; 
  ADC_val[6] = ADC_data_BUFFER[7][1] << 8 | ADC_data_BUFFER[7][2]; 
  ADC_val[7] = ADC_data_BUFFER[4][1] << 8 | ADC_data_BUFFER[4][2];


  // limit adc value.
  for(int i = 0; i<numPot; i++)
 {
  if(ADC_val[i] > 32767)
  {
    ADC_val[i] = 0;
  }
 }


  ///////////////////////////////////////////////////////////
/*
  //MOVING Average
  for(int i = 0; i<numPot; i++)
 {
  SUM[i] = SUM[i] - READINGS[i][INDEX[i]];       // Remove the oldest entry from the sum
  VALUE[i] = ADC_val[i];        // Read the next sensor value
  READINGS[i][INDEX[i]] = VALUE[i];           // Add the newest reading to the window
  SUM[i] = SUM[i] + VALUE[i];                 // Add the newest reading to the sum
  INDEX[i] = (INDEX[i]+1) % WINDOW_SIZE;   // Increment the index, and wrap to 0 if it exceeds the window size

  AVERAGED[i] = SUM[i] / WINDOW_SIZE;      // Divide the sum of the window by the window size for the result
  average_map[i] = map (AVERAGED[i], 0,32752, -16376,16376);
  cv_OUT[i] = average_map[i] * 10.0/32752;
 }
///////////////////////////////////////////////////////////



 for(int i = 0; i<numPot; i++)
 {
  if(cv_OUT[i] > 10.0)
  {
    cv_OUT[i] = 0;
  }
 }
*/

  Serial.print(ADC_val[0]);
  Serial.print("   ");
  Serial.print(ADC_val[1]);
  Serial.print("   ");
  Serial.print(ADC_val[2]);
  Serial.print("   ");
  Serial.print(ADC_val[3]);
  Serial.print("   ");
  Serial.print(ADC_val[4]);
  Serial.print("   ");
  Serial.print(ADC_val[5]);
  Serial.print("   ");
  Serial.print(ADC_val[6]);
  Serial.print("   ");
  Serial.println(ADC_val[7]);
  
  

  
}




















#include <Wire.h>
#define ASD1115_1 0x48 // adc1
#define ASD1115_2 0x49 // adc 2

// Data types for ADC
const byte numPot = 8;
unsigned long ADC_val[numPot];
byte set_ADC_REG[numPot][3];
byte ADC_data_BUFFER[numPot][3];

// Data types for averaging
const byte  WINDOW_SIZE = 8; // stores n adc values to average
unsigned long INDEX[numPot]; // index for window
unsigned long VALUE[numPot]; // variable to pass adc value
unsigned long SUM[numPot]; // sum of average
unsigned long AVERAGED[numPot]; //average variable
unsigned long READINGS[numPot][WINDOW_SIZE]; //array for adc readings

float cv_OUT[numPot]; //converts mapped averaged value to decimal value

long average_map[numPot]; // maps range -5.00 - +5.00
void setup()
{
  Serial.begin(9600);
  Wire.begin(); // begin I2C
  // ASD1115
  // set config register and start conversion

  set_ADC_REG[0][0] = 1;    // config register
  set_ADC_REG[0][1] = 0b01000010; // input 0 from adc 1

  set_ADC_REG[1][0] = 1;    // config register
  set_ADC_REG[1][1] = 0b01010010; // input 1 from adc 1

  set_ADC_REG[2][0] = 1;    // config register
  set_ADC_REG[2][1] = 0b01100010; // input 2 from adc 1

  set_ADC_REG[3][0] = 1;    // config register
  set_ADC_REG[3][1] = 0b01110010; // input 3 from adc 1

  set_ADC_REG[4][0] = 1;    // config register
  set_ADC_REG[4][1] = 0b01000010; // input 0 from adc 2

  set_ADC_REG[5][0] = 1;    // config register
  set_ADC_REG[5][1] = 0b01010010; // input 1 from adc 2

  set_ADC_REG[6][0] = 1;    // config register
  set_ADC_REG[6][1] = 0b01100010; // input 2 from adc 2

  set_ADC_REG[7][0] = 1;    // config register
  set_ADC_REG[7][1] = 0b01110010; // input 3 from adc 2

  // bit 15 flag bit for single shot
  // Bits 14-12 input selection:
  // 100 ANC0; 101 ANC1; 110 ANC2; 111 ANC3
  // Bits 11-9 Amp gain. Default to 010 here 001 P19
  // Bit 8 Operational mode of the ADS1115.
  // 0 : Continuous conversion mode
  // 1 : Power-down single-shot mode (default)

  set_ADC_REG[0][2] = 0b10000111; // bits 7-0  0x85

  set_ADC_REG[1][2] = 0b10000111; // bits 7-0  0x85

  set_ADC_REG[2][2] = 0b10000111; // bits 7-0  0x85

  set_ADC_REG[3][2] = 0b10000111; // bits 7-0  0x85

  set_ADC_REG[4][2] = 0b10000111; // bits 7-0  0x85

  set_ADC_REG[5][2] = 0b10000111; // bits 7-0  0x85

  set_ADC_REG[6][2] = 0b10000111; // bits 7-0  0x85

  set_ADC_REG[7][2] = 0b10000111; // bits 7-0  0x85
  // Bits 7-5 data rate default to 111 for 860SPS
  // Bits 4-0  comparator functions see spec sheet.


}

void fsm()
{
  const byte pause = 1;
  static enum {
    SET0, WAIT0, READ0, WAIT1, WRITE0, WAIT2,
    SET1, WAIT3, READ1, WAIT4, WRITE1, WAIT5,
    SET2, WAIT6, READ2, WAIT7, WRITE2, WAIT8,
    SET3, WAIT9, READ3, WAIT10, WRITE3, WAIT11,
    SET4, WAIT12, READ4, WAIT13, WRITE4, WAIT14,
    SET5, WAIT15, READ5, WAIT16, WRITE5, WAIT17,
    SET6, WAIT18, READ6, WAIT19, WRITE6, WAIT20,
    SET7, WAIT21, READ7, WAIT22, WRITE7, WAIT23,
  }
  state = SET0;

  static byte timeLastTransition = 0;

  switch (state)
  {
    case SET0:
      ADC_data_BUFFER[0][0] = 0;
      Wire.beginTransmission(ASD1115_1);  // ADC
      Wire.write(set_ADC_REG[0][0]);
      Wire.write(set_ADC_REG[0][1]);
      Wire.write(set_ADC_REG[0][2]);
      Wire.endTransmission();
      timeLastTransition = micros();
      state = WAIT0;
      break;

    case WAIT0:   // wait for the delay period
      if (micros() - timeLastTransition >= pause)
        state = READ0;
      break;

    case READ0:
      Wire.beginTransmission(ASD1115_1);  // writes register of ADC
      Wire.write(ADC_data_BUFFER[0][0]);
      Wire.endTransmission();
      timeLastTransition = micros();
      state = WAIT1;
      break;

    case WAIT1:   // wait for the delay period
      if (micros() - timeLastTransition >= pause)
        state = WRITE0;
      break;

    case WRITE0:
      Wire.requestFrom(ASD1115_1, 2); // reads data from ADC
      while (Wire.available() < 2);
      ADC_data_BUFFER[0][1] = Wire.read();
      ADC_data_BUFFER[0][2] = Wire.read();
      Wire.endTransmission();
      timeLastTransition = micros();
      state = WAIT2;
      break;

    case WAIT2:   // wait for the delay period
      if (micros() - timeLastTransition >= pause)
        state = SET1;
      break;

    case SET1:
      ADC_data_BUFFER[1][0] = 0;
      Wire.beginTransmission(ASD1115_1);  // ADC
      Wire.write(set_ADC_REG[1][0]);
      Wire.write(set_ADC_REG[1][1]);
      Wire.write(set_ADC_REG[1][2]);
      Wire.endTransmission();
      timeLastTransition = micros();
      state = WAIT3;
      break;

    case WAIT3:   // wait for the delay period
      if (micros() - timeLastTransition >= pause)
        state = READ1;
      break;

    case READ1:
      Wire.beginTransmission(ASD1115_1);  // writes register of ADC
      Wire.write(ADC_data_BUFFER[1][0]);
      Wire.endTransmission();
      timeLastTransition = micros();
      state = WAIT4;
      break;

    case WAIT4:   // wait for the delay period
      if (micros() - timeLastTransition >= pause)
        state = WRITE1;
      break;

    case WRITE1:
      Wire.requestFrom(ASD1115_1, 2); // reads data from ADC
      while (Wire.available() < 2);
      ADC_data_BUFFER[1][1] = Wire.read();
      ADC_data_BUFFER[1][2] = Wire.read();
      Wire.endTransmission();
      timeLastTransition = micros();
      state = WAIT5;
      break;

    case WAIT5:   // wait for the delay period
      if (micros() - timeLastTransition >= pause)
        state = SET2;
      break;

    case SET2:
      ADC_data_BUFFER[2][0] = 0;
      Wire.beginTransmission(ASD1115_1);  // ADC
      Wire.write(set_ADC_REG[2][0]);
      Wire.write(set_ADC_REG[2][1]);
      Wire.write(set_ADC_REG[2][2]);
      Wire.endTransmission();
      timeLastTransition = micros();
      state = WAIT6;
      break;

    case WAIT6:   // wait for the delay period
      if (micros() - timeLastTransition >= pause)
        state = READ2;
      break;

    case READ2:
      Wire.beginTransmission(ASD1115_1);  // writes register of ADC
      Wire.write(ADC_data_BUFFER[2][0]);
      Wire.endTransmission();
      timeLastTransition = micros();
      state = WAIT7;
      break;

    case WAIT7:   // wait for the delay period
      if (micros() - timeLastTransition >= pause)
        state = WRITE2;
      break;

    case WRITE2:
      Wire.requestFrom(ASD1115_1, 2); // reads data from ADC
      while (Wire.available() < 2);
      ADC_data_BUFFER[2][1] = Wire.read();
      ADC_data_BUFFER[2][2] = Wire.read();
      Wire.endTransmission();
      timeLastTransition = micros();
      state = WAIT8;
      break;

    case WAIT8:   // wait for the delay period
      if (micros() - timeLastTransition >= pause)
        state = SET3;
      break;

    case SET3:
      ADC_data_BUFFER[3][0] = 0;
      Wire.beginTransmission(ASD1115_1);  // ADC
      Wire.write(set_ADC_REG[3][0]);
      Wire.write(set_ADC_REG[3][1]);
      Wire.write(set_ADC_REG[3][2]);
      Wire.endTransmission();
      timeLastTransition = micros();
      state = WAIT9;
      break;

    case WAIT9:   // wait for the delay period
      if (micros() - timeLastTransition >= pause)
        state = READ3;
      break;

    case READ3:
      Wire.beginTransmission(ASD1115_1);  // writes register of ADC
      Wire.write(ADC_data_BUFFER[3][0]);
      Wire.endTransmission();
      timeLastTransition = micros();
      state = WAIT10;
      break;

    case WAIT10:   // wait for the delay period
      if (micros() - timeLastTransition >= pause)
        state = WRITE3;
      break;

    case WRITE3:
      Wire.requestFrom(ASD1115_1, 2); // reads data from ADC
      while (Wire.available() < 2);
      ADC_data_BUFFER[3][1] = Wire.read();
      ADC_data_BUFFER[3][2] = Wire.read();
      Wire.endTransmission();
      timeLastTransition = micros();
      state = WAIT11;
      break;

    case WAIT11:   // wait for the delay period
      if (micros() - timeLastTransition >= pause)
        state = SET4;
      break;

    case SET4:
      ADC_data_BUFFER[4][0] = 0;
      Wire.beginTransmission(ASD1115_2);  // ADC
      Wire.write(set_ADC_REG[4][0]);
      Wire.write(set_ADC_REG[4][1]);
      Wire.write(set_ADC_REG[4][2]);
      Wire.endTransmission();
      timeLastTransition = micros();
      state = WAIT12;
      break;

    case WAIT12:   // wait for the delay period
      if (micros() - timeLastTransition >= pause)
        state = READ4;
      break;

    case READ4:
      Wire.beginTransmission(ASD1115_2);  // writes register of ADC
      Wire.write(ADC_data_BUFFER[4][0]);
      Wire.endTransmission();
      timeLastTransition = micros();
      state = WAIT13;
      break;

    case WAIT13:   // wait for the delay period
      if (micros() - timeLastTransition >= pause)
        state = WRITE4;
      break;

    case WRITE4:
      Wire.requestFrom(ASD1115_2, 2); // reads data from ADC
      while (Wire.available() < 2);
      ADC_data_BUFFER[4][1] = Wire.read();
      ADC_data_BUFFER[4][2] = Wire.read();
      Wire.endTransmission();
      timeLastTransition = micros();
      state = WAIT14;
      break;

    case WAIT14:   // wait for the delay period
      if (micros() - timeLastTransition >= pause)
        state = SET5;
      break;

    case SET5:
      ADC_data_BUFFER[5][0] = 0;
      Wire.beginTransmission(ASD1115_2);  // ADC
      Wire.write(set_ADC_REG[5][0]);
      Wire.write(set_ADC_REG[5][1]);
      Wire.write(set_ADC_REG[5][2]);
      Wire.endTransmission();
      timeLastTransition = micros();
      state = WAIT15;
      break;

    case WAIT15:   // wait for the delay period
      if (micros() - timeLastTransition >= pause)
        state = READ5;
      break;

    case READ5:
      Wire.beginTransmission(ASD1115_2);  // writes register of ADC
      Wire.write(ADC_data_BUFFER[5][0]);
      Wire.endTransmission();
      timeLastTransition = micros();
      state = WAIT16;
      break;

    case WAIT16:   // wait for the delay period
      if (micros() - timeLastTransition >= pause)
        state = WRITE5;
      break;

    case WRITE5:
      Wire.requestFrom(ASD1115_2, 2); // reads data from ADC
      while (Wire.available() < 2);
      ADC_data_BUFFER[5][1] = Wire.read();
      ADC_data_BUFFER[5][2] = Wire.read();
      Wire.endTransmission();
      timeLastTransition = micros();
      state = WAIT17;
      break;

    case WAIT17:   // wait for the delay period
      if (micros() - timeLastTransition >= pause)
        state = SET6;
      break;

    case SET6:
      ADC_data_BUFFER[6][0] = 0;
      Wire.beginTransmission(ASD1115_2);  // ADC
      Wire.write(set_ADC_REG[6][0]);
      Wire.write(set_ADC_REG[6][1]);
      Wire.write(set_ADC_REG[6][2]);
      Wire.endTransmission();
      timeLastTransition = micros();
      state = WAIT18;
      break;

    case WAIT18:   // wait for the delay period
      if (micros() - timeLastTransition >= pause)
        state = READ6;
      break;

    case READ6:
      Wire.beginTransmission(ASD1115_2);  // writes register of ADC
      Wire.write(ADC_data_BUFFER[6][0]);
      Wire.endTransmission();
      timeLastTransition = micros();
      state = WAIT19;
      break;

    case WAIT19:   // wait for the delay period
      if (micros() - timeLastTransition >= pause)
        state = WRITE6;
      break;

    case WRITE6:
      Wire.requestFrom(ASD1115_2, 2); // reads data from ADC
      while (Wire.available() < 2);
      ADC_data_BUFFER[6][1] = Wire.read();
      ADC_data_BUFFER[6][2] = Wire.read();
      Wire.endTransmission();
      timeLastTransition = micros();
      state = WAIT20;
      break;

    case WAIT20:   // wait for the delay period
      if (micros() - timeLastTransition >= pause)
        state = SET7;
      break;

    case SET7:
      ADC_data_BUFFER[7][0] = 0;
      Wire.beginTransmission(ASD1115_2);  // ADC
      Wire.write(set_ADC_REG[7][0]);
      Wire.write(set_ADC_REG[7][1]);
      Wire.write(set_ADC_REG[7][2]);
      Wire.endTransmission();
      timeLastTransition = micros();
      state = WAIT21;
      break;

    case WAIT21:   // wait for the delay period
      if (micros() - timeLastTransition >= pause)
        state = READ7;
      break;

    case READ7:
      Wire.beginTransmission(ASD1115_2);  // writes register of ADC
      Wire.write(ADC_data_BUFFER[7][0]);
      Wire.endTransmission();
      timeLastTransition = micros();
      state = WAIT22;
      break;

    case WAIT22:   // wait for the delay period
      if (micros() - timeLastTransition >= pause)
        state = WRITE7;
      break;

    case WRITE7:
      Wire.requestFrom(ASD1115_2, 2); // reads data from ADC
      while (Wire.available() < 2);
      ADC_data_BUFFER[7][1] = Wire.read();
      ADC_data_BUFFER[7][2] = Wire.read();
      Wire.endTransmission();
      timeLastTransition = micros();
      state = WAIT23;
      break;

    case WAIT23:   // wait for the delay period
      if (micros() - timeLastTransition >= pause)
        state = SET0;
      break;

    default:
      Serial.println("DATA");
      break;
  }
}

void loop()
{
  fsm();
  ADC_VALUES();


  ///////////////////////////////////////////////////////////
  /*
    //MOVING Average
    for(int i = 0; i<numPot; i++)
    {
    SUM[i] = SUM[i] - READINGS[i][INDEX[i]];       // Remove the oldest entry from the sum
    VALUE[i] = ADC_val[i];        // Read the next sensor value
    READINGS[i][INDEX[i]] = VALUE[i];           // Add the newest reading to the window
    SUM[i] = SUM[i] + VALUE[i];                 // Add the newest reading to the sum
    INDEX[i] = (INDEX[i]+1) % WINDOW_SIZE;   // Increment the index, and wrap to 0 if it exceeds the window size

    AVERAGED[i] = SUM[i] / WINDOW_SIZE;      // Divide the sum of the window by the window size for the result
    average_map[i] = map (AVERAGED[i], 0,32752, -16376,16376);
    cv_OUT[i] = average_map[i] * 10.0/32752;
    }
    ///////////////////////////////////////////////////////////



    for(int i = 0; i<numPot; i++)
    {
    if(cv_OUT[i] > 10.0)
    {
      cv_OUT[i] = 0;
    }
    }
  */

  Serial.print(ADC_val[0]);
  Serial.print("   ");
  Serial.print(ADC_val[1]);
  Serial.print("   ");
  Serial.print(ADC_val[2]);
  Serial.print("   ");
  Serial.print(ADC_val[3]);
  Serial.print("   ");
  Serial.print(ADC_val[4]);
  Serial.print("   ");
  Serial.print(ADC_val[5]);
  Serial.print("   ");
  Serial.print(ADC_val[6]);
  Serial.print("   ");
  Serial.println(ADC_val[7]);

}

void ADC_VALUES()
{
  // pass results onto variable
  ADC_val[0] = ADC_data_BUFFER[0][1] << 8 | ADC_data_BUFFER[0][2];
  ADC_val[1] = ADC_data_BUFFER[1][1] << 8 | ADC_data_BUFFER[1][2];
  ADC_val[2] = ADC_data_BUFFER[2][1] << 8 | ADC_data_BUFFER[2][2];
  ADC_val[3] = ADC_data_BUFFER[3][1] << 8 | ADC_data_BUFFER[3][2];
  ADC_val[4] = ADC_data_BUFFER[4][1] << 8 | ADC_data_BUFFER[4][2];
  ADC_val[5] = ADC_data_BUFFER[5][1] << 8 | ADC_data_BUFFER[5][2];
  ADC_val[6] = ADC_data_BUFFER[6][1] << 8 | ADC_data_BUFFER[6][2];
  ADC_val[7] = ADC_data_BUFFER[7][1] << 8 | ADC_data_BUFFER[7][2];

  // limit adc value.
  for (int i = 0; i < numPot; i++)
  {
    if (ADC_val[i] > 32767)
    {
      ADC_val[i] = 0;
    }
  }
}