You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
714 lines
15 KiB
C++
714 lines
15 KiB
C++
#include <MozziGuts.h>
|
|
#include <Oscil.h>
|
|
#include <tables/sin2048_int8.h>
|
|
#include <Line.h> // for envelope
|
|
#include <ADSR.h>
|
|
#include <mozzi_fixmath.h>
|
|
|
|
#include <ADC.h>
|
|
#include <IntervalTimer.h>
|
|
|
|
//#include <MusicWithoutDelay.h>
|
|
//#include <synth.h>
|
|
//#include <tables.h>
|
|
|
|
#include <Wire.h>
|
|
#include <Adafruit_ADS1015.h>
|
|
|
|
//multiplexer adresses
|
|
Adafruit_ADS1115 adsa (0x48);
|
|
Adafruit_ADS1115 adsb (0x49);
|
|
Adafruit_ADS1115 adsc (0x4A);
|
|
Adafruit_ADS1115 adsd (0x4B);
|
|
|
|
|
|
//note values
|
|
//const char note0[] PROGMEM = ":d=128,b=300:c-1+"; //plays c4
|
|
//const char note1[] PROGMEM = ":d=128,b=300:d-1+"; //plays d4
|
|
//const char note2[] PROGMEM = ":d=128,b=300:e-1+"; //plays e4
|
|
//const char note3[] PROGMEM = ":d=128,b=300:g-1+"; //plays g4
|
|
//const char note4[] PROGMEM = ":d=128,b=300:a-1+"; //plays a4
|
|
//const char note5[] PROGMEM = ":d=128,b=300:c+"; //plays c5
|
|
//const char note6[] PROGMEM = ":d=128,b=300:d+"; //plays d5
|
|
//const char note7[] PROGMEM = ":d=128,b=300:e+"; //plays e5
|
|
//const char note8[] PROGMEM = ":d=128,b=300:g+"; //plays g5
|
|
//const char note9[] PROGMEM = ":d=128,b=300:a+"; //plays a5
|
|
//const char note10[] PROGMEM = ":d=128,b=300:c+1+"; //plays c6
|
|
//const char note11[] PROGMEM = ":d=128,b=300:d+1+"; //plays d6
|
|
//const char note12[] PROGMEM = ":d=128,b=300:e+1+"; //plays e6
|
|
//const char note13[] PROGMEM = ":d=128,b=300:g+1+"; //plays g6
|
|
//const char note14[] PROGMEM = ":d=128,b=300:a+1+"; //plays a6
|
|
//const char note15[] PROGMEM = ":d=128,b=300:c+2+"; //plays c7
|
|
|
|
//instruments
|
|
//MusicWithoutDelay Insta(note0);
|
|
//MusicWithoutDelay Instb(note1);
|
|
//MusicWithoutDelay Instc(note2);
|
|
//MusicWithoutDelay Instd(note3);
|
|
//MusicWithoutDelay Inste(note4);
|
|
//MusicWithoutDelay Instf(note5);
|
|
//MusicWithoutDelay Instg(note6);
|
|
//MusicWithoutDelay Insth(note7);
|
|
//MusicWithoutDelay Insti(note8);
|
|
//MusicWithoutDelay Instj(note9);
|
|
//MusicWithoutDelay Instk(note10);
|
|
//MusicWithoutDelay Instl(note11);
|
|
//MusicWithoutDelay Instm(note12);
|
|
//MusicWithoutDelay Instn(note13);
|
|
//MusicWithoutDelay Insto(note14);
|
|
//MusicWithoutDelay Instp(note15);
|
|
|
|
#define CONTROL_RATE 64
|
|
#define ATTACK 50 // long enough for control rate to catch it
|
|
#define DECAY 50
|
|
#define SUSTAIN 600000 // Sustain 60 seconds unless a noteOff comes.
|
|
#define RELEASE 1000
|
|
#define ATTACK_LEVEL 255
|
|
#define DECAY_LEVEL 255
|
|
|
|
Oscil <2048, AUDIO_RATE> Insta(SIN2048_DATA);
|
|
Oscil <2048, AUDIO_RATE> Instb(SIN2048_DATA);
|
|
Oscil <2048, AUDIO_RATE> Instc(SIN2048_DATA);
|
|
Oscil <2048, AUDIO_RATE> Instd(SIN2048_DATA);
|
|
Oscil <2048, AUDIO_RATE> Inste(SIN2048_DATA);
|
|
Oscil <2048, AUDIO_RATE> Instf(SIN2048_DATA);
|
|
Oscil <2048, AUDIO_RATE> Instg(SIN2048_DATA);
|
|
Oscil <2048, AUDIO_RATE> Insth(SIN2048_DATA);
|
|
Oscil <2048, AUDIO_RATE> Insti(SIN2048_DATA);
|
|
Oscil <2048, AUDIO_RATE> Instj(SIN2048_DATA);
|
|
Oscil <2048, AUDIO_RATE> Instk(SIN2048_DATA);
|
|
Oscil <2048, AUDIO_RATE> Instl(SIN2048_DATA);
|
|
Oscil <2048, AUDIO_RATE> Instm(SIN2048_DATA);
|
|
Oscil <2048, AUDIO_RATE> Instn(SIN2048_DATA);
|
|
Oscil <2048, AUDIO_RATE> Insto(SIN2048_DATA);
|
|
Oscil <2048, AUDIO_RATE> Instp(SIN2048_DATA);
|
|
|
|
ADSR <CONTROL_RATE, CONTROL_RATE> envelope1;
|
|
|
|
int count;
|
|
//int vol;
|
|
int VA0, VA1, VA2, VA3, VA4, VA5, VA6, VA7, VA8, VA9, VA10, VA11, VA12, VA13, VA14, VA15;
|
|
int TH0, TH1, TH2, TH3, TH4, TH5, TH6, TH7, TH8, TH9, TH10, TH11, TH12, TH13, TH14, TH15;
|
|
int VOL0, VOL1, VOL2, VOL3, VOL4, VOL5, VOL6, VOL7, VOL8, VOL9, VOL10, VOL11, VOL12, VOL13, VOL14, VOL15;
|
|
bool CV;
|
|
|
|
bool ZER;
|
|
bool ONE;
|
|
bool TWO;
|
|
bool THR;
|
|
bool FOU;
|
|
bool FIV;
|
|
bool SIX;
|
|
bool SEV;
|
|
bool EIG;
|
|
bool NIN;
|
|
bool TEN;
|
|
bool ELE;
|
|
bool TWE;
|
|
bool THT;
|
|
bool FOT;
|
|
bool FIT;
|
|
|
|
void setup() {
|
|
Serial.begin(9600);
|
|
|
|
//set the gain for multiplexed INs
|
|
adsa.setGain(GAIN_ONE); // 1x gain +/- 4.096V 1 bit = 2mV 0.125mV
|
|
adsb.setGain(GAIN_ONE);
|
|
adsc.setGain(GAIN_ONE);
|
|
adsd.setGain(GAIN_ONE);
|
|
|
|
Serial.println("Ini MPX ");
|
|
adsa.begin();
|
|
adsb.begin();
|
|
adsc.begin();
|
|
adsd.begin();
|
|
Serial.println("MPX Ini");
|
|
|
|
//calibrate the LDRs
|
|
Serial.println ("Calib");
|
|
TH0 = (adsa.readADC_SingleEnded(0) + 800);
|
|
TH1 = (adsa.readADC_SingleEnded(1) + 800);
|
|
TH2 = (adsa.readADC_SingleEnded(2) + 800);
|
|
TH3 = (adsa.readADC_SingleEnded(3) + 800);
|
|
TH4 = (adsb.readADC_SingleEnded(0) + 800);
|
|
TH5 = (adsb.readADC_SingleEnded(1) + 800);
|
|
TH6 = (adsb.readADC_SingleEnded(2) + 800);
|
|
TH7 = (adsb.readADC_SingleEnded(3) + 800);
|
|
TH8 = (adsc.readADC_SingleEnded(0) + 800);
|
|
TH9 = (adsc.readADC_SingleEnded(1) + 800);
|
|
TH10 = (adsc.readADC_SingleEnded(2) + 800);
|
|
TH11 = (adsc.readADC_SingleEnded(3) + 800);
|
|
TH12 = (adsd.readADC_SingleEnded(0) + 800);
|
|
TH13 = (adsd.readADC_SingleEnded(1) + 800);
|
|
TH14 = (adsd.readADC_SingleEnded(2) + 800);
|
|
TH15 = (adsd.readADC_SingleEnded(3) + 800);
|
|
|
|
Serial.print ("TH0=");
|
|
Serial.println (TH0);
|
|
Serial.print ("TH1=");
|
|
Serial.println (TH1);
|
|
Serial.print ("TH2=");
|
|
Serial.println (TH2);
|
|
Serial.print ("TH3=");
|
|
Serial.println (TH3);
|
|
Serial.print ("TH4=");
|
|
Serial.println (TH4);
|
|
Serial.print ("TH5=");
|
|
Serial.println (TH5);
|
|
Serial.print ("TH6=");
|
|
Serial.println (TH6);
|
|
Serial.print ("TH7=");
|
|
Serial.println (TH7);
|
|
Serial.print ("TH8=");
|
|
Serial.println (TH8);
|
|
Serial.print ("TH9=");
|
|
Serial.println (TH9);
|
|
Serial.print ("TH10=");
|
|
Serial.println (TH10);
|
|
Serial.print ("TH11=");
|
|
Serial.println (TH11);
|
|
Serial.print ("TH12=");
|
|
Serial.println (TH12);
|
|
Serial.print ("TH13=");
|
|
Serial.println (TH13);
|
|
Serial.print ("TH14=");
|
|
Serial.println (TH14);
|
|
Serial.print ("TH15=");
|
|
Serial.println (TH15);
|
|
|
|
Serial.println("Wait4MWD");
|
|
Serial.println("Ini MWD");
|
|
|
|
|
|
Insta.setFreq(165);
|
|
Insta.setPhase(0);
|
|
Instb.setFreq(196);
|
|
Instb.setPhase(30);
|
|
Instc.setFreq(220);
|
|
Instc.setPhase(60);
|
|
Instd.setFreq(262);
|
|
Instd.setPhase(90);
|
|
Inste.setFreq(330);
|
|
Inste.setPhase(120);
|
|
Instf.setFreq(392);
|
|
Instf.setPhase(150);
|
|
Instg.setFreq(440);
|
|
Instg.setPhase(180);
|
|
Insth.setFreq(523);
|
|
Insth.setPhase(210);
|
|
Insti.setFreq(659);
|
|
Insti.setPhase(240);
|
|
Instj.setFreq(784);
|
|
Instj.setPhase(270);
|
|
Instk.setFreq(880);
|
|
Instk.setPhase(300);
|
|
Instl.setFreq(1047);
|
|
Instl.setPhase(330);
|
|
Instm.setFreq(659);
|
|
Instm.setPhase(240);
|
|
Instn.setFreq(784);
|
|
Instn.setPhase(270);
|
|
Insto.setFreq(880);
|
|
Insto.setPhase(300);
|
|
Instp.setFreq(1047);
|
|
Instp.setPhase(330);
|
|
|
|
envelope1.setADLevels(ATTACK_LEVEL,DECAY_LEVEL);
|
|
envelope1.setTimes(ATTACK,DECAY,SUSTAIN,RELEASE);
|
|
//
|
|
// Insta.begin(CHA, TRIANGLE, ENVELOPE2, 0);
|
|
// Instb.begin(TRIANGLE, ENVELOPE2, 0);
|
|
// Instc.begin(TRIANGLE, ENVELOPE2, 0);
|
|
// Instd.begin(TRIANGLE, ENVELOPE2, 0);
|
|
// Inste.begin(TRIANGLE, ENVELOPE2, 0);
|
|
// Instf.begin(TRIANGLE, ENVELOPE2, 0);
|
|
// Instg.begin(TRIANGLE, ENVELOPE2, 0);
|
|
// Insth.begin(TRIANGLE, ENVELOPE2, 0);
|
|
// Insti.begin(TRIANGLE, ENVELOPE2, 0);
|
|
// Instj.begin(TRIANGLE, ENVELOPE2, 0);
|
|
// Instk.begin(TRIANGLE, ENVELOPE2, 0);
|
|
// Instl.begin(TRIANGLE, ENVELOPE2, 0);
|
|
// Instm.begin(TRIANGLE, ENVELOPE2, 0);
|
|
// Instn.begin(TRIANGLE, ENVELOPE2, 0);
|
|
// Insto.begin(TRIANGLE, ENVELOPE2, 0);
|
|
// Instp.begin(TRIANGLE, ENVELOPE2, 0);
|
|
//
|
|
// Insta.pause(true);
|
|
// Instb.pause(true);
|
|
// Instc.pause(true);
|
|
// Instd.pause(true);
|
|
// Inste.pause(true);
|
|
// Instf.pause(true);
|
|
// Instg.pause(true);
|
|
// Insth.pause(true);
|
|
// Insti.pause(true);
|
|
// Instj.pause(true);
|
|
// Instk.pause(true);
|
|
// Instl.pause(true);
|
|
// Instm.pause(true);
|
|
// Instn.pause(true);
|
|
// Insto.pause(true);
|
|
// Instp.pause(true);
|
|
|
|
startMozzi(CONTROL_RATE);
|
|
|
|
Serial.println("go!");
|
|
}
|
|
|
|
void updateControl(){
|
|
if (VA0 > TH0) {
|
|
count++;
|
|
ZER = true;
|
|
if (CV) {
|
|
digitalWrite(0, HIGH);
|
|
}
|
|
else if (!CV) {
|
|
digitalWrite(0, LOW);
|
|
}
|
|
}
|
|
else if (VA0 < TH0) {
|
|
ZER = false;
|
|
//Kill ControlVoltage
|
|
digitalWrite(0, LOW);
|
|
}
|
|
|
|
if (VA1 > TH1) {
|
|
count++;
|
|
ONE = true;
|
|
if (CV) {
|
|
digitalWrite(1, HIGH);
|
|
}
|
|
else if (!CV) {
|
|
digitalWrite(1, LOW);
|
|
}
|
|
}
|
|
else if (VA1 < TH1) {
|
|
ONE = false;
|
|
//Kill ControlVoltage
|
|
digitalWrite(1, LOW);
|
|
}
|
|
|
|
if (VA2 > TH2) {
|
|
count++;
|
|
TWO = true;
|
|
if (CV) {
|
|
digitalWrite(2, HIGH);
|
|
}
|
|
else if (!CV) {
|
|
digitalWrite(2, LOW);
|
|
}
|
|
}
|
|
else if (VA2 < TH2) {
|
|
TWO = false;
|
|
//Kill ControlVoltage
|
|
digitalWrite(2, LOW);
|
|
}
|
|
|
|
if (VA3 > TH3) {
|
|
count++;
|
|
THR = true;
|
|
if (CV) {
|
|
digitalWrite(3, HIGH);
|
|
}
|
|
else if (!CV) {
|
|
digitalWrite(3, LOW);
|
|
}
|
|
}
|
|
else if (VA3 < TH3) {
|
|
THR = false;
|
|
//Kill ControlVoltage
|
|
digitalWrite(3, LOW);
|
|
}
|
|
|
|
if (VA4 > TH4) {
|
|
count++;
|
|
FOU = true;
|
|
if (CV) {
|
|
digitalWrite(4, HIGH);
|
|
}
|
|
else if (!CV) {
|
|
digitalWrite(4, LOW);
|
|
}
|
|
}
|
|
else if (VA4 < TH4) {
|
|
FOU = false;
|
|
//Kill ControlVoltage
|
|
digitalWrite(4, LOW);
|
|
}
|
|
|
|
if (VA5 > TH5) {
|
|
if (CV) {
|
|
digitalWrite(5, HIGH);
|
|
}
|
|
else if (!CV) {
|
|
digitalWrite(5, LOW);
|
|
}
|
|
count++;
|
|
FIV = true;
|
|
}
|
|
else if (VA5 < TH5) {
|
|
FIV = false;
|
|
//Kill ControlVoltage
|
|
digitalWrite(5, LOW);
|
|
}
|
|
|
|
if (VA6 > TH6) {
|
|
count++;
|
|
SIX = true;
|
|
if (CV) {
|
|
digitalWrite(6, HIGH);
|
|
}
|
|
else if (!CV) {
|
|
digitalWrite(6, LOW);
|
|
}
|
|
}
|
|
else if (VA6 < TH6) {
|
|
SIX = false;
|
|
//Kill ControlVoltage
|
|
digitalWrite(6, LOW);
|
|
}
|
|
|
|
if (VA7 > TH7) {
|
|
count++;
|
|
SEV = true;
|
|
if (CV) {
|
|
digitalWrite(7, HIGH);
|
|
}
|
|
else if (!CV) {
|
|
digitalWrite(7, LOW);
|
|
}
|
|
}
|
|
else if (VA7 < TH7) {
|
|
SEV = false;
|
|
//Kill ControlVoltage
|
|
digitalWrite(7, LOW);
|
|
}
|
|
|
|
if (VA8 > TH8) {
|
|
count++;
|
|
EIG = true;
|
|
if (CV) {
|
|
digitalWrite(8, HIGH);
|
|
}
|
|
else if (!CV) {
|
|
digitalWrite(8, LOW);
|
|
}
|
|
}
|
|
else if (VA8 < TH8) {
|
|
EIG = false;
|
|
//Kill ControlVoltage
|
|
digitalWrite(8, LOW);
|
|
|
|
}
|
|
|
|
if (VA9 > TH9) {
|
|
count++;
|
|
NIN = true;
|
|
if (CV) {
|
|
digitalWrite(9, HIGH);
|
|
}
|
|
else if (!CV) {
|
|
digitalWrite(9, LOW);
|
|
}
|
|
}
|
|
else if (VA9 < TH9) {
|
|
NIN = false;
|
|
//Kill ControlVoltage
|
|
digitalWrite(9, LOW);
|
|
}
|
|
|
|
if (VA10 > TH10) {
|
|
count++;
|
|
TEN = true;
|
|
if (CV) {
|
|
digitalWrite(10, HIGH);
|
|
}
|
|
else if (!CV) {
|
|
digitalWrite(10, LOW);
|
|
}
|
|
}
|
|
else if (VA10 < TH10) {
|
|
TEN = false;
|
|
//Kill ControlVoltage
|
|
digitalWrite(10, LOW);
|
|
}
|
|
|
|
if (VA11 > TH11) {
|
|
count++;
|
|
ELE = true;
|
|
if (CV) {
|
|
digitalWrite(11, HIGH);
|
|
}
|
|
else if (!CV) {
|
|
digitalWrite(11, LOW);
|
|
}
|
|
}
|
|
else if (VA11 < TH11) {
|
|
ELE = false;
|
|
//Kill ControlVoltage
|
|
digitalWrite(11, LOW);
|
|
}
|
|
|
|
if (VA12 > TH12) {
|
|
count++;
|
|
TWE = true;
|
|
if (CV) {
|
|
digitalWrite(12, HIGH);
|
|
}
|
|
else if (!CV) {
|
|
digitalWrite(12, LOW);
|
|
}
|
|
}
|
|
else if (VA12 < TH12) {
|
|
TWE = false;
|
|
//Kill ControlVoltage
|
|
digitalWrite(12, LOW);
|
|
}
|
|
|
|
if (VA13 > TH13) {
|
|
count++;
|
|
THT = true;
|
|
if (CV) {
|
|
digitalWrite(13, HIGH);
|
|
}
|
|
else if (!CV) {
|
|
digitalWrite(13, LOW);
|
|
}
|
|
}
|
|
else if (VA13 < TH13) {
|
|
THT = false;
|
|
//Kill ControlVoltage
|
|
digitalWrite(13, LOW);
|
|
}
|
|
|
|
if (VA14 > TH14) {
|
|
count++;
|
|
FOT = true;
|
|
if (CV) {
|
|
digitalWrite(14, HIGH);
|
|
}
|
|
else if (!CV) {
|
|
digitalWrite(14, LOW);
|
|
}
|
|
}
|
|
else if (VA14 < TH14) {
|
|
FOT = false;
|
|
//Kill ControlVoltage
|
|
digitalWrite(14, LOW);
|
|
}
|
|
|
|
if (VA15 > TH15) {
|
|
count++;
|
|
FIT = true;
|
|
if (CV) {
|
|
digitalWrite(15, HIGH);
|
|
}
|
|
else if (!CV) {
|
|
digitalWrite(15, LOW);
|
|
}
|
|
}
|
|
else if (VA15 < TH15) {
|
|
FIT = false;
|
|
//Kill ControlVoltage
|
|
digitalWrite(15, LOW);
|
|
}
|
|
|
|
|
|
// Serial.print("Intruments playing = ");
|
|
// Serial.println(count);
|
|
}
|
|
|
|
int updateAudio(){
|
|
int result = 0;
|
|
//Play notes and mix down (set volume depending on number of notes playing)
|
|
if (ZER) {
|
|
//envelope1.update();
|
|
//return Insta.noteOn());
|
|
return (Insta) (envelope1.noteOn());
|
|
}
|
|
|
|
if (!ZER) {
|
|
envelope1.noteOff();
|
|
}
|
|
|
|
if (ONE) {
|
|
// VOL1 = 50/count+constrain(map(VA1, TH1, TH1+5000, 0, 65), 0, 65);
|
|
result += Instb.next();
|
|
}
|
|
|
|
if (!ONE) {
|
|
}
|
|
|
|
if (TWO) {
|
|
result += Instc.next();
|
|
}
|
|
|
|
if (!TWO) {
|
|
}
|
|
|
|
if (THR) {
|
|
result += Instd.next();
|
|
}
|
|
|
|
if (!THR) {
|
|
}
|
|
|
|
if (FOU) {
|
|
result += Inste.next();
|
|
}
|
|
|
|
if (!FOU) {
|
|
}
|
|
|
|
if (FIV) {
|
|
result += Instf.next();
|
|
}
|
|
|
|
if (!FIV) {
|
|
}
|
|
|
|
if (SIX) {
|
|
result += Instg.next();
|
|
}
|
|
|
|
if (!SIX) {
|
|
}
|
|
|
|
if (SEV) {
|
|
result += Insth.next();
|
|
}
|
|
|
|
if (!SEV) {
|
|
}
|
|
|
|
|
|
if (EIG) {
|
|
result += Insti.next();
|
|
}
|
|
|
|
if (!EIG) {
|
|
}
|
|
|
|
if (NIN) {
|
|
result += Instj.next();
|
|
}
|
|
|
|
if (!NIN) {
|
|
}
|
|
|
|
if (TEN) {
|
|
result += Instk.next();
|
|
}
|
|
|
|
if (!TEN) {
|
|
}
|
|
|
|
if (ELE) {
|
|
result += Instl.next();
|
|
}
|
|
|
|
if (!ELE) {
|
|
}
|
|
|
|
if (TWE) {
|
|
result += Instm.next();
|
|
}
|
|
|
|
if (!TWE) {
|
|
}
|
|
|
|
if (THT) {
|
|
result += Instn.next();
|
|
}
|
|
|
|
if (!THT) {
|
|
}
|
|
|
|
if (FOT) {
|
|
result += Insto.next();
|
|
}
|
|
|
|
if (!FOT) {
|
|
}
|
|
|
|
|
|
if (FIT) {
|
|
result += Instp.next();
|
|
}
|
|
|
|
if (!FIT) {
|
|
}
|
|
return;
|
|
}
|
|
|
|
void loop() {
|
|
CV = digitalRead(22);
|
|
count = 0;
|
|
|
|
// Insta.update();
|
|
// Instb.update();
|
|
// Instc.update();
|
|
// Instd.update();
|
|
// Inste.update();
|
|
// Instf.update();
|
|
// Instg.update();
|
|
// Insth.update();
|
|
// Insti.update();
|
|
// Instj.update();
|
|
// Instk.update();
|
|
// Instl.update();
|
|
// Instm.update();
|
|
// Instn.update();
|
|
// Insto.update();
|
|
// Instp.update();
|
|
|
|
//Messure LDR inputs
|
|
VA0 = adsa.readADC_SingleEnded(0);
|
|
VA1 = adsa.readADC_SingleEnded(1);
|
|
VA2 = adsa.readADC_SingleEnded(2);
|
|
VA3 = adsa.readADC_SingleEnded(3);
|
|
|
|
// Serial.print("VA0: "); Serial.println(VA0);
|
|
// Serial.print("VA1: "); Serial.println(VA1);
|
|
// Serial.print("VA2: "); Serial.println(VA2);
|
|
// Serial.print("VA3: "); Serial.println(VA3);
|
|
// Serial.println(" ");
|
|
|
|
VA4 = adsb.readADC_SingleEnded(0);
|
|
VA5 = adsb.readADC_SingleEnded(1);
|
|
VA6 = adsb.readADC_SingleEnded(2);
|
|
VA7 = adsb.readADC_SingleEnded(3);
|
|
|
|
// Serial.print("VA4: "); Serial.println(VA4);
|
|
// Serial.print("VA5: "); Serial.println(VA5);
|
|
// Serial.print("VA6: "); Serial.println(VA6);
|
|
// Serial.print("VA7: "); Serial.println(VA7);
|
|
// Serial.println(" ");
|
|
|
|
VA8 = adsc.readADC_SingleEnded(0);
|
|
VA9 = adsc.readADC_SingleEnded(1);
|
|
VA10 = adsc.readADC_SingleEnded(2);
|
|
VA11 = adsc.readADC_SingleEnded(3);
|
|
|
|
// Serial.print("VA8: "); Serial.println(VA8);
|
|
// Serial.print("VA9: "); Serial.println(VA9);
|
|
// Serial.print("VA10: "); Serial.println(VA10);
|
|
// Serial.print("VA11: "); Serial.println(VA11);
|
|
// Serial.println(" ");
|
|
|
|
VA12 = adsd.readADC_SingleEnded(0);
|
|
VA13 = adsd.readADC_SingleEnded(1);
|
|
VA14 = adsd.readADC_SingleEnded(2);
|
|
VA15 = adsd.readADC_SingleEnded(3);
|
|
|
|
// Serial.print("VA12: "); Serial.println(VA12);
|
|
// Serial.print("VA13: "); Serial.println(VA13);
|
|
// Serial.print("VA14: "); Serial.println(VA14);
|
|
// Serial.print("VA15: "); Serial.println(VA15);
|
|
// Serial.println(" ");
|
|
|
|
|
|
audioHook();
|
|
}
|