subtracting sequencer3

/* Mit diesem Notensequencer können "Wahrscheinlichkeiten" für jede Note eingegeben werden.
    Nach dem Einschalten werden die aktuellen Potipositionen auf % "Wahrscheinlichkeit" umgerechnet und in einem
    array hinterlegt. Es wird die Note mit der höchsten Wahrscheinlichkeit ermittelt.
    Nach Eingang eines ersten Clocksignals soll die Note mit der höchsten WHK gespielt werden.
    Danach werden der Note 10% wahrscheinlichkeit abgezogen und der nächste maximalwert ermittelt.
    Nach einem neuelichen Clocksignal wird der gerade ermittelte maximalwert ausgegeben, 10%WHK der gerade
    gespielten Note abgezogen und der nächste Maximalwert ermittelt.

    Eine Note wird mitunter solange gespielt (dabei weiterhin ein Abzug von 10& WHK bei jedem Clocksignal),
    bis es eine andere Note gibt deren WHK mittlerweile höher ist.
    Wenn die WHK für eine Note unter 10 fällt wird die Position des jeweiligen AnalogInputs abgefragt
    und als neue WHK herangezogen.
    Optional:
 *  **Wenn alle Noten ein ähnliches WHK Level erreicht haben kann mittels random die WHK für die Notenfolge variiert werden.
 *  **%-Abzug der WHK kann variiert werden
 *  **Selectable Octave Range

*/
#include <MyMCP4725.h>
MyMCP4725 DAC(0x60); //I2C-Adress = 0x60

const int clockPin = 9;
const int pinC = 0;           //setze Wert 0 für "pinC"
const int pinCs = 1;           //setze Wert 1 für "pinC#"
const int pinD = 2;           //setze Wert 2 für "pinD"
const int pinDs = 3;           //setze Wert 3 für "pinD#"


//Notes-Probability
int probC = 0;               //setze (vorerst) einen Wert für probC
int probCs = 0;               //setze (vorerst) einen Wert für probC#
int probD = 0;               //setze (vorerst) einen Wert für probD
int probDs = 0;               //setze (vorerst) einen Wert für probD#
int analogReadArraysize = 4;
int analogReadArray[4];  // erstelle ein Array mit 4 Werten, hier werden die analogreads der einzelnen noten für den durchlauf gespeichert
float outPut[4] = {3, 4, 4.5, 5};             //Ausgangsspannungen für den DAC entsprechend den Noten C, C#, D, D# im 1V/Oktave System (12Noten/1V + Oktave)

int maxVal = analogReadArray[0];
int clockState = 0;         // Variable to save tasterstate
int mode = 0;
bool dacStatus = false;

void setup() {
  Serial.begin(115200);
  DAC.setVoltage(5);
  if (DAC.isReady())
  {
    Serial.println("\nDAC in Ordnung!");
    dacStatus = true;
  }
  else Serial.println("DAC Fehler!");


  pinMode(clockPin, INPUT);

  probC = (int)map(analogRead(pinC), 0, 1023, 0, 100);                           //lies im setup durchlauf, nach dem einschalten die potiwerte
  analogReadArray[0] = probC;                                                    //und setze den Wert in das analogReadArray, erster Index
  probCs = (int)map(analogRead(pinCs), 0, 1023, 0, 100);                            //lies im setup durchlauf, nach dem einschalten die potiwerte
  analogReadArray[1] = probCs;                                                    //und setze den Wert in das analogReadArray, zweiter Index
  probD = (int)map(analogRead(pinD), 0, 1023, 0, 100);                            //lies im setup durchlauf, nach dem einschalten die potiwerte
  analogReadArray[2] = probD;                                                 //und setze den Wert in das analogReadArray, dritter Index
  probDs = (int)map(analogRead(pinDs), 0, 1023, 0, 100);                           //lies im setup durchlauf, nach dem einschalten die potiwerte
  analogReadArray[3] = probDs;                                                //und setze den Wert in das analogReadArray, vierter Index

}

void loop() {
  clockState = digitalRead(clockPin);
  int maxValIndex = 0;

  if (dacStatus) {
    int maxVal = 0;

    for (int i = 0; i < analogReadArraysize; i++) {
      if (analogReadArray[i] > maxVal) {
        maxVal      = analogReadArray[i];
        //maxVal = max(analogReadArray[i], maxVal);
        maxValIndex = i;
      }
    }
    if (clockState == HIGH) {
      switch (maxValIndex) {
        case 0:
          DAC.setVoltage(outPut[0]);
          probC = probC - 10;
          break;
        case 1:
          DAC.setVoltage(outPut[1]);
          probCs = probCs - 10;
          break;
        case 2:
          DAC.setVoltage(outPut[2]);
          probD = probD - 10;
          break;
        case 3:
          DAC.setVoltage(outPut[3]);
          probDs = probDs - 10;
          break;
        default:                                                                  //next taster push brings us back to page 0
          mode = 0;
      }
      if (probC <= 10) {
        probC = (int)map(analogRead(pinC), 0, 1023, 0, 100);                           //lies im setup durchlauf, nach dem einschalten die potiwerte
        analogReadArray[0] = probC;                          //und setze den Wert in das analogReadArray, erster Index
      }
      if (probCs <= 10) {
        probCs = (int)map(analogRead(pinCs), 0, 1023, 0, 100);                           //lies im setup durchlauf, nach dem einschalten die potiwerte
        analogReadArray[1] = probCs;                          //und setze den Wert in das analogReadArray, erster Index
      }

      if (probD <= 10) {
        probD = (int)map(analogRead(pinD), 0, 1023, 0, 100);                           //lies im setup durchlauf, nach dem einschalten die potiwerte
        analogReadArray[2] = probD;                          //und setze den Wert in das analogReadArray, erster Index
      }
      if (probDs <= 10) {
        probDs = (int)map(analogRead(pinDs), 0, 1023, 0, 100);                           //lies im setup durchlauf, nach dem einschalten die potiwerte
        analogReadArray[1] = probDs;                          //und setze den Wert in das analogReadArray, erster Index
      }

      //Ausgabe des Potiwertes im Normal-Modus
      //DAC.setVoltage(outPut[maxVal]);
      Serial.print(maxVal);
      Serial.print("--");
      Serial.print(maxValIndex);
      Serial.print("--");
      Serial.print(probC);
      Serial.print("-");
      Serial.print(probCs);
      Serial.print("-");
      Serial.print(probD);
      Serial.print("-");
      Serial.print(probDs);
      Serial.print("--");
      Serial.println(DAC.readRegister());

      delay(500);
    }
  }
}