I2C-Funksender am Raspberry

diesen Beispielcode hat mir Steffen G. freundlicherweise zur Verfügung gestellt.

Mit dem Code können bis zu 160 Funksteckdosen geschaltet werden.

Das Modul hängt über einen I2C-Repeater am Raspberry-PI

433MHz Funksender am Raspberry-PI

433-MHz Funksender am Raspberry-PI

 

Funksteckdosen mit Python schalten

Hallo Herr Horter,
ich habe für das I2HFS-Modul ein kleines Python-Skipt geschrieben, welches sie gern im Blog mit veröffentlichen können.
Das Skript heißt “i2hfs.py”.

 

Download:

Python-Code für Funksender (282 Downloads)

 

Usage:

==============================
Horter I2HFS I2C-433 MHz Modul
==============================

Usage: ./i2hfs.py -a [ADDRESS] -p [PROTOCOL] -s [SYSCODE] -v [VALUE]

-h    –help=           show Usage
-a    –address=      I2C-ADDRESS as Integer
-p    –protocol=      Protocol as Integer [1-15]
-s    –syscode=     Systemcode as Integer-Bitmask [0-31]
-v    –value=          Value as Integer-Bitmask [0-255]

Es müssen alle vier Parameter angegeben werden.

Die I2C-Adresse muss als Integer angegeben werden, also 8 statt 0x08.

Als Protokoll ist nur “1” im Moment zulässig.

Der Systemcode und der Value sind ebenfalls als Integer anzugeben. Diese Werte symbolisieren eine Bitmaske.

Hinweis:

Das Skript geht davon aus, dass der I2C-Bus 2 verwendet wird (BananaPi).

Beim Raspberry Pi muss im Skript der Bus auf 1 gesetzt werden.

# create I2C-instance
I2HFS = smbus.SMBus(2)

Beispiel:

./i2hfs.py -a8 -p1 -s12 -v3

Adresse:    0x08
Protokoll:   1
Systemcode: DIP-Schalter 3 und 4 sind an, also
2^0 low = 0
2^1 low = 0
2^2 high = 4
2^3 high = 8
2^4 low = 0

Bytes: [ 15 0 0 15 15 ]

Value: Steckdosen mit Adresse 1 und 2 sollen geschaltet werden, also

2^0 high = 1
2^1 high = 2
2^2 low = 0
2^3 low = 0
2^4 low = 0
2^5 low = 0
2^6 low = 0
2^7 low = 0Bytes: [ 129 130 3 4 5 6 7 8 ]
Mit dem Skript können theoretisch 8 Verbraucher (Funksteckdosen) mit Protokoll 1 und gleichem Systemcode gleichzeitig geschalten werden.
Dies wird über den Parameter -v, der als Integer-Bitmaske anzugeben ist, realisiert.
Da die Pollin-Dosen nur 5 DIP-Schalter für die Adressierung haben, können also gleichzeitig anstatt der möglichen 8 nur 5 Dosen geschaltet werden.
Maximal können von den Pollindosen 1 x 32 x 5 = 160 Dosen angesteuert werden.

Python Beispielcode i2hfs.py

#!/usr/bin/python

from __future__ import print_function
import smbus
import sys
import time
import getopt

ADDRESS = ''	# I2C-address as integer [8-31]
PROTOCOL = ''	# protocol as integer [1-15]
SYSCODE = ''	# system-code as integer-bitmask
VALUE = ''		# value as integer-bitmask

def usage():
  print("\n==============================")
  print("Horter I2HFS I2C-433 MHz Modul")
  print("==============================\n")
  print('Usage: '+sys.argv[0]+' -a [ADDRESS] -p [PROTOCOL] -s [SYSCODE] -v [VALUE]')
  print("\r")
  print("-h\t--help\t\t\tshow Usage")
  print("-a\t--address=\tM\tI2C-ADDRESS as Integer")
  print("-p\t--protocol=\tM\tProtocol as Integer [1-15]")
  print("-s\t--syscode=\tM\tSystemcode as Integer-Bitmask [0-31]")
  print("-v\t--value=\tM\tValue as Integer-Bitmask [0-255]\n")

def protocol_01():  
  # create I2C-instance
  I2HFS = smbus.SMBus(2)
  
  # write protocol ############################################################
  REGISTER = 0x02
  DATA = [ PROTOCOL, 0x01 ]
  I2HFS.write_i2c_block_data(ADDRESS, REGISTER, DATA)

  time.sleep(0.05)

  # write systemcode ##########################################################
  REGISTER = 0x00
  DATA = [ 15, 15, 15, 15, 15 ]
  
  V_STRING = bin(SYSCODE)	# e.g 0b1010
  V = V_STRING[2:]			# e.g 1010

  i = len(V) - 1
  n = 0
  while i >= 0:
    BIT = V[i:][:1]
    if BIT == "1":
      DATA[n] = 0

    i = i - 1
    n = n + 1
	
  print ("\nSYSTEMCODE=\t",DATA)

  I2HFS.write_i2c_block_data(ADDRESS, REGISTER, DATA)

  time.sleep(0.05)

  # write value ###############################################################
  DATA = [ 1, 2, 3, 4, 5, 6, 7, 8 ]

  V_STRING = bin(VALUE)		# e.g. 0b1010
  V = V_STRING[2:]			# e.g. 1010

  i = len(V) - 1
  n = 0
  while i >= 0:
    BIT = V[i:][:1]
    if BIT == "1":
      DATA[n] = n + 1 + 128

    i = i - 1
    n = n + 1
	
  print ("VALUE=\t\t",DATA,"\n")

  # check if module is sending
  REGISTER = 0x02
  STATUS = I2HFS.read_i2c_block_data(ADDRESS, REGISTER, 8)
  while STATUS[2] != 15:	# also 0xAC = 172 = ACtive
    time.sleep(0.01)
    STATUS = I2HFS.read_i2c_block_data(ADDRESS, REGISTER, 8)

  time.sleep(0.05)
  
  # write value only if module is not sending
  if STATUS[2] == 15:		# also 0x0F = 15 = OFF
    REGISTER = 0x01
    I2HFS.write_i2c_block_data(ADDRESS, REGISTER, DATA)
  
def main(argv):

  global ADDRESS
  global PROTOCOL
  global SYSCODE
  global VALUE
  
  try:
    opts, args = getopt.getopt(argv,"ha:p:s:v:",["address=","protocol=","syscode=","value="])
  except getopt.GetoptError:
    usage()
    sys.exit(2)
  for opt, arg in opts:
    if opt == '-h':
      usage()
      sys.exit()
    elif opt in ("-a", "--address"):
      ADDRESS = int(arg)
    elif opt in ("-p", "--protocol"):
      PROTOCOL = int(arg)
    elif opt in ("-s", "--syscode"):
      SYSCODE = int(arg)
    elif opt in ("-v", "--value"):
      VALUE = int(arg)

  if ADDRESS == '':
    usage()
    sys.exit(2)

  if VALUE == '':
    usage()
    sys.exit(2)
	
  if SYSCODE == '':
    usage()
    sys.exit(2)
	
  if PROTOCOL == '':
    usage()
    sys.exit(2)
  elif PROTOCOL == 1:
    protocol_01()
  else:
    print("\nProtocol",PROTOCOL,"not available!\n")

if __name__ == "__main__":
  main(sys.argv[1:])

Ein Kommentar

  1. Hallo Herr Horter

    Ich habe endlich mein 433MHz Funksender gelötet und heute mit etwas Fleiss meine Conrad/ Renkforce Fernbedienung ersetzen können. Die Steckdosen sind RSL366R und ich dachte ich schicke Ihnen noch die System- und ValueCodes, evtl. hilft das jemand anderem weiter:

    https://docs.google.com/spreadsheets/d/19nOr0zbZeFqv7cMqax1WxTmul2a2GGQ0AK64BHT4smU/edit?usp=sharing

    ./i2hfs.py -a24 -p1 -s17 -v128

    Eine Frage hätte ich noch: Meine Fernbedienung ist doch noch recht viel schneller im Senden der Daten. Wissen Sie evtl. warum das Funkmodul länger braucht um den Befehl an die Steckdosen zu senden?

    freundlichst, Robert

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert.