#define SCLK 3  // (1) DFR0072 ShiftOut SCLK Serial-Clock Input
#define iCS 8     // (3) DFR0072 ShiftOut /CS Chip-Select Input set low to receive data, set high to output
#define DIN 9    // (5) DFR0072 ShiftOut DIN Serial-Data Input 

/****************************************************************************** 
Test Program for the 12C PCA9555 Board part number DFR0013 IIC TO GPIO module from dfrobot.com
16 outputs that I used to drive this relay board made in Bulgaria
http://www.denkovi.com/product/21/16-relay-board-for-your-pic-avr-project-12v.html
it's a great little expansion board that can be used to drive LEDs or anything you want.
made by [email protected]
January 07th 2011
My biggest problem was figuring out the I2C address of the PCA9555.
If there are no jumpers the address is 1 0 0 '1 1 1'
Jumpers make the address 1 0 0 '0 0 0'. This is opposite of what I expected.
******************************************************************************/ 

#include <Wire.h> 

//  with no jumpers the full address is   1 0 0 1 1 1    1 0 0 A2 A1 A0  0x27 is the default address for the DFR0013 board with no jumpers.
#define PCA9555 0x27 // 0x27 is default address for the DFR0013 board with no jumpers.
                     // 0x20 is address for the DFR0013 board with all jumpers.
// COMMAND BYTE TO REGISTER RELATIONSHIP FROM PCA9555 DATA SHEET
// At reset, the device's ports are inputs with a high value resistor pull-ups to VDD
// If relays turning on during power up are a problem. Add a pull down resistor to each relay transistor base.

#define IN_P0 0x00 // Read Input port0
#define IN_P1 0x01 // Read Input port1
#define OUT_P0 0x02 // Write Output port0
#define OUT_P1 0x03 // Write Output port1
#define INV_P0 0x04 // Input Port Polarity Inversion port0 if B11111111 is written input polarity is inverted
#define INV_P1 0x05 // Input Port Polarity Inversion port1 if B11111111 is written input polarity is inverted
#define CONFIG_P0 0x06 // Configuration port0 configures the direction of the I/O pins 0 is output 1 is input
#define CONFIG_P1 0x07 // Configuration port1 configures the direction of the I/O pins 0 is output 1 is input

#define PAUSE 200

void setup()
{
  Wire.begin(PCA9555); // join i2c bus (address optional for master) tried to get working
  write_io (CONFIG_P0, B00000000); //defines all pins on Port0 are outputs
  write_io (CONFIG_P1, B00000000); //defines all pins on Port1 are outputs  
  write_io (OUT_P0, B00000000); //clears all relays
  write_io (OUT_P1, B00000000); //clears all relays
  delay (PAUSE);
}


void loop()
{
  set_relay (0b0000000000000001);
  delay (PAUSE);
  set_relay (0b0000000000000010);
  delay (PAUSE);
  set_relay (0b0000000000000100);
  delay (PAUSE);
  set_relay (0b0000000000001000);
  delay (PAUSE);
  set_relay (0b0000000000010000);
  delay (PAUSE);
  set_relay (0b0000000000100000);
  delay (PAUSE);
  set_relay (0b0000000001000000);
  delay (PAUSE);
  set_relay (0b0000000010000000);
  delay (PAUSE);
  set_relay (0b0000000100000000);
  delay (PAUSE);
  set_relay (0b0000001000000000);
  delay (PAUSE);
  set_relay (0b0000010000000000);
  delay (PAUSE);
  set_relay (0b0000100000000000);
  delay (PAUSE);
  set_relay (0b0001000000000000);
  delay (PAUSE);
  set_relay (0b0010000000000000);
  delay (PAUSE);
  set_relay (0b0100000000000000);
  delay (PAUSE);
  set_relay (0b1000000000000000);
  delay (PAUSE);
  set_relay (0b0000000000000000);
  delay (PAUSE);
  set_relay (0b1111111111111111);
  delay (PAUSE);
  set_relay (0b0000000000000000);
  delay (PAUSE);
  set_relay (0b1111111111111111);
  delay (PAUSE);
  set_relay (0b0000000000000000);
  delay (PAUSE);
}
 
  void set_relay (word data) //requires a word for the 16 bits
 {
  write_io(OUT_P0,lowByte(data)); // send low byte
  write_io(OUT_P1,highByte(data)); // send high byte
 }

  void write_io(int command, int value)
 {
  Wire.beginTransmission(PCA9555);
  Wire.send(command),Wire.send(value); // send command then send value
  Wire.endTransmission();
 }

/* Peter Strobl Test Electronics Jan 9th 2011
   changed the original program to use the full 32 Bits from the
   IR Kit For Arduino Model: DFR0107 32 bit controller. 
   All keypresses are sent to the serial monitor at 9600 baud.
   pulseIn is always HIGH. The phototransistor in the kit does not invert the signal.
   uses pin 13 for heartbeat debug
   32 bits requires an unsigned long variable.  
*/

#define IR_BIT_LENGTH 32    // number of bits sent by IR remote
#define BIT_1 1300          // Binary 1 threshold (Microseconds)
#define BIT_0 300           // Binary 0 threshold (Microseconds)
#define BIT_START 3000      // Start bit threshold (Microseconds)

#define IR_PIN 10            // IR Sensor pin
#define LED_PIN 13          // LED goes off when signal is received

int debug = 0;              // flag as 1 to output raw IR pulse data stream length in microseconds
int output_verify = 0;      // flag as 1 to print decoded verification integers. same number for all buttons
int output_key = 0;         // flag as 1 to print decoded key integers

void setup() {
  pinMode(LED_PIN, OUTPUT);	//This shows when ready to recieve
  pinMode(IR_PIN, INPUT);
  digitalWrite(LED_PIN, LOW);
  Serial.begin(9600);
}

void loop() {
  digitalWrite(LED_PIN, HIGH);
  unsigned long key = get_ir_key();
  
  digitalWrite(LED_PIN, LOW);  // turn LED off while processing response
  do_response(key);
  delay(130);                  // 2 cycle delay to cancel duplicate keypresses
}

/*
  wait for a keypress from the IR remote, and return the
  integer mapping of that key (e.g. power button on remote returns 
  the unsigned long 4278238976)
*/

unsigned long get_ir_key() 
{
  int pulse[IR_BIT_LENGTH];
  int bits[IR_BIT_LENGTH];

  do {} //Wait for a start bit
  while(pulseIn(IR_PIN, HIGH) < BIT_START);

  read_pulse(pulse);
  pulse_to_bits(pulse, bits);
  return bits_to_int(bits);
}


/*
  use pulseIn to receive IR pulses from the remote.
  Record the length of these pulses (in ms) in an array
*/

void read_pulse(int pulse[])
{
  for (int i = 0; i < IR_BIT_LENGTH; i++)
  {
    pulse[i] = pulseIn(IR_PIN, HIGH, 10000);
  }
}

/*
  IR pulses encode binary "0" as a short pulse, and binary "1"
  as a long pulse.  Given an array containing pulse lengths,
  convert this to an array containing binary values
*/

void pulse_to_bits(int pulse[], int bits[])
{
  if (debug) { Serial.println("-----"); }
  for(int i = 0; i < IR_BIT_LENGTH; i++) 
  {
    if (debug) { Serial.println(pulse[i]); }
    if(pulse[i] > BIT_1) //is it a 1?
    {
      bits[i] = 1;
    }  
    else if(pulse[i] > BIT_0) //is it a 0?
    {
      bits[i] = 0;
    } 
    else //data is invalid...
    {
      Serial.println("Error");
    }
  }
}

/*
  convert an array of binary values to a single base-10 integer
*/

unsigned long bits_to_int(int bits[])
{
  unsigned long result = 0;
  unsigned long seed = 1;
  
  //Convert bits to integer
  for(int i = 0 ; i < IR_BIT_LENGTH ; i++) 
  {		  
    if(bits[i] == 1) 
    {
	result += seed;
    }   
    seed *= 2;
  }
  return result;
}


/* 
  respond to specific remote-control keys with different behaviors
*/

void do_response(unsigned long key)
{  
  
  if (output_key)
   {
      Serial.print("Key ");
      Serial.println(key);
   }
  
  switch (key)
  {
    case 4278238976:  // turns on UUT power
      Serial.println("POWER");
      break;

    case 4244815616:  // FUNC/STOP turns off UUT power
      Serial.println("FUNC/STOP");
      break;

    case 4211392256:  // |<< ReTest failed Test
      Serial.println("|<<");
      break;

    case 4194680576:  // >|| Test
      Serial.println(">||");
      break;

    case 4177968896:  // >>| perform selected test number
      Serial.println(">>|");
      break;

    case 4261527296:  // VOL+ turns on individual test beeper
      Serial.println("VOL+");
      break;

    case 4127833856:  // VOL- turns off individual test beeper
      Serial.println("VOL-");
      break;

    case 4144545536:  // v scroll down tests
      Serial.println("v");
      break;

    case 4111122176:  // ^ scroll up tests
      Serial.println("^");
      break;

    case 4060987136:  // EQ negative tests internal setup
      Serial.println("EQ");
      break;

    case 4044275456:  // ST/REPT Positive tests Select Test and Repeat Test
    Serial.println("ST/REPT");
      break;

    case 4077698816:  // 0
      Serial.println("0");
      break;

    case 4010852096:  // 1
      Serial.println("1");
      break;

    case 3994140416:  // 2
      Serial.println("2");
      break;

    case 3977428736:  // 3
      Serial.println("3");
      break;

    case 3944005376:  // 4
      Serial.println("4");
      break;

    case 3927293696:  // 5
      Serial.println("5");
      break;

    case 3910582016:  // 6
      Serial.println("6");
      break;

    case 3877158656:  // 7
      Serial.println("7");
      break;

    case 3860446976:  // 8
      Serial.println("8");
      break;

    case 3843735296:  // 9
      Serial.println("9");
      break;
     
    default:
      {
        Serial.print("Key ");
        Serial.print(key);
        Serial.println(" not programmed");
      }
    break;
  }
}