#include "U8glib.h" // Display Controls
// >>>> UNMASK LATER
//#include "HID-Project.h" // Nicohood HID
U8GLIB_SSD1306_128X64 u8g(U8G_I2C_OPT_DEV_0 | U8G_I2C_OPT_NO_ACK | U8G_I2C_OPT_FAST); // Fast I2C / TWI
/** VOLUME CONTROL **/
const int NUM_SLIDERS = 5;
const int analogInputs[NUM_SLIDERS] = {A0, A1, A2, A3, A6}; // This is the order in which the sliders will be used for output values! - Make Master 0!
const int NUM_STATIC_SLIDERS = 1; // define how many sliders are static, e.g. do not change behaviour depending to layer
const int NUM_DYNAMIC_SLIDERS = NUM_SLIDERS - NUM_STATIC_SLIDERS;
//int analogSliderValues[NUM_SLIDERS];
/** BUTTON CONTROL **/
const int NUM_LAYERS = 4;
#define BUTTON_PLAYPAUSE_PIN 10 // pin for PLAY//PAUSE button
#define BUTTON_NEXT_PIN 9 // pin for NEXT button
#define BUTTON_AUDIOMUTE_PIN 8 // pin for AUDIO MUTE button
#define BUTTON_LAYERDOWN_PIN 7 // pin for NEXT LAYER button
#define BUTTON_LAYERUP_PIN 6 // pin for PREV LAYER button
#define BUTTON_MICMUTE_PIN 5 // pin for MICROPHONE MUTE button
#define LED_AUDIOMUTE_PIN 2 // pin for Audio Mute LED
#define LED_MICMUTE_PIN 3 // pin for Audio Mute LED
int button_playpause_clicked = 0; // only perform action when button is clicked, and wait until another press
int button_next_clicked = 0; // same as above
int button_audiomute_clicked = 0; // same as above
int button_layerup_clicked = 0; // same as above
int button_layerdown_clicked = 0; // same as above
int button_micmute_clicked = 0; // same as above
int led_audiomute_on = 0; // turn Audio Mute led off initially
int led_micmute_on = 0; // turn Mic Mute led off initially
int current_layer = 0; // which layer is selected
int previous_layer; // previous layer - used to draw the item before the selected one
int next_layer; // next layer - used to draw next item after the selected one
/** VOLUME CONTROL #2 **/
const int NUM_VIRTUAL_SLIDERS = (NUM_DYNAMIC_SLIDERS * NUM_LAYERS) + NUM_STATIC_SLIDERS; // calculate Virtual Slider Number, without Master Slider
int currentSlidersetStart = 1; // initially set first slider start number (1) set as default
int analogSliderValues[NUM_VIRTUAL_SLIDERS]; // Define number of total array values to be submitted to deej exe = Amount of virtual Sliders
int currentReading[NUM_SLIDERS]; // Define number of total array values for CURRENT reading of dynamic sliders - used to determine whether to update the virtual slider value upon layer change!
int lastReading[NUM_SLIDERS]; // Define number of total array values for LAST reading of dynamic sliders - used to determine whether to update the virtual slider value upon layer change!
/** DISPLAY **/
int potentiometer_value = 0;
int volume_bar = 0;
char buffer[20];
int string_width = 0;
int current_screen = 0;
// Delay for returning to Screen 0
unsigned long DELAY_TIME = 666; // wait for .666 sec
unsigned long delayStart = 0; // the time the delay started
bool delayRunning = false; // true if still waiting for delay to finish
/* PROGRESS BAR SAMPLE
int progress = 0;
void setup() {
u8g.setFont(u8g_font_tpssb);
u8g.setColorIndex(1);
}
void loop() {
u8g.firstPage();
do {
u8g.drawStr(25, 50, "Progress Bar");
u8g.drawFrame(0, 10, 128, 20);
u8g.drawBox(10, 15, progress, 10);
} while ( u8g.nextPage() );
if (progress < 108) {
progress++;
} else {
progress = 0;
}
}
*/
void setup() {
/** VOLUME CONTROL **/
for (int i = 0; i < NUM_SLIDERS; i++) { // Set Pin Mode for Potentiometer input
pinMode(analogInputs[i], INPUT);
}
Serial.begin(9600);
/* Adding this would mean that layer 0 (zero) values are not updates according to poti values but set to zero = AUTO MUTE of all apps, which is unwanted
for (int k = 1; k < NUM_SLIDERS; k++) { // Read & set starting value of dynamic sliders to later verify whether a potentiometer has been turned
lastReading[k] = analogRead(analogInputs[k]);
//Serial.println(k);
//Serial.println(lastReading[k]);
}
auto mute */
/** BUTTON CONTROL **/
// define pins for buttons
// INPUT_PULLUP means the button is HIGH when not pressed, and LOW when pressed
// since it´s connected between some pin and GND
pinMode(BUTTON_PLAYPAUSE_PIN, INPUT_PULLUP); // PLAY//PAUSE button
pinMode(BUTTON_NEXT_PIN, INPUT_PULLUP); // NEXT button
pinMode(BUTTON_AUDIOMUTE_PIN, INPUT_PULLUP); // AUDIO MUTE button
pinMode(BUTTON_LAYERUP_PIN, INPUT_PULLUP); // NEXT LAYER button
pinMode(BUTTON_LAYERDOWN_PIN, INPUT_PULLUP); // PREV LAYER button
pinMode(BUTTON_MICMUTE_PIN, INPUT_PULLUP); // MICROPHONE MUTE button
// LEDs
pinMode(LED_AUDIOMUTE_PIN, OUTPUT); // Audio Mute Led
pinMode(LED_MICMUTE_PIN, OUTPUT); // Mic Mute Led
// >>>> UNMASK LATER
//Consumer.begin(); // Needed for HID - Audio Controls
// >>>> UNMASK LATER
//Keyboard.begin(); // Needed for HID - Keyboard Keys
/** DISPLAY **/
u8g.setFont(u8g_font_profont10); // define font
u8g.setColorIndex(1); // Set display color to white
}
void loop() {
/** VOLUME CONTROL **/
updateSliderValues(current_layer, NUM_LAYERS, NUM_SLIDERS, currentSlidersetStart);
sendSliderValues(); // Actually send data (all the time)
// printSliderValues(); // For debug
delay(10);
/** BUTTON CONTROL **/
/* Play // Pause */
if ((digitalRead(BUTTON_PLAYPAUSE_PIN) == LOW) && (button_playpause_clicked == 0)) { // Play// Pause button clicked - jump to previous layer
Serial.println("Play//Pause BTN pressed");
// >>>> UNMASK LATER
//Consumer.write(MEDIA_PLAY_PAUSE); // Send Play/Pause command to pc
button_playpause_clicked = 1; // set button to clicked to only perform the action once
}
/* Next */
else if ((digitalRead(BUTTON_NEXT_PIN) == LOW) && (button_next_clicked == 0)) { // Next button clicked - jump to previous layer
Serial.println("Next BTN pressed");
// >>>> UNMASK LATER
//Consumer.write(MEDIA_NEXT); // Send Next command to pc
button_next_clicked = 1; // set button to clicked to only perform the action once
}
/* Audio Mute */
else if ((digitalRead(BUTTON_AUDIOMUTE_PIN) == LOW) && (button_audiomute_clicked == 0)) { // Audio Mute button clicked - jump to previous layer
Serial.print("Audio Mute BTN pressed || ");
// >>>> UNMASK LATER
//Consumer.write(MEDIA_VOLUME_MUTE); // Send Audio Mute command to pc
button_audiomute_clicked = 1; // set button to clicked to only perform the action once
if (led_audiomute_on == 0) {
digitalWrite(LED_AUDIOMUTE_PIN, HIGH); // Turn Audio Mute LED ON
led_audiomute_on = 1; // set Audio Mute LED state to ON so it can be turned off again
Serial.println ("Led turned on");
}
else {
digitalWrite(LED_AUDIOMUTE_PIN, LOW); // Turn Audio Mute LED OFF
led_audiomute_on = 0; // set Audio Mute LED state to OFF so it can be turned on again
Serial.println ("Led turned off");
}
}
/* Layer UP */
else if ((digitalRead(BUTTON_LAYERDOWN_PIN) == LOW) && (button_layerdown_clicked == 0)) { // Previous Layer button clicked - jump to previous layer
Serial.print("Prev Layer BTN pressed || Layer = ");
current_layer = current_layer - 1; // select previous item
button_layerdown_clicked = 1; // set button to clicked to only perform the action once
if (current_layer < 0) { // if first item was selected, jump to last item
current_layer = NUM_LAYERS-1;
}
Serial.println(current_layer);
currentSlidersetStart = (NUM_DYNAMIC_SLIDERS * current_layer) + 1; // calculate first number of current virtual Slider Set for Value updates
//Serial.print("Current Slider Set Start Number = ");
//Serial.println(currentSlidersetStart);
}
/* Layer DOWN */
else if ((digitalRead(BUTTON_LAYERUP_PIN) == LOW) && (button_layerup_clicked == 0)) { // Next layer button clicked - jump to next layer
Serial.print("Next Layer BTN pressed || Layer = ");
current_layer = current_layer + 1; // select next item
button_layerup_clicked = 1; // set button to clicked to only perform the action once
if (current_layer >= NUM_LAYERS) { // last item was selected, jump to first menu item
current_layer = 0;
currentSlidersetStart = 1;
}
Serial.println(current_layer);
currentSlidersetStart = (NUM_DYNAMIC_SLIDERS * current_layer) + 1; // calculate first number of current virtual Slider Set for Value updates
//Serial.print("Current Slider Set Start Number = ");
//Serial.println(currentSlidersetStart);
}
/* Mic Mute */
else if ((digitalRead(BUTTON_MICMUTE_PIN) == LOW) && (button_micmute_clicked == 0)) { // Mic Mute button clicked - jump to previous layer
Serial.print("Mic Mute BTN pressed || ");
// >>>> UNMASK LATER
//Keyboard.write('F22'); // send Keystroke to PC
button_micmute_clicked = 1; // set button to clicked to only perform the action once
if (led_micmute_on == 0) {
digitalWrite(LED_MICMUTE_PIN, HIGH); // Turn Mic Mute LED ON
led_micmute_on = 1; // set Mic Mute LED state to ON so it can be turned off again
Serial.println ("Led turned on");
}
else {
digitalWrite(LED_MICMUTE_PIN, LOW); // Turn Mic Mute LED OFF
led_micmute_on = 0; // set Mic Mute LED state to OFF so it can be turned on again
Serial.println ("Led turned off");
}
}
/* Unclick BTNS */
if ((digitalRead(BUTTON_PLAYPAUSE_PIN) == HIGH) && (button_playpause_clicked == 1)) { // unclick
button_playpause_clicked = 0;
}
if ((digitalRead(BUTTON_NEXT_PIN) == HIGH) && (button_next_clicked == 1)) { // unclick
button_next_clicked = 0;
}
if ((digitalRead(BUTTON_AUDIOMUTE_PIN) == HIGH) && (button_audiomute_clicked == 1)) { // unclick
button_audiomute_clicked = 0;
}
if ((digitalRead(BUTTON_LAYERDOWN_PIN) == HIGH) && (button_layerdown_clicked == 1)) { // unclick
button_layerdown_clicked = 0;
}
if ((digitalRead(BUTTON_LAYERUP_PIN) == HIGH) && (button_layerup_clicked == 1)) { // unclick
button_layerup_clicked = 0;
}
if ((digitalRead(BUTTON_MICMUTE_PIN) == HIGH) && (button_micmute_clicked == 1)) { // unclick
button_micmute_clicked = 0;
}
/** DISPLAY **/
// set correct values for the previous and next layers
previous_layer = current_layer - 1;
if (previous_layer < 0) {previous_layer = NUM_LAYERS - 1;} // previous layer would be below first = make it the last
next_layer = current_layer + 1;
if (next_layer >= NUM_LAYERS) {next_layer = 0;} // next layer would be after last = make it the first
// set correct screen
if (delayRunning && ((millis() - delayStart) >= DELAY_TIME)) {
delayRunning = false; // finished delay -- single shot, once only
current_screen = 0; // Go back to current screen
}
u8g.firstPage();
do {
if (current_screen == 0) { // LAYER OVERVIEW
for (int j = 0; j < NUM_LAYERS; j++) { // For each layer - change volume knob values
int box_width = 28;
int box_height = 28;
int box_spacing = 4;
int box_x_pos = (box_width*j) + (box_spacing*j);
int box_y_pos = (64-box_height)/2;
int corner_radius = 2;
int font_height = 10;
int font_x_pos = box_x_pos + ((box_width-(string_width-1))/2);
int font_y_pos = box_y_pos + (box_height-(font_height/2));
if (current_layer == j) {
u8g.setColorIndex(1); // set color to white
u8g.drawRBox(box_x_pos, box_y_pos, box_width, box_height, corner_radius); //u8g_uint_t x, u8g_uint_t y, u8g_uint_t w, u8g_uint_t h, u8g_uint_t r#
u8g.setColorIndex(0); // set color to "black" or off
dtostrf(j, 1, 0, buffer); // Convert potentiometer value into str: Divide value by 10, max char width, number of decimals, write to [buffer]
string_width = u8g.getStrWidth(buffer);
u8g.drawStr(font_x_pos, font_y_pos, buffer);
}
else {
u8g.setColorIndex(1); // set color to white
u8g.drawRFrame(box_x_pos, box_y_pos, box_width, box_height, corner_radius); //u8g_uint_t x, u8g_uint_t y, u8g_uint_t w, u8g_uint_t h, u8g_uint_t r#
dtostrf(j, 1, 0, buffer); // Convert potentiometer value into str: Divide value by 10, max char width, number of decimals, write to [buffer]
string_width = u8g.getStrWidth(buffer);
u8g.drawStr(font_x_pos, font_y_pos, buffer);
}
}
}
else if (current_screen == 1) { // VOLUME BAR
//potentiometer_value = map(analogRead(analogInputs[0]), 0, 1023, 0, 100);
//volume_bar = map(analogRead(analogInputs[0]), 0, 1023, 0, 128);
for (int j = 0; j < NUM_LAYERS; j++) { // For each layer - change volume knob values
int box_width = 16;
int box_height = 16;
int box_spacing = 4;
int box_x_pos = (box_width*j) + (box_spacing*j);
int box_y_pos = 0;
int corner_radius = 2;
int font_height = 10;
int font_x_pos = box_x_pos + ((box_width-(string_width-1))/2);
int font_y_pos = box_y_pos + (box_height- (font_height/2));
if (current_layer == j) {
u8g.setColorIndex(1); // set color to white
u8g.drawRBox(box_x_pos, box_y_pos, box_width, box_height, corner_radius); //u8g_uint_t x, u8g_uint_t y, u8g_uint_t w, u8g_uint_t h, u8g_uint_t r#
u8g.setColorIndex(0); // set color to "black" or off
dtostrf(j, 1, 0, buffer); // Convert potentiometer value into str: value, max char width, number of decimals, write to [buffer]
string_width = u8g.getStrWidth(buffer);
u8g.drawStr(font_x_pos, font_y_pos, buffer);
}
else {
u8g.setColorIndex(1); // set color to white
u8g.drawRFrame(box_x_pos, box_y_pos, box_width, box_height, corner_radius); //u8g_uint_t x, u8g_uint_t y, u8g_uint_t w, u8g_uint_t h, u8g_uint_t r#
dtostrf(j, 1, 0, buffer); // Convert potentiometer value into str: value, max char width, number of decimals, write to [buffer]
string_width = u8g.getStrWidth(buffer);
u8g.drawStr(font_x_pos, font_y_pos, buffer);
}
}
u8g.setColorIndex(1); // set color to white
u8g.drawBox(0,32,volume_bar,32); //Draw a box (filled frame), starting at x/y position (upper left edge). The box has width w and height
u8g.setColorIndex(0); // set color to "black" or off
dtostrf(potentiometer_value, 1, 0, buffer); // Convert potentiometer value into str: Divide value by 10, max char width, number of decimals, write to [buffer]
u8g.drawStr(8, 51, buffer);
}
//u8g.drawStr(25, 50, itoa(potentiometer_value, buffer, 10 )); // Convert integer into str with [buffer number] characters in decimal system
//u8g.drawFrame(0, 10, 128, 20);
//u8g.drawBox(10, 15, progress, 10);
} while ( u8g.nextPage() );
/*
if ((digitalRead(BUTTON_SELECT_PIN) == LOW) && (button_select_clicked == 0)) { // select button clicked, jump between screens
button_select_clicked = 1; // set button to clicked to only perform the action once
if (current_screen == 0) {current_screen = 1;} // menu items screen --> screenshots screen
else if (current_screen == 1) {current_screen = 2;} // screenshots screen --> qr codes screen
else {current_screen = 0;} // qr codes screen --> menu items screen
}
if ((digitalRead(BUTTON_SELECT_PIN) == HIGH) && (button_select_clicked == 1)) { // unclick
button_select_clicked = 0;
}
*/
}
/* VOLUME CONTROL V03 - Pretty & WORKING Approach */
void updateSliderValues(int current_layer, int NUM_SLIDERS, int NUM_LAYERS, int currentSlidersetStart) {
for (int j = 0; j < NUM_LAYERS; j++) { // For each layer - change volume knob values
currentReading[0] = analogRead(analogInputs[0]); // Save current Potentiometer value
if( abs(currentReading[0] - lastReading[0]) >= 10 ) { // Check whether the current value significantly (>=10) varies from the last reading
lastReading[0] = currentReading[0]; // Save currentReading as last reading
analogSliderValues[0] = analogRead(analogInputs[0]); // Read Master Slider Volume, regardless of layer - move to if loop below if master slider should behave differenty for each layer
//Serial.println(analogSliderValues[0]);
potentiometer_value = map(analogRead(analogInputs[0]), 0, 1023, 0, 100); // For OLED Volume Bar: Map Potentiometer values to 0-100
volume_bar = map(analogRead(analogInputs[0]), 0, 1023, 0, 128); // For OLED Volume Bar: Map 0-100 Volume to 0-128, i.e. display width
current_screen = 1;
delayStart = millis();
delayRunning = true;
}
if (current_layer == j) { // Check which is current layer and read corresponding values
//Serial.print("Current Layer = ");
//Serial.println(j);
//Add Master volume slider here if it should behave differently for each layer
int i = currentSlidersetStart; // Start with Virtual Slider corresponding to selected layer
int k = 1; // Start with Slider 1 of 4
int max_i = currentSlidersetStart + NUM_SLIDERS; // Calculate max i for value - loop
//Serial.print("CurrentSlidersetStart = ");
//Serial.println(currentSlidersetStart);
//Serial.print("max_i = ");
//Serial.println(max_i);
for (i; i < max_i; i++) { // Read Sliders 1-4 (k) and update Virtual Slider Value i
currentReading[k] = analogRead(analogInputs[k]); // Save current Potentiometer value
if( abs(currentReading[k] - lastReading[k]) >= 10 ) { // Check whether the current value significantly (>=10) varies from the last reading
//Serial.print("Read Slider ");
//Serial.print(k);
//Serial.print("; Last reading: ");
//Serial.print(lastReading[k]);
//Serial.print("; Current Reading: ");
//Serial.println(currentReading[k]);
lastReading[k] = currentReading[k]; // Save currentReading as last reading
analogSliderValues[i] = analogRead(analogInputs[k]); // Update Slider Value
// add what you want to do with a pot change here
//Serial.print("; Set input # to ");
//Serial.print(i);
//Serial.print(" = ");
//Serial.println(analogSliderValues[i]);
potentiometer_value = map(analogRead(analogInputs[k]), 0, 1023, 0, 100); // For OLED Volume Bar: Map Potentiometer values to 0-100
volume_bar = map(analogRead(analogInputs[k]), 0, 1023, 0, 128); // For OLED Volume Bar: Map 0-100 Volume to 0-128, i.e. display width
current_screen = 1;
delayStart = millis();
delayRunning = true;
}
k++;
//Serial.print("Read Slider ");
//Serial.print(k);
//Serial.print("; Set input # to ");
//Serial.print(i);
//Serial.print(" = ");
//Serial.println(analogSliderValues[i]);
}
//delay(1000);
}
}
}
void sendSliderValues() {
String builtString = String("");
for (int i = 0; i < NUM_VIRTUAL_SLIDERS; i++) {
builtString += String((int)analogSliderValues[i]);
if (i < NUM_VIRTUAL_SLIDERS-1) {
builtString += String("|");
}
}
Serial.println(builtString);
}
void printSliderValues() {
for (int i = 0; i < NUM_VIRTUAL_SLIDERS; i++) {
String printedString = String("Slider #") + String(i + 1) + String(": ") + String(analogSliderValues[i]) + String(" mV");
Serial.write(printedString.c_str());
if (i < NUM_VIRTUAL_SLIDERS-1) {
Serial.write(" | ");
} else {
Serial.write("\n");
}
}
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////// BACKED UP WORKING STUFF
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/* VOLUME CONTROL V03 - Pretty & WORKING Approach
void updateSliderValues(int current_layer, int NUM_SLIDERS, int NUM_LAYERS, int currentSlidersetStart) {
for (int j = 0; j < NUM_LAYERS; j++) { // For each layer - change volume knob values
if (current_layer == j) { // Check which is current layer and read corresponding values
//Serial.print("Current Layer = ");
//Serial.println(j);
analogSliderValues[0] = analogRead(analogInputs[0]); // Read Master Slider Volume
//Serial.println(analogSliderValues[0]);
int i = currentSlidersetStart;
int k = 1; // Start with Slider 1 of 4
int max_i = currentSlidersetStart + NUM_SLIDERS; // Calculate max i for value - Schleife
//Serial.print("CurrentSlidersetStart = ");
//Serial.println(currentSlidersetStart);
//Serial.print("max_i = ");
//Serial.println(max_i);
for (i; i < max_i; i++) { // Read Sliders 1-4 (k) and update Virtual Slider Value i
analogSliderValues[i] = analogRead(analogInputs[k]);
k++;
//Serial.print("Read Slider ");
//Serial.print(k);
//Serial.print("; Set input # to ");
//Serial.print(i);
//Serial.print(" = ");
//Serial.println(analogSliderValues[i]);
}
//delay(1000);
}
}
}
*/
/* Working drawings
u8g.setColorIndex(1); // set color to white
u8g.drawRFrame(0, 0, 16, 16, 2); //u8g_uint_t x, u8g_uint_t y, u8g_uint_t w, u8g_uint_t h, u8g_uint_t r#
u8g.setColorIndex(1); // set color to "black" or off
dtostrf(current_layer, 1, 0, buffer); // Convert potentiometer value into str: Divide value by 10, max char width, number of decimals, write to [buffer]
string_width = u8g.getStrWidth(buffer);
u8g.drawStr((16-(string_width-1))/2, 11, buffer);
u8g.setColorIndex(1); // set color to white
u8g.drawRBox(20, 0, 16, 16, 2); //u8g_uint_t x, u8g_uint_t y, u8g_uint_t w, u8g_uint_t h, u8g_uint_t r
u8g.setColorIndex(1); // set color to white
u8g.drawRBox(40, 0, 16, 16, 2); //u8g_uint_t x, u8g_uint_t y, u8g_uint_t w, u8g_uint_t h, u8g_uint_t r
u8g.setColorIndex(1); // set color to white
u8g.drawRBox(60, 0, 16, 16, 2); //u8g_uint_t x, u8g_uint_t y, u8g_uint_t w, u8g_uint_t h, u8g_uint_t r
*/
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////// Random Backups
/* VOLUME CONTROL V02 - if else approach*/
/*
void updateSliderValues(int current_layer) {
int _current_layer = current_layer;
//int _num_layers = 4;
//int SliderSetStart;
//int max_i;
if (_current_layer == 0) { // Change layer 0 knob values
Serial.println("Current Layer 0!)");
//SliderSetStart = 1;
//max_i = SliderSetStart + _num_layers;
for (int i = 1; i < 5; i++) {
analogSliderValues[i] = analogRead(analogInputs[i]);
}
/*
for (int i = SliderSetStart; i < max_i; i++) {
analogSliderValues[i] = analogRead(analogInputs[i]);
}
*/
/*
}
if (_current_layer == 1) { // Change layer 1 knob values
Serial.println("Current Layer 1!)");
//SliderSetStart = 5;
//max_i = SliderSetStart + _num_layers;
for (int i = 5; i < 9; i++) {
analogSliderValues[i] = analogRead(analogInputs[i]);
}
}
if (_current_layer == 2) { // Change layer 1 knob values
Serial.println("Current Layer 2!)");
//SliderSetStart = 9;
//max_i = SliderSetStart + _num_layers;
for (int i = 9; i < 12; i++) {
analogSliderValues[i] = analogRead(analogInputs[i]);
}
}
if (_current_layer == 3) { // Change layer 1 knob values
Serial.println("Current Layer 3!)");
//SliderSetStart = 13;
//max_i = SliderSetStart + _num_layers;
for (int i = 13; i < 17; i++) {
analogSliderValues[i] = analogRead(analogInputs[i]);
}
}
}
*/
/*
void updateSliderValues() { //int current_layer, const int NUM_LAYERS, const int NUM_SLIDERS, int currentSlidersetStart) {
//int _current_layer = current_layer;
int SliderSetStart = 1;
int max_i = SliderSetStart + 4;
if (current_layer == 0) { // Change layer 0 knob values
//Serial.println("Current Layer 0!)");
SliderSetStart = 1;
max_i = SliderSetStart + 4;
for (int i = SliderSetStart; i < max_i; i++) {
analogSliderValues[i] = analogRead(analogInputs[i]);
}
}
else if (current_layer == 1) { // Change layer 1 knob values
//Serial.println("Current Layer 1!)");
SliderSetStart = 5;
max_i = SliderSetStart + 4;
for (int i = SliderSetStart; i < max_i; i++) {
analogSliderValues[i] = analogRead(analogInputs[i]);
}
}
/*
int _num_sliders = NUM_SLIDERS;
int _num_layers = NUM_LAYERS;
//Serial.println(_NUM_LAYERS);
int _current_layer = current_layer;
//Serial.println(_current_layer);
int _currentSlidersetStart = currentSlidersetStart;
int max_i = _currentSlidersetStart + _num_sliders - 1; // Add number of existing knobs (minus 1, the master knob) to reach next slider set of 4
//Serial.println(max_i);
int max_i = _currentSlidersetStart + _num_sliders - 1; // Add number of existing knobs (minus 1, the master knob) to reach next slider set of 4
// Master Volume - always read as it doesn't change with different layers
analogSliderValues[0] = analogRead(analogInputs[0]); // Read ONLY MASTER volume value
for (int j = 0; j <= _num_layers; j++) { // For each layer - change volume knob values
if (_current_layer == j) { // Check which is current layer and read corresponding values
Serial.print("Current Layer = ");
Serial.println(j);
for (int i = _currentSlidersetStart; i < max_i; i++) {
analogSliderValues[i] = analogRead(analogInputs[i]);
}
}
}
*/
/*
for (int j = 0; j < max_j; j++) { // For each layer - change volume knob values
if (current_layer == j) { // Check which is current layer and read corresponding values
// Serial.print("Current Layer = ");
// Serial.println(j);
//SliderSetStart = 1+j;
for (int i = currentSlidersetStart; i < max_i; i++) {
analogSliderValues[i] = analogRead(analogInputs[i]);
}
}
}
/*
if (current_layer == 0) { // Change layer 0 knob values
//Serial.println("Current Layer 0!)");
SliderSetStart = 1;
max_i = SliderSetStart + 4;
for (int i = SliderSetStart; i < max_i; i++) {
analogSliderValues[i] = analogRead(analogInputs[i]);
}
}
else if (current_layer == 1) { // Change layer 1 knob values
//Serial.println("Current Layer 1!)");
SliderSetStart = 5;
max_i = SliderSetStart + 4;
for (int i = SliderSetStart; i < max_i; i++) {
analogSliderValues[i] = analogRead(analogInputs[i]);
}
}
*/
//}
/** VOLUME CONTROL v01 - weird problems **/
//if (current_layer == 0) { // USE LAYER 0 VOLUME KNOB CONFIG
/*
void updateSliderValues() {}
// Master Volume
analogSliderValues[0] = analogRead(analogInputs[0]); // Read MASTER volume value
for (int i = currentSlidersetStart; i < currentSlidersetStart + 4; i++) { // Update input values for next 4 Sliders, depending on current layer
analogSliderValues[i] = analogRead(analogInputs[i]);
}
}
void sendSliderValues() {
String builtString = String("");
for (int i = 0; i < 17 +1; i++) { // Send string with input values for all sliders, INCLUDING master
builtString += String((int)analogSliderValues[i]);
if (i < 16) {
builtString += String("|");
}
}
// >>>> UNMASK LATER
//Serial.println(builtString);
}
/*
void printSliderValues() {
for (int i = 0; i < NUM_VIRTUAL_SLIDERS; i++) { // Write string with input values for all sliders, INCLUDING master (=+1!)
String printedString = String("Slider #") + String(i + 1) + String(": ") + String(analogSliderValues[i]) + String(" mV");
Serial.write(printedString.c_str());
if (i < NUM_VIRTUAL_SLIDERS - 1) {
Serial.write(" | ");
} else {
Serial.write("\n");
}
}
}
*/
/* VOLUME CONTROL BACKUP*/
/*
void updateSliderValues() {
for (int i = 0; i < NUM_SLIDERS; i++) {
analogSliderValues[i] = analogRead(analogInputs[i]);
}
}
void sendSliderValues() {
String builtString = String("");
for (int i = 0; i < NUM_SLIDERS; i++) {
builtString += String((int)analogSliderValues[i]);
if (i < NUM_SLIDERS - 1) {
builtString += String("|");
}
}
// >>>> UNMASK LATER
//Serial.println(builtString);
}
void printSliderValues() {
for (int i = 0; i < NUM_SLIDERS; i++) {
String printedString = String("Slider #") + String(i + 1) + String(": ") + String(analogSliderValues[i]) + String(" mV");
Serial.write(printedString.c_str());
if (i < NUM_SLIDERS - 1) {
Serial.write(" | ");
} else {
Serial.write("\n");
}
}
}
*/