rf433ctl/rf433ctl.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 BLUELED_PWM_PIN 6
  15 #define BLUELED2_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 10000
  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 char YAMAHA_CODE_BASE = 0x000000005EA10000;
  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_1 =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_ABCDE =0x48; //Tuner Next Station Row A-E (of A1 - E7)
  52
  53 const char YAMAHA_MUTE =0x38;
  54 const char YAMAHA_VOLUME_UP =0x58;
  55 const char YAMAHA_VOLUME_DOWN =0xD8;
  56
  57 //const char YAMAHA_FRONT_LEVEL_P =0x01;  //no function
  58 //const char YAMAHA_FRONT_LEVEL_M =0x81; //no function
  59 //const char YAMAHA_CENTRE_LEVEL_P =0x41;  //no function
  60 //const char YAMAHA_CENTRE_LEVEL_M =0xC1; //no function
  61 //const char YAMAHA_REAR_LEVEL_P =0x7A; //no function
  62 //const char YAMAHA_REAR_LEVEL_M =0xFA; //no function
  63 const char YAMAHA_PLUS =0x4A;  //unteres Steuerkreuz: Taste Rechts (Plus)
  64 const char YAMAHA_MINUS =0xCA; //unteres Steuerkreuz: Taste Links (Minus)
  65 const char YAMAHA_MENU =0x39; // Menu: Settings
  66 const char YAMAHA_TEST =0xA1 // Test Sounds
  67 const char YAMAHA_TIME_LEVEL =0x19; //Settings for Delay, Subwfs, Right Surround, Left Surround, Center
  68 const char YAMAHA_TIME_LEVEL2 =0x61; //(also) Settings for Delay, Subwfs, Right Surround, Left Surround, Center
  69 const char YAMAHA_TIME_LEVEL3 =0x99; //(also) Settings for Delay, Subwfs, Right Surround, Left Surround, Center
  70
  71 const char YAMAHA_EFFECT_TOGGLE =0x6A; //Effect Toggle On/Off
  72 const char YAMAHA_PRG_DOWN =0x9A; //Effect/DSP Programm Toggle in down direction
  73 const char YAMAHA_PRG_UP =0x1A; //Effect/DSP Programm Toggle in up direction
  74 const char YAMAHA_EFFECT1 =0x31; //Effect TV Sports
  75 const char YAMAHA_EFFECT2 =0x71; //Effect Rock Concert
  76 const char YAMAHA_EFFECT3 =0xB1;  //Effect Disco
  77 const char YAMAHA_EFFECT4 =0xD1;  //Mono Movie
  78 const char YAMAHA_EFFECT5 =0x91; //Effect Toggle 70mm Sci-Fi / 70mm Spectacle
  79 const char YAMAHA_EFFECT6 =0x51; //Effect Toggle 70mm General / 70mm Adventure
  80 const char YAMAHA_P5 =0xFB; //P5 PRT (1 Main Bypass)? (1587674115)
  81
  82
  83 void send_std_nec_ir_signal(char codebyte)
  84 {
  85   unsigned long int code = codebyte & 0xFF;
  86   code <<= 8;
  87   code |= (0xff ^ codebyte) & 0xFF;
  88   code |= YAMAHA_CODE_BASE;
  89   irsend.sendNEC(code,YAMAHA_CODE_BITS);
  90   Serial.println("Ok");
  91 }
  92
  93 //********************************************************************//
  94
  95 typedef struct {
  96   byte offset;
  97   byte state;
  98 } rf_bit_t;
  99
 100 // offset is number of alphas (0.08ms)
 101
 102 const rf_bit_t zero_bit[] = { {  4, 1 },
 103                               { 16, 0 },
 104                               { 20, 1 },
 105                               { 32, 0 },
 106                               {  0, 0 } };
 107
 108 const rf_bit_t one_bit[] = { { 12, 1 },
 109                              { 16, 0 },
 110                              { 28, 1 },
 111                              { 32, 0 },
 112                              {  0, 0 } };
 113
 114 const rf_bit_t float_bit[] = { {  4, 1 },
 115                                { 16, 0 },
 116                                { 28, 1 },
 117                                { 32, 0 },
 118                                {  0, 0 } };
 119
 120 const rf_bit_t sync_bit[] = { {   4, 1 },
 121                               { 128, 0 },
 122                               {   0, 0 } };
 123
 124 typedef enum { ZERO = 0, ONE , FLOAT , SYNC } adbit_t;
 125 typedef byte ad_bit_t;
 126 #define WORD_LEN 13
 127 typedef ad_bit_t word_t[WORD_LEN];
 128
 129 const rf_bit_t* bit_defs[] = { zero_bit, one_bit, float_bit, sync_bit };
 130
 131 byte alpha_cnt = 0;
 132 byte bit_cnt = 0;
 133 byte chunk_cnt = 0;
 134 byte word_cnt = 0;
 135 const ad_bit_t* current_word;
 136 byte volatile frame_finished = 1;
 137
 138 #define FRAME_LEN 8
 139
 140 #define A1_ON  0
 141 #define A1_OFF 1
 142 #define A2_ON  2
 143 #define A2_OFF 3
 144
 145 #define B1_ON  4
 146 #define B1_OFF 5
 147 #define B2_ON  6
 148 #define B2_OFF 7
 149
 150 #define C1_ON  8
 151 #define C1_OFF 9
 152 #define C2_ON  10
 153 #define C2_OFF 11
 154
 155 #define D1_ON  12
 156 #define D1_OFF 13
 157 #define D2_ON  14
 158 #define D2_OFF 15
 159
 160 const word_t words[]  = {
 161 { ZERO,  ZERO,  FLOAT, FLOAT, ZERO,  ZERO, FLOAT, FLOAT, ZERO, FLOAT, FLOAT, FLOAT, SYNC }, // A1_ON
 162 { ZERO,  ZERO,  FLOAT, FLOAT, ZERO,  ZERO, FLOAT, FLOAT, ZERO, FLOAT, FLOAT, ZERO,  SYNC }, // A1_OFF
 163 { ZERO,  ZERO,  FLOAT, FLOAT, FLOAT, ZERO, FLOAT, FLOAT, ZERO, FLOAT, FLOAT, FLOAT, SYNC }, // A2_ON
 164 { ZERO,  ZERO,  FLOAT, FLOAT, FLOAT, ZERO, FLOAT, FLOAT, ZERO, FLOAT, FLOAT, ZERO,  SYNC }, // A2_OFF
 165
 166 { FLOAT, ZERO,  FLOAT, FLOAT, ZERO,  ZERO, FLOAT, FLOAT, ZERO, FLOAT, FLOAT, FLOAT, SYNC }, // B1_ON
 167 { FLOAT, ZERO,  FLOAT, FLOAT, ZERO,  ZERO, FLOAT, FLOAT, ZERO, FLOAT, FLOAT, ZERO,  SYNC }, // B1_OFF
 168 { FLOAT, ZERO,  FLOAT, FLOAT, FLOAT, ZERO, FLOAT, FLOAT, ZERO, FLOAT, FLOAT, FLOAT, SYNC }, // B2_ON
 169 { FLOAT, ZERO,  FLOAT, FLOAT, FLOAT, ZERO, FLOAT, FLOAT, ZERO, FLOAT, FLOAT, ZERO,  SYNC }, // B2_OFF
 170
 171 { ZERO,  FLOAT, FLOAT, FLOAT, ZERO,  ZERO, FLOAT, FLOAT, ZERO, FLOAT, FLOAT, FLOAT, SYNC }, // C1_ON
 172 { ZERO,  FLOAT, FLOAT, FLOAT, ZERO,  ZERO, FLOAT, FLOAT, ZERO, FLOAT, FLOAT, ZERO,  SYNC }, // C1_OFF
 173 { ZERO,  FLOAT, FLOAT, FLOAT, FLOAT, ZERO, FLOAT, FLOAT, ZERO, FLOAT, FLOAT, FLOAT, SYNC }, // C2_ON
 174 { ZERO,  FLOAT, FLOAT, FLOAT, FLOAT, ZERO, FLOAT, FLOAT, ZERO, FLOAT, FLOAT, ZERO,  SYNC }, // C2_OFF
 175
 176 { FLOAT, FLOAT, FLOAT, FLOAT, ZERO,  ZERO, FLOAT, FLOAT, ZERO, FLOAT, FLOAT, FLOAT, SYNC }, // D1_ON
 177 { FLOAT, FLOAT, FLOAT, FLOAT, ZERO,  ZERO, FLOAT, FLOAT, ZERO, FLOAT, FLOAT, ZERO,  SYNC }, // D1_OFF
 178 { FLOAT, FLOAT, FLOAT, FLOAT, FLOAT, ZERO, FLOAT, FLOAT, ZERO, FLOAT, FLOAT, FLOAT, SYNC }, // D2_ON
 179 { FLOAT, FLOAT, FLOAT, FLOAT, FLOAT, ZERO, FLOAT, FLOAT, ZERO, FLOAT, FLOAT, ZERO,  SYNC }  // D2_OFF
 180 };
 181
 182
 183 //********************************************************************//
 184
 185 void start_timer()
 186 {
 187   // timer 1: 2 ms
 188   TCCR1A = 0;                    // prescaler 1:8, WGM = 4 (CTC)
 189   TCCR1B = 1<<WGM12 | 1<<CS11;   //
 190   OCR1A = 159;        // (1+159)*8 = 1280 -> 0.08ms @ 16 MHz -> 1*alpha
 191 //  OCR1A = 207;        // (1+207)*8 = 1664 -> 0.104ms @ 16 MHz -> 1*alpha
 192   TCNT1 = 0;          // reseting timer
 193   TIMSK1 = 1<<OCIE1A; // enable Interrupt
 194 }
 195
 196 void stop_timer() // stop the timer
 197 {
 198   // timer1
 199   TCCR1B = 0; // no clock source
 200   TIMSK1 = 0; // disable timer interrupt
 201 }
 202
 203 void init_word(const word_t w)
 204 {
 205   current_word = w;
 206   alpha_cnt = 0;
 207   chunk_cnt = 0;
 208   bit_cnt = 0;
 209
 210   if(bit_defs[current_word[bit_cnt]][chunk_cnt].state)
 211     digitalWrite(RF_DATA_OUT_PIN, LOW); //neue 12V MosFET Verstärkung invertiert Logik !
 212   else
 213     digitalWrite(RF_DATA_OUT_PIN, HIGH);
 214
 215   start_timer();
 216 }
 217
 218 ISR(TIMER1_COMPA_vect)
 219 {
 220   alpha_cnt++;
 221   if(alpha_cnt < bit_defs[current_word[bit_cnt]][chunk_cnt].offset)
 222     return;
 223
 224   chunk_cnt++;
 225   if(bit_defs[current_word[bit_cnt]][chunk_cnt].offset != 0) {
 226     if(bit_defs[current_word[bit_cnt]][chunk_cnt].state)
 227       digitalWrite(RF_DATA_OUT_PIN, LOW); //neue 12V MosFET Verstärkung invertiert Logik !
 228     else
 229       digitalWrite(RF_DATA_OUT_PIN, HIGH);
 230     return;
 231   }
 232
 233   bit_cnt++;
 234   if(bit_cnt < WORD_LEN) {
 235     alpha_cnt = 0;
 236     chunk_cnt = 0;
 237     if(bit_defs[current_word[bit_cnt]][chunk_cnt].state)
 238       digitalWrite(RF_DATA_OUT_PIN, LOW); //neue 12V MosFET Verstärkung invertiert Logik !
 239     else
 240       digitalWrite(RF_DATA_OUT_PIN, HIGH);
 241     return;
 242   }
 243   stop_timer();
 244   digitalWrite(RF_DATA_OUT_PIN, HIGH);
 245
 246   word_cnt++;
 247   if(word_cnt < FRAME_LEN)
 248     init_word(current_word);
 249   else
 250     frame_finished = 2;
 251 }
 252
 253 //***********//
 254
 255
 256 void send_frame(const word_t w)
 257 {
 258   if (frame_finished == 0)
 259     for(;;)
 260       if (frame_finished)
 261       {
 262         delay(150);
 263         break;
 264       }
 265   word_cnt = 0;
 266   frame_finished = 0;
 267   init_word(w);
 268 }
 269
 270 void check_frame_done()
 271 {
 272   if (frame_finished==2)
 273   {
 274     Serial.println("Ok");
 275     frame_finished=1;
 276   }
 277 }
 278
 279 //********************************************************************//
 280
 281 void printTemperature(DeviceAddress deviceAddress)
 282 {
 283   dallas_sensors.requestTemperatures();
 284   float tempC = dallas_sensors.getTempC(deviceAddress);
 285   //Serial.print("Temp C: ");
 286   Serial.println(tempC TEMPC_OFFSET_ARDUINO_GENEREATED_HEAT);
 287   //Serial.print(" Temp F: ");
 288   //Serial.println(DallasTemperature::toFahrenheit(tempC)); // Converts tempC to Fahrenheit
 289 }
 290
 291 //********************************************************************//
 292
 293 unsigned int light_level_mean_ = 0;
 294 unsigned int light_sample_time_ = 0;
 295
 296 void updateLightLevel(unsigned int pin)
 297 {
 298   light_sample_time_++;
 299   if (light_sample_time_ < PHOTO_SAMPLE_INTERVAL)
 300     return;
 301   light_sample_time_ = 0;
 302
 303   unsigned int value = analogRead(pin);
 304   if (value == light_level_mean_)
 305     return;
 306
 307   unsigned int diff = abs(value - light_level_mean_);
 308   if (diff > 100)
 309     light_level_mean_ = value;
 310   else
 311       light_level_mean_=(unsigned int) ( ((float) light_level_mean_) * 0.90 + ((float)value)*0.10 );
 312 }
 313
 314 void printLightLevel()
 315 {
 316   //Serial.print("Photo: ");
 317   Serial.println(light_level_mean_);
 318 }
 319
 320 //********************************************************************//
 321
 322 unsigned long wm_start_=0;
 323 bool wait_millis(unsigned long ms)
 324 {
 325   if (wm_start_ > 0)
 326   {
 327     if (millis() < wm_start_ || millis() > wm_start_+ ms)
 328     {
 329       wm_start_=0;
 330       return false;
 331     }
 332     else
 333       return true;
 334   }
 335   else
 336   {
 337     wm_start_=millis();
 338     return true;
 339   }
 340 }
 341
 342 unsigned int flash_led_time_=0;
 343 unsigned int flash_led_brightness_=255;
 344 unsigned int flash_led_delay_=8;
 345 void calculate_led_level(unsigned int pwm_pin)
 346 {
 347   if (flash_led_time_ == 0)
 348     return;
 349   if (wait_millis(flash_led_delay_))
 350     return;
 351   flash_led_time_--;
 352   int c = abs(sin(float(flash_led_time_) / 100.0)) * flash_led_brightness_;
 353   //int d = abs(sin(float(flash_led_time_) / 100.0)) * flash_led_brightness_;
 354   analogWrite(BLUELED2_PWM_PIN, 255-c);
 355   if (flash_led_brightness_ == 255)
 356   {
 357     if (flash_led_time_)
 358       analogWrite(BLUELED_PWM_PIN, 255-c);
 359     else
 360       analogWrite(BLUELED_PWM_PIN, c);
 361   }
 362 }
 363
 364 void flash_led(unsigned int times, unsigned int brightness_divisor, unsigned int delay_divisor)
 365 {
 366   unsigned int new_flash_led_brightness = 255 / brightness_divisor;
 367   unsigned int new_flash_led_delay = 8 / delay_divisor;
 368   if (flash_led_time_ == 0 || new_flash_led_brightness > flash_led_brightness_)
 369     flash_led_brightness_=new_flash_led_brightness;
 370   if (flash_led_time_ == 0 || new_flash_led_delay < flash_led_delay_)
 371     flash_led_delay_=new_flash_led_delay;
 372   flash_led_time_ += 314*times;
 373 }
 374
 375 //********************************************************************//
 376
 377 void setup()
 378 {
 379   pinMode(RF_DATA_OUT_PIN, OUTPUT);
 380   digitalWrite(RF_DATA_OUT_PIN, HIGH);
 381   pinMode(IR_MOVEMENT_PIN, INPUT);      // set pin to input
 382   digitalWrite(IR_MOVEMENT_PIN, LOW);  // turn off pullup resistors
 383   pinMode(PANIC_BUTTON_PIN, INPUT);      // set pin to input
 384   digitalWrite(PANIC_BUTTON_PIN, HIGH);  // turn on pullup resistors
 385   analogWrite(BLUELED_PWM_PIN,0);
 386   analogWrite(BLUELED2_PWM_PIN,255); //pwm sink(-) instead of pwm + (better for mosfets)
 387   pinMode(IRREMOTE_SEND_PIN, OUTPUT);
 388   digitalWrite(IRREMOTE_SEND_PIN, HIGH);
 389
 390   Serial.begin(9600);
 391
 392   onewire.reset();
 393   onewire.reset_search();
 394   dallas_sensors.begin();
 395   //in case we change temp sensor:
 396   if (!dallas_sensors.getAddress(onShieldTemp, 0))
 397     Serial.println("Error: Unable to find address for Device 0");
 398   dallas_sensors.setResolution(onShieldTemp, 9);
 399 }
 400
 401 unsigned int ir_time=IR_SAMPLE_DURATION;
 402 unsigned int ir_count=0;
 403 boolean pb_last_state=0;
 404 boolean pb_state=0;
 405 boolean pb_postth_state=0;
 406 unsigned int pb_time=0;
 407
 408 void sensorEchoCommand(char command)
 409 {
 410   Serial.print("Sensor ");
 411   Serial.print(command);
 412   Serial.print(": ");
 413 }
 414
 415 void loop()
 416 {
 417   ir_time--;
 418   ir_count += (digitalRead(IR_MOVEMENT_PIN) == HIGH);
 419
 420   if (pb_time < PB_TRESHOLD)
 421     pb_time++;
 422   pb_state=(digitalRead(PANIC_BUTTON_PIN) == LOW);
 423
 424   if (ir_time == 0)
 425   {
 426     if (ir_count >= IR_TRESHOLD)
 427     {
 428       flash_led(1,8,1);
 429       Serial.println("movement");
 430     }
 431     ir_time=IR_SAMPLE_DURATION;
 432     ir_count=0;
 433   }
 434
 435   if (pb_state == pb_last_state && pb_time >= PB_TRESHOLD)
 436   {
 437     if (pb_state && ! pb_postth_state)
 438     {
 439       pb_postth_state=1;
 440       Serial.println("PanicButton");
 441       flash_led(7,1,2);
 442     }
 443     else if (!pb_state)
 444       pb_postth_state=0;
 445   }
 446   else if (pb_state != pb_last_state)
 447   {
 448     pb_time=0;
 449     pb_last_state=pb_state;
 450   }
 451
 452   updateLightLevel(PHOTO_ANALOGPIN);
 453   calculate_led_level(BLUELED_PWM_PIN);
 454   check_frame_done();
 455
 456   if(Serial.available()) {
 457     char command = Serial.read();
 458
 459     if(command == 'A')
 460       send_frame(words[A1_ON]);
 461     else if(command == 'a')
 462       send_frame(words[A1_OFF]);
 463     else if(command == 'B')
 464       send_frame(words[A2_ON]);
 465     else if(command == 'b')
 466       send_frame(words[A2_OFF]);
 467
 468     else if(command == 'C')
 469       send_frame(words[B1_ON]);
 470     else if(command == 'c')
 471       send_frame(words[B1_OFF]);
 472     else if(command == 'D')
 473       send_frame(words[B2_ON]);
 474     else if(command == 'd')
 475       send_frame(words[B2_OFF]);
 476
 477     else if(command == 'E')
 478       send_frame(words[C1_ON]);
 479     else if(command == 'e')
 480       send_frame(words[C1_OFF]);
 481     else if(command == 'F')
 482       send_frame(words[C2_ON]);
 483     else if(command == 'f')
 484       send_frame(words[C2_OFF]);
 485
 486     else if(command == 'G')
 487       send_frame(words[D1_ON]);
 488     else if(command == 'g')
 489       send_frame(words[D1_OFF]);
 490     else if(command == 'H')
 491       send_frame(words[D2_ON]);
 492     else if(command == 'h')
 493       send_frame(words[D2_OFF]);
 494     else if(command == 'T')
 495     {
 496       sensorEchoCommand(command);
 497       printTemperature(onShieldTemp);
 498     }
 499     else if(command == 'P')
 500     {
 501       sensorEchoCommand(command);
 502       printLightLevel();
 503     }
 504     else if (command == '1')
 505     {
 506       irsend.sendNEC(YAMAHA_POWER,YAMAHA_CODE_BITS);
 507       Serial.println("Ok");
 508     }
 509     else if (command == '2')
 510     {
 511       irsend.sendNEC(YAMAHA_CD,YAMAHA_CODE_BITS);
 512       Serial.println("Ok");
 513     }
 514     else if (command == '3')
 515     {
 516       irsend.sendNEC(YAMAHA_DVD_SPDIF,YAMAHA_CODE_BITS);
 517       Serial.println("Ok");
 518     }
 519     else if (command == '4')
 520     {
 521       irsend.sendNEC(YAMAHA_TUNER,YAMAHA_CODE_BITS);
 522       Serial.println("Ok");
 523     }
 524     else if (command == '5')
 525     {
 526       irsend.sendNEC(YAMAHA_VOLUME_UP,YAMAHA_CODE_BITS);
 527       Serial.println("Ok");
 528     }
 529     else if (command == '6')
 530     {
 531       irsend.sendNEC(YAMAHA_VOLUME_DOWN,YAMAHA_CODE_BITS);
 532       Serial.println("Ok");
 533     }
 534     else if (command == '7')
 535     {
 536       irsend.sendNEC(YAMAHA_MUTE,YAMAHA_CODE_BITS);
 537       Serial.println("Ok");
 538     }
 539     else
 540       Serial.println("Error: unknown command");
 541   }
 542 }