Manufacturer: Panasonic: Model: TX-65HX940E: Creator: Control4: Modified Date: Mon Jul 06 14:52:00 UTC 2020: Device Type: TV: Control Method: IP. Download NEC USB Floppy for Windows to uSB driver. Download NEC USB Floppy for Windows to uSB driver. Join or Sign In. USB Mass Storage Device Realtek USB 2.0 Card Reader.

• Nec Input Devices Driver Manual
• Nec Input Devices Driver Code
• NEC Input Devices Driver
• Nec Input Devices Drivers

About this guide

This guide tries to describe the basic configuration steps for commonly used hardware. It's focused on the basic usage scenario to get the remote up and running, the more advanced features are not covered. This includes irexec, lircmd, ir blasting and the TCP/IP-based remote features.

Why should I use LIRC?

Recent Linux kernels have built-in support for IR remotes. Using that, pressing an up-arrow on the remote works the same way as pressing the up-arrow on a keyboard. This is a modern 'just works' solution. On the other hand, LIRC is an old style linux application which can be tweaked to do almost anything, but is tricky to setup. So, why would you use LIRC?

• You might have a remote which is supported by LIRC but not the kernel.
• If you have a remote which isn't supported at all, LIRC is probably your best bet to get it running.
• You might be on a non-Linux platform supporting lirc e. g., MacOS.
• You might have an application which is more or less designed to use LIRC.
• You might need LIRC's capabilities e. g., modes where a single remote button can be teached to deliver different keys to the application. Handling input to multiple program is also easier with lirc
• You might want to send IR signals to other devices (IR blasting).
• You might want to use lirc's applications e. g., irexec(1) which can run arbitrary commands in parallel with an application such as mythtv or kodi.

So, while the kernel built-in handling works out of the box in many cases, there are still scenarios when LIRC is the right tool.

The default configuration

From 0.9.4+ LIRC is distributed with a default configuration based on the devinput driver. This should work out of the box with the following limitations:

• There must be exactly one capture device supported by the kernel
• The remote(s) used must be supported by the kernel.
• There is no need to do IR blasting (i. e., to send IR data).

The easy way to check is to try the remotes without lircd running. If it works this way, it should also work using lircd.

To check the number of supported devices run ls /sys/class/rc. This should list a single entry rc0.

If you want to use the default configuration you should start and enable the lircd service and possibly define lircrc files for your applications. However, you can use the lirc_options.conf file as-is. See systemd-setup

Supported Hardware

Generally speaking everything that can receive or send infrared signals can be supported by LIRC. The project began with support for home-brew receivers and transmitters for the serial port and later support for similar hardware for the parallel port was added. At that time the focus of the project was to provide an infrared solution that was both very cheap and easy to assemble. There is some more info on this in Appendix 11

Current versions of LIRC now support many more commercially available solutions. As a starter, it can use all devices supported by the kernel. Besides those, it has specific drivers for other devices including the Irman, built-in IrDA ports, TV cards, and consumer devices like Tira and Irtoy.

Drivers for even more hardware are likely to appear in the future. If you are a programmer who wants to maintain such a driver you are welcome to join the project.

Overall Configuration Decisions.

LIRC can be run together with the kernel in different ways. You need to decide on a general approach.

Depending on whether lirc is used or not application will get data either from the input layer (/dev/input) or from LIRC (/var/run/lirc/lircd). Using the LIRC data requires application support. Support for LIRC is common in typical linux htpc applications like mythtv, kodi and vlc; of course also LIRC applications like irexec, lircmd and irpty supports this.

The /var/run/lirc/lircd interfaces allows several applications to receive input events. On the other hand, the /dev/input interfaces only allows one application to receive each event. Despite these limitations, a common scenario is to not involve lirc at all, the upmost path in the picture (kernel -> Linux input layer -> application). Unless there is reason to use lirc (above)) this is probably the way to go.

If you need to use lirc, there are two cases depending on if your remote is supported by the kernel or not.

• If it's supported, the easiest path usually is using the linux input layer decoding and use that as input to lirc. This is the devinput data path in picture (kernel -> Linux input layer -> lirc -> app).
• If the kernel built-in decoding can't be used (e. g., due to need of IR blasting or remote not being supported by the kernel) you should use a lirc driver instead. This is the bottom data path (kernel -> lirc -> app).

It is also possible to use lirc as a pure low-level driver, and let the application receive the data from /dev/input, just as for a device supported by the kernel. See lircd-uinput(8)

The lirc configuration consists of several files described in Appendix 10. There are some tools to aid in the configuration listed in programs overview

Basic setup flow

The overall LIRC blues:

• The remote generates an IR (or perhaps RF) signal.
• The IR data is captured by a capture device such as an IR dongle or a built-in IR port.
• Data from the capture device is caught by a linux kernel driver and made available on a kernel device such as /dev/lirc0, /dev/ttyS0 or /dev/input/eventXX.
• Data from the kernel is then caught by LIRC using a lircd driver.
• In the next step, lircd converts the kernel data from the lirc driver to key symbols using the lircd.conf file. The key symbols are presented on the output socket, by default /var/run/lirc/lircd.
• In the next step the key symbols are converted to application-specific strings using the ~/.config/lircrc file and a lirc library.

This flow is configured in four points:

• The kernel driver occasionally needs to be configured using modprobe(1) or udev(7). See Configuring the kernel
• lircd needs to know which driver and often also kernel device to use. This is configured using command line options which eventually are stored in lirc_options.conf. This is described in Determine driver and device.
• To convert IR pulse data to key symbols lircd needs a lircd.conf configuration file. Creating this is done either by using the linux input layer or an lirc driver.
• Converting key symbols to application strings is done using a lircrc config file. This is created according to Convert the key symbols to application strings .

lircd can handle multiple remotes using the same capture device. This is described in Appendix 8.

To use multiple capture devices you need to setup multiple lircd instances as described in Appendix 9.

lircd can run as a regular user or as root. Some aspects on running as a non-root user is described in Appendix 14.

Determine driver and device

To determine the driver to use you might need to know the name of your capture device, what module the kernel has loaded for it and the kernel device it's connected to.

If our remote is bundled with a capture device such as a usb dongle, your first stop is the remote database. If you can find your device here, look in lircd.conf file's header for the following comment:

Here you can learn that this file was recorded using the awlibusb driver. Take a note to the final decision.

Next thing to do is to invoke ir-keytable:

If you get this kind of output you know the event device (/dev/input/event11) and the kernel module loaded (em28xx). Furthermore, since ir-keytable finds the device you know that the driver is part of the rc subsystem. Not all devices are recognized by ir-keytable, though.

Next step is to inspect dmesg, possibly after reconnecting your device. If you have a standard IR remote which is recognized by the kernel you can find how it's registered as rc0:

If you just find something like this you have a device which isn't an IR device (in this case an RF remote):

Even if you have an IR device, you might see something like this if the kernel sees it as a keyboard rather than a remote. Here, an usb keyboard from JITTEL:

For devices like these which not are registered as rc devices (and thus not recognized by ir-keytable) you might need to find out the corresponding event device as described in Appendix 2

Knowing the capture device name, the kernel module loaded (if any) and perhaps also a /dev/input device you have to select a driver:

• If ir-keytable located the device you can use the devinput driver. This means that the kernel decodes the ir signals and converts them to button press symbols. Use something like (with device as from ir-keytable): If ir-keytable only locates one device (the most common case) you can use This is actually the default setup, and needs no modifications.
• From 0.9.5+ you can list all usable event devices using
• If you dont wan't to use the decoding done by the kernel, but the device is recognized by ir-keytable you can have lirc decode the raw signal from the driver. This means using the default driver which accesses the kernel on a /dev/lirc device, usually /dev/lirc0. Use something like: From 0.9.5+ you can list all available devices using
• If you could find out the driver used to record this device in the driver database (above) you should try this driver if it makes sense. If it doesn't make sense e. g., it refers to some hardware you don't have just proceed.
• if you can find the device name in the generic driver list you might try to use this driver. Refer to Appendix 3 for details.
• If you have a device such as a keyboard which is not recognized and can't find a driver in the driver list or in the lirc-lsplugins output, the feasible option is using the devinput driver (above).

After selecting the driver and device you should check if there is any driver documentation. After this, check the driver and device using using e. g., something like

Refer to EXAMPLES in the mode2 manpage too see expected output.

The lirc-setup tool can be used to run mode2 with different drivers and devices in a GUI environment.

If you don't see anything, try to find out: (a) if you selected the correct driver b) If the driver needs settings (I/O base address, IRQ) in modprobe.d, (c) if the remote which works and (d) if your capture hardware works.

If you are to use the devinput driver, read on. Otherwise proceed to Getting the key symbols using lirc driver

Getting the key symbols using linux input layer

If you're lucky, your remote is already supported by the kernel. In order to find out, the first task is to locate the event device, something like /dev/input/event12 which is connected to your IR device. This is described in appendix 2.

With the device known use ir-keytable to test if your remote works:

Press buttons on the remote. If it starts to print out scan codes and key symbols everything is fine. Otherwise, try to change the protocol (see the ir-keytable manpage). If this doesn't work, it might be the end of the road and you might need to use the lirc driver option instead.

Check that all buttons generate output when testing. If there are buttons which are not mapped (no key symbol) you might not be able to fix this unless you go for the lirc driver option (to change the key symbol is perfectly possible, but probably not what you want here).

Then, activate the devinput.lircd.conf template which comes with lirc:

If the devinput.lircd.dist file is not available or have some problem it can be re-generated using the script lirc-make-devinput(1). This might become necessary if the running kernel is different from the one used when packaging the lirc files.

Start the lircd daemon and use irw to check:

Press remote buttons. You should see the key symbols being printed. When so you are done and can proceed to Configure systemd

Depending on your box, it might be that the event device found this way changes after a reboot. If this becomes o problem, look into appendix 6

Getting the key symbols using lirc drivers

You have already determined the driver and device to use which is verified using mode2. Make sure the lirc driver can read the remote, and produce pulses:

lirc pass 1: Using lircd.conf, convert pulses to key symbols like KEY_UP:

The lircd.conf is the file which lircd uses to read data from the driver and then convert (or decode) it to key symbols. It's the single most important lirc configuration file. There are some ways to find or create such a file.

• The lirc-setup GUI tool can be used to find and download both driver and configuration file which also can be tested in a GUI environment.
• If you manually selected a driver from the driver table it might need a specific lircd.conf. Such drivers are best installed using the lirc-setup tool but the corresponding configuration files can also be downloaded from the website(below)
• You can use one of the already existing configuration files on the lirc-remotes website. You can browse here or use the irdb-get tool to search and download such files.
• You can create your own configuration using the irrecord tool
• If you already have a config file for the libirman package you can convert it using the irman2lirc script that you can find in the contrib directory.
• It's also possible to convert CCF files and Pronto codes to a valid lircd.conf file using the pronto2lirc script.
• The irscrutinizer tool from harctoolbox.org can convert a wide range of formats to lircd.conf files. It can also record data the same way as irrecord.

Even if you obtain the configuration file without using lirc-setup, you can still use it to verify the configuration. It runs lircd and irw as described below, making testing much simpler.

To install the file it should be copied to the lircd.conf.d directory, usually /etc/lirc/lircd.conf.d. Make sure the name ends with .lircd.conf.

If you are using several remotes you need to combine several lircd.conf files. See Appendix 8

After installation you should be able to start the the lircd daemon using something like:

Verify the results using irw(1) in another window. Pressing buttons should give something like:

Once irw works you are done with this step: lirc can convert the button presses to key symbols. The next step is to convert the symbols to configure the systemd service.

Configure systemd

By now you should know the driver and device used when running lircd. Update the configuration file /etc/lirc/lirc_options.conf with the driver and device you have determined:

You should then be able to start, stop and inspect the service using:

Check that you can start/stop a working service, irw is your friend. If you are using another init system than systemd, you need to make similar steps.

Converting key symbols to application strings

Using ~/.config/lircrc, convert the key symbols to application-specific strings.

The first step is to create a simple configuration for just one key for the irexec application, dipping a toe into the water. Create the following file and store it as ~/.config/lircrc:

Notes:

• The remote (here 'mceusb') is the name attribute from the lircd.conf file i. e., the line starting with 'name'.
• The button is a key symbol from the *.lircd.conf. If you don't have a KEY_RED, use another button.
• The whole idea with this step is that each application has its own translation. We will use the simple irexec app as prog for now, and check what kind of data it will receive when pressing the KEY_RED button.
• The config string is what irexec will receive when we press the KEY_RED button.

With this irexec file in place, we use ircat(1) to check what irexec receives when we push the KEY_RED button:

So, at this point you can start irexec, and it will do actually echo some 'foo' when you press the red button:

With this simple example working, you now need to create complete config files for your application(s). First, you should read .lircrc chapter . Then, create your application config setup in ~/.config/lircrc and test it with ircat as above.

Depending on your application, lirc-config-tool might be able to generate a starting point. i See appendix 5.

Once the application is up, you might want to exploit LIRC's capabilities:

• Using irexec(1) you can configure lirc to run arbitrary program when a button is pressed.
• Using lircmd(1) you can use lirc to let the remote emulate a mouse.
• You can setup lirc to transmit IR signals (IR blasting) to other devices e. g., let the remote send ir signals to a TV set. The program is irsend(1), you might want to scan the web for howto:s.

Appendixes

A1: Configuring the kernel

When using the default LIRC IR driver, the kernel IR driver must be configured to send the data only to the /dev/lirc device and not to the general input layer. If not, each button event will delivered twice to the application, both through /var/run/lirc and /dev/input.

Nec Input Devices Driver Manual

As of 0.9.1+ this is configured automatically by lircd, and neither the echo 'lirc' >/sys/class/rc/... nor the protocol udev rule should normally be required.

lircd can run either as root or as a regular user. In the latter case you might need to adjust device permissions.

Also, some lirc drivers conflicts with the kernel drivers. A common example is the lirc atilibusb driver which conflicts with the kernel ati_remote driver. Another example is lirc serial drivers which conflicts with the kernel default tty driver. Such conflicts shows up as dmesg output about not being able to open the involved device, plus various other symptoms.

If required, the default driver configuration can be done using /sys/class/rc interfaces or using a udev rule. Conflicting kernel drivers must be blacklisted. Conflicts on serial ports can be handled by disabling the kernel serial driver for that port.

When using serial or parallel port hardware the proper kernel module must be loaded with correct options. This requires modprobe(1) configurationi.

Using TV-cards requires some extra attention.

Kernel IR driver runtime configuration.

The builtin ir driver subsystem is aware of LIRC, and is capable to send all data through /dev/lirc0. If lircd fails to configure this automatically it can be done manually:

Here, 'rc0' is OK if you have only one infrared device. Note that this is not persistent, you need to do this after each boot.

Using '-lirc' instead restores the normal kernel operation when stopping LIRC.

Kernel IR driver udev configuration

Likewise, if lircd fails to configure the kernel IR driver automatically you can create a file /etc/udev/rules.d/99-remote-control-lirc like:

This is persistent and makes all ir (i. e., rc-based) devices send data only through /dev/lirc0 where it can be retrieved by the 'default' driver. The file is available in the contrib/ directory.

Kernel module conflicts

When using remotes which are not infrared, the corresponding driver is not affected by the methods above. One example is an RF remote which uses the atilibusb LIRC driver. This conflicts with the ati_remote kernel module, which thus needs to be disabled. Do this by creating the file /etc/modprobe.d/blacklist-atiremote.conf like:

For known cases the lirc-setup tool generates blacklisting configuration files.

The contrib directory contains a file 61-lirc.blacklist-all.conf which blacklists all kernel drivers known to conflict with any lirc plugin. While in most cases an overkill, it can be helpful.

In general, finding out what module to blacklist is not always easy. dmesg(1) sometimes gives a hint about conflicts on a device. Another method is to boot the system without the usb device connected, and do a lsmod. After that, connect the device and make a new lsmod. Comparing the different outputs might give a clue.

Adjusting kernel device permissions

When lircd not runs as root, it needs read and write access to the kernel device it communicates with. Since devices in Linux are handled by udev this is handled by udev rules.

Many drivers including the default driver uses the /dev/lirc or USB devices. In the contrib directory is an example file for the these devices called 60-lirc.rules containing:

The file should be stored in /etc/udev/rules.d/60-lirc.rules This example gives users in the group lirc full permissions to the /dev/lirc0 devices using regular group permissions. It also gives members of the same group access to all USB devices using extended permissions (ACL). It should be simple to adopt to other users (USER=), usernames and devices. Refer to more generic udev docs.

The devinput driver uses the /dev/input/event* devices. These are often accessible for members of a specific group; the best solution is then to add this group the the lircd user's supplementary group e. g., using usermod -aG input lirc which adds the input group to user lirc. See Running as a regular user

Disabling kernel serial port reservation

Usually the default kernel serial port driver grabs all ports it auto-detects as soon as it is loaded and the LIRC modules won't be able to use any of them.

This needs to be resolved using the setserial(1) tool. An example how to load a lirc_serial module on /dev/ttyS0:

This could be added to lirc_options.conf as a modprobe section e. g.,:

This section is parsed by the lircd-setup tool which runs as root when lircd is started.

lirc-setup can generate this section in many cases.

Debian users should adjust their /etc/serial.conf. Note that lirc_serial probably needs some modprobe setup, see below.

modprobe configuration

The kernel loads the appropriate driver for most modern, USB-based using udev hotplugging - as soon as the device is connected the corresponding kernel module is loaded. However, when using hardware connected to e. g., serial or parallel ports the proper kernel module must be manually loaded. This is done using modprobe(1) options or modprobe.d(5) files. Options to modprobe include things like the actual port, interrupt to use etc.

lirc-setup can generate proper /etc/modprobe.d files in such cases. modinfo(1) also provides useful info. In any case, the proper kernel module must be loaded with correct options before lircd is started.

TV cards

To use any remote control receivers connected directly to a bttv based TV card you will need a working bttv setup in your kernel. For most TV cards we rely on bttv autodetection. That way you don't have to give any parameters to the module as they are selected internally depending on the information the bttv module gives us. This means that you should pay attention that your TV card is detected correctly by bttv, as can be checked using dmesg(1).

A2: Finding the event device

For many tasks it's necessary to find out the event device, something like /dev/input/event12, which is connected to your IR input.

The first try is to invoke mode2 to enumerate the available devices:

With this kind of output all is set: the required device is

The second try is to invoke ir-keytable(1) without any options:

If the reported device matches your expectations you're done - here we have /dev/input/event11.

If this doesn't work next try is to look in in /dev/input/by-id. If you find a device here which looks like your device, check where it's linked:

So, here your interface is /dev/input/event13, and your're done.

If this does not work, cat the input devices under /sys.

Look in foo to find this snippet about your device:

Here, the device is /dev/input/event14.

Testing the device.

The easiest way to test if the correct device is found is to just try to print the data like in

This will print garbage on the terminal when remote buttons are pressed if it is the correct device.

Nec Input Devices Driver Code

A3: Understanding the driver table

The driver list gives some hints on the usage for each driver. The important columns are 'Hardware', 'Required LIRC kernel module', 'lircd driver' and 'Default lircd and lircmd config files'.

The 'Hardware' column should be obvious. Note that it in many cases it refers to the receiver unit (e. g., the name reported by dmesg), not the name of the remote. So, before looking for a suitable driver use dmesg to find out the name as described in Appendix 2

The 'lircd driver' refers to the argument you should give to lircd i. e., --driver=... You might need to check that the driver is available using irrecord -H help. If it's not listed here you need to rebuild lirc which is outside the scope of this document.

The 'Required LIRC kernel modules' refers to modules that are part of the linux kernel. Some of these are regular modules and should be available in any reasonably updated linux system. However, some of these modules are part of the staging drivers and might not be available on your system.

To look for a particular module just search for it in /lib/modules e. g.,

If it's listed, kernel should load it automatically on-demand in most cases. If the module exists but isn't loaded you might need to load it manually using modprobe(1). If it does not exist you have to build the staging drivers, also outside the scope of this document.

The Supported Remotes column reflects what kind of lircd.conf files which are supported. Common values are 'Any' meaning that any file from the website could be used or 'bundled' meaning that the driver requires a specific config file. In some cases any file can be used if it conforms to some limitation.

Unfortunately, the driver list does not provide information on the device which should be used for a particular driver. In some cases there is more info in the driver documentation. Besides this, the only way to be sure is actually inspecting he sources. You might try to search the web before walking this path, though.

A4: Normalizing the lircd.conf

Several of the pre-defined remotes uses non-standard key symbols. This is a Bad Thing, which makes it harder to create the ~/.config/lircrc file in next step. It's also a problem when using the uinput option, or when converting to use the build-in decoding.

You should replace all non-standard definitions with standard key symbols where it's possible. Some buttons might not be possible to map to standard symbols is a sane way, and could be left as-is. But the vast majority of buttons should use standard symbols. The standard symbols a. k. a. the namespace, is listed by irrecord -l.

The script lirc-config-tool helpful here. List all non-standard symbols in lircd.conf:

Update the lircd.conf file with standard key symbols as applicable:

A5: Generating the .lircrc

The .lircrc file basically combines the remote buttons with application capabilities. To actually write a .lircrc file from scratch is not that hard, but it's a lot of work. lirc-config-tool can save some of this work by creating a starting point. For this to work , the lircd.conf file must be in place. It must also use standard key symbols from the namespaceii as described above.

The first step is to check if your application is supported by the script:

if you find your application here, you can make an .lircrc for that app:

If you're using the devinput lircd.conf, create a new version of that file which only contains the key symbols you are actually using. Use this instead in the -c option to let lirc-config-tool make it's work. The generated file will look like (excerpt!)

The comments are about buttons which havn't found a use, and capabilities in the program (vlc) which are not bound to a button. Obviously, this saves some work.

The lirc-config-tool has a -h and a manpage option for more info.

BEWARE: The configuration file generated this way is a starting point. It needs to be inspected and tweaked before it actually does it's job.

A6 : Addressing changing event devices

When using the devinput driver, input devices like /dev/input/event12 might come up as another device after a reboot. If this becomes a problem, you should address the device using it's name or it's physical bus address.

From 0.9.5, the easy way is to let mode2 enumerate the available devices, something like

This lists not only /dev/input/event device but also a link in /dev/input/by-id. If there is only one device of each kind the link is stable after reboots.Handling cases with more than one device of the same kind is best handled by creating udev rules. The output from

can be used to create such rules.

On 0.9.5- versions the first step is to inspect dmesg after connecting the device. There you should find something like:

Here you can see the device's name: 'Media center Ed. eHome...' and it's address: ...usb4/4-4/4-4:1.0/rc/rc0.

As long as you have only one remote of each kind you can use simple name matching like in

If you have several devices with the same name you need to use the address instead. Since this depends on how the device is connected, you lose if you disconnect the device and reconnect it to another socket. With this limitation you can use phys=*usb4/4-4/4-4:1.0* in the same way as name. However, in complicated cases like these you might be better off creating a fixed device name using a udev rule

A7 : Running irexec

After having configured lirc, you might want to run irexec(1). Using this, you can bind remote buttons to any command you can run. It's typically used to shut down system, system volume controls etc.

There is two ways to run irexec, both with their pros and cons. It is possible to run irexec either way, or both as parallel services.

The first way is to run irexec as a system daemon. This can be done using a systemd service. This way has security problems since running arbitrary commands and scripts as root is generally a bad idea. There is also the problem that irexec runs outside your session which means it's problematic to access the display, sound system and other resources typically bound to the session. On the other hand, this is flexible and since irexec runs as root it can in the end do anything. As shipped, lircd has a service which can be enabled using systemctl start irexec.service etc. It is configured using /etc/lirc/irexec.lircrc

The second way to run irexec is to run it as a part of the session. The standard way to do this is to drop a irexec.desktop file in the config autostart directory, normally ~/.config/autostart. Doing so you can use your desktop tools to control the service. Also, since the service runs as part of your session, it can access the display, sound system etc.

The drawback is that since it runs as a regular user, it might run into permission problems e. g., when trying to shut down the computer. This can be handled using sudo, giving the user running irexec right to run specific commands otherwise requiring root permission. E. g., the following entry in /etc/sudoers allows the htpc user to restart gdm, effectively making a soft reboot:

All in all, to configure irexec as a session service:

• Copy irexec.desktop from the contrib directory to ~/.config/autostart
• Possibly add entries to /etc/sudoers (above) if you need to run otherwise restricted commands.
• Enable the session service using e. g., gnome-tweak-tool or corresponding apps. Or just logout-login.
• Configure the ~/.config/lircrc file as described in .lircrc chapter Note that you must specify 'program = irexec' for irexec to pick up your configuration.

A8 : Using multiple remotes

lirc will happily accept several lircd.conf files. When doing so, it will try to match input with each configuration until there is a match. This means that the number of configurations has some limits, otherwise it would take too long time. For practical scenarios say 2-4 remotes this shouldn't really be a problem on modern hardware. There are a number of ways to combine several configurations:

• The old method has been to just paste several configuration files into lircd.conf. This method is deprecated, since you will loose track of which files that actually are in use.
• The preferred way is to install the files in the directory lircd.conf.d. This directory should be in the same place as the main lircd.conf file, usually /etc/lirc/lircd.conf.d/. Any file in this directory which has a name ending with .conf is automagically included by the default lircd.conf file.
• Another way is to use the include directive. Using this, you can include files without changing them e. g., using a file like A relative path like MKJ61842704 is supposed to live in the same dir as the main lircd.conf file, usually /etc/lirc. All-in-all, this is good method which preserves the original files

When using multiple remotes lircd tries to sort them so that the ones which decodes faster are used first. Normally you could use this feature as-is. However, if you want to define the order yourself you should set the attribute manual_sort to 1 in any of the configs. Doing so disables the automatic sorting.

In manual sort mode the remotes are used in the order they appear in the config file. Files in lircd.conf.d are used in order defined by the filenames. The recommended way to use this is to name the links to 00-my_first_remote.conf, 01-next-remote.conf etc.

To add the manual_sort attribute to an existing remote is actually a bad idea since it creates cross-dependencies between configurations. A cleaner way is to add a dummy remote like this in lircd.conf.d (the name does not matter):

A9 : Using multiple capture devices

When using using multiple capture devices e. g., two different USB dongles you need to create a separate lircd instance for each device. Setup the first device according to the main flow in this document, then add the second as documented below.

Also, when using multiple capture devices you might run into trouble with several /dev/lirc* devices e. g., /dev/lirc0 and /dev/lirc1. Since udev does not guarantee in which order devices are created, you cannot know which physical device /dev/lirc0 refers to is in this scenario. To handle this you need to define udev rules defining fixed device names.

If running multiple input capture devices you need to connect them using the --listen and --connect options.

Setup a new lircd instance.

To create a new lircd instance serving a separate capture device create a file like /etc/systemd/system/lircd-lirc1.service:

This will create a new service called lircd-lirc1.service which can be started using # systemd start lircd-lirc1.service etc. Options not defined in the service file will default to the values in lirc_options.conf. Each instance must have unique --device, --output and --pidfile options.

Udev rules handling multiple /dev/lirc* devices.

Udev can be used to define fixed device names which can be used instead of the random /dev/lirc[0-9] devices set up by default. To do this, you need to define udev rules. As an example, a file /etc/udev/rules.d/80-lirc.rules like:

will create a new device called /dev/lirc-mce which will be connected to a kernel device using the mceusb driver.

Practically, each installation will need to match other attributes depending on the hardware. The command

will list the possible attributes to match for a given /dev/lirc* device.

Creating udev rules is a large topic. Please refer to more generic information to resolve problems.

Connecting several input capture devices.

For each device you want to use you have to setup an individual lircd instance. If you want to receive events from all receivers at one socket interface you have to connect the different lircd interfaces with an additional TCP/IP socket. This could e. g., look like this:

All events will now be visible at /var/run/lirc/lircd. The second lircd instance connects to the first instance using a TCP/IP socket. The default port is 8765. It can be changed by providing an optional parameter to the --listen switch. If you have more lircd instances you want to connect to, you can add more host:port items to the last lircd instance's --connect option. Please note that lircd will not relay events received from one lircd to another. So you can't daisy-chain lircds. Instead you need a star topology setup.

In order to check each lircd instance individually if events are being received, use irw providing the according socket interface on the command line:

The only situation where the described procedure will not work is when you have two devices that both use a kernel driver that can only handle one device at once like e.g. lirc_serial, lirc_sir or lirc_parallel. Resolving this requires recompiling the kernel drivers with different names and device numbers. Lifting this limitation is one of the todo items for future releases.

A10 : Configuration files

The lirc configuration is mostly done in the lirc config directory, usually /etc/lirc. Besides this, there are occasionally needs to configure the kernel drivers using files in /etc/modprobe.d.

The files:

• lirc_options.conf holds the lircd options. This includes driver, port and other important configuration. All of these options can be overridden on the lircd command line.
• lircd.conf contains timing information. It's used by lircd to convert raw data from the kernel to key symbols. As shipped, the lircd.conf is empty and just includes any configuration file in lircd.conf.d.
• lircd.conf.d contains all used remote configuration files. When receiving data lircd will try to decode it, trying each of these files.
• /etc/lirc/lircrc is an optional default lircrc file.
• modprobe.d/blacklist-*. These contains a single blacklist directive used to disable kernel drivers which conflicts with lirc's driver.
• modprobe.d/options-*. Contains kernel module options e. g., which serial port the lirc_serial module should use.
• $HOME/.config/lircrc is the main lircrc file. Many applications supporting LIRC have specific paths to their lircrc files.

A11 : Using home-brew hardware

The LIRC project began as an attempt to create drivers for home-brew hardware. Some links to build such:

Using home-brew hardware in many cases means using the lirc_serial or lirc_parallel driver. These drivers needs configuration such as I/O base address and IRQ. This is done using modprobe, using command line parameters to modprobe(1) or adding files to the modprobe.d(5) directory. The modinfo(1) command provides useful info how to configure the drivers.

If there is no output when testing with mode2, there are some things to check:

• Is this the correct kernel driver? is there anything useful in dmesg(1)?
• Are the kernel driver settings OK? Does modinfo(1) provide any help?
• Does the remote work? Can you test it with some other hardware?
• Does the hardware work? The voltage input of the infrared receiver should be 5V +/- 0.5V, the output pin of the receiver should be about 0.5V less than the input voltage.

From time to time there should be long spaces (>30000). If you can see very long pulses this usually means that sense auto detection of your serial port IR receiver circuit has failed. You can override sense auto detection by loading the device driver with the following option:

modprobe lirc_serial sense=0 if your receiver circuit is active high or
modprobe lirc_serial sense=1 if your receiver circuit is active low.

There is also a hardware-related section in the FAQ

A14 : Running lircd as a regular user

Traditionally lircd has been run as user root. However, this raises both stability and security concerns, so running as a regular user is the preferred option. In the following its assumed that this user is called lirc and it's group also is named lirc.

There are two ways to run as a regular user. One is to patch the lircd.service file so the services started as the lirc user. The other is to use the --effective-user option. In this mode, lircd is started as root but drops privileges before actually processing infrared data.

Since lircd repeatedly opens/closes the input device, it always needs write access to it. This can be achieved using group rights and/or udev rules.

In the general case the lirc user should be member of groups owning tty locks, the /dev/input devices and the serial devices. Examples includes the groups lock, input and dialout but ultimately depends on the distribution.

Some devices are created as accessible only by root. This includes the often used /dev/lirc? and the USB devices. These should be made accessible using udev rules. The contrib/ directory contains an example rule 60-lirc.rules. This sets up the /dev/lirc* devices to be accessible for the lirc group using regular group permissions. It also grants r/w access for the lirc group to USB devices using ACLs.

If there is a need to run setup code as root the lirc_options.conf file supports a section modinit which e. g., might look like

The lircd-setup script which by default is run before the lircd service runs this setup code as root. The code is ordinary shell commands.

[LIRC homepage]

Search By:

• NEC (215)

• Plasma (215)

• IR (169)
• Serial (46)

NEC PX-50VP2A(ID4)

NEC PX-50XM3A(ID1)

NEC 61XR4A(ID3)

NEC 50XR5A(ID4)

NEC 84VM5(ID3)

NEC PX-42XM3(ID1)

NEC 42VM5

NEC 42XR3(ID4)

NEC PX-42XM3(ID2)

NEC PX-42VP2A(ID4)

NEC 61XR4A(ID1)

NEC Input Devices Driver

NEC PX-42VP1A(ID4)

NEC PX-50XM2A(ID2)

Nec Input Devices Drivers

NEC PX-50XM3A(ID3)

NEC 42VP4(ID3)

NEC PX-50M5A

NEC PX-42VP2A(ID3)

NEC PX-42VP1A(ID3)

NEC PX-50XM2A(ID4)