Loading...
Searching...
No Matches
dump_config.c
Go to the documentation of this file.
/****************************************************************************
** dump_config.c ***********************************************************
****************************************************************************
*
* dump_config.c - dumps data structures into file
*
* Copyright (C) 1998 Pablo d'Angelo <pablo@ag-trek.allgaeu.org>
*
*/
#ifdef HAVE_CONFIG_H
# include <config.h>
#endif
#ifdef TIME_WITH_SYS_TIME
# include <sys/time.h>
# include <time.h>
#else
# ifdef HAVE_SYS_TIME_H
# include <sys/time.h>
# else
# include <time.h>
# endif
#endif
#include <stdio.h>
#include <stdint.h>
#include "media/lirc.h"
#include "lirc/config_file.h"
#include "lirc/dump_config.h"
#include "lirc/config_flags.h"
#include "lirc/ir_remote_types.h"
void fprint_comment(FILE* f, const struct ir_remote* rem, const char* commandline)
{
time_t timet;
struct tm* tmp;
char cmd[128];
char uname[64];
FILE* p;
p = popen("uname -r", "r");
if (p < 0) {
strcat(uname, "Cannot run uname -r(!)");
} else {
if (fgets(uname, sizeof(uname), p) != uname)
strcat(uname, "Cannot run uname -r (!)");
pclose(p);
}
if (commandline)
snprintf(cmd, sizeof(cmd), "%s", commandline);
else
strcat(cmd, "");
timet = time(NULL);
tmp = localtime(&timet);
fprintf(f,
"#\n"
"# This config file was automatically generated\n"
"# using lirc-%s(%s) on %s"
"# Command line used: %s\n"
"# Kernel version (uname -r): %s"
"#\n"
"# Remote name (as of config file): %s\n"
"# Brand of remote device, the thing you hold in your hand:\n"
"# Remote device model nr:\n"
"# Remote device info url:\n"
"# Does remote device has a bundled capture device e. g., a\n"
"# usb dongle? :\n"
"# For bundled USB devices: usb vendor id, product id\n"
"# and device string (use dmesg or lsusb):\n"
"# Type of device controlled\n"
"# (TV, VCR, Audio, DVD, Satellite, Cable, HTPC, ...) :\n"
"# Device(s) controlled by this remote:\n\n",
VERSION, curr_driver->name, asctime(tmp), cmd, uname, rem->name);
}
void fprint_flags(FILE* f, int flags)
{
int i;
int begin = 0;
for (i = 0; all_flags[i].flag; i++) {
if (flags & all_flags[i].flag) {
flags &= (~all_flags[i].flag);
if (begin == 0)
fprintf(f, " flags ");
else if (begin == 1)
fprintf(f, "|");
fprintf(f, "%s", all_flags[i].name);
begin = 1;
}
}
if (begin == 1)
fprintf(f, "\n");
}
void fprint_remotes(FILE* f, const struct ir_remote* all, const char* commandline)
{
while (all) {
fprint_remote(f, all, commandline);
fprintf(f, "\n\n");
all = all->next;
}
}
void fprint_remote_gap(FILE* f, const struct ir_remote* rem)
{
if (rem->gap2 != 0)
fprintf(f, " gap %u %u\n", (uint32_t)rem->gap, (uint32_t)rem->gap2);
else
fprintf(f, " gap %u\n", (uint32_t)rem->gap);
}
void fprint_remote_head(FILE* f, const struct ir_remote* rem)
{
fprintf(f, "begin remote\n\n");
fprintf(f, " name %s\n", rem->name);
if (rem->manual_sort)
fprintf(f, " manual_sort %d\n", rem->manual_sort);
if (rem->driver)
fprintf(f, " driver %s\n", rem->driver);
if (!is_raw(rem))
fprintf(f, " bits %5d\n", rem->bits);
fprint_flags(f, rem->flags);
fprintf(f, " eps %5d\n", rem->eps);
fprintf(f, " aeps %5d\n\n", rem->aeps);
if (!is_raw(rem)) {
if (has_header(rem))
fprintf(f, " header %5u %5u\n", (uint32_t)rem->phead, (uint32_t)rem->shead);
if (rem->pthree != 0 || rem->sthree != 0)
fprintf(f, " three %5u %5u\n", (uint32_t)rem->pthree, (uint32_t)rem->sthree);
if (rem->ptwo != 0 || rem->stwo != 0)
fprintf(f, " two %5u %5u\n", (uint32_t)rem->ptwo, (uint32_t)rem->stwo);
fprintf(f, " one %5u %5u\n", (uint32_t)rem->pone, (uint32_t)rem->sone);
fprintf(f, " zero %5u %5u\n", (uint32_t)rem->pzero, (uint32_t)rem->szero);
}
if (rem->ptrail != 0)
fprintf(f, " ptrail %5u\n", (uint32_t)rem->ptrail);
if (!is_raw(rem)) {
if (rem->plead != 0)
fprintf(f, " plead %5u\n", (uint32_t)rem->plead);
if (has_foot(rem))
fprintf(f, " foot %5u %5u\n", (uint32_t)rem->pfoot, (uint32_t)rem->sfoot);
}
if (has_repeat(rem))
fprintf(f, " repeat %5u %5u\n", (uint32_t)rem->prepeat, (uint32_t)rem->srepeat);
if (!is_raw(rem)) {
if (rem->pre_data_bits > 0) {
fprintf(f, " pre_data_bits %d\n", rem->pre_data_bits);
fprintf(f, " pre_data 0x%llX\n", (unsigned long long)rem->pre_data);
}
if (rem->post_data_bits > 0) {
fprintf(f, " post_data_bits %d\n", rem->post_data_bits);
fprintf(f, " post_data 0x%llX\n", (unsigned long long)rem->post_data);
}
if (rem->pre_p != 0 && rem->pre_s != 0)
fprintf(f, " pre %5u %5u\n", (uint32_t)rem->pre_p, (uint32_t)rem->pre_s);
if (rem->post_p != 0 && rem->post_s != 0)
fprintf(f, " post %5u %5u\n", (uint32_t)rem->post_p, (uint32_t)rem->post_s);
}
fprint_remote_gap(f, rem);
if (has_repeat_gap(rem))
fprintf(f, " repeat_gap %u\n", (uint32_t)rem->repeat_gap);
if (rem->suppress_repeat > 0)
fprintf(f, " suppress_repeat %d\n", rem->suppress_repeat);
if (rem->min_repeat > 0) {
fprintf(f, " min_repeat %d\n", rem->min_repeat);
if (rem->suppress_repeat == 0) {
fprintf(f, "# suppress_repeat %d\n", rem->min_repeat);
fprintf(f, "# uncomment to suppress unwanted repeats\n");
}
}
if (!is_raw(rem)) {
if (rem->min_code_repeat > 0)
fprintf(f, " min_code_repeat %d\n", rem->min_code_repeat);
fprintf(f, " toggle_bit_mask 0x%llX\n", (unsigned long long)rem->toggle_bit_mask);
if (has_toggle_mask(rem))
fprintf(f, " toggle_mask 0x%llX\n", (unsigned long long)rem->toggle_mask);
if (rem->repeat_mask != 0)
fprintf(f, " repeat_mask 0x%llX\n", (unsigned long long)rem->repeat_mask);
if (rem->rc6_mask != 0)
fprintf(f, " rc6_mask 0x%llX\n", (unsigned long long)rem->rc6_mask);
if (has_ignore_mask(rem))
fprintf(f, " ignore_mask 0x%llX\n", (unsigned long long)rem->ignore_mask);
if (is_serial(rem)) {
fprintf(f, " baud %d\n", rem->baud);
fprintf(f, " serial_mode %dN%d%s\n", rem->bits_in_byte, rem->stop_bits / 2,
rem->stop_bits % 2 ? ".5" : "");
}
}
if (rem->freq != 0)
fprintf(f, " frequency %u\n", rem->freq);
if (rem->duty_cycle != 0)
fprintf(f, " duty_cycle %u\n", rem->duty_cycle);
fprintf(f, "\n");
}
void fprint_remote_foot(FILE* f, const struct ir_remote* rem)
{
fprintf(f, "end remote\n");
}
void fprint_remote_signal_head(FILE* f, const struct ir_remote* rem)
{
if (!is_raw(rem))
fprintf(f, " begin codes\n");
else
fprintf(f, " begin raw_codes\n\n");
}
void fprint_remote_signal_foot(FILE* f, const struct ir_remote* rem)
{
if (!is_raw(rem))
fprintf(f, " end codes\n\n");
else
fprintf(f, " end raw_codes\n\n");
}
void fprint_remote_signal(FILE* f,
const struct ir_remote* rem,
const struct ir_ncode* codes)
{
int i, j;
if (!is_raw(rem)) {
char format[64];
const struct ir_code_node* loop;
sprintf(format, " %%-24s 0x%%0%dllX",
(rem->bits + 3) / 4);
fprintf(f, format, codes->name, codes->code);
sprintf(format, " 0x%%0%dlX", (rem->bits + 3) / 4);
for (loop = codes->next; loop != NULL; loop = loop->next)
fprintf(f, format, loop->code);
fprintf(f, "\n");
} else {
fprintf(f, " name %s\n", codes->name);
j = 0;
for (i = 0; i < codes->length; i++) {
if (j == 0) {
fprintf(f, " %7u", (uint32_t)codes->signals[i]);
} else if (j < 5) {
fprintf(f, " %7u", (uint32_t)codes->signals[i]);
} else {
fprintf(f, " %7u\n", (uint32_t)codes->signals[i]);
j = -1;
}
j++;
}
codes++;
if (j == 0) {
fprintf(f, "\n");
} else {
fprintf(f, "\n\n");
}
}
}
void fprint_remote_signals(FILE* f, const struct ir_remote* rem)
{
const struct ir_ncode* codes;
fprint_remote_signal_head(f, rem);
codes = rem->codes;
while (codes->name != NULL) {
fprint_remote_signal(f, rem, codes);
codes++;
}
fprint_remote_signal_foot(f, rem);
}
void fprint_remote(FILE* f, const struct ir_remote* rem, const char* commandline)
{
fprint_comment(f, rem, commandline);
fprint_remote_head(f, rem);
fprint_remote_signals(f, rem);
fprint_remote_foot(f, rem);
}
all_flags
const struct flaglist all_flags[]
All flags i config file: Their name and mask.
Definition config_file.c:95
curr_driver
const struct driver *const curr_driver
Read-only access to drv for client code.
Definition driver.c:34
driver::name
const char * name
Driver name, as listed by -H help and used as argument to i –driver.
Definition driver.h:224
flaglist::flag
int flag
Flag bitmask.
Definition config_flags.h:18
ir_code_node
An ir_code for entering into (singly) linked lists, i.e.
Definition ir_remote_types.h:49
ir_ncode
IR Command, corresponding to one (command defining) line of the configuration file.
Definition ir_remote_types.h:60
ir_ncode::next
struct ir_code_node * next
Linked list of the subsequent ir_code's, after the first one.
Definition ir_remote_types.h:75
ir_ncode::code
ir_code code
The first code of the command.
Definition ir_remote_types.h:65
ir_ncode::length
int length
(private)
Definition ir_remote_types.h:68
ir_ncode::signals
lirc_t * signals
(private)
Definition ir_remote_types.h:71
ir_ncode::name
char * name
Name of command.
Definition ir_remote_types.h:62
ir_remote
One remote as represented in the configuration file.
Definition ir_remote_types.h:150
ir_remote::driver
const char * driver
Name of driver for LIRCCODE cases.
Definition ir_remote_types.h:152
ir_remote::repeat_gap
uint32_t repeat_gap
time between two repeat codes if different from gap
Definition ir_remote_types.h:188
ir_remote::stwo
lirc_t stwo
2 (only used for RC-MM)
Definition ir_remote_types.h:171
ir_remote::freq
unsigned int freq
modulation frequency
Definition ir_remote_types.h:203
ir_remote::suppress_repeat
int suppress_repeat
suppress unwanted repeats
Definition ir_remote_types.h:191
ir_remote::aeps
unsigned int aeps
detecting very short pulses is difficult with relative tolerance for some remotes,...
Definition ir_remote_types.h:157
ir_remote::gap2
uint32_t gap2
time between signals in usecs
Definition ir_remote_types.h:187
ir_remote::stop_bits
unsigned int stop_bits
mapping: 1->2 1.5->3 2->4
Definition ir_remote_types.h:212
ir_remote::bits_in_byte
unsigned int bits_in_byte
default: 8
Definition ir_remote_types.h:210
ir_remote::sfoot
lirc_t sfoot
foot
Definition ir_remote_types.h:176
ir_remote::rc6_mask
ir_code rc6_mask
RC-6 doubles signal length of some bits.
Definition ir_remote_types.h:206
ir_remote::ptrail
lirc_t ptrail
trailing pulse
Definition ir_remote_types.h:175
ir_remote::duty_cycle
unsigned int duty_cycle
0<duty cycle<=100 default: 50
Definition ir_remote_types.h:204
ir_remote::repeat_mask
ir_code repeat_mask
mask defines which bits are inverted for repeats
Definition ir_remote_types.h:217
ir_remote::srepeat
lirc_t srepeat
indicate repeating
Definition ir_remote_types.h:177
ir_remote::pre_data
ir_code pre_data
data which the remote sends before actual keycode
Definition ir_remote_types.h:180
ir_remote::bits
int bits
bits (length of code)
Definition ir_remote_types.h:154
ir_remote::post_data_bits
int post_data_bits
length of post_data
Definition ir_remote_types.h:181
ir_remote::ignore_mask
ir_code ignore_mask
mask defines which bits can be ignored when matching a code
Definition ir_remote_types.h:216
ir_remote::plead
lirc_t plead
leading pulse
Definition ir_remote_types.h:174
ir_remote::sthree
lirc_t sthree
3 (only used for RC-MM)
Definition ir_remote_types.h:170
ir_remote::shead
lirc_t shead
header
Definition ir_remote_types.h:169
ir_remote::szero
lirc_t szero
0
Definition ir_remote_types.h:173
ir_remote::post_data
ir_code post_data
data which the remote sends after actual keycode
Definition ir_remote_types.h:182
ir_remote::toggle_mask
ir_code toggle_mask
Sharp (?) error detection scheme.
Definition ir_remote_types.h:205
ir_remote::flags
int flags
flags
Definition ir_remote_types.h:155
ir_remote::baud
unsigned int baud
can be overridden by [p|s]zero, [p|s]one
Definition ir_remote_types.h:209
ir_remote::min_repeat
int min_repeat
code is repeated at least x times code sent once -> min_repeat=0
Definition ir_remote_types.h:194
ir_remote::manual_sort
int manual_sort
If set in any remote, disables automatic sorting.
Definition ir_remote_types.h:237
ir_remote::post_s
lirc_t post_s
signal between keycode and post_code
Definition ir_remote_types.h:184
ir_remote::pre_s
lirc_t pre_s
signal between pre_data and keycode
Definition ir_remote_types.h:183
ir_remote::gap
uint32_t gap
time between signals in usecs
Definition ir_remote_types.h:186
ir_remote::eps
int eps
eps (relative tolerance)
Definition ir_remote_types.h:156
ir_remote::min_code_repeat
unsigned int min_code_repeat
meaningful only if remote sends a repeat code: in this case this value indicates how often the real c...
Definition ir_remote_types.h:202
ir_remote::sone
lirc_t sone
1
Definition ir_remote_types.h:172
ir_remote::name
const char * name
name of remote control
Definition ir_remote_types.h:151
ir_remote::toggle_bit_mask
ir_code toggle_bit_mask
previously only one bit called toggle_bit
Definition ir_remote_types.h:190
ir_remote::pre_data_bits
int pre_data_bits
length of pre_data
Definition ir_remote_types.h:179