rf433ctl/rf433ctl_timer_consolidation_experiment.pde

   1 #include <avr/io.h>
   2 #include <avr/interrupt.h>
   3 #include <inttypes.h>
   4 #include <OneWire.h>
   5 #include <DallasTemperature.h>
   6 #include <IRremote.h>
   7
   8 //********************************************************************//
   9
  10 #define RF_DATA_OUT_PIN 13
  11 #define IR_MOVEMENT_PIN 9
  12 #define ONE_WIRE_PIN 8
  13 #define PANIC_BUTTON_PIN 7
  14 #define PANICLED_PWM_PIN 6
  15 #define BLUELED_PWM_PIN 11
  16 #define PHOTO_ANALOGPIN 0
  17 //movement is reported if during IR_SAMPLE_DURATION at least IR_TRESHOLD ir signals are detectd
  18 #define IR_SAMPLE_DURATION 12000
  19 #define IR_TRESHOLD 8000
  20 //duration PanicButton needs to be pressed before status change occurs (i.e. for two PanicButton Reports, the buttons needs to be pressed 1000 cycles, releases 1000 cycles and again pressed 1000 cycles)
  21 #define PB_TRESHOLD 1000
  22 #define PHOTO_SAMPLE_INTERVAL 4000
  23 #define IRREMOTE_SEND_PIN 3   //hardcoded in library
  24 //WARNING IRremote Lib uses TCCR2
  25
  26 OneWire  onewire(ONE_WIRE_PIN);
  27 DallasTemperature dallas_sensors(&onewire);
  28 DeviceAddress onShieldTemp = { 0x10, 0xE7, 0x77, 0xD3, 0x01, 0x08, 0x00, 0x3F };
  29 IRsend irsend;
  30 #define TEMPC_OFFSET_ARDUINO_GENEREATED_HEAT
  31
  32 //********************************************************************//
  33 // IR Codes, 32 bit, NEC
  34 const int YAMAHA_CODE_BITS = 32;
  35 const unsigned long int YAMAHA_CODE_BASE = 0x0000000005EA10000;
  36
  37 const char YAMAHA_POWER_TOGGLE =0xF8; //Power On/Off
  38 const char YAMAHA_POWER_OFF =0x78; //Power Off !!!
  39 const char YAMAHA_SLEEP =0xEA; //Toggle Sleep 120/90/60/30min or Off
  40
  41 const char YAMAHA_CD =0xA8; //Input CD
  42 const char YAMAHA_TUNER =0x68; //Input Tuner
  43 const char YAMAHA_TAPE =0x18; //Input Toggle Tape/CD
  44 const char YAMAHA_DVD_SPDIF =0xE8; //Input Toggle DVD Auto / DVD Analog
  45 const char YAMAHA_SAT_SPDIFF =0x2A; //Input Toggle Sat-DTV Auto / Sat-DTV Analog
  46 const char YAMAHA_AUX =0xAA;  //Input AUX (mode)
  47 const char YAMAHA_VCR =0xF0; //Input VCR
  48 const char YAMAHA_EXT51DEC =0xE1; //Input Ext. Decoder On/Off
  49
  50 const char YAMAHA_TUNER_PLUS =0x08; //Tuner Next Station 1-7  (of A1 - E7)
  51 const char YAMAHA_TUNER_MINUS =0x88; //Tuner Prev Station 1-7  (of A1 - E7)
  52 const char YAMAHA_TUNER_ABCDE =0x48; //Tuner Next Station Row A-E (of A1 - E7)
  53
  54 const char YAMAHA_MUTE =0x38;
  55 const char YAMAHA_VOLUME_UP =0x58;
  56 const char YAMAHA_VOLUME_DOWN =0xD8;
  57
  58 //const char YAMAHA_FRONT_LEVEL_P =0x01;  //no function
  59 //const char YAMAHA_FRONT_LEVEL_M =0x81; //no function
  60 //const char YAMAHA_CENTRE_LEVEL_P =0x41;  //no function
  61 //const char YAMAHA_CENTRE_LEVEL_M =0xC1; //no function
  62 //const char YAMAHA_REAR_LEVEL_P =0x7A; //no function
  63 //const char YAMAHA_REAR_LEVEL_M =0xFA; //no function
  64 const char YAMAHA_PLUS =0x4A;  //unteres Steuerkreuz: Taste Rechts (Plus)
  65 const char YAMAHA_MINUS =0xCA; //unteres Steuerkreuz: Taste Links (Minus)
  66 const char YAMAHA_MENU =0x39; // Menu: Settings
  67 const char YAMAHA_TEST =0xA1; // Test Sounds
  68 const char YAMAHA_TIME_LEVEL =0x19; //Settings for Delay, Subwfs, Right Surround, Left Surround, Center
  69 const char YAMAHA_TIME_LEVEL2 =0x61; //(also) Settings for Delay, Subwfs, Right Surround, Left Surround, Center
  70 const char YAMAHA_TIME_LEVEL3 =0x99; //(also) Settings for Delay, Subwfs, Right Surround, Left Surround, Center
  71
  72 const char YAMAHA_EFFECT_TOGGLE =0x6A; //Effect Toggle On/Off
  73 const char YAMAHA_PRG_DOWN =0x9A; //Effect/DSP Programm Toggle in down direction
  74 const char YAMAHA_PRG_UP =0x1A; //Effect/DSP Programm Toggle in up direction
  75 const char YAMAHA_EFFECT1 =0x31; //Effect TV Sports
  76 const char YAMAHA_EFFECT2 =0x71; //Effect Rock Concert
  77 const char YAMAHA_EFFECT3 =0xB1;  //Effect Disco
  78 const char YAMAHA_EFFECT4 =0xD1;  //Mono Movie
  79 const char YAMAHA_EFFECT5 =0x91; //Effect Toggle 70mm Sci-Fi / 70mm Spectacle
  80 const char YAMAHA_EFFECT6 =0x51; //Effect Toggle 70mm General / 70mm Adventure
  81 const char YAMAHA_P5 =0xFB; //P5 PRT (1 Main Bypass)? (1587674115)
  82
  83 //********************************************************************//
  84
  85 typedef struct {
  86   byte offset;
  87   byte state;
  88 } rf_bit_t;
  89
  90 // offset is number of alphas (0.08ms)
  91
  92 const rf_bit_t zero_bit[] = { {  4, 1 },
  93                               { 16, 0 },
  94                               { 20, 1 },
  95                               { 32, 0 },
  96                               {  0, 0 } };
  97
  98 const rf_bit_t one_bit[] = { { 12, 1 },
  99                              { 16, 0 },
 100                              { 28, 1 },
 101                              { 32, 0 },
 102                              {  0, 0 } };
 103
 104 const rf_bit_t float_bit[] = { {  4, 1 },
 105                                { 16, 0 },
 106                                { 28, 1 },
 107                                { 32, 0 },
 108                                {  0, 0 } };
 109
 110 const rf_bit_t sync_bit[] = { {   4, 1 },
 111                               { 128, 0 },
 112                               {   0, 0 } };
 113
 114 typedef enum { ZERO = 0, ONE , FLOAT , SYNC } adbit_t;
 115 typedef byte ad_bit_t;
 116 #define WORD_LEN 13
 117 typedef ad_bit_t word_t[WORD_LEN];
 118
 119 const rf_bit_t* bit_defs[] = { zero_bit, one_bit, float_bit, sync_bit };
 120
 121 byte alpha_cnt = 0;
 122 byte bit_cnt = 0;
 123 byte chunk_cnt = 0;
 124 byte word_cnt = 0;
 125 const ad_bit_t* current_word;
 126 byte volatile frame_finished = 1;
 127
 128 #define FRAME_LEN 8
 129
 130 #define A1_ON  0
 131 #define A1_OFF 1
 132 #define A2_ON  2
 133 #define A2_OFF 3
 134
 135 #define B1_ON  4
 136 #define B1_OFF 5
 137 #define B2_ON  6
 138 #define B2_OFF 7
 139
 140 #define C1_ON  8
 141 #define C1_OFF 9
 142 #define C2_ON  10
 143 #define C2_OFF 11
 144
 145 #define D1_ON  12
 146 #define D1_OFF 13
 147 #define D2_ON  14
 148 #define D2_OFF 15
 149
 150 const word_t words[]  = {
 151 { ZERO,  ZERO,  FLOAT, FLOAT, ZERO,  ZERO, FLOAT, FLOAT, ZERO, FLOAT, FLOAT, FLOAT, SYNC }, // A1_ON
 152 { ZERO,  ZERO,  FLOAT, FLOAT, ZERO,  ZERO, FLOAT, FLOAT, ZERO, FLOAT, FLOAT, ZERO,  SYNC }, // A1_OFF
 153 { ZERO,  ZERO,  FLOAT, FLOAT, FLOAT, ZERO, FLOAT, FLOAT, ZERO, FLOAT, FLOAT, FLOAT, SYNC }, // A2_ON
 154 { ZERO,  ZERO,  FLOAT, FLOAT, FLOAT, ZERO, FLOAT, FLOAT, ZERO, FLOAT, FLOAT, ZERO,  SYNC }, // A2_OFF
 155
 156 { FLOAT, ZERO,  FLOAT, FLOAT, ZERO,  ZERO, FLOAT, FLOAT, ZERO, FLOAT, FLOAT, FLOAT, SYNC }, // B1_ON
 157 { FLOAT, ZERO,  FLOAT, FLOAT, ZERO,  ZERO, FLOAT, FLOAT, ZERO, FLOAT, FLOAT, ZERO,  SYNC }, // B1_OFF
 158 { FLOAT, ZERO,  FLOAT, FLOAT, FLOAT, ZERO, FLOAT, FLOAT, ZERO, FLOAT, FLOAT, FLOAT, SYNC }, // B2_ON
 159 { FLOAT, ZERO,  FLOAT, FLOAT, FLOAT, ZERO, FLOAT, FLOAT, ZERO, FLOAT, FLOAT, ZERO,  SYNC }, // B2_OFF
 160
 161 { ZERO,  FLOAT, FLOAT, FLOAT, ZERO,  ZERO, FLOAT, FLOAT, ZERO, FLOAT, FLOAT, FLOAT, SYNC }, // C1_ON
 162 { ZERO,  FLOAT, FLOAT, FLOAT, ZERO,  ZERO, FLOAT, FLOAT, ZERO, FLOAT, FLOAT, ZERO,  SYNC }, // C1_OFF
 163 { ZERO,  FLOAT, FLOAT, FLOAT, FLOAT, ZERO, FLOAT, FLOAT, ZERO, FLOAT, FLOAT, FLOAT, SYNC }, // C2_ON
 164 { ZERO,  FLOAT, FLOAT, FLOAT, FLOAT, ZERO, FLOAT, FLOAT, ZERO, FLOAT, FLOAT, ZERO,  SYNC }, // C2_OFF
 165
 166 { FLOAT, FLOAT, FLOAT, FLOAT, ZERO,  ZERO, FLOAT, FLOAT, ZERO, FLOAT, FLOAT, FLOAT, SYNC }, // D1_ON
 167 { FLOAT, FLOAT, FLOAT, FLOAT, ZERO,  ZERO, FLOAT, FLOAT, ZERO, FLOAT, FLOAT, ZERO,  SYNC }, // D1_OFF
 168 { FLOAT, FLOAT, FLOAT, FLOAT, FLOAT, ZERO, FLOAT, FLOAT, ZERO, FLOAT, FLOAT, FLOAT, SYNC }, // D2_ON
 169 { FLOAT, FLOAT, FLOAT, FLOAT, FLOAT, ZERO, FLOAT, FLOAT, ZERO, FLOAT, FLOAT, ZERO,  SYNC }  // D2_OFF
 170 };
 171
 172
 173 //********************************************************************//
 174
 175 int save_tcnt2=0;
 176 int save_tccr2a=0;
 177 int save_tccr2b=0;
 178 int save_timsk2=0;
 179 void reset_timer2()
 180 {
 181   TCNT2 = save_tcnt2;
 182   TCCR2A = save_tccr2a;  // normal mode
 183   TCCR2B = save_tccr2b;
 184   TIMSK2 = save_timsk2;
 185 }
 186
 187 void start_timer()
 188 {
 189   // timer 1: 2 ms
 190   TCCR2A = 0;                    // prescaler 1:8, WGM = 4 (CTC)
 191   TCCR2B = 1<<WGM12 | 1<<CS11;   //
 192   OCR2A = 159;        // (1+159)*8 = 1280 -> 0.08ms @ 16 MHz -> 1*alpha
 193 //  OCR1A = 207;        // (1+207)*8 = 1664 -> 0.104ms @ 16 MHz -> 1*alpha
 194   TCNT2 = 0;          // reseting timer
 195   TIMSK2 = 1<<OCIE2A; // enable Interrupt
 196 }
 197
 198 void stop_timer() // stop the timer
 199 {
 200   // timer1
 201   TCCR2B = 0; // no clock source
 202   TIMSK2 = 0; // disable timer interrupt
 203 }
 204
 205 void init_word(const word_t w)
 206 {
 207   current_word = w;
 208   alpha_cnt = 0;
 209   chunk_cnt = 0;
 210   bit_cnt = 0;
 211
 212   if(bit_defs[current_word[bit_cnt]][chunk_cnt].state)
 213     digitalWrite(RF_DATA_OUT_PIN, LOW); //neue 12V MosFET Verstärkung invertiert Logik !
 214   else
 215     digitalWrite(RF_DATA_OUT_PIN, HIGH);
 216
 217   start_timer();
 218 }
 219
 220 ISR(TIMER2_COMPA_vect)
 221 {
 222   alpha_cnt++;
 223   if(alpha_cnt < bit_defs[current_word[bit_cnt]][chunk_cnt].offset)
 224     return;
 225
 226   chunk_cnt++;
 227   if(bit_defs[current_word[bit_cnt]][chunk_cnt].offset != 0) {
 228     if(bit_defs[current_word[bit_cnt]][chunk_cnt].state)
 229       digitalWrite(RF_DATA_OUT_PIN, LOW); //neue 12V MosFET Verstärkung invertiert Logik !
 230     else
 231       digitalWrite(RF_DATA_OUT_PIN, HIGH);
 232     return;
 233   }
 234
 235   bit_cnt++;
 236   if(bit_cnt < WORD_LEN) {
 237     alpha_cnt = 0;
 238     chunk_cnt = 0;
 239     if(bit_defs[current_word[bit_cnt]][chunk_cnt].state)
 240       digitalWrite(RF_DATA_OUT_PIN, LOW); //neue 12V MosFET Verstärkung invertiert Logik !
 241     else
 242       digitalWrite(RF_DATA_OUT_PIN, HIGH);
 243     return;
 244   }
 245   stop_timer();
 246   digitalWrite(RF_DATA_OUT_PIN, HIGH);
 247
 248   word_cnt++;
 249   if(word_cnt < FRAME_LEN)
 250     init_word(current_word);
 251   else
 252     frame_finished = 2;
 253 }
 254
 255 //***********//
 256
 257
 258 void send_frame(const word_t w)
 259 {
 260   if (frame_finished != 1)
 261     for(;;) //wait until sending of previous frame finishes
 262       if (frame_finished)
 263       {
 264         delay(150);
 265         break;
 266       }
 267   word_cnt = 0;
 268   frame_finished = 0;
 269   init_word(w);
 270 }
 271
 272 void check_frame_done()
 273 {
 274   if (frame_finished==2)
 275   {
 276     Serial.println("Ok");
 277     frame_finished=1;
 278     reset_timer2();
 279     delay(120);
 280   }
 281 }
 282
 283 //********************************************************************//
 284
 285 void printTemperature(DeviceAddress deviceAddress)
 286 {
 287   dallas_sensors.requestTemperatures();
 288   float tempC = dallas_sensors.getTempC(deviceAddress);
 289   //Serial.print("Temp C: ");
 290   Serial.println(tempC TEMPC_OFFSET_ARDUINO_GENEREATED_HEAT);
 291   //Serial.print(" Temp F: ");
 292   //Serial.println(DallasTemperature::toFahrenheit(tempC)); // Converts tempC to Fahrenheit
 293 }
 294
 295 //********************************************************************//
 296
 297 unsigned int light_level_mean_ = 0;
 298 unsigned int light_sample_time_ = 0;
 299
 300 void updateLightLevel(unsigned int pin)
 301 {
 302   light_sample_time_++;
 303   if (light_sample_time_ < PHOTO_SAMPLE_INTERVAL)
 304     return;
 305   light_sample_time_ = 0;
 306
 307   unsigned int value = analogRead(pin);
 308   if (value == light_level_mean_)
 309     return;
 310
 311   unsigned int diff = abs(value - light_level_mean_);
 312   if (diff > 100)
 313     light_level_mean_ = value;
 314   else
 315       light_level_mean_=(unsigned int) ( ((float) light_level_mean_) * 0.90 + ((float)value)*0.10 );
 316 }
 317
 318 void printLightLevel()
 319 {
 320   Serial.println(light_level_mean_);
 321 }
 322
 323 //********************************************************************//
 324
 325 unsigned long wm_start_[3]={0,0,0};
 326 bool wait_millis(unsigned long *start_time, unsigned long ms)
 327 {
 328   if (ms == 0)
 329     return false;
 330   else if (*start_time > 0)
 331   {
 332     if (millis() < *start_time || millis() > (*start_time) + ms)
 333     {
 334       *start_time = 0;
 335       return false;
 336     }
 337     else
 338       return true;
 339   }
 340   else
 341   {
 342     *start_time=millis();
 343     return true;
 344   }
 345 }
 346 #define NUM_LEDS 2
 347 char flash_led_pins_[NUM_LEDS]={BLUELED_PWM_PIN,PANICLED_PWM_PIN};
 348 unsigned int flash_led_time_[3]={0,0,0};
 349 unsigned int flash_led_brightness_[3]={255,255,255};
 350 unsigned int flash_led_delay_[3]={8,8,8};
 351 unsigned int flash_led_initial_delay_[3]={0,0,0};
 352 void calculate_led_level()
 353 {
 354   for (int ledid = 0; ledid < NUM_LEDS; ledid++)
 355   {
 356     if (flash_led_time_[ledid] == 0)
 357       continue;
 358     if (wait_millis(wm_start_ + ledid, flash_led_initial_delay_[ledid]))
 359       continue;
 360     flash_led_initial_delay_[ledid]=0;
 361     if (wait_millis(wm_start_ + ledid, flash_led_delay_[ledid]))
 362       continue;
 363     flash_led_time_[ledid]--;
 364     int c = abs(sin(float(flash_led_time_[ledid]) / 100.0)) * flash_led_brightness_[ledid];
 365     //int d = abs(sin(float(flash_led_time_) / 100.0)) * flash_led_brightness_;
 366     analogWrite(flash_led_pins_[ledid], 255-c);
 367   }
 368 }
 369
 370 ISR(TIMER1_COMPA_vect)
 371 {
 372   calculate_led_level();
 373 }
 374 // id: id of LED to flash (0,1)
 375 // times: # of times the LED should flash
 376 // brightness_divisor: 1: full brightness, 2: half brightness, ...
 377 // delay_divisor: 1: slow... 8: fastest
 378 // phase_divisor: 0.. same phase; 2.. pi/2 phase, 4.. pi phase, 6.. 3pi/2 phase
 379 void flash_led(unsigned int id, unsigned int times, unsigned int brightness_divisor, unsigned int delay_divisor, unsigned int phase_divisor)
 380 {
 381   if (id >= NUM_LEDS)
 382     return;
 383   unsigned int new_flash_led_brightness = 255;
 384   unsigned int new_flash_led_delay = 8;
 385   if (times == 0)
 386   {
 387     analogWrite(flash_led_pins_[id],255); //off
 388     return;
 389   }
 390   if (brightness_divisor > 1) //guard against div by zero
 391     new_flash_led_brightness /= brightness_divisor;
 392   if (delay_divisor > 1)  //guard against div by zero
 393     new_flash_led_delay /= delay_divisor;
 394   if (flash_led_time_[id] == 0 || new_flash_led_brightness > flash_led_brightness_[id])
 395     flash_led_brightness_[id]=new_flash_led_brightness;
 396   if (flash_led_time_[id] == 0 || new_flash_led_delay < flash_led_delay_[id])
 397     flash_led_delay_[id]=new_flash_led_delay;
 398   flash_led_time_[id] += 314*times;
 399   flash_led_initial_delay_[id] = flash_led_delay_[id]*314*phase_divisor/8;
 400 }
 401
 402 void start_led_timer()
 403 {
 404   // timer 1: 2 ms
 405   TCCR1A = 0;                    // prescaler 1:8, WGM = 4 (CTC)
 406   TCCR1B = 1<<WGM12 | 1<<CS11;   //
 407   OCR1A = 15999;        // (1+15999) = 16000 -> 1ms @ 16 MHz
 408   TCNT1 = 0;          // reseting timer
 409   TIMSK1 = 1<<OCIE1A; // enable Interrupt
 410 }
 411
 412 void stop_led_timer() // stop the timer
 413 {
 414   // timer1
 415   TCCR1B = 0; // no clock source
 416   TIMSK1 = 0; // disable timer interrupt
 417 }
 418
 419 //********************************************************************//
 420
 421 void send_yamaha_ir_signal(char codebyte)
 422 {
 423   unsigned long int code = codebyte & 0xFF;
 424   code <<= 8;
 425   code |= (0xff ^ codebyte) & 0xFF;
 426   code |= YAMAHA_CODE_BASE;
 427
 428   //irsend changes PWM Timer Frequency among other things
 429   //.. doesn't go well with PWM output using the same timer
 430   //.. thus we just set output to 255 so whatever frequency is used, led is off for the duration
 431   //analogWrite(BLUELED_PWM_PIN,255); // switch led off
 432
 433   irsend.sendNEC(code,YAMAHA_CODE_BITS);
 434
 435   reset_timer2();
 436   analogWrite(BLUELED_PWM_PIN,255); // switch off led again to be sure
 437                                       //is actually not necessary, since we are not multitasking/using interrupts, but just to be sure in case this might change
 438
 439   Serial.println("Ok");
 440 }
 441
 442 //********************************************************************//
 443
 444 void setup()
 445 {
 446   pinMode(RF_DATA_OUT_PIN, OUTPUT);
 447   digitalWrite(RF_DATA_OUT_PIN, HIGH);
 448   pinMode(IR_MOVEMENT_PIN, INPUT);      // set pin to input
 449   digitalWrite(IR_MOVEMENT_PIN, LOW);  // turn off pulldown resistors
 450   pinMode(PANIC_BUTTON_PIN, INPUT);      // set pin to input
 451   digitalWrite(PANIC_BUTTON_PIN, LOW);  // turn on pulldown resistors
 452   analogWrite(PANICLED_PWM_PIN,255);
 453   analogWrite(BLUELED_PWM_PIN,255); //pwm sink(-) instead of pwm + (better for mosfets)
 454   pinMode(IRREMOTE_SEND_PIN, OUTPUT);
 455   digitalWrite(IRREMOTE_SEND_PIN, HIGH);
 456
 457   Serial.begin(9600);
 458
 459   onewire.reset();
 460   onewire.reset_search();
 461   dallas_sensors.begin();
 462   //in case we change temp sensor:
 463   if (!dallas_sensors.getAddress(onShieldTemp, 0))
 464     Serial.println("Error: Unable to find address for Device 0");
 465   dallas_sensors.setResolution(onShieldTemp, 9);
 466
 467   //save prev timer states:
 468   save_tcnt2 = TCNT2;
 469   save_tccr2a = TCCR2A;  // normal mode
 470   save_tccr2b = TCCR2B;
 471   start_led_timer();
 472 }
 473
 474 unsigned int ir_time=IR_SAMPLE_DURATION;
 475 unsigned int ir_count=0;
 476 boolean pb_last_state=0;
 477 boolean pb_state=0;
 478 boolean pb_postth_state=0;
 479 unsigned int pb_time=0;
 480
 481 void sensorEchoCommand(char command)
 482 {
 483   Serial.print("Sensor ");
 484   Serial.print(command);
 485   Serial.print(": ");
 486 }
 487
 488 void loop()
 489 {
 490   ir_time--;
 491   ir_count += (digitalRead(IR_MOVEMENT_PIN) == HIGH);
 492
 493   if (pb_time < PB_TRESHOLD)
 494     pb_time++;
 495   pb_state=(digitalRead(PANIC_BUTTON_PIN) == HIGH);
 496
 497   if (ir_time == 0)
 498   {
 499     if (ir_count >= IR_TRESHOLD)
 500     {
 501       flash_led(0, 1, 8, 1, 0 );
 502       Serial.println("movement");
 503     }
 504     ir_time=IR_SAMPLE_DURATION;
 505     ir_count=0;
 506   }
 507
 508   if (pb_state == pb_last_state && pb_time >= PB_TRESHOLD)
 509   {
 510     if (pb_state && ! pb_postth_state)
 511     {
 512       pb_postth_state=1;
 513       Serial.println("PanicButton");
 514       flash_led(0, 28, 1, 4, 0 );
 515       flash_led(1, 28, 1, 4, 4 );
 516     }
 517     else if (!pb_state)
 518       pb_postth_state=0;
 519   }
 520   else if (pb_state != pb_last_state)
 521   {
 522     pb_time=0;
 523     pb_last_state=pb_state;
 524   }
 525
 526   updateLightLevel(PHOTO_ANALOGPIN);
 527   //calculate_led_level();
 528   check_frame_done();
 529
 530   if(Serial.available()) {
 531     char command = Serial.read();
 532
 533     if(command == 'A')
 534       send_frame(words[A1_ON]);
 535     else if(command == 'a')
 536       send_frame(words[A1_OFF]);
 537     else if(command == 'B')
 538       send_frame(words[A2_ON]);
 539     else if(command == 'b')
 540       send_frame(words[A2_OFF]);
 541
 542     else if(command == 'C')
 543       send_frame(words[B1_ON]);
 544     else if(command == 'c')
 545       send_frame(words[B1_OFF]);
 546     else if(command == 'D')
 547       send_frame(words[B2_ON]);
 548     else if(command == 'd')
 549       send_frame(words[B2_OFF]);
 550
 551     else if(command == 'E')
 552       send_frame(words[C1_ON]);
 553     else if(command == 'e')
 554       send_frame(words[C1_OFF]);
 555     else if(command == 'F')
 556       send_frame(words[C2_ON]);
 557     else if(command == 'f')
 558       send_frame(words[C2_OFF]);
 559
 560     else if(command == 'G')
 561       send_frame(words[D1_ON]);
 562     else if(command == 'g')
 563       send_frame(words[D1_OFF]);
 564     else if(command == 'H')
 565       send_frame(words[D2_ON]);
 566     else if(command == 'h')
 567       send_frame(words[D2_OFF]);
 568     else if(command == 'T')
 569     {
 570       sensorEchoCommand(command);
 571       printTemperature(onShieldTemp);
 572     }
 573     else if(command == 'P')
 574     {
 575       sensorEchoCommand(command);
 576       printLightLevel();
 577     }
 578     else if (command == '^')
 579       flash_led(1, 1, 2, 1, 0);
 580     else if (command == '0')
 581       send_yamaha_ir_signal(YAMAHA_POWER_OFF);
 582     else if (command == '1')
 583       send_yamaha_ir_signal(YAMAHA_POWER_TOGGLE);
 584     else if (command == '2')
 585       send_yamaha_ir_signal(YAMAHA_VOLUME_UP);
 586     else if (command == '3')
 587       send_yamaha_ir_signal(YAMAHA_VOLUME_DOWN);
 588     else if (command == '4')
 589       send_yamaha_ir_signal(YAMAHA_MUTE);
 590     else if (command == '5')
 591       send_yamaha_ir_signal(YAMAHA_CD);
 592     else if (command == '6')
 593       send_yamaha_ir_signal(YAMAHA_TUNER);
 594     else if (command == '7')
 595       send_yamaha_ir_signal(YAMAHA_DVD_SPDIF);
 596     else if (command == '8')
 597       send_yamaha_ir_signal(YAMAHA_MENU);
 598     else if (command == '+')
 599       send_yamaha_ir_signal(YAMAHA_PLUS);
 600     else if (command == '-')
 601       send_yamaha_ir_signal(YAMAHA_MINUS);
 602     else if (command == 0xa7) // §
 603       send_yamaha_ir_signal(YAMAHA_TEST);
 604     else if (command == '$')
 605       send_yamaha_ir_signal(YAMAHA_TIME_LEVEL);
 606     else if (command == '%')
 607       send_yamaha_ir_signal(YAMAHA_EFFECT_TOGGLE);
 608     else if (command == '&')
 609       send_yamaha_ir_signal(YAMAHA_PRG_DOWN);
 610     else if (command == '/')
 611       send_yamaha_ir_signal(YAMAHA_PRG_UP);
 612     else if (command == '(')
 613       send_yamaha_ir_signal(YAMAHA_TUNER_PLUS);
 614     else if (command == '[')
 615       send_yamaha_ir_signal(YAMAHA_TUNER_MINUS);
 616     else if (command == ')')
 617       send_yamaha_ir_signal(YAMAHA_TUNER_ABCDE);
 618     else if (command == '9')
 619       send_yamaha_ir_signal(YAMAHA_TAPE);
 620     else if (command == '?')
 621       send_yamaha_ir_signal(YAMAHA_VCR);
 622     else if (command == '=')
 623       send_yamaha_ir_signal(YAMAHA_EXT51DEC);
 624     else
 625       Serial.println("Error: unknown command");
 626   }
 627 }