Saturday, April 28, 2012

5.1 amplifier system redesign

I always wanted a 5.1 amplifier system for my computer, but never bothered to go out and buy one. One day I got a dead 5.1 amplifier system that appeared to be ok. When I opened it up, everything seemed to be in order. No signs of overheating, voltages were good, unit turned on normally. Everything worked, but no sound. System was based on three integrated circuits and a ordinary amplifier with preamplifier.


Time to diagnose what was wrong, starting with the amplifier and preamplifier. I took a ordinary cable with 3.5 jack from old headphones, pealed off one end and exposed GND, L channel and R channel. Then I connected this cable to my old MP3 player, turned the volume down to almost mute and pressed play. Next I connected the headphones GND with my amplifiers GND and start poking around with R and L channel.  Before this I inspected the amplifier and preamplifier and looked for where the audio comes in. I also discovered that preamplifier had a MUTE option, so I had to connect this wire (MUTE) to +5V to enable sound. When I touched audio in pins on preamplifier with one of the headphones channel outputs, amplifier came to life and started playing. I tested all 6 channels (FRONT LEFT, FRONT RIGHT, CENTER, SUB, REAR LEFT, REAR RIGHT) and every one of them was ok. Sound was good, no distortion and good quality.  From this I could assume that amplifier and preamplifier is ok.
 
Next I measured the MUTE wire from main microprocessor and found that it gives out +5V to enable amplifier. So this was not the case. Only 3 more options were left. Faulty micro controller, or two audio chips.

This system used BT2323 chip as audio selector and mixer, BT2258 as volume controller and BT1610 as the system controller. After some time searching on the net, I found nothing. Then I remembered some post long ago about volume controller IC PT2258. No problem here. Found data sheet, examples and even some source code for AVR. Then I compared these two chips and found out that they were the same. Same pins, same pin out (looked on the board and traced wires).  Also tried with PT2323 and it was a hit. Same pin out same pins everything. Complete data sheets (with I2C commands) of these two ICs are included in my download. Sadly no luck for BT1610 or PT1610. Looks like it was a custom micro controller.

I assumed that the BT1610 was OK, because unit turned on normally. So it should be the fault in these two chips. BT2323 and BT2258. I searched eBay and found that they were very cheap. I immediately ordered 10 pcs of each chip (PT2258 and PT2323), put everything away and forgot about it for a month. Then the chips arrived.

PT2258 was easy to replace because it was in DIP package. PT2323 was a problem though. When I tried to remove it with a hot air station, all the cooper connections went with it. Really don't know if it was my fault or the PCB was really bad. Probably both. Well this didn't stop me and I successfully replaced PT2323, but it took me 2 hours of hand soldering little wires to the chip. After inspection and no problems found I hooked the system up and turned it on. Again no sound... This could only mean BT1610 has a fault. And it was true. I hooked up I2C line from BT1610 to Arduino I2C sniffer and found out I2C communication was dead. Thought to myself what a waste of time and money for trying to fix this. The system was beyond repair, because you couldn't get BT1610. Ok, for spare parts it is then. Once again I put everything away and forget about it for a week or so.   

One day I was walking true some stores with hi-fi audio and saw that Genius and Logitech 5.1 systems start from 90€ and I really wanted one for a long time. But then again I would have to modify them to work with my setup I have in my room. Well, will be in my room anyways.... still working on it (I have 3 computers, 4 monitors and stereo audio system that I command over Internet - and I really do mean command, not just mains power relay switching. More of this setup in my next posts, for now it is just a proof of concept). It would be a waste spending money on something that needs to be modified completely. Then I remembered I already have a 5.1 system that needs a "little" more work done and it will be completely for my needs and my desires. So I started working...

I went to get that busted 5.1 amplifier and started thinking. I inspected all of circuitry and decided on what to do next. System had one stereo input and one 6-channel input, 4 buttons, encoder, 7-segment led display and IR receiver. And this is what I wanted to do:

  • PT2323 supports 4 stereo inputs and one 6-channel (add 3 stereo inputs to my design)
  • replace 7-segment led display with cool 2x16 red LCD module with black background
  • replace IR sensor that is for 38kHz to 36kHz for a Sony remote (I did not have original remote)
  • reuse encoder and 4 buttons (Mute->On/Off, 2.1/5.1->MUTE, BASS- -> MENU, BASS+ ->OK )
  • add a relay for amplifier power (you can still hear that annoying buzz in speakers when on stand-by)
  • add serial communication for controlling over Internet
  • 3 wires for controlling amplifier coming out (MUTE, SDA, SCL)
  • 3 wires for power coming out (+5V, +12V, GND)
  • 6 wires for amplifier power coming out (-12V|GND|+12V  - RELAY-  BACK TO AMPLIFIER)
  • 20 wires coming out for LCD and FRONT PANEL:
    • LCD (GND, +5V, lcdV, back light, R, E, D4, D5, D6, D7)
    • Front panel (Button 1, 2, 3, 4, encoder 1, 2, leds, IR, GND, +5V)
  • 7 wires coming out for 3 additional stereo inputs
    • L2, R2, L3, R3, L4, R4, GND
  • prepare all the wires coming out and soldered them to boards




Before I continue I will say that all this could be mounted inside the amplifier, but I like it this way. You can see all the effort went into this, otherwise you are looking in an ordinary amplifier bought in a store. It may be stupid for someone but for me... it keeps me warm inside knowing that this is my work.

Before I started doing anything else, I connected PT2323 and PT2258 SDA, SCL and GND to Arduino, and send some data over I2C to try out if it works. I used wire library for Arduino. It is already included in Arduino IDE and all commands were listed in data sheets. A quick test was a success and amplifier was working. Now I can continue with my design. 


Now that everything seemed ok, I put it all back together. I started thinking on which micro controller to use. I wanted to go with MSP430F2274, but it is not available in DIP package and I still haven't finished my UV lamp for creating circuits. So I decided to go with a DIP package soldered on breadboard. I needed 20 available I/O pins. And as luck would have it, ATMEGA328P for Arduino Uno has them, in DIP package and also I had one left. One thing I will miss though, MSP430 series have nice low power modes and put the chip to sleep. Arduino is a little bit different. But nevertheless, I don't need sleep mode because this is not battery powered application and power is not an issue. So I started drawing the schematic with consideration of which pin will do what.


UPDATE: Missing 100nF decoupling capacitor between reset and gnd line!

Now that the schematic was done, it is time to create it on a breadboard. You can download all three schematics at the end of this post in PDF format. For the preamplifier and amplifier schematic you will have to search the net. There are tons of schematics out there.


Now that the breadboard was done, I wired it up and finished with the hardware part. I also hot-glued all the wires and holes to be air tight as much as possible. All together took me about 48 hours for the hardware part (testing, inspecting, repairing and redesign).



Now I had an 5.1 amplifier system that still didn't work. Off to programming software. First of all I went on the net and found all the libraries I needed. This is library for I2C, internal eeprom, lcd, ir, encoder and interrupts. The I2C, LCD and internal EEPROM libraries are already included in Arduino IDE. The rest I found on the Internet. IR library from Ken Shirriff, that I used before, PinChangeInt library for interrupts and AdaEncoder library for rotary encoder. So special thanks to all the authors of these libraries that made my life easier. Here is how they are included:
#include <Wire.h>                        // I2C library    
#include <LiquidCrystal.h>               // LCD library   
#include <IRremote.h>                    // IR library                   
#include <PinChangeInt.h>                // Interrupt library    
#include <AdaEncoder.h>                  // Encoder library
#include <EEPROM.h>                      // Eeprom library  
Now I won't go into details on how these libraries work and how are they imported to Arduino IDE. All I can say is that they are easy to use and very well written.

A week of intense programming and my software was finished. Here is a short description of how it works:
  • on power on read default values from eeprom and store them to global variables
  • setup micro controller
  • set default status (on or stand-by)
  • loop():
    • check serial communication if anything received
    • check IR if anything received
    • check buttons and execute commands
    • update lcd if needed
  
This is a basic overview of how the software works, but it can also do a number of different things like:
  • enable or disable remote
  • enable or disable buttons
  • change default settings and store them in eeprom
  • lcd mode (always on, on for a period of time)
  • different info displayed on lcd for a period of time (on timeout)
  • software button debounce
  • delay between IR receive
  • full control with serial communication
  • anything audio related  (channel corrections, soft volume transition, enhance, boost...) 

Code:
// 5.1 amplifier system redesign
// by Neoxy <http://www.neoxy-yx.blogspot.com>
// matjaz.behek@gmail.com

// Special thanks to all the authors of included libraries

// Created 20 April 2012

/* Circuit:
 * LCD RS pin to digital pin 10
 * LCD Enable pin to digital pin 9
 * LCD D4 pin to digital pin 8
 * LCD D5 pin to digital pin 7
 * LCD D6 pin to digital pin 6
 * LCD D7 pin to digital pin 5
 
 * I2C SCL to analog pin 5
 * I2C SDA to analog pin 4
 
 * TX to digital pin 0
 * RX to digital pin 1
 
 * IR to digital pin 11
 
 * Relay to digital pin 4
 
 * Mute to analog 3
 
 * LED light and backlight to analog 2
 
 * Volume encoder I pin to digital pin 2  
 * Volume encoder II pin to digital pin 3
 * Button 1 to analog pin 0
 * Button 2 to analog pin 1
 * Button 3 to digital pin 12 
 * Button 4 to digital pin 13
 
 */

//******************************************************************************
// GLOBALS, FLAGS, INCLUDES, INTTERUPT FUNCTIONS  
//******************************************************************************

// includes
#include <Wire.h>                        // I2C library    
#include <LiquidCrystal.h>               // LCD library   
#include <IRremote.h>                    // IR library                   
#include <PinChangeInt.h>                // Interrupt library    
#include <AdaEncoder.h>                  // Encoder library
#include <EEPROM.h>                      // Eeprom library    

// delay defines (these are delays that don't slow down processor)
#define IR_WAIT       3500               // ir wait counts  
#define LCD_WAIT      100000             // lcd wait counts
#define INT_WAIT      3000               // interrupt debounce wait counts
#define TEMP_LCD_WAIT 50000              // temp lcd show wait counts 
#define volDELAY      50                 // this one is used for normal delay(); 

// IR mapped buttons
#define rMUTE  0x68b5f    // IR remote button MUTE (emulate button MUTE)
#define rON    0xa8b5f    // IR remote button ON (emulate button ON)
#define rCH    0xc8b5f    // IR remote button CHANNEL++
#define rMODE  0x28b5f    // IR remote button MODE++
#define rBASSP 0x9ebd0    // IR remote button BASS++
#define rBASSM 0x98bd0    // IR remote button BASS-- 
#define rREARP 0x8cb5f    // IR remote button REAR++
#define rREARM 0xcb5f     // IR remote button REAR-- 
#define rCENP  0x2cb5f    // IR remote button CENTER++
#define rCENM  0xccb5f    // IR remote button CENTER--
#define rVOLP  0x490      // IR remote button VOLUME++ (emulate ENCODER++)
#define rVOLM  0xc90      // IR remote button VOLUME-- (emulate ENCODER--)
#define rLCD   0x2ab5f    // IR remote button LCD ON/OFF
#define rENH   0x18bd0    // IR remote button ENHANCE ACTIVE/DISABLED
#define rBOOST 0x70b5f    // IR remote button BOOST ACTIVE/DISABLED
#define rMENU  0xd8b5f    // IR remote button MENU (emulate button MENU)
#define rOK    0xb0b5f    // IR remote button OK (emulate button OK)

// IR globals
int RECV_PIN = 11;        // Receive pin
IRrecv irrecv(RECV_PIN);  // Set receive
decode_results results;   // Received IR codes   

// Serial communication globals and flags
int bufferX[16] = {'\0','\0','\0','\0','\0','\0','\0','\0','\0','\0','\0','\0','\0','\0','\0','\0'};  // global buffer for received chars
int xyz = 0;                      // BufferX size count    
int kontrolaCMD = 0;              // Control flag for BufferX read
char *code = "AMP1";              // Serial starting code for our Amplifier

// global varaiables for LCD
LiquidCrystal lcd(10, 9, 8, 7, 6, 5);   // LCD pins
byte lcd_flag = 0;                      // flag for lcd update        

// These global values will be red from EEPROM 
byte volume = 0;                  // volume level 0-79
byte FL = 128;                    // front left volume level correct
byte FR = 128;                    // front right volume level correct
byte CE = 128;                    // center volume level correct
byte SU = 128;                    // sub left volume level correct
byte RL = 128;                    // rear left volume level correct    
byte RR = 128;                    // rear right volume level correct
byte CH = 0;                    // Selected channel 
byte enhance = 1;               // enhance select 
byte amp = 0;                   // +6dB boost select
byte mute = 0;                  // mute select
byte unit = 0;                  // unit on/stand-by state
byte mode = 0;                  // speaker mode

byte external_buttons = 1;              // enable external buttons
byte external_remote = 1;               // enable remote
byte enable_lcd = 1;                    // enable LCD (lcd on/off)
//----------------------------------------------------------------------

// other global values and flags
byte int1 = 0;                 // interrupt flag for button 1 (on/off)
byte int2 = 0;                 // interrupt flag for button 2 (mute)
byte int3 = 0;                 // interrupt flag for button 3 (menu)     
byte int4 = 0;                 // interrupt flag for button 4 (ok)
byte button_menus = 0;         // global variable for  main menu
int set_menu = 0;              // global variable for sub_menu 
int temp_menu = 0;             // global temp menu varaiable (for quick status)
int set_corrections_menu = 0;       // global variable for sub_menu of corrections
byte read_value = 0;                // read encoder flag value in menu
byte do_this = 0;                   // select menu flag
byte do_correct = 0;                // select correct flag
int temp1 = external_buttons;               // flag for enable buttons
int temp2 = external_remote;                // flag for enable remote
int temp3 = enable_lcd;                     // flag for enable lcd
int temp4 = unit;                           // flag for unit on/off

unsigned long counter_lcd = LCD_WAIT;       // delay counter for lcd change 
unsigned int ir_counter = IR_WAIT;          // delay counter for ir receive
unsigned int int_counter = INT_WAIT;        // delay counter for interrupt (debounce)
unsigned long temp_lcd_counter = TEMP_LCD_WAIT; // delay counter for temp LCD status show
byte debounce = 1;                          // debounce flag (when 1 debounce over, we can read value again)  

int encoder_value = 0;          // value for encoder
int8_t clicks = 0;              // encoder clicks   
char id = 0;                    // encoder ID       

//------------------------------------------------------------
// button interrupt actions (set flag to 1)
void but1func()         // set interrupt flag on button 1
{
  if(external_buttons == 1) int1 = 1;  // if buttons enabled, set flag (ON/OFF)
}

void but2func()         // set interrupt flag on button 2 (MUTE)
{
  if(external_buttons == 1) int2 = 1;
}

void but3func()         // set interrupt flag on button 3 (MENU)
{
  if(external_buttons == 1) int3 = 1;
}

void but4func()         // set interrupt flag on button 4 (OK)
{
  if(external_buttons == 1) int4 = 1;
}
//------------------------------------------------------------

//******************************************************************************
// SETUP AND POWER ON DEFAULTS
//******************************************************************************
void setup()
{
  if(EEPROM.read(16) != 23)    // very small chance that unknown eeprom value would be 23 :) (lucky gues I would say) 
  {                            // this will be done only once, this is to store default values
     EEPROM.write(16,23);       // on first power up, so we don't get unknown invalid eeprom values
     write_to_eeprom();
  }
    
  read_from_eeprom();   // load values from eeprom 

  pinMode(4, OUTPUT);     // as output (relay for amplifier power)
  pinMode(A3, OUTPUT);    // as output (mute)
  pinMode(A2, OUTPUT);    // as output (led lights) 

  digitalWrite(4, LOW);    // set 0  (relay for amplifier power) 
  digitalWrite(A3, LOW);   // set 0  (mute)
  digitalWrite(A2, LOW);   // set 0  (led lights)

  // attach interrupt, pull-up, on FALLING (from HIGH to LOW) 
  pinMode(A0, INPUT); 
  digitalWrite(A0, HIGH);            // set A0 input intterupt (ON/OFF)
  PCintPort::attachInterrupt(A0, &but1func, FALLING);
  pinMode(A1, INPUT); 
  digitalWrite(A1, HIGH);            // set A1 input intterupt (MUTE)
  PCintPort::attachInterrupt(A1, &but2func, FALLING);
  pinMode(12, INPUT); 
  digitalWrite(12, HIGH);            // set 12 input intterupt (MENU)
  PCintPort::attachInterrupt(12, &but3func, FALLING);
  pinMode(13, INPUT); 
  digitalWrite(13, HIGH);            // set 13 input intterupt (OK)
  PCintPort::attachInterrupt(13, &but4func, FALLING);

  AdaEncoder::addEncoder('a',2 ,3);  // encoder on pins 2 and 3

  delay(1000);          // wait for voltage stabilisation  
  Wire.begin();         // join I2C
  Serial.begin(9600);   // start serial communication
  irrecv.enableIRIn();  // start receiver
  lcd.begin(16, 2);     // start LCD
  lcd.noCursor();       // turn off cursor  
  pt2323(1);            // Stereo input 1 (so we don't leave our PT chip floating)
  pt2258(79, 0);        // -79dB All CH (mute)

  // From here the program begins
  set_unit();            // turn on/off with default settings
}

//******************************************************************************
// MAIN LOOP with timeout operation
//******************************************************************************
void loop()
{
  checkSerial();              // check for serial commands    

  if(external_remote == 1)    // if remote enabled 
  {
    checkIR();                // check for IR commands if enabled 
    if(ir_counter == IR_WAIT)   // just before timeout 
    {
      irrecv.resume();          // listen for new commands
      ir_counter++;             // count +1 to wait in next statement
    }  
    else if(ir_counter == IR_WAIT+1)    // here IR waits for a counter reset and values are checked 
    {
      // Do nothing
    }  
    else
    {
      ir_counter++;             // count to timeout   
    }
  }

  if(external_remote == 1 || external_buttons == 1) checkButtons();     // check for button commands if at least one enabled 

  if(temp_menu >= 3)        // if temporary LCD info is needed
  {
    button_menus = temp_menu;  // display info we need (just for some time)
    temp_menu = 0;          // reset value 
  }

  if(enable_lcd == 1 && lcd_flag == 1 && unit == 1)  // update lcd if unit is on, LCD is enabled and if an update is needed
  {   
    lcd_led_enable(1);        // turn on LCD
    update_lcd();             // update LCD info if enabled and lcd_flag set 
    lcd_flag = 0;             // reset flag 
  }
  if(enable_lcd == 0 && lcd_flag == 1 && unit == 1)    // show lcd for a shord period of time, if unit is on and if update is needed
  { 
    lcd_led_enable(1);        // turn on LCD and LEDs
    counter_lcd = 0;          // reset counter to start again  
    update_lcd();             // update LCD info 
    lcd_flag = 0;             // reset flag for LCD update
  }

  if(counter_lcd == LCD_WAIT && enable_lcd == 0)    // lcd timeout 
  {
    lcd_led_enable(0);                              // turn off display                
    counter_lcd++;                                  // count +1 to go in next statement where we will wait
  }
  else if(counter_lcd == LCD_WAIT+1)               // here counter will be stuck until called again (set to 0)     
  {
    // do nothing
  }
  else counter_lcd++;                               // counter_lcd++


  if(int_counter == INT_WAIT)       // on timeout enable reading of buttons (for debounce)   
  {
    debounce = 1;      // debounce over
    int_counter++;     // go in next statement where we will wait
  }
  else if(int_counter == INT_WAIT + 1)  // here counter is stuck until called again (set to 0)
  {
    // do nothing
  }
  else 
  {
    int_counter++;
  }

  if(temp_lcd_counter == TEMP_LCD_WAIT)       // on timeout show regular INFO on LCD, until then show temp INFO  
  {
    button_menus = 0;         // go in main menu (reset) from temp_menu
    temp_lcd_counter++;       // count +1 
    lcd_flag = 1;             // update LCD info
  }
  else if(temp_lcd_counter == TEMP_LCD_WAIT + 1)  // here we wait for another call
  {
    // do nothing
  }
  else 
  {
    temp_lcd_counter++;
  }
}

//******************************************************************************
// PT2323 AND PT2258 COMMAND SET 
//******************************************************************************
//------------------------------------------------------------------------------
// 2CH to 6CH translator and input selector command set
//------------------------------------------------------------------------------
void pt2323(byte command)
{
  Wire.beginTransmission(74);   // transmit to device 0x94(hex) -> 148(dec)(addressing is 7-bit) -> 148/2
  switch(command)
  {
  case 0:
    Wire.send(0xc7);   // 6-ch input
    break;
  case 4:
    Wire.send(0xc8);   // stereo 4 input
    break;
  case 3:
    Wire.send(0xc9);   // stereo 3 input
    break;
  case 2:
    Wire.send(0xca);   // stereo 2 input
    break;
  case 1:
    Wire.send(0xcb);   // stereo 1 input
    break;
  case 5:
    Wire.send(0xd0);   // enhance active
    break;
  case 6:
    Wire.send(0xd1);   // enhance disable
    break;
  case 7:
    Wire.send(0x90);   // 0dB setup
    break;
  case 8:
    Wire.send(0x91);   // +6dB setup
    break;
  case 9:
    Wire.send(0xf0);   // FL mute disabled
    break;
  case 10:
    Wire.send(0xf1);   // FL mute
    break;
  case 11:
    Wire.send(0xf2);   // FR mute disabled
    break;
  case 12:
    Wire.send(0xf3);   // FR mute
    break;
  case 13:
    Wire.send(0xf4);   // CE mute disabled
    break;
  case 14:
    Wire.send(0xf5);   // CE mute
    break;
  case 15:
    Wire.send(0xf6);   // SU mute disabled
    break;
  case 16:
    Wire.send(0xf7);   // SU mute
    break;
  case 17:
    Wire.send(0xf8);   // SL mute disabled
    break;
  case 18:
    Wire.send(0xf9);   // SL mute
    break;
  case 19:
    Wire.send(0xfa);   // SR mute disabled
    break;
  case 20:
    Wire.send(0xfb);   // SR mute
    break;
  case 21:
    Wire.send(0xfe);   // All CH mute disabled
    break;
  default:
    Wire.send(0xff);   // All CH mute
    break; 
  }
  Wire.endTransmission();     // stop transmitting  
}

//------------------------------------------------------------------------------
// Volume controller IC command set
//------------------------------------------------------------------------------
void pt2258(byte command, byte ch)  // send volume level commands
{
  byte x10;
  byte x1; 

  if(command >= 10)
  {
    x10 = command/10;        // set decade step
    x1 = command % 10;       // set step
  }
  else                       // set step       
  {
    x1 = command;
    x10 = 0;
  }

  switch(ch)                 // which channel to command 
  {
  case 0:    // all channels
    x1 = x1 + 0xe0;
    x10 = x10 + 0xd0;
    break;

  case 1:    // channel 1
    x1 = x1 + 0x90;
    x10 = x10 + 0x80;
    break;

  case 2:    // channel 2
    x1 = x1 + 0x50;
    x10 = x10 + 0x40;
    break;

  case 3:    // channel 3
    x1 = x1 + 0x10;
    x10 = x10 + 0x00;
    break;

  case 4:    // channel 4
    x1 = x1 + 0x30;
    x10 = x10 + 0x20;
    break;

  case 5:    // channel 5
    x1 = x1 + 0x70;
    x10 = x10 + 0x60;
    break;

  case 6:    // channel 6
    x1 = x1 + 0xb0;
    x10 = x10 + 0xa0;
    break;

  default:   // mute functions    
    if(command == 0) x10, x1 = 0xf8;   // mute off
    else x10, x1 = 0xf9;               // mute on       
    break;
  }

  for(int i = 0; i <= 2; i++)  // repeat 2x (had some unknown issues when transmitted only once)
  {  
    Wire.beginTransmission(68); // transmit to device 0x88(hex) -> 136(dec)(addressing is 7-bit) -> 136/2
    Wire.send(x10);             // send decade step         
    Wire.send(x1);              // send step
    Wire.endTransmission();     // stop transmitting   
  }  
}

//******************************************************************************
// AUDIO SETTINGS
//******************************************************************************
//------------------------------------------------------------------------------
// Set volume in steps (soft volume change)
//------------------------------------------------------------------------------
void set_volume(byte begin_from, byte to_level)
{ 
  // calculate corrects 
  int var1 = 0;    // FL
  int var2 = 0;    // FR
  int var3 = 0;    // CE
  int var4 = 0;    // SU
  int var5 = 0;    // RR
  int var6 = 0;    // RL

  var1 = FL-128;
  var2 = FR-128;
  var3 = CE-128;
  var4 = SU-128;
  var5 = RR-128;
  var6 = RL-128;

  // set volume + corrects
  int y;

  if(begin_from < to_level)          // increse volume
  {
    for(y = begin_from; y < to_level; y++)
    {  
      if((0 <= (79 - (y + var1))) && (79 >= (79 - (y + var1))))  pt2258(79 - (y + var1), 1);  // send value if in 0-79 range
      if((0 <= (79 - (y + var2))) && (79 >= (79 - (y + var2))))  pt2258(79 - (y + var2), 2);  
      if((0 <= (79 - (y + var3))) && (79 >= (79 - (y + var3))))  pt2258(79 - (y + var3), 3);
      if((0 <= (79 - (y + var4))) && (79 >= (79 - (y + var4))))  pt2258(79 - (y + var4), 4);
      if((0 <= (79 - (y + var5))) && (79 >= (79 - (y + var5))))  pt2258(79 - (y + var5), 5);
      if((0 <= (79 - (y + var6))) && (79 >= (79 - (y + var6))))  pt2258(79 - (y + var6), 6);

      delay(volDELAY);  // delay for a soft transition of volume
    }
  } 
  else if(begin_from > to_level)      // decrease volume
  {
    for(y = begin_from; y > to_level; y--)
    {
      if((0 <= (79 - (y + var1))) && (79 >= (79 - (y + var1))))  pt2258(79 - (y + var1), 1);  // send value if in 0-79 range
      if((0 <= (79 - (y + var2))) && (79 >= (79 - (y + var2))))  pt2258(79 - (y + var2), 2);  
      if((0 <= (79 - (y + var3))) && (79 >= (79 - (y + var3))))  pt2258(79 - (y + var3), 3);
      if((0 <= (79 - (y + var4))) && (79 >= (79 - (y + var4))))  pt2258(79 - (y + var4), 4);
      if((0 <= (79 - (y + var5))) && (79 >= (79 - (y + var5))))  pt2258(79 - (y + var5), 5);
      if((0 <= (79 - (y + var6))) && (79 >= (79 - (y + var6))))  pt2258(79 - (y + var6), 6);

      delay(volDELAY);
    }
  }
  else          // same volume just corrects, here we don't need soft transition
  {
    var1 = var1 + volume;
    if(var1 < 0) var1 = 0;
    if(var1 > 79) var1 = 79;
    var2 = var2 + volume;
    if(var2 < 0) var2 = 0;
    if(var2 > 79) var2 = 79;
    var3 = var3 + volume;
    if(var3 < 0) var3 = 0;
    if(var3 > 79) var3 = 79;
    var4 = var4 + volume;
    if(var4 < 0) var4 = 0;
    if(var4 > 79) var4 = 79;
    var5 = var5 + volume;
    if(var5 < 0) var5 = 0;
    if(var5 > 79) var5 = 79;
    var6 = var6 + volume;
    if(var6 < 0) var6 = 0;
    if(var6 > 79) var6 = 79;

    // send new values for each channel
    pt2258(79 - var1, 1);
    pt2258(79 - var2, 2);
    pt2258(79 - var3, 3);
    pt2258(79 - var4, 4);
    pt2258(79 - var5, 5);
    pt2258(79 - var6, 6);
  }
  if(to_level >= 79) to_level = 79;    // do not exceed 79
  if(to_level <= 0)  to_level = 0;     // do not go in -
  volume = to_level;
  if(volume == 0) pt2258(79,0);        // mute all channels  (otherwise you could hear volume of + correct)
}

//------------------------------------------------------------------------------
// Set speaker mode
//------------------------------------------------------------------------------
void set_mode()    // set speaker mode
{
  switch(mode)
  {
  case 1:                      // 2.1 mode
    pt2323(14);  // disable CE 
    pt2323(18);  // disable RL
    pt2323(20);  // disable RR
    break;
  case 2:                      // 3.1 mode
    pt2323(13);  // enable CE
    pt2323(18);  // disable RL
    pt2323(20);  // disable RR
    break;
  case 3:                      // 4.1 mode
    pt2323(14);  // disable CE
    pt2323(17);  // enable RL
    pt2323(19);  // enable RR
    break;
  default:                     // 5.1 mode
    pt2323(13);  // disable CE
    pt2323(17);  // enable RL
    pt2323(19);  // enable RR 
    break;
  }
}

//------------------------------------------------------------------------------
// Set enhance
//------------------------------------------------------------------------------
void set_enhance()
{
  if(enhance == 1) pt2323(5); // enhance enabled
  else pt2323(6);
}

//------------------------------------------------------------------------------
// Set +6dB setup
//------------------------------------------------------------------------------    
void set_amp()
{
  if(amp == 1) pt2323(8);   // boost enabled
  else pt2323(7);
}

//------------------------------------------------------------------------------
// Select channel
//------------------------------------------------------------------------------
void set_ch()
{
  pt2323(CH);   // set channel
}

//------------------------------------------------------------------------------
// Set mute
//------------------------------------------------------------------------------
void set_mute()
{
  if(mute == 0)
  { 
    amplifier_enable(1);         // enable amplifier
  }
  else
  {
    amplifier_enable(0);         // disable amplifier
  }
}

//------------------------------------------------------------------------------
// Set unit (power)
//------------------------------------------------------------------------------
void set_unit()
{
  if(unit == 1) // power on
  {
    default_flags();           // load default flags on power up 
    lcd_led_enable(1);         // enable lcd and leds
    lcd.setCursor(1, 0);       // cursor at 2nd character, 1 line 
    lcd.print("5.1  Amplifier");
    lcd.setCursor(1, 1);       // cursor at 2nd character, 2 line 
    lcd.print("   by Neoxy   ");
    delay(2500);               // here we can afford a delay like this
    lcd.clear();
    lcd.setCursor(1, 0);       // cursor at 2nd character, 1 line 
    lcd.print("  Turning ON  ");

    set_ch();                      // set channel
    set_mode();                    // set mode      
    set_enhance();                 // set enhance mode 
    set_amp();                     // set +6dB setup
    set_volume(0, volume);         // set volume from level 0 to level volume
    set_mute();                    // set mute
    delay(1500);

    lcd_flag = 1;     // update lcd  
  }
  else
  {
    amplifier_enable(0);       // turn off amplifier 
    lcd.clear();
    lcd_led_enable(1);        // enable lcd and leds
    lcd.setCursor(1, 0);       // cursor at 2nd character, 1 line 
    lcd.print("   Stand-by   ");
    delay(2000); // here we can afford a delay like this
    lcd.clear();    
    lcd_led_enable(0);         // turn off LCD and LED lights
    lcd_flag = 0;              // do not update lcd
  }  
}

//------------------------------------------------------------------------------
// Enable or disable amplifier
//------------------------------------------------------------------------------
void amplifier_enable(byte cmd)    // enable or disable amplifier
{
  if(cmd == 1)                           // turn on amplifier 
  {
    digitalWrite(4, HIGH);   // relay on
    delay(200);                // small delay like this does not influence operation much
    digitalWrite(A3, HIGH);   // mute off
  }
  else                                   // turn off amplifier
  {
    digitalWrite(A3, LOW);   // mute on
    delay(50);
    digitalWrite(4, LOW);   // relay off
  } 
}

//------------------------------------------------------------------------------
// Enable or disable LCD and LED lights
//------------------------------------------------------------------------------
void lcd_led_enable(byte cmd)      // enable or disable lcd
{
  if(cmd == 1)                           // turn on or off LCD and leds 
  {
    digitalWrite(A2, HIGH);    // leds on
    lcd.display();             // turn on display
  }
  else
  {
    digitalWrite(A2, LOW);    // leds off
    lcd.noDisplay();          // turn off display
  }
}

//******************************************************************************
// SERIAL COMMUNICATION
//******************************************************************************
//------------------------------------------------------------------------------
// Check Serial Communication, verify code and execute command
//------------------------------------------------------------------------------
void checkSerial()              // check serial commands
{
  byte temp;    // temp value
  byte c;       // received char 
  if(Serial.available() > 0)     // If something received
  {
    while(Serial.available() != 0 && kontrolaCMD == 0) // read incomming bytes if flag = 0
    {
      c = Serial.read();   // read receaved byte from serial buffer
      if(c == 13 || c == 10 || xyz >= 16 ) kontrolaCMD = 1;  // if end of line received or temp buffer size exceeded escape, set flag to 1  
      else                    
      { 
        bufferX[xyz] = c;      // store in our temp buffer
        xyz++;                 // increment bufferX position
      }    
    } 

    if(kontrolaCMD==1)        // If EOL detected or buffer size exceeded  
    {
      if(compareStr(0,code) == 1)    // compare if code is a match (our case "AMP1")
      {
        if(compareStr(4, "00") == 1)    // next code 00 (stand-by, on)
        {
          lcd_flag = 1;    // here we want a lcd update
          temp = toNum(6);  

          if(temp <= 1)    // only default values
          {
            if(unit != temp)
            {
              unit = temp;
              set_unit();
            }
          }
          Serial.print(code);          // send back OK when done
          Serial.println("OK");
        }
        else if(compareStr(4, "01") == 1)   // code 01 (set channel)
        {
          lcd_flag = 1;    // here we want a lcd update
          temp = toNum(6);
          if(temp <= 4)
          {
            if(temp != CH)
            {
              CH = temp;
              set_ch();
            }
          }
          Serial.print(code);
          Serial.println("OK");
        }
        else if(compareStr(4, "02") == 1)   // code 02 (set mode)
        {
          lcd_flag = 1;  // here we want a lcd update
          temp = toNum(6);
          if(temp <= 3)
          {
            if(temp != mode)
            {
              mode = temp;
              set_mode();
            }
          }
          Serial.print(code);
          Serial.println("OK");
        }
        else if(compareStr(4, "03") == 1)   // code 03 (set correction), here we don't need a lcd update (lcd_flag not set) 
        {
          temp = toNum(8);
          if(temp <= 168 && temp >= 88)
          {
            if(compareStr(6, "FL"))              // no problem here if same value is set
            {
              FL = temp;
            }
            else if(compareStr(6, "FR"))
            {
              FR = temp;
            }
            else if(compareStr(6, "CE"))
            {
              CE = temp;
            }
            else if(compareStr(6, "SU"))
            {
              SU = temp;
            }
            else if(compareStr(6, "RL"))
            {
              RL = temp;
            }
            else if(compareStr(6, "RR"))
            {
              RR = temp;
            }
            set_volume(volume,volume);
          }
          Serial.print(code);
          Serial.println("OK");
        }
        else if(compareStr(4, "04") == 1)  // code 04 (set enhance)
        {
          lcd_flag = 1; 
          if(toNum(6) <= 1)
          {
            enhance = toNum(6);
            set_enhance();
          }
          Serial.print(code);
          Serial.println("OK");
        }
        else if(compareStr(4, "05") == 1)  // code 05 (set amp)
        {
          lcd_flag = 1;
          if(toNum(6) <= 1)
          {
            amp = toNum(6);
            set_amp();
          }
          Serial.print(code);
          Serial.println("OK");
        }
        else if(compareStr(4, "06") == 1)  // code 06 (set volume)
        {
          lcd_flag = 1;
          if(toNum(6) <= 79)
          {
            set_volume(volume, toNum(6)); // from current volume to new volume
          }
          Serial.print(code);
          Serial.println("OK"); 
        }
        else if(compareStr(4, "07") == 1)  // set mute
        {
          lcd_flag = 1;
          if(toNum(6) <= 1)
          {
            mute = toNum(6);
            set_mute();
          }
          Serial.print(code);
          Serial.println("OK");
        }
        else if(compareStr(4, "08") == 1)  // set buttons 
        {
          if(toNum(6) <= 1)
          {
            external_buttons = toNum(6);
          }
          Serial.print(code);
          Serial.println("OK");
        }
        else if(compareStr(4, "09") == 1)  // set remote
        {
          if(toNum(6) <= 1)
          {
            external_remote = toNum(6);
          }
          Serial.print(code);
          Serial.println("OK");
        }
        else if(compareStr(4, "10") == 1)  // set lcd enable
        {
          lcd_flag = 1;
          if(toNum(6) <= 1)
          {
            enable_lcd = toNum(6);
          }
          Serial.print(code);
          Serial.println("OK");           
        }
        else if(compareStr(4, "11") == 1)  // store in flash
        {
          write_to_eeprom();
          Serial.print(code);
          Serial.println("OK");
        }
        else if(compareStr(4, "20") == 1)  // return main status
        {
          Serial.print(code);
          Serial.print("P");
          Serial.print(unit, DEC);
          Serial.print("C");
          Serial.print(CH, DEC);
          Serial.print("M");
          Serial.print(mode, DEC);
          Serial.print("E");
          Serial.print(enhance, DEC);
          Serial.print("A");
          Serial.print(amp, DEC);
          Serial.print("V");
          if(volume<10) Serial.print("0");
          Serial.print(volume, DEC);
          Serial.print("MU");
          Serial.print(mute, DEC);
          Serial.print("B");
          Serial.print(external_buttons, DEC);
          Serial.print("R");
          Serial.print(external_remote, DEC);
          Serial.print("L");
          Serial.println(enable_lcd, DEC);
        }
        else if(compareStr(4, "21") == 1)  // return correction settings
        {
          Serial.print(code);
          Serial.print("L");
          if(FL<10) Serial.print("0");
          if(FL<100) Serial.print("0");
          Serial.print(FL, DEC); 
          Serial.print("R");
          if(FR<10) Serial.print("0");
          if(FR<100) Serial.print("0");
          Serial.print(FR, DEC);
          Serial.print("S");
          if(SU<10) Serial.print("0");
          if(SU<100) Serial.print("0");
          Serial.print(SU, DEC);
          Serial.print("C");
          if(CE<10) Serial.print("0");
          if(CE<100) Serial.print("0");
          Serial.print(CE, DEC);
          Serial.print("L");
          if(RL<10) Serial.print("0");
          if(RL<100) Serial.print("0");
          Serial.print(RL, DEC);
          Serial.print("R");
          if(RR<10) Serial.print("0");
          if(RR<100) Serial.print("0");
          Serial.println(RR, DEC);
        }
        else
        {
          // do nothing, inccorect code
        } 
      }
      bufXClear();            // Clear BufferX
      xyz = 0;                // reset bufferX counter
      kontrolaCMD = 0;        // Read again flag
    }
  }
}

//------------------------------------------------------------------------------
// Convert  1, 2 or 3 chars to number (Location in bufferX at startLocation)
//------------------------------------------------------------------------------
int toNum(byte startLocation)
{
  char numbers[10] = {
    '0','1','2','3','4','5','6','7','8','9'  };  // array of chars (numbers)
  byte flag_nmb = 0;    // flag for number found 

  int x = 0;

  for(int i = 0; i < 10; i++)          // check first loction for number
  {
    if(bufferX[startLocation] == numbers[i]) x = x + (i*100), flag_nmb = 1;
  }

  if(flag_nmb == 0) return 0;  // number not found
  flag_nmb = 0;                // reset flag

  for(int i = 0; i < 10; i++)         // check second location for number
  {
    if(bufferX[startLocation+1]== numbers[i]) x = x + (i*10), flag_nmb = 1; 
  }

  if(flag_nmb == 0) // number on second location not found
  {
    if(x != 0 )return x/100;    // we don't want to divide by 0 (end of the world and stuff.. :)
    else return 0;
  }

  flag_nmb = 0; // reset flag

  for(int i = 0; i < 10; i++)  // check third location for number
  {
    if(bufferX[startLocation+2]== numbers[i]) x = x + i, flag_nmb = 1; 
  }

  if(flag_nmb == 0)  // number on third location not found
  {
    if(x != 0 ) return x/10;   // we don't want to divide by 0 (end of the world and stuff.. :)
    else return 0;
  }

  if(x >= 256) return 0;
  return x;    // if all 3 numbers found 
}

//------------------------------------------------------------------------------
// Clear temp Serial buffer
//------------------------------------------------------------------------------
void bufXClear()          // clear serial buffer
{
  for(int x = 0; x < 16; x++)   // clear bufferX
  {
    bufferX[x] = '\0';            // \0 in ASCII end of string
  }
}

//------------------------------------------------------------------------------
// Commpare bufferX from location startPos with another string
//------------------------------------------------------------------------------
byte compareStr(int startPos, char *nekaj)
{
  int comp = 1;
  while(*nekaj)
  {
    if(bufferX[startPos] != *nekaj++) comp = 0;
    startPos++;
  }
  return comp;
}

//******************************************************************************
// EXTERNAL BUTTONS
//******************************************************************************
//------------------------------------------------------------------------------
// External buttons command execute, move between menus
//------------------------------------------------------------------------------
void checkButtons()             // check button interrupts
{
  if(read_button1() == 1)        // read on/off (allways)
  {
    if(unit == 1)
    {
      unit = 0;
      set_unit();
    }
    else
    {
      unit = 1;
      set_unit();
    }
  }

  if(read_button2() == 1)          // read mute
  {
    if(mute == 1)
    {
      mute = 0;
      set_mute();
    }
    else
    {
      mute = 1;
      set_mute();
    }
    lcd_flag = 1; // update lcd
  }

  int tempvalue = 0;                  // temp value    
  byte butn_menu = read_button3();    // read button menu and work with this value  
  byte butn_ok = read_button4();      // read button ok and work with this value
  check_encoder();                    // read encoder and work with this value

  if(butn_menu == 1) lcd_flag = 1;      // if button pressed update lcd
  if(butn_ok == 1) lcd_flag = 1;        // if button pressed update lcd
  if(encoder_value != 0) lcd_flag = 1;  // if encoder turned update lcd

  if(butn_ok == 1 && do_this == 0 && button_menus == 1)    // toggle do_this with OK button (depends on where in menu are we)
  {
    do_this = 1;
  }  
  else if(butn_ok == 1 && do_this == 1 && button_menus == 1)
  {
    do_this = 0;
    read_value = 1;             // here flag is set to change menu with encoder, and not change value 
  }
  else 
  {
    // do nothing
  }

  if(butn_ok == 1 && do_correct == 0  && button_menus == 2)  // toggle do_correct with OK button (depends on where in menu are we)
  {
    do_correct = 1;
  }
  else if(butn_ok == 1 && do_correct == 1  && button_menus == 2)
  {
    do_correct = 0;
    read_value = 1;              // here flag is set to change menu with encoder, and not change value
  }
  else 
  {
    // do nothing
  }


  if(butn_menu == 1)          // read menu if button pressed, move between menus (depends on where we are), also set default flags
  {  
    if(button_menus == 0) button_menus = 1, read_value = 1, set_menu = 0,  do_correct = 0, do_this = 0;
    else if(button_menus == 2) button_menus = 1, set_menu = 2, do_correct = 0, do_this = 0;
    else button_menus = 0, read_value = 1, set_menu = 0,  do_correct = 0, do_this = 0;
  }

  // Programmed menues
  switch(button_menus)
  {
  case 0:      // default - status  only change volume, show status
    do_correct = 0;
    do_this = 0;
    temp1 = external_buttons;                     // flag for enable buttons, latter used for APPLY and STORE, other changes take effect immediatly
    temp2 = external_remote;                      // flag for enable remote
    temp3 = enable_lcd;                           // flag for enable lcd
    temp4 = unit;                                 // flag for unit on/off
    if(encoder_value != 0)        // if encoder is not 0
    {
      if(volume + encoder_value > 79) set_volume(volume, 79);
      else if(volume + encoder_value < 0 ) set_volume(volume, 0);
      else set_volume(volume, (volume + encoder_value));
      set_menu = 0;            // in main menu we change volume with encoder 
      read_value = 1;     
    }
    break;

  case 1:      // go in menu selection (if menu pressed)
    do_correct = 0;
    if(read_value == 1)       // we are in menu and we move between him with encoder
    { 
      set_menu = set_menu + encoder_value;
      if(set_menu < 0) set_menu = 13;
      if(set_menu > 13) set_menu = 0;
    }
    switch(set_menu)  // jump between menus
    {
    case 0:    // set CH
      if(do_this == 1) // if OK pressed, encoder is used to change value and not move between menu
      {
        read_value = 0;                          // dont'leave this menu, set value
        if(CH + encoder_value < 0) CH = 4;
        else if(CH + encoder_value > 4) CH = 0;
        else CH = CH + encoder_value;
        if(encoder_value != 0) set_ch();         // if we have a value on encoder, execute command
      }
      else read_value = 1;                       // move between menu, encoder used for this 
      break;

    case 1:    // set mode
      if(do_this == 1)
      {
        read_value = 0;  // dont'leave this menu, set value
        if(mode + encoder_value < 0) mode = 3;
        else if(mode + encoder_value > 3) mode = 0;
        else mode = mode + encoder_value;
        if(encoder_value != 0) set_mode();
      }
      else read_value = 1;
      break;

    case 2:    // set correct
      if(do_this == 1)
      {
        read_value = 1;
        button_menus = 2;  // go in corrections menu  
      }
      else 
      {  
        read_value = 1;
        set_corrections_menu = 0;
      }
      break;

    case 3:    // set enhence
      if(do_this == 1)
      {
        read_value = 0;  // dont'leave this menu, set value
        if(enhance + encoder_value <= 0) enhance = 0;
        if(enhance + encoder_value >= 1) enhance = 1;
        if(encoder_value != 0) set_enhance();
      }
      else read_value = 1;
      break;

    case 4:    // set boost
      if(do_this == 1)
      {
        read_value = 0;  // dont'leave this menu, set value
        if(amp + encoder_value <= 0) amp = 0;
        if(amp + encoder_value >= 1) amp = 1;
        if(encoder_value != 0) set_amp();
      }
      else read_value = 1;
      break;

    case 5:    // set mute
      if(do_this == 1)
      {
        read_value = 0;  // dont'leave this menu, set value
        if(mute + encoder_value <= 0) mute = 0;
        if(mute + encoder_value >= 1) mute = 1;
        if(encoder_value != 0) set_mute();
      }
      else read_value = 1;
      break;

    case 6:    // set volume
      if(do_this == 1)
      {
        read_value = 0;  // dont'leave this menu, set value
        tempvalue = volume + encoder_value;
        if(tempvalue < 0) tempvalue = 0;
        if(tempvalue > 79) tempvalue = 79;
        if(encoder_value != 0) set_volume(volume, tempvalue);
      }
      else read_value = 1;
      break;

    case 7:    // set buttons
      if(do_this == 1)
      {
        read_value = 0;  // dont'leave this menu, set value
        if(external_buttons + encoder_value <= 0 && encoder_value != 0) temp1 = 0;  // value stored in temp value, will be set on APPLY or STORE
        if(external_buttons + encoder_value >= 1 && encoder_value != 0) temp1 = 1;
      }
      else read_value = 1;
      break;

    case 8:    // set remote
      if(do_this == 1)
      {
        read_value = 0;  // dont'leave this menu, set value
        if(external_remote + encoder_value <= 0 && encoder_value != 0) temp2 = 0;  // value stored in temp value, will be set on APPLY or STORE
        if(external_remote + encoder_value >= 1 && encoder_value != 0) temp2 = 1;
      }
      else read_value = 1;
      break;

    case 9:    // set lcd
      if(do_this == 1)
      {
        read_value = 0;  // dont'leave this menu, set value
        if(enable_lcd + encoder_value <= 0 && encoder_value != 0) temp3 = 0;    // value stored in temp value, will be set on APPLY or STORE
        if(enable_lcd + encoder_value >= 1 && encoder_value != 0) temp3 = 1;
      }
      else read_value = 1;
      break;

    case 10:    // set on/off
      if(do_this == 1)
      {
        read_value = 0;  // dont'leave this menu, set value
        if(unit + encoder_value <= 0 && encoder_value != 0) temp4 = 0;   // value stored in temp value, will be set on APPLY or STORE
        if(unit + encoder_value >= 1 && encoder_value != 0) temp4 = 1;
      }
      else read_value = 1;
      break;

    case 11:    // set apply
      if(do_this == 1)
      {
        read_value = 0;  // dont'leave this menu, set value
        external_buttons = temp1;    // set globals with temp values, we don't need to set unit ON/OFF because we don't want to turn our unit off
        external_remote = temp2;
        enable_lcd = temp3; 

        button_menus = 0;    // return in main menu
      }
      break;

    case 12:    // set store
      if(do_this == 1)
      {
        read_value = 0;  // dont'leave this menu, set value
        external_buttons = temp1;    // set globals with temp values
        external_remote = temp2;
        enable_lcd = temp3;
        unit = temp4;

        button_menus = 0;
        write_to_eeprom();  // store in eeprom
        
        unit = 1;  // set flag for unit ON, because we don't want to turn off unit, just store the value as default
      }
      break;

    default:   // exit
      if(do_this == 1)
      {
        button_menus = 0;    // go in main menu
      }
      break;
    }
    break;

  case 2:
    do_this = 0;
    if(read_value == 1)       // we are in sub menu for correction
    { 
      set_corrections_menu = set_corrections_menu + encoder_value;    // move between menu with encoder
      if(set_corrections_menu < 0) set_corrections_menu = 6;
      if(set_corrections_menu > 6) set_corrections_menu = 0;
    }
    switch(set_corrections_menu)      // go in sub menu
    {
    case 0:    // set FL
      if(do_correct == 1)
      {
        read_value = 0;  // dont'leave this menu, set value
        if(FL + encoder_value < 88) FL = 88;
        else if(FL + encoder_value > 168) FL = 168;
        else FL = FL + encoder_value;
      }
      else read_value = 1;
      break;

    case 1:    // set FR
      if(do_correct == 1)
      {
        read_value = 0;  // dont'leave this menu, set value
        if(FR + encoder_value < 88) FR = 88;
        else if(FR + encoder_value > 168) FR = 168;
        else FR = FR + encoder_value;
      }
      else read_value = 1;
      break;

    case 2:    // set SU
      if(do_correct == 1)
      {
        read_value = 0;  // dont'leave this menu, set value
        if(SU + encoder_value < 88) SU = 88;
        else if(SU + encoder_value > 168) SU = 168;
        else SU = SU + encoder_value;
      }
      else read_value = 1;
      break;

    case 3:    // set CE
      if(do_correct == 1)
      {
        read_value = 0;  // dont'leave this menu, set value
        if(CE + encoder_value < 88) CE = 88;
        else if(CE + encoder_value > 168) CE = 168;
        else CE = CE + encoder_value;
      }
      else read_value = 1;
      break;

    case 4:    // set RR
      if(do_correct == 1)
      {
        read_value = 0;  // dont'leave this menu, set value
        if(RR + encoder_value < 88) RR = 88;
        else if(RR + encoder_value > 168) RR = 168;
        else RR = RR + encoder_value;
      }
      else read_value = 1;
      break;

    case 5:    // set RL
      if(do_correct == 1)
      {
        read_value = 0;  // dont'leave this menu, set value
        if(RL + encoder_value < 88) RL = 88;
        else if(RL + encoder_value > 168) RL = 168;
        else RL = RL + encoder_value;
      }
      else read_value = 1;
      break;

    default:   // go back
      if(do_correct == 1)
      { 
        set_menu = 2;    // set defaults for previous menu  
        do_correct = 0;
        read_value = 1;
        button_menus = 1; 
      }
      else read_value = 1;
      break;
    }
    if(do_correct == 1 && encoder_value != 0) set_volume(volume, volume);  // if a value was on encoder execute command
    break;

  default:    // should not go here
    break;
  }
  encoder_value = 0;        // reset value 
}

//------------------------------------------------------------------------------
// Check encoder clicks, and buttons
//------------------------------------------------------------------------------
void check_encoder()      // check encoder status
{
  encoder *thisEncoder;
  if(external_buttons == 1 && unit == 1) // if buttons enabled and unit is on
  {
    thisEncoder=AdaEncoder::genie(&clicks, &id);    // check clicks
    if(clicks != 0)    
    {
      if(clicks > 1) clicks = 1;      // move only with 1 in either direction
      if(clicks < -1) clicks = -1;
      encoder_value = clicks;         // store in global value
    }
  }
  clicks = 0;    // reset clicks
}

//------------------------------------------------------------------------------
byte read_button1()  // on/off
{
  if(int1 == 1 && debounce == 1)  // read if interrupt flag set and debounce over
  {
    debounce = 0;          // reset debounce
    int_counter = 0;       // reset debounce counter
    int1 = 0; 
    return 1;
  }
  int1 = 0;   // reset flag (in case debounce was not timed out and interrupt flag was set)
  return 0;
}

//------------------------------------------------------------------------------
byte read_button2()   // mute 
{
  if(int2 == 1 && unit == 1 && debounce == 1) // read only if unit is on, on interrupt and debounce over 
  {
    debounce = 0;
    int_counter = 0;
    int2 = 0;
    return 1;
  }
  int2 = 0;  // reset flag (in case debounce was not timed out and interrupt flag was set)
  return 0;
}

//------------------------------------------------------------------------------
byte read_button3()    // menu
{
  if(int3 == 1 && unit == 1 && debounce == 1)
  {
    debounce = 0;
    int_counter = 0;
    int3 = 0;
    return 1;
  }
  int3 = 0;
  return 0;
}

//------------------------------------------------------------------------------
byte read_button4()    // ok
{
  if(int4 == 1 && unit == 1 && debounce == 1)
  {
    debounce = 0;
    int_counter = 0;
    int4 = 0;
    return 1;
  }
  int4 = 0;
  return 0;
}

//******************************************************************************
// REMOTE 
//******************************************************************************
//------------------------------------------------------------------------------
// Remote commands execute
//------------------------------------------------------------------------------
void checkIR()                  // check IR commands
{
  if((irrecv.decode(&results) != 0))  // if something received
  {
    //Serial.println(results.value, HEX);  // here you can uncomment this to listen for values of unknown remote
    if(((unit == 0 && results.value == rON) || unit == 1) && (IR_WAIT+1) == ir_counter) // check if unit is on, if unit is off (just power button), and if timedout
    {
      ir_counter = 0;         // reset timeout counter
      switch(results.value)
      {
      case rON:       // on/off
        int1 = 1;          // emulate button pressed (set interrupt flag)
        break;

      case rMUTE:     // mute
        int2 = 1;
        break;

      case rCH:     // ch
        CH++;
        if (CH == 5) CH = 0;  // do not exceed 4, set back to 0
        set_ch();
        lcd_flag = 1;    // here we want lcd to update
        break;

      case rMODE:     // mode
        mode++;
        if (mode == 4) mode = 0;
        set_mode();
        lcd_flag = 1;
        break;

      case rBASSP:     // bass+
        temp_menu = 3;                // temp lcd info will be shown
        temp_lcd_counter = 0;         // temp lcd counter reset   
        if (SU >= 168) SU = 168;
        else SU++;
        set_volume(volume,volume);
        lcd_flag = 1;
        break;

      case rBASSM:     // bass-
        temp_menu = 3;
        temp_lcd_counter = 0;
        if (SU <= 88) SU = 88;
        else SU--;
        set_volume(volume,volume);
        lcd_flag = 1;
        break;

      case rREARP:     // rear+
        temp_menu = 5;
        temp_lcd_counter = 0;
        if (RR >= 168) RR = 168;
        else RR++;
        if (RL >= 168) RL = 168;
        else RL++;
        set_volume(volume,volume);
        lcd_flag = 1;
        break;

      case rREARM:     // rear-
        temp_menu = 5;
        temp_lcd_counter = 0;
        if (RR <= 88) RR = 88;
        else RR--;
        if (RL <= 88) RL = 88;
        else RL--;
        set_volume(volume,volume);
        lcd_flag = 1;
        break;

      case rCENP:     // center+
        temp_menu = 6;
        temp_lcd_counter = 0;
        if (CE >= 168) CE = 168;
        else CE++;
        set_volume(volume,volume);
        lcd_flag = 1;
        break;

      case rCENM:     // center-
        temp_menu = 6;
        temp_lcd_counter = 0;
        if (CE <= 88) CE = 88;
        else CE--;
        set_volume(volume,volume);
        lcd_flag = 1;
        break;

      case rVOLP:     // vol+
        encoder_value++; 
        lcd_flag = 1;
        break;
      case rVOLM:     // vol-
        encoder_value--;
        lcd_flag = 1;
        break;

      case rLCD:     // lcd on/off
        temp_menu = 4;
        temp_lcd_counter = 0;
        enable_lcd++;
        if (enable_lcd == 2) enable_lcd = 0;
        lcd_flag = 1;
        break;

      case rENH:     // enhance
        enhance++;
        if (enhance == 2) enhance = 0;
        set_enhance();
        lcd_flag = 1;
        break;    

      case rBOOST:     // boost
        amp++;
        if (amp == 2) amp = 0;
        set_amp();
        lcd_flag = 1;
        break;

      case rMENU:     // menu
        int3 = 1;
        break;

      case rOK:     // ok
        int4 = 1;
        break;

      default:   // incorect code
        break;
      }
    }
    irrecv.resume();      // receive next value on IR
    results.value = 0;    // reset results value to 0
  }
}

//******************************************************************************
// LCD UPDATE
//******************************************************************************
//------------------------------------------------------------------------------
// Update LCD
//------------------------------------------------------------------------------
void update_lcd()
{
  switch(button_menus)    // where we are in menu
  {
  case 0:      // status and volume
    lcd.setCursor(1, 0);       // cursor at 2nd character, 1 line 
    switch(CH)
    {
    case 1:
      lcd.print("CH-1 ");
      break;
    case 2:
      lcd.print("CH-2 ");
      break;
    case 3:
      lcd.print("CH-3 ");
      break;
    case 4:
      lcd.print("CH-4 ");
      break;
    default:
      lcd.print("6-CH ");
      break;
    }
    switch(mode)
    {
    case 1:
      lcd.print(" 2.1 MODE");
      break;
    case 2:
      lcd.print(" 3.1 MODE");
      break;
    case 3:
      lcd.print(" 4.1 MODE");
      break;
    case 4:
    default:
      lcd.print(" 5.1 MODE");
      break;
    }
    lcd.setCursor(1, 1);       // cursor at 2nd character, 2 line 
    switch(enhance)
    {
    case 1:
      lcd.print("E");
      break;
    default:
      lcd.print(" ");
      break;
    }
    switch(amp)
    {
    case 1:
      lcd.print("B  ");
      break;
    default:
      lcd.print("   ");
      break;
    }
    lcd.print(" VOL ");
    if(volume < 10) lcd.print(" ");
    lcd.print(volume, DEC);
    lcd.print("  ");
    switch(mute)
    {
    case 1:
      lcd.print("M");
      break;
    default:
      lcd.print(" ");
      break;
    }
    break;

  case 1:      // main menu (move between menu)
    switch(set_menu)
    {
    case 0:  // ch
      lcd.setCursor(1, 0);       // cursor at 2nd character, 1 line 
      lcd.print(" SET  CHANNEL ");
      lcd.setCursor(1, 1);       // cursor at 2nd character, 2 line 
      if(do_this == 1) lcd.print("S");  // S stands for selected and waits for a change of value
      else lcd.print(" ");
      switch(CH)
      {
      case 1:
        lcd.print("    CH-1     ");
        break;
      case 2:
        lcd.print("    CH-2     ");
        break;
      case 3:
        lcd.print("    CH-3     ");
        break;
      case 4:
        lcd.print("    CH-4     ");
        break;
      default:
        lcd.print("    6-CH     ");
        break;
      }
      break;

    case 1:  // mode
      lcd.setCursor(1, 0);       // cursor at 2nd character, 1 line 
      lcd.print("   SET MODE   ");
      lcd.setCursor(1, 1);       // cursor at 2nd character, 2 line 
      if(do_this == 1) lcd.print("S");
      else lcd.print(" ");
      switch(mode)
      {
      case 1:
        lcd.print("  2.1  MODE  ");
        break;
      case 2:
        lcd.print("  3.1  MODE  ");
        break;
      case 3:
        lcd.print("  4.1  MODE  ");
        break;
      default:
        lcd.print("  5.1  MODE  ");
        break;
      }
      break;

    case 2:  // correct
      lcd.setCursor(1, 0);       // cursor at 2nd character, 1 line 
      lcd.print("  CH CORRECT  ");
      lcd.setCursor(1, 1);       // cursor at 2nd character, 2 line 
      lcd.print("              ");
      break;

    case 3:  // enhence
      lcd.setCursor(1, 0);       // cursor at 2nd character, 1 line 
      lcd.print(" SET  ENHANCE ");
      lcd.setCursor(1, 1);       // cursor at 2nd character, 2 line 
      if(do_this == 1) lcd.print("S");
      else lcd.print(" ");
      switch(enhance)
      {
      case 1:
        lcd.print("   ACTIVE    ");
        break;
      default:
        lcd.print("  DISABLED   ");
        break;
      }
      break;

    case 4:  // boost
      lcd.setCursor(1, 0);       // cursor at 2nd character, 1 line 
      lcd.print("  SET BOOST   ");
      lcd.setCursor(1, 1);       // cursor at 2nd character, 2 line 
      if(do_this == 1) lcd.print("S");
      else lcd.print(" ");
      switch(amp)
      {
      case 1:
        lcd.print("   ACTIVE    ");
        break;
      default:
        lcd.print("  DISABLED   ");
        break;
      }
      break;

    case 5:  // mute
      lcd.setCursor(1, 0);       // cursor at 2nd character, 1 line 
      lcd.print("   SET MUTE   ");
      lcd.setCursor(1, 1);       // cursor at 2nd character, 2 line 
      if(do_this == 1) lcd.print("S");
      else lcd.print(" ");
      switch(mute)
      {
      case 1:
        lcd.print("   ACTIVE    ");
        break;
      default:
        lcd.print("  DISABLED   ");
        break;
      }
      break;

    case 6:  // volume
      lcd.setCursor(1, 0);       // cursor at 2nd character, 1 line 
      lcd.print("  SET VOLUME  ");
      lcd.setCursor(1, 1);       // cursor at 2nd character, 2 line 
      if(do_this == 1) lcd.print("S");
      else lcd.print(" ");
      lcd.print("  VOL  ");
      if(volume < 10) lcd.print(" "); 
      lcd.print(volume, DEC);
      lcd.print("    ");
      break;

    case 7:  // buttons
      lcd.setCursor(1, 0);       // cursor at 2nd character, 1 line 
      lcd.print("  SET BUTTONS ");
      lcd.setCursor(1, 1);       // cursor at 2nd character, 2 line 
      if(do_this == 1) lcd.print("S");
      else lcd.print(" ");
      switch(temp1)        // here we use temp values, globals need to be set
      {
      case 1:
        lcd.print("   ACTIVE    ");
        break;
      default:
        lcd.print("  DISABLED   ");
        break;
      }
      break;

    case 8:  // remote
      lcd.setCursor(1, 0);       // cursor at 2nd character, 1 line 
      lcd.print("  SET REMOTE  ");
      lcd.setCursor(1, 1);       // cursor at 2nd character, 2 line 
      if(do_this == 1) lcd.print("S");
      else lcd.print(" ");
      switch(temp2)
      {
      case 1:
        lcd.print("   ACTIVE    ");
        break;
      default:
        lcd.print("  DISABLED   ");
        break;
      }
      break;

    case 9:  // lcd
      lcd.setCursor(1, 0);       // cursor at 2nd character, 1 line 
      lcd.print("   LCD MODE   ");
      lcd.setCursor(1, 1);       // cursor at 2nd character, 2 line 
      if(do_this == 1) lcd.print("S");
      else lcd.print(" ");
      switch(temp3)
      {
      case 1:
        lcd.print("     ON      ");
        break;
      default:
        lcd.print("   TIMEOUT   ");
        break;
      }
      break;

    case 10:  // on-off
      lcd.setCursor(1, 0);       // cursor at 2nd character, 1 line 
      lcd.print("  SET ON/OFF  ");
      lcd.setCursor(1, 1);       // cursor at 2nd character, 2 line 
      if(do_this == 1) lcd.print("S");
      else lcd.print(" ");
      switch(temp4)
      {
      case 1:
        lcd.print("     ON      ");
        break;
      default:
        lcd.print("     OFF     ");
        break;
      }
      break;

    case 11:  // apply
      lcd.setCursor(1, 0);       // cursor at 2nd character, 1 line 
      lcd.print("     APPLY    ");
      lcd.setCursor(1, 1);       // cursor at 2nd character, 2 line 
      lcd.print("              ");
      break;

    case 12:  // store
      lcd.setCursor(1, 0);       // cursor at 2nd character, 1 line 
      lcd.print("     STORE    ");
      lcd.setCursor(1, 1);       // cursor at 2nd character, 2 line 
      lcd.print("              ");
      break;

    default:   // back
      lcd.setCursor(1, 0);       // cursor at 2nd character, 1 line 
      lcd.print("     BACK     ");
      lcd.setCursor(1, 1);       // cursor at 2nd character, 2 line 
      lcd.print("              ");
      break;
    }
    break;

  case 2:      // correct menu, move beetween correct menu
    switch(set_corrections_menu)
    {
    case 0:    // FL
      lcd.setCursor(1, 0);       // cursor at 2nd character, 1 line 
      lcd.print(" SET  FRONT L ");
      lcd.setCursor(1, 1);       // cursor at 2nd character, 2 line 
      if(do_correct == 1) lcd.print("S");
      else lcd.print(" ");
      lcd.print("    ");
      if(FL-128 < 10 && FL-128> -10) lcd.print(" ");
      if(FL>128) lcd.print("+");
      lcd.print(FL-128);
      lcd.print("      ");
      break;

    case 1:    // FR
      lcd.setCursor(1, 0);       // cursor at 2nd character, 1 line 
      lcd.print(" SET  FRONT R ");
      lcd.setCursor(1, 1);       // cursor at 2nd character, 2 line 
      if(do_correct == 1) lcd.print("S");
      else lcd.print(" ");
      lcd.print("    ");
      if(FR-128 < 10 && FR-128> -10) lcd.print(" ");
      if(FR>128) lcd.print("+");
      lcd.print(FR-128);
      lcd.print("      ");
      break;

    case 2:    // SU
      lcd.setCursor(1, 0);       // cursor at 2nd character, 1 line 
      lcd.print(" SET SUBWOOFER ");
      lcd.setCursor(1, 1);       // cursor at 2nd character, 2 line 
      if(do_correct == 1) lcd.print("S");
      else lcd.print(" ");
      lcd.print("    ");
      if(SU-128 < 10 && SU-128> -10) lcd.print(" ");
      if(SU>128) lcd.print("+");
      lcd.print(SU-128);
      lcd.print("      ");
      break;

    case 3:    // CE
      lcd.setCursor(1, 0);       // cursor at 2nd character, 1 line 
      lcd.print("  SET CENTER  ");
      lcd.setCursor(1, 1);       // cursor at 2nd character, 2 line 
      if(do_correct == 1) lcd.print("S");
      else lcd.print(" ");
      lcd.print("    ");
      if(CE-128 < 10 && CE-128> -10) lcd.print(" ");
      if(CE>128) lcd.print("+");
      lcd.print(CE-128);
      lcd.print("      ");
      break;

    case 4:    // RR
      lcd.setCursor(1, 0);       // cursor at 2nd character, 1 line 
      lcd.print(" SET  REAR  R ");
      lcd.setCursor(1, 1);       // cursor at 2nd character, 2 line 
      if(do_correct == 1) lcd.print("S");
      else lcd.print(" ");
      lcd.print("    ");
      if(RR-128 < 10 && RR-128> -10) lcd.print(" ");
      if(RR>128) lcd.print("+");
      lcd.print(RR-128);
      lcd.print("      ");
      break;

    case 5:    // RL
      lcd.setCursor(1, 0);       // cursor at 2nd character, 1 line 
      lcd.print(" SET  REAR  L ");
      lcd.setCursor(1, 1);       // cursor at 2nd character, 2 line 
      if(do_correct == 1) lcd.print("S");
      else lcd.print(" ");
      lcd.print("    ");
      if(RL-128 < 10 && RL-128> -10) lcd.print(" ");
      if(RL>128) lcd.print("+");
      lcd.print(RL-128);
      lcd.print("      ");
      break;

    default:   // BACK
      lcd.setCursor(1, 0);       // cursor at 2nd character, 1 line 
      lcd.print("     BACK     ");
      lcd.setCursor(1, 1);       // cursor at 2nd character, 2 line 
      lcd.print("              ");
      break;
    }
    break;

  case 3:        // remote bass info (this is a temp LCD INFO)
    lcd.setCursor(1, 0);       // cursor at 2nd character, 1 line 
    lcd.print("  SUBWOOFER   ");
    lcd.setCursor(1, 1);       // cursor at 2nd character, 2 line 
    lcd.print("     ");
    if(SU-128 < 10 && SU-128> -10) lcd.print(" ");
    if(SU>128) lcd.print("+");
    lcd.print(SU-128);
    lcd.print("      ");  
    break;

  case 4:        // remote lcd on/off info(this is a temp LCD INFO)
    lcd.setCursor(1, 0);       // cursor at 2nd character, 1 line 
    lcd.print("   LCD MODE   ");
    lcd.setCursor(1, 1);       // cursor at 2nd character, 1 line 
    if(enable_lcd == 1)lcd.print("      ON      ");
    else lcd.print("    TIMEOUT   "); 
    break;

  case 5:        // remote rear info (this is a temp LCD INFO)
    lcd.setCursor(1, 0);       // cursor at 2nd character, 1 line 
    lcd.print("  REAR L & R  ");
    lcd.setCursor(1, 1);       // cursor at 2nd character, 1 line 
    lcd.print("  ");
    if(RR-128 > -10 && RR-128 < 10) lcd.print(" ");
    if(RR > 128) lcd.print("+");
    lcd.print(RR-128);
    lcd.print("    ");
    if(RL-128 > -10 && RL-128 < 10) lcd.print(" ");
    if(RL > 128) lcd.print("+");
    lcd.print(RL-128);
    lcd.print("  ");  
    break;

  case 6:        // remote cen info (this is a temp LCD INFO)
    lcd.setCursor(1, 0);       // cursor at 2nd character, 1 line 
    lcd.print("    CENTER    ");
    lcd.setCursor(1, 1);       // cursor at 2nd character, 1 line 
    lcd.print("     ");
    if(CE-128 > -10 && CE-128 < 10) lcd.print(" ");
    if(CE > 128) lcd.print("+");
    lcd.print(CE-128);
    lcd.print("      ");
    break;

  default:     // should not go here
    break;
  }
}

//******************************************************************************
// EEPROM READ AND WRITE
//******************************************************************************
//------------------------------------------------------------------------------
// Store settings in eeprom
//------------------------------------------------------------------------------
void write_to_eeprom()          
{
  EEPROM.write(0, volume);      // store volume settings in address location 0 (1 byte for location)
  EEPROM.write(1, FL);          // ...        
  EEPROM.write(2, FR);                  
  EEPROM.write(3, CE);                  
  EEPROM.write(4, SU);                  
  EEPROM.write(5, RL);                      
  EEPROM.write(6, RR);                  
  EEPROM.write(7, CH);                   
  EEPROM.write(8, enhance);              
  EEPROM.write(9, amp);                 
  EEPROM.write(10, mute);               
  EEPROM.write(11, unit);               
  EEPROM.write(12, mode);               

  EEPROM.write(13, external_buttons);   
  EEPROM.write(14, external_remote);    
  EEPROM.write(15, enable_lcd);         
}

//------------------------------------------------------------------------------
// Read from eeprom and store to our global variables
//------------------------------------------------------------------------------
void read_from_eeprom()
{
  volume = EEPROM.read(0);
  FL = EEPROM.read(1);
  FR = EEPROM.read(2);
  CE = EEPROM.read(3);
  SU = EEPROM.read(4);
  RL = EEPROM.read(5);    
  RR = EEPROM.read(6);
  CH = EEPROM.read(7); 
  enhance = EEPROM.read(8); 
  amp = EEPROM.read(9);
  mute = EEPROM.read(10);
  unit = EEPROM.read(11);
  mode = EEPROM.read(12);

  external_buttons = EEPROM.read(13);
  external_remote = EEPROM.read(14);
  enable_lcd = EEPROM.read(15);
}

//******************************************************************************
// FLAGS
//******************************************************************************
//------------------------------------------------------------------------------
// Default settings of global flags
//------------------------------------------------------------------------------
void default_flags()
{
  int1 = 0;                 // interrupt flag for button 1
  int2 = 0;                 // interrupt flag for button 2
  int3 = 0;                 // interrupt flag for button 3     
  int4 = 0;                 // interrupt flag for button 4 
  button_menus = 0;         // global variable for menu
  set_menu = 0;              // global variable for sub_menu 
  temp_menu = 0;             // global temp menu varaiable (for quick status)
  set_corrections_menu = 0;      // global variable for sub_menu of corrections
  read_value = 0;                // read encoder flag value in menu
  do_this = 0;                   // select menu flag
  do_correct = 0;                // select correct flag
  temp1 = -1;                     // flag for enable buttons
  temp2 = -1;                     // flag for enable remote
  temp3 = -1;                     // flag for enable lcd
  temp4 = -1;                     // flag for unit on/off     
  encoder_value = 0;              // value for encoder
  clicks = 0;                     // value for encoder clicks
  lcd_flag = 0;                   // lcd_flag
}
I used my own software timeout feature with a simple counter, it is used for:
  • check IR (delay between IR receive)
  • delay for reading buttons (for debounce)
  • LCD (to turn off after some time if active)
  • temporary LCD info (shows it, then goes to normal after some time)

I went with my method, all though I could use a function millis(). The problem here is that millis() overflow after approximately 50 days. And here a problem could occur, resulting as an unstable system (subtracting unsigned smaller value with a larger one). If someone has more experience working with this function please fell free to leave a comment. Well my counters get stuck at some point and they wait until called again (set to 0). With this I have full control, and never have to worry about overflow. These count delays are defined at the beginning. A reminder that this is not an accurate delay, but it is good enough to do my bidding. Of to uploading software to my board.



My breadboard has a external connector, from which you can connect your Arduino Uno and program the unit. You just connect TX, RX, Reset, GND, and +5V to your Arduino Uno with no chip in. Be aware that you also must disconnect jumper on the breadboard that supplies +5V from the amplifier. Reason why I'm using USB power is that, that sometimes Arduino Uno doesn't want to reset Atmega328p on upload if powered externally. Thus resulting in error message "not in sync".  When uploading is finished, disconnect Arduino Uno and put the jumper back on. Now you can connect TX and RX for external control.


When upload was complete I hooked the system up and gave it a try. Everything was working, except one little hardware bug I had. I forgot to connect 100nF decoupling capacitor to reset and GND line. This was showing as an unexpected system reset when there was an EMF disturbance. When capacitor was added, this problem disappeared.

I have also tested my software in any possible way and it is very responsive, does not hang and is well commented.  When compiled it uses 24116 bytes of memory, so there is still room for new features. Below you can see the video of what it can do.


First of all, I apologise about poor video quality and editing.. it was my first time. Audio on the video is poor because of poor microphone in my camera, otherwise audio is excellent quality. Volume on computers were set to 50%, that's why amplifier was laud at volume 60, otherwise it gets pretty laud at volume 50. I also had to censor some parts of the video, because my static IP was showed. And that's just for me to know :)
About controlling over Internet... I used Ethernet shield and Arduino Uno. System is communicating with TV and my Amplifier over serial connection, computer and other stuff are just normal digital outputs for now. Like I said, this is still a prototype and I'm still working on it. More of this will be published in my future posts.

Serial communication is the same as in my Serial LCD project with MSP430. Command must start with a code (in my case "AMP1") for system to accept it, other code and values must follow and a end of line (\n) to tell the system transmission is over. Here is a table of serial commands:


Serial commands:
code: AMP1
code
00
x
\n
x = 0 - 1
Turn unit ON/OFF
code
01
x
\n
x = 0 - 4
Select audio in
code
02
x
\n
x = 0 - 3
Select mode
code
03
FL
xxx
\n
x = 88 – 168
Front Left correct

FR
xxx
\n
x = 88 – 168
Front Right correct
SU
xxx
\n
x = 88 – 168
Subwoofer correct
CE
xxx
\n
x = 88 – 168
Center correct
RR
xxx
\n
x = 88 – 168
Rear Right correct
RL
xxx
\n
x = 88 – 168
Rear Left correct
code
04
x
\n
x = 0 – 1
Set enhance
code
05
x
\n
x = 0 – 1
Set boost
code
06
xx
\n
x = 0 – 79
Set volume
code
07
x
\n
x = 0 – 1
Set mute
code
08
x
\n
x = 0 – 1
Set external buttons
code
09
x
\n
x = 0 – 1
Set external remote
code
10
x
\n
x = 0 – 1
LCD settings
code
11
\n

Store in eeprom
code
20
\n

Return status
code
21
\n

Return correction settings
Response:
code
OK
\n
Respond with OK
code
PxCxMxExAxVxxMUxBxRxLx
\n
Return status
code
LxxxRxxxSxxxCxxxLxxxRxxx
\n
Return corrections

You can find table of commands with descriptions in my download.

There is still room for improvement, and new features... but for now I don't need them:
  • send strings on LCD via serial communication
  • work in stealth mode (LCD and LEDs completely off)
  • IR receiver sends IR values over serial communication for other applications
  • configure count delays in system menu
  • configure IR hex values over serial communication 
  • ...

You can download entire project here.

All comments, opinions and suggestions are welcome.

Next posts will be about computer remote control and controlling over Internet. Until next time... happy hacking

16 comments:

  1. this is nice !!! you have inspired me to get my old 5.1 dead (gigaworks 550) out and work on repairing it and adding these absolutely cool features.

    I hope you wouldn't mind if pick your brains at fualt finding my system

    Good luck and I look forward to seeing your next blog

    ReplyDelete
  2. Thank you

    I would be glad to help you out. You can contact me any time via email.

    Good luck

    ReplyDelete
    Replies
    1. i need help ,, imran india,,, my mail id is imranicsworld@gmail.com

      Delete
  3. Really nice and interesting project. Thank you for sharing with us

    ReplyDelete
  4. really great job.... i am working on it...

    ReplyDelete
  5. anybody help me becoz i am getting lot of error in arduino library ,,,

    my mail id is imranicsworld@gmail.com,,
    or else anbody send me the hex code for this project

    ReplyDelete
  6. i have worked in this project but i am getting lot of error messages in arduino library ,,plz i need help

    ReplyDelete
  7. Great work you have done friend. I am facing the same problem with my 5.1 .
    there was 28 pins micro controller used for volume up-down + input selector+ and mode=controlling the volume for SR, FR, C & SW, this chip may be internally short because when I connect +5v it drops to 1.5v. cant i get ready programmed chip instead of this to run my system ? my level of knowledge is not that much as you suggested above. pl. guide to replace this chip.

    ReplyDelete
    Replies
    1. I doubt a microcontroller is the cause of a voltage drop. Try and replace all capacitors on 5V line and see if this solves the problem. Sorry to say but if you don't have enough knowledge replacement is very difficult and hard to do on your own.

      Delete
  8. Nice , Very nice..
    Good Work.. :) (y)

    ReplyDelete
  9. For past one months, i am searching over net to get guidence to update my 5.1 ch Philips home theatre.

    1. Its not having USB/FM/ Bluetooth support
    2. Its consists 2 stereo + 6 Channel Input RCA available.
    3. I want to one more INPUT for my USB/FM/Bluetooth board in existing system.
    4.Input device having BT2323M IC and PT2258 volume control.
    5. There is no much more diplay and single LED only glowing front.
    6.I have tried and soldered in the I/p of pin 3 and 26 of 2323m which is free in the IC for stereo I/P.
    7. after soldered, i connected to FM board, this input not detecting. but in another I/p is detecting.
    8.anything to be updated in the IC programming (BT2323M)
    9.Kindly help to update my audio system

    ReplyDelete
    Replies
    1. Bt2323 has nothing to do with programming.. you need to locate the microcontroller that controlls both bt2323 and pt2258. You will need to modify entire system if you want to add another input...

      Delete
    2. Kindly help the procedure.. how can i locate microcontroller that controls both bt2323 and pt2258.. pl guide

      Delete
  10. Hi Neoxy
    Thanks for the informative post.
    I am having a Philips SP065 5.1 amplifier system (which was dead. The unit was given to a Philips authorized service center; they changed the amplifier board and gave it back. It worked for two days and stopped working after two days. The unit was taken back to them but they hesitated to accept it blaming my power supply at home. They returned the unit with the board cost without repairs. Now it is with me and wanted to repair it. I opened the unit and details are below.
    1.It is powered by a Transformer 15-0-15, 2A.
    2.Two boards are there .One is the power board cum power ampboard having DC out +18,0 and -18 supplies, +9V and amp ICs , 5 Nos.TDA 2030 for 5 nos. speakers and 2 nos.TDA 2050 for SW. The same board contains 2 nos. HCF4053 BE ICs.
    3. The preamp or input board has 4 nos. 4558 ICs (inputs are TV(L/R), AUX (L/R), CD (L/R) and DVD (FR,FL,SW,C,RR,RL) 1 no.PT2258 (20 pin DIP) and 1 no.BT2323M (28 pin SMD).
    There is one basic remote and front panel (without display only LED indication)
    What I understood from the datasheets and of course your details, TDA 2030s and TDA 2050s are for power amps.BT 2258 is for volume control side, BT2323M is for channel selection.
    I blindly switched on the system and a heavy motor bike sound was continuously heard from the SW. Noticed that one of the 2050s was getting much heated, and replaced both 2050s simultaneously connected to the SW.( I think that for the power amp side, the 5 nos. 2030s are for all 5 channels and two 2050s are for SW? –Total 7 ICs ?). Also I changed both the HCF4053BE (MUX/DEMUX) and then checked and found the abnormal sound has stopped but not working, now some humming sound from the SW .
    Also I observed that the PT2258 is getting much heated soon after the unit is switched on and the 9V supply (7809) is loaded very much.
    There is no heat felt on BT2323M and all 4 nos. 4558Ds.
    Now I like get your advice what shall I do next / check to solve / troubleshoot the issue. Pls help me as you are an experienced hand in this area.
    Regards and expecting an early reply
    Hareesh.

    ReplyDelete
  11. Great job,next thanks.
    I assembled one unit,programmed,working nice.
    What changes are done for using ax2258 audio processor(combined pt2323+pt2258).help me please.

    ReplyDelete