reProgrammer – Creative Technical

The reProgrammer is an immersive jumpsuit combining sound, light and vibration. After putting on all the equipment – visor, headphones, and coveralls – one is led into another world…

The reProgrammer is an immersive jumpsuit.

See… the Lights:

A visor made out of acrylic has an LED mounted for each eye. These WS2801 RGB LEDs can produce pretty much any color imaginable.

Hear… the Sounds:

A standard pair of stereo headphones is connected to a non-standard MP3 player. The difference between this MP3 player and an iPod? This player is designed to interface with a microcontroller. The MP3 player contains prerecorded tracks which are designed to enhance the user’s experience.

Feel… the Love:

The jumpsuit itself has 10 tactile transducers attached to strategic locations: Feet, legs, torso, and arms are all outfitted with these vibrating “pucks” to make your journey… sensational. Velcro elastics hold the pucks snugly to the participant’s body.

Powering the transducers are a series of small Class D stereo amplifiers – 5 in total, which gives us ten (that’s right, 10!) discrete channels of spine-tingling fun.

Not one, but two Arduinos are at the centre of all of this fun – the first is responsible for the soundtrack, as well as delivering cues to the second Arduino. The second Arduino patiently waits for its next cue, and at the appropriate time, controls the eyeball LEDs and the good vibrations.

Here’s a clip of it in action at the local Maker Faire:

Arduino1 (mp3 player) CODE:

/*
 --reProgrammer--
 The reProgrammer is an immersive experience.
 http://creativetechnical.ca/reprogrammer/
 Essentially used to play a couple MP3s and trigger the reProgrammer (slave) Arduino.
 This code has been modified from MP3Shield_Library_Demo.ino.


 * \file MP3Shield_Library_Demo.ino
 *
 * \brief Example sketch of using the MP3Shield Arduino driver, demonstrating all methods and functions.
 * \remarks comments are implemented with Doxygen Markdown format
 *
 * \author Bill Porter
 * \author Michael P. Flaga
 *
 * This sketch listens for commands from a serial terminal (like the Serial
 * Monitor in the Arduino IDE). If it sees 1-9 it will try to play an MP3 file
 * named track00x.mp3 where x is a number from 1 to 9. For eaxmple, pressing
 * 2 will play 'track002.mp3'. A lowe case 's' will stop playing the mp3.
 * 'f' will play an MP3 by calling it by it's filename as opposed to a track
 * number.
 *
 * Sketch assumes you have MP3 files with filenames like "track001.mp3",
 * "track002.mp3", etc on an SD card loaded into the shield.
 */
//abort - low pulse resets arduino "reset" pin (red arcade button)

#include <SPI.h>

//Add the SdFat Libraries
#include <SdFat.h>
#include <SdFatUtil.h>

//and the MP3 Shield Library
#include <SFEMP3Shield.h>

union twobyte mp3_vol; // create key_command existing variable that can be both word and double byte of left and right.

// Below is not needed if interrupt driven. Safe to remove if not using.
#if defined(USE_MP3_REFILL_MEANS) && USE_MP3_REFILL_MEANS == USE_MP3_Timer1
  #include <TimerOne.h>
#elif defined(USE_MP3_REFILL_MEANS) && USE_MP3_REFILL_MEANS == USE_MP3_SimpleTimer
  #include <SimpleTimer.h>
#endif

/**
 * \brief Object instancing the SdFat library.
 *
 * principal object for handling all SdCard functions.
 */
SdFat sd;

/**
 * \brief Object instancing the SFEMP3Shield library.
 *
 * principal object for handling all the attributes, members and functions for the library.
 */
SFEMP3Shield MP3player;

//------------------------------------------------------------------------------
/**
 * \brief Setup the Arduino Chip's feature for our use.
 *
 * After Arduino's kernel has booted initialize basic features for this
 * application, such as Serial port and MP3player objects with .begin.
 * Along with displaying the Help Menu.
 *
 * \note returned Error codes are typically passed up from MP3player.
 * Whicn in turns creates and initializes the SdCard objects.
 *
 * \see
 * \ref Error_Codes
 */
void setup() {

  uint8_t result; //result code from some function as to be tested at later time.

  Serial.begin(115200);

  Serial.print(F("F_CPU = "));
  Serial.println(F_CPU);
  Serial.print(F("Free RAM = ")); // available in Version 1.0 F() bases the string to into Flash, to use less SRAM.
  Serial.print(FreeRam(), DEC);  // FreeRam() is provided by SdFatUtil.h
  Serial.println(F(" Should be a base line of 1028, on ATmega328 when using INTx"));


  //Initialize the SdCard.
  if(!sd.begin(SD_SEL, SPI_FULL_SPEED)) sd.initErrorHalt();
  // depending upon your SdCard environment, SPI_HAVE_SPEED may work better.
  if(!sd.chdir("/")) sd.errorHalt("sd.chdir");

  //Initialize the MP3 Player Shield
  result = MP3player.begin();
  //check result, see readme for error codes.
  if(result != 0) {
    Serial.print(F("Error code: "));
    Serial.print(result);
    Serial.println(F(" when trying to start MP3 player"));
    if( result == 6 ) {
      Serial.println(F("Warning: patch file not found, skipping.")); // can be removed for space, if needed.
      Serial.println(F("Use the \"d\" command to verify SdCard can be read")); // can be removed for space, if needed.
    }
  }

#if defined(__BIOFEEDBACK_MEGA__) // or other reasons, of your choosing.
  // Typically not used by most shields, hence commented out.
  Serial.println(F("Applying ADMixer patch."));
  if(MP3player.ADMixerLoad("admxster.053") == 0) {
    Serial.println(F("Setting ADMixer Volume."));
    MP3player.ADMixerVol(-3);
  }
#endif

  help();
  pinMode(A4, OUTPUT);
  pinMode(A5, OUTPUT);
  digitalWrite(A4, LOW);
  digitalWrite(A5, LOW);
//////////////////////////////////////////////////////////////////////////////
  mp3_vol.byte[1] = 15;      //lower is louder
  MP3player.setVolume(mp3_vol.byte[1], mp3_vol.byte[1]); // commit new volume
}

//------------------------------------------------------------------------------
/**
 * \brief Main Loop the Arduino Chip
 *
 * This is called at the end of Arduino kernel's main loop before recycling.
 * And is where the user's serial input of bytes are read and analyzed by
 * parsed_menu.
 *
 * Additionally, if the means of refilling is not interrupt based then the
 * MP3player object is serviced with the availaible function.
 *
 * \note Actual examples of the libraries public functions are implemented in
 * the parse_menu() function.
 */
void loop() {

// Below is only needed if not interrupt driven. Safe to remove if not using.
#if defined(USE_MP3_REFILL_MEANS) \
    && ( (USE_MP3_REFILL_MEANS == USE_MP3_SimpleTimer) \
    ||   (USE_MP3_REFILL_MEANS == USE_MP3_Polled)      )

  MP3player.available();
#endif

  if(Serial.available()) {
    parse_menu(Serial.read()); // get command from serial input
  }
//////////////////////////////////////////////////////
  MP3player.playMP3("track001.mp3");
  
  MP3player.playMP3("track001.mp3");
  delay(56400);      //wait to trigger eyes    <57000  56500
  digitalWrite(A4, HIGH);      //trigger eyes
  delay(100); 
  digitalWrite(A4, LOW);
  
  delay(55000);      //wait til main routine 55700

  mp3_vol.byte[1] = 5;      //lower is louder
  MP3player.setVolume(mp3_vol.byte[1], mp3_vol.byte[1]); // commit new volume
  
  MP3player.playMP3("track002.mp3");
  delay(200);  
  digitalWrite(A5, HIGH);      //main routine
  delay(300); 
  digitalWrite(A5, LOW);

  delay(128000);      //wait 2:08 for main routine to finish

  mp3_vol.byte[1] = 10;      //lower is louder
  MP3player.setVolume(mp3_vol.byte[1], mp3_vol.byte[1]); // commit new volume

  MP3player.playMP3("track003.mp3");      //play outro
  
  delay(7200000); //end of the ride    //2 hours
}

uint32_t  millis_prv;

//------------------------------------------------------------------------------
/**
 * \brief Decode the Menu.
 *
 * Parses through the characters of the users input, executing corresponding
 * MP3player library functions and features then displaying a brief menu and
 * prompting for next input command.
 */
void parse_menu(byte key_command) {

  uint8_t result; // result code from some function as to be tested at later time.

  // Note these buffer may be desired to exist globably.
  // but do take much space if only needed temporarily, hence they are here.
  char title[30]; // buffer to contain the extract the Title from the current filehandles
  char artist[30]; // buffer to contain the extract the artist name from the current filehandles
  char album[30]; // buffer to contain the extract the album name from the current filehandles

  Serial.print(F("Received command: "));
  Serial.write(key_command);
  Serial.println(F(" "));

  //if s, stop the current track
  if(key_command == 's') {
    Serial.println(F("Stopping"));
    MP3player.stopTrack();

  //if 1-9, play corresponding track
  } else if(key_command >= '1' && key_command <= '9') {
    //convert ascii numbers to real numbers
    key_command = key_command - 48;

#if USE_MULTIPLE_CARDS
    sd.chvol(); // assign desired sdcard's volume.
#endif
    //tell the MP3 Shield to play a track
    result = MP3player.playTrack(key_command);

    //check result, see readme for error codes.
    if(result != 0) {
      Serial.print(F("Error code: "));
      Serial.print(result);
      Serial.println(F(" when trying to play track"));
    } else {

      Serial.println(F("Playing:"));

      //we can get track info by using the following functions and arguments
      //the functions will extract the requested information, and put it in the array we pass in
      MP3player.trackTitle((char*)&title);
      MP3player.trackArtist((char*)&artist);
      MP3player.trackAlbum((char*)&album);

      //print out the arrays of track information
      Serial.write((byte*)&title, 30);
      Serial.println();
      Serial.print(F("by:  "));
      Serial.write((byte*)&artist, 30);
      Serial.println();
      Serial.print(F("Album:  "));
      Serial.write((byte*)&album, 30);
      Serial.println();
    }

  //if +/- to change volume
  } else if((key_command == '-') || (key_command == '+')) {
    union twobyte mp3_vol; // create key_command existing variable that can be both word and double byte of left and right.
    mp3_vol.word = MP3player.getVolume(); // returns a double uint8_t of Left and Right packed into int16_t

    if(key_command == '-') { // note dB is negative
      // assume equal balance and use byte[1] for math
      if(mp3_vol.byte[1] >= 254) { // range check
        mp3_vol.byte[1] = 254;
      } else {
        mp3_vol.byte[1] += 2; // keep it simpler with whole dB's
      }
    } else {
      if(mp3_vol.byte[1] <= 2) { // range check
        mp3_vol.byte[1] = 2;
      } else {
        mp3_vol.byte[1] -= 2;
      }
    }
    // push byte[1] into both left and right assuming equal balance.
    MP3player.setVolume(mp3_vol.byte[1], mp3_vol.byte[1]); // commit new volume
    Serial.print(F("Volume changed to -"));
    Serial.print(mp3_vol.byte[1]>>1, 1);
    Serial.println(F("[dB]"));

  //if < or > to change Play Speed
  } else if((key_command == '>') || (key_command == '<')) {
    uint16_t playspeed = MP3player.getPlaySpeed(); // create key_command existing variable
    // note playspeed of Zero is equal to ONE, normal speed.
    if(key_command == '>') { // note dB is negative
      // assume equal balance and use byte[1] for math
      if(playspeed >= 254) { // range check
        playspeed = 5;
      } else {
        playspeed += 1; // keep it simpler with whole dB's
      }
    } else {
      if(playspeed == 0) { // range check
        playspeed = 0;
      } else {
        playspeed -= 1;
      }
    }
    MP3player.setPlaySpeed(playspeed); // commit new playspeed
    Serial.print(F("playspeed to "));
    Serial.println(playspeed, DEC);

  /* Alterativly, you could call a track by it's file name by using playMP3(filename);
  But you must stick to 8.1 filenames, only 8 characters long, and 3 for the extension */
  } else if(key_command == 'f' || key_command == 'F') {
    uint32_t offset = 0;
    if (key_command == 'F') {
      offset = 2000;
    }

    //create a string with the filename
    char trackName[] = "track001.mp3";

#if USE_MULTIPLE_CARDS
    sd.chvol(); // assign desired sdcard's volume.
#endif
    //tell the MP3 Shield to play that file
    result = MP3player.playMP3(trackName, offset);
    //check result, see readme for error codes.
    if(result != 0) {
      Serial.print(F("Error code: "));
      Serial.print(result);
      Serial.println(F(" when trying to play track"));
    }

  /* Display the file on the SdCard */
  } else if(key_command == 'd') {
    if(!MP3player.isPlaying()) {
      // prevent root.ls when playing, something locks the dump. but keeps playing.
      // yes, I have tried another unique instance with same results.
      // something about SdFat and its 500byte cache.
      Serial.println(F("Files found (name date time size):"));
      sd.ls(LS_R | LS_DATE | LS_SIZE);
    } else {
      Serial.println(F("Busy Playing Files, try again later."));
    }

  /* Get and Display the Audio Information */
  } else if(key_command == 'i') {
    MP3player.getAudioInfo();

  } else if(key_command == 'p') {
    if( MP3player.getState() == playback) {
      MP3player.pauseMusic();
      Serial.println(F("Pausing"));
    } else if( MP3player.getState() == paused_playback) {
      MP3player.resumeMusic();
      Serial.println(F("Resuming"));
    } else {
      Serial.println(F("Not Playing!"));
    }

  } else if(key_command == 't') {
    int8_t teststate = MP3player.enableTestSineWave(126);
    if(teststate == -1) {
      Serial.println(F("Un-Available while playing music or chip in reset."));
    } else if(teststate == 1) {
      Serial.println(F("Enabling Test Sine Wave"));
    } else if(teststate == 2) {
      MP3player.disableTestSineWave();
      Serial.println(F("Disabling Test Sine Wave"));
    }

  } else if(key_command == 'S') {
    Serial.println(F("Current State of VS10xx is."));
    Serial.print(F("isPlaying() = "));
    Serial.println(MP3player.isPlaying());

    Serial.print(F("getState() = "));
    switch (MP3player.getState()) {
    case uninitialized:
      Serial.print(F("uninitialized"));
      break;
    case initialized:
      Serial.print(F("initialized"));
      break;
    case deactivated:
      Serial.print(F("deactivated"));
      break;
    case loading:
      Serial.print(F("loading"));
      break;
    case ready:
      Serial.print(F("ready"));
      break;
    case playback:
      Serial.print(F("playback"));
      break;
    case paused_playback:
      Serial.print(F("paused_playback"));
      break;
    case testing_memory:
      Serial.print(F("testing_memory"));
      break;
    case testing_sinewave:
      Serial.print(F("testing_sinewave"));
      break;
    }
    Serial.println();

   } else if(key_command == 'b') {
    Serial.println(F("Playing Static MIDI file."));
    MP3player.SendSingleMIDInote();
    Serial.println(F("Ended Static MIDI file."));

#if !defined(__AVR_ATmega32U4__)
  } else if(key_command == 'm') {
      uint16_t teststate = MP3player.memoryTest();
    if(teststate == -1) {
      Serial.println(F("Un-Available while playing music or chip in reset."));
    } else if(teststate == 2) {
      teststate = MP3player.disableTestSineWave();
      Serial.println(F("Un-Available while Sine Wave Test"));
    } else {
      Serial.print(F("Memory Test Results = "));
      Serial.println(teststate, HEX);
      Serial.println(F("Result should be 0x83FF."));
      Serial.println(F("Reset is needed to recover to normal operation"));
    }

  } else if(key_command == 'e') {
    uint8_t earspeaker = MP3player.getEarSpeaker();
    if(earspeaker >= 3){
      earspeaker = 0;
    } else {
      earspeaker++;
    }
    MP3player.setEarSpeaker(earspeaker); // commit new earspeaker
    Serial.print(F("earspeaker to "));
    Serial.println(earspeaker, DEC);

  } else if(key_command == 'r') {
    MP3player.resumeMusic(2000);

  } else if(key_command == 'R') {
    MP3player.stopTrack();
    MP3player.vs_init();
    Serial.println(F("Reseting VS10xx chip"));

  } else if(key_command == 'g') {
    int32_t offset_ms = 20000; // Note this is just an example, try your own number.
    Serial.print(F("jumping to "));
    Serial.print(offset_ms, DEC);
    Serial.println(F("[milliseconds]"));
    result = MP3player.skipTo(offset_ms);
    if(result != 0) {
      Serial.print(F("Error code: "));
      Serial.print(result);
      Serial.println(F(" when trying to skip track"));
    }

  } else if(key_command == 'k') {
    int32_t offset_ms = -1000; // Note this is just an example, try your own number.
    Serial.print(F("moving = "));
    Serial.print(offset_ms, DEC);
    Serial.println(F("[milliseconds]"));
    result = MP3player.skip(offset_ms);
    if(result != 0) {
      Serial.print(F("Error code: "));
      Serial.print(result);
      Serial.println(F(" when trying to skip track"));
    }

  } else if(key_command == 'O') {
    MP3player.end();
    Serial.println(F("VS10xx placed into low power reset mode."));

  } else if(key_command == 'o') {
    MP3player.begin();
    Serial.println(F("VS10xx restored from low power reset mode."));

  } else if(key_command == 'D') {
    uint16_t diff_state = MP3player.getDifferentialOutput();
    Serial.print(F("Differential Mode "));
    if(diff_state == 0) {
      MP3player.setDifferentialOutput(1);
      Serial.println(F("Enabled."));
    } else {
      MP3player.setDifferentialOutput(0);
      Serial.println(F("Disabled."));
    }

  } else if(key_command == 'V') {
    MP3player.setVUmeter(1);
    Serial.println(F("Use \"No line ending\""));
    Serial.print(F("VU meter = "));
    Serial.println(MP3player.getVUmeter());
    Serial.println(F("Hit Any key to stop."));

    while(!Serial.available()) {
      union twobyte vu;
      vu.word = MP3player.getVUlevel();
      Serial.print(F("VU: L = "));
      Serial.print(vu.byte[1]);
      Serial.print(F(" / R = "));
      Serial.print(vu.byte[0]);
      Serial.println(" dB");
      delay(1000);
    }
    Serial.read();

    MP3player.setVUmeter(0);
    Serial.print(F("VU meter = "));
    Serial.println(MP3player.getVUmeter());

  } else if(key_command == 'T') {
    uint16_t TrebleFrequency = MP3player.getTrebleFrequency();
    Serial.print(F("Former TrebleFrequency = "));
    Serial.println(TrebleFrequency, DEC);
    if (TrebleFrequency >= 15000) { // Range is from 0 - 1500Hz
      TrebleFrequency = 0;
    } else {
      TrebleFrequency += 1000;
    }
    MP3player.setTrebleFrequency(TrebleFrequency);
    Serial.print(F("New TrebleFrequency = "));
    Serial.println(MP3player.getTrebleFrequency(), DEC);

  } else if(key_command == 'E') {
    int8_t TrebleAmplitude = MP3player.getTrebleAmplitude();
    Serial.print(F("Former TrebleAmplitude = "));
    Serial.println(TrebleAmplitude, DEC);
    if (TrebleAmplitude >= 7) { // Range is from -8 - 7dB
      TrebleAmplitude = -8;
    } else {
      TrebleAmplitude++;
    }
    MP3player.setTrebleAmplitude(TrebleAmplitude);
    Serial.print(F("New TrebleAmplitude = "));
    Serial.println(MP3player.getTrebleAmplitude(), DEC);

  } else if(key_command == 'B') {
    uint16_t BassFrequency = MP3player.getBassFrequency();
    Serial.print(F("Former BassFrequency = "));
    Serial.println(BassFrequency, DEC);
    if (BassFrequency >= 150) { // Range is from 20hz - 150hz
      BassFrequency = 0;
    } else {
      BassFrequency += 10;
    }
    MP3player.setBassFrequency(BassFrequency);
    Serial.print(F("New BassFrequency = "));
    Serial.println(MP3player.getBassFrequency(), DEC);

  } else if(key_command == 'C') {
    uint16_t BassAmplitude = MP3player.getBassAmplitude();
    Serial.print(F("Former BassAmplitude = "));
    Serial.println(BassAmplitude, DEC);
    if (BassAmplitude >= 15) { // Range is from 0 - 15dB
      BassAmplitude = 0;
    } else {
      BassAmplitude++;
    }
    MP3player.setBassAmplitude(BassAmplitude);
    Serial.print(F("New BassAmplitude = "));
    Serial.println(MP3player.getBassAmplitude(), DEC);

  } else if(key_command == 'M') {
    uint16_t monostate = MP3player.getMonoMode();
    Serial.print(F("Mono Mode "));
    if(monostate == 0) {
      MP3player.setMonoMode(1);
      Serial.println(F("Enabled."));
    } else {
      MP3player.setMonoMode(0);
      Serial.println(F("Disabled."));
    }
#endif

  } else if(key_command == 'h') {
    help();
  }

  // print prompt after key stroke has been processed.
  Serial.print(F("Time since last command: "));  
  Serial.println((float) (millis() -  millis_prv)/1000, 2);  
  millis_prv = millis();
  Serial.print(F("Enter s,1-9,+,-,>,<,f,F,d,i,p,t,S,b"));
#if !defined(__AVR_ATmega32U4__)
  Serial.print(F(",m,e,r,R,g,k,O,o,D,V,B,C,T,E,M:"));
#endif
  Serial.println(F(",h :"));
}

//------------------------------------------------------------------------------
/**
 * \brief Print Help Menu.
 *
 * Prints a full menu of the commands available along with descriptions.
 */
void help() {
  Serial.println(F("Arduino SFEMP3Shield Library Example:"));
  Serial.println(F(" courtesy of Bill Porter & Michael P. Flaga"));
  Serial.println(F("COMMANDS:"));
  Serial.println(F(" [1-9] to play a track"));
  Serial.println(F(" [f] play track001.mp3 by filename example"));
  Serial.println(F(" [F] same as [f] but with initial skip of 2 second"));
  Serial.println(F(" [s] to stop playing"));
  Serial.println(F(" [d] display directory of SdCard"));
  Serial.println(F(" [+ or -] to change volume"));
  Serial.println(F(" [> or <] to increment or decrement play speed by 1 factor"));
  Serial.println(F(" [i] retrieve current audio information (partial list)"));
  Serial.println(F(" [p] to pause."));
  Serial.println(F(" [t] to toggle sine wave test"));
  Serial.println(F(" [S] Show State of Device."));
  Serial.println(F(" [b] Play a MIDI File Beep"));
#if !defined(__AVR_ATmega32U4__)
  Serial.println(F(" [e] increment Spatial EarSpeaker, default is 0, wraps after 4"));
  Serial.println(F(" [m] perform memory test. reset is needed after to recover."));
  Serial.println(F(" [M] Toggle between Mono and Stereo Output."));
  Serial.println(F(" [g] Skip to a predetermined offset of ms in current track."));
  Serial.println(F(" [k] Skip a predetermined number of ms in current track."));
  Serial.println(F(" [r] resumes play from 2s from begin of file"));
  Serial.println(F(" [R] Resets and initializes VS10xx chip."));
  Serial.println(F(" [O] turns OFF the VS10xx into low power reset."));
  Serial.println(F(" [o] turns ON the VS10xx out of low power reset."));
  Serial.println(F(" [D] to toggle SM_DIFF between inphase and differential output"));
  Serial.println(F(" [V] Enable VU meter Test."));
  Serial.println(F(" [B] Increament bass frequency by 10Hz"));
  Serial.println(F(" [C] Increament bass amplitude by 1dB"));
  Serial.println(F(" [T] Increament treble frequency by 1000Hz"));
  Serial.println(F(" [E] Increament treble amplitude by 1dB"));
#endif
  Serial.println(F(" [h] this help"));
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

381

382

383

384

385

386

387

388

389

390

391

392

393

394

395

396

397

398

399

400

401

402

403

404

405

406

407

408

409

410

411

412

413

414

415

416

417

418

419

420

421

422

423

424

425

426

427

428

429

430

431

432

433

434

435

436

437

438

439

440

441

442

443

444

445

446

447

448

449

450

451

452

453

454

455

456

457

458

459

460

461

462

463

464

465

466

467

468

469

470

471

472

473

474

475

476

477

478

479

480

481

482

483

484

485

486

487

488

489

490

491

492

493

494

495

496

497

498

499

500

501

502

503

504

505

506

507

508

509

510

511

512

513

514

515

516

517

518

519

520

521

522

523

524

525

526

527

528

529

530

531

532

533

534

535

536

537

538

539

540

541

542

543

544

545

546

547

548

549

550

551

552

553

554

555

556

557

558

559

560

561

562

563

564

565

566

567

568

569

570

571

572

573

574

575

576

577

578

579

580

581

582

583

584

585

586

587

588

589

590

591

592

593

594

595

596

597

598

599

600

601

602

603

604

605

606

607

608

609

610

611

612

613

614

615

616

617

--reProgrammer--

The reProgrammer is an immersive experience.

http://creativetechnical.ca/reprogrammer/

Essentially used to play a couple MP3s and trigger the reProgrammer (slave) Arduino.

This code has been modified from MP3Shield_Library_Demo.ino.

* \file MP3Shield_Library_Demo.ino

* \brief Example sketch of using the MP3Shield Arduino driver, demonstrating all methods and functions.

* \remarks comments are implemented with Doxygen Markdown format

* \author Bill Porter

* \author Michael P. Flaga

* This sketch listens for commands from a serial terminal (like the Serial

* Monitor in the Arduino IDE). If it sees 1-9 it will try to play an MP3 file

* named track00x.mp3 where x is a number from 1 to 9. For eaxmple, pressing

* 2 will play 'track002.mp3'. A lowe case 's' will stop playing the mp3.

* 'f' will play an MP3 by calling it by it's filename as opposed to a track

* number.

* Sketch assumes you have MP3 files with filenames like "track001.mp3",

* "track002.mp3", etc on an SD card loaded into the shield.

//abort - low pulse resets arduino "reset" pin (red arcade button)

#include <SPI.h>

//Add the SdFat Libraries

#include <SdFat.h>

#include <SdFatUtil.h>

//and the MP3 Shield Library

#include <SFEMP3Shield.h>

union twobyte mp3_vol; // create key_command existing variable that can be both word and double byte of left and right.

// Below is not needed if interrupt driven. Safe to remove if not using.

#if defined(USE_MP3_REFILL_MEANS) && USE_MP3_REFILL_MEANS == USE_MP3_Timer1

#include <TimerOne.h>

#elif defined(USE_MP3_REFILL_MEANS) && USE_MP3_REFILL_MEANS == USE_MP3_SimpleTimer

#include <SimpleTimer.h>

#endif

/**

* \brief Object instancing the SdFat library.

* principal object for handling all SdCard functions.

SdFat sd;

/**

* \brief Object instancing the SFEMP3Shield library.

* principal object for handling all the attributes, members and functions for the library.

SFEMP3Shield MP3player;

//------------------------------------------------------------------------------

/**

* \brief Setup the Arduino Chip's feature for our use.

* After Arduino's kernel has booted initialize basic features for this

* application, such as Serial port and MP3player objects with .begin.

* Along with displaying the Help Menu.

* \note returned Error codes are typically passed up from MP3player.

* Whicn in turns creates and initializes the SdCard objects.

* \see

* \ref Error_Codes

void setup() {

uint8_t result; //result code from some function as to be tested at later time.

Serial.begin(115200);

Serial.print(F("F_CPU = "));

Serial.println(F_CPU);

Serial.print(F("Free RAM = ")); // available in Version 1.0 F() bases the string to into Flash, to use less SRAM.

Serial.print(FreeRam(), DEC); // FreeRam() is provided by SdFatUtil.h

Serial.println(F(" Should be a base line of 1028, on ATmega328 when using INTx"));

//Initialize the SdCard.

if(!sd.begin(SD_SEL, SPI_FULL_SPEED)) sd.initErrorHalt();

// depending upon your SdCard environment, SPI_HAVE_SPEED may work better.

if(!sd.chdir("/")) sd.errorHalt("sd.chdir");

//Initialize the MP3 Player Shield

result = MP3player.begin();

//check result, see readme for error codes.

if(result != 0) {

Serial.print(F("Error code: "));

Serial.print(result);

Serial.println(F(" when trying to start MP3 player"));

if( result == 6 ) {

Serial.println(F("Warning: patch file not found, skipping.")); // can be removed for space, if needed.

Serial.println(F("Use the \"d\" command to verify SdCard can be read")); // can be removed for space, if needed.

}

#if defined(__BIOFEEDBACK_MEGA__) // or other reasons, of your choosing.

// Typically not used by most shields, hence commented out.

Serial.println(F("Applying ADMixer patch."));

if(MP3player.ADMixerLoad("admxster.053") == 0) {

Serial.println(F("Setting ADMixer Volume."));

MP3player.ADMixerVol(-3);

}

#endif

help();

pinMode(A4, OUTPUT);

pinMode(A5, OUTPUT);

digitalWrite(A4, LOW);

digitalWrite(A5, LOW);

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

mp3_vol.byte[1] = 15; //lower is louder

MP3player.setVolume(mp3_vol.byte[1], mp3_vol.byte[1]); // commit new volume

}

//------------------------------------------------------------------------------

/**

* \brief Main Loop the Arduino Chip

* This is called at the end of Arduino kernel's main loop before recycling.

* And is where the user's serial input of bytes are read and analyzed by

* parsed_menu.

* Additionally, if the means of refilling is not interrupt based then the

* MP3player object is serviced with the availaible function.

* \note Actual examples of the libraries public functions are implemented in

* the parse_menu() function.

void loop() {

// Below is only needed if not interrupt driven. Safe to remove if not using.

#if defined(USE_MP3_REFILL_MEANS) \

&& ( (USE_MP3_REFILL_MEANS == USE_MP3_SimpleTimer) \

|| (USE_MP3_REFILL_MEANS == USE_MP3_Polled) )

MP3player.available();

#endif

if(Serial.available()) {

parse_menu(Serial.read()); // get command from serial input

}

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

MP3player.playMP3("track001.mp3");

delay(56400); //wait to trigger eyes <57000 56500

digitalWrite(A4, HIGH); //trigger eyes

delay(100);

digitalWrite(A4, LOW);

delay(55000); //wait til main routine 55700

mp3_vol.byte[1] = 5; //lower is louder

MP3player.setVolume(mp3_vol.byte[1], mp3_vol.byte[1]); // commit new volume

MP3player.playMP3("track002.mp3");

delay(200);

digitalWrite(A5, HIGH); //main routine

delay(300);

digitalWrite(A5, LOW);

delay(128000); //wait 2:08 for main routine to finish

mp3_vol.byte[1] = 10; //lower is louder

MP3player.setVolume(mp3_vol.byte[1], mp3_vol.byte[1]); // commit new volume

MP3player.playMP3("track003.mp3"); //play outro

delay(7200000); //end of the ride //2 hours

}

uint32_t millis_prv;

//------------------------------------------------------------------------------

/**

* \brief Decode the Menu.

* Parses through the characters of the users input, executing corresponding

* MP3player library functions and features then displaying a brief menu and

* prompting for next input command.

void parse_menu(byte key_command) {

uint8_t result; // result code from some function as to be tested at later time.

// Note these buffer may be desired to exist globably.

// but do take much space if only needed temporarily, hence they are here.

char title[30]; // buffer to contain the extract the Title from the current filehandles

char artist[30]; // buffer to contain the extract the artist name from the current filehandles

char album[30]; // buffer to contain the extract the album name from the current filehandles

Serial.print(F("Received command: "));

Serial.write(key_command);

Serial.println(F(" "));

//if s, stop the current track

if(key_command == 's') {

Serial.println(F("Stopping"));

MP3player.stopTrack();

//if 1-9, play corresponding track

} else if(key_command >= '1' && key_command <= '9') {

//convert ascii numbers to real numbers

key_command = key_command - 48;

#if USE_MULTIPLE_CARDS

sd.chvol(); // assign desired sdcard's volume.

#endif

//tell the MP3 Shield to play a track

result = MP3player.playTrack(key_command);

//check result, see readme for error codes.

if(result != 0) {

Serial.print(F("Error code: "));

Serial.print(result);

Serial.println(F(" when trying to play track"));

} else {

Serial.println(F("Playing:"));

//we can get track info by using the following functions and arguments

//the functions will extract the requested information, and put it in the array we pass in

MP3player.trackTitle((char*)&title);

MP3player.trackArtist((char*)&artist);

MP3player.trackAlbum((char*)&album);

//print out the arrays of track information

Serial.write((byte*)&title, 30);

Serial.println();

Serial.print(F("by: "));

Serial.write((byte*)&artist, 30);

Serial.println();

Serial.print(F("Album: "));

Serial.write((byte*)&album, 30);

Serial.println();

}

//if +/- to change volume

} else if((key_command == '-') || (key_command == '+')) {

union twobyte mp3_vol; // create key_command existing variable that can be both word and double byte of left and right.

mp3_vol.word = MP3player.getVolume(); // returns a double uint8_t of Left and Right packed into int16_t

if(key_command == '-') { // note dB is negative

// assume equal balance and use byte[1] for math

if(mp3_vol.byte[1] >= 254) { // range check

mp3_vol.byte[1] = 254;

} else {

mp3_vol.byte[1] += 2; // keep it simpler with whole dB's

}

} else {

if(mp3_vol.byte[1] <= 2) { // range check

mp3_vol.byte[1] = 2;

} else {

mp3_vol.byte[1] -= 2;

}

// push byte[1] into both left and right assuming equal balance.

MP3player.setVolume(mp3_vol.byte[1], mp3_vol.byte[1]); // commit new volume

Serial.print(F("Volume changed to -"));

Serial.print(mp3_vol.byte[1]>>1, 1);

Serial.println(F("[dB]"));

//if < or > to change Play Speed

} else if((key_command == '>') || (key_command == '<')) {

uint16_t playspeed = MP3player.getPlaySpeed(); // create key_command existing variable

// note playspeed of Zero is equal to ONE, normal speed.

if(key_command == '>') { // note dB is negative

// assume equal balance and use byte[1] for math

if(playspeed >= 254) { // range check

playspeed = 5;

} else {

playspeed += 1; // keep it simpler with whole dB's

}

} else {

if(playspeed == 0) { // range check

playspeed = 0;

} else {

playspeed -= 1;

}

MP3player.setPlaySpeed(playspeed); // commit new playspeed

Serial.print(F("playspeed to "));

Serial.println(playspeed, DEC);

/* Alterativly, you could call a track by it's file name by using playMP3(filename);

But you must stick to 8.1 filenames, only 8 characters long, and 3 for the extension */

} else if(key_command == 'f' || key_command == 'F') {

uint32_t offset = 0;

if (key_command == 'F') {

offset = 2000;

}

//create a string with the filename

char trackName[] = "track001.mp3";

#if USE_MULTIPLE_CARDS

sd.chvol(); // assign desired sdcard's volume.

#endif

//tell the MP3 Shield to play that file

result = MP3player.playMP3(trackName, offset);

//check result, see readme for error codes.

if(result != 0) {

Serial.print(F("Error code: "));

Serial.print(result);

Serial.println(F(" when trying to play track"));

}

/* Display the file on the SdCard */

} else if(key_command == 'd') {

if(!MP3player.isPlaying()) {

// prevent root.ls when playing, something locks the dump. but keeps playing.

// yes, I have tried another unique instance with same results.

// something about SdFat and its 500byte cache.

Serial.println(F("Files found (name date time size):"));

sd.ls(LS_R | LS_DATE | LS_SIZE);

} else {

Serial.println(F("Busy Playing Files, try again later."));

}

/* Get and Display the Audio Information */

} else if(key_command == 'i') {

MP3player.getAudioInfo();

} else if(key_command == 'p') {

if( MP3player.getState() == playback) {

MP3player.pauseMusic();

Serial.println(F("Pausing"));

} else if( MP3player.getState() == paused_playback) {

MP3player.resumeMusic();

Serial.println(F("Resuming"));

} else {

Serial.println(F("Not Playing!"));

}

} else if(key_command == 't') {

int8_t teststate = MP3player.enableTestSineWave(126);

if(teststate == -1) {

Serial.println(F("Un-Available while playing music or chip in reset."));

} else if(teststate == 1) {

Serial.println(F("Enabling Test Sine Wave"));

} else if(teststate == 2) {

MP3player.disableTestSineWave();

Serial.println(F("Disabling Test Sine Wave"));

}

} else if(key_command == 'S') {

Serial.println(F("Current State of VS10xx is."));

Serial.print(F("isPlaying() = "));

Serial.println(MP3player.isPlaying());

Serial.print(F("getState() = "));

switch (MP3player.getState()) {

case uninitialized:

Serial.print(F("uninitialized"));

break;

case initialized:

Serial.print(F("initialized"));

break;

case deactivated:

Serial.print(F("deactivated"));

break;

case loading:

Serial.print(F("loading"));

break;

case ready:

Serial.print(F("ready"));

break;

case playback:

Serial.print(F("playback"));

break;

case paused_playback:

Serial.print(F("paused_playback"));

break;

case testing_memory:

Serial.print(F("testing_memory"));

break;

case testing_sinewave:

Serial.print(F("testing_sinewave"));

break;

}

Serial.println();

} else if(key_command == 'b') {

Serial.println(F("Playing Static MIDI file."));

MP3player.SendSingleMIDInote();

Serial.println(F("Ended Static MIDI file."));

#if !defined(__AVR_ATmega32U4__)

} else if(key_command == 'm') {

uint16_t teststate = MP3player.memoryTest();

if(teststate == -1) {

Serial.println(F("Un-Available while playing music or chip in reset."));

} else if(teststate == 2) {

teststate = MP3player.disableTestSineWave();

Serial.println(F("Un-Available while Sine Wave Test"));

} else {

Serial.print(F("Memory Test Results = "));

Serial.println(teststate, HEX);

Serial.println(F("Result should be 0x83FF."));

Serial.println(F("Reset is needed to recover to normal operation"));

}

} else if(key_command == 'e') {

uint8_t earspeaker = MP3player.getEarSpeaker();

if(earspeaker >= 3){

earspeaker = 0;

} else {

earspeaker++;

}

MP3player.setEarSpeaker(earspeaker); // commit new earspeaker

Serial.print(F("earspeaker to "));

Serial.println(earspeaker, DEC);

} else if(key_command == 'r') {

MP3player.resumeMusic(2000);

} else if(key_command == 'R') {

MP3player.stopTrack();

MP3player.vs_init();

Serial.println(F("Reseting VS10xx chip"));

} else if(key_command == 'g') {

int32_t offset_ms = 20000; // Note this is just an example, try your own number.

Serial.print(F("jumping to "));

Serial.print(offset_ms, DEC);

Serial.println(F("[milliseconds]"));

result = MP3player.skipTo(offset_ms);

if(result != 0) {

Serial.print(F("Error code: "));

Serial.print(result);

Serial.println(F(" when trying to skip track"));

}

} else if(key_command == 'k') {

int32_t offset_ms = -1000; // Note this is just an example, try your own number.

Serial.print(F("moving = "));

Serial.print(offset_ms, DEC);

Serial.println(F("[milliseconds]"));

result = MP3player.skip(offset_ms);

if(result != 0) {

Serial.print(F("Error code: "));

Serial.print(result);

Serial.println(F(" when trying to skip track"));

}

} else if(key_command == 'O') {

MP3player.end();

Serial.println(F("VS10xx placed into low power reset mode."));

} else if(key_command == 'o') {

MP3player.begin();

Serial.println(F("VS10xx restored from low power reset mode."));

} else if(key_command == 'D') {

uint16_t diff_state = MP3player.getDifferentialOutput();

Serial.print(F("Differential Mode "));

if(diff_state == 0) {

MP3player.setDifferentialOutput(1);

Serial.println(F("Enabled."));

} else {

MP3player.setDifferentialOutput(0);

Serial.println(F("Disabled."));

}

} else if(key_command == 'V') {

MP3player.setVUmeter(1);

Serial.println(F("Use \"No line ending\""));

Serial.print(F("VU meter = "));

Serial.println(MP3player.getVUmeter());

Serial.println(F("Hit Any key to stop."));

while(!Serial.available()) {

union twobyte vu;

vu.word = MP3player.getVUlevel();

Serial.print(F("VU: L = "));

Serial.print(vu.byte[1]);

Serial.print(F(" / R = "));

Serial.print(vu.byte[0]);

Serial.println(" dB");

delay(1000);

}

Serial.read();

MP3player.setVUmeter(0);

Serial.print(F("VU meter = "));

Serial.println(MP3player.getVUmeter());

} else if(key_command == 'T') {

uint16_t TrebleFrequency = MP3player.getTrebleFrequency();

Serial.print(F("Former TrebleFrequency = "));

Serial.println(TrebleFrequency, DEC);

if (TrebleFrequency >= 15000) { // Range is from 0 - 1500Hz

TrebleFrequency = 0;

} else {

TrebleFrequency += 1000;

}

MP3player.setTrebleFrequency(TrebleFrequency);

Serial.print(F("New TrebleFrequency = "));

Serial.println(MP3player.getTrebleFrequency(), DEC);

} else if(key_command == 'E') {

int8_t TrebleAmplitude = MP3player.getTrebleAmplitude();

Serial.print(F("Former TrebleAmplitude = "));

Serial.println(TrebleAmplitude, DEC);

if (TrebleAmplitude >= 7) { // Range is from -8 - 7dB

TrebleAmplitude = -8;

} else {

TrebleAmplitude++;

}

MP3player.setTrebleAmplitude(TrebleAmplitude);

Serial.print(F("New TrebleAmplitude = "));

Serial.println(MP3player.getTrebleAmplitude(), DEC);

} else if(key_command == 'B') {

uint16_t BassFrequency = MP3player.getBassFrequency();

Serial.print(F("Former BassFrequency = "));

Serial.println(BassFrequency, DEC);

if (BassFrequency >= 150) { // Range is from 20hz - 150hz

BassFrequency = 0;

} else {

BassFrequency += 10;

}

MP3player.setBassFrequency(BassFrequency);

Serial.print(F("New BassFrequency = "));

Serial.println(MP3player.getBassFrequency(), DEC);

} else if(key_command == 'C') {

uint16_t BassAmplitude = MP3player.getBassAmplitude();

Serial.print(F("Former BassAmplitude = "));

Serial.println(BassAmplitude, DEC);

if (BassAmplitude >= 15) { // Range is from 0 - 15dB

BassAmplitude = 0;

} else {

BassAmplitude++;

}

MP3player.setBassAmplitude(BassAmplitude);

Serial.print(F("New BassAmplitude = "));

Serial.println(MP3player.getBassAmplitude(), DEC);

} else if(key_command == 'M') {

uint16_t monostate = MP3player.getMonoMode();

Serial.print(F("Mono Mode "));

if(monostate == 0) {

MP3player.setMonoMode(1);

Serial.println(F("Enabled."));

} else {

MP3player.setMonoMode(0);

Serial.println(F("Disabled."));

}

#endif

} else if(key_command == 'h') {

help();

}

// print prompt after key stroke has been processed.

Serial.print(F("Time since last command: "));

Serial.println((float) (millis() - millis_prv)/1000, 2);

millis_prv = millis();

Serial.print(F("Enter s,1-9,+,-,>,<,f,F,d,i,p,t,S,b"));

#if !defined(__AVR_ATmega32U4__)

Serial.print(F(",m,e,r,R,g,k,O,o,D,V,B,C,T,E,M:"));

#endif

Serial.println(F(",h :"));

}

//------------------------------------------------------------------------------

/**

* \brief Print Help Menu.

* Prints a full menu of the commands available along with descriptions.

void help() {

Serial.println(F("Arduino SFEMP3Shield Library Example:"));

Serial.println(F(" courtesy of Bill Porter & Michael P. Flaga"));

Serial.println(F("COMMANDS:"));

Serial.println(F(" [1-9] to play a track"));

Serial.println(F(" [f] play track001.mp3 by filename example"));

Serial.println(F(" [F] same as [f] but with initial skip of 2 second"));

Serial.println(F(" [s] to stop playing"));

Serial.println(F(" [d] display directory of SdCard"));

Serial.println(F(" [+ or -] to change volume"));

Serial.println(F(" [> or <] to increment or decrement play speed by 1 factor"));

Serial.println(F(" [i] retrieve current audio information (partial list)"));

Serial.println(F(" [p] to pause."));

Serial.println(F(" [t] to toggle sine wave test"));

Serial.println(F(" [S] Show State of Device."));

Serial.println(F(" [b] Play a MIDI File Beep"));

#if !defined(__AVR_ATmega32U4__)

Serial.println(F(" [e] increment Spatial EarSpeaker, default is 0, wraps after 4"));

Serial.println(F(" [m] perform memory test. reset is needed after to recover."));

Serial.println(F(" [M] Toggle between Mono and Stereo Output."));

Serial.println(F(" [g] Skip to a predetermined offset of ms in current track."));

Serial.println(F(" [k] Skip a predetermined number of ms in current track."));

Serial.println(F(" [r] resumes play from 2s from begin of file"));

Serial.println(F(" [R] Resets and initializes VS10xx chip."));

Serial.println(F(" [O] turns OFF the VS10xx into low power reset."));

Serial.println(F(" [o] turns ON the VS10xx out of low power reset."));

Serial.println(F(" [D] to toggle SM_DIFF between inphase and differential output"));

Serial.println(F(" [V] Enable VU meter Test."));

Serial.println(F(" [B] Increament bass frequency by 10Hz"));

Serial.println(F(" [C] Increament bass amplitude by 1dB"));

Serial.println(F(" [T] Increament treble frequency by 1000Hz"));

Serial.println(F(" [E] Increament treble amplitude by 1dB"));

#endif

Serial.println(F(" [h] this help"));

}

Arduino2 (eyeballs and vibes) CODE:

/*
 --reProgrammer--
 The reProgrammer is an immersive experience.
 http://creativetechnical.ca/reprogrammer/
 This sketch responds to cues from Arduino1 and controls the eyeball LEDs and the tactile transducers. 
*/

//abort: low pulse resets arduino "reset" pin (red arcade button)

#include <FastLED.h>
#define NUM_LEDS 2
CRGB leds[NUM_LEDS];

#define NUM_COLUMNS 25
#define NUM_ROWS 13

#define audio 300
#define whole 599     //<600
#define half whole/2
#define quarter whole/4
#define eighth whole/8

#define a 850  //"this is the left eye" delay
#define k 1000

#define d1 1
#include "LedLibrary.h"

/* Timer reload value, globally available */
unsigned int tcnt2;
unsigned int pin_control;//pin_control

/* Toggle HIGH or LOW digital write */
unsigned char toggle = 0;

/* Frequency Output Pins */
#define SPKR1 A1
#define SPKR2 2
#define SPKR3 3
#define SPKR4 4
#define SPKR5 5
#define SPKR6 6
#define SPKR7 7
#define SPKR8 8
#define SPKR9 9
#define SPKR10 A0

/*Bit position names*/
#define BIT0 (1<<0)
#define BIT1 (1<<1)
#define BIT2 (1<<2)
#define BIT3 (1<<3)
#define BIT4 (1<<4)
#define BIT5 (1<<5)
#define BIT6 (1<<6)
#define BIT7 (1<<7)
#define BIT8 (1<<8)
#define BIT9 (1<<9)
#define BIT10 (1<<10)
//#define BIT11 (1<<11)
//#define BIT12 (1<<12)

int trigger1 = A4; // trigger1 is attached to analog pin 4 (pinA4 on MP3 arduino)
int trigger2 = A5; // trigger2 is attached to analog pin 5 (pinA5 on MP3 arduino)
int trigger1state;
int trigger2state;

/*
Future: attempt to have any song trigger the pucks/eyeball LEDs in a sensible fsahion, using the spectrum analyzer MSGEQ7 x 2 (stereo)
int resetPin = A2; // reset is attached to analog pin 2 (pin7 on MSGeq7)
int analogPinLeft = A3; // read from multiplexer using analog input 3 (pin3 on MSGeq7#1)
int strobePin = A4; // strobe is attached to analog pin 4 (pin4 on MSGeq7)
int analogPinRight = A5; // read from multiplexer using analog input 5 (pin3 on MSGeq7#2)
int leftspectrumValue;//[7]; // to hold a2d values
int rightspectrumValue[7]; // to hold a2d values
*/
///////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////
void setup()
{
  FastLED.addLeds<WS2801, RGB>(leds, NUM_LEDS);
  Serial.begin(9600);
  pinMode(trigger1, INPUT);
  pinMode(trigger2, INPUT);
  analogReference(DEFAULT);

  /* First disable the timer overflow interrupt*/
  TIMSK2 &= ~(1<<TOIE2);
  
  /* Configure timer2 in normal mode (no PWM) */
  TCCR2A &= ~((1<<WGM21) | (1<<WGM20));
  TCCR2B &= ~(1<<WGM22);

  /* Select clock source: internal I/O clock */
  ASSR &= ~(1<<AS2);
  
  /* Disable Compare Match A interrupt (only overflow) */
  TIMSK2 &= ~(1<<OCIE2A);
  
  /* Configure the prescaler to CPU clock divided by 128 */
  TCCR2B |= (1<<CS22)  | (1<<CS21) | (1<<CS20); // Set bits
//  TCCR2B &= ~(1<<CS21);             // Clear bit

  /* Save value globally for later reload in ISR */
  tcnt2 = 60;
  
  /* Finally load and enable the timer */
  TCNT2 = tcnt2;
  TIMSK2 |= (1<<TOIE2);
  
  //Configure I/O Pin Directions
  pinMode(SPKR1,    OUTPUT);
  pinMode(SPKR2,    OUTPUT);
  pinMode(SPKR3,    OUTPUT);
  pinMode(SPKR4,    OUTPUT);
  pinMode(SPKR5,    OUTPUT);
  pinMode(SPKR6,    OUTPUT);
  pinMode(SPKR7,    OUTPUT);
  pinMode(SPKR8,    OUTPUT);
  pinMode(SPKR9,    OUTPUT);
  pinMode(SPKR10,    OUTPUT);
  
  pin_control = 0;
  eyesOff();
  FastSPI_LED.show();
  speakersOff();
  leftEye(0,100,0);
  delay(1000);
  eyesOff();
}

/* Install the Interrupt Service Routine (ISR) for Timer1.  */
ISR(TIMER2_OVF_vect) 
{
  /* Reload the timer */
  TCNT2 = tcnt2;
  if (pin_control & BIT1)
  {
    digitalWrite(SPKR1, toggle == 0 ? HIGH : LOW);
  }
  
  if (pin_control & BIT2)
  {
    digitalWrite(SPKR2, toggle == 0 ? HIGH : LOW);
  }
  
  if (pin_control & BIT3)
  {
    digitalWrite(SPKR3, toggle == 0 ? HIGH : LOW);
  }
  
  if (pin_control & BIT4)
  {
    digitalWrite(SPKR4, toggle == 0 ? HIGH : LOW);
  }
  
  if (pin_control & BIT5)
  {
    digitalWrite(SPKR5, toggle == 0 ? HIGH : LOW);
  }
  
  if (pin_control & BIT6)
  {
    digitalWrite(SPKR6, toggle == 0 ? HIGH : LOW);
  }
  
  if (pin_control & BIT7)
  {
    digitalWrite(SPKR7, toggle == 0 ? HIGH : LOW);
  }
  
  if (pin_control & BIT8)
  {
    digitalWrite(SPKR8, toggle == 0 ? HIGH : LOW);
  }
  
  if (pin_control & BIT9)
  {
    digitalWrite(SPKR9, toggle == 0 ? HIGH : LOW);
  }
  
  if (pin_control & BIT10)
  {
    digitalWrite(SPKR10, toggle == 0 ? HIGH : LOW);
  }
  
  toggle = ~toggle;
}

///////////////////////////////////////////////////////////////////////////////////////  
///////////////////////////////////////////////////////////////////////////////////////
void speakersOff()
{
  pin_control &= ~(BIT1 | BIT2 | BIT3 | BIT4 | BIT5 | BIT6 | BIT7 | BIT8 | BIT9 | BIT10);
}
///////////////////////////////////////////////////////////////////////////////////////
void speakersOn()
{
  pin_control |= BIT1 | BIT2 | BIT3 | BIT4 | BIT5 | BIT6 | BIT7 | BIT8 | BIT9 | BIT10;
}
///////////////////////////////////////////////////////////////////////////////////////
void leftSpeakersOff()
{
  pin_control &= ~(BIT1 | BIT3 | BIT5 | BIT7 | BIT9);    //turn off 1 and 2 and 3...9
}
///////////////////////////////////////////////////////////////////////////////////////
void leftSpeakersOn()
{
  pin_control |= BIT1 | BIT3 | BIT5 | BIT7 | BIT9;    //turn on 1 and 2 and 3...9
}
///////////////////////////////////////////////////////////////////////////////////////
void rightSpeakersOff()
{
  pin_control &= ~(BIT2 | BIT4 | BIT6 | BIT8 | BIT10);
}
///////////////////////////////////////////////////////////////////////////////////////
void rightSpeakersOn()
{
  pin_control |= BIT2 | BIT4 | BIT6 | BIT8 | BIT10;
}
///////////////////////////////////////////////////////////////////////////////////////
void aSpeakersOff()
{
  pin_control &= ~(BIT1 | BIT2);
}
///////////////////////////////////////////////////////////////////////////////////////
void aSpeakersOn()
{
  pin_control |= BIT1 | BIT2;
}
///////////////////////////////////////////////////////////////////////////////////////
void bSpeakersOff()
{
  pin_control &= ~(BIT3 | BIT4);
}
///////////////////////////////////////////////////////////////////////////////////////
void bSpeakersOn()
{
  pin_control |= BIT3 | BIT4;
}
///////////////////////////////////////////////////////////////////////////////////////
void cSpeakersOff()
{
  pin_control &= ~(BIT5 | BIT6);
}
///////////////////////////////////////////////////////////////////////////////////////
void cSpeakersOn()
{
  pin_control |= BIT5 | BIT6;
}
///////////////////////////////////////////////////////////////////////////////////////
void dSpeakersOff()
{
  pin_control &= ~(BIT7 | BIT8);
}
///////////////////////////////////////////////////////////////////////////////////////
void dSpeakersOn()
{
  pin_control |= BIT7 | BIT8;
}
///////////////////////////////////////////////////////////////////////////////////////
void eSpeakersOff()
{
  pin_control &= ~(BIT9 | BIT10);
}
///////////////////////////////////////////////////////////////////////////////////////
void eSpeakersOn()
{
  pin_control |= BIT9 | BIT10;
}
///////////////////////////////////////////////////////////////////////////////////////
void xSpeakerOn(int x)
{
  pin_control |= 1<< x;
}
///////////////////////////////////////////////////////////////////////////////////////
void xSpeakerOff(int x)
{
  pin_control &= 1<< x;
}
///////////////////////////////////////////////////////////////////////////////////////
void speakersTest()
{
  for(int x=0; x<11; x++)
  {
    pin_control |= 1<< x;   //pin_control |= BIT[x];
    delay(520);    //500?
    pin_control &= 1<< (x+1);    //turn off previously turned on
  }
}
///////////////////////////////////////////////////////////////////////////////////////
void oneRandomSpeakerOn()
{
  int i=random(1,11);  //generates a number between 1 and 10 inclusive
  pin_control |= 1<< i;
  delay(half);
  pin_control &= 1<< (i+1);
}
///////////////////////////////////////////////////////////////////////////////////////
void twoRandomSpeakersOn()
{
  int i=random(1,6);
  int q=random(6,11);
  pin_control |= 1<< i;
  pin_control |= 1<< q;
  delay(half);
  pin_control &= 1<< (i+1);
  pin_control &= 1<< (q+1);
}
///////////////////////////////////////////////////////////////////////////////////////
void loop()
{
//tests//////////////////////////////////////////////////////////////////////
  trigger1state = digitalRead(trigger1);
  trigger2state = digitalRead(trigger2);
  if (trigger1state == HIGH)    ////when triggerHIGH is received
  {
  //"this is the left eye"
    leftEye(0,50,150);      //
    delay(a);
    leftEye(100,20,0);      //
    delay(a);
    leftEye(30,100,0);      //
    delay(a);
    leftEye(50,0,100);      //
    delay(a);
    leftEye(100,50,50);      //
    delay(a+50);
    eyesOff();
//    delay(200);
     
  //"this is the right eye"
    rightEye(30,100,60);      //
    delay(a);
    rightEye(70,20,50);      //
    delay(a);
    rightEye(0,0,100);      //
    delay(a);
    rightEye(80,100,0);      //
    delay(a);
    rightEye(30,20,160);      //
    delay(a);

    eyesOff();
    delay(3130);      //delay for speech  3150
    
  //"begin body test"   
    speakersTest();
  }
//"sensory tests complete...Sequence start in 5...4...3...2...1..."
//main routine///////////////////////////////////////////////////////////////////////
  if (trigger2state == HIGH)      //when triggerHIGH is received
  {
//        for (int i = 0; i < 4; i++)      //4X whole-note alternate
      {   
        leftSpeakersOn();
        leftEye(255,0,0);      //red
        delay(whole);
        leftSpeakersOff();
        eyesOff();
        delay(3*whole);
       
        rightSpeakersOn();
        rightEye(0,255,150);      //cyan
        delay(whole);
        rightSpeakersOff();
        eyesOff();
        delay(3*whole);

        leftSpeakersOn();
        leftEye(200,255,0);      //yellow
        delay(whole);
        leftSpeakersOff();
        eyesOff();
        delay(3*whole);
       
        rightSpeakersOn();
        rightEye(60,0,150);      //purple
        delay(whole);
        rightSpeakersOff();
        eyesOff();
        delay(3*whole);

        leftSpeakersOn();
        leftEye(0,255,0);      //green
        delay(whole);
        leftSpeakersOff();
        eyesOff();
        delay(3*whole);
       
        rightSpeakersOn();
        rightEye(200,100,0);      //orange
        delay(whole);
        rightSpeakersOff();
        eyesOff();
        delay(3*whole);

        leftSpeakersOn();
        leftEye(30,100,100);      //white
        delay(whole);
        leftSpeakersOff();
        eyesOff();
        delay(3*whole);
       
        rightSpeakersOn();
        rightEye(0,60,200);      //light blue
        delay(whole);
        rightSpeakersOff();
        eyesOff();
        delay(3*whole);
      }
      delay(15);   // >5
//        for (int i = 0; i < 4; i++)      //4X half-note alternate
      { 
        
        leftSpeakersOn();
        leftEye(200,255,0);      //yellow
        delay(whole);
        leftSpeakersOff();
        eyesOff();
        delay(whole);
       
        rightSpeakersOn();
        rightEye(60,0,255);      //purple
        delay(whole);
        rightSpeakersOff();
        eyesOff();
        delay(whole);
        
        leftSpeakersOn();
        leftEye(0,255,0);      //green
        delay(whole);
        leftSpeakersOff();
        eyesOff();
        delay(whole);
       
        rightSpeakersOn();
        rightEye(200,100,0);      //orange
        delay(whole);
        rightSpeakersOff();
        eyesOff();
        delay(whole);
        
        leftSpeakersOn();
        leftEye(255,0,0);      //red
        delay(whole);
        leftSpeakersOff();
        eyesOff();
        delay(whole);
       
        rightSpeakersOn();
        rightEye(0,255,150);      //cyan
        delay(whole);
        rightSpeakersOff();
        eyesOff();
        delay(whole);
        
        leftSpeakersOn();
        leftEye(200,0,150);      //pink
        delay(whole);
        leftSpeakersOff();
        eyesOff();
        delay(whole);
       
        rightSpeakersOn();
        rightEye(0,0,255);      //blue
        delay(whole);
        rightSpeakersOff();
        eyesOff();
        delay(whole);
      }
   delay(20);   
      for (int i = 0; i < 2; i++)    //2X quarter-note (go to "A")
      {   
        leftSpeakersOn();
        leftEye(100,100,0);      //yellow
        rightEye(0,255,255);
        delay(half);
        rightEye(255,255,0);
        delay(half);
        leftSpeakersOff();
        leftEyeOff();
        rightEye(255,100,100);
        delay(half);
        rightEye(50,50,255);
        delay(half);
  
        leftSpeakersOn();
        leftEye(255,0,0);      //different than previous
        rightEye(0,255,255);
        delay(half);
        rightEye(255,255,0);
        delay(half);
        leftSpeakersOff();
        leftEyeOff();
        rightEye(255,100,100);
        delay(half);
        rightEye(50,50,255);
        delay(half);
       
        rightSpeakersOn();
        rightEye(0,0,255);      //make this original
        leftEye(0,255,255);
        delay(half);
        leftEye(255,255,0);
        delay(half);
        rightSpeakersOff();
        rightEyeOff();
        leftEye(255,100,100);
        delay(half);
        leftEye(50,50,255);
        delay(half);
  
        rightSpeakersOn();
        rightEye(0,200,0);      //diff than previous
        leftEye(0,255,255);
        delay(half);
        leftEye(255,255,0);
        delay(half);
        rightSpeakersOff();
        rightEyeOff();
        leftEye(255,100,100);
        delay(half);
        leftEye(50,50,255);
        delay(half);
      }
    delay(20);      //trying to sync with audio
      for (int i = 0; i < 32; i++)    //32x random 2-speaker fun
      { 
        leftEye(random(255), random(255), random(255));
        rightEye(random(255), random(255), random(255));
        //eyesOn(random(255), random(255), random(255));    //randomize each eye; left diff than right
        twoRandomSpeakersOn();
        delay(quarter-3);    //sound is earlier
        speakersOff();
        //eyesOff();
        delay(quarter);
      } 
   delay(20);     
      for (int i = 0; i < 4; i++)    //4x ascend/descend pairs
      {   
        aSpeakersOn();
        eyesOn(0,0,100);//blue
        delay(half);
  
        aSpeakersOff();
        eyesOff();
        bSpeakersOn();
        eyesOn(0,100,0);//green
        delay(half);
  
        bSpeakersOff();
        eyesOff();
        cSpeakersOn();
        eyesOn(100,0,0);//red
        delay(half);
   
        cSpeakersOff();
        eyesOff();
        dSpeakersOn();
        eyesOn(0,100,100);
        delay(half);
   
        dSpeakersOff();
        eyesOff();
        eSpeakersOn();
        eyesOn(100,100,100);//white
        delay(half);
   
        eSpeakersOff();
        eyesOff();
        dSpeakersOn();
        eyesOn(100,0,0);//red
        delay(half);
   
        dSpeakersOff();
        eyesOff();
        cSpeakersOn();
        eyesOn(50,100,0);
        delay(half);
   
        cSpeakersOff();
        eyesOff();
        bSpeakersOn();
        eyesOn(50,0,100);//
        delay(half);
        bSpeakersOff();
        eyesOff();
      }
//restart///////////////////////////////////////////////////////////////////////////////

//        for (int i = 0; i < 4; i++)      //4X whole-note alternate
      {   
        leftSpeakersOn();
        leftEye(100,0,0);      //red
        delay(whole);
        leftSpeakersOff();
        eyesOff();
        delay(3*whole);
       
        rightSpeakersOn();
        rightEye(0,255,150);      //cyan
        delay(whole);
        rightSpeakersOff();
        eyesOff();
        delay(3*whole);

        leftSpeakersOn();
        leftEye(255,255,0);      //yellow
        delay(whole);
        leftSpeakersOff();
        eyesOff();
        delay(3*whole);
       
        rightSpeakersOn();
        rightEye(200,0,150);      //purple
        delay(whole);
        rightSpeakersOff();
        eyesOff();
        delay(3*whole);

        leftSpeakersOn();
        leftEye(0,255,0);      //green
        delay(whole);
        leftSpeakersOff();
        eyesOff();
        delay(3*whole);
       
        rightSpeakersOn();
        rightEye(200,100,0);      //orange
        delay(whole);
        rightSpeakersOff();
        eyesOff();
        delay(3*whole);

        leftSpeakersOn();
        leftEye(100,100,100);      //white
        delay(whole);
        leftSpeakersOff();
        eyesOff();
        delay(3*whole);
       
        rightSpeakersOn();
        rightEye(0,60,200);      //light blue
        delay(whole);
        rightSpeakersOff();
        eyesOff();
        delay(3*whole);
      }
      
//        for (int i = 0; i < 4; i++)      //4X half-note alternate
      { 
        
        leftSpeakersOn();
        leftEye(255,255,0);      //yellow
        delay(whole);
        leftSpeakersOff();
        eyesOff();
        delay(whole);
       
        rightSpeakersOn();
        rightEye(200,0,150);      //purple
        delay(whole);
        rightSpeakersOff();
        eyesOff();
        delay(whole);
        
        leftSpeakersOn();
        leftEye(0,255,0);      //green
        delay(whole);
        leftSpeakersOff();
        eyesOff();
        delay(whole);
       
        rightSpeakersOn();
        rightEye(200,100,0);      //orange
        delay(whole);
        rightSpeakersOff();
        eyesOff();
        delay(whole);
        
        leftSpeakersOn();
        leftEye(200,0,0);      //red
        delay(whole);
        leftSpeakersOff();
        eyesOff();
        delay(whole);
       
        rightSpeakersOn();
        rightEye(0,255,150);      //cyan
        delay(whole);
        rightSpeakersOff();
        eyesOff();
        delay(whole);
        
        leftSpeakersOn();
        leftEye(200,0,150);      //pink
        delay(whole);
        leftSpeakersOff();
        eyesOff();
        delay(whole);
       
        rightSpeakersOn();
        rightEye(0,0,100);      //blue
        delay(whole);
        rightSpeakersOff();
        eyesOff();
        delay(whole);
      }
      
//  delay(32);    
      for (int i = 0; i < 2; i++)    //2X quarter-note (go to "A")
      {   
        leftSpeakersOn();
        leftEye(100,100,0);      //yellow
        rightEye(0,255,255);
        delay(half);
        rightEye(255,255,0);
        delay(half);
        leftSpeakersOff();
        leftEyeOff();
        rightEye(255,100,100);
        delay(half);
        rightEye(50,50,255);
        delay(half);
  
        leftSpeakersOn();
        leftEye(255,0,0);      //different than previous
        rightEye(0,255,255);
        delay(half);
        rightEye(255,255,0);
        delay(half);
        leftSpeakersOff();
        leftEyeOff();
        rightEye(255,100,100);
        delay(half);
        rightEye(50,50,255);
        delay(half);
       
        rightSpeakersOn();
        rightEye(0,0,255);      //make this original
        leftEye(0,255,255);
        delay(half);
        leftEye(255,255,0);
        delay(half);
        rightSpeakersOff();
        rightEyeOff();
        leftEye(255,100,100);
        delay(half);
        leftEye(50,50,255);
        delay(half);
  
        rightSpeakersOn();
        rightEye(0,200,0);      //diff than previous
        leftEye(0,255,255);
        delay(half);
        leftEye(255,255,0);
        delay(half);
        rightSpeakersOff();
        rightEyeOff();
        leftEye(255,100,100);
        delay(half);
        leftEye(50,50,255);
        delay(half);
      }
  
      for (int i = 0; i < 32; i++)    //32x all pulse
      {
        speakersOn();
        eyesOn(random(255), random(255), random(255));    //separate left and right?
        delay(half-2);    //sound is earlier(half-1)
        speakersOff();
        eyesOff();
        delay(half);
      }   
      delay(60000);//end of the ride
    }
}

/*
MSGEQ7 tests:
  if (leftspectrumValue[2] > h)
  {
    xSpeakerOn(3);
    leftEye(20,100,0);
  }
  else
  {
    xSpeakerOff(3);
    eyesOff();
  }
  if (leftspectrumValue[3] > h)
  {
    xSpeakerOn(5);
    leftEye(20,100,0);
  }
  else
  {
    xSpeakerOff(5);
    eyesOff();
  }
  if (leftspectrumValue[4] > h)
  {
    xSpeakerOn(7);
    leftEye(20,100,0);
  }
  else
  {
    xSpeakerOff(7);
    eyesOff();
  }
  if (leftspectrumValue[5] > h)
  {
    xSpeakerOn(9);
    leftEye(20,100,0);
  }
  else
  {
    xSpeakerOff(9);
    eyesOff();
  }

  if (rightspectrumValue[1] > h)
  {
    xSpeakerOn(2);
    rightEye(20,100,0);
  }
  else
  {
    xSpeakerOff(2);
    eyesOff();
  }
  if (rightspectrumValue[2] > h)
  {
    xSpeakerOn(4);
    rightEye(20,100,0);
  }
  else
  {
    xSpeakerOff(4);
    eyesOff();
  }
  if (rightspectrumValue[3] > h)
  {
    xSpeakerOn(6);
    rightEye(20,100,0);
  }
  else
  {
    xSpeakerOff(6);
    eyesOff();
  }
  if (rightspectrumValue[4] > h)
  {
    xSpeakerOn(8);
    rightEye(20,100,0);
  }
  else
  {
    xSpeakerOff(8);
    eyesOff();
  }
  if (rightspectrumValue[5] > h)
  {
    xSpeakerOn(10);
    rightEye(20,100,0);
  }
  else
  {
    xSpeakerOff(10);
    eyesOff();
  }
*/

////////////////////////////////////////////////////////////////////////////////////////////////////
/*
  int x=(spectrumValue[0]+spectrumValue[1]+spectrumValue[2]+spectrumValue[3]+
  spectrumValue[4]+spectrumValue[5]+spectrumValue[6])/7;
  if (x > 150)
  {
    SpeakersOn();
    eyesOn(20,100,0);
  }
  else
  {
    SpeakersOff();
    eyesOff() ;
  } 
}
///////////////////////////////////////////////////////////////////////////////////////  
/*

  if (leftspectrumValue[2] > h)
  {
    leftSpeakersOn();
    leftEye(20,100,0);
  }
  else
  {
    leftSpeakersOff();
    leftEyeOff();
  }

  if (rightspectrumValue[3] > h)
  {
    rightSpeakersOn();
    rightEye(20,100,0);
  }
  else
  {
    rightSpeakersOff();
    rightEyeOff();
  }

  {
    if (x > 300 && x < 400)
      level1();
    if (x > 400 && x < 500)
      level2();
    if (x > 500 && x < 600)
      level4();
    if (x > 600 && x < 700)
      level5();
    if (x > 700 && x < 800)
      level6();
    if (x > 800 && x < 900)
      level7();
  }
*/

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

381

382

383

384

385

386

387

388

389

390

391

392

393

394

395

396

397

398

399

400

401

402

403

404

405

406

407

408

409

410

411

412

413

414

415

416

417

418

419

420

421

422

423

424

425

426

427

428

429

430

431

432

433

434

435

436

437

438

439

440

441

442

443

444

445

446

447

448

449

450

451

452

453

454

455

456

457

458

459

460

461

462

463

464

465

466

467

468

469

470

471

472

473

474

475

476

477

478

479

480

481

482

483

484

485

486

487

488

489

490

491

492

493

494

495

496

497

498

499

500

501

502

503

504

505

506

507

508

509

510

511

512

513

514

515

516

517

518

519

520

521

522

523

524

525

526

527

528

529

530

531

532

533

534

535

536

537

538

539

540

541

542

543

544

545

546

547

548

549

550

551

552

553

554

555

556

557

558

559

560

561

562

563

564

565

566

567

568

569

570

571

572

573

574

575

576

577

578

579

580

581

582

583

584

585

586

587

588

589

590

591

592

593

594

595

596

597

598

599

600

601

602

603

604

605

606

607

608

609

610

611

612

613

614

615

616

617

618

619

620

621

622

623

624

625

626

627

628

629

630

631

632

633

634

635

636

637

638

639

640

641

642

643

644

645

646

647

648

649

650

651

652

653

654

655

656

657

658

659

660

661

662

663

664

665

666

667

668

669

670

671

672

673

674

675

676

677

678

679

680

681

682

683

684

685

686

687

688

689

690

691

692

693

694

695

696

697

698

699

700

701

702

703

704

705

706

707

708

709

710

711

712

713

714

715

716

717

718

719

720

721

722

723

724

725

726

727

728

729

730

731

732

733

734

735

736

737

738

739

740

741

742

743

744

745

746

747

748

749

750

751

752

753

754

755

756

757

758

759

760

761

762

763

764

765

766

767

768

769

770

771

772

773

774

775

776

777

778

779

780

781

782

783

784

785

786

787

788

789

790

791

792

793

794

795

796

797

798

799

800

801

802

803

804

805

806

807

808

809

810

811

812

813

814

815

816

817

818

819

820

821

822

823

824

825

826

827

828

829

830

831

832

833

834

835

836

837

838

839

840

841

842

843

844

845

846

847

848

849

850

851

852

853

854

855

856

857

858

859

860

861

862

863

864

865

866

867

868

869

870

871

872

873

874

875

876

877

878

879

880

881

882

883

884

885

886

887

888

889

890

891

892

893

894

895

896

897

898

899

900

901

902

903

904

905

906

907

908

909

910

911

912

913

914

915

916

917

918

919

920

921

922

923

924

925

926

927

928

929

--reProgrammer--

The reProgrammer is an immersive experience.

http://creativetechnical.ca/reprogrammer/

This sketch responds to cues from Arduino1 and controls the eyeball LEDs and the tactile transducers.

//abort: low pulse resets arduino "reset" pin (red arcade button)

#include <FastLED.h>

#define NUM_LEDS 2

CRGB leds[NUM_LEDS];

#define NUM_COLUMNS 25

#define NUM_ROWS 13

#define audio 300

#define whole 599 //<600

#define half whole/2

#define quarter whole/4

#define eighth whole/8

#define a 850 //"this is the left eye" delay

#define k 1000

#define d1 1

#include "LedLibrary.h"

/* Timer reload value, globally available */

unsigned int tcnt2;

unsigned int pin_control;//pin_control

/* Toggle HIGH or LOW digital write */

unsigned char toggle = 0;

/* Frequency Output Pins */

#define SPKR1 A1

#define SPKR2 2

#define SPKR3 3

#define SPKR4 4

#define SPKR5 5

#define SPKR6 6

#define SPKR7 7

#define SPKR8 8

#define SPKR9 9

#define SPKR10 A0

/*Bit position names*/

#define BIT0 (1<<0)

#define BIT1 (1<<1)

#define BIT2 (1<<2)

#define BIT3 (1<<3)

#define BIT4 (1<<4)

#define BIT5 (1<<5)

#define BIT6 (1<<6)

#define BIT7 (1<<7)

#define BIT8 (1<<8)

#define BIT9 (1<<9)

#define BIT10 (1<<10)

//#define BIT11 (1<<11)

//#define BIT12 (1<<12)

int trigger1 = A4; // trigger1 is attached to analog pin 4 (pinA4 on MP3 arduino)

int trigger2 = A5; // trigger2 is attached to analog pin 5 (pinA5 on MP3 arduino)

int trigger1state;

int trigger2state;

Future: attempt to have any song trigger the pucks/eyeball LEDs in a sensible fsahion, using the spectrum analyzer MSGEQ7 x 2 (stereo)

int resetPin = A2; // reset is attached to analog pin 2 (pin7 on MSGeq7)

int analogPinLeft = A3; // read from multiplexer using analog input 3 (pin3 on MSGeq7#1)

int strobePin = A4; // strobe is attached to analog pin 4 (pin4 on MSGeq7)

int analogPinRight = A5; // read from multiplexer using analog input 5 (pin3 on MSGeq7#2)

int leftspectrumValue;//[7]; // to hold a2d values

int rightspectrumValue[7]; // to hold a2d values

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

void setup()

{

FastLED.addLeds<WS2801, RGB>(leds, NUM_LEDS);

Serial.begin(9600);

pinMode(trigger1, INPUT);

pinMode(trigger2, INPUT);

analogReference(DEFAULT);

/* First disable the timer overflow interrupt*/

TIMSK2 &= ~(1<<TOIE2);

/* Configure timer2 in normal mode (no PWM) */

TCCR2A &= ~((1<<WGM21) | (1<<WGM20));

TCCR2B &= ~(1<<WGM22);

/* Select clock source: internal I/O clock */

ASSR &= ~(1<<AS2);

/* Disable Compare Match A interrupt (only overflow) */

TIMSK2 &= ~(1<<OCIE2A);

/* Configure the prescaler to CPU clock divided by 128 */

TCCR2B |= (1<<CS22) | (1<<CS21) | (1<<CS20); // Set bits

// TCCR2B &= ~(1<<CS21); // Clear bit

/* Save value globally for later reload in ISR */

tcnt2 = 60;

/* Finally load and enable the timer */

TCNT2 = tcnt2;

TIMSK2 |= (1<<TOIE2);

//Configure I/O Pin Directions

pinMode(SPKR1, OUTPUT);

pinMode(SPKR2, OUTPUT);

pinMode(SPKR3, OUTPUT);

pinMode(SPKR4, OUTPUT);

pinMode(SPKR5, OUTPUT);

pinMode(SPKR6, OUTPUT);

pinMode(SPKR7, OUTPUT);

pinMode(SPKR8, OUTPUT);

pinMode(SPKR9, OUTPUT);

pinMode(SPKR10, OUTPUT);

pin_control = 0;

eyesOff();

FastSPI_LED.show();

speakersOff();

leftEye(0,100,0);

delay(1000);

eyesOff();

}

/* Install the Interrupt Service Routine (ISR) for Timer1. */

ISR(TIMER2_OVF_vect)

{

/* Reload the timer */

TCNT2 = tcnt2;

if (pin_control & BIT1)

{

digitalWrite(SPKR1, toggle == 0 ? HIGH : LOW);

}

if (pin_control & BIT2)

{

digitalWrite(SPKR2, toggle == 0 ? HIGH : LOW);

}

if (pin_control & BIT3)

{

digitalWrite(SPKR3, toggle == 0 ? HIGH : LOW);

}

if (pin_control & BIT4)

{

digitalWrite(SPKR4, toggle == 0 ? HIGH : LOW);

}

if (pin_control & BIT5)

{

digitalWrite(SPKR5, toggle == 0 ? HIGH : LOW);

}

if (pin_control & BIT6)

{

digitalWrite(SPKR6, toggle == 0 ? HIGH : LOW);

}

if (pin_control & BIT7)

{

digitalWrite(SPKR7, toggle == 0 ? HIGH : LOW);

}

if (pin_control & BIT8)

{

digitalWrite(SPKR8, toggle == 0 ? HIGH : LOW);

}

if (pin_control & BIT9)

{

digitalWrite(SPKR9, toggle == 0 ? HIGH : LOW);

}

if (pin_control & BIT10)

{

digitalWrite(SPKR10, toggle == 0 ? HIGH : LOW);

}

toggle = ~toggle;

}

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

void speakersOff()

{

pin_control &= ~(BIT1 | BIT2 | BIT3 | BIT4 | BIT5 | BIT6 | BIT7 | BIT8 | BIT9 | BIT10);

}

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

void speakersOn()

{

pin_control |= BIT1 | BIT2 | BIT3 | BIT4 | BIT5 | BIT6 | BIT7 | BIT8 | BIT9 | BIT10;

}

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

void leftSpeakersOff()

{

pin_control &= ~(BIT1 | BIT3 | BIT5 | BIT7 | BIT9); //turn off 1 and 2 and 3...9

}

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

void leftSpeakersOn()

{

pin_control |= BIT1 | BIT3 | BIT5 | BIT7 | BIT9; //turn on 1 and 2 and 3...9

}

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

void rightSpeakersOff()

{

pin_control &= ~(BIT2 | BIT4 | BIT6 | BIT8 | BIT10);

}

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

void rightSpeakersOn()

{

pin_control |= BIT2 | BIT4 | BIT6 | BIT8 | BIT10;

}

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

void aSpeakersOff()

{

pin_control &= ~(BIT1 | BIT2);

}

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

void aSpeakersOn()

{

pin_control |= BIT1 | BIT2;

}

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

void bSpeakersOff()

{

pin_control &= ~(BIT3 | BIT4);

}

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

void bSpeakersOn()

{

pin_control |= BIT3 | BIT4;

}

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

void cSpeakersOff()

{

pin_control &= ~(BIT5 | BIT6);

}

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

void cSpeakersOn()

{

pin_control |= BIT5 | BIT6;

}

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

void dSpeakersOff()

{

pin_control &= ~(BIT7 | BIT8);

}

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

void dSpeakersOn()

{

pin_control |= BIT7 | BIT8;

}

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

void eSpeakersOff()

{

pin_control &= ~(BIT9 | BIT10);

}

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

void eSpeakersOn()

{

pin_control |= BIT9 | BIT10;

}

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

void xSpeakerOn(int x)

{

pin_control |= 1<< x;

}

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

void xSpeakerOff(int x)

{

pin_control &= 1<< x;

}

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

void speakersTest()

{

for(int x=0; x<11; x++)

{

pin_control |= 1<< x; //pin_control |= BIT[x];

delay(520); //500?

pin_control &= 1<< (x+1); //turn off previously turned on

}

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

void oneRandomSpeakerOn()

{

int i=random(1,11); //generates a number between 1 and 10 inclusive

pin_control |= 1<< i;

delay(half);

pin_control &= 1<< (i+1);

}

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

void twoRandomSpeakersOn()

{

int i=random(1,6);

int q=random(6,11);

pin_control |= 1<< i;

pin_control |= 1<< q;

delay(half);

pin_control &= 1<< (i+1);

pin_control &= 1<< (q+1);

}

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

void loop()

{

//tests//////////////////////////////////////////////////////////////////////

trigger1state = digitalRead(trigger1);

trigger2state = digitalRead(trigger2);

if (trigger1state == HIGH) ////when triggerHIGH is received

{

//"this is the left eye"

leftEye(0,50,150); //

delay(a);

leftEye(100,20,0); //

delay(a);

leftEye(30,100,0); //

delay(a);

leftEye(50,0,100); //

delay(a);

leftEye(100,50,50); //

delay(a+50);

eyesOff();

// delay(200);

//"this is the right eye"

rightEye(30,100,60); //

delay(a);

rightEye(70,20,50); //

delay(a);

rightEye(0,0,100); //

delay(a);

rightEye(80,100,0); //

delay(a);

rightEye(30,20,160); //

delay(a);

eyesOff();

delay(3130); //delay for speech 3150

//"begin body test"

speakersTest();

}

//"sensory tests complete...Sequence start in 5...4...3...2...1..."

//main routine///////////////////////////////////////////////////////////////////////

if (trigger2state == HIGH) //when triggerHIGH is received

{

// for (int i = 0; i < 4; i++) //4X whole-note alternate

{

leftSpeakersOn();

leftEye(255,0,0); //red

delay(whole);

leftSpeakersOff();

eyesOff();

delay(3*whole);

rightSpeakersOn();

rightEye(0,255,150); //cyan

delay(whole);

rightSpeakersOff();

eyesOff();

delay(3*whole);

leftSpeakersOn();

leftEye(200,255,0); //yellow

delay(whole);

leftSpeakersOff();

eyesOff();

delay(3*whole);

rightSpeakersOn();

rightEye(60,0,150); //purple

delay(whole);

rightSpeakersOff();

eyesOff();

delay(3*whole);

leftSpeakersOn();

leftEye(0,255,0); //green

delay(whole);

leftSpeakersOff();

eyesOff();

delay(3*whole);

rightSpeakersOn();

rightEye(200,100,0); //orange

delay(whole);

rightSpeakersOff();

eyesOff();

delay(3*whole);

leftSpeakersOn();

leftEye(30,100,100); //white

delay(whole);

leftSpeakersOff();

eyesOff();

delay(3*whole);

rightSpeakersOn();

rightEye(0,60,200); //light blue

delay(whole);

rightSpeakersOff();

eyesOff();

delay(3*whole);

}

delay(15); // >5

// for (int i = 0; i < 4; i++) //4X half-note alternate

{

leftSpeakersOn();

leftEye(200,255,0); //yellow

delay(whole);

leftSpeakersOff();

eyesOff();

delay(whole);

rightSpeakersOn();

rightEye(60,0,255); //purple

delay(whole);

rightSpeakersOff();

eyesOff();

delay(whole);

leftSpeakersOn();

leftEye(0,255,0); //green

delay(whole);

leftSpeakersOff();

eyesOff();

delay(whole);

rightSpeakersOn();

rightEye(200,100,0); //orange

delay(whole);

rightSpeakersOff();

eyesOff();

delay(whole);

leftSpeakersOn();

leftEye(255,0,0); //red

delay(whole);

leftSpeakersOff();

eyesOff();

delay(whole);

rightSpeakersOn();

rightEye(0,255,150); //cyan

delay(whole);

rightSpeakersOff();

eyesOff();

delay(whole);

leftSpeakersOn();

leftEye(200,0,150); //pink

delay(whole);

leftSpeakersOff();

eyesOff();

delay(whole);

rightSpeakersOn();

rightEye(0,0,255); //blue

delay(whole);

rightSpeakersOff();

eyesOff();

delay(whole);

}

delay(20);

for (int i = 0; i < 2; i++) //2X quarter-note (go to "A")

{

leftSpeakersOn();

leftEye(100,100,0); //yellow

rightEye(0,255,255);

delay(half);

rightEye(255,255,0);

delay(half);

leftSpeakersOff();

leftEyeOff();

rightEye(255,100,100);

delay(half);

rightEye(50,50,255);

delay(half);

leftSpeakersOn();

leftEye(255,0,0); //different than previous

rightEye(0,255,255);

delay(half);

rightEye(255,255,0);

delay(half);

leftSpeakersOff();

leftEyeOff();

rightEye(255,100,100);

delay(half);

rightEye(50,50,255);

delay(half);

rightSpeakersOn();

rightEye(0,0,255); //make this original

leftEye(0,255,255);

delay(half);

leftEye(255,255,0);

delay(half);

rightSpeakersOff();

rightEyeOff();

leftEye(255,100,100);

delay(half);

leftEye(50,50,255);

delay(half);

rightSpeakersOn();

rightEye(0,200,0); //diff than previous

leftEye(0,255,255);

delay(half);

leftEye(255,255,0);

delay(half);

rightSpeakersOff();

rightEyeOff();

leftEye(255,100,100);

delay(half);

leftEye(50,50,255);

delay(half);

}

delay(20); //trying to sync with audio

for (int i = 0; i < 32; i++) //32x random 2-speaker fun

{

leftEye(random(255), random(255), random(255));

rightEye(random(255), random(255), random(255));

//eyesOn(random(255), random(255), random(255)); //randomize each eye; left diff than right

twoRandomSpeakersOn();

delay(quarter-3); //sound is earlier

speakersOff();

//eyesOff();

delay(quarter);

}

delay(20);

for (int i = 0; i < 4; i++) //4x ascend/descend pairs

{

aSpeakersOn();

eyesOn(0,0,100);//blue

delay(half);

aSpeakersOff();

eyesOff();

bSpeakersOn();

eyesOn(0,100,0);//green

delay(half);

bSpeakersOff();

eyesOff();

cSpeakersOn();

eyesOn(100,0,0);//red

delay(half);

cSpeakersOff();

eyesOff();

dSpeakersOn();

eyesOn(0,100,100);

delay(half);

dSpeakersOff();

eyesOff();

eSpeakersOn();

eyesOn(100,100,100);//white

delay(half);

eSpeakersOff();

eyesOff();

dSpeakersOn();

eyesOn(100,0,0);//red

delay(half);

dSpeakersOff();

eyesOff();

cSpeakersOn();

eyesOn(50,100,0);

delay(half);

cSpeakersOff();

eyesOff();

bSpeakersOn();

eyesOn(50,0,100);//

delay(half);

bSpeakersOff();

eyesOff();

}

//restart///////////////////////////////////////////////////////////////////////////////

// for (int i = 0; i < 4; i++) //4X whole-note alternate

{

leftSpeakersOn();

leftEye(100,0,0); //red

delay(whole);

leftSpeakersOff();

eyesOff();

delay(3*whole);

rightSpeakersOn();

rightEye(0,255,150); //cyan

delay(whole);

rightSpeakersOff();

eyesOff();

delay(3*whole);

leftSpeakersOn();

leftEye(255,255,0); //yellow

delay(whole);

leftSpeakersOff();

eyesOff();

delay(3*whole);

rightSpeakersOn();

rightEye(200,0,150); //purple

delay(whole);

rightSpeakersOff();

eyesOff();

delay(3*whole);

leftSpeakersOn();

leftEye(0,255,0); //green

delay(whole);

leftSpeakersOff();

eyesOff();

delay(3*whole);

rightSpeakersOn();

rightEye(200,100,0); //orange

delay(whole);

rightSpeakersOff();

eyesOff();

delay(3*whole);

leftSpeakersOn();

leftEye(100,100,100); //white

delay(whole);

leftSpeakersOff();

eyesOff();

delay(3*whole);

rightSpeakersOn();

rightEye(0,60,200); //light blue

delay(whole);

rightSpeakersOff();

eyesOff();

delay(3*whole);

}

// for (int i = 0; i < 4; i++) //4X half-note alternate

{

leftSpeakersOn();

leftEye(255,255,0); //yellow

delay(whole);

leftSpeakersOff();

eyesOff();

delay(whole);

rightSpeakersOn();

rightEye(200,0,150); //purple

delay(whole);

rightSpeakersOff();

eyesOff();

delay(whole);

leftSpeakersOn();

leftEye(0,255,0); //green

delay(whole);

leftSpeakersOff();

eyesOff();

delay(whole);

rightSpeakersOn();

rightEye(200,100,0); //orange

delay(whole);

rightSpeakersOff();

eyesOff();

delay(whole);

leftSpeakersOn();

leftEye(200,0,0); //red

delay(whole);

leftSpeakersOff();

eyesOff();

delay(whole);

rightSpeakersOn();

rightEye(0,255,150); //cyan

delay(whole);

rightSpeakersOff();

eyesOff();

delay(whole);

leftSpeakersOn();

leftEye(200,0,150); //pink

delay(whole);

leftSpeakersOff();

eyesOff();

delay(whole);

rightSpeakersOn();

rightEye(0,0,100); //blue

delay(whole);

rightSpeakersOff();

eyesOff();

delay(whole);

}

// delay(32);

for (int i = 0; i < 2; i++) //2X quarter-note (go to "A")

{

leftSpeakersOn();

leftEye(100,100,0); //yellow

rightEye(0,255,255);

delay(half);

rightEye(255,255,0);

delay(half);

leftSpeakersOff();

leftEyeOff();

rightEye(255,100,100);

delay(half);

rightEye(50,50,255);

delay(half);

leftSpeakersOn();

leftEye(255,0,0); //different than previous

rightEye(0,255,255);

delay(half);

rightEye(255,255,0);

delay(half);

leftSpeakersOff();

leftEyeOff();

rightEye(255,100,100);

delay(half);

rightEye(50,50,255);

delay(half);

rightSpeakersOn();

rightEye(0,0,255); //make this original

leftEye(0,255,255);

delay(half);

leftEye(255,255,0);

delay(half);

rightSpeakersOff();

rightEyeOff();

leftEye(255,100,100);

delay(half);

leftEye(50,50,255);

delay(half);

rightSpeakersOn();

rightEye(0,200,0); //diff than previous

leftEye(0,255,255);

delay(half);

leftEye(255,255,0);

delay(half);

rightSpeakersOff();

rightEyeOff();

leftEye(255,100,100);

delay(half);

leftEye(50,50,255);

delay(half);

}

for (int i = 0; i < 32; i++) //32x all pulse

{

speakersOn();

eyesOn(random(255), random(255), random(255)); //separate left and right?

delay(half-2); //sound is earlier(half-1)

speakersOff();

eyesOff();

delay(half);

}

delay(60000);//end of the ride

}

MSGEQ7 tests:

if (leftspectrumValue[2] > h)

{

xSpeakerOn(3);

leftEye(20,100,0);

}

else

{

xSpeakerOff(3);

eyesOff();

}

if (leftspectrumValue[3] > h)

{

xSpeakerOn(5);

leftEye(20,100,0);

}

else

{

xSpeakerOff(5);

eyesOff();

}

if (leftspectrumValue[4] > h)

{

xSpeakerOn(7);

leftEye(20,100,0);

}

else

{

xSpeakerOff(7);

eyesOff();

}

if (leftspectrumValue[5] > h)

{

xSpeakerOn(9);

leftEye(20,100,0);

}

else

{

xSpeakerOff(9);

eyesOff();

}

if (rightspectrumValue[1] > h)

{

xSpeakerOn(2);

rightEye(20,100,0);

}

else

{

xSpeakerOff(2);

eyesOff();

}

if (rightspectrumValue[2] > h)

{

xSpeakerOn(4);

rightEye(20,100,0);

}

else

{

xSpeakerOff(4);

eyesOff();

}

if (rightspectrumValue[3] > h)

{

xSpeakerOn(6);

rightEye(20,100,0);

}

else

{

xSpeakerOff(6);

eyesOff();

}

if (rightspectrumValue[4] > h)

{

xSpeakerOn(8);

rightEye(20,100,0);

}

else

{

xSpeakerOff(8);

eyesOff();

}

if (rightspectrumValue[5] > h)

{

xSpeakerOn(10);

rightEye(20,100,0);

}

else

{

xSpeakerOff(10);

eyesOff();

}

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

int x=(spectrumValue[0]+spectrumValue[1]+spectrumValue[2]+spectrumValue[3]+

spectrumValue[4]+spectrumValue[5]+spectrumValue[6])/7;

if (x > 150)

{

SpeakersOn();

eyesOn(20,100,0);

}

else

{

SpeakersOff();

eyesOff() ;

}

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

if (leftspectrumValue[2] > h)

{

leftSpeakersOn();

leftEye(20,100,0);

}

else

{

leftSpeakersOff();

leftEyeOff();

}

if (rightspectrumValue[3] > h)

{

rightSpeakersOn();

rightEye(20,100,0);

}

else

{

rightSpeakersOff();

rightEyeOff();

}

{

if (x > 300 && x < 400)

level1();

if (x > 400 && x < 500)

level2();

if (x > 500 && x < 600)

level4();

if (x > 600 && x < 700)

level5();

if (x > 700 && x < 800)

level6();

if (x > 800 && x < 900)

level7();

}