// Connect the distance sensor to this input pin
#define sensorInputPin 0
 
// This stores the state that the headphones were in the last
// time we checked them
boolean lastHeadphonesOn;
 
// Return true if the headphones were just taken off or put back on.
boolean checkHeadphoneState() {
 
  // If the sensor value is really high, it means that nothing
  // is near it, so the headphones must not be on your head.
  int sensorIn = analogRead(sensorInputPin);
  boolean headphonesOn = sensorIn < 800;
 
  // If our results are different from the last time we checked,
  // return true.
  if (headphonesOn != lastHeadphonesOn) {
    lastHeadphonesOn = headphonesOn;
    return true;
  }
 
  // Otherwise, return false.
  lastHeadphonesOn = headphonesOn;
  return false;
}
 
void setup() {
  Serial.begin(9600);
}  
 
void loop() {
  if (checkHeadphoneState()) {
    if (lastHeadphonesOn) {
      // headphones just put on
      Serial.println("headphones on!");
    }
    else {
      // headphones just removed
      Serial.println("headphones off!");
    } 
  }
}

// Tell processing how to use a serial port
import processing.serial.*;
Serial myPort;
 
void setup() {
  // Open up the first available serial port, and set it to 9600 baud
  myPort = new Serial(this, Serial.list()[0], 9600);
}
 
void draw() {
    // Read from the serial port until we get a linefeed
    int lf = 10;
    byte[] inBuffer = new byte[200];
    myPort.readBytesUntil(lf, inBuffer);
 
    // If we actually got some text, check if it contains a message we were
    // waiting for
    if (inBuffer != null) {
      String myString = new String(inBuffer);
      if (myString.contains("headphones on!")) {
        // Hooray! Turn the music on
        println("Headphones on!!!");
        // Run the Banshee music program with the play command specified.
        // If banshee was already running, it starts up the music again.
        try{
          Runtime.getRuntime().exec("banshee --play");
        }
          catch(java.io.IOException e){
          println(e);
        }
      }
      else if (myString.contains("headphones off!")) {
        println("Headphones off!!!");
        // Run the Banshee music program with the pause command specified.
        // If banshee was already running, it just pauses the music.
        try{
          Runtime.getRuntime().exec("banshee --pause");
        }
          catch(java.io.IOException e){
          println(e);
        }
      }
    }
}

/////////////////////////////////////////////////////////////////////////////
// Include files
// These lines allow us to use code routines (libraries) from other files,
// so that we don't have to write everything by ourselves.
/////////////////////////////////////////////////////////////////////////////
 
#include <p18lf25k22.h>	    // This file includes definitions for all of the
                            // registers on our chip
#include <stdio.h>          // For the sprintf() function
 
#define __18LF25K80
#include <i2c.h>
 
/////////////////////////////////////////////////////////////////////////////
// Pragma statements
// These lines tell the microcontroller what configuration to use when it
// when it turns on. The most important part for now is to tell the
// microcontroller what to use for a clock input.
/////////////////////////////////////////////////////////////////////////////
 
// Use the internal oscillator as a clock
#pragma config FOSC = INTIO67		// Use internal clock, don't output 
//#pragma config FOSC = INTIO7        // Use internal clock, output on RA6
 
// Configure it to run at 16 MHz
#pragma config PLLCFG = OFF
 
// Allow the program to turn on the watchdog timer. The watchdog is a
// a special feature of the processor, that runs separately from the main
// program and can be used to wake up the processor after a certain amount of time.
#pragma config WDTEN = OFF
 
// Set the watchdog timer prescaler to 1.
#pragma config WDTPS = 256
 
 
// Fix a compiler bug
#undef INTCON
#undef INTCONbits
 
/////////////////////////////////////////////////////////////////////////////
// Function declarations
// Declare any user functions that you want to use here
/////////////////////////////////////////////////////////////////////////////
void main (void);
void setup(void);
void loop(void);
 
void receive_interrupt(void);
 
unsigned char receiveCharacter = 0;    // Stores the last character that was
                                       // received by the serial port
unsigned char stayAwakeCount = 0;      // 5 second countdown to keep the
                                       // chip from sleeping
 
unsigned char measureSwitch(unsigned char channel);
 
 
#define PINCOUNT 8
 
int lastState[PINCOUNT];
unsigned char offCount[PINCOUNT];
 
// Pins:
// 2 4 7 14 21 23 25 15
 
unsigned char inputADC[PINCOUNT] =      { 0, 2, 4,15,12, 8,11,16};
unsigned char inputPorts[PINCOUNT] =    { 0, 0, 0, 2, 1, 1, 1, 2};
unsigned char inputPins[PINCOUNT] =     { 0, 2, 5, 3, 0, 2, 4, 4};
 
unsigned char noteChannels[PINCOUNT] =  { 0, 0, 0, 0, 0, 0, 0, 0};
//unsigned char noteKeys[PINCOUNT] =      {49,51,54,56,58,61,63};
unsigned char noteKeys[PINCOUNT] =      {49,51,53,54,56,58,60,61};
 
 
int Vread[PINCOUNT];
 
 
#define PRESSED 0
#define RELEASED 1
#define NOCHANGE 2
 
/////////////////////////////////////////////////////////////////////////////
// Function definitions
// Define any user functions that you want to use here
/////////////////////////////////////////////////////////////////////////////
 
// Configure the high interrupt to call the high_isr() function
// From MPLAB C18 C Compiler Users Guide, Page 29
#pragma code low_vector=0x08
void low_interrupt (void)
{
_asm GOTO receive_interrupt _endasm
}
#pragma code /* return to the default code section */
 
 
 
// The main() function is where the program 'starts' when the microcontroller
// is turned on. For this project, we will use it to call setup() and loop()
// functions, then use those similar to an Arduino sketch.
void main ( void )
{
    // Call the setup function once to put everything in order
    setup();
 
    // Then call the loop() function over and over
    while (1)
    {
        loop();
    }
}
 
 
 
// Function to write a character string to the serial port, from:
// C:\MCC18\src\pmc_common\USART\u1puts.c
void puts1USART( char *data )
{
    do
    { // Transmit a byte
        while(!TXSTA1bits.TRMT);
        TXREG1 = *data; // Write the data byte to the USART2
    } while( *data++ );
}
 
 
// Map function, from:
// http://www.arduino.cc/en/Reference/Map
long map(long x, long in_min, long in_max, long out_min, long out_max)
{
    return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;
}
 
 
// Function to write a single byte to a device on the i2c bus
void i2cWriteByte( char byte )
{
    // Send the first byte of address, and wait for ack
    SSPBUF = byte;
 
    // Wait for idle
    while ( ( SSPCON2 & 0x1F ) || ( SSPSTATbits.R_W ) )
        continue;
}
 
 
// This function is called once, when the microcontroller is turned on.
void setup( void ) {
    int i;
 
  // Processor configuration
 
    // Configure the oscillator to run at 16 MHz
    OSCCONbits.IRCF = 111;      // 16 MHz
//    OSCCONbits.IRCF = 101;      // 4 MHz
 
    ANSELA = 0;
    TRISA = 0;
    PORTA = 0;
 
    ANSELB = 0;
    TRISB = 0;
    PORTB = 0;
 
    ANSELC = 0;
    TRISC = 0;
    PORTC = 0;
 
  // ADC configuration
    ADCON2bits.ADFM=1;        // Right Justified
 
    // Set the speed that the ADC should capture data
//    ADCON2bits.ACQT=0b110;    // Acquisition time
//    ADCON2bits.ADCS=0b010;    // Fosc/8 (?)
 
    ADCON2bits.ACQT=0b111;    // Acquisition time
    ADCON2bits.ADCS=0b010;    // Fosc/32
 
 
    ADCON0bits.ADON = 1;      // Turn the ADC on
 
 
  // Serial port configuration
    TRISCbits.TRISC6 = 0;	  // Make TX pin an output
    TRISCbits.TRISC7 = 1;	  // and RX pin an input
    ANSELCbits.ANSC7 = 0;     // Specifically, an analog input
 
    // Configure the serial port to run at 9600 baud
    // (see manual, page 275)
 
    // for 16 MHz clock
    SPBRG1 = 25;    
    TXSTA1bits.BRGH = 0;      // Baud rate select
    BAUD1CONbits.BRG16 = 0;
 
    // Turn on the serial port
    RCSTA1bits.CREN = 1;      // Enable receive mode on the serial port
    TXSTA1bits.TXEN = 1;      // Enable transmitter
    RCSTA1bits.SPEN = 1;      // Enable receiver
 
    // CTMU configuration
    CTMUCONH = 0x00;
 
    //make sure CTMU is disabled
    CTMUCONL = 0x90;
 
    //CTMU continues to run when emulator is stopped,CTMU continues
    //to run in idle mode,Time Generation mode disabled, Edges are blocked
    //No edge sequence order, Analog current source not grounded, trigger
    //output disabled, Edge2 polarity = positive level, Edge2 source =
    //source 0, Edge1 polarity = positive level, Edge1 source = source 0,
 
    CTMUICONbits.IRNG = 0x01;  // .55uA current source
//    CTMUICONbits.ITRIM = 0b111111;	// half power
 
    // Configure the pins we are going to use
    for(i = 0; i < PINCOUNT; i++) {
        lastState[i] = 0;
        offCount[i] = 0;
 
        switch(inputPorts[i]) {
          case 0:  // A
            ANSELA =  ANSELA | 1<<inputPins[i];
//            TRISA = TRISA | 1<<inputPins[i];
            break;
          case 1:  // B
            ANSELB =  ANSELB | 1<<inputPins[i];
//            TRISB = TRISB | 1<<inputPins[i];
            break;
          case 2:  // C
            ANSELC =  ANSELC | 1<<inputPins[i];
//            TRISC = TRISC | 1<<inputPins[i];
            break;
        }
    }
}
 
unsigned int logCount = 0;     // Number of samples that the logger has acquired
int logInterval = 10; // Number of seconds between measurements
char logging = 0;     // Specifies whether we are actively logging or not
int intervalCounter = 0;
 
// This function is called repeatedly
int in;
char buffer[100];
 
void loop(void) {
	unsigned char i;
 
    for( i = 0; i < PINCOUNT; i++) {
//i = 1;
        in = measureSwitch(i);
            if (in != RELEASED) {
                offCount[i] = 0;
            }
 
            if (in == PRESSED && in != lastState[i]) {
                lastState[i] = in;
 
                // Note on
                buffer[0] = 0x90 + noteChannels[i];
                buffer[1] = noteKeys[i];
                buffer[2] = 127;
                buffer[3] = 0x00;
                puts1USART(buffer);
 
//        sprintf(buffer,(const rom far char *)"TOUCH_ON channel=%hu value=%i\r\n\x00", i, Vread[i]);
//        puts1USART(buffer);
 
            } else if (in == RELEASED && in != lastState[i]) {
                if (offCount[i] < 3) {
                    offCount[i]++;
                }
                else {
                    lastState[i] = in;
                    offCount[i] = 0;
 
                    // Note off
                    buffer[0] = 0x80 + noteChannels[i];
                    buffer[1] = noteKeys[i];
                    buffer[2] = 127;
                    buffer[3] = 0x00;
                    puts1USART(buffer);
                }
 
//        sprintf(buffer,(const rom far char *)"TOUCH_OFF channel=%hu value=%i\r\n\x00", i, Vread[i]);
//        puts1USART(buffer);
 
            }
        }
}
 
 
// This function is called whenever a high interrupt occurs. For the
// datalogger project, this only happens when the EUSART (serial port)
// receives a character.
#pragma interruptlow receive_interrupt
void receive_interrupt (void)
{
    // Read the character in from the serial module. If the serial port just
    // woke up the microcontroller, this will be garbage.
    receiveCharacter = RCREG;
 
    // If we just woke up from sleeping, discard the first character because
    // it is probably corrupted
    if (stayAwakeCount == 0) {
        receiveCharacter = 0;
    }
 
    // Start a counter to wait 5 seconds before sleeping, in order to give
    // the user time to send a serial command
    stayAwakeCount = 5;
}
 
 
// PIC 18lf22 datasheet, page 326
 
#define COUNT 150                     //@ 16MHz = 125uS.
#define DELAY for(i=0;i<COUNT;i++) {}
 
/*
#define OPENSW 1000                   //Un-pressed switch value
#define TRIP 200                      //Difference between pressed
                                      //and un-pressed switch
#define HYST 65                       //amount to change
*/
#define TRIPOFF  1000                 // 
#define TRIPON   800
                                      //from pressed to un-pressed
 
 
unsigned char measureSwitch(unsigned char channel)
{
    int i, j;
 
        switch(inputPorts[channel]) {
          case 0:  // A
            TRISA = TRISA | 1<<inputPins[channel];
            break;
          case 1:  // B
            TRISB = TRISB | 1<<inputPins[channel];
            break;
          case 2:  // C
            TRISC = TRISC | 1<<inputPins[channel];
            break;
        }
 
 
    ADCON0bits.CHS = inputADC[channel];
//    ADCON0bits.ADON = 1;      // Turn the ADC on
    DELAY;
 
    //assume CTMU and A/D have been setup correctly
    //see Example 25-1 for CTMU & A/D setup
 
    CTMUCONHbits.CTMUEN = 1;      // Enable the CTMU
    CTMUCONLbits.EDG1STAT = 0;    // Set Edge status bits to zero
    CTMUCONLbits.EDG2STAT = 0; 
    CTMUCONHbits.IDISSEN = 1;     //drain charge on the circuit
    DELAY;
    DELAY;
 
    CTMUCONHbits.IDISSEN = 0;     //end drain of circuit
 
    CTMUCONLbits.EDG1STAT = 1;    //Begin charging the circuit
                                  //using CTMU current source
    DELAY;                        //wait for 125us
    CTMUCONLbits.EDG1STAT = 0;    //Stop charging circuit
 
    PIR1bits.ADIF = 0;            // Make sure adc interrupts are disabled
    ADCON0bits.GO=1;              //and begin A/D conv.
    while(!PIR1bits.ADIF);        //Wait for A/D convert complete
 
    Vread[channel] = ADRES;       //Get the value from the A/D
 
 
    CTMUCONHbits.CTMUEN = 0;      // Disable the CTMU
 
    switch(inputPorts[channel]) {
      case 0:  // A
        TRISA = 0;
        break;
      case 1:  // B
        TRISB = 0;
        break;
      case 2:  // C
        TRISC = 0;
        break;
    }
 
    if(Vread[channel] < TRIPON) 
    {
//        sprintf(buffer,(const rom far char *)"TOUCH_ON  channel=%hu value=%i\r\n\x00", channel, Vread[channel]);
//        puts1USART(buffer);
        return PRESSED;
    }
    else if(Vread[channel] > TRIPOFF )
    {
//        sprintf(buffer,(const rom far char *)"TOUCH_OFF channel=%hu value=%i\r\n\x00", channel, Vread[channel]);
//        puts1USART(buffer);
        return RELEASED;
    }
    else
    {
//        sprintf(buffer,(const rom far char *)"NO_CHANGE channel=%hu value=%i\r\n\x00", channel, Vread[channel]);
//        puts1USART(buffer);
        return NOCHANGE;
    }
}

import processing.serial.*;
 
LolShieldBuffer lolShield;
PFont fontA;
 
void setup()
{
  size(14, 9);
 
  // Load the font. Fonts must be placed within the data 
  // directory of your sketch. A font must first be created
  // using the 'Create Font...' option in the Tools menu.
  fontA = loadFont("LucidaSans-9.vlw");
 
  // Set the font and its size (in units of pixels)
  textFont(fontA, 9);
 
  // I know that the first port in the serial list on my mac
  // is always my  FTDI adaptor, so I open Serial.list()[0].
  // On Windows machines, this generally opens COM1.
  // Open whatever port is the one you're using.
  String portName = Serial.list()[0];
  print(portName);
  lolShield = new LolShieldBuffer(this, portName);
}
 
int i = 0;
 
void draw()
{
  background(0);
 
  fill(255);
 
  text("The time is now " + hour() + ":" + minute(), i, 8);
 
//  lolShield.sendWindow(mouseX,mouseY, 14, 9);
  lolShield.sendWindow(0,0, 14, 9);
 
  i--;
  if (i < -130) {i = 14;}
  delay(50);
}

#include "Charliplexing.h"
#include "Font.h"
#include "WProgram.h"
 
// Inspired by Video Peggy:
// http://www.planetclegg.com/projects/QC-Peggy.html
 
void setup()                    // run once, when the sketch starts
{
  Serial.begin(115200);
 
  LedSign::Init(DOUBLE_BUFFER);
//  LedSign::Init();
}
 
int state = 0; 
int counter = 0;
const uint8_t DISP_BUFFER_SIZE = 9*2;
 
void loop()                     // run over and over again
{ 
  while( !Serial.available()) {}
  uint8_t c = Serial.read();
 
  // very simple state machine to look for 6 byte start of frame
  // marker and copy bytes that follow into buffer
  if (state < 6) 
  {
 
    // must wait for 0xdeadbeef to start frame.
    // note, I look for two more bytes after that, but
    // they are reserved for future use. 
 
    if (state == 0 && c == 0x12) state++;
    else if (state ==1 && c == 0x34) state++;
    else if (state ==2 && c == 0x56) state++;
    else if (state ==3 && c == 0x78) state++;
    else if (state ==4 && c == 0x1) state++;
    else if (state ==5)  // dont care what 6th byte is 
    {
      state++;
      counter = 0;
    }
    else state = 0; // error: reset to look for start of frame
  }
  else 
  {
    // inside of a frame, so write to the buffer
    uint8_t row = counter / 2;
    uint8_t col = (counter % 2)*8;
    uint8_t length = (col==0?8:6);
    for (uint8_t colOffset = 0;  colOffset < length ; colOffset++ ) {
      LedSign::Set(col+colOffset, row, c >> (7 - colOffset) & 1);
    }
 
    counter++;
    if (counter >= DISP_BUFFER_SIZE)
    {
      // buffer filled, so reset everything to wait for next frame
      state = 0;
      LedSign::Flip();
    }
  }
}

import processing.serial.*;
 
class LolShieldBuffer
{
  Serial serial;
 
  int ledWidth = 14;
  int ledHeight = 9;
  int ledFrameSize = 9*2;
 
 
  LolShieldBuffer(PApplet parent, String portName) {
    serial = new Serial(parent, portName, 115200);
  }
 
  void sendWindow(int x, int y, int w, int h) {
 
    PImage img = get(x, y, w, h);
//    img.resize(ledWidth, ledHeight);
 
    char[] frame = new char[ledFrameSize];
 
    // Grab a 14x9 window
    for (int row = 0; row < ledHeight; row++) {
      char buf = 0;
      for (int col = 0; col < 8; col++) {
        buf = (char)(buf << 1);
        buf |= (brightness(img.pixels[row*ledWidth+col])>127) ? 1:0;
      }
      frame[row*2] = buf;
 
      for (int col = 0; col < 6; col++) {
        buf = (char)(buf << 1);
        buf |= (brightness(img.pixels[row*ledWidth+8+col])>127) ? 1:0;
      }
      buf = (char)(buf << 2);
 
      frame[row*2+1] = buf;
    }
 
    sendFrame(frame);
  }
 
 
  void sendFrame(char[] frame) {
    byte[] magicNumber = {0x12, 0x34, 0x56, 0x78, 0x1, 0x0};
 
    serial.write(magicNumber);
 
    // TODO: Drop 9*2 magic number
    for(int index = 0; index < ledFrameSize; index++) {
      serial.write(frame[index]);
    }
  }
}

#!/usr/bin/python
# Python script to convert a 14x9 pixel animated gif into a format that can
# be displayed on the LoLShield.
#
# Requires Python and the Python Imaging Library (PIL)
# It would be nice if this was available using a more common language.
 
import sys, os, Image
 
class ImageSequence:
    def __init__(self, im):
        self.im = im
    def __getitem__(self, ix):
        try:
            if ix:
                self.im.seek(ix)
            return self.im
        except EOFError:
            raise IndexError # end of sequence
 
# Open image
filename = sys.argv[1]
filenameBase = os.path.splitext(os.path.split(filename)[1])[0]
im = Image.open(filename)
 
# Print the variable declaration
print "uint16_t " + filenameBase + "[][9] PROGMEM = {"
 
# For each frame in the image, convert it to black & white, then into the
# LoLShield format
for frame in ImageSequence(im):
    # Convert to black and white
    converted = frame.convert("1")
 
    print " {",
    frameString = converted.tostring()
 
    # For each row in the image
    for row in range (0, 9):
        charA = ord(frameString[row*2])
        charB = ord(frameString[row*2 + 1])
 
        rowTotal = 0
        # Handle the first 8 bits
        for col in range (0, 8):
            shiftAmount = 7-col
            rowTotal += ((charA >> shiftAmount) & 1) * 2**col
        # Then the next 6
        for col in range (0, 6):
            shiftAmount = 7-col
            rowTotal += ((charB >> shiftAmount) & 1) * 2**(col+8)
        # And output the total for this row
        print rowTotal, ",",
    print "},"
print "};"