Ich habe nur die notwendigen Teile zusammengefasst. Die Trial and Error Edition ist hier.

2017-04-09 Es wurde auf github hochgeladen. https://github.com/boyaki-machine/TSL2561

Physikalische Verkabelung

Löten Sie den Stiftkopf an den Sensor, der angekommen ist. Dann verdrahten.

Sensor 1 Pin (GND) -> Raspi 6. Pin Sensor 2pin (SDA) -> Raspi Pin 3 Sensor 3-polig (SCL) -> Raspi-5-polig Sensor 4-polig (VDD) -> Raspi-Stift 1

Es ist so.

Aktivieren Sie I2C mit Raspberry pi

Im Konfigurationsmenü des Betriebssystems einstellen.

$ sudo raspi-config

Wählen Sie das Menü in der Reihenfolge "9 erweiterte Optionen" -> "A7 I2C". Sie werden gefragt, ob die ARM I2C-Schnittstelle aktiviert werden soll. Wählen Sie also Ja. Sie werden gefragt, ob das I2C-Kernelmodul standardmäßig geladen werden soll. Wählen Sie also Ja.

Bearbeiten Sie dann /boot/config.txt.

$ sudo vi /boot/config.txt
...Folgende Inhalte wurden hinzugefügt
dtparam=i2c_arm=on

Bearbeiten Sie außerdem / etc / modules.

$ sudo vi /etc/modules
...Folgende Inhalte wurden hinzugefügt
snd-bcm2835
i2c-dev

Starten Sie Raspy nach Abschluss der Einstellungen neu. Stellen Sie sicher, dass das Kernelmodul nach dem Neustart geladen ist.

$ lsmod
...
i2c_dev                 6709  0 
snd_bcm2835            21342  0 
...

Installieren Sie Werkzeuge

$ sudo apt-get install i2c-tools python-smbus

Adressbestätigung

Überprüfen Sie die Adresse des Sensors.

$ sudo i2cdetect -y 1
     0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f
00:          -- -- -- -- -- -- -- -- -- -- -- -- --
10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
20: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
30: -- -- -- -- -- -- -- -- -- 39 -- -- -- -- -- --
40: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
50: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
60: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
70: -- -- -- -- -- -- -- --

An der Adresse 0x39 erkannt.

Daten in Python abrufen

Verwenden Sie die folgende Klasse.

#!/usr/bin/python -u
# -*- coding: utf-8 -*-

import smbus
import time

#Aus "TSL2561 Illumination Sensor Module" von Strawberry Linux
#Klasse zum Abrufen von Daten in I2C
# https://strawberry-linux.com/catalog/items?code=12561
# 2016-05-03 Boyaki Machine
class SL_TSL2561:
	def __init__(self, address, channel):
		self.address	= address
		self.channel	= channel
		self.bus		= smbus.SMBus(self.channel)
		self.gain 		= 0x00			# 0x00=normal, 0x10=×16
		self.integrationTime 	= 0x02	# 0x02=402ms, 0x01=101ms, 0x00=13.7ms
		self.scale 		= 1.0

		#Initialisierung der Sensoreinstellungen
		self.setLowGain()
		self.setIntegrationTime('default')

	def powerOn(self):
		self.bus.write_i2c_block_data(self.address, 0x80, [0x03])
		time.sleep(0.5)

	def powerOff(self):
		self.bus.write_i2c_block_data(self.address, 0x80, [0x00])

	#Auf High Gain einstellen(16 mal empfindlicher?)
	def setHighGain(self):
		#Bei Einstellung auf High Gain werden Rohdaten möglicherweise nicht richtig abgerufen.
		#Untersuchung der Ursache erforderlich(5047 Festwert)	
		self.gain 	= 0x10
		data 		= self.integrationTime | self.gain
		self.bus.write_i2c_block_data(self.address, 0x81, [data])
		self.calcScale()

	# Low Gain(default)Einstellen
	def setLowGain(self):
		self.gain 	= 0x00
		data 		= self.integrationTime | self.gain
		self.bus.write_i2c_block_data(self.address, 0x81, [data])
		self.calcScale()

	#Einstellen der Integrationszeit (Zeit für eine Erfassung?)
	# val = shor, middle, logn(default)
	def setIntegrationTime(self, val):
		if val=='short':
			self.integrationTime 	= 0x00	# 13.7ms scale=0.034
		elif val=='middle':
			self.integrationTime 	= 0x01 	# 101ms	 scale=0.252
		else:
			self.integrationTime 	= 0x02  # defaultVal 402ms  scale=1.0
		data = self.integrationTime | self.gain
		self.bus.write_i2c_block_data(self.address, 0x81, [data])
		self.calcScale()

	def getVisibleLightRawData(self):
		data 	= self.bus.read_i2c_block_data(self.address, 0xAC ,2)
		raw 	= data[1] << 8 | data[0]	#16bit mit niedrigerem Byte zuerst
		return raw

	def getInfraredRawData(self):
		data 	= self.bus.read_i2c_block_data(self.address, 0xAE ,2)
		raw 	= data[1] << 8 | data[0]	#16bit mit niedrigerem Byte zuerst
		return raw

	def getRawData(self):
		data 	= self.bus.read_i2c_block_data(self.address, 0xAC ,4)
		VL 		= data[1] << 8 | data[0]	#Sichtbares Licht 16 Bit, unteres Byte zuerst
		IR 		= data[3] << 8 | data[2]	#Infrarot 16bit, unteres Byte zuerst
		return (VL,IR)

	def calcScale(self):
		_scale = 1.0
		#Skalieren Sie nach IntegrationTime
		if self.integrationTime == 0x01:	# middle
			_scale = _scale / 0.252
		elif self.integrationTime == 0x00:	# short
			_scale = _scale / 0.034
		
		#Skalieren Sie nach Gewinn
		if self.gain == 0x00 :				# gain 1
			_scale = _scale * 16.0

		self.scale = _scale

	def getLux(self):
		#Erfassung von Sensorrohdaten
		raw  = self.getRawData()

		#Implementierung zur Ausgabe eines Fehlers bei 65535
		if raw[0] == 65535 or raw[1] == 65535:
			return "Range Over"

		#Skalieren Sie Rohdaten mit Sensoreinstellungen
		VLRD = raw[0] * self.scale
		IRRD = raw[1] * self.scale

		#Teilen Sie nicht durch 0
		if (float(VLRD) == 0):
			ratio = 9999
		else:
			ratio = (IRRD / float(VLRD))

		#Lux Berechnung
		if ((ratio >= 0) & (ratio <= 0.52)):
			lux = (0.0315 * VLRD) - (0.0593 * VLRD * (ratio**1.4))
		elif (ratio <= 0.65):
			lux = (0.0229 * VLRD) - (0.0291 * IRRD)
		elif (ratio <= 0.80):
			lux = (0.0157 * VLRD) - (0.018 * IRRD)
		elif (ratio <= 1.3):
			lux = (0.00338 * VLRD) - (0.0026 * IRRD)
		elif (ratio > 1.3):
			lux = 0

		return lux 


if __name__ == "__main__":
	sensor 	= SL_TSL2561(0x39,1) 
	sensor.powerOn()
	# sensor.setHighGain()
	sensor.setIntegrationTime('default')
	while True:
		print "Lux : " + str(sensor.getLux())
		time.sleep(1.0)

Punkte, die man sich merken sollte

Bei Einstellung auf High Gain tritt das Problem auf, dass bei einer bestimmten Beleuchtungsstärke (am Maitag um das Fenster herum) ein abnormaler Wert festgelegt wird.