26 #include "media/lirc.h"
28 #include "lirc/driver.h"
29 #include "lirc/lirc_log.h"
30 #include "lirc/receive.h"
31 #include "lirc/ir_remote.h"
43 lirc_t data[RBUF_SIZE];
52 struct timeval last_signal_time;
61 static struct rbuf rec_buffer;
62 static int update_mode = 0;
70 int (*lircd_waitfordata)(uint32_t timeout) = NULL;
73 static lirc_t readdata(lirc_t timeout)
78 rec_buffer.at_eof = data &
LIRC_EOF ? 1 : 0;
79 if (rec_buffer.at_eof)
85 static lirc_t lirc_t_max(lirc_t a, lirc_t b)
90 static void set_pending_pulse(lirc_t deltap)
93 rec_buffer.pendingp = deltap;
96 static void set_pending_space(lirc_t deltas)
99 rec_buffer.pendings = deltas;
103 static void log_input(lirc_t data)
105 fprintf(rec_buffer.input_log,
"%s %u\n",
106 data & PULSE_BIT ?
"pulse" :
"space", data & PULSE_MASK);
107 fflush(rec_buffer.input_log);
111 static lirc_t get_next_rec_buffer_internal(lirc_t maxusec)
113 if (rec_buffer.rptr < rec_buffer.wptr) {
114 log_trace2(
"<%c%lu", rec_buffer.data[rec_buffer.rptr] & PULSE_BIT ?
'p' :
's', (uint32_t)
115 rec_buffer.data[rec_buffer.rptr] & (PULSE_MASK));
116 rec_buffer.sum += rec_buffer.data[rec_buffer.rptr] & (PULSE_MASK);
117 return rec_buffer.data[rec_buffer.rptr++];
119 if (rec_buffer.wptr < RBUF_SIZE) {
121 unsigned long elapsed = 0;
123 if (timerisset(&rec_buffer.last_signal_time)) {
124 struct timeval current;
126 gettimeofday(¤t, NULL);
127 elapsed = time_elapsed(&rec_buffer.last_signal_time, ¤t);
129 if (elapsed < maxusec)
130 data = readdata(maxusec - elapsed);
139 if (LIRC_IS_TIMEOUT(data)) {
140 log_trace(
"timeout received: %lu", (uint32_t)LIRC_VALUE(data));
141 if (LIRC_VALUE(data) < maxusec)
142 return get_next_rec_buffer_internal(maxusec - LIRC_VALUE(data));
146 rec_buffer.data[rec_buffer.wptr] = data;
147 if (rec_buffer.input_log != NULL)
149 if (rec_buffer.data[rec_buffer.wptr] == 0)
151 rec_buffer.sum += rec_buffer.data[rec_buffer.rptr]
155 log_trace2(
"+%c%lu", rec_buffer.data[rec_buffer.rptr - 1] & PULSE_BIT ?
'p' :
's', (uint32_t)
156 rec_buffer.data[rec_buffer.rptr - 1]
158 return rec_buffer.data[rec_buffer.rptr - 1];
160 rec_buffer.too_long = 1;
167 lircd_waitfordata = func;
174 struct pollfd pfd = {
177 if (lircd_waitfordata != NULL)
178 return lircd_waitfordata(maxusec);
183 ret = curl_poll(&pfd, 1, (maxusec > 0) ? (maxusec / 1000) : -1);
184 if (maxusec > 0 && ret == 0)
186 }
while (ret == -1 && errno == EINTR);
193 if (pfd.revents & POLLIN)
202 if (rec_buffer.input_log != NULL)
203 fclose(rec_buffer.input_log);
204 rec_buffer.input_log = f;
208 static lirc_t get_next_rec_buffer(lirc_t maxusec)
210 return get_next_rec_buffer_internal(receive_timeout(maxusec));
215 memset(&rec_buffer, 0,
sizeof(rec_buffer));
221 rec_buffer.too_long = 0;
222 set_pending_pulse(0);
223 set_pending_space(0);
225 rec_buffer.at_eof = 0;
237 timerclear(&rec_buffer.last_signal_time);
247 log_error(
"reading in mode LIRC_MODE_LIRCCODE failed");
250 for (i = 0, rec_buffer.decoded = 0; i < count; i++)
251 rec_buffer.decoded = (rec_buffer.decoded << CHAR_BIT) + ((
ir_code)buffer[i]);
255 move = rec_buffer.wptr - rec_buffer.rptr;
256 if (move > 0 && rec_buffer.rptr > 0) {
257 memmove(&rec_buffer.data[0], &rec_buffer.data[rec_buffer.rptr],
258 sizeof(rec_buffer.data[0]) * move);
259 rec_buffer.wptr -= rec_buffer.rptr;
264 log_trace2(
"c%lu", (uint32_t)data & (PULSE_MASK));
266 rec_buffer.data[rec_buffer.wptr] = data;
272 rec_buffer.is_biphase = 0;
277 static void unget_rec_buffer(
int count)
280 if (count == 1 || count == 2) {
281 rec_buffer.rptr -= count;
282 rec_buffer.sum -= rec_buffer.data[rec_buffer.rptr] & (PULSE_MASK);
284 rec_buffer.sum -= rec_buffer.data[rec_buffer.rptr + 1]
289 static void unget_rec_buffer_delta(lirc_t delta)
292 rec_buffer.sum -= delta & (PULSE_MASK);
293 rec_buffer.data[rec_buffer.rptr] = delta;
296 static lirc_t get_next_pulse(lirc_t maxusec)
300 data = get_next_rec_buffer(maxusec);
303 if (!is_pulse(data)) {
307 return data & (PULSE_MASK);
310 static lirc_t get_next_space(lirc_t maxusec)
314 data = get_next_rec_buffer(maxusec);
317 if (!is_space(data)) {
324 static int sync_pending_pulse(
struct ir_remote* remote)
326 if (rec_buffer.pendingp > 0) {
329 deltap = get_next_pulse(rec_buffer.pendingp);
332 if (!expect(remote, deltap, rec_buffer.pendingp))
334 set_pending_pulse(0);
339 static int sync_pending_space(
struct ir_remote* remote)
341 if (rec_buffer.pendings > 0) {
344 deltas = get_next_space(rec_buffer.pendings);
347 if (!expect(remote, deltas, rec_buffer.pendings))
349 set_pending_space(0);
354 static int expectpulse(
struct ir_remote* remote,
int exdelta)
360 if (!sync_pending_space(remote))
363 deltap = get_next_pulse(rec_buffer.pendingp + exdelta);
366 if (rec_buffer.pendingp > 0) {
367 if (rec_buffer.pendingp > deltap)
369 retval = expect(remote, deltap - rec_buffer.pendingp, exdelta);
372 set_pending_pulse(0);
374 retval = expect(remote, deltap, exdelta);
379 static int expectspace(
struct ir_remote* remote,
int exdelta)
385 if (!sync_pending_pulse(remote))
388 deltas = get_next_space(rec_buffer.pendings + exdelta);
391 if (rec_buffer.pendings > 0) {
392 if (rec_buffer.pendings > deltas)
394 retval = expect(remote, deltas - rec_buffer.pendings, exdelta);
397 set_pending_space(0);
399 retval = expect(remote, deltas, exdelta);
404 static int expectone(
struct ir_remote* remote,
int bit)
406 if (is_biphase(remote)) {
407 int all_bits = bit_count(remote);
410 mask = ((
ir_code)1) << (all_bits - 1 - bit);
412 if (remote->
sone > 0 && !expectspace(remote, 2 * remote->
sone)) {
416 set_pending_pulse(2 * remote->pone);
418 if (remote->
sone > 0 && !expectspace(remote, remote->
sone)) {
422 set_pending_pulse(remote->pone);
424 }
else if (is_space_first(remote)) {
425 if (remote->
sone > 0 && !expectspace(remote, remote->
sone)) {
429 if (remote->pone > 0 && !expectpulse(remote, remote->pone)) {
434 if (remote->pone > 0 && !expectpulse(remote, remote->pone)) {
439 if (remote->
sone > 0 && !expectspace(remote, remote->
sone)) {
444 set_pending_space(remote->
sone);
450 static int expectzero(
struct ir_remote* remote,
int bit)
452 if (is_biphase(remote)) {
453 int all_bits = bit_count(remote);
456 mask = ((
ir_code)1) << (all_bits - 1 - bit);
458 if (!expectpulse(remote, 2 * remote->pzero)) {
462 set_pending_space(2 * remote->
szero);
464 if (!expectpulse(remote, remote->pzero)) {
468 set_pending_space(remote->
szero);
470 }
else if (is_space_first(remote)) {
471 if (remote->
szero > 0 && !expectspace(remote, remote->
szero)) {
475 if (remote->pzero > 0 && !expectpulse(remote, remote->pzero)) {
480 if (!expectpulse(remote, remote->pzero)) {
485 if (!expectspace(remote, remote->
szero)) {
490 set_pending_space(remote->
szero);
496 static lirc_t sync_rec_buffer(
struct ir_remote* remote)
499 lirc_t deltas, deltap;
502 deltas = get_next_space(1000000);
508 deltap = get_next_pulse(1000000);
511 deltas = get_next_space(1000000);
515 if (count > REC_SYNC)
519 if (has_toggle_mask(remote)) {
521 remote->toggle_mask_state = 0;
530 static int get_header(
struct ir_remote* remote)
532 if (is_rcmm(remote)) {
533 lirc_t deltap, deltas, sum;
535 deltap = get_next_pulse(remote->phead);
540 deltas = get_next_space(remote->
shead);
545 sum = deltap + deltas;
546 if (expect(remote, sum, remote->phead + remote->
shead))
550 }
else if (is_bo(remote)) {
551 if (expectpulse(remote, remote->pone) && expectspace(remote, remote->
sone)
552 && expectpulse(remote, remote->pone) && expectspace(remote, remote->
sone)
553 && expectpulse(remote, remote->phead) && expectspace(remote, remote->
shead))
557 if (remote->
shead == 0) {
558 if (!sync_pending_space(remote))
560 set_pending_pulse(remote->phead);
563 if (!expectpulse(remote, remote->phead)) {
572 deltas = get_next_space(remote->
shead);
574 if (expect(remote, remote->
shead, deltas))
581 set_pending_space(remote->
shead);
585 static int get_foot(
struct ir_remote* remote)
587 if (!expectspace(remote, remote->
sfoot))
589 if (!expectpulse(remote, remote->pfoot))
594 static int get_lead(
struct ir_remote* remote)
596 if (remote->
plead == 0)
598 if (!sync_pending_space(remote))
600 set_pending_pulse(remote->
plead);
604 static int get_trail(
struct ir_remote* remote)
607 if (!expectpulse(remote, remote->
ptrail))
609 if (rec_buffer.pendingp > 0)
610 if (!sync_pending_pulse(remote))
615 static int get_gap(
struct ir_remote* remote, lirc_t gap)
620 data = get_next_rec_buffer(gap - gap * remote->
eps / 100);
623 if (!is_space(data)) {
628 if (!expect_at_least(remote, data, gap)) {
635 static int get_repeat(
struct ir_remote* remote)
637 if (!get_lead(remote))
639 if (is_biphase(remote)) {
640 if (!expectspace(remote, remote->
srepeat))
642 if (!expectpulse(remote, remote->prepeat))
645 if (!expectpulse(remote, remote->prepeat))
647 set_pending_space(remote->
srepeat);
649 if (!get_trail(remote))
653 is_const(remote) ? (min_gap(remote) >
655 min_gap(remote) - rec_buffer.sum : 0) :
656 (has_repeat_gap(remote) ? remote->
repeat_gap : min_gap(remote))
669 if (is_rcmm(remote)) {
670 lirc_t deltap, deltas, sum;
672 if (bits % 2 || done % 2) {
676 if (!sync_pending_space(remote))
678 for (i = 0; i < bits; i += 2) {
680 deltap = get_next_pulse(remote->pzero + remote->pone + remote->ptwo + remote->pthree);
682 if (deltap == 0 || deltas == 0) {
683 log_error(
"failed on bit %d", done + i + 1);
686 sum = deltap + deltas;
688 if (expect(remote, sum, remote->pzero + remote->
szero)) {
691 }
else if (expect(remote, sum, remote->pone + remote->
sone)) {
694 }
else if (expect(remote, sum, remote->ptwo + remote->
stwo)) {
697 }
else if (expect(remote, sum, remote->pthree + remote->
sthree)) {
701 log_trace1(
"no match for %d+%d=%d", deltap, deltas, sum);
706 }
else if (is_grundig(remote)) {
707 lirc_t deltap, deltas, sum;
708 int state, laststate;
710 if (bits % 2 || done % 2) {
714 if (!sync_pending_pulse(remote))
716 for (laststate = state = -1, i = 0; i < bits; ) {
718 deltap = get_next_pulse(remote->pzero + remote->pone + remote->ptwo + remote->pthree);
719 if (deltas == 0 || deltap == 0) {
720 log_error(
"failed on bit %d", done + i + 1);
723 sum = deltas + deltap;
724 log_trace2(
"grundig: sum %ld", (uint32_t)sum);
725 if (expect(remote, sum, remote->
szero + remote->pzero)) {
728 }
else if (expect(remote, sum, remote->
sone + remote->pone)) {
731 }
else if (expect(remote, sum, remote->
stwo + remote->ptwo)) {
734 }
else if (expect(remote, sum, remote->
sthree + remote->pthree)) {
738 log_trace1(
"no match for %d+%d=%d", deltas, deltap, sum);
746 }
else if (laststate == 2 && state == 0) {
751 }
else if (laststate == 1 && state == 1) {
756 }
else if (laststate == 0 && state == 2) {
761 }
else if (laststate == -1) {
764 log_error(
"invalid state %d:%d", laststate, state);
770 }
else if (is_serial(remote)) {
772 int space, stop_bit, parity_bit;
774 lirc_t delta, origdelta, pending, expecting, gap_delta;
776 lirc_t max_space, max_pulse;
778 base = 1000000 / remote->
baud;
781 set_pending_pulse(base);
784 space = (rec_buffer.pendingp == 0);
787 delta = origdelta = 0;
794 if (remote->
parity != IR_PARITY_NONE) {
796 max_space += remote->
sone;
797 max_pulse += remote->pzero;
801 while (received < bits || stop_bit) {
803 delta = space ? get_next_space(max_space) : get_next_pulse(max_pulse);
804 if (delta == 0 && space && received + remote->
bits_in_byte + parity_bit >= bits)
810 log_trace(
"failed before bit %d", received + 1);
813 pending = (space ? rec_buffer.pendings : rec_buffer.pendingp);
814 if (expect(remote, delta, pending)) {
816 }
else if (delta > pending) {
819 log_trace(
"failed before bit %d", received + 1);
827 set_pending_pulse(base);
828 set_pending_space(0);
834 set_pending_pulse(0);
835 set_pending_space(0);
837 space = (space ? 0 : 1);
841 expecting = (space ? remote->
sone : remote->pzero);
842 if (delta > expecting || expect(remote, delta, expecting)) {
843 delta -= (expecting > delta ? delta : expecting);
849 if (received % (remote->
bits_in_byte + parity_bit) == 0) {
852 if ((remote->
parity == IR_PARITY_EVEN && parity)
853 || (remote->
parity == IR_PARITY_ODD && !parity)) {
854 log_trace(
"parity error after %d bits", received + 1);
862 temp << remote->
bits_in_byte | reverse(code >> parity_bit,
865 if (space && delta == 0) {
866 log_trace(
"failed at stop bit after %d bits", received + 1);
870 set_pending_space(stop);
874 if (delta == origdelta) {
875 log_trace(
"framing error after %d bits", received + 1);
881 space = (space ? 0 : 1);
884 unget_rec_buffer_delta(gap_delta);
885 set_pending_pulse(0);
886 set_pending_space(0);
888 }
else if (is_bo(remote)) {
890 lirc_t deltap, deltas;
894 for (i = 0; i < bits; i++) {
896 deltap = get_next_pulse(remote->pzero + remote->pone + remote->ptwo + remote->pthree);
898 if (deltap == 0 || deltas == 0) {
899 log_error(
"failed on bit %d", done + i + 1);
903 pzero = remote->pone;
904 szero = remote->
sone;
908 pzero = remote->ptwo;
909 szero = remote->
stwo;
910 pone = remote->pthree;
913 log_trace2(
"%lu %lu %lu %lu", pzero, szero, pone, sone);
914 if (expect(remote, deltap, pzero)) {
915 if (expect(remote, deltas, szero)) {
923 if (expect(remote, deltap, pone)) {
924 if (expect(remote, deltas, sone)) {
931 log_error(
"failed on bit %d", done + i + 1);
935 }
else if (is_xmp(remote)) {
936 lirc_t deltap, deltas, sum;
939 if (bits % 4 || done % 4) {
943 if (!sync_pending_space(remote))
945 for (i = 0; i < bits; i += 4) {
947 deltap = get_next_pulse(remote->pzero);
948 deltas = get_next_space(remote->
szero + 16 * remote->
sone);
949 if (deltap == 0 || deltas == 0) {
950 log_error(
"failed on bit %d", done + i + 1);
953 sum = deltap + deltas;
955 sum -= remote->pzero + remote->
szero;
956 n = (sum + remote->
sone / 2) / remote->
sone;
958 log_error(
"failed on bit %d", done + i + 1);
967 for (i = 0; i < bits; i++) {
969 if (expectone(remote, done + i)) {
972 }
else if (expectzero(remote, done + i)) {
976 log_trace(
"failed on bit %d", done + i + 1);
993 log_trace(
"Failed on pre_data: cannot get it");
1004 remote_pre = remote->
pre_data & ~toggle_mask;
1005 match_pre = pre & ~toggle_mask;
1006 if (remote->
pre_data != 0 && remote_pre != match_pre) {
1007 log_trace(
"Failed on pre_data: bad data: %x", pre);
1011 if (remote->pre_p > 0 && remote->
pre_s > 0) {
1012 if (!expectpulse(remote, remote->pre_p))
1014 set_pending_space(remote->
pre_s);
1023 if (remote->post_p > 0 && remote->
post_s > 0) {
1024 if (!expectpulse(remote, remote->post_p))
1026 set_pending_space(remote->
post_s);
1042 struct timeval current;
1049 if (rec_buffer.at_eof && rec_buffer.wptr - rec_buffer.rptr <= 1) {
1052 rec_buffer.at_eof = 0;
1059 rec_buffer.is_biphase = is_biphase(remote) ? 1 : 0;
1062 sync = sync_rec_buffer(remote);
1069 if (has_repeat(remote) &&
last_remote == remote) {
1071 if (!get_header(remote)) {
1077 if (get_repeat(remote)) {
1079 log_notice(
"repeat code without last_code received");
1089 is_const(remote) ? (min_gap(remote) >
1090 rec_buffer.sum ? min_gap(remote) -
1091 rec_buffer.sum : 0) : (has_repeat_gap(remote) ? remote->
1092 repeat_gap : min_gap(remote));
1094 is_const(remote) ? (max_gap(remote) >
1095 rec_buffer.sum ? max_gap(remote) -
1096 rec_buffer.sum : 0) : (has_repeat_gap(remote) ? remote->
1097 repeat_gap : max_gap(remote));
1102 sync_rec_buffer(remote);
1105 if (has_header(remote)) {
1107 if (!get_header(remote)) {
1109 if (!(remote->
flags &
NO_HEAD_REP && expect_at_most(remote, sync, max_gap(remote)))) {
1118 if (is_raw(remote)) {
1126 codes = remote->codes;
1128 while (codes->
name != NULL && found == NULL) {
1130 for (i = 0; i < codes->
length; ) {
1131 if (!expectpulse(remote, codes->
signals[i++])) {
1134 sync_rec_buffer(remote);
1137 if (i < codes->
length && !expectspace(remote, codes->
signals[i++])) {
1140 sync_rec_buffer(remote);
1145 if (found != NULL) {
1147 (remote, is_const(remote) ?
1148 min_gap(remote) - rec_buffer.sum :
1159 ir_code decoded = rec_buffer.decoded;
1168 ctx->
code = decoded & gen_mask(remote->
bits);
1169 ctx->
pre = decoded >> remote->
bits;
1171 gettimeofday(¤t, NULL);
1172 sum = remote->phead + remote->
shead +
1173 lirc_t_max(remote->pone + remote->
sone,
1174 remote->pzero + remote->
szero) * bit_count(remote) + remote->
plead +
1175 remote->
ptrail + remote->pfoot + remote->
sfoot + remote->pre_p + remote->
pre_s +
1176 remote->post_p + remote->
post_s;
1178 rec_buffer.sum = sum >= remote->
gap ? remote->
gap - 1 : sum;
1179 sync = time_elapsed(&remote->
last_send, ¤t) - rec_buffer.sum;
1181 if (!get_lead(remote)) {
1186 if (has_pre(remote)) {
1187 ctx->
pre = get_pre(remote);
1202 if (has_post(remote)) {
1203 ctx->
post = get_post(remote);
1210 if (!get_trail(remote)) {
1214 if (has_foot(remote)) {
1215 if (!get_foot(remote)) {
1221 rec_buffer.sum -= remote->phead + remote->
shead;
1222 if (is_rcmm(remote)) {
1223 if (!get_gap(remote, 1000))
1225 }
else if (is_const(remote)) {
1226 if (!get_gap(remote, min_gap(remote) > rec_buffer.sum ?
1227 min_gap(remote) - rec_buffer.sum :
1231 if (!get_gap(remote, min_gap(remote)))
1245 if (time_elapsed(&remote->
last_send, ¤t) < 325000)
1248 if (is_const(remote)) {
1249 ctx->
min_remaining_gap = min_gap(remote) > rec_buffer.sum ? min_gap(remote) - rec_buffer.sum : 0;
1250 ctx->
max_remaining_gap = max_gap(remote) > rec_buffer.sum ? max_gap(remote) - rec_buffer.sum : 0;
lirc_t min_remaining_gap
remember gap for CONST_LENGTH remotes
void rec_buffer_init(void)
Clear internal buffer to pristine state.
struct ir_remote * last_remote
TODO.
void rec_buffer_set_logfile(FILE *f)
Set a file logging input from driver in same format as mode2(1).
One remote as represented in the configuration file.
int bits
bits (length of code)
int fd
Set by the driver after init().
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
struct ir_ncode * toggle_code
toggle code received or sent last
void rec_buffer_rewind(void)
Reset the modules's internal fifo's read state to initial values where the nothing is read...
#define log_debug(fmt,...)
Log a debug message.
unsigned int baud
can be overridden by [p|s]zero, [p|s]one
lirc_t * signals
(private)
int eps
eps (relative tolerance)
struct ir_ncode * last_code
code received or sent last
unsigned int parity
currently unsupported
ir_code pre
pre data, before code.
int receive_decode(struct ir_remote *remote, struct decode_ctx_t *ctx)
Decode data from remote.
#define LIRC_EOF
Bit manipulator in lirc_t, see lirc.h .
lirc_t ptrail
trailing pulse
int pre_data_bits
length of pre_data
logchannel_t
Log channels used to filter messages.
void rec_buffer_reset_wptr(void)
Reset internal fifo's write pointer.
char * name
Name of command.
struct timeval last_send
time last_code was received or sent
#define log_trace2(fmt,...)
Log a trace2 message.
uint32_t rec_mode
Possible values are: LIRC_MODE_RAW, LIRC_MODE_PULSE, LIRC_MODE_MODE2, LIRC_MODE_LIRCCODE.
int post_data_bits
length of post_data
lirc_t sthree
3 (only used for RC-MM)
#define log_trace1(fmt,...)
Log a trace1 message.
#define log_error(fmt,...)
Log an error message.
ir_code pre_data
data which the remote sends before actual keycode
ir_code post
post data, sent after code.
uint32_t gap
time between signals in usecs
#define log_trace(fmt,...)
Log a trace message.
#define log_perror_err(fmt,...)
perror wrapper logging with level LIRC_ERROR.
lirc_t(*const readdata)(lirc_t timeout)
Get length of next pulse/space from hardware.
uint32_t repeat_gap
time between two repeat codes if different from gap
#define REPEAT_HEADER
header is also sent before repeat code
lirc_t max_remaining_gap
Estimated max time of trailing gap.
ir_code code
Code part, matched to code defintion.
int waitfordata(uint32_t maxusec)
If set_waitfordata(func) is called, invoke and return function set this way.
void set_waitfordata_func(int(*func)(uint32_t maxusec))
Set the function used by waitfordata().
#define NO_HEAD_REP
no header for key repeats
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.
const uint32_t code_length
Length in bits of the code.
lirc_t stwo
2 (only used for RC-MM)
lirc_t srepeat
indicate repeating
State describing code, pre, post + gap and repeat state.
lirc_t min_remaining_gap
Estimated min time of trailing gap.
lirc_t max_remaining_gap
gap range
ir_code code
The first code of the command.
void rec_set_update_mode(int mode)
Set update mode, where recorded pre_data is verified to match the template pre_data.
unsigned int min_code_repeat
meaningful only if remote sends a repeat code: in this case this value indicates how often the real c...
ir_code rc6_mask
RC-6 doubles signal length of some bits.
int repeat_flag
True if code is a repeated one.
ir_code toggle_bit_mask
previously only one bit called toggle_bit
int rec_buffer_clear(void)
Flush the internal fifo and store a single code read from the driver in it.
#define log_notice(fmt,...)
Log a notice message.
uint64_t ir_code
Denotes an internal coded representation for an IR transmission.
unsigned int bits_in_byte
default: 8