Callback indexes look wrong

[Nemecsek]

Referring to my example below, it looks like the callback indexes are not associated to the correct ADC channel: a read on A1 will report index 2; A2 index 3; A3 index 4; A4 index 5; A5 index 0.
In my case I scan through 6 channels, but only one has a callback.

Another example: scanning A0 and A1 only will return the values respectively to index 1 and 0 (reversed).

---

In this code, readings not reassigned by a callback are -1.

#include <AnalogScanner.h>

AnalogScanner scanner;

int scanOrder[] = {A0, A1, A2, A3, A4, A5};
const int SCAN_COUNT = sizeof(scanOrder) / sizeof(scanOrder[0]);

// text callback values
int readings[6] = {-1,-1,-1,-1,-1,-1};  // available for 6 ADC channels

void callback_on_read(int index, int pin, int newValue) {
    readings[index] = index; // <------- it must assign index 5 here, 
                            // but only assign 0 to readings[0]
}

void setup() {
  Serial.begin(38400);
  scanner.setScanOrder(SCAN_COUNT, scanOrder);
  scanner.beginScanning();

  
  // scanner.setCallback(A0, callback_on_read);
  // scanner.setCallback(A1, callback_on_read);
  // scanner.setCallback(A2, callback_on_read);
  // scanner.setCallback(A3, callback_on_read);
  // scanner.setCallback(A4, callback_on_read);
  scanner.setCallback(A5, callback_on_read); // <------ it must callback and fill readings[5] 
}

void loop() {
  for (int i=0; i < SCAN_COUNT; ++i) {
    if (i > 0) {
      Serial.print(" ");
    }
    Serial.print("A");
    Serial.print(i);
    Serial.print("=");

    Serial.print(readings[i]);
  }
  
  Serial.println();
  delay(1);
}

[ygator]

@Nemecsek
I have encountered this issue as well. On line 246 of AnalogScanner.cpp it calls the callback routine with CurrentIndex, however on line 243 before this a call is made to startNextScan which increments CurrentIndex (and wraps to 0 if needed). So therefore it is calling the callback routine with the wrong index.

[hexeguitar]

This could be easily fixed by making a local copy of the currentIndex variable, before starting a new scan and using it to invoke the correct callback routine. I.e. the processScan() function could look like this:

// Processes a new value from the ADC.
void AnalogScanner::processScan() {
  // We must read ADCL first, which locks ADCH until it is read.
  int low = ADCL;
  int high = ADCH;
  int index = getPinIndex(currentPin);
  int pin = currentPin;
  values[index] = (high << 8) | low;
  int currentIndexLocal = currentIndex;  //make a local copy of the currentIndex
  // Invoke the next scan before the callback, to make the
  // read rate more uniform.
  startNextScan(); //currentIndex will be updated/wrapped to 0 here

  if (pCallback[index] != NULL) {
    pCallback[index](currentIndexLocal, pin, values[index]); //use the not updated copy of the currentIndex here
  }
}