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 (249 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:])

Schreibe einen Kommentar

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