// Tasks
char cTask = 0;
#define TASK_INT_EXT0     0
#define TASK_RS232        1
#define TASK_INT_TX       2
#define TASK_INT_EXT1	    3
#define TASK_INT_EXT2     4
#define TASK_TIMER1_MUTE  5
#define TASK_TIMER1_FUNC  6
#define TASK_TIMER1       7

// LED and Relay outputs
#define POWEROUT (porta.0) // Output for the main power relays
#define MUTEOUT (porta.1) // Output for the unmute relay
#define IR_LED (porta.2) // Red IR LED pin
#define RED (porta.3) // Red LED pin
#define GREEN (porta.4) // Green LED pin
#define BLUE (porta.5) // Blue LED pin

// Pins for monitoring
#define PWR_FAIL (portb.0) // AC detection for when amp is unplugged - if this is high, then AC was removed
#define IR_PIN (portb.1) // IR detector input pin
#define DC_FAIL (portb.2) // Amp DC detection - if this is low, then in a fault condition!
#define EXT_POWER (portd.6) // Externally triggered power - if this is low, then a device connected by USB is on

// MAX7219 pins
#define LEDDATA (portb.3)
#define LEDCLOCK (portb.4)
#define LEDLATCH (portb.5)
#define LEDDISPON (portd.7) // v3.0 added this to control power Vss to MAX7219 - low = display on

// PGA2310 pins
#define VOLDATA (portc.0)
#define VOLCLOCK (portc.1)
#define VOLLATCH (portc.2)

// 74HCT595 pins
#define RELAYDATA (porte.0)
#define RELAYCLOCK (porte.1)
#define RELAYLATCH (porte.2)

// MAX7219 bit-bang delay
#define LEDDELAYUS 40

// Timer2 preloads for IR timing
// 21 for 208us on 10MHz, 1:8 postscaler
// 34 for 16MHz, 50 for 24MHz
#define IR_PR2_200US 21
// 92 for 872us on 10MHz, 1:8 postscaler
// 148 for 16MHz, 222 for 24MHz
#define IR_PR2_890US 92

// For setting TMR1 to 3072 (tmr1h=12) - so it interrupts after roughly 200ms at 10Mhz, 1:8 prescaler
#define TMR1H_SET 12
#define TMR1_1SEC 5

#define RX_BUFFER_SIZE	30

char iVolume = 0; // Overall system volume 0-255
char iMute = 0; // 1 if muted
char iMuteHeld = 0;
char iMuteWasPressed = 0;
signed char iFrontBalance = 0; // signed offset to front speakers left/right balance
signed char iRearBalance = 0; // signed offset to rear speakers left/right balance
signed char iRearAdjust = 0; // signed offset to rear speakers volume
signed char iCentreAdjust = 0; // signed offset to centre speaker volume
signed char iSubAdjust = 0; // signed offset to subwoofer volume

char iPower = 0; // 1 if powered on
char iPowerExternal = 0; // 1 if powered on by external USB trigger
char iActiveInput = 0; // The active input 0 to 3
char iTrigger = 1; // The active 12V trigger outputs - by default, trigger 1 on, trigger 2 off
char iSurroundMode = 1; // Surround sound mode. 0 = stereo, 1 = all 6 channels
char iExtSurroundMode = 1; // Surround sound decoding. 0 = internal hafler, 1 = external decoded via 5.1 input
char iFunctionMode = 0;

// Buffer and index pointer for RS232 receiving
//char iRS232Index;
//char rs232Buffer[RX_BUFFER_SIZE];

// Timer 1 overflow counting
char iTimer1Count = 0;
char iTimer1SecCounts = 0;
char iTimer1OffCount = 10;

// RC5 message time (~114ms) multiple
#define MUTE_HOLD_TIME 9

// Configuration registers
#pragma DATA    _CONFIG1L, 00001000b // USBDIV off, CPU divide by 2, PLL direct
#pragma DATA    _CONFIG1H, 10001101b // enable oscillator switchover, disable failsafe clock monitor, HS
#pragma DATA    _CONFIG2L, 00011111b // USB voltage regulator disabled, brownout set for 2.1 volts, hardware brownout only, PWRT disabled
#pragma DATA    _CONFIG2H, 00011110b // Watchdog timer disabled
#pragma DATA    _CONFIG3H, 10000000b // MCLR enabled, RB4:RB0 digital on POR
#pragma DATA    _CONFIG4L, 10000000b // Debug off, extended instructions disabled, LVP disabled, disable stack full/underflow reset
#pragma DATA    _CONFIG5L, 00001111b // Read code protection off
#pragma DATA    _CONFIG5H, 11000000b // Read EEPROM and boot block protection off
#pragma DATA    _CONFIG6L, 00001111b // Write code protection off
#pragma DATA    _CONFIG6H, 11100000b // Write EEPROM, boot block and config register protection off
#pragma DATA    _CONFIG7L, 00001111b // Table read protection off
#pragma DATA    _CONFIG7H, 01000000b // Boot block table read protection off

// 20 MHz crystal but the system clock is 10MHz due to CPUDIV configuration
#pragma CLOCK_FREQ 10000000

void initialise() {
    // IO ports setup
    trisa = 0x00; // all ouptuts
    porta = 0x00; // set to off
    trisb = 0x07; // RB0, RB1, RB2 are inputs
    portb = 0x00; // set to off
    trisc = 0xC0; // RC7 (Rx) and RC6 (Tx) are inputs
    portc = 0x04; // Set bit 2 on portc, the pga2310 latch /CS
    trisd = 0x40; // v3.0 - RB6 is an input
    portd = 0x00; // LED outputs off
    trise = 0x00; // All outputs (relay 74ht595)
    porte = 0x00; // All off

    osccon.IDLEN = 1; // Enter idle mode on sleep
    osccon.IRCF2 = 1; // IRCF2 to IRCF0 are 110 for 4MHz for RC_RUN mode to save power
    osccon.IRCF1 = 1;
    osccon.IRCF0 = 0;

    // ADC setup
    adcon0 = 0x00; //  ADC off
    adcon1 = 0x0F; // All digital I/O

    readData(); // Read in variables from EEPROM
    writeRelay(); // v1.1 moved to power on sequence

    // Timer calculator: http://eng-serve.com/pic/pic_timer.html
    // Timer 1 setup - interrupt every 87ms seconds 24MHz, 131ms 16MHz, 210ms 10Mhz
    t1con = 0x30;  //  00 11 0000 - 1:8 prescale, oscil off, internal clock, timer disabled
    iTimer1Count = 0; // Counter for number of interrupts
    tmr1h = TMR1H_SET; // Set TMR1 to 3072 (tmr1h 12)
    pie1.TMR1IE = 1; // Timer 1 interrupt
    pir1.TMR1IF = 0; // Clear timer 1 interrupt flag bit

    // Timer 2 setup - interrupt every 890us
    t2con = 0x29;  //  0 0101 0 01 - 1:6 postscale, timer off, 1:4 prescale
    // 10MHz settings
    pr2 = 92; // Preload timer2 comparator value - 0.00088320s
    pie1.TMR2IE = 1; // Timer 2 interrupt
    pir2.TMR2IF = 0; // Clear timer 1 interrupt flag bit

    // Setup for RB0 Interrupt [Power Fail]
    intcon.INT0IE = 1; // RB0 Interrupt enabled (for power fail)
    intcon2.INTEDG0 = 1; // RB0 interrupt should occur on rising edge
    intcon.INT0IF = 0; // Clear RB0 interrupt flag bit
    
    // Setup for RB1 Interrupt [IR LED]
    intcon3.INT1E = 1; // RB1 Interrupt (for IR receive)
    intcon2.INTEDG1 = 0; // RB1 interrupt should occur on falling edge
    intcon3.INT1IF = 0; // Clear RB1 interrupt flag bit
    
    // Setup for RB2 Interrupt [DC fail]
    intcon3.INT2E = 1; // RB2 Interrupt (for DC Fail)
    intcon2.INTEDG2 = 0; // RB2 interrupt should occur on falling edge
    intcon3.INT2IF = 0; // Clear RB2 interrupt flag bit

    intcon2.RBPU = 1; // Port B pull-ups disabled (otherwise DC fail is not detected)

    intcon.PEIE = 1; // Enables all unmasked peripheral interrupts (required for RS232)

    // No task at initialisation
    cTask = 0;

    // rs232 communications setup
    // SYNC = 0, BRGH = 1, BRG16 = 0
    // 10MHz Baud rate 9600 = 65 = ((10000000 / 9600) / 16) - 1
    //spbrg = 65; // 65 = ((10000000 / 9600) / 16) - 1
    //txsta = 0x26; // 00100110 - 8 bit, transmit enable, async mode, high speed, TSR empty, 9bit (0)
    //rcsta = 0x90; // 10010000 - serial port enabled, 8 bit reception, async mode continuous recieve, no frame error, no overrun error
    //baudcon = 0x42; // 01000010 - non-inverted, 8 bit generator, wake up on receive

    //pie1.RCIE = 1; // Usart interrupt receive (no send interrupt)
    //iRS232Index = 0;
    
    RED = 1; // Standby LED

    delay_s(2);
    
    // v3.0 altered display test
    ledOn();
    ledTest();
    delay_s(2);
    ledOff();
    
    //bluetoothSetup();

    enableInterrupts();
}

//-----------------------------------------------------------------------------
// MAIN PROGRAM
//------------------------------------------------------------------------------
void main() {
    initialise();
    
    while (1) {
        // Task scheduler
        // If there are tasks to be performed, find out the
        // most recent task from the array and execute it
        while (cTask > 0) {
            if (cTask.TASK_INT_EXT2) {
                // A DC fault occurred - show on display
                showFault();
                t1con.TMR1ON = 1; // Switch on the timer - will reset fault if it clears within 5 seconds
                cTask.TASK_INT_EXT2 = 0;
            } else if (cTask.TASK_INT_EXT0) {
                // Power fail occurred
                // When power supply is disconnected, save variables to EEPROM
                saveData();
                cTask.TASK_INT_EXT0 = 0;
            } else if (cTask.TASK_TIMER1_MUTE) {
                // Mute and update display
                doMute();
                //sendRS232Status();
                showVolume();
                ledWrite();
                // reset the timer
                timer1Reset();
                cTask.TASK_TIMER1_MUTE = 0;
            } else if (cTask.TASK_TIMER1_FUNC) {
                // enter function mode
                iFunctionMode = 1;
                // Show first function
                functionDisplay();
                // turn off the timer
                timer1Reset();
                cTask.TASK_TIMER1_FUNC = 0;
            } else if (cTask.TASK_TIMER1) {
                onTimer1(); // Timer 1 has finished counting
                cTask.TASK_TIMER1 = 0;
            } else if (cTask.TASK_INT_EXT1) {
                rc5Process(); // IR sensor received a signal
                IR_LED = 0; // Ensure LED is off
                cTask.TASK_INT_EXT1 = 0;
            //} else if (cTask.TASK_RS232) {
            //    rs232CommandReceived();
            //    cTask.TASK_RS232 = 0;
            }
        }
        
        // Poll for EXT_POWER
        // if EXT_POWER is low (USB trigger high), iPower is off
        // v1.1 and not previously powered on externally
        if (!EXT_POWER && !iPower && !iPowerExternal) {
            // Powered on by external appliance
            iPowerExternal = 1;
            // set the input to the trigged input (input 1) = in2 on the tda7439
            iActiveInput = 0;
            doPower();
        }
        // if EXT_POWER is high (USB trigger low), iPower is on, and was powered on externally
        // ..then power off
        // This is done in a countdown timer - see onTimer1();
        // v1.1 If no external power signal, and power is off anyway, reset the iPowerExternal indicator
        if (EXT_POWER && !iPower) {
            iPowerExternal = 0;
        }
    }
} 

RED = 1;

RED = 0;

/******************************************************
  Apply relay selection to the 74HCT595 shift register
*******************************************************/
void writeRelay() {
    char iRelay = 0; // initialised empty

    // V2.0 changed outputs
    // TRG 1 = 00000001  0x01
    // TRG 2 = 00000010  0x02
    // INP 1 = 00000100  0x04
    // INP 2 = 00001000  0x08
    // INP 3 = 00010000  0x10
    // INP 0 = 00100000  0x20
    // SUR M = 01000000  0x40

    // Set surround mode relay if Active Input is 0 and ExtSurround is on
    if (iExtSurroundMode && (iActiveInput == 0)) {
        // Set bit 7
        iRelay = ((iRelay & 0xBF) + 0x40);
    }

    // Write selected input to input byte
    switch (iActiveInput) {
        // For each input, take the existing selected and logic AND with 0x43 (01000011) so the status 
        // of the power and surround switch remains. Then add the representation of the input 
        case 0:
            // Clear bits 2 to 5, Set bit 5, 
            iRelay = ((iRelay & 0x43) + 0x20);
            break;
        case 1:
            // Clear bits 2 to 5, Set bit 2, 
            iRelay = ((iRelay & 0x43) + 0x04);
            break;
        case 2:
            // Clear bits 2 to 5, Set bit 3, 
            iRelay = ((iRelay & 0x43) + 0x08);
            break;
        case 3:
            // Clear bits 2 to 5, Set bit 4, 
            iRelay = ((iRelay & 0x43) + 0x10);
            break;
    }
    
    if (iTrigger <= 3)
        iRelay += iTrigger;
    
    // v1.1 if power is off, disable all relays (to reduce standby current) and triggers
    if (!iPower)
        iRelay = 0;
    
    // Lower latch
    RELAYLATCH = 0;

    for (char cBitSelect = 0x01; cBitSelect; cBitSelect <<= 1) {
        if (iRelay & cBitSelect)
            RELAYDATA = 1; // Serial data output high
        else
            RELAYDATA = 0;

        RELAYCLOCK = 1; // Clock set high, so bit is loaded onto the shift register
        RELAYCLOCK = 0; // Clock cleared
    }

    // Load the new register
    RELAYLATCH = 1; // Set the latch to high so contents of shift register are put on the parallel output
}

/******************************************************
  Apply volume levels (6 channels) to PGA2310 chips
*******************************************************/
void writeVolumes() {
    char n; // Loop counter
    char byteVolume[6] = {0,0,0,0,0,0};
    
    // Set front levels based on balance setting
    if (iFrontBalance == 0) {
        byteVolume[4] = iVolume; // Right balance adjust (reduce left channel)
        byteVolume[5] = iVolume; // Set other channel to volume level
    } else if (iFrontBalance > 0) {
        byteVolume[4] = getAdjustedVolume(iFrontBalance * -1); // Right balance adjust (reduce left channel)
        byteVolume[5] = iVolume; // Set other channel to volume level
    } else {
        byteVolume[5] = getAdjustedVolume(iFrontBalance); // Left balance adjust (reduce right channel)
        byteVolume[4] = iVolume; // Set other channel to volume level
    }

    // Set rear levels based on balance setting and adjustment
    if (iRearBalance == 0) {
        byteVolume[2] = getAdjustedVolume(iRearAdjust); // Rear level adjust
        byteVolume[3] = getAdjustedVolume(iRearAdjust); // Rear level adjust
    } else if (iRearBalance > 0) {
        byteVolume[2] = getAdjustedVolume((iRearBalance * -1) + iRearAdjust); // Right balance adjust (reduce left channel)
        byteVolume[3] = getAdjustedVolume(iRearAdjust); // Adjust other channel only
    } else {
        byteVolume[3] = getAdjustedVolume(iRearBalance + iRearAdjust); // Left balance adjust (reduce right channel)
        byteVolume[2] = getAdjustedVolume(iRearAdjust); // Adjust other channel only
    }

    // Set centre and sub woofer levels based on each adjustment
    byteVolume[1] = getAdjustedVolume(iCentreAdjust); // Centre level adjust
    byteVolume[0] = getAdjustedVolume(iSubAdjust);  // Sub level adjust

    // If set to stereo, clear first 4 bytes (rear l/r, centre, sub)
    if (!iSurroundMode) {
        for (char i = 0; i < 4; i++)
            byteVolume[i] = 0;
    }
    // If muted (volume zero or iMute is 1), set all to zero regardless of levels
    if ((iVolume == 0) || (iMute == 1)) {
        for (char i = 0; i < 6; i++)
            byteVolume[i] = 0;
        // Display correct LED colour - green for muted
        GREEN = 1;
        BLUE = 0;
    } else {
        // Blue for active
        GREEN = 0;
        BLUE = 1;
    }

    // Set latch to low
    VOLLATCH = 0;

    for (n = 0; n < 6; n++) { // 6 bytes to send
        // MSB first
        for (char cBitSelect = 0x80; cBitSelect; cBitSelect >>= 1) {
            // Clear clock for next bit
            VOLCLOCK = 0;

            if (byteVolume[n] & cBitSelect) // the set bit position in cBitSelect in vol is set, output high
                VOLDATA = 1;
            else
                VOLDATA = 0;

            // Raise clock so serial bit output is sent
            VOLCLOCK = 1;
        }
    }
    // Set latch to high
    VOLLATCH = 1;
}

/******************************************************
 Adjust the volume level and return the result, from 0 to 255 only
 *******************************************************/
char getAdjustedVolume(signed char iVolAdj) {
    // Returns an adjustment to the volume, floor at zero and ceiling at 255
    char iResult = iVolume + iVolAdj;
    // Prevent overflow
    if (iVolAdj < 0) { // Negative, new level should always be less than overall
        if (iResult > iVolume)
            iResult = 0;
    }
    else { // Positive, new level should be greater than overall
        if (iResult < iVolume)
            iResult = 255;
    }
    return iResult;
}

/**************************************************************************************
    LED Display Functions
**************************************************************************************/

char ledData1[8];
char ledData2[8];

// Converts a string of characters into decoded 7 segment bytes for LED character array
// Optionally writes these bytes to LED displays
void ledPrint(char iLine, unsigned char *s) {
    char dig;
    for (dig = 0; dig < 8; dig++) {
        if (*s) {
            if (iLine == 1)
                ledData1[dig] = displayASCIItoSeg[*s++ - 0x20];
            else
                ledData2[dig] = displayASCIItoSeg[*s++ - 0x20];
        } else {
            if (iLine == 1)
                ledData1[dig] = 0;
            else
                ledData2[dig] = 0;
        }
    }
}

// Converts an ASCII char to decoded byte and places it in LED array
// Support decimal places
void ledChar(char iChar, char iHasDot) {
    char iDecoded = displayASCIItoSeg[iChar - 0x20];
    if (iHasDot)
        iDecoded = iDecoded | 0x80;
    if (ledCurrentLine == 1) {
        ledData1[ledCurrentCol] = iDecoded;
    } else {
        ledData2[ledCurrentCol] = iDecoded;
    }
    if (ledCurrentCol < 8)
        ledCurrentCol++;
}

// LED test function
void ledTest() {
    ledPrint(1, "Init on");
    ledPrint(2, "Testing");
    ledWrite();
}


// Setup the MAX7219 LED displays by sending the required configuration bytes
void ledSetup() {
    // Scan limit
    ledLatchDown();
    ledSendChar(0x0B);
    ledSendChar(0x07); // Scan all 8 digits
    ledSendChar(0x0B);
    ledSendChar(0x07); // Scan all 8 digits
    ledLatchUp();
    
    // Set no decode mode
    ledLatchDown();
    ledSendChar(0x09);
    ledSendChar(0);
    ledSendChar(0x09);
    ledSendChar(0);
    ledLatchUp();
    
    // Set intensity
    ledLatchDown();
    ledSendChar(0x0A);
    ledSendChar(0x06); // A: 21/32, 8: 17/32, 6:13/32
    ledSendChar(0x0A);
    ledSendChar(0x06); // A: 21/32, 8: 17/32, 6:13/32
    ledLatchUp();
}

// Start LED display
void ledOn() {
    // v3.0 Power on and setup
    LEDDATA = 0;
    LEDCLOCK = 0;
    LEDLATCH = 1;
    LEDDISPON = 0;
    //delay_s(1);
    delay_ms(250);
    ledSetup();
    
    // No shutdown
    ledLatchDown();
    ledSendChar(0x0C);
    ledSendChar(0x01); // no shutdown
    ledSendChar(0x0C);
    ledSendChar(0x01); // no shutdown
    ledLatchUp();
    // Startup time delay
    delay_us(250);
}

// Shutdown LED display
void ledOff() {
    // Shutdown
    ledLatchDown();
    ledSendChar(0x0C);
    ledSendChar(0x00); // shutdown
    ledSendChar(0x0C);
    ledSendChar(0x00); // shutdown
    ledLatchUp();
    // v3.0, remove the power
    LEDDISPON = 1;
    delay_ms(100);
}

// Write the bytes set in each array to the MAX7219 LED displays
void ledWrite() {
    char n;
    char d = 7; // Characters in array are written out backwards so start from furthest (7)
    
    // Loop through digits 0 to 8 (addressed as 1 to 9)
    for (n = 1; n < 9; n++) { 
        // Writing character to second device
        ledLatchDown();
        ledSendChar(n); // Digit to write
        ledSendChar(ledData2[d]); // Data to write
        
        // Writing character to first device
        ledSendChar(n); // Digit to write
        ledSendChar(ledData1[d]); // Digit to write
        ledLatchUp();
        d--; // Decrement array counter
    }
}

void ledLatchDown() {
    // Load the new register
    LEDDATA = 0;
    LEDCLOCK = 0;
    LEDLATCH = 0; // Clock must fall so that last bit is clocked out
}

void ledLatchUp() {
    // Load the new register
    LEDLATCH = 1;
    LEDCLOCK = 0; // Clock must fall after latch raised
    LEDDATA = 0; // Data to default
    delay_us(LEDDELAYUS); // Need to delay before starting again
}

// Write a single piece of data (byte) out serially
// Uses bit-banging to control protocol and delays
void ledSendChar(char iData) {
    for (char cBitSelect = 0x80; cBitSelect; cBitSelect >>= 1) {
        LEDCLOCK = 0; // Clock cleared
        if (iData & cBitSelect)
            LEDDATA = 1;
        else
            LEDDATA = 0;
        LEDCLOCK = 1; // Clock set high, so bit is loaded onto the shift register
    }
}

// This table, taken from http://www.ccsinfo.com/forum/viewtopic.php?p=57034 is ideal for writing the converted character out
// However as the dot is the MSB for the MAX7219 when writing, bit shift 1 to the right
// Converted using spreadsheet formula ="0x"&RIGHT("0"&DEC2HEX(BITRSHIFT(HEX2DEC(RIGHT(A1,2)),1)),2)
// Modification - capital T output differently
const char displayASCIItoSeg[] = {// ASCII to SEVEN-SEGMENT conversion table
    0x00,       // ' ', 
    0x00,       // '!', No seven-segment conversion for exclamation point
    0x22,       // '"', Double quote
    0x00,       // '#', Pound sign
    0x00,       // '$', No seven-segment conversion for dollar sign
    0x00,       // '%', No seven-segment conversion for percent sign
    0x00,       // '&', No seven-segment conversion for ampersand
    0x20,       // ''', Single quote
    0x4E,       // '(', Same as '['
    0x78,       // ')', Same as ']'
    0x00,       // '*', No seven-segment conversion for asterix
    0x00,       // '+', No seven-segment conversion for plus sign
    0x00,       // ', '
    0x01,       // '-', Minus sign
    0x00,       // '.', No seven-segment conversion for period
    0x00,       // '/', No seven-segment conversion for slash
    0x7E,       // '0', 
    0x30,       // '1', 
    0x6D,       // '2', 
    0x79,       // '3', 
    0x33,       // '4', 
    0x5B,       // '5', 
    0x5F,       // '6', 
    0x70,       // '7', 
    0x7F,       // '8', 
    0x7B,       // '9', 
    0x00,       // ':', No seven-segment conversion for colon
    0x00,       // ';', No seven-segment conversion for semi-colon
    0x00,       // '<', No seven-segment conversion for less-than sign
    0x09,       // '=', Equal sign
    0x00,       // '>', No seven-segment conversion for greater-than sign
    0x65,       //'?', Question mark
    0x00,       // '@', No seven-segment conversion for commercial at-sign
    0x77,       // 'A', 
    0x1F,       // 'B', Actually displayed as 'b'
    0x4E,       // 'C', 
    0x3D,       // 'D', Actually displayed as 'd'
    0x4F,       // 'E', 
    0x47,       // 'F', 
    0x5E,       // 'G', Actually displayed as 'g'
    0x37,       // 'H', 
    0x30,       // 'I', Same as '1'
    0x3C,       // 'J', 
    0x00,       // 'K', No seven-segment conversion
    0x0E,       // 'L', 
    0x00,       // 'M', No seven-segment conversion
    0x15,       // 'N', Actually displayed as 'n'
    0x7E,       // 'O', Same as '0'
    0x67,       // 'P', 
    0x00,       // 'Q', No seven-segment conversion
    0x05,       // 'R', Actually displayed as 'r'
    0x5B,       // 'S', Same as '5'
    0x70,       // 'T', Displayed as 7
    0x3E,       // 'U', 
    0x00,       // 'V', No seven-segment conversion
    0x00,       // 'W', No seven-segment conversion
    0x00,       // 'X', No seven-segment conversion
    0x3B,       // 'Y', 
    0x00,       // 'Z', No seven-segment conversion
    0x00,       // '[', 
    0x00,       // '\', No seven-segment conversion
    0x00,       // ']', 
    0x00,       // '^', No seven-segment conversion
    0x00,       // '_', Underscore
    0x00,       // '`', No seven-segment conversion for reverse quote
    0x7D,       // 'a', 
    0x1F,       // 'b', 
    0x0D,       // 'c', 
    0x3D,       // 'd', 
    0x6F,       // 'e', 
    0x47,       // 'f', Actually displayed as 'F'
    0x5E,       // 'g', 
    0x17,       // 'h', 
    0x10,       // 'i', 
    0x3C,       // 'j', Actually displayed as 'J'
    0x00,       // 'k', No seven-segment conversion
    0x0E,       // 'l', Actually displayed as 'L'
    0x00,       // 'm', No seven-segment conversion
    0x15,       // 'n', 
    0x1D,       // 'o', 
    0x67,       // 'p', Actually displayed as 'P'
    0x00,       // 'q', No seven-segment conversion
    0x05,       // 'r', 
    0x5B,       // 's', Actually displayed as 'S'
    0x0F,       // 't', 
    0x1C,       // 'u', 
    0x00,       // 'v', No seven-segment conversion
    0x00,       // 'w', No seven-segment conversion
    0x00,       // 'x', No seven-segment conversion
    0x3B,       // 'y', Actually displayed as 'Y'
    0x00        // 'z', No seven-segment conversion
}; 

void doInputDown() {
    // Decrement the active input
    iActiveInput--;
    if (iActiveInput > 4) // If overflowed (less than 0) was 5
        iActiveInput = 3; // was 4
    writeRelay();
}

void doInputUp() {
    // Increment the active input
    iActiveInput++;
    if (iActiveInput >= 4) // was 5
        iActiveInput = 0;
    writeRelay();
}

void doVolumeUp() {
    // Increase level
    if (iVolume < 255) { // Don't process if volume is 255 or power is off
        // Increase level
        char iNewVol = iVolume + 2; // Increment by larger step for IR command VolumeUp
        if (iNewVol < iVolume)
            iNewVol = 255;
        iVolume = iNewVol;
        writeVolumes();
    }
}

void doVolumeDown() {
    // Decrease level
    if (iVolume > 0) { // Don't process if volume is 0 or power is off
        // Increase level
        char iNewVol = iVolume - 2; // Increment by larger step for IR command VolumeUp
        if (iNewVol > iVolume)
            iNewVol = 0;
        iVolume = iNewVol;
        writeVolumes();
    }
}

void doMute() {
    iMute = !iMute;
    writeVolumes();
}

/***********************************************************************************
  Functions to display and adjust amp functions i.e. bass, treble, balance
************************************************************************************/
void functionValueDisplay(signed char iValue, char isBal) {
    ledData2[0] = 0;
    ledData2[1] = 0;
    
    ledCurrentLine = 2;
    // write characters to array
    if (isBal) {
        ledCurrentCol = 0;
        if (iValue < 0)
            ledChar('L', 0);
        if (iValue > 0)
            ledChar('r', 0);
    }
    ledCurrentCol = 1;
    if (iValue < 0)
        ledChar('-', 0);
    if (iValue > 0) {
        if (isBal)
            ledChar('-', 0);
    }

    char iAdj = abs(iValue);
    char iDecimal = 0;
    if (iAdj.0)
        iDecimal = 5;
    iAdj = iAdj / 2;
    
    // incrementing 10s
    // determine to tens digit
    ledCurrentCol = 2;
    if (iAdj >= 10) {
        ledChar('1', 0);
        iAdj -= 10;
    } else {
        ledChar(' ', 0);
    }    
    // 2nd digit in number + added decimal point
    ledChar(iAdj + 48, 1);
    
    // Decimal number
    ledChar(iDecimal + 48, 0);
    ledChar(' ', 0);
    ledChar('d', 0);
    ledChar('b', 0);
    
    // Write Result to LED display
    ledWrite();
    
}

void functionDisplay() {
    switch (iFunctionMode) {
        case 1: // Centre
            ledPrint(1, "Centre");
            functionValueDisplay(iCentreAdjust, 0);
            break;
        case 2: // Rear
            ledPrint(1, "rear");
            functionValueDisplay(iRearAdjust, 0);
            break;
        case 3: // Balance
            ledPrint(1, "balance");
            functionValueDisplay(iFrontBalance, 1);
            break;
        case 4: // Rear Balance
            ledPrint(1, "rear bal");
            functionValueDisplay(iRearBalance, 1);
            break;
        case 5: // Sub
            ledPrint(1, "Sub");
            //ledPrint(2, "Testing", 1);
            functionValueDisplay(iSubAdjust, 0);
            break;
        case 6: // Trigger 1
            ledPrint(1, "Trig 1");
            if (iTrigger.0)
                ledPrint(2, "On");
            else
                ledPrint(2, "Off");
            break;
        case 7: // Trigger 2
            ledPrint(1, "Trig 2");
            if (iTrigger.1)
                ledPrint(2, "On");
            else
                ledPrint(2, "Off");
            break;
        case 8: // External surround
            ledPrint(1, "51 Sound");
            ledData1[0] = 0xDB; // 5 with dot
            if (iExtSurroundMode)
                ledPrint(2, "On");
            else
                ledPrint(2, "Off");
            break;
        case 9: // Hafler surround
            ledPrint(1, "Hafler");
            if (iSurroundMode)
                ledPrint(2, "On");
            else
                ledPrint(2, "Off");
            break;
    }
    // Write Result to LED display
    ledWrite();
}

char functionValueRaise(signed char iValue) {
    if (iValue < 32)
        iValue++;
    return iValue;
}

char functionValueLower(signed char iValue) {
    if (iValue > -32)
        iValue--;
    return iValue;
}

void functionRaise() {
    switch (iFunctionMode) {
        case 1: // Centre
            iCentreAdjust = functionValueRaise(iCentreAdjust);
            writeVolumes();
            break;
        case 2: // Rear
            iRearAdjust = functionValueRaise(iRearAdjust);
            writeVolumes();
            break;
        case 3: // Balance
            iFrontBalance = functionValueRaise(iFrontBalance);
            writeVolumes();
            break;
        case 4: // Rear Balance
            iRearBalance = functionValueRaise(iRearBalance);
            writeVolumes();
            break;
        case 5: // Centre
            iSubAdjust = functionValueRaise(iSubAdjust);
            writeVolumes();
            break;
        case 6: // Trigger 1
            iTrigger.0 = 1;
            writeRelay();
            break;
        case 7: // Trigger 2
            iTrigger.1 = 1;
            writeRelay();
            break;
        case 8: // External surround
            if (iExtSurroundMode)
                iExtSurroundMode = 0;
            else
                iExtSurroundMode = 1;
            writeRelay();
            break;
        case 9: // Hafler surround
            if (iSurroundMode)
                iSurroundMode = 0;
            else
                iSurroundMode = 1;
            writeVolumes();
            break;
    }
    // Display the changed value
    functionDisplay();
}

void functionLower() {
    switch (iFunctionMode) {
        case 1: // Centre
            iCentreAdjust = functionValueLower(iCentreAdjust);
            writeVolumes();
            break;
        case 2: // Rear
            iRearAdjust = functionValueLower(iRearAdjust);
            writeVolumes();
            break;
        case 3: // Balance
            iFrontBalance = functionValueLower(iFrontBalance);
            writeVolumes();
            break;
        case 4: // Rear Balance
            iRearBalance = functionValueLower(iRearBalance);
            writeVolumes();
            break;
        case 5: // Centre
            iSubAdjust = functionValueLower(iSubAdjust);
            writeVolumes();
            break;
        case 6: // Trigger 1
            iTrigger.0 = 0;
            writeRelay();
            break;
        case 7: // Trigger 2
            iTrigger.1 = 0;
            writeRelay();
            break;
        case 8: // External surround
            if (iExtSurroundMode)
                iExtSurroundMode = 0;
            else
                iExtSurroundMode = 1;
            writeRelay();
            break;
        case 9: // Hafler surround
            if (iSurroundMode)
                iSurroundMode = 0;
            else
                iSurroundMode = 1;
            writeVolumes();
            break;
    }
    // Display the changed value
    functionDisplay();
}

void functionUp() {
    // Change to another function
    iFunctionMode++;
    // Cycle back to 1st function if at 9th
    if (iFunctionMode > 9)
        iFunctionMode = 1;
    // Display the function and value
    functionDisplay();
}

void functionDown() {
    // Change to another function
    iFunctionMode--;
    // Cycle back to 9th function if at 1st
    if (iFunctionMode < 1)
        iFunctionMode = 9;
    // Display the function and value
    functionDisplay();
}

/******************************************************
  Read and process remote control RC5 commands
*******************************************************/
void rc5Process() {
    IR_LED = 0; // switch off IR LED
    char iGotCommand = 0;
    if (rc5_address == 0) { // Addresses above zero are not for this device
        // Process commands
        if (iPower) { // Don't process the following if power is off
            // Get current volume level
            switch (rc5_command) {
                // For each command, cause the correct action 
                case 13: // Mute (13 / 0x0D / D)
                    if (rc5_flickBitOld != rc5_flickBit) { // Prevent repeated muting when holding the button
                        // reset mute held flag
                        iMuteHeld = 0;
                        if (iFunctionMode == 0) {
                            // reset timer
                            timer1Reset();
                            // Identify mute button was pressed
                            iMuteWasPressed = 1;
                        } else {
                            // exit function mode
                            iFunctionMode = 0;
                            iGotCommand = 1;
                            // turn off the timer
                            timer1Reset();
                        }
                    } else {
                        // Button held - this should reset timer1 before it interrupts, therefore avoiding processing the command until the button is released
                        iMuteHeld++;
                        // Reset timer
                        timer1Reset();
                        if (iMuteHeld >= MUTE_HOLD_TIME) {
                            // flag for entering function mode
                            iMuteWasPressed = 0;
                            cTask.TASK_TIMER1_FUNC = 1;
                        } else {
                            // Turn on the timer again
                            t1con.TMR1ON = 1;
                        }
                    }
                    break;
                case 16: // Volume up (16 / 0x10 / E)
                    if (iFunctionMode == 0) {
                        iGotCommand = 1;
                        doVolumeUp();
                    } else {
                        functionRaise();
                    }
                    break;
                case 17: // Volume down (17 / 0x11 / F)
                    if (iFunctionMode == 0) {
                        iGotCommand = 1;
                        doVolumeDown();
                    } else {
                        functionLower();
                    }
                    break;
                case 32: // Input right (32 / 0x20 / V)
                    if (rc5_flickBitOld != rc5_flickBit) { // Prevent repeated input changing when holding the button
                        if (iFunctionMode == 0) {
                            iGotCommand = 1;
                            doInputUp();
                        } else {
                            functionUp();
                        }
                    }
                    break;
                case 33: // Input left (33 / 0x21 / U)
                    if (rc5_flickBitOld != rc5_flickBit) { // Prevent repeated input changing when holding the button
                        if (iFunctionMode == 0) {
                            iGotCommand = 1;
                            doInputDown();
                        } else {
                            functionDown();
                        }
                    }
                    break;
            }
        }
        // Process power button regardless of power state
        if (rc5_command == 12) { // Power (12 / 0x0C / A)
            if (rc5_flickBitOld != rc5_flickBit) { // Prevent repeated power when holding the button
                // exit function mode
                iFunctionMode = 0;
                //iPowerExternal = 0; v1.1 removed this to allow forced power off
                // power up or down
                doPower();
            }
        }
        rc5_flickBitOld = rc5_flickBit;
        
        // Generic RS232 send and display if a command was received, and amp powered on
        if (iPower) {
            if (iGotCommand) {
                //sendRS232Status();
                showInput();
                showVolume();
                ledWrite();
            } else if (iFunctionMode) {
                iTimer1SecCounts = 0; // reset 30 sec timeout
            }
        }
    }
}

void sendRS232Status() {
    // Array length:
    // P[1]V[2]I[1]F[2]R[2]r[2]C[2]S[2]M[1]E[1]|
    // 26
    // or as bytes - 20
    rs232SendByte('P');
    rs232SendByte(iPower + 48); // ASCII representation
    
    rs232SendByte('V');
    rs232SendNibble(iVolume); // Split into two bytes
    
    rs232SendByte('Q');
    rs232SendByte(iMute + 48); // ASCII representation
    
    rs232SendByte('I');
    rs232SendByte(iActiveInput + 48); // ASCII representation
    
    rs232SendByte('F');
    rs232SendNibble(iFrontBalance); // Split into two bytes
    
    rs232SendByte('R');
    rs232SendNibble(iRearBalance); // Split into two bytes
    
    rs232SendByte('r');
    rs232SendNibble(iRearAdjust); // Split into two bytes
    
    rs232SendByte('C');
    rs232SendNibble(iCentreAdjust); // Split into two bytes
    
    rs232SendByte('S');
    rs232SendNibble(iSubAdjust); // Split into two bytes
    
    rs232SendByte('M');
    rs232SendByte(iSurroundMode + 48); // ASCII representation
    
    rs232SendByte('E');
    rs232SendByte(iExtSurroundMode + 48); // ASCII representation
    
    rs232SendByte('T');
    rs232SendByte(iTrigger + 48); // ASCII representation
    
    // Line feed
    rs232SendByte(10);
}

// Send single character byte over rs232
void rs232SendByte(char c) {
    txreg = c; 
    while (pir1.TXIF == 0); // Wait for byte to be transmitted
    while (txsta.TRMT == 0); // Wait for byte to be transmitted
    //delay_us(10);
}

// Send two bytes over rs232
void rs232SendNibble(char c) {
    // Splits one byte into two nibbles and sends
    // Upper nibble first
    char cu = (c & 0xF0) >> 4;
    // then lower
    char cl = (c & 0x0F);

    rs232SendByte(cu + 48);
    rs232SendByte(cl + 48);
    
    // Translation:
    // Byte of x = nibble character
    // 0   = 0,0
    // 64  = 4,0  0100 = 4,  4  + 48 = 52 : 4  - 0100 0000
    // 100 = 6,4  0110 = 6,  6  + 48 = 54 : 6  - 0110 0100
    // 128 = 8,0  1000 = 8,  8  + 48 = 56 : 8  - 1000 0000
    // 255 = ?,?  1111 = 15, 15 + 48 = 63 : ?  - 1111 1111
    
    // For the character values - 16 possible (adding to 48) gives:
    // 0,1,2,3,4,5,6,7,8,9,:,;,<,=,>,?
}

// V2.0 - send string over rs232
void rs232Print(unsignedchar *s) {
      while (*s) {
        rs232SendByte(*s++);
    }
}

void interrupt(void) {
...snip...
    // RS232
    // byte received interrupt
    if (pir1.RCIF && pie1.RCIE) {
        // pir1.RCIF is cleared automatically once rcreg is read
        if (rcsta.OERR) { // Overrun error rcsta.OERR
            rcsta.CREN = 0; // clear bit CREN
            rcsta.CREN = 1; // set bit CREN
        } else if (rcsta.FERR) {
            rs232Buffer[iRS232Index] = rcreg;
        } else {
            rs232Buffer[iRS232Index] = rcreg;
            // Read until line feed or EOT is detected
            if (!cTask.TASK_RS232) { 
                while (!pir1.TXIF);
                if ((rs232Buffer[iRS232Index] == 10) || (rs232Buffer[iRS232Index] == 4)) {
                    cTask.TASK_RS232 = 1;
                    //iRS232Index = 0; // Don't reset this until processed as loop needs to know length of command
                }
                // Otherwise increment buffer index for next byte received
                iRS232Index++;
            }
        }
    }
}

// Process a complete RS232 command
void rs232CommandReceived() {
    // Loop through received bytes
    char i = 0;
    char iNewPower;
    iNewPower = iPower; // V1.1 set new power to power intially, otherwise power changes when any command received
    while (i < iRS232Index) {
        switch (rs232Buffer[i]) {
            case 'G':
                sendRS232Status();
                i = iRS232Index; // Break out of loop for get command (cannot get status and issue commands at the same time)
                break;
            case 'P': // Power
                iNewPower = rs232Buffer[i + 1] - 48;
                i++; // Skip testing next byte
                break;
            case 'V': // Volume change
                iVolume = rs232ReceiveNibbles(rs232Buffer[i+1], rs232Buffer[i+2]);
                i+=2; // Skip testing next two bytes
                break;
            case 'Q': // Mute
                iMute = rs232Buffer[i + 1] - 48;
                i++; // Skip testing next byte
                break;
            case 'I': // Input
                if ((rs232Buffer[i + 1] - 48) < 4) // Valid inputs are 0 to 3
                    iActiveInput = rs232Buffer[i + 1] - 48;
                i++; // Skip testing next byte
                break;
            case 'F': // Front balance
                iFrontBalance = rs232ReceiveNibbles(rs232Buffer[i+1], rs232Buffer[i+2]);
                i+=2; // Skip testing next two bytes
                break;
            case 'R': // Rear balance
                iRearBalance = rs232ReceiveNibbles(rs232Buffer[i+1], rs232Buffer[i+2]);
                i+=2; // Skip testing next two bytes
                break;
            case 'r': // Rear adjust
                iRearAdjust = rs232ReceiveNibbles(rs232Buffer[i+1], rs232Buffer[i+2]);
                i+=2; // Skip testing next two bytes
                break;
            case 'C': // Centre adjust
                iCentreAdjust = rs232ReceiveNibbles(rs232Buffer[i+1], rs232Buffer[i+2]);
                i+=2; // Skip testing next two bytes
                break;
            case 'S': // Sub adjust
                iSubAdjust = rs232ReceiveNibbles(rs232Buffer[i+1], rs232Buffer[i+2]);
                i+=2; // Skip testing next two bytes
                break;
            case 'M': // Surround Mode
                iSurroundMode = rs232Buffer[i + 1] - 48;
                i++; // Skip testing next byte
                break;
            case 'E': // Ext Surround Mode
                iExtSurroundMode = rs232Buffer[i + 1] - 48;
                i++; // Skip testing next byte
                break;
            case 'T': // Trigger state
                iTrigger = rs232Buffer[i + 1] - 48;
                i++; // Skip testing next byte
                break;
        }
        i++;
    }

    // Reset buffer length
    iRS232Index = 0;

    if (iNewPower != iPower) {
        // V1.1 Only change power if it is different from existing
        // The doPower routine will change the iPower variable
        //iPower = iNewPower;
        doPower();
    }
    // For get status, do nothing, otherwise write the data
    if (iPower && (rs232Buffer[0] != 'G')) { 
        writeVolumes();
        writeRelay();
        showVolume();
        showInput();
        t1con.TMR1ON = 1; // Start timer
    }
}

// From two bytes containing a nibble of the original byte, reconstruct the original
char rs232ReceiveNibbles(char i, char j) {
    // Upper nibble first
    char cu = (i - 48) << 4;
    // then lower
    char cl = (j - 48) & 0x0F; // V1.1 changed i to j, V2.0 changed F0 to 0F
    
    return cu + cl;
}

void interrupt(void) {
    // external interrupt on RB2 - highest priority [DC fail]
    if (intcon3.INT2IF && intcon3.INT2IE) {
        if (!DC_FAIL) {
            MUTEOUT = 0; // Mute amps
            // Show fault on display
            // Flag this task to the task array
            cTask.TASK_INT_EXT2 = 1;
        }
        intcon3.INT2IF = 0;

        return; // do not process any other interrupt
    }
...snip...
}

void main() {
...snip...
            if (cTask.TASK_INT_EXT2) {
                // A DC fault occurred - show on display
                showFault();
                t1con.TMR1ON = 1; // Switch on the timer - will reset fault if it clears within 5 seconds
                cTask.TASK_INT_EXT2 = 0;
            } else if 
...snip...
} 

void showFault() {
    ledPrint(1, "FAULt"); // Show fault
    printMute()
    RED = 1;
    BLUE = 0;
}

void printMute() {
  ledPrint(2, "Snd OFF");
  ledWrite();
}

/******************************************************
  Events for when Timer 1 has finished counting
*******************************************************/
void onTimer1() {
    // This function will get called every second, if the amplifier is powered on
    iTimer1SecCounts++;
    if (iTimer1SecCounts >= 30) {
        // every 30 seconds, do a reset
        if (iPower && DC_FAIL) {
            // If powered on and DC fail is OK, unmute and show volume/input
            MUTEOUT = 1; // Unmute amps
            RED = 0;
            BLUE = 1;
            // exit function mode
            iFunctionMode = 0;
            // Show volume and input
            showVolume();
            showInput();
            ledWrite();
        }
        iTimer1SecCounts = 0;
    }
    // Count down for power off
    if (EXT_POWER && iPower && iPowerExternal) {
        // If off countdown has reached zero, power off
        if (iTimer1OffCount == 0) {
            // power off
            iTimer1OffCount = 10;
            doPower();
        } else {
            // otherwise decrement counter and display countdown on display
            iTimer1OffCount--;
            ledPrint(1, "Off In ");
            ledCurrentLine = 1;
            ledCurrentCol = 7;
            ledChar(iTimer1OffCount+48, 0);
            ledWrite();
         }
    } else if (iTimer1OffCount < 10) {
        // reset off count, external power must be back on
        iTimer1OffCount = 10;
        // exit function mode (in case it was entered)
        iFunctionMode = 0;
        // Show volume and input
        showVolume();
        showInput();
        ledWrite();
    }
}

void interrupt(void) {
...snip...
    // external interrupt on RB0 - next highest priority [AC fail]
    if (intcon.INT0IF && intcon.INT0IE) {
        MUTEOUT = 0; // Mute amps
        cTask.TASK_INT_EXT0 = 1;
        intcon.INT0IF = 0;
        
        return; // do not process any other interrupt
    }
...snip...
}

void saveData() {
    eepromWrite(0, 10); // To indicate EEPROM has been saved
    eepromWrite(1, iVolume);
    eepromWrite(2, iFrontBalance);
    eepromWrite(3, iRearBalance);
    eepromWrite(4, iRearAdjust);
    eepromWrite(5, iCentreAdjust);
    eepromWrite(6, iSubAdjust);
    eepromWrite(7, iActiveInput);
    eepromWrite(8, iSurroundMode);
    eepromWrite(9, iExtSurroundMode);
    eepromWrite(10, iTrigger);
}

void eepromWrite(char address, char data) {
    char intconsave = intcon;
    
    // Load address and data
    eeadr = address;
    eedata = data;

    eecon1.EEPGD = 0; // Point to DATA memory
    eecon1.CFGS = 0; // Access EEPROM
    eecon1.WREN = 1; // Enable writes
    
    // Required write sequence
    intcon = 0;
    eecon2 = 0x55; // Write 55h
    eecon2 = 0xAA; // Write 0AAh
    eecon1.WR = 1; // Set WR bit to begin write
    intcon = intconsave;
    eecon1.WREN = 0; // Disable writes on write complete (EEIF set)
    while(!pir2.EEIF); // Wait for the interrupt bit EEIF to be set
    pir2.EEIF = 0; // Clear EEIF
}

// Power on routine
void doPower() {
    if (iPower) {
        // Power off sequence
        MUTEOUT = 0; // Mute amps
        // Switch on green (for muted)
        BLUE = 0;
        GREEN = 1;
        RED = 0;
        
        // Disable timer 1
        t1con.TMR1ON = 0;

        //saveData(); // Save variables - moved because interrupts need to be enabled
        
        // Goodbye!
        ledPrint(1, "Goodbye");
        ledPrint(2, "");
        ledWrite();
        
        iPower = 0;
        // Write relay (disables or enables relays if powered)
        // V2.2 - moved here so that triggers are shut off immediately instead of after the delay
        // V2.4 - added a slight delay so the power isn't removed from the trigger output at the same time the mute occurs
        delay_ms(250);
        delay_ms(250); // v3.0, delay_ms call with 500 is invalid (max 255), added 2x 250 instead
        writeRelay();

        delay_ms(250); // Force a 1 second wait before powering down the amps
        delay_ms(250); // v3.0, delay_ms call with 500 is invalid (max 255), added 2x 250 instead
        POWEROUT = 0; // Power off amps

        delay_s(6); // Force a 6 second wait before the ability to switch on again (allows electronics to drain)
        
        ledOff();
        
        // Switch on red (for standby)
        BLUE = 0;
        GREEN = 0;
        RED = 1;
    } else if (DC_FAIL) {
        // Power on sequence - v2.0 only runs if there is no DC failure present
        POWEROUT = 1; // Power on amps
                
        // Switch on green (for muted)
        BLUE = 0;
        GREEN = 1;
        RED = 0;
        
        writeVolumes(); // Ensure volume level is sent out (this will also colour the LED)
        
        ledOn();
        ledPrint(1, "HELLO");
        ledPrint(2, "");
        ledWrite();
    
        iPower = 1;
        // Write relay (disables or enables relays if powered)
        // V2.2 - moved here so that triggers are enable immediately instead of after the delay
        writeRelay();

        // Delay mute
        // Flash Green/Blue for 5.4 seconds
        char l;
        for (l=0; l<27; l++) {
            // Green off, blue on
            BLUE = 1;
            GREEN = 0;
            DELAY_SHORT;
            // Blue off, green on
            BLUE = 0;
            GREEN = 1;
            DELAY_SHORT;
        }
        
        showInput();
        showVolume();
        ledWrite();
    
        // Check for DC failure
        if (!DC_FAIL) {
            showFault(); // Show that a fault has occured
            iPower = 0;
        } else {
            // Only unmute amps if no fault
            MUTEOUT = 1; // Unmute amps
        }
        
        // Enable timer 1
        t1con.TMR1ON = 1;
    }
}

/******************************************************
  Function to print the current volume to the LED display
*******************************************************/
void showVolume() {
    int iModulus = 0;
    char cGain = 95; // Gain level -95.5db - +31.5dB
    char cGainDecimalPoint = 0; // Gain decimal - either 0 or 5

    ledData2[0] = 0;
    ledData2[1] = 0;
    if (iMute) {
        printMute(); // Sound off
    } else {
        ledCurrentLine = 2;
        if (iVolume == 192) {
            // Gain is 0dB
            cGain = 0;
        } else if (iVolume > 192) {
            // Gain is postive
            cGain = 31 - ((255-iVolume) / 2);
        } else if (iVolume < 192) {
            // Gain is negative
            cGain = ((254-iVolume) / 2) - 31;
            ledCurrentCol = 1;
            ledChar('-', 0);
        }
        // Gain decimal - if volume is an odd number (test the last bit), it's 0.5dB
        // V3.0 made this more efficient
        if (iVolume.0 == 1)
            cGainDecimalPoint = 5;
        
        // V3.0 made this more efficient
        // Work out each digit
        // less program memory needed - may be slower executing
        // https://electronics.stackexchange.com/questions/158563/how-to-split-a-floating-point-number-into-individual-digits
        char cDig1 = 0;
        char cDig0 = 0;
        // incrementing variables for each digit
        // determine to tens digit
        while (cGain >= 10) {
            cGain = cGain - 10;
            // each time we take off 10, the left most digit is incremented
            cDig1++;
        }
        // the last digit is what's left on iValue
        cDig0 = cGain;
        
        // add 48 for ASCII equilvalent (48 = 0)
        // 1st digit in number
        ledCurrentCol = 2;
        if (cDig1 == 0)
            ledChar(' ', 0);
        else
            ledChar(cDig1 + 48, 0);
        // 2nd digit in number + added decimal point
        ledChar(cDig0 + 48, 1);
        
        // Decimal number
        ledChar(cGainDecimalPoint + 48, 0);
        ledChar(' ', 0);
        ledChar('d', 0);
        ledChar('b', 0);
    }
    
    // Display green LED if volume is 0 (effectively mute) or mute is on
    if ((iVolume == 0) || (iMute == 1)) {
        // Green on, blue off
        BLUE = 0;
        GREEN = 1;
    } else {
        // Green off, blue on
        BLUE = 1;
        GREEN = 0;
    }
}

void showInput() {
    switch (iActiveInput) {
        case 0:
            ledPrint(1, "TELE 51"); // 5.1 Input
            ledData1[5] = 0xDB; // 5 with dot
            break;
        case 1:
            ledPrint(1, "Chr Cast"); // Chromecast
            break;
        case 2:
            ledPrint(1, "Phono"); // Phono
            break;
        case 3:
            ledPrint(1, "ALt"); // Auxiliary Input
            break;
    }
}

void bluetoothSetup() {
    rs232Print("AT");
    delay_s(2);
    rs232Print("AT+NAMEAmp");
    delay_s(2);
    rs232Print("AT+PIN4321");
    delay_s(2);
}