class Si7021Sensor:
def __init__(self):
self._bus = SMBus(1)
self._address = 0x40
def __del__(self):
self._bus.close()
def _send_command(self, command_code):
self._bus.write_byte(self._address, command_code)
time.sleep(0.3)
def _read_data(self):
data0 = self._bus.read_byte(self._address)
data1 = self._bus.read_byte(self._address)
time.sleep(0.3)
return data0, data1
def humidity(self):
"""
:return: relative humidity in percent.
"""
self._send_command(0xF5)
data0, data1 = self._read_data()
humidity = ((data0 * 256 + data1) * 125 / 65536.0) - 6
return humidity
def temperature(self):
"""
:return: temperature in celsius degrees.
"""
self._send_command(0xF3)
data0, data1 = self._read_data()
cels_temp = ((data0 * 256 + data1) * 175.72 / 65536.0) - 46.85
return cels_temp
class HD44780:
def __init__(self,
addr=HD44780_DEFAULT_ADDRESS,
channel=I2C_DEFAULT_CHANNEL):
self.__addr = addr
self.__bus = SMBus(channel)
# initialization
self.__write(0x03)
self.__write(0x03)
self.__write(0x03)
self.__write(0x02)
self.__write(FUNCTION_SET | FOUR_BITS_MODE | TWO_LINES | FIVE_EIGHT)
self.__write(DISPLAY_CONTROL | DISPLAY_ON | CURSOR_OFF)
self.__write(CLEAR_DISPLAY)
self.__write(ENTRY_MODE_SET | ENTRY_LEFT)
sleep(0.2)
def __write_four_bits(self, data):
self.__bus.write_byte(self.__addr, data | BACKLIGHT_ON)
sleep(0.0002)
self.__bus.write_byte(self.__addr, data | En | BACKLIGHT_ON)
sleep(0.0006)
self.__bus.write_byte(self.__addr, data | BACKLIGHT_ON)
sleep(0.0002)
def __write(self, data, RwRs=0b00):
self.__write_four_bits((data & 0xF0) | RwRs)
self.__write_four_bits(((data << 4) & 0xF0) | RwRs)
def backlight(self, state=BacklightMode.ON):
if state == BacklightMode.OFF:
self.__bus.write_byte(self.__addr, BACKLIGHT_OFF)
else:
self.__bus.write_byte(self.__addr, BACKLIGHT_ON)
def clear(self):
self.__write(CLEAR_DISPLAY)
self.__write(RETURN_HOME)
def print(self, string, line=1, align_mode=AlignMode.LEFT):
if len(string) > 0:
if line == 2:
self.__write(LINE_2)
else:
self.__write(LINE_1)
if len(string) > MAX_LINE_LENGTH:
string_to_be_printed = string[:MAX_LINE_LENGTH]
else:
if align_mode == AlignMode.CENTER:
string_to_be_printed = string.center(MAX_LINE_LENGTH)
elif align_mode == AlignMode.RIGHT:
string_to_be_printed = string.rjust(MAX_LINE_LENGTH)
else:
string_to_be_printed = string.ljust(MAX_LINE_LENGTH)
for char in string_to_be_printed:
self.__write(ord(char), Rs)
def __init__(self, name, i2c_addr):
self.I2Caddr = i2c_addr
directory = "/tmp/" + name
if not os.path.exists(directory):
os.makedirs(directory)
self.FptrTC = directory + "/tc"
self.FptrRH = directory + "/rh"
self.FptrTD = directory + "/td"
self.FptrAH = directory + "/ah"
# For file handeling, maintaining the moving averages
self.temp_buff = [ 0 ] * HTU21D_MAX
self.temp_ptr = 0
self.humid_buff = [ 0 ] * HTU21D_MAX
self.humid_ptr = 0
self.init_buff = 1 # flag to fill buffers
try:
bus = SMBus(I2CBUS)
bus.write_byte( self.I2Caddr, HTU21D_SOFT_RESET )
time.sleep(0.05)
bus.close()
except:
bus.close()
print "htu21d.init() failed"
class i2c_device: def __init__(self, addr, port=I2CBUS): self.addr = addr self.bus = SMBus(port) # Write a single command def write_cmd(self, cmd): self.bus.write_byte(self.addr, cmd) sleep(0.0001) # Write a command and argument def write_cmd_arg(self, cmd, data): self.bus.write_byte_data(self.addr, cmd, data) sleep(0.0001) # Write a block of data def write_block_data(self, cmd, data): self.bus.write_block_data(self.addr, cmd, data) sleep(0.0001) # Read a single byte def read(self): return self.bus.read_byte(self.addr) # Read def read_data(self, cmd): return self.bus.read_byte_data(self.addr, cmd) # Read a block of data def read_block_data(self, cmd): return self.bus.read_block_data(self.addr, cmd)
class RotEncThread(threading.Thread):
global clk_last_state
def __init__(self):
threading.Thread.__init__(self)
self.read_volume = 0
self.last_read_volume = 0
self.vol_change_func = None
self.arduino_addr = 0x08
self.bus = SMBus(1)
self.get_vol_arr = [103, 101, 116, 118, 0]
def set_vol_change_func(self, func):
self.vol_change_func = func
def run(self):
#try:
while True:
#lock.acquire()
try:
#self.bus.write_i2c_block_data(self.arduino_addr, 0x00, self.get_vol_arr)
self.bus.write_byte(self.arduino_addr, 0x01)
time.sleep(0.1)
self.read_volume = self.bus.read_byte_data(
self.arduino_addr, 0)
#print(self.read_volume)
if self.read_volume != self.last_read_volume:
self.vol_change_func(self.read_volume)
self.last_read_volume = self.read_volume
finally:
#lock.release()
time.sleep(0.01)
class MAX11644(object):
def __init__(self, bus=_DEFAULT_BUS, address=_DEFAULT_ADDRESS, internal_reference=True,
v_ref_internal=_V_REF_INTERNAL):
# I2C bus object
self._i2c = SMBus(bus)
# added to avoid communication problems
time.sleep(1)
self._address = address
self._SETUP = 0x80
self._CONF = 0x00
if internal_reference:
self._SETUP = 0xD0
self._ref_volt = v_ref_internal
else:
self._SETUP = 0x82
self._ref_volt = _VDD
self._SETUP = (self._SETUP | 0x02) # internal clock, unipolar, no action
self._send_data_(self._SETUP)
def _send_data_(self, byte):
"""Send a byte to device"""
self._i2c.write_byte(self._address, byte)
time.sleep(0.1)
def _read_data(self, address):
"""Read 2 bytes from address address."""
data = self._i2c.read_i2c_block_data(self._address, address, 2)
return data
def get_value(self, channel=0):
"""Get Full scale value (12 bits)"""
if channel == 0:
self._CONF = 0x61
data = self._read_data(self._CONF)
elif channel == 1:
self._CONF = 0x63
data = self._read_data(self._CONF)
else:
raise Exception("Channel doesn't exist")
data = ((data[0] & 0x0F) << 8) | data[1]
return data
def convert_to_volt(self, value):
"""Convert Full scale value (12 bits) into volts"""
return self._ref_volt * value / 4096.
def get_voltage(self, channel=0, factor=1):
return self.convert_to_volt(self.get_value(channel) / factor)
class Motors:
def __init__(self, motorsList):
self.motors = motorsList
self.motorCount = 0
self.bus = SMBus(1)
def start_motor(self):
if self.motorCount < self.motors.count:
self.bus.write_byte(self.motors[self.motorCount], 0x01)
def add_counter(self):
if self.motorCount < len(self.motors) - 1:
self.motorCount += 1
else:
self.motorCount = 0
def read_motor_info(self):
b = self.bus.read_byte(self.motors[self.motorCount])
return b
def set_status_counter(self):
self.bus.write_byte(self.motors[self.motorCount], 0x02)
def set_status_sensor(self):
self.bus.write_byte(self.motors[self.motorCount], 0x03)
def set_status_reset(self):
self.bus.write_byte(self.motors[self.motorCount], 0x09)
def get_actual_status(self):
b = self.bus.read_byte(self.motors[self.motorCount])
return b
class Cobra:
def __init__(self):
''' Creates a object
'''
self.HOST = '192.168.0.102'
self.PORT = 2017
self.server = SocketServer.TCPServer((self.HOST, self.PORT),
TCPHandler)
self.i2c = SMBus(1)
self.i2c.write_byte(0x40, 0)
self.i2c.write_byte(0x41, 0)
self.i2c.write_byte(0x42, 0)
# Activate the server; this will keep running until you
# interrupt the program with Ctrl-C
self.server.serve_forever()
def callback(data):
#rospy.loginfo(rospy.get_caller_id() + "I heard %s", data.data)
left = data.linear.x - data.angular.z
right = data.linear.x + data.angular.z
i2c = SMBus(1)
i2c.write_byte(0x40, 101)
i2c.write_byte(0x40, int(left))
i2c.write_byte(0x40, 102)
i2c.write_byte(0x40, int(right))
i2c.close()
class HTU21D:
def __init__(self, busno):
self.bus = SMBus(busno)
def read_temperature(self):
self.reset()
msb, lsb, crc = self.bus.read_i2c_block_data(I2C_ADDR,
CMD_TRIG_TEMP_HM, 3)
return -46.85 + 175.72 * (msb * 256 + lsb) / 65536
def read_humidity(self):
self.reset()
msb, lsb, crc = self.bus.read_i2c_block_data(I2C_ADDR,
CMD_TRIG_HUMID_HM, 3)
return -6 + 125 * (msb * 256 + lsb) / 65536.0
def reset(self):
self.bus.write_byte(I2C_ADDR, CMD_RESET)
class Device(object):
"""Class for communicating with an I2C device using the adafruit-pureio pure
python smbus library, or other smbus compatible I2C interface. Allows reading
and writing 8-bit, 16-bit, and byte array values to registers
on the device."""
def __init__(self, address, busnum):
"""Create an instance of the I2C device at the specified address on the
specified I2C bus number."""
self._address = address
self._bus = SMBus(busnum)
self._logger = logging.getLogger('Rover_log')
def writeByte(self, value):
"""Write an 8-bit value"""
value = value & 0xFF
self._bus.write_byte(self._address, register, value)
self._logger.debug("Wrote 0x%02X to register 0x%02X", value, register)
def write8(self, value, register=0):
"""Write an 8-bit value to the specified register. use register 0 if not needed"""
value = value & 0xFF
self._bus.write_byte_data(self._address, register, value)
self._logger.debug("Wrote 0x%02X to register 0x%02X", value, register)
def readU8(self, register=0):
"""Read an unsigned byte from the specified register. use 0 if egister is not needed"""
result = self._bus.read_byte_data(self._address, register) & 0xFF
self._logger.debug("Read 0x%02X from register 0x%02X", result,
register)
return result
def writeList(self, data, register=0):
"""Write bytes to the specified register. Use 0 if register is not needed"""
self._bus.write_i2c_block_data(self._address, register, data)
self._logger.debug("Wrote to register 0x%02X: %s", register, data)
def readList(self, length, register=0):
"""Read a length number of bytes from the specified register, use 0 if register is not needed. Results
will be returned as a bytearray."""
results = self._bus.read_i2c_block_data(self._address, register,
length)
self._logger.debug("Read the following from register 0x%02X: %s",
register, results)
return results
class WiiController:
def __init__(self, delay=0.05):
self.delay = delay
if rpi.RPI_REVISION == 1:
i2c_bus = 0
elif rpi.RPI_REVISION == 2:
i2c_bus = 1
elif rpi.RPI_REVISION == 3:
i2c_bus = 1
else:
raise OSError("Unable to determine Raspberry Pi revision.")
self.bus = SMBus(i2c_bus)
self.bus.write_byte_data(0x52, 0x40, 0x00)
time.sleep(0.1)
@cached(TTLCache(maxsize=1, ttl=0.0166))
def read(self):
self.bus.write_byte(0x52, 0x00)
time.sleep(self.delay)
return [(0x17 + (0x17 ^ self.bus.read_byte(0x52))) % 256
for _ in range(6)]
def handle(self):
# self.request is the TCP socket connected to the client
self.data = self.request.recv(1024)
print "{} wrote:".format(self.client_address[0])
speed = self.data.split(':')
speed_left = int(100 * float(speed[0]))
speed_right = int(100 * float(speed[1]))
if speed_left < 0:
speed_left = 256 + speed_left
if speed_right < 0:
speed_right = 256 + speed_right
print(speed_left, speed_right)
i2c = SMBus(1)
i2c.write_byte(0x41, speed_left)
i2c.write_byte(0x42, speed_right)
i2c.close()
class I2CBus():
def __init__(self, I2C_bus_number, address):
self.bus = SMBus(I2C_bus_number)
self.address = address
def write_register(self, reg_address, device_address=None):
device_address = self.address
return self.bus.write_byte(device_address, reg_address)
def read_registers(self, reg_address, device_address=None):
device_address = self.address
return self.bus.read_i2c_block_data(device_address, reg_address, 6)
def main(argv):
print("Hello world!")
bus = SMBus(1)
for i in range(0, 128, 16):
vals = []
for j in range(0, 16):
res = True
try:
k = i + j
if (k >= 0x30 and k <= 0x37) or (k >= 0x50 and k <= 0x5f):
bus.read_byte(i + j)
else:
bus.write_byte(i + j, 0)
except Exception as e:
res = False
if res:
vals.append("{}: {:3}".format(j, i + j))
else:
vals.append("{}: ---".format(j))
print("{:3}".format(i), ", ".join(vals))
def main():
# MCP4725 defaults to address 0x60
address = 0x7f
# Initialize I2C (SMBus)
bus = SMBus(1)
#bus.write_byte(address, 0x01)
byte_to_send = 0
'''
Values greater than a byte, 0-255, are overflowed back around.
For example, sending 256 results in a 0, 257 -> 1, etc.
'''
while byte_to_send <= 255:
print("Writing", byte_to_send)
try:
bus.write_byte(address, byte_to_send)
byte_to_send += 1
except OSError:
print("OSError: Failed to write to specified peripheral")
sleep(.2)
'''
class PCF8754:
def __init__(self, address, busnum=1):
self._address = address
self._i2c = SMBus(busnum)
self._access_error = False
def set_out(self, output):
try:
self._i2c.write_byte(self._address, (~output & 0xFF))
self._access_error = False
except OSError:
if not self._access_error:
self._access_error = True
log.warning('I2C device at address ' +
str(hex(self._address)) +
' could not be accessed.')
# print('I2C device at address ' + str(hex(self._address)) + ' could not be accessed.')
return self._access_error
def get_out(self):
try:
value = ~self._i2c.read_byte(self._address) & 0xFF
self._access_error = False
except OSError:
if not self._access_error:
self._access_error = True
log.warning('I2C device at address ' +
str(hex(self._address)) +
' could not be accessed.')
# print('I2C device at address ' + str(hex(self._address)) + ' could not be accessed.')
value = 0x00
return value, self._access_error
class Tsl2561Sensor(RestoreEntity):
"""Representation of a Sensor."""
def __init__(self):
"""Initialize the sensor."""
self._state = None
self._bus = SMBus(1)
@property
def name(self):
"""Return the name of the sensor."""
return 'Luminosita'
@property
def state(self):
"""Return the state of the sensor."""
return self._state
@property
def unit_of_measurement(self):
"""Return the unit of measurement."""
return "lux"
def update(self):
"""Fetch new state data for the sensor."""
self._state = self._lightcheck()
def _lightcheck(self):
self._bus.write_byte(TSLaddr, 0x00 | TSLcmd, TSLon) #Power On
#Gain x1 at 402ms is the default so this line not required but change for different sensitivity
self._bus.write_byte(TSLaddr, 0x01 | TSLcmd,LowLong) #Gain x1 402ms
time.sleep(1) #give time sensor to settle
#Read Ch0 Word
data = self._bus.read_i2c_block_data(TSLaddr, chan0 | TSLcmd, 2)
#Read CH1 Word
data1 = self._bus.read_i2c_block_data(TSLaddr, chan1 | TSLcmd, 2)
# Convert the data to Integer
ch0 = data[1] * 256 + data[0]
ch1 = data1[1] * 256 + data1[0]
vResults = ch0-ch1 #get visable light results
self._bus.write_byte(TSLaddr, 0x00 | TSLcmd, TSLoff) #switch off
return str(vResults)
class InputModule(AbstractInput):
"""
A sensor support class that measures the Chirp's moisture, temperature
and light
"""
def __init__(self, input_dev, testing=False):
super(InputModule, self).__init__(input_dev, testing=testing, name=__name__)
if not testing:
self.i2c_address = int(str(input_dev.i2c_location), 16)
self.i2c_bus = input_dev.i2c_bus
self.bus = SMBus(self.i2c_bus)
self.filter_average('lux', init_max=3)
def get_measurement(self):
""" Gets the light, moisture, and temperature """
self.return_dict = measurements_dict.copy()
if self.is_enabled(0):
self.value_set(0, self.filter_average('lux', measurement=self.light()))
if self.is_enabled(1):
self.value_set(1, self.moist())
if self.is_enabled(2):
self.value_set(2, self.temp() / 10.0)
return self.return_dict
def get_reg(self, reg):
# read 2 bytes from register
val = self.bus.read_word_data(self.i2c_address, reg)
# return swapped bytes (they come in wrong order)
return (val >> 8) + ((val & 0xFF) << 8)
def reset(self):
# To reset the sensor, write 6 to the device I2C address
self.bus.write_byte(self.i2c_address, 6)
def set_addr(self, new_addr):
# To change the I2C address of the sensor, write a new address
# (one byte [1..127]) to register 1; the new address will take effect after reset
self.bus.write_byte_data(self.i2c_address, 1, new_addr)
self.reset()
# self.address = new_addr
def moist(self):
# To read soil moisture, read 2 bytes from register 0
return self.get_reg(0)
def temp(self):
# To read temperature, read 2 bytes from register 5
return self.get_reg(5)
def light(self):
# To read light level, start measurement by writing 3 to the
# device I2C address, wait for 3 seconds, read 2 bytes from register 4
self.bus.write_byte(self.i2c_address, 3)
time.sleep(1.5)
lux = self.get_reg(4)
if lux == 0:
return 65535.0
else:
return(1 - (lux / 65535.0)) * 65535.0
class MCP3425:
def __init__(self,
bus=1,
ready=MCP3425_CONF_RDY,
channel=MCP3425_CONF_CHANNEL_1,
mode=MCP3425_CONF_MODE_CONTINUOUS,
rate=MCP3425_CONF_SIZE_12BIT,
gain=MCP3425_CONF_GAIN_1X,
resolution=MCP3425_BITS_RESOLUTION,
vref=2.048):
try:
self._bus = SMBus(bus)
except:
print("Bus %d is not available." % bus)
print("Available busses are listed as /dev/i2c*")
self._bus = None
self._ready = ready
self._channel = channel
self._mode = mode
self._rate = rate
self._gain = gain
self._resolution = resolution
self._vref = vref
def init(self):
if self._bus is None:
print("No bus!")
return False
self.setReady(self._ready)
self.setChannel(self._channel)
self.setMode(self._mode)
self.setSampleRate(self._rate)
self.setGain(self._gain)
return True
def setReady(self, ready):
"""
Set Ready Bit
In read mode, it indicates the output register has been updated with a new conversion.
In one-shot Conversion mode, writing initiates a new conversion.
"""
if self._bus:
self._bus.write_byte(MCP3425_DEFAULT_ADDRESS, ready)
def setChannel(self, channel):
"""
Set Channel Selection for MCP3426, MCP3427, MCP3428
Channels are not used for MCP3425
"""
if self._bus:
self._bus.write_byte(MCP3425_DEFAULT_ADDRESS, channel)
def setMode(self, mode):
"""
Set Conversion Mode
1 = Continous Conversion Mode
0 = One-shot Conversion Mode
"""
if self._bus:
self._bus.write_byte(MCP3425_DEFAULT_ADDRESS, mode)
def setSampleRate(self, rate):
"""
Set Sample rate selection bit
00 : 240 SPS-12 bits
01 : 60 SPS 14 bits
10 : 15 SPS 16 bits
"""
if self._bus:
self._bus.write_byte(MCP3425_DEFAULT_ADDRESS, rate)
def setGain(self, gain):
"""
# Set the PGA gain
00 : 1 V/V
01 : 2 V/V
10 : 4 V/V
11 : 8 V/V
"""
if self._bus:
self._bus.write_byte(MCP3425_DEFAULT_ADDRESS, gain)
def read(self):
"""
Get the measurement for the ADC values from the register using the General Calling method
"""
if self._bus:
data = self._bus.read_i2c_block_data(MCP3425_DEFAULT_ADDRESS, 0x00,
2)
value = ((data[0] << 8) | data[1])
if (value >= 32768):
value = 65536 - value
return value
else:
return 0
def convert(self, factor=1.0, offset=0.0):
"""
Shows the output codes of input level using 16-bit conversion mode
The output code is proportional to the voltage difference b/w two analog points
"""
code = self.read()
voltage = offset + (2 * self._vref *
code) / (2**self._resolution) * factor
return voltage
class InputModule(AbstractInput):
"""
A sensor support class that measures the SHT2x's humidity and temperature
and calculates the dew point
"""
def __init__(self, input_dev, testing=False):
super(InputModule, self).__init__(input_dev,
testing=testing,
name=__name__)
if not testing:
self.initialize_input()
def initialize_input(self):
from smbus2 import SMBus
self.i2c_address = int(str(self.input_dev.i2c_location), 16)
self.sht2x = SMBus(self.input_dev.i2c_bus)
def get_measurement(self):
""" Gets the humidity and temperature """
if not self.sht2x:
self.logger.error("Input not set up")
return
self.return_dict = copy.deepcopy(measurements_dict)
for _ in range(2):
try:
# Send temperature measurement command
# 0xF3(243) NO HOLD master
self.sht2x.write_byte(self.i2c_address, 0xF3)
time.sleep(0.5)
# Read data back, 2 bytes
# Temp MSB, Temp LSB
data0 = self.sht2x.read_byte(self.i2c_address)
data1 = self.sht2x.read_byte(self.i2c_address)
temperature = -46.85 + ((
(data0 * 256 + data1) * 175.72) / 65536.0)
# Send humidity measurement command
# 0xF5(245) NO HOLD master
self.sht2x.write_byte(self.i2c_address, 0xF5)
time.sleep(0.5)
# Read data back, 2 bytes
# Humidity MSB, Humidity LSB
data0 = self.sht2x.read_byte(self.i2c_address)
data1 = self.sht2x.read_byte(self.i2c_address)
humidity = -6 + (((data0 * 256 + data1) * 125.0) / 65536.0)
if self.is_enabled(0):
self.value_set(0, temperature)
if self.is_enabled(1):
self.value_set(1, humidity)
if self.is_enabled(2) and self.is_enabled(
0) and self.is_enabled(1):
self.value_set(
2,
calculate_dewpoint(self.value_get(0),
self.value_get(1)))
if self.is_enabled(3) and self.is_enabled(
0) and self.is_enabled(1):
self.value_set(
3,
calculate_vapor_pressure_deficit(
self.value_get(0), self.value_get(1)))
return self.return_dict
except Exception as e:
self.logger.exception(
"Exception when taking a reading: {err}".format(err=e))
# Send soft reset and try a second read
self.sht2x.write_byte(self.i2c_address, 0xFE)
time.sleep(0.1)
if __name__ == "__main__":
slave_addr = 0x0F
user_input = 1
payload = 0
response = 0
other_response = 0
bomba2 = 7
bus = SMBus(1)
wiringpi.wiringPiSetup()
wiringpi.pinMode(bomba2, wiringpi.OUTPUT)
while (user_input != 0):
user_input = int(input('Qual ação deseja realizar? '))
bus.write_byte(slave_addr, user_input)
sleep(0.2)
response = bus.read_byte(slave_addr)
print(INPUT[user_input], response)
if (user_input == 9):
if (response == 10):
payload = 3
bus.write_byte(slave_addr, payload)
sleep(1)
other_response = bus.read_byte(slave_addr)
while (other_response1 < 20):
i = 0
if speed_left < 0:
speed_left = 256 + speed_left
if speed_right < 0:
speed_right = 256 + speed_right
print(speed_left, speed_right)
i2c = SMBus(1)
i2c.write_byte(0x41, speed_left)
i2c.write_byte(0x42, speed_right)
i2c.close()
server = SocketServer.TCPServer((HOST, PORT), TCPHandler)
i2c = SMBus(1)
i2c.write_byte(0x40, 1)
i2c.write_byte(0x41, 0)
i2c.write_byte(0x42, 0)
i2c.close()
server.serve_forever()
'''
i2c = SMBus(1)
result = i2c.write_byte(0x40, 0)
result = i2c.write_byte(0x41, 5)
result = i2c.write_byte(0x42, 5)
print(result)
from smbus2 import SMBus i2c = SMBus(1) result = i2c.write_byte(0x40, 101) result = i2c.write_byte(0x40, 55) result = i2c.write_byte(0x40, 102) result = i2c.write_byte(0x40, -55) i2c.close()
class InputModule(AbstractInput):
"""A sensor support class that monitors the DS18B20's lux."""
def __init__(self, input_dev, testing=False):
super().__init__(input_dev, testing=testing, name=__name__)
self.i2c_address = None
self.i2c_bus = None
self.resolution = None
if not testing:
self.try_initialize()
def initialize(self):
from smbus2 import SMBus
self.i2c_address = int(str(self.input_dev.i2c_location), 16)
self.resolution = self.input_dev.resolution
self.i2c_bus = SMBus(self.input_dev.i2c_bus)
self.power_down()
self.set_sensitivity(sensitivity=self.input_dev.sensitivity)
@property
def lux(self):
"""BH1750 luminosity in lux."""
if self._measurements is None: # update if needed
self.read()
return self._measurements
def get_measurement(self):
"""Gets the BH1750's lux."""
self.return_dict = copy.deepcopy(measurements_dict)
if self.resolution == 0:
lux = self.measure_low_res()
elif self.resolution == 1:
lux = self.measure_high_res()
elif self.resolution == 2:
lux = self.measure_high_res2()
else:
return None
self.value_set(0, lux)
return self.return_dict
def _set_mode(self, mode):
self.mode = mode
self.i2c_bus.write_byte(self.i2c_address, self.mode)
def power_down(self):
self._set_mode(POWER_DOWN)
def power_on(self):
self._set_mode(POWER_ON)
def reset(self):
self.power_on() # It has to be powered on before resetting
self._set_mode(RESET)
def cont_low_res(self):
self._set_mode(CONTINUOUS_LOW_RES_MODE)
def cont_high_res(self):
self._set_mode(CONTINUOUS_HIGH_RES_MODE_1)
def cont_high_res2(self):
self._set_mode(CONTINUOUS_HIGH_RES_MODE_2)
def oneshot_low_res(self):
self._set_mode(ONE_TIME_LOW_RES_MODE)
def oneshot_high_res(self):
self._set_mode(ONE_TIME_HIGH_RES_MODE_1)
def oneshot_high_res2(self):
self._set_mode(ONE_TIME_HIGH_RES_MODE_2)
def set_sensitivity(self, sensitivity=69):
"""
Set the sensor sensitivity.
Valid values are 31 (lowest) to 254 (highest), default is 69.
"""
if sensitivity < 31:
self.mtreg = 31
elif sensitivity > 254:
self.mtreg = 254
else:
self.mtreg = sensitivity
self.power_on()
self._set_mode(0x40 | (self.mtreg >> 5))
self._set_mode(0x60 | (self.mtreg & 0x1f))
self.power_down()
def get_result(self):
"""Return current measurement result in lux."""
data = self.i2c_bus.read_word_data(self.i2c_address, self.mode)
count = data >> 8 | (data & 0xff) << 8
mode2coeff = 2 if (self.mode & 0x03) == 0x01 else 1
ratio = 1 / (1.2 * (self.mtreg / 69.0) * mode2coeff)
return ratio * count
def wait_for_result(self, additional=0):
basetime = 0.018 if (self.mode & 0x03) == 0x03 else 0.128
time.sleep(basetime * (self.mtreg / 69.0) + additional)
def do_measurement(self, mode, additional_delay=0):
"""
Perform complete measurement using command specified by parameter
mode with additional delay specified in parameter additional_delay.
Return output value in Lx.
"""
self.reset()
self._set_mode(mode)
self.wait_for_result(additional=additional_delay)
return self.get_result()
def measure_low_res(self, additional_delay=0):
return self.do_measurement(ONE_TIME_LOW_RES_MODE, additional_delay)
def measure_high_res(self, additional_delay=0):
return self.do_measurement(ONE_TIME_HIGH_RES_MODE_1, additional_delay)
def measure_high_res2(self, additional_delay=0):
return self.do_measurement(ONE_TIME_HIGH_RES_MODE_2, additional_delay)
class LCD_Generic:
"""Output to a generic I2C LCD (16x2 and 20x4 LCD with I2C backpack)"""
def __init__(self, lcd_dev=None, lcd_settings_dict=None):
self.lcd_initialized = False
self.lcd_is_on = False
if lcd_dev:
self.logger = logging.getLogger("{}_{}".format(
__name__,
lcd_dev.unique_id.split('-')[0]))
self.i2c_address = int(lcd_dev.location, 16)
self.i2c_bus = lcd_dev.i2c_bus
self.lcd_x_characters = lcd_dev.x_characters
self.lcd_y_lines = lcd_dev.y_lines
elif lcd_settings_dict:
self.logger = logging.getLogger("{}_{}".format(
__name__, lcd_settings_dict["unique_id"].split('-')[0]))
self.i2c_address = int(lcd_settings_dict["i2c_address"], 16)
self.i2c_bus = lcd_settings_dict["i2c_bus"]
self.lcd_x_characters = lcd_settings_dict["x_characters"]
self.lcd_y_lines = lcd_settings_dict["y_lines"]
self.LCD_LINE = {1: 0x80, 2: 0xC0, 3: 0x94, 4: 0xD4}
self.LCD_CHR = 1 # Mode - Sending data
self.LCD_CMD = 0 # Mode - SenLCDding command
self.LCD_BACKLIGHT = 0x08 # On
self.LCD_BACKLIGHT_OFF = 0x00 # Off
self.ENABLE = 0b00000100 # Enable bit
# Timing constants
self.E_PULSE = 0.0005
self.E_DELAY = 0.0005
self.LCD_WIDTH = self.lcd_x_characters # Max characters per line
# Setup I2C bus
try:
self.bus = SMBus(self.i2c_bus)
except Exception as except_msg:
self.logger.exception(
"Could not initialize I2C bus: {err}".format(err=except_msg))
self.I2C_ADDR = self.i2c_address
def lcd_init(self):
""" Initialize LCD display """
try:
self.lcd_byte(0x33, self.LCD_CMD) # 110011 Initialise
self.lcd_byte(0x32, self.LCD_CMD) # 110010 Initialise
self.lcd_byte(0x06, self.LCD_CMD) # 000110 Cursor move direction
self.lcd_byte(
0x0C, self.LCD_CMD) # 001100 Display On,Cursor Off, Blink Off
self.lcd_byte(
0x28,
self.LCD_CMD) # 101000 Data length, number of lines, font size
self.lcd_byte(0x01, self.LCD_CMD) # 000001 Clear display
time.sleep(self.E_DELAY)
except Exception as err:
self.logger.error(
"Could not initialize LCD. Check your configuration and wiring. Error: {err}"
.format(err=err))
def lcd_backlight(self, state):
""" Turn the backlight on or off """
if state:
self.lcd_byte(0x01, self.LCD_CMD, self.LCD_BACKLIGHT)
else:
self.lcd_byte(0x01, self.LCD_CMD, self.LCD_BACKLIGHT_OFF)
def lcd_byte(self, bits, mode, backlight=None):
""" Send byte to data pins """
if backlight is None:
backlight = self.LCD_BACKLIGHT
# bits = the data
# mode = 1 for data
# 0 for command
bits_high = mode | (bits & 0xF0) | backlight
bits_low = mode | ((bits << 4) & 0xF0) | backlight
# High bits
self.bus.write_byte(self.I2C_ADDR, bits_high)
self.lcd_toggle_enable(bits_high)
# Low bits
self.bus.write_byte(self.I2C_ADDR, bits_low)
self.lcd_toggle_enable(bits_low)
def lcd_toggle_enable(self, bits):
""" Toggle enable """
time.sleep(self.E_DELAY)
self.bus.write_byte(self.I2C_ADDR, (bits | self.ENABLE))
time.sleep(self.E_PULSE)
self.bus.write_byte(self.I2C_ADDR, (bits & ~self.ENABLE))
time.sleep(self.E_DELAY)
def lcd_string_write(self, message, line):
""" Send strings to display """
line_write = self.LCD_LINE[line]
message = message.ljust(self.LCD_WIDTH, " ")
self.lcd_byte(line_write, self.LCD_CMD)
for i in range(self.LCD_WIDTH):
self.lcd_byte(ord(message[i]), self.LCD_CHR)
def lcd_write_lines(self, line_1, line_2, line_3, line_4):
if line_1:
self.lcd_string_write(line_1, 1)
if line_2:
self.lcd_string_write(line_2, 2)
if line_3:
self.lcd_string_write(line_3, 3)
if line_4:
self.lcd_string_write(line_4, 4)
class InputModule(AbstractInput):
"""
A sensor support class that measures the SHT2x's humidity and temperature
and calculates the dew point
"""
def __init__(self, input_dev, testing=False):
super(InputModule, self).__init__()
self.logger = logging.getLogger("mycodo.inputs.sht2x")
if not testing:
from smbus2 import SMBus
self.logger = logging.getLogger(
"mycodo.sht2x_{id}".format(id=input_dev.unique_id.split('-')[0]))
self.device_measurements = db_retrieve_table_daemon(
DeviceMeasurements).filter(
DeviceMeasurements.device_id == input_dev.unique_id)
self.i2c_address = int(str(input_dev.i2c_location), 16)
self.i2c_bus = input_dev.i2c_bus
self.sht2x = SMBus(self.i2c_bus)
def get_measurement(self):
""" Gets the humidity and temperature """
return_dict = measurements_dict.copy()
for _ in range(2):
try:
# Send temperature measurement command
# 0xF3(243) NO HOLD master
self.sht2x.write_byte(self.i2c_address, 0xF3)
time.sleep(0.5)
# Read data back, 2 bytes
# Temp MSB, Temp LSB
data0 = self.sht2x.read_byte(self.i2c_address)
data1 = self.sht2x.read_byte(self.i2c_address)
temperature = -46.85 + (((data0 * 256 + data1) * 175.72) / 65536.0)
# Send humidity measurement command
# 0xF5(245) NO HOLD master
self.sht2x.write_byte(self.i2c_address, 0xF5)
time.sleep(0.5)
# Read data back, 2 bytes
# Humidity MSB, Humidity LSB
data0 = self.sht2x.read_byte(self.i2c_address)
data1 = self.sht2x.read_byte(self.i2c_address)
humidity = -6 + (((data0 * 256 + data1) * 125.0) / 65536.0)
if self.is_enabled(0):
return_dict[0]['value'] = temperature
if self.is_enabled(1):
return_dict[1]['value'] = humidity
if (self.is_enabled(2) and
self.is_enabled(0) and
self.is_enabled(1)):
return_dict[2]['value'] = calculate_dewpoint(
return_dict[0]['value'], return_dict[1]['value'])
if (self.is_enabled(3) and
self.is_enabled(0) and
self.is_enabled(1)):
return_dict[3]['value'] = calculate_vapor_pressure_deficit(
return_dict[0]['value'], return_dict[1]['value'])
return return_dict
except Exception as e:
self.logger.exception(
"Exception when taking a reading: {err}".format(err=e))
# Send soft reset and try a second read
self.sht2x.write_byte(self.i2c_address, 0xFE)
time.sleep(0.1)
class VL53L1X:
"""VL53L1X ToF."""
def __init__(self,
i2c_bus=1,
i2c_address=0x29,
tca9548a_num=255,
tca9548a_addr=0):
"""Initialize the VL53L1X ToF Sensor from ST"""
self._i2c_bus = i2c_bus
self.i2c_address = i2c_address
self._tca9548a_num = tca9548a_num
self._tca9548a_addr = tca9548a_addr
self._i2c = SMBus(i2c_bus)
try:
if tca9548a_num == 255:
self._i2c.read_byte_data(self.i2c_address, 0x00)
except IOError:
raise RuntimeError("VL53L1X not found on adddress: {:02x}".format(
self.i2c_address))
self._dev = None
# Register Address
self.ADDR_UNIT_ID_HIGH = 0x16 # Serial number high byte
self.ADDR_UNIT_ID_LOW = 0x17 # Serial number low byte
self.ADDR_I2C_ID_HIGH = 0x18 # Write serial number high byte for I2C address unlock
self.ADDR_I2C_ID_LOW = 0x19 # Write serial number low byte for I2C address unlock
self.ADDR_I2C_SEC_ADDR = 0x8a # Write new I2C address after unlock
def open(self, reset=False):
self._i2c.open(bus=self._i2c_bus)
self._configure_i2c_library_functions()
self._dev = _TOF_LIBRARY.initialise(self.i2c_address,
self._tca9548a_num,
self._tca9548a_addr, reset)
def close(self):
self._i2c.close()
self._dev = None
def _configure_i2c_library_functions(self):
# I2C bus read callback for low level library.
def _i2c_read(address, reg, data_p, length):
ret_val = 0
msg_w = i2c_msg.write(address, [reg >> 8, reg & 0xff])
msg_r = i2c_msg.read(address, length)
self._i2c.i2c_rdwr(msg_w, msg_r)
if ret_val == 0:
for index in range(length):
data_p[index] = ord(msg_r.buf[index])
return ret_val
# I2C bus write callback for low level library.
def _i2c_write(address, reg, data_p, length):
ret_val = 0
data = []
for index in range(length):
data.append(data_p[index])
msg_w = i2c_msg.write(address, [reg >> 8, reg & 0xff] + data)
self._i2c.i2c_rdwr(msg_w)
return ret_val
# I2C bus write callback for low level library.
def _i2c_multi(address, reg):
ret_val = 0
# Write to the multiplexer
self._i2c.write_byte(address, reg)
return ret_val
# Pass i2c read/write function pointers to VL53L1X library.
self._i2c_multi_func = _I2C_MULTI_FUNC(_i2c_multi)
self._i2c_read_func = _I2C_READ_FUNC(_i2c_read)
self._i2c_write_func = _I2C_WRITE_FUNC(_i2c_write)
_TOF_LIBRARY.VL53L1_set_i2c(self._i2c_multi_func, self._i2c_read_func,
self._i2c_write_func)
def start_ranging(self, mode=VL53L1xDistanceMode.LONG):
"""Start VL53L1X ToF Sensor Ranging"""
_TOF_LIBRARY.startRanging(self._dev, mode)
def set_distance_mode(self, mode):
"""Set distance mode
:param mode: One of 1 = Short, 2 = Medium or 3 = Long
"""
_TOF_LIBRARY.setDistanceMode(self._dev, mode)
def stop_ranging(self):
"""Stop VL53L1X ToF Sensor Ranging"""
_TOF_LIBRARY.stopRanging(self._dev)
def get_distance(self):
"""Get distance from VL53L1X ToF Sensor"""
return _TOF_LIBRARY.getDistance(self._dev)
def set_timing(self, timing_budget, inter_measurement_period):
"""Set the timing budget and inter measurement period.
A higher timing budget results in greater measurement accuracy,
but also a higher power consumption.
The inter measurement period must be >= the timing budget, otherwise
it will be double the expected value.
:param timing_budget: Timing budget in microseconds
:param inter_measurement_period: Inter Measurement Period in milliseconds
"""
if (inter_measurement_period * 1000) < timing_budget:
raise ValueError(
"The Inter Measurement Period must be >= Timing Budget")
self.set_timing_budget(timing_budget)
self.set_inter_measurement_period(inter_measurement_period)
def set_timing_budget(self, timing_budget):
"""Set the timing budget in microseocnds"""
_TOF_LIBRARY.setMeasurementTimingBudgetMicroSeconds(
self._dev, timing_budget)
def set_inter_measurement_period(self, period):
"""Set the inter-measurement period in milliseconds"""
_TOF_LIBRARY.setInterMeasurementPeriodMilliSeconds(self._dev, period)
# This function included to show how to access the ST library directly
# from python instead of through the simplified interface
def get_timing(self):
budget = c_uint(0)
budget_p = pointer(budget)
status = _TOF_LIBRARY.VL53L1_GetMeasurementTimingBudgetMicroSeconds(
self._dev, budget_p)
if status == 0:
return budget.value + 1000
else:
return 0
def change_address(self, new_address):
status = _TOF_LIBRARY.setDeviceAddress(self._dev, new_address)
if status == 0:
self.i2c_address = new_address
else:
raise RuntimeError(
"change_address failed with code: {}".format(status))
return True
def get_RangingMeasurementData(self):
'''
Returns the full RangingMeasurementData structure.
(it ignores the fields that are not implemented according to en.DM00474730.pdf)
'''
contents = _getRangingMeasurementData(self._dev).contents
return {
'StreamCount': contents.StreamCount,
'SignalRateRtnMegaCps': contents.SignalRateRtnMegaCps / 65536,
'AmbientRateRtnMegaCps': contents.AmbientRateRtnMegaCps / 65536,
'EffectiveSpadRtnCount': contents.EffectiveSpadRtnCount / 256,
'SigmaMilliMeter': contents.SigmaMilliMeter / 65536,
'RangeMilliMeter': contents.RangeMilliMeter,
'RangeStatus': contents.RangeStatus
}
def task(self):
temp = 99999
humid = 99999
tdew = 99999
status = 0
try:
bus = SMBus(I2CBUS)
bus.write_byte( self.I2Caddr, HTU21D_READ_TEMP_NOHOLD )
time.sleep(0.05)
read = i2c_msg.read( self.I2Caddr, 3 )
bus.i2c_rdwr(read)
resp = list(read)
if ( self.crc8(resp) == 0 ):
status += 1
# data sheet 15/21 Temperature Conversion
t = (resp[0] << 8) | (resp[1] & HTU21D_STATUS_LSBMASK)
temp = ((175.72 * t) / 65536.0) - 46.86
self.temp_buff[self.temp_ptr] = temp
self.temp_ptr += 1
if self.temp_ptr >= HTU21D_MAX:
self.temp_ptr = 0
# runs first pass only
if self.init_buff :
for i in range(HTU21D_MAX):
self.temp_buff[i] = temp
# need to init humid_buff[] too
# so don't clear self.init_buff flag here
avg_temp = 0
for i in range(HTU21D_MAX):
avg_temp += self.temp_buff[i]
avg_temp /= HTU21D_MAX_FLOAT
f = open(self.FptrTC,"w")
f.write("%3.1f" % avg_temp)
f.close()
bus.write_byte( self.I2Caddr, HTU21D_READ_HUM_NOHOLD )
time.sleep(0.05)
read = i2c_msg.read( self.I2Caddr, 3 )
bus.i2c_rdwr(read)
resp = list(read)
bus.close()
if( self.crc8( resp ) == 0 ):
status += 1
# data sheet 15/21 Relative Humidity
h = (resp[0] << 8) | (resp[1] & HTU21D_STATUS_LSBMASK)
humid = ((125.0 * h) / 65536.0) - 6.0
# limit for out of range values
# per data sheet page 15/21
if humid < 0.0 :
humid = 0.0
if humid > 100.0:
humid = 100.0
# RH compensation per datasheet page: 4/12
# JUN 28, 2018 changed to avg_temp
rh = humid + ( 25.0 - avg_temp) * -0.15
self.humid_buff[self.humid_ptr] = rh
self.humid_ptr += 1
if self.humid_ptr >= HTU21D_MAX:
self.humid_ptr = 0
# runs first pass only
if self.init_buff :
for i in range(HTU21D_MAX):
self.humid_buff[i] = rh
self.init_buff = 0
avg_humid = 0
for i in range(HTU21D_MAX):
avg_humid += self.humid_buff[i]
avg_humid /= HTU21D_MAX_FLOAT
f = open(self.FptrRH,"w")
f.write("%3.1f" % avg_humid)
f.close()
# with both valid temperature and RH
# calculate the dew point and absolute humidity using average values
if status > 1:
# Calculate dew point
# because log of zero is not possible
if avg_humid < 0.1:
avg_humid = 0.1
A = 8.1332
B = 1762.39
C = 235.66
# data sheet page 16/21 Partial Pressure & Dew Point
pp = 10**( A - ( B / ( avg_temp + C )))
tdew = -(( B / ( log10( avg_humid * pp / 100.0) - A )) + C )
f = open(self.FptrTD,"w")
f.write("%3.1f" % tdew)
f.close()
# Calculate absolute humidity in grams/M^3
e = 2.71828
a = 13.2473
b = e**((17.67 * avg_temp)/(avg_temp + 243.5))
c = 273.15 + avg_temp
ah = a * b * avg_humid / c
f = open(self.FptrAH,"w")
f.write("%3.1f" % ah)
f.close()
#print "htu21d.task() T: %3.1f RH: %3.1f Tdew: %3.1f AH: %3.1f" % ( avg_temp, avg_humid, tdew, ah )
except:
bus.close()
print "htu21d.task() failed"
# returning average values
return [ temp, humid, tdew ]
class InputModule(AbstractInput):
""" A sensor support class that monitors the DS18B20's lux """
def __init__(self, input_dev, testing=False):
super(InputModule, self).__init__()
self.logger = logging.getLogger("mycodo.inputs.bh1750")
if not testing:
from smbus2 import SMBus
self.logger = logging.getLogger(
"mycodo.bh1750_{id}".format(id=input_dev.unique_id.split('-')[0]))
self.device_measurements = db_retrieve_table_daemon(
DeviceMeasurements).filter(
DeviceMeasurements.device_id == input_dev.unique_id)
self.i2c_address = int(str(input_dev.i2c_location), 16)
self.resolution = input_dev.resolution
self.sensitivity = input_dev.sensitivity
self.i2c_bus = SMBus(input_dev.i2c_bus)
self.power_down()
self.set_sensitivity(sensitivity=self.sensitivity)
@property
def lux(self):
""" BH1750 luminosity in lux """
if self._measurements is None: # update if needed
self.read()
return self._measurements
def get_measurement(self):
""" Gets the BH1750's lux """
return_dict = measurements_dict.copy()
if self.resolution == 0:
lux = self.measure_low_res()
elif self.resolution == 1:
lux = self.measure_high_res()
elif self.resolution == 2:
lux = self.measure_high_res2()
else:
return None
return_dict[0]['value'] = lux
return return_dict
def _set_mode(self, mode):
self.mode = mode
self.i2c_bus.write_byte(self.i2c_address, self.mode)
def power_down(self):
self._set_mode(POWER_DOWN)
def power_on(self):
self._set_mode(POWER_ON)
def reset(self):
self.power_on() # It has to be powered on before resetting
self._set_mode(RESET)
def cont_low_res(self):
self._set_mode(CONTINUOUS_LOW_RES_MODE)
def cont_high_res(self):
self._set_mode(CONTINUOUS_HIGH_RES_MODE_1)
def cont_high_res2(self):
self._set_mode(CONTINUOUS_HIGH_RES_MODE_2)
def oneshot_low_res(self):
self._set_mode(ONE_TIME_LOW_RES_MODE)
def oneshot_high_res(self):
self._set_mode(ONE_TIME_HIGH_RES_MODE_1)
def oneshot_high_res2(self):
self._set_mode(ONE_TIME_HIGH_RES_MODE_2)
def set_sensitivity(self, sensitivity=69):
"""
Set the sensor sensitivity.
Valid values are 31 (lowest) to 254 (highest), default is 69.
"""
if sensitivity < 31:
self.mtreg = 31
elif sensitivity > 254:
self.mtreg = 254
else:
self.mtreg = sensitivity
self.power_on()
self._set_mode(0x40 | (self.mtreg >> 5))
self._set_mode(0x60 | (self.mtreg & 0x1f))
self.power_down()
def get_result(self):
""" Return current measurement result in lx. """
data = self.i2c_bus.read_word_data(self.i2c_address, self.mode)
count = data >> 8 | (data & 0xff) << 8
mode2coeff = 2 if (self.mode & 0x03) == 0x01 else 1
ratio = 1 / (1.2 * (self.mtreg / 69.0) * mode2coeff)
return ratio * count
def wait_for_result(self, additional=0):
basetime = 0.018 if (self.mode & 0x03) == 0x03 else 0.128
time.sleep(basetime * (self.mtreg / 69.0) + additional)
def do_measurement(self, mode, additional_delay=0):
"""
Perform complete measurement using command specified by parameter
mode with additional delay specified in parameter additional_delay.
Return output value in Lx.
"""
self.reset()
self._set_mode(mode)
self.wait_for_result(additional=additional_delay)
return self.get_result()
def measure_low_res(self, additional_delay=0):
return self.do_measurement(ONE_TIME_LOW_RES_MODE, additional_delay)
def measure_high_res(self, additional_delay=0):
return self.do_measurement(ONE_TIME_HIGH_RES_MODE_1, additional_delay)
def measure_high_res2(self, additional_delay=0):
return self.do_measurement(ONE_TIME_HIGH_RES_MODE_2, additional_delay)
import time
from smbus2 import SMBus
address = 0x48
A0 = 0x40
A1 = 0x41
A2 = 0x42
A3 = 0x43
bus = SMBus(1)
while True:
bus.write_byte(address, A0)
value = bus.read_byte(address)
if (value < 3):
print("- No Pressure")
elif (value < 50):
print("- Light Touch")
elif (value < 125):
print("- Light Squeeze")
elif (value < 200):
print("- Meduim Squeeze")
else:
print("- Big Squeeze")
time.sleep(1)
#----------------------------------------------------------------------------
i2c = SMBus(1)
adc = MCP3208()
GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)
GPIO.setup(12, GPIO.OUT)
GPIO.setup(18, GPIO.OUT)
fan_L = GPIO.PWM(12, 500)
fan_R = GPIO.PWM(18, 500)
fan_L.start(fan_L_sp)
fan_R.start(fan_R_sp)
val = (1 << OE_1) | (1 << OE_2) | (1 << OE_3) | (0 << CLR) | (1 << CLK_EN)
i2c.write_byte(PCF_CTRL, val)
val = (1 << OE_1) | (1 << OE_2) | (1 << OE_3) | (1 << CLR) | (1 << CLK_EN)
i2c.write_byte(PCF_CTRL, val)
while True:
sensor = W1ThermSensor(W1ThermSensor.THERM_SENSOR_DS18B20, T_SENSOR_1)
temp_1 = sensor.get_temperature()
sensor = W1ThermSensor(W1ThermSensor.THERM_SENSOR_DS18B20, T_SENSOR_2)
temp_2 = sensor.get_temperature()
left_fan = GetRPM(0)
right_fan = GetRPM(1)
u_psu = 0
u_bat = 0
i_bat = 0
class InputModule(AbstractInput):
"""
A sensor support class that measures the Chirp's moisture, temperature
and light
"""
def __init__(self, input_dev, testing=False):
super(InputModule, self).__init__()
self.logger = logging.getLogger("mycodo.inputs.chirp")
if not testing:
self.logger = logging.getLogger(
"mycodo.chirp_{id}".format(id=input_dev.unique_id.split('-')[0]))
self.device_measurements = db_retrieve_table_daemon(
DeviceMeasurements).filter(
DeviceMeasurements.device_id == input_dev.unique_id)
self.i2c_address = int(str(input_dev.i2c_location), 16)
self.i2c_bus = input_dev.i2c_bus
self.bus = SMBus(self.i2c_bus)
self.filter_average('lux', init_max=3)
def get_measurement(self):
""" Gets the light, moisture, and temperature """
return_dict = measurements_dict.copy()
if self.is_enabled(0):
return_dict[0]['value'] = self.filter_average('lux', measurement=self.light())
if self.is_enabled(1):
return_dict[1]['value'] = self.moist()
if self.is_enabled(2):
return_dict[2]['value'] = self.temp() / 10.0
return return_dict
def get_reg(self, reg):
# read 2 bytes from register
val = self.bus.read_word_data(self.i2c_address, reg)
# return swapped bytes (they come in wrong order)
return (val >> 8) + ((val & 0xFF) << 8)
def reset(self):
# To reset the sensor, write 6 to the device I2C address
self.bus.write_byte(self.i2c_address, 6)
def set_addr(self, new_addr):
# To change the I2C address of the sensor, write a new address
# (one byte [1..127]) to register 1; the new address will take effect after reset
self.bus.write_byte_data(self.i2c_address, 1, new_addr)
self.reset()
# self.address = new_addr
def moist(self):
# To read soil moisture, read 2 bytes from register 0
return self.get_reg(0)
def temp(self):
# To read temperature, read 2 bytes from register 5
return self.get_reg(5)
def light(self):
# To read light level, start measurement by writing 3 to the
# device I2C address, wait for 3 seconds, read 2 bytes from register 4
self.bus.write_byte(self.i2c_address, 3)
time.sleep(1.5)
lux = self.get_reg(4)
if lux == 0:
return 65535.0
else:
return(1 - (lux / 65535.0)) * 65535.0
