raspyrfm-client 1.2.7

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.