20 #ifdef TIME_WITH_SYS_TIME    21 # include <sys/time.h>    24 # ifdef HAVE_SYS_TIME_H    25 #  include <sys/time.h>    34 #ifdef HAVE_KERNEL_LIRC_H    35 #include <linux/lirc.h>    37 #include "media/lirc.h"    40 #include "lirc/config_file.h"    41 #include "lirc/dump_config.h"    42 #include "lirc/config_flags.h"    43 #include "lirc/ir_remote_types.h"    45 void fprint_comment(FILE* f, 
const struct ir_remote* rem, 
const char* commandline)
    53         p = popen(
"uname -r", 
"r");
    55                 strcat(uname, 
"Cannot run uname -r(!)");
    57                 if (fgets(uname, 
sizeof(uname), p) != uname)
    58                         strcat(uname, 
"Cannot run uname -r (!)");
    62                 snprintf(cmd, 
sizeof(cmd), 
"%s", commandline);
    67         tmp = localtime(&timet);
    70                 "# This config file was automatically generated\n"    71                 "# using lirc-%s(%s) on %s"    72                 "# Command line used: %s\n"    73                 "# Kernel version (uname -r): %s"    75                 "# Remote name (as of config file): %s\n"    76                 "# Brand of remote device, the thing you hold in your hand:\n"    77                 "# Remote device model nr:\n"    78                 "# Remote device info url:\n"    79                 "# Does remote device has a bundled capture device e. g., a\n"    81                 "# For bundled USB devices: usb vendor id, product id\n"    82                 "#     and device string (use dmesg or lsusb):\n"    83                 "# Type of device controlled\n"    84                 "#     (TV, VCR, Audio, DVD, Satellite, Cable, HTPC, ...) :\n"    85                 "# Device(s) controlled by this remote:\n\n",
    89 void fprint_flags(FILE* f, 
int flags)
    98                                 fprintf(f, 
"  flags ");
   109 void fprint_remotes(FILE* f, 
const struct ir_remote* all, 
const char* commandline)
   112                 fprint_remote(f, all, commandline);
   118 void fprint_remote_gap(FILE* f, 
const struct ir_remote* rem)
   121                 fprintf(f, 
"  gap          %u %u\n", (uint32_t)rem->
gap, (uint32_t)rem->
gap2);
   123                 fprintf(f, 
"  gap          %u\n", (uint32_t)rem->
gap);
   126 void fprint_remote_head(FILE* f, 
const struct ir_remote* rem)
   128         fprintf(f, 
"begin remote\n\n");
   129         fprintf(f, 
"  name  %s\n", rem->
name);
   133                 fprintf(f, 
"  driver %s\n", rem->
driver);
   135                 fprintf(f, 
"  bits        %5d\n", rem->
bits);
   136         fprint_flags(f, rem->
flags);
   137         fprintf(f, 
"  eps         %5d\n", rem->
eps);
   138         fprintf(f, 
"  aeps        %5d\n\n", rem->
aeps);
   141                         fprintf(f, 
"  header      %5u %5u\n", (uint32_t)rem->phead, (uint32_t)rem->
shead);
   142                 if (rem->pthree != 0 || rem->
sthree != 0)
   143                         fprintf(f, 
"  three       %5u %5u\n", (uint32_t)rem->pthree, (uint32_t)rem->
sthree);
   144                 if (rem->ptwo != 0 || rem->
stwo != 0)
   145                         fprintf(f, 
"  two         %5u %5u\n", (uint32_t)rem->ptwo, (uint32_t)rem->
stwo);
   146                 fprintf(f, 
"  one         %5u %5u\n", (uint32_t)rem->pone, (uint32_t)rem->
sone);
   147                 fprintf(f, 
"  zero        %5u %5u\n", (uint32_t)rem->pzero, (uint32_t)rem->
szero);
   150                 fprintf(f, 
"  ptrail      %5u\n", (uint32_t)rem->
ptrail);
   153                         fprintf(f, 
"  plead       %5u\n", (uint32_t)rem->
plead);
   155                         fprintf(f, 
"  foot        %5u %5u\n", (uint32_t)rem->pfoot, (uint32_t)rem->
sfoot);
   158                 fprintf(f, 
"  repeat      %5u %5u\n", (uint32_t)rem->prepeat, (uint32_t)rem->
srepeat);
   162                         fprintf(f, 
"  pre_data       0x%llX\n", (
unsigned long long)rem->
pre_data);
   166                         fprintf(f, 
"  post_data      0x%llX\n", (
unsigned long long)rem->
post_data);
   168                 if (rem->pre_p != 0 && rem->
pre_s != 0)
   169                         fprintf(f, 
"  pre         %5u %5u\n", (uint32_t)rem->pre_p, (uint32_t)rem->
pre_s);
   170                 if (rem->post_p != 0 && rem->
post_s != 0)
   171                         fprintf(f, 
"  post        %5u %5u\n", (uint32_t)rem->post_p, (uint32_t)rem->
post_s);
   173         fprint_remote_gap(f, rem);
   174         if (has_repeat_gap(rem))
   175                 fprintf(f, 
"  repeat_gap   %u\n", (uint32_t)rem->
repeat_gap);
   179                 fprintf(f, 
"  min_repeat      %d\n", rem->
min_repeat);
   181                         fprintf(f, 
"#  suppress_repeat %d\n", rem->
min_repeat);
   182                         fprintf(f, 
"#  uncomment to suppress unwanted repeats\n");
   188                 fprintf(f, 
"  toggle_bit_mask 0x%llX\n", (
unsigned long long)rem->
toggle_bit_mask);
   189                 if (has_toggle_mask(rem))
   190                         fprintf(f, 
"  toggle_mask    0x%llX\n", (
unsigned long long)rem->
toggle_mask);
   192                         fprintf(f, 
"  repeat_mask    0x%llX\n", (
unsigned long long)rem->
repeat_mask);
   194                         fprintf(f, 
"  rc6_mask    0x%llX\n", (
unsigned long long)rem->
rc6_mask);
   195                 if (has_ignore_mask(rem))
   196                         fprintf(f, 
"  ignore_mask 0x%llX\n", (
unsigned long long)rem->
ignore_mask);
   197                 if (is_serial(rem)) {
   198                         fprintf(f, 
"  baud            %d\n", rem->
baud);
   204                 fprintf(f, 
"  frequency    %u\n", rem->
freq);
   206                 fprintf(f, 
"  duty_cycle   %u\n", rem->
duty_cycle);
   210 void fprint_remote_foot(FILE* f, 
const struct ir_remote* rem)
   212         fprintf(f, 
"end remote\n");
   215 void fprint_remote_signal_head(FILE* f, 
const struct ir_remote* rem)
   218                 fprintf(f, 
"      begin codes\n");
   220                 fprintf(f, 
"      begin raw_codes\n\n");
   223 void fprint_remote_signal_foot(FILE* f, 
const struct ir_remote* rem)
   226                 fprintf(f, 
"      end codes\n\n");
   228                 fprintf(f, 
"      end raw_codes\n\n");
   231 void fprint_remote_signal(FILE* f,
   241                 sprintf(format, 
"          %%-24s 0x%%0%dllX",
   242                         (rem->
bits + 3) / 4);
   243                 fprintf(f, format, codes->
name, codes->
code);
   244                 sprintf(format, 
" 0x%%0%dlX", (rem->
bits + 3) / 4);
   245                 for (loop = codes->
next; loop != NULL; loop = loop->next)
   246                         fprintf(f, format, loop->code);
   250                 fprintf(f, 
"          name %s\n", codes->
name);
   252                 for (i = 0; i < codes->
length; i++) {
   254                                 fprintf(f, 
"          %7u", (uint32_t)codes->
signals[i]);
   256                                 fprintf(f, 
" %7u", (uint32_t)codes->
signals[i]);
   258                                 fprintf(f, 
" %7u\n", (uint32_t)codes->
signals[i]);
   272 void fprint_remote_signals(FILE* f, 
const struct ir_remote* rem)
   276         fprint_remote_signal_head(f, rem);
   278         while (codes->
name != NULL) {
   279                 fprint_remote_signal(f, rem, codes);
   282         fprint_remote_signal_foot(f, rem);
   285 void fprint_remote(FILE* f, 
const struct ir_remote* rem, 
const char* commandline)
   287         fprint_comment(f, rem, commandline);
   288         fprint_remote_head(f, rem);
   289         fprint_remote_signals(f, rem);
   290         fprint_remote_foot(f, rem);
 One remote as represented in the configuration file. 
int bits
bits (length of code) 
An ir_code for entering into (singly) linked lists, i.e. 
unsigned int freq
modulation frequency 
const struct driver *const curr_driver
Read-only access to drv for client code. 
ir_code post_data
data which the remote sends after actual keycode 
lirc_t post_s
signal between keycode and post_code 
lirc_t plead
leading pulse 
ir_code repeat_mask
mask defines which bits are inverted for repeats 
struct ir_code_node * next
Linked list of the subsequent ir_code's, after the first one. 
unsigned int baud
can be overridden by [p|s]zero, [p|s]one 
const char * name
name of remote control 
lirc_t * signals
(private) 
int eps
eps (relative tolerance) 
lirc_t ptrail
trailing pulse 
int pre_data_bits
length of pre_data 
int manual_sort
If set in any remote, disables automatic sorting. 
char * name
Name of command. 
unsigned int duty_cycle
0<duty cycle<=100 default: 50 
int post_data_bits
length of post_data 
lirc_t sthree
3 (only used for RC-MM) 
ir_code toggle_mask
Sharp (?) error detection scheme. 
ir_code pre_data
data which the remote sends before actual keycode 
uint32_t gap
time between signals in usecs 
uint32_t repeat_gap
time between two repeat codes if different from gap 
uint32_t gap2
time between signals in usecs 
unsigned int stop_bits
mapping: 1->2 1.5->3 2->4 
lirc_t pre_s
signal between pre_data and keycode 
IR Command, corresponding to one (command defining) line of the configuration file. 
lirc_t stwo
2 (only used for RC-MM) 
unsigned int aeps
detecting very short pulses is difficult with relative tolerance for some remotes, this is an absolute tolerance to solve this problem usually you can say 0 here. 
lirc_t srepeat
indicate repeating 
const char * name
Driver name, as listed by -H help and used as argument to i –driver. 
int suppress_repeat
suppress unwanted repeats 
ir_code code
The first code of the command. 
const char * driver
Name of driver for LIRCCODE cases. 
unsigned int min_code_repeat
meaningful only if remote sends a repeat code: in this case this value indicates how often the real c...
const struct flaglist all_flags[]
All flags i config file: Their name and mask. 
ir_code rc6_mask
RC-6 doubles signal length of some bits. 
ir_code toggle_bit_mask
previously only one bit called toggle_bit 
int min_repeat
code is repeated at least x times code sent once -> min_repeat=0 
ir_code ignore_mask
mask defines which bits can be ignored when matching a code 
unsigned int bits_in_byte
default: 8