raspyrfm-client

A python 3.4+ library that allows the generation of network codes for the RaspyRFM rc module (and other gateways too!).

Build Status

Master	Beta	Dev

Home Assistant

The initial goal of this library was to be able to integrate the SimpleSolutions ConnAir gateway with Home Assistant. This gateway is sadly not sold anymore but there are other alternatives like the Intertechno Gateway or the ConnAir Emulator script that can be used on a Raspberry Pi equipped with a 433MHz radio like the RaspyRFM from Seegel Systeme.

The bundled Home Assistant panel now features a refreshed design, inline validation for switch payloads, and a graphical signal mapping workspace that lets you categorise learned payloads as sensors, actuators, or auxiliary events. Linked device chips show exactly which Home Assistant entities react to a given payload so legacy installations stay understandable. Incoming payloads are fingerprinted against the original raspyrfm-client library so the interface can suggest whether a signal looks like a switch, a dimmable light, or a pairing remote. Suggested actions populate the creation form automatically and cover newly supported entity types such as lights and button groups. When no fingerprint matches, the universal entity card stores the raw payloads and exposes a quick-send button so you can still read and replay transmissions.

You can find the related integration documentation here: RaspyRFM Home Assistant component documentation

Home Assistant OS Installation (Raspberry Pi 4/5)

Pre-built Releases for HAOS

This integration is optimized for Home Assistant OS running on Raspberry Pi 4 and 5. Download the latest release from the GitHub Releases page.

Quick Installation Steps:

1. Download the latest raspyrfm-X.X.X.zip from releases

2. Access your Home Assistant installation via SSH or the Samba share

3. Navigate to your config directory (usually /config)

4. Create custom_components directory if it doesn’t exist

5. Extract the zip file contents to /config/custom_components/raspyrfm/

6. Restart Home Assistant

7. Go to Settings → Devices & Services → Add Integration

8. Search for “RaspyRFM” and configure with your gateway details

Configuration:

• Host: IP address of your RaspyRFM gateway (e.g., 192.168.1.100)

• Port: Gateway port (default: 49880)

Hardware Setup for Raspberry Pi:

If you’re using a Raspberry Pi as your RaspyRFM gateway:

1. Connect your 433MHz RF module to the GPIO pins

2. Ensure the RaspyRFM daemon is running on the gateway Pi

3. The gateway must be on the same network as your HAOS installation

4. Test connectivity: ping <gateway-ip> from HAOS terminal

Troubleshooting:

• Cannot find gateway: Check network connectivity and firewall settings

• Integration won’t load: Verify all files are in custom_components/raspyrfm/

• Devices not responding: Confirm gateway is running and RF codes are correct

• Check logs: Go to Settings → System → Logs and filter for “raspyrfm”

How to use

Installation

pip install raspyrfm-client

Documentation

The full project manual is published automatically via GitHub Pages whenever changes land on the master branch. Visit https://halbothpa.github.io/raspyrfm-client/ for the rendered HTML documentation sourced from the docs directory. The site now uses the Furo theme with custom accent colours and hero components that mirror the refreshed Home Assistant UI, plus SVG illustrations of the mapping workspace for quick onboarding. A new UI showcase page highlights every card in the Home Assistant panel, including the adaptive classification chips and the universal entity send controls.

Usage

For a basic example have a look at the example.py file.

If you need more info the documentation covers the full Home Assistant workflow.

Basic Example

Import required modules

from raspyrfm_client import RaspyRFMClient
from raspyrfm_client.device_implementations.controlunit.actions import Action
from raspyrfm_client.device_implementations.controlunit.controlunit_constants import ControlUnitModel
from raspyrfm_client.device_implementations.gateway.manufacturer.gateway_constants import GatewayModel
from raspyrfm_client.device_implementations.manufacturer_constants import Manufacturer

Create the RaspyRFMClient object

Get a client instance by calling:

rfm_client = RaspyRFMClient()

Create a Gateway instance

You can let the library search automatically for gateways available in LAN using:

gateways = rfm_client.search()

This will return a list of Gateways that can later be used to send signals to.

To get a quick overview of what gateway manufacturers and models are supported call:

rfm_client.list_supported_gateways()

Create a gateway instance with the specified IP and Port of your Gateway by using:

gateway = rfm_client.get_gateway(Manufacturer.SEEGEL_SYSTEME, GatewayModel.RASPYRFM, "192.168.2.10", 9876)

or

gateway = rfm_client.get_gateway(Manufacturer.SEEGEL_SYSTEME, GatewayModel.RASPYRFM, "192.168.2.10") # defaults to 49880 or the gateway implementations default

Get a ControlUnit

ControlUnits are the devices that receive the RC signals sent using the gateway, f.ex. a power outlet.

To get a quick overview of what ControlUnits manufacturers and models are supported call:

rfm_client.list_supported_controlunits()

which will give you an indented list of supported manufacturers and their supported models similar to this:

Elro
  RC3500-A IP44 DE
  AB440S
  AB440D 200W
  AB440D 300W
  AB440ID
  AB440IS
  AB440L
  AB440SC
  AB440WD
BAT
  RC AAA1000-A IP44 Outdoor
Brennenstuhl
  RCS 1000 N Comfort
  RCS 1044 N Comfort
Intertek
  Model 1919361
[...]

To generate codes for a device you first have to get an instance of its implementation like this:

brennenstuhl_rcs1000 = rfm_client.get_controlunit(manufacturer_constants.BRENNENSTUHL,
                                          manufacturer_constants.RCS_1000_N_COMFORT)

The parameters of the get_controlunit() method always need to be an enum value of the specified type. You can get an enum constant by its name though using:

manufacturer = Manufacturer("Intertechno")
model = ControlUnitModel("IT-1500")

ControlUnit channel configuration

Before you can generate codes with your shiny new gateway and ControlUnit implementations you have to specify a channel configuration for your ControlUnit. These configurations can be very different for every device. The best way to know the correct way of specifying the channel configuration for a specific device is to look at the source code (yes I know…) or by trial and error (even worse). A good ControlUnit implementation should tell you how the configuration should look like when specifying it in a wrong way.

However all configurations are a keyed dictionary. So in general there are two ways of passing the channel configuration argument. One (inline):

device.set_channel_config(value1=1, value2=2)

Two (as a dictionary):

device.set_channel_config(**{
    'value1': 1,
    'value2': 2
})

Note that the keys always need to be a string. The second one is the recommended one as it will often result in a much more readable source code.

For our Brennenstuhl device it would look like this:

brennenstuhl_rcs1000.set_channel_config(**{
    '1': True,
    '2': True,
    '3': True,
    '4': True,
    '5': True,
    'CH': 'A'
})

Generate action codes

Now that you have a properly set up ControlUnit you can generate codes for it’s supported actions by using an Action enum constant that you imported previously.

To get a list of supported actions for a ControlUnit call:

brennenstuhl_rcs1000.get_supported_actions()

and generate a code for one of them using your Gateway instance:

code = gateway.generate_code(brennenstuhl_rcs1000, Action.ON)

Send the code to the RaspyRFM module

To send a code for your device of choice you can combine the objects in this call:

rfm_client.send(gateway, brennenstuhl_rcs1000, Action.ON)

This will generate a code specific to the passed in gateway implementation and send it to it’s host address immediately after.

Custom implementations

The raspyrfm-client library is designed so you can implement custom devices in a (hopefully) very easy way.

File Structure

All ControlUnit implementations are located in the /device_implementations/controlunit/manufacturer/ module and implement the base class Device that can be found in /device_implementations/controlunit/base.py.

Create a new ControlUnit

To create a new ControlUnit implementation for a new manufacturer and model create a new subdirectory for your manufacturer and a python file for your model:

───raspyrfm_client
│   │   client.py
│   │
│   └───device
│       │   actions.py
│       │   base.py
│       │
│       └───manufacturer
│           │   manufacturer_constants.py
│           │
│           ├───intertek
│           │       Model1919361.py
│           │
│           ├───rev
│           │       Ritter.py
│           │       Telecontrol.py
│           │
│           ├───universal
│           │       HX2262Compatible.py
│           │
│           └───yourmanufacturer
│                   yourmodel.py
──────────────────────────────────────────

Implement a ControlUnit

Now the basic implementation of your ControlUnit should looks like this:

from raspyrfm_client.device_implementations.controlunit.actions import Action
from raspyrfm_client.device_implementations.controlunit.base import ControlUnit


class YourModel(ControlUnit):
    def __init__(self):
        from raspyrfm_client.device_implementations.manufacturer_constants import Manufacturer
        from raspyrfm_client.device_implementations.controlunit.controlunit_constants import ControlUnitModel
        super().__init__(Manufacturer.YourManufacturer, ControlUnitModel.YourModel)

    def get_channel_config_args(self):
        return {}

    def get_pulse_data(self, action: Action):
        return [[0, 0], [0, 0]], 0, 0

    def get_supported_actions(self) -> [str]:
        return [Action.ON]

Most importantly you have to call the super().__init__ method like shown. This will ensure that your implementation is found by the RaspyRFMClient and you can get an instance of your device using rfm_client.get_controlunit() as shown before.

If your manufacturer does not exist yet create a new enum constant in the manufacturer_constants.py file and use its value in your __init__. Do the same thing for your model name in the controlunit_constants.py file.

You also have to implement all abstract methods from the Device class. Have a look at it’s documentation to get a sense of what those methods are all about.

After you have implemented all methods you are good to go! Just call rfm_client.reload_implementation_classes() and rfm_client.list_supported_controlunits() to check if your implementation is listed. If everything looks good you can use your implementation like any other one.

Exclude a WIP implementation

To prevent the RaspyRFM client from importing your half baked or base class implementation just include a class field like this:

class YourModel(ControlUnit):
   DISABLED = True

   [...]

Contributing

GitHub is for social coding: if you want to write code, I encourage contributions through pull requests from forks of this repository. Create GitHub tickets for bugs and new features and comment on the ones that you are interested in.

License

raspyrfm-client by Markus Ressel
Copyright (C) 2017  Markus Ressel

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.

Content:

• RaspyRFM Client Manual
  • Overview