Je n'ai résumé que les parties nécessaires. L'édition d'essai et d'erreur est ici.

2017-04-09 Il a été téléchargé sur github. https://github.com/boyaki-machine/TSL2561

Câblage physique

Souder la tête de broche au capteur qui est arrivé. Puis fil.

Capteur 1pin (GND) -> Raspi 6ème broche Capteur 2 broches (SDA) -> Raspi broche 3 Capteur 3 broches (SCL) -> Raspi 5ème broche Capteur 4 broches (VDD) -> Raspi pin 1

C'est comme ça.

Activer I2C avec Raspberry pi

Réglez dans le menu de configuration du système d'exploitation.

$ sudo raspi-config

Sélectionnez le menu dans l'ordre "9 Options avancées" -> "A7 I2C". Il vous sera demandé "Souhaitez-vous que l'interface ARM I2C soit activée?", Alors sélectionnez oui. On vous demandera "Souhaitez-vous que le module du noyau I2C soit chargé par défaut?", Alors sélectionnez oui.

Puis éditez /boot/config.txt.

$ sudo vi /boot/config.txt
...Ajout du contenu suivant
dtparam=i2c_arm=on

De plus, modifiez / etc / modules.

$ sudo vi /etc/modules
...Ajout du contenu suivant
snd-bcm2835
i2c-dev

Une fois les paramètres définis, redémarrez Raspy. Assurez-vous que le module du noyau est chargé après le redémarrage.

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

Installer des outils

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

Confirmation d'adresse

Vérifiez l'adresse du capteur.

$ 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: -- -- -- -- -- -- -- --

Reconnu à l'adresse 0x39.

Obtenir des données en Python

Utilisez la classe suivante.

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

import smbus
import time

#À partir du "TSL2561 Illumination Sensor Module" de Strawberry Linux
#Classe pour obtenir des données dans 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

		#Initialisation des paramètres du capteur
		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])

	#Réglé sur Gain élevé(16 fois plus sensible?)
	def setHighGain(self):
		#Lorsqu'il est réglé sur Gain élevé, les données brutes peuvent ne pas être obtenues correctement.
		#Enquête sur la cause requise(5047 Valeur fixe)	
		self.gain 	= 0x10
		data 		= self.integrationTime | self.gain
		self.bus.write_i2c_block_data(self.address, 0x81, [data])
		self.calcScale()

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

	#Réglage du temps d'intégration (temps pour une détection?)
	# 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]	#16 bits avec l'octet inférieur en premier
		return raw

	def getInfraredRawData(self):
		data 	= self.bus.read_i2c_block_data(self.address, 0xAE ,2)
		raw 	= data[1] << 8 | data[0]	#16 bits avec l'octet inférieur en premier
		return raw

	def getRawData(self):
		data 	= self.bus.read_i2c_block_data(self.address, 0xAC ,4)
		VL 		= data[1] << 8 | data[0]	#Lumière visible 16 bits, octet inférieur en premier
		IR 		= data[3] << 8 | data[2]	#Infrarouge 16 bits, octet inférieur en premier
		return (VL,IR)

	def calcScale(self):
		_scale = 1.0
		#Échelle par intégration
		if self.integrationTime == 0x01:	# middle
			_scale = _scale / 0.252
		elif self.integrationTime == 0x00:	# short
			_scale = _scale / 0.034
		
		#Échelle par gain
		if self.gain == 0x00 :				# gain 1
			_scale = _scale * 16.0

		self.scale = _scale

	def getLux(self):
		#Acquisition des données brutes du capteur
		raw  = self.getRawData()

		#Implémentation pour générer une erreur lorsque 65535
		if raw[0] == 65535 or raw[1] == 65535:
			return "Range Over"

		#Mettre à l'échelle les données brutes avec les paramètres du capteur
		VLRD = raw[0] * self.scale
		IRRD = raw[1] * self.scale

		#Ne divisez pas par 0
		if (float(VLRD) == 0):
			ratio = 9999
		else:
			ratio = (IRRD / float(VLRD))

		#Calcul Lux
		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)

Points à retenir

Lorsqu'il est réglé sur Gain élevé, il y a un problème: il est fixé à une valeur anormale s'il y a une certaine quantité d'éclairement (autour de la fenêtre pendant le 1er mai).