/*
 
    Holtech HT1632 Driver Class (Header)
    Values taken from Datasheet...
 
*/
 
#ifndef HT1632_h
#define HT1632_h
 
//Data Mode
#define HT1632_CTL_COMMAND      0x04    //Preceeds all _COMMANDS_ to the system
#define HT1632_CTL_WRITE        0x05    //Write data to the RAM
#define HT1632_CTL_READ         0x06    //Read data from the RAM
 
//Command Mode
#define HT1632_CMD_SYSDIS       0x00    //Turn off system oscillator and LED duty cycle generator
#define HT1632_CMD_SYSEN        0x01    //Turn on system oscillator
#define HT1632_CMD_LEDOFF       0x02    //Turn off LED duty cycle generator
#define HT1632_CMD_LEDON        0x03    //Turn on LED duty cycle generator
#define HT1632_CMD_BLINKOFF     0x08    //Turn off blinking function
#define HT1632_CMD_BLINKON      0x09    //Turn on blinking function
#define HT1632_CMD_SLAVEMODE    0x10    //Set slave mode and clock source from external clock, the system clock input from OSC pin and synchronous signal input from SYN pin
#define HT1632_CMD_RCMASTER     0x18    //Set master mode anc clock source from on-chip RC oscillator, the system clock output to OSC pin and synchronous signal output SYN pin
#define HT1632_CMD_EXTCLK       0x1C    //System clock source, external
#define HT1632_CMD_COM00        0x20    //N-MOS open drain output and 8 COM option
#define HT1632_CMD_COM01        0x24    //N-MOS open drain output and 8 COM option
#define HT1632_CMD_COM10        0x28    //P-MOS open drain output and 8 COM option
#define HT1632_CMD_COM11        0x2C    //P-MOS open drain output and 16 COM option
 
//Command Mode - PWM Settings
#define HT1632_CMD_PWM01        0xA0    //PWM 1/16 Duty
#define HT1632_CMD_PWM02        0xA1    //PWM 2/16 Duty
#define HT1632_CMD_PWM03        0xA2    //PWM 3/16 Duty
#define HT1632_CMD_PWM04        0xA3    //PWM 4/16 Duty
#define HT1632_CMD_PWM05        0xA4    //PWM 5/16 Duty
#define HT1632_CMD_PWM06        0xA5    //PWM 6/16 Duty
#define HT1632_CMD_PWM07        0xA6    //PWM 7/16 Duty
#define HT1632_CMD_PWM08        0xA7    //PWM 8/16 Duty
#define HT1632_CMD_PWM09        0xA8    //PWM 9/16 Duty
#define HT1632_CMD_PWM10        0xA9    //PWM 10/16 Duty
#define HT1632_CMD_PWM11        0xAA    //PWM 11/16 Duty
#define HT1632_CMD_PWM12        0xAB    //PWM 12/16 Duty
#define HT1632_CMD_PWM13        0xAC    //PWM 13/16 Duty
#define HT1632_CMD_PWM14        0xAD    //PWM 14/16 Duty
#define HT1632_CMD_PWM15        0xAE    //PWM 15/16 Duty
#define HT1632_CMD_PWM16        0xAF    //PWM 16/16 Duty
 
#include "wProgram.h"
 
class HT1632 {
    public:
        HT1632(byte data, byte wclock, byte chip0, byte chip1=NULL, byte chip2=NULL, byte chip3=NULL, byte rclock=NULL);
        void ChipSelect(byte chip);
        void ChipRelease(byte chip);
        void SendCommand(byte command, byte chip=0);
        void WriteBits(byte bits, byte mask);
        byte ReadData(byte address, byte chip);
        void Clear(byte chip=0);
        void WriteData(byte address, byte data, byte chip=0);
        void Init(byte chip=0);
        void BlinkMode(bool blink=false, byte chip=0);
 
    private:
        byte _DATA;
        byte _WCLOCK;
        byte _RCLOCK;
        byte _CHIP0;
        byte _CHIP1;
        byte _CHIP2;
        byte _CHIP3;
};
 
#endif

/*
 
    Holtech HT1632 Driver Class
    Some functionality inspired by westfw from this thread: http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1225239439
 
*/
 
#include "wProgram.h"
#include "HT1632.h"
 
HT1632::HT1632(byte data, byte wclock, byte chip0, byte chip1, byte chip2, byte chip3, byte rclock) {
    //Set the I/O Directions
    pinMode(data, OUTPUT);
    pinMode(wclock, OUTPUT);
    if(rclock) {
        pinMode(rclock, OUTPUT);
        _RCLOCK = rclock;
    }
 
    pinMode(chip0, OUTPUT);
    digitalWrite(chip0, HIGH);
    _CHIP0 = chip0;
 
    if(chip1) {
        pinMode(chip1, OUTPUT);
        digitalWrite(chip1, HIGH);
        _CHIP1 = chip1;
    }
 
    if(chip2) {
        pinMode(chip2, OUTPUT);
        digitalWrite(chip2, HIGH);
        _CHIP2 = chip2;
    }
 
    if(chip3) {
        pinMode(chip3, OUTPUT);
        digitalWrite(chip3, HIGH);
        _CHIP2 = chip2;
    }
 
    _DATA = data;
    _WCLOCK = wclock;
}
 
void HT1632::ChipSelect(byte chip) {
    switch(chip) {
        case 0:
            digitalWrite(_CHIP0, LOW);
            break;
        case 1:
            digitalWrite(_CHIP1, LOW);
            break;
        case 2:
            digitalWrite(_CHIP2, LOW);
            break;
        case 3:
            digitalWrite(_CHIP3, LOW);
            break;
        }
}
 
void HT1632::ChipRelease(byte chip) {
    switch(chip) {
        case 0:
            digitalWrite(_CHIP0, HIGH);
            break;
        case 1:
            digitalWrite(_CHIP1, HIGH);
            break;
        case 2:
            digitalWrite(_CHIP2, HIGH);
            break;
        case 3:
            digitalWrite(_CHIP3, HIGH);
            break;
    }
}
 
void HT1632::WriteBits(byte bits, byte mask) {
    while (mask) {
        digitalWrite(_WCLOCK, LOW);
        if (bits & mask) {
            digitalWrite(_DATA, HIGH);
        } else {
            digitalWrite(_DATA, LOW);
        }
        digitalWrite(_WCLOCK, HIGH);
        mask >>= 1;
    }
}
 
void HT1632::SendCommand(byte command, byte chip) {
    ChipSelect(chip);
    WriteBits(HT1632_CTL_COMMAND, 1<<2);//3 bit command id
    WriteBits(command, 1<<7);//8 bit command
    WriteBits(0,1);//There's one extra bit in commands that dont matter...
    ChipRelease(chip);
}
 
byte HT1632::ReadData(byte address, byte chip) {
    //Do stuff here to read the data from the chip...
}
 
void HT1632::Clear(byte chip) {
    ChipSelect(chip);
    for(int i=0; i<256; i++) {
        WriteData(i, 0);
    }
    ChipRelease(chip);
}
 
void HT1632::WriteData(byte address, byte data, byte chip) {
    ChipSelect(chip);//Select the chip...
    //Send the WRITE command...
    WriteBits(HT1632_CTL_WRITE, 1<<2);  //3 bit command
    //Send the Address...
    WriteBits(address, 1<<6);   //7 bit address
    //Send the data...
    WriteBits(data, 1<<3); //4 bit data
    ChipRelease(chip);//Release the chip...
}
 
void HT1632::Init(byte chip) {
    SendCommand(HT1632_CMD_SYSDIS); //Disable system
    SendCommand(HT1632_CMD_COM11); //PMOS drivers
    SendCommand(HT1632_CMD_RCMASTER); //Master mode
    SendCommand(HT1632_CMD_SYSEN); //System Enable
    SendCommand(HT1632_CMD_LEDON); //Enable the display
    Clear(chip);
}
 
void HT1632::BlinkMode(bool blink, byte chip) {
    if(blink) {
        SendCommand(HT1632_CMD_BLINKON, chip);
    } else {
        SendCommand(HT1632_CMD_BLINKOFF, chip);
    }
}

#!/usr/bin/env python
 
#
# PIL Image Module Handbook - http://www.pythonware.com/library/pil/handbook/image.htm
#
 
from PIL import Image
from optparse import OptionParser
 
def processImageAverage(imageFile):
    image = Image.open(imageFile)     #open the image for processing
    pixels = list(image.getdata())    #break the image down into a list of pixels, each pixel contains a list of red,green,blue
 
    totalpx = 0 #set some default values to start counting...
    redpx = 0
    greenpx = 0
    bluepx = 0
 
    for pixel in pixels:    #loop through the lists and build the values.
        totalpx += 1
        redpx += pixel[0]
        greenpx += pixel[1]
        bluepx += pixel[2]
 
    redavg = redpx / totalpx   #generate the averages
    greenavg = greenpx / totalpx
    blueavg = bluepx / totalpx
 
    print "\nTotal Pixels:\t", totalpx     #and write them out.
    print "Red Average:\t", redavg
    print "Green Average:\t", greenavg
    print "Blue Average:\t", blueavg
    print "HEX Color:\t#%x%x%x" % (redavg, greenavg, blueavg)
 
def main():
    parser = OptionParser("Usage: %prog source")
 
    (options, arguments) = parser.parse_args()
    if len(arguments) != 1:
        parser.error("Please specify a single input file.")
 
    processImageAverage(arguments[0])
 
if __name__ == "__main__":
    main()