lirc-0.8.4a/daemons/ir_remote.c

   1 /*      $Id: ir_remote.c,v 5.38 2008/06/03 17:21:29 lirc Exp $      */
   2
   3 /****************************************************************************
   4  ** ir_remote.c *************************************************************
   5  ****************************************************************************
   6  *
   7  * ir_remote.c - sends and decodes the signals from IR remotes
   8  *
   9  * Copyright (C) 1996,97 Ralph Metzler (rjkm@thp.uni-koeln.de)
  10  * Copyright (C) 1998 Christoph Bartelmus (lirc@bartelmus.de)
  11  *
  12  */
  13
  14 #ifdef HAVE_CONFIG_H
  15 # include <config.h>
  16 #endif
  17
  18 #include <stdlib.h>
  19 #include <stdio.h>
  20 #include <fcntl.h>
  21 #include <limits.h>
  22
  23 #include <sys/ioctl.h>
  24
  25 #include "drivers/lirc.h"
  26
  27 #include "lircd.h"
  28 #include "ir_remote.h"
  29 #include "hardware.h"
  30 #include "release.h"
  31
  32 struct ir_remote *decoding=NULL;
  33
  34 struct ir_remote *last_remote=NULL;
  35 struct ir_remote *repeat_remote=NULL;
  36 struct ir_ncode *repeat_code;
  37
  38 extern struct hardware hw;
  39
  40 static int match_ir_code(struct ir_remote *remote, ir_code a, ir_code b)
  41 {
  42         return ((remote->ignore_mask|a) == (remote->ignore_mask|b) ||
  43                 (remote->ignore_mask|a) ==
  44                 (remote->ignore_mask|(b^remote->toggle_bit_mask)));
  45 }
  46
  47 void get_frequency_range(struct ir_remote *remotes,
  48                          unsigned int *min_freq,unsigned int *max_freq)
  49 {
  50         struct ir_remote *scan;
  51
  52         /* use remotes carefully, it may be changed on SIGHUP */
  53         scan=remotes;
  54         if(scan==NULL)
  55         {
  56                 *min_freq=DEFAULT_FREQ;
  57                 *max_freq=DEFAULT_FREQ;
  58         }
  59         else
  60         {
  61                 *min_freq=scan->freq;
  62                 *max_freq=scan->freq;
  63                 scan=scan->next;
  64         }
  65         while(scan)
  66         {
  67                 if(scan->freq!=0)
  68                 {
  69                         if(scan->freq>*max_freq)
  70                         {
  71                                 *max_freq=scan->freq;
  72                         }
  73                         else if(scan->freq<*min_freq)
  74                         {
  75                                 *min_freq=scan->freq;
  76                         }
  77                 }
  78                 scan=scan->next;
  79         }
  80 }
  81
  82 struct ir_remote *is_in_remotes(struct ir_remote *remotes,
  83                                 struct ir_remote *remote)
  84 {
  85         while(remotes != NULL)
  86         {
  87                 if(remotes == remote)
  88                 {
  89                         return remote;
  90                 }
  91                 remotes = remotes->next;
  92         }
  93         return NULL;
  94 }
  95
  96 struct ir_remote *get_ir_remote(struct ir_remote *remotes,char *name)
  97 {
  98         struct ir_remote *all;
  99
 100         /* use remotes carefully, it may be changed on SIGHUP */
 101         all=remotes;
 102         while(all)
 103         {
 104                 if(strcasecmp(all->name,name)==0)
 105                 {
 106                         return(all);
 107                 }
 108                 all=all->next;
 109         }
 110         return(NULL);
 111 }
 112
 113 int map_code(struct ir_remote *remote,
 114              ir_code *prep,ir_code *codep,ir_code *postp,
 115              int pre_bits,ir_code pre,
 116              int bits,ir_code code,
 117              int post_bits,ir_code post)
 118 {
 119         ir_code all;
 120
 121         if(pre_bits+bits+post_bits!=
 122            remote->pre_data_bits+remote->bits+remote->post_data_bits)
 123         {
 124                 return(0);
 125         }
 126         all=(pre&gen_mask(pre_bits));
 127         all<<=bits;
 128         all|=(code&gen_mask(bits));
 129         all<<=post_bits;
 130         all|=(post&gen_mask(post_bits));
 131
 132         *postp=(all&gen_mask(remote->post_data_bits));
 133         all>>=remote->post_data_bits;
 134         *codep=(all&gen_mask(remote->bits));
 135         all>>=remote->bits;
 136         *prep=(all&gen_mask(remote->pre_data_bits));
 137
 138         LOGPRINTF(1,"pre: %llx", (unsigned long long) *prep);
 139         LOGPRINTF(1,"code: %llx", (unsigned long long) *codep);
 140         LOGPRINTF(1,"post: %llx", (unsigned long long) *postp);
 141         LOGPRINTF(1, "code:                   %016llx\n", code);
 142
 143         return(1);
 144 }
 145
 146 void map_gap(struct ir_remote *remote,
 147              struct timeval *start, struct timeval *last,
 148              lirc_t signal_length,
 149              int *repeat_flagp,
 150              lirc_t *min_remaining_gapp,
 151              lirc_t *max_remaining_gapp)
 152 {
 153         // Time gap (us) between a keypress on the remote control and
 154         // the next one.
 155         lirc_t gap;
 156
 157         // Check the time gap between the last keypress and this one.
 158         if (start->tv_sec - last->tv_sec >= 2) {
 159                 // Gap of 2 or more seconds: this is not a repeated keypress.
 160                 *repeat_flagp = 0;
 161                 gap = 0;
 162         } else {
 163                 // Calculate the time gap in microseconds.
 164                 gap = time_elapsed(last, start);
 165                 if(expect_at_most(remote, gap, remote->max_remaining_gap))
 166                 {
 167                         // The gap is shorter than a standard gap
 168                         // (with relative or aboslute tolerance): this
 169                         // is a repeated keypress.
 170                         *repeat_flagp = 1;
 171                 }
 172                 else
 173                 {
 174                         // Standard gap: this is a new keypress.
 175                         *repeat_flagp = 0;
 176                 }
 177         }
 178
 179         // Calculate extimated time gap remaining for the next code.
 180         if (is_const(remote)) {
 181                 // The sum (signal_length + gap) is always constant
 182                 // so the gap is shorter when the code is longer.
 183                 if (min_gap(remote) > signal_length) {
 184                         *min_remaining_gapp = min_gap(remote) - signal_length;
 185                         *max_remaining_gapp = max_gap(remote) - signal_length;
 186                 } else {
 187                         *min_remaining_gapp = 0;
 188                         if(max_gap(remote) > signal_length)
 189                         {
 190                                 *max_remaining_gapp = max_gap(remote) - signal_length;
 191                         }
 192                         else
 193                         {
 194                                 *max_remaining_gapp = 0;
 195                         }
 196                 }
 197         } else {
 198                 // The gap after the signal is always constant.
 199                 // This is the case of Kanam Accent serial remote.
 200                 *min_remaining_gapp = min_gap(remote);
 201                 *max_remaining_gapp = max_gap(remote);
 202         }
 203
 204         LOGPRINTF(1, "repeat_flagp:           %d", *repeat_flagp);
 205         LOGPRINTF(1, "is_const(remote):       %d", is_const(remote));
 206         LOGPRINTF(1, "remote->gap range:      %lu %lu",
 207                   (unsigned long) min_gap(remote),
 208                   (unsigned long) max_gap(remote));
 209         LOGPRINTF(1, "remote->remaining_gap:  %lu %lu",
 210                   (unsigned long) remote->min_remaining_gap,
 211                   (unsigned long) remote->max_remaining_gap);
 212         LOGPRINTF(1, "signal length:          %lu",
 213                   (unsigned long) signal_length);
 214         LOGPRINTF(1, "gap:                    %lu",
 215                   (unsigned long) gap);
 216         LOGPRINTF(1, "extim. remaining_gap:   %lu %lu",
 217                   (unsigned long) *min_remaining_gapp,
 218                   (unsigned long) *max_remaining_gapp);
 219
 220 }
 221
 222 struct ir_ncode *get_code_by_name(struct ir_remote *remote,char *name)
 223 {
 224         struct ir_ncode *all;
 225
 226         all=remote->codes;
 227         while(all->name!=NULL)
 228         {
 229                 if(strcasecmp(all->name,name)==0)
 230                 {
 231                         return(all);
 232                 }
 233                 all++;
 234         }
 235         return(0);
 236 }
 237
 238 struct ir_ncode *get_code(struct ir_remote *remote,
 239                           ir_code pre,ir_code code,ir_code post,
 240                           ir_code *toggle_bit_mask_statep)
 241 {
 242         ir_code pre_mask,code_mask,post_mask,toggle_bit_mask_state,all;
 243         int found_code, have_code;
 244         struct ir_ncode *codes,*found;
 245
 246         pre_mask=code_mask=post_mask=0;
 247
 248         if(has_toggle_bit_mask(remote))
 249         {
 250                 pre_mask = remote->toggle_bit_mask >>
 251                            (remote->bits + remote->post_data_bits);
 252                 post_mask = remote->toggle_bit_mask &
 253                             gen_mask(remote->post_data_bits);
 254         }
 255         if(has_ignore_mask(remote))
 256         {
 257                 pre_mask |= remote->ignore_mask >>
 258                            (remote->bits + remote->post_data_bits);
 259                 post_mask |= remote->ignore_mask &
 260                             gen_mask(remote->post_data_bits);
 261         }
 262         if(has_toggle_mask(remote) && remote->toggle_mask_state%2)
 263         {
 264                 ir_code *affected,mask,mask_bit;
 265                 int bit,current_bit;
 266
 267                 affected=&post;
 268                 mask=remote->toggle_mask;
 269                 for(bit=current_bit=0;bit<bit_count(remote);bit++,current_bit++)
 270                 {
 271                         if(bit==remote->post_data_bits)
 272                         {
 273                                 affected=&code;
 274                                 current_bit=0;
 275                         }
 276                         if(bit==remote->post_data_bits+remote->bits)
 277                         {
 278                                 affected=&pre;
 279                                 current_bit=0;
 280                         }
 281                         mask_bit=mask&1;
 282                         (*affected)^=(mask_bit<<current_bit);
 283                         mask>>=1;
 284                 }
 285         }
 286         if(has_pre(remote))
 287         {
 288                 if((pre|pre_mask)!=(remote->pre_data|pre_mask))
 289                 {
 290                         LOGPRINTF(1,"bad pre data");
 291 #                       ifdef LONG_IR_CODE
 292                         LOGPRINTF(2,"%llx %llx",pre,remote->pre_data);
 293 #                       else
 294                         LOGPRINTF(2,"%lx %lx",pre,remote->pre_data);
 295 #                       endif
 296                         return(0);
 297                 }
 298                 LOGPRINTF(1,"pre");
 299         }
 300
 301         if(has_post(remote))
 302         {
 303                 if((post|post_mask)!=(remote->post_data|post_mask))
 304                 {
 305                         LOGPRINTF(1,"bad post data");
 306 #                       ifdef LONG_IR_CODE
 307                         LOGPRINTF(2,"%llx %llx",post,remote->post_data);
 308 #                       else
 309                         LOGPRINTF(2,"%lx %lx",post,remote->post_data);
 310 #                       endif
 311                         return(0);
 312                 }
 313                 LOGPRINTF(1,"post");
 314         }
 315
 316         all = gen_ir_code(remote, pre, code, post);
 317
 318         toggle_bit_mask_state = all&remote->toggle_bit_mask;
 319
 320         found=NULL;
 321         found_code=0;
 322         have_code=0;
 323         codes=remote->codes;
 324         if(codes!=NULL)
 325         {
 326                 while(codes->name!=NULL)
 327                 {
 328                         ir_code next_all;
 329
 330                         next_all = gen_ir_code(remote, remote->pre_data,
 331                                                get_ir_code(codes, codes->current),
 332                                                remote->post_data);
 333                         if(match_ir_code(remote, next_all, all))
 334                         {
 335                                 found_code=1;
 336                                 if(codes->next!=NULL)
 337                                 {
 338                                         if(codes->current==NULL)
 339                                         {
 340                                                 codes->current=codes->next;
 341                                         }
 342                                         else
 343                                         {
 344                                                 codes->current=
 345                                                         codes->current->next;
 346                                         }
 347                                 }
 348                                 if(!have_code)
 349                                 {
 350                                         found=codes;
 351                                         if(codes->current==NULL)
 352                                         {
 353                                                 have_code=1;
 354                                         }
 355                                 }
 356                         }
 357                         else
 358                         {
 359                                 /* find longest matching sequence */
 360                                 struct ir_code_node *search;
 361
 362                                 search = codes->next;
 363                                 if(search == NULL ||
 364                                         (codes->next != NULL && codes->current == NULL))
 365                                 {
 366                                         codes->current=NULL;
 367                                 }
 368                                 else
 369                                 {
 370                                         int sequence_match = 0;
 371
 372                                         while(search != codes->current->next)
 373                                         {
 374                                                 struct ir_code_node *prev, *next;
 375                                                 int flag = 1;
 376
 377                                                 prev = NULL; /* means codes->code */
 378                                                 next = search;
 379                                                 while(next != codes->current)
 380                                                 {
 381                                                         if(get_ir_code(codes, prev) != get_ir_code(codes, next))
 382                                                         {
 383                                                                 flag = 0;
 384                                                                 break;
 385                                                         }
 386                                                         prev = get_next_ir_code_node(codes, prev);
 387                                                         next = get_next_ir_code_node(codes, next);
 388                                                 }
 389                                                 if(flag == 1)
 390                                                 {
 391                                                         next_all = gen_ir_code(remote, remote->pre_data,
 392                                                                                get_ir_code(codes, prev),
 393                                                                                remote->post_data);
 394                                                         if(match_ir_code(remote, next_all, all))
 395                                                         {
 396                                                                 codes->current = get_next_ir_code_node(codes, prev);
 397                                                                 sequence_match = 1;
 398                                                                 break;
 399                                                         }
 400                                                 }
 401                                                 search = search->next;
 402                                         }
 403                                         if(!sequence_match) codes->current = NULL;
 404                                 }
 405                         }
 406                         codes++;
 407                 }
 408         }
 409 #       ifdef DYNCODES
 410         if(!found_code)
 411         {
 412                 if(remote->dyncodes[remote->dyncode].code!=code)
 413                 {
 414                         remote->dyncode++;
 415                         remote->dyncode%=2;
 416                 }
 417                 remote->dyncodes[remote->dyncode].code=code;
 418                 found=&(remote->dyncodes[remote->dyncode]);
 419                 found_code=1;
 420         }
 421 #       endif
 422         if(found_code && found!=NULL && has_toggle_mask(remote))
 423         {
 424                 if(!(remote->toggle_mask_state%2))
 425                 {
 426                         remote->toggle_code=found;
 427                         LOGPRINTF(1,"toggle_mask_start");
 428                 }
 429                 else
 430                 {
 431                         if(found!=remote->toggle_code)
 432                         {
 433                                 remote->toggle_code=NULL;
 434                                 return(NULL);
 435                         }
 436                         remote->toggle_code=NULL;
 437                 }
 438         }
 439         *toggle_bit_mask_statep=toggle_bit_mask_state;
 440         return(found);
 441 }
 442
 443 unsigned long long set_code(struct ir_remote *remote,struct ir_ncode *found,
 444                             ir_code toggle_bit_mask_state,int repeat_flag,
 445                             lirc_t min_remaining_gap, lirc_t max_remaining_gap)
 446 {
 447         unsigned long long code;
 448         struct timeval current;
 449
 450         LOGPRINTF(1,"found: %s",found->name);
 451
 452         gettimeofday(&current,NULL);
 453         if(remote==last_remote &&
 454            (found==remote->last_code || (found->next!=NULL && found->current!=NULL)) &&
 455            repeat_flag &&
 456            time_elapsed(&remote->last_send,&current)<1000000 &&
 457            (!has_toggle_bit_mask(remote) || toggle_bit_mask_state==remote->toggle_bit_mask_state))
 458         {
 459                 if(has_toggle_mask(remote))
 460                 {
 461                         remote->toggle_mask_state++;
 462                         if(remote->toggle_mask_state==4)
 463                         {
 464                                 remote->reps++;
 465                                 remote->toggle_mask_state=2;
 466                         }
 467                 }
 468                 else if(found->current==NULL)
 469                 {
 470                         remote->reps++;
 471                 }
 472         }
 473         else
 474         {
 475                 if(found->next!=NULL && found->current==NULL)
 476                 {
 477                         remote->reps=1;
 478                 }
 479                 else
 480                 {
 481                         remote->reps=0;
 482                 }
 483                 if(has_toggle_mask(remote))
 484                 {
 485                         remote->toggle_mask_state=1;
 486                         remote->toggle_code=found;
 487                 }
 488                 if(has_toggle_bit_mask(remote))
 489                 {
 490                         remote->toggle_bit_mask_state=toggle_bit_mask_state;
 491                 }
 492         }
 493         last_remote=remote;
 494         if(found->current==NULL) remote->last_code=found;
 495         remote->last_send=current;
 496         remote->min_remaining_gap=min_remaining_gap;
 497         remote->max_remaining_gap=max_remaining_gap;
 498
 499         code=0;
 500         if(has_pre(remote))
 501         {
 502                 code|=remote->pre_data;
 503                 code=code<<remote->bits;
 504         }
 505         code|=found->code;
 506         if(has_post(remote))
 507         {
 508                 code=code<<remote->post_data_bits;
 509                 code|=remote->post_data;
 510         }
 511         if(remote->flags&COMPAT_REVERSE)
 512         {
 513                 /* actually this is wrong: pre, code and post should
 514                    be rotated separately but we have to stay
 515                    compatible with older software
 516                  */
 517                 code=reverse(code,bit_count(remote));
 518         }
 519         return(code);
 520 }
 521
 522 int write_message(char *buffer, size_t size, const char *remote_name,
 523                   const char *button_name, const char *button_suffix,
 524                   ir_code code, int reps)
 525 {
 526         int len;
 527
 528 #ifdef __GLIBC__
 529         /* It seems you can't print 64-bit longs on glibc */
 530
 531         len=snprintf(buffer, size,"%08lx%08lx %02x %s%s %s\n",
 532                      (unsigned long) (code>>32),
 533                      (unsigned long) (code&0xFFFFFFFF),
 534                      reps,
 535                      button_name, button_suffix,
 536                      remote_name);
 537 #else
 538         len=snprintf(buffer, size, "%016llx %02x %s%s %s\n",
 539                      code,
 540                      reps,
 541                      button_name, button_suffix,
 542                      remote_name);
 543 #endif
 544         return len;
 545 }
 546
 547 char *decode_all(struct ir_remote *remotes)
 548 {
 549         struct ir_remote *remote;
 550         static char message[PACKET_SIZE+1];
 551         ir_code pre,code,post;
 552         struct ir_ncode *ncode;
 553         int repeat_flag;
 554         ir_code toggle_bit_mask_state;
 555         lirc_t min_remaining_gap, max_remaining_gap;
 556         struct ir_remote *scan;
 557         struct ir_ncode *scan_ncode;
 558
 559         /* use remotes carefully, it may be changed on SIGHUP */
 560         decoding=remote=remotes;
 561         while(remote)
 562         {
 563                 LOGPRINTF(1,"trying \"%s\" remote",remote->name);
 564
 565                 if(hw.decode_func(remote,&pre,&code,&post,&repeat_flag,
 566                                   &min_remaining_gap, &max_remaining_gap) &&
 567                    (ncode=get_code(remote,pre,code,post,&toggle_bit_mask_state)))
 568                 {
 569                         int len;
 570
 571                         code=set_code(remote,ncode,toggle_bit_mask_state,
 572                                       repeat_flag,
 573                                       min_remaining_gap,
 574                                       max_remaining_gap);
 575                         if((has_toggle_mask(remote) &&
 576                             remote->toggle_mask_state%2) ||
 577                            ncode->current!=NULL)
 578                         {
 579                                 decoding=NULL;
 580                                 return(NULL);
 581                         }
 582
 583                         for(scan = decoding; scan != NULL; scan = scan->next)
 584                         {
 585                                 for( scan_ncode = scan->codes; scan_ncode->name != NULL; scan_ncode++)
 586                                 {
 587                                         scan_ncode->current = NULL;
 588                                 }
 589                         }
 590                         register_button_press
 591                                 (remote, remote->last_code,
 592                                  code, remote->reps-(ncode->next ? 1:0));
 593
 594                         len = write_message(message, PACKET_SIZE+1,
 595                                             remote->name,
 596                                             remote->last_code->name, "", code,
 597                                             remote->reps-(ncode->next ? 1:0));
 598                         decoding=NULL;
 599                         if(len>=PACKET_SIZE+1)
 600                         {
 601                                 logprintf(LOG_ERR,"message buffer overflow");
 602                                 return(NULL);
 603                         }
 604                         else
 605                         {
 606                                 return(message);
 607                         }
 608                 }
 609                 else
 610                 {
 611                         LOGPRINTF(1,"failed \"%s\" remote",remote->name);
 612                 }
 613                 remote->toggle_mask_state=0;
 614                 remote=remote->next;
 615         }
 616         decoding=NULL;
 617         last_remote=NULL;
 618         LOGPRINTF(1,"decoding failed for all remotes");
 619         return(NULL);
 620 }
 621
 622 int send_ir_ncode(struct ir_remote *remote,struct ir_ncode *code)
 623 {
 624         int ret;
 625
 626         ret = hw.send_func(remote, code);
 627
 628         if(ret)
 629         {
 630                 gettimeofday(&remote->last_send, NULL);
 631                 remote->last_code = code;
 632         }
 633
 634         return ret;
 635  }