// _Simple_ half-stepping driver for a unipolar stepper motor
// 
// Written by Matt Mets in 2010
//
// Generates a waveform that looks like this:
//
//    ______
// A |      |_____________
//   
//         ______
// B _____|      |________
//   
//              ______  
// C __________|      |___
//   
//   _               _____  
// D  |_____________|     
 
 
// Digital I/O pins to which the n-channel FET drivers are connected
unsigned char motorPins[] = {2, 4, 5, 3};
 
 
void setup() {
  // Set all the pins to outputs, and turn them off.  
  for (unsigned char i = 0; i < 4; i++) {
    pinMode(motorPins[i], OUTPUT);
    digitalWrite(motorPins[i], LOW);
  }
}
 
// number of times the complete cycle is repeated
#define rotations 50
 
// microsecond delay between half-steps
#define delayLength 2000
 
void loop() {
  // walk forward in half-steps
  for (unsigned char j = 0; j < rotations; j++) {
    for (unsigned char i = 0; i < 4; i++) {
      digitalWrite(motorPins[(i+1)%4], HIGH);
      delayMicroseconds(delayLength);
      digitalWrite(motorPins[i], LOW);
      delayMicroseconds(delayLength);
    }
  }
 
  delay(100);
 
  // then backward
  for (unsigned char j = 0; j < rotations; j++) {
    for (unsigned char i = 0; i < 4; i++) {
      digitalWrite(motorPins[3 - ((i+1)%4)], HIGH);
      delayMicroseconds(delayLength);
      digitalWrite(motorPins[3-i], LOW);
      delayMicroseconds(delayLength);
    }
  }
 
  delay(100);
}

// Sketch to convert an older electric organ (Eminent S20) into a MIDI instrument.
// By Matt Mets, completed in 2009
//
// This code is released into the public domain.  Attribution is appreciated.
//
// MIDI source code from the ITP website:
// http://itp.nyu.edu/physcomp/Labs/MIDIOutput
 
#include <Wire.h>
 
 
#define LEDpin 13                  // Just the standard output LED
#define volumePedal 1              // The analog input for the volume control
 
char velocity;                     // Use the foot pedal to determine this
 
// Define the MIDI channels that each instrument transmits on
#define keyboardChannel 0
 
// Number of key banks to scan.  There are eight 'normal' key banks, and 2 special ones.
#define numKeyBanks 8
#define numKeysPerBank 12
 
// Lookup table, used to determine the select line to turn on to read the keys in that key bank.
static char keyBankSelectLines[] = {2,3,4,5,6,7,8,11};
 
// Storage for the previous value of each bank of keys.  There are 10 access lines, with a maximum of 12 inputs per line.
// The 12 bits of data on each line are split into low and high banks.
unsigned char noteStatesL[numKeyBanks];
unsigned char noteStatesH[numKeyBanks];
 
// Storage for the instrument data associated with each key.  Must be filled in at startup.
unsigned char noteChannels[numKeyBanks][numKeysPerBank];
unsigned char noteValues[numKeyBanks][numKeysPerBank];
 
 
// Initialize IO ports
void setup()
{
  // Setup the I2C bus (analog pins 4&5) in master mode.  This bus is used to talk to the IO expander chips.
  Wire.begin();
 
  //  Set the serial port to the correct baud rate for MIDI
  Serial.begin(31250);
 
  // Set all initial note bank vales to 0
  for (unsigned int i = 0; i < numKeyBanks; i++) {
    noteStatesL[i] = 0;
    noteStatesH[i] = 0;
  }
 
  pinMode(LEDpin, OUTPUT);    // Status LED
 
  // Set all of the bank select lines to outputs
  for (unsigned char bankNo = 0; bankNo < numKeyBanks; bankNo++) {
    pinMode(keyBankSelectLines[bankNo], OUTPUT);
  }
 
  // Set up the instrument data for the keys
 
  // first off, clear everything.
  for (unsigned char bank = 0; bank < numKeyBanks; bank ++) {
    for (unsigned char key = 0; key < numKeysPerBank; key++) {
      noteChannels[bank][key] = 0;
      noteValues[bank][key] = 0;
    }
  }
 
  // The bottom half of the keyboard comprised of banks 4-6, starting at F
  unsigned char noteValue = 24;    // Octave 2, C note
  for (unsigned char bank = 4; bank < 7; bank ++) {
    for (unsigned char key = 0; key < 12; key++) {
      noteChannels[bank][key] = keyboardChannel;
      noteValues[bank][key] = noteValue++;
    }
  }
 
  // The top keyboard row is comprised of banks 0-3, starting at F
  for (unsigned char bank = 0; bank < 4; bank ++) {
    for (unsigned char key = 0; key < 12; key++) {
      noteChannels[bank][key] = keyboardChannel;
      noteValues[bank][key] = noteValue++;
    }
  }
  // And one extra one on bank 9 note 1
  noteChannels[7][1] = keyboardChannel;
  noteValues[7][1] = noteValue++;
}
 
//  Send a MIDI command.
//  cmd is the command and channel (0x90 for channel 1 note on)
//  data1 is the note
//  data2 is the velocity
void midiCommand(char cmd, char data1, char data2) {
  Serial.print(cmd, BYTE);
  Serial.print(data1, BYTE);
  Serial.print(data2, BYTE);
}
 
// Map an integer into a charater given a set range
unsigned char mapInteger(int input, int min, int max) {
  return (((input - min)*255)/(max-min));
}
 
 
// Main loop
unsigned char newNoteStateL;
unsigned char newNoteStateH;
 
void loop()
{ 
  // Read the velocity in
//  velocity = mapInteger(analogRead(volumePedal),400,900);
  velocity = 90;
 
  for (char bankNo = 0; bankNo < numKeyBanks; bankNo++) {
 
    digitalWrite(keyBankSelectLines[bankNo], HIGH);    // Select the key bank
 
    Wire.requestFrom(0x38, 1);                      // Read the low data
    while (Wire.available()) {
      newNoteStateL = Wire.receive();
    }
 
    Wire.requestFrom(0x39, 1);                      // Read the high data
    while (Wire.available()) {
      newNoteStateH = Wire.receive();
    }
 
    digitalWrite(keyBankSelectLines[bankNo], LOW);     // Deselect the key bank
 
    if (newNoteStateL != noteStatesL[bankNo]) {      // Check if any notes in this bank are different
      char stateDelta = newNoteStateL ^ noteStatesL[bankNo];
      for (unsigned char i = 0; i < 8; i++) {
        if ((stateDelta >> i) & 1) {
          if ((newNoteStateL >> i) & 1) {
            // Send a MIDI on message
            midiCommand(0x90 + noteChannels[bankNo][i], noteValues[bankNo][i], velocity);
          }
          else {
            // Send a MIDI off message
            midiCommand(0x80 + noteChannels[bankNo][i], noteValues[bankNo][i], velocity);
          }
        }
      }
    }
 
    if (newNoteStateH != noteStatesH[bankNo]) {      // Check if any notes in this bank are different
      digitalWrite(LEDpin, HIGH);
      char stateDelta = newNoteStateH ^ noteStatesH[bankNo];
      for (unsigned char i = 0; i < 8; i++) {
        if ((stateDelta >> i) & 1) {
          if ((newNoteStateH >> i) & 1) {
            // Send a MIDI on message
            midiCommand(0x90 + noteChannels[bankNo][i+8], noteValues[bankNo][i+8], velocity);
          }
          else {
            // Send a MIDI off message
            midiCommand(0x80 + noteChannels[bankNo][i+8], noteValues[bankNo][i+8], velocity);
          }
        }
      }
    }
 
    noteStatesL[bankNo] = newNoteStateL;
    noteStatesH[bankNo] = newNoteStateH;
  }
}

#include <iostream>
#include <fstream>
#include <cmath>            // for square root
#include <sys/stat.h>       // For file size
#include "easybmp/EasyBMP.h"
 
int main(int argc, char** argv) {
    // Rom info
    char fileName[] = "smb.nes";
 
    // Desired aspect ratio
    float aspectRatio =  1.333;
 
    // Determine the file size
    int romByteSize = 0;
 
    struct stat results;
 
    if (stat(fileName, &results) == 0) {
        romByteSize = results.st_size;
    }
    else {
        std::cout << "Sorry, could not determine file length!" << std::endl;
        return 1;
    }
 
    // Determine the height and with to achieve the proper aspect ratio
    // we know:
    //    h/w = aspectRatio/8
    //    h*w = romByteSize
    // So:
    //    h = aspectRatio*w
    //    h = romByteSize/w
    //    w^2 = romByteSize / (aspectRatio/8)
 
    int imageWidth = (int)(sqrt(romByteSize / (aspectRatio/8))+.5);
    int imageHeight = (aspectRatio)*imageWidth - (int((aspectRatio)*imageWidth)%8) + 8;
 
    std::cout << "romByteSize=" << romByteSize
              << " imageWidth=" << imageWidth
              << " imageHeight=" << imageHeight
              << std::endl;
 
    // Open the binary
    std::ifstream myFile (fileName, std::ios::in | std::ios::binary);
 
    if (!myFile) {
        std::cout << "Sorry, couldn't open file for reading!" << std::endl;
        return 1;
    }
 
    // Create a bitmap to hold the image
    BMP Output;
    Output.SetSize( imageWidth, imageHeight );
    Output.SetBitDepth( 1 );
 
    // Copy the image data over, byte by byte
    RGBApixel blackPixel = {0,0,0,0};
 
    for (int pos = 0; pos < romByteSize; pos++) {
        char byte;
 
        if (!myFile.read (&byte, 1)) {
            std::cout << "read error, bailing.  pos=" << pos << std::endl;
            return 1;
        }
 
        int Col = pos%imageWidth;
        int baseRow = (pos/imageWidth)*8;
        for (int i = 0; i < 8; i++) {
            if ((byte >> (7-i)) & 1) {
 
                Output.SetPixel( Col, baseRow + i, blackPixel );
            }
        }
    }
 
    // Then write it to a file
    Output.WriteToFile( "rom_image.bmp" );
 
    return 0;
}