From d8e7f8a2aadca3105a6e1e772b9cd0bfd19198c1 Mon Sep 17 00:00:00 2001 From: Marian Minar Date: Thu, 11 Jul 2024 17:27:47 +0200 Subject: [PATCH] Update AXP805, MCP3221, small fixes --- ecomet_i2c_sensors/axp805/__init__.py | 0 ecomet_i2c_sensors/axp805/axp805.py | 254 ++++++++++++++++++ ecomet_i2c_sensors/axp805/axp805_constant.py | 143 ++++++++++ ecomet_i2c_sensors/mcp3221/mcp3221.py | 116 ++++++++ .../mcp3221/mcp3221_constant.py | 15 ++ ecomet_i2c_sensors/pca9632/pca9632.py | 10 +- ecomet_i2c_sensors/sgp40/sgp40.py | 8 +- python_test_scripts/pca_9632_i2c_rgb.py | 49 +++- python_test_scripts/pca_9632_i2c_rgb_2led.py | 103 +++++++ 9 files changed, 679 insertions(+), 19 deletions(-) create mode 100644 ecomet_i2c_sensors/axp805/__init__.py create mode 100644 ecomet_i2c_sensors/axp805/axp805.py create mode 100644 ecomet_i2c_sensors/axp805/axp805_constant.py create mode 100644 ecomet_i2c_sensors/mcp3221/mcp3221.py create mode 100644 ecomet_i2c_sensors/mcp3221/mcp3221_constant.py create mode 100755 python_test_scripts/pca_9632_i2c_rgb_2led.py diff --git a/ecomet_i2c_sensors/axp805/__init__.py b/ecomet_i2c_sensors/axp805/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/ecomet_i2c_sensors/axp805/axp805.py b/ecomet_i2c_sensors/axp805/axp805.py new file mode 100644 index 0000000..99305f4 --- /dev/null +++ b/ecomet_i2c_sensors/axp805/axp805.py @@ -0,0 +1,254 @@ +from __future__ import division +import logging +import time +import math +import numpy as np +from ecomet_i2c_sensors.axp209 import axp209_constant +from ctypes import c_uint8, BigEndianStructure, Union + +reg_list = { 'POWER_OPERATING_MODE_REG' : axp209_constant.POWER_OPERATING_MODE_REG, 'POWER_INPUT_STATUS_REG' : axp209_constant.POWER_INPUT_STATUS_REG, + 'BATTERY_GAUGE_REG' : axp209_constant.BATTERY_GAUGE_REG, + 'INTERNAL_TEMPERATURE_REG' : axp209_constant.INTERNAL_TEMPERATURE_REG, 'BATTERY_VOLTAGE_REG' : axp209_constant.BATTERY_VOLTAGE_REG, + 'BATTERY_CHARGE_CURRENT_REG' : axp209_constant.BATTERY_CHARGE_CURRENT_REG, + 'BATTERY_DISCHARGE_CURRENT_REG' : axp209_constant.BATTERY_DISCHARGE_CURRENT_REG, 'BATTERY_VOLTAGE_REG' : axp209_constant.BATTERY_VOLTAGE_REG, + 'VBUS_IPSOUT_CHANNEL_MANAGEMENT_REG' : axp209_constant.VBUS_IPSOUT_CHANNEL_MANAGEMENT_REG, + 'ADC_ENABLE1_REG' : axp209_constant.ADC_ENABLE1_REG, 'ADC_ENABLE2_REG' : axp209_constant.ADC_ENABLE2_REG + } + +logger = logging.getLogger(__name__) + +class AXP209(object): + '''axp209() Power Management Controller''' + + def __init__(self, address=axp209_constant.AXP209_ADDRESS, busnum=None, i2c=None, **kwargs) : + '''Initialize the axp209.''' + # Setup I2C interface for the device. + if i2c is None: + import ecomet_i2c_sensors.i2c as I2C + i2c = I2C + self._logger = logging.getLogger(__name__) + self._device = i2c.get_i2c_device(address, busnum=busnum, i2c_interface='smbus2', **kwargs) + #i2c_interface parameter choise smbus2 lib insted of Adafruit PureIO + + # force ADC enable for battery voltage and current + self.adc_enable1 = 0xc3 + + def __enter__(self): + return self + + def __exit__(self, exc_type, exc_val, exc_tb): + if self.autocleanup: + self.close() + + def close(self): + self._device.close() + + @property + def gpio2_output(self): + pass + + @gpio2_output.setter + def gpio2_output(self, val): + flags = GPIO012_FEATURE_SET_FLAGS() + if bool(val): + flags.gpio_function = 0b111 + else: + flags.gpio_function = 0b000 + self.write_register('ADC_ENABLE1_REG', flags.asbyte) + + @property + def adc_enable1(self): + flags = axp209_constant.ADC_ENABLE1_FLAGS() + (flags.asbyte,ret) = self.read_register('ADC_ENABLE1_REG') + return flags + + @adc_enable1.setter + def adc_enable1(self, flags): + if hasattr(flags, "asbyte"): + flags = flags.asbyte + self.write_register('ADC_ENABLE1_REG', flags) + + @property + def adc_enable2(self): + flags = axp209_constant.ADC_ENABLE2_FLAGS() + (flags.asbyte,ret) = self.read_register('ADC_ENABLE2_REG') + return flags + + @adc_enable2.setter + def adc_enable2(self, flags): + if hasattr(flags, "asbyte"): + flags = flags.asbyte + self.write_register('ADC_ENABLE2_REG', flags) + + @property + def vbus_current_limit(self): + """ Returns the current vbus current limit setting """ + limits = { #00:900 mA; 01:500 mA; 10:100 mA; 11: not limit + 0: "900 mA", + 1: "500 mA", + 2: "100 mA", + 3: "not limited", + } + (current_data,ret) = self.read_register('VBUS_IPSOUT_CHANNEL_MANAGEMENT_REG') + current_limit = current_data & 0x03 + return limits.get(current_limit, "invalid setting") + + @vbus_current_limit.setter + def vbus_current_limit(self, val): + flags = axp209_constant.VBUS_CURRENT_LIMIT_CONTROL() + limits = { #00:900 mA; 01:500 mA; 10:100 mA; 11: not limit + 0: "900 mA", + 1: "500 mA", + 2: "100 mA", + 3: "no limit", + } + for setting, limit in limits.items(): + if limit == val : + (flags.asbyte,ret) = self.read_register('VBUS_IPSOUT_CHANNEL_MANAGEMENT_REG') + flags.vbus_current_limit = setting + self.write_register('VBUS_IPSOUT_CHANNEL_MANAGEMENT_REG', flags.asbyte) + + @property + def power_input_status(self): + flags = axp209_constant.POWER_INPUT_STATUS_FLAGS() + (flags.asbyte,ret) = self.read_register('POWER_INPUT_STATUS_REG') + return flags + + @property + def battery_current_direction(self): + return bool(self.power_input_status.battery_current_direction) + + @property + def power_operating_mode(self): + flags = axp209_constant.POWER_OPERATING_STATUS_FLAGS() + (flags.asbyte,ret) = self.read_register('POWER_OPERATING_MODE_REG') + return flags + + # ADC_ENABLE1 REGISTER status + @property + def battery_current_adc_enable(self): + return bool(self.adc_enable1.battery_current_adc_enable) + + @property + def acin_voltage_adc_enable(self): + return bool(self.adc_enable1.acin_voltage_adc_enable) + + @property + def acin_current_adc_enable(self): + return bool(self.adc_enable1.acin_current_adc_enable) + + @property + def vbus_voltage_adc_enable(self): + return bool(self.adc_enable1.vbus_voltage_adc_enable) + + @property + def vbus_current_adc_enable(self): + return bool(self.adc_enable1.vbus_current_adc_enable) + + @property + def aps_voltage_adc_enable(self): + return bool(self.adc_enable1.aps_voltage_adc_enable) + + @property + def ts_pin_adc_function_enable(self): + return bool(self.adc_enable1.ts_pin_adc_function_enable) + + # TBD_ENABLE2_REGISTER status + @property + def apx209_internal_temperature_monitoring_adc_enable(self): + return bool(self.adc_enable2.apx209_internal_temperature_monitoring_adc_enable) + + @property + def gpio0_adc_function_enable(self): + return bool(self.adc_enable2.gpio0_adc_function_enable) + + @property + def gpio1_adc_function_enable(self): + return bool(self.adc_enable2.gpio1_adc_function_enable) + # + @property + def battery_exists(self): + return bool(self.power_operating_mode.battery_exists) + + @property + def battery_charging(self): + return bool(self.power_operating_mode.battery_charging) + + @property + def battery_voltage(self): + """ Returns voltage in mV """ + (voltage_bin,ret) = self.read_register('BATTERY_VOLTAGE_REG') + return voltage_bin * 1.1 + + @property + def battery_charge_current(self): + """ Returns current in mA """ + (charge_bin,ret) = self.read_register('BATTERY_CHARGE_CURRENT_REG') + # (12 bits) + # 0 mV -> 000h, 0.5 mA/bit FFFh -> 1800 mA + return charge_bin * 0.5 + + @property + def battery_discharge_current(self): + """ Returns current in mA """ + (discharge_bin,ret) = self.read_register('BATTERY_DISCHARGE_CURRENT_REG') + # 13bits + # 0 mV -> 000h, 0.5 mA/bit 1FFFh -> 1800 mA + return discharge_bin * 0.5 + + @property + def internal_temperature(self): + """ Returns temperature in celsius C """ + (temp,ret) = self.read_register('INTERNAL_TEMPERATURE_REG') + # MSB is 8 bits, LSB is lower 4 bits + # -144.7c -> 000h, 0.1c/bit FFFh -> 264.8c + return temp*0.1-144.7 + + @property + def battery_gauge(self): + (gauge_bin,ret) = self.read_register('BATTERY_GAUGE_REG') + gauge = gauge_bin & 0x7f + if gauge > 100: + return -1 + return gauge + + def read_register(self, register) : + reg_status = -9999 + ret = 0 + if register in ['INTERNAL_TEMPERATURE_REG','BATTERY_VOLTAGE_REG','BATTERY_CHARGE_CURRENT_REG'] : + try : + # 12 bit + reg_status_bita = self._device.readList(reg_list[register],2) + reg_status_hex_high = reg_status_bita[0] + reg_status_hex_low = reg_status_bita[1] + reg_status = reg_status_hex_high << 4 | reg_status_hex_low & 0x0f + except : + ret = ret + 1 + elif register in ['BATTERY_DISCHARGE_CURRENT_REG'] : + try : + # 13 bit + reg_status_bita = self._device.readList(reg_list[register],2) + reg_status_hex_high = reg_status_bita[0] + reg_status_hex_low = reg_status_bita[1] + reg_status = reg_status_hex_high << 5 | reg_status_hex_low & 0x1f + except : + ret = ret + 1 + elif register in ['POWER_OPERATING_MODE_REG','POWER_INPUT_STATUS_REG','BATTERY_GAUGE_REG','BATTERY_GAUGE_REG','VBUS_IPSOUT_CHANNEL_MANAGEMENT_REG', + 'ADC_ENABLE1_REG','ADC_ENABLE2_REG'] : + try : + reg_status = self._device.readU8(reg_list[register]) + except : + ret = ret + 1 + return(reg_status,ret) + + def write_register(self, register,data) : + ret = 0 + #print ( register ) + if register in ['VBUS_IPSOUT_CHANNEL_MANAGEMENT_REG','ADC_ENABLE1_REG','ADC_ENABLE2_REG'] : + self._device.write8(reg_list[register],data) + try : + self._device.write8(reg_list[register],data) + except : + ret = ret + 1 + return (ret) + diff --git a/ecomet_i2c_sensors/axp805/axp805_constant.py b/ecomet_i2c_sensors/axp805/axp805_constant.py new file mode 100644 index 0000000..2019404 --- /dev/null +++ b/ecomet_i2c_sensors/axp805/axp805_constant.py @@ -0,0 +1,143 @@ +from ctypes import c_uint8, BigEndianStructure, Union + +# Address: +AXP209_ADDRESS = 0x34 # 8 bit version + +# from CHIP battery.sh script +POWER_INPUT_STATUS_REG = 0x00 +POWER_OPERATING_MODE_REG = 0x01 +CHARGE_CONTROL_REG = 0x33 +CHARGE_CONTROL2_REG = 0x34 +ADC_ENABLE1_REG = 0x82 +ADC_ENABLE2_REG = 0x83 +INTERNAL_TEMPERATURE_REG = 0x5e +BATTERY_VOLTAGE_REG = 0x78 +BATTERY_CHARGE_CURRENT_REG = 0x7a +BATTERY_DISCHARGE_CURRENT_REG = 0x7c +GPIO0_FEATURE_SET_REG = 0x90 +GPIO1_FEATURE_SET_REG = 0x92 +GPIO2_FEATURE_SET_REG = 0x93 +BATTERY_GAUGE_REG = 0xb9 +VBUS_IPSOUT_CHANNEL_MANAGEMENT_REG = 0X30 + +# POWER_OPERATING_MODE_REG Bits: +class POWER_OPERATING_STATUS_FLAGS(Union): + class _b(BigEndianStructure): + _fields_ = [ + ("over-temperature", c_uint8, 1), # instruct AXP209 Is it overheated? 0:Not too warm ； 1:Overtemperature + ("battery_charging", c_uint8, 1), # Charging instructions + # 0:Not charging or charging completed ； 1:Charging + ("battery_exists", c_uint8, 1), # Battery presence status indication + # 0:No battery connected to AXP209； 1:The battery is connected to AXP209 + ("_reserved_", c_uint8, 1), + ("battery_active", c_uint8, 1), # Indicates whether the battery has entered activation mode + # 0:Not entering battery activation mode ； 1:Entered battery activation mode + ("reached_desired_charge_current", c_uint8, 1), # Indicates whether the charging current is less than the expected current + # 0:The actual charging current is equal to the expected current ； 1:The actual charging current is less than the expected current + ("_reserved_", c_uint8, 2), + ] + + _fields_ = [("_b", _b), + ("asbyte", c_uint8)] + + _anonymous_ = ("_b",) + +class POWER_INPUT_STATUS_FLAGS(Union): + class _b(BigEndianStructure): + _fields_ = [ + ("acin_present", c_uint8, 1), + ("acin_available", c_uint8, 1), + ("vbus_present", c_uint8, 1), + ("vbus_available", c_uint8, 1), + ("vbus_direction", c_uint8, 1), + ("battery_current_direction", c_uint8, 1), # 1: charging, 0: discharging + ("acin_vbus_shorted", c_uint8, 1), + ("start_source", c_uint8, 1) + ] + + _fields_ = [("_b", _b), + ("asbyte", c_uint8)] + + _anonymous_ = ("_b",) + + +class POWER_OPERATING_STATUS_FLAGS(Union): + class _b(BigEndianStructure): + _fields_ = [ + ("over-temperature", c_uint8, 1), + ("battery_charging", c_uint8, 1), # 1: charging, 0: not charging or charging done + ("battery_exists", c_uint8, 1), # 1: battery is connected, 0: not connected + ("_reserved_", c_uint8, 1), + ("battery_active", c_uint8, 1), + ("reached_desired_charge_current", c_uint8, 1), + ("_reserved_", c_uint8, 2), + ] + + _fields_ = [("_b", _b), + ("asbyte", c_uint8)] + + _anonymous_ = ("_b",) + + +class GPIO012_FEATURE_SET_FLAGS(Union): + class _b(BigEndianStructure): + _fields_ = [ + ("gpio_rising_edge_interupt", c_uint8, 1), + ("gpio_falling_edge_interupt", c_uint8, 1), + ("_reserved_", c_uint8, 3), + ("gpio_function", c_uint8, 3), + ] + + _fields_ = [("_b", _b), + ("asbyte", c_uint8)] + + _anonymous_ = ("_b",) + + +class VBUS_CURRENT_LIMIT_CONTROL(Union): + class _b(BigEndianStructure): + _fields_ = [ + ("vbus_available", c_uint8, 1), + ("hold_pressure_limiting", c_uint8, 1), + ("hold_set_up", c_uint8, 3), + ("_reserved_", c_uint8, 1), + ("vbus_current_limit", c_uint8, 2), + ] + + _fields_ = [("_b", _b), + ("asbyte", c_uint8)] + + _anonymous_ = ("_b",) + +class ADC_ENABLE1_FLAGS(Union): + class _b(BigEndianStructure): + _fields_ = [ + ("battery_voltage_adc_enable", c_uint8, 1), + ("battery_current_adc_enable", c_uint8, 1), + ("acin_voltage_adc_enable", c_uint8, 1), + ("acin_current_adc_enable", c_uint8, 1), + ("vbus_voltage_adc_enable", c_uint8, 1), + ("vbus_current_adc_enable", c_uint8, 1), + ("aps_voltage_adc_enable", c_uint8, 1), + ("ts_pin_adc_function_enable", c_uint8, 1), + ] + + _fields_ = [("_b", _b), + ("asbyte", c_uint8)] + + _anonymous_ = ("_b",) + +class ADC_ENABLE2_FLAGS(Union): + class _b(BigEndianStructure): + _fields_ = [ + ("apx209_internal_temperature_monitoring_adc_enable", c_uint8, 1), + ("_reserved_", c_uint8, 3), + ("gpio0_adc_function_enable", c_uint8, 1), + ("gpio1_adc_function_enable", c_uint8, 1), + ("_reserved_", c_uint8, 2), + ] + + _fields_ = [("_b", _b), + ("asbyte", c_uint8)] + + _anonymous_ = ("_b",) diff --git a/ecomet_i2c_sensors/mcp3221/mcp3221.py b/ecomet_i2c_sensors/mcp3221/mcp3221.py new file mode 100644 index 0000000..952b4b4 --- /dev/null +++ b/ecomet_i2c_sensors/mcp3221/mcp3221.py @@ -0,0 +1,116 @@ +''' + Updated Code: 2024-07-11 + Copyright (c) 2024 eComet Co.Ltd (https://twitter.com/mminar7) + @author + @license GPL-3.0 +''' + +from time import sleep, time +import smbus2 +import logging +from ecomet_i2c_sensors.mcp3221 import mcp3221_constant + +class MCP3221: + + def __init__(self,bus = 1,address=mcp3221_constant.MCP_ADDR, busnum=None, i2c=None, **kwargs): + if i2c is None: + import ecomet_i2c_sensors.i2c as I2C + i2c = I2C + self._logger = logging.getLogger(__name__) + self._device = i2c.get_i2c_device(address, busnum=busnum, **kwargs) + + @property + def read_value(self) : + ret = 0 + try : + reg_status = self._device.readRaw16() + decimal_number = (reg_status[0] << 8) | reg_status[1] + self._logger.debug('Dec_Num: %s',decimal_number) + out = decimal_number/mcp3221_constant.MAX_VDD + self._logger.debug('Number: %s',out) + except : + ret = ret + 1 + return(out,ret) + + @property + def to_max_const(self) : + ret = 0 + val = self.read_value + if val[1] == 0 : + out = val[0] * mcp3221_constant.MAX_DEGREE + else : + ret = ret + 1 + return (out,ret) + + ''' + @Convert degrees to cardinal points. + @param degrees: Degrees (0-360) + @return: Cardinal direction as a string + ''' + @property + def degrees_to_cardinal(self): + ret = 0 + try : + val = self.to_max_const + degrees = val[0] + if val[1] == 0 and (0 <= degrees < 360.1) : + if (degrees >= 337.5 and degrees < 360.1) or (degrees >= 0 and degrees < 22.5): + val = "North" + elif degrees >= 22.5 and degrees < 67.5: + val = "North-West" + elif degrees >= 67.5 and degrees < 112.5: + val = "West" + elif degrees >= 112.5 and degrees < 157.5: + val = "South-West" + elif degrees >= 157.5 and degrees < 202.5: + val = "South" + elif degrees >= 202.5 and degrees < 247.5: + val = "South-East" + elif degrees >= 247.5 and degrees < 292.5: + val = "East" + elif degrees >= 292.5 and degrees < 337.5: + val = "North-East" + else : + val = "Error" + ret = ret + 2 + except : + ret = ret + 1 + return (val,ret) + + @property + def degrees_to_cardinal_calibrated(self): + ret = 0 + try : + val = self.to_max_const + degrees = val[0] + if val[1] == 0 and (0 <= degrees < 360.1) : + thr_n = ( mcp3221_constant.NORTH_WEST)/2 + thr_nw = mcp3221_constant.NORTH_WEST + ( mcp3221_constant.WEST - mcp3221_constant.NORTH_WEST )/2 + thr_w = mcp3221_constant.WEST + ( mcp3221_constant.SOUTH_WEST - mcp3221_constant.WEST )/2 + thr_sw = mcp3221_constant.SOUTH_WEST + ( mcp3221_constant.SOUTH - mcp3221_constant.SOUTH_WEST )/2 + thr_s = mcp3221_constant.SOUTH + ( mcp3221_constant.SOUTH_EAST - mcp3221_constant.SOUTH )/2 + thr_se = mcp3221_constant.SOUTH_EAST + ( mcp3221_constant.EAST - mcp3221_constant.SOUTH_EAST )/2 + thr_e = mcp3221_constant.EAST + ( mcp3221_constant.NORTH_EAST - mcp3221_constant.EAST )/2 + thr_ne = mcp3221_constant.NORTH_EAST + ( mcp3221_constant.NORTH - mcp3221_constant.NORTH_EAST )/2 + if (degrees >= thr_ne and degrees < 360.1) or (degrees >= 0 and degrees < thr_n): + val = "North" + elif degrees >= thr_n and degrees < thr_nw: + val = "North-West" + elif degrees >= thr_nw and degrees < thr_w: + val = "West" + elif degrees >= thr_w and degrees < thr_sw: + val = "South-West" + elif degrees >= thr_sw and degrees < thr_s: + val = "South" + elif degrees >= thr_s and degrees < thr_se: + val = "South-East" + elif degrees >= thr_se and degrees < thr_e: + val = "East" + elif degrees >= thr_e and degrees < thr_ne: + val = "North-East" + else : + val = "Error" + ret = ret + 2 + except : + ret = ret + 1 + return (val,ret) diff --git a/ecomet_i2c_sensors/mcp3221/mcp3221_constant.py b/ecomet_i2c_sensors/mcp3221/mcp3221_constant.py new file mode 100644 index 0000000..76bbbcd --- /dev/null +++ b/ecomet_i2c_sensors/mcp3221/mcp3221_constant.py @@ -0,0 +1,15 @@ +MCP_ADDR = 0x4F + +VDD = 5 # Voltage = 5V +MAX_DEGREE = 360 # 360 Degree max position +WEST = 75 +SOUTH = 176 +EAST = 280 +NORTH = 360 +NORTH_WEST = 36 +SOUTH_WEST = 125 +SOUTH_EAST = 225 +NORTH_EAST = 330 + +MAX_VDD = 4095 + diff --git a/ecomet_i2c_sensors/pca9632/pca9632.py b/ecomet_i2c_sensors/pca9632/pca9632.py index c216464..304c3df 100644 --- a/ecomet_i2c_sensors/pca9632/pca9632.py +++ b/ecomet_i2c_sensors/pca9632/pca9632.py @@ -6,8 +6,6 @@ #import pca9632_constant #import i2c_command_oop - - reg_list = { 'MODE1' : pca9632_constant.MODE1, 'MODE2' : pca9632_constant.MODE2, 'PWM0' : pca9632_constant.PWM0, 'PWM1' : pca9632_constant.PWM1, 'PWM2' : pca9632_constant.PWM2, 'PWM3' : pca9632_constant.PWM3, 'GRPPWM' : pca9632_constant.GRPPWM, 'GRPFREQ' : pca9632_constant.GRPFREQ, 'LEDOUT' : pca9632_constant.LEDOUT, @@ -213,13 +211,17 @@ def ledout_clear (): class PCA9632(object): '''PCA9632() PWM LED/servo controller.''' - def __init__(self, address=pca9632_constant.PCA9632_ADDRESS, i2c=None, **kwargs) : - '''Initialize the PCA9685.''' + def __init__(self, address=None, i2c=None, **kwargs) : + '''Initialize the PCA9632.''' # Setup I2C interface for the device. + if address is None: + address=pca9632_constant.PCA9632_ADDRESS if i2c is None: import ecomet_i2c_sensors.i2c as I2C i2c = I2C + self._logger = logging.getLogger(__name__) self._device = i2c.get_i2c_device(address, **kwargs) + self._logger.info('address: 0x%s', '{0:02x}'.format(address)) #self._device.write8(PWM0,0x7D) def self_test(self) : try : diff --git a/ecomet_i2c_sensors/sgp40/sgp40.py b/ecomet_i2c_sensors/sgp40/sgp40.py index ee46a3b..f5b37ae 100644 --- a/ecomet_i2c_sensors/sgp40/sgp40.py +++ b/ecomet_i2c_sensors/sgp40/sgp40.py @@ -143,13 +143,13 @@ def _measure_test(self): def index_to_explanation(self,index) : if index < 80 : return 'excelent' - elif index >= 80 and index < 180 : + elif index >= 80 and index < 150 : return 'normal' - elif index >= 180 and index < 300 : + elif index >= 150 and index < 250 : return 'warning' - elif index >= 300 and index < 400 : + elif index >= 250 and index < 400 : return 'major' - elif index > 500 : + elif index >= 400 : return 'critical' ''' diff --git a/python_test_scripts/pca_9632_i2c_rgb.py b/python_test_scripts/pca_9632_i2c_rgb.py index 13783cf..e07e3dd 100755 --- a/python_test_scripts/pca_9632_i2c_rgb.py +++ b/python_test_scripts/pca_9632_i2c_rgb.py @@ -3,16 +3,35 @@ import sys import time +import logging print (sys.version) from ecomet_i2c_sensors.pca9632 import pca9632 -pwm = pca9632.PCA9632() -reg_view = pca9632.read_pca9632(); +pwm1 = pca9632.PCA9632(address=0x60) +pwm2 = pca9632.PCA9632(address=0x62) +logging.basicConfig(level=logging.INFO, # change level looging to (INFO, DEBUG, ERROR) + format='%(asctime)s %(name)-12s %(levelname)-8s %(message)s', + datefmt='%m-%d %H:%M', + filename='pca9632.log', + filemode='w') +console = logging.StreamHandler() +console.setLevel(logging.DEBUG) +formatter = logging.Formatter('%(name)-12s: %(levelname)-8s %(message)s') +console.setFormatter(formatter) +logging.getLogger('').addHandler(console) +pwm1._logger = logging.getLogger('ecomet.pca9632') +pwm1._logger.info('Start logging ...') + +#reg_view = pca9632.read_pca9632(); ret = pca9632.software_reset() ret = pca9632.ledout_clear() -ret = pwm.write_register( register = 'MODE1', bits = ['ALLCALL','SLEEP_N']) -ret = pwm.write_register( register = 'MODE2', bits = ['DMBLNK_BLINKING']) -ret = pwm.write_register( register = 'LEDOUT', bits = [{'LDR0' : 'OFF' }, {'LDR1' : 'PWM'}, {'LDR2' : 'PWM'}, {'LDR3' : 'PWM'}]) +ret = pwm1.write_register( register = 'MODE1', bits = ['ALLCALL','SLEEP_N']) +ret = pwm1.write_register( register = 'MODE2', bits = ['DMBLNK_BLINKING']) +ret = pwm1.write_register( register = 'LEDOUT', bits = [{'LDR0' : 'PWM' }, {'LDR1' : 'PWM'}, {'LDR2' : 'PWM'}, {'LDR3' : 'OFF'}]) + +ret = pwm2.write_register( register = 'MODE1', bits = ['ALLCALL','SLEEP_N']) +ret = pwm2.write_register( register = 'MODE2', bits = ['DMBLNK_BLINKING']) +ret = pwm2.write_register( register = 'LEDOUT', bits = [{'LDR0' : 'PWM' }, {'LDR1' : 'PWM'}, {'LDR2' : 'PWM'}, {'LDR3' : 'OFF'}]) # RGB led connected to PWM1, PWM2, PWM3 # PWM1 = BLUE, PWM2 = GREEN, PWM3 = RED @@ -62,13 +81,21 @@ for loop in range (1,10) : for i in palette : - pwm.write_register( register = 'PWM3', bits = [{'PWM' : int(i['R'] / der[loop]) }]) - pwm.write_register( register = 'PWM2', bits = [{'PWM' : int(i['G'] / der[loop]) }]) - pwm.write_register( register = 'PWM1', bits = [{'PWM' : int(i['B'] / der[loop]) }]) + pwm1.write_register( register = 'PWM2', bits = [{'PWM' : int(i['R'] / der[loop]) }]) + pwm1.write_register( register = 'PWM1', bits = [{'PWM' : int(i['G'] / der[loop]) }]) + pwm1.write_register( register = 'PWM0', bits = [{'PWM' : int(i['B'] / der[loop]) }]) + + pwm2.write_register( register = 'PWM2', bits = [{'PWM' : int(i['R'] / der[loop]) }]) + pwm2.write_register( register = 'PWM1', bits = [{'PWM' : int(i['G'] / der[loop]) }]) + pwm2.write_register( register = 'PWM0', bits = [{'PWM' : int(i['B'] / der[loop]) }]) sleep(0.1) -pwm.write_register( register = 'PWM3', bits = [{'PWM' : '0' }]) -pwm.write_register( register = 'PWM2', bits = [{'PWM' : '0' }]) -pwm.write_register( register = 'PWM1', bits = [{'PWM' : '0' }]) +pwm1.write_register( register = 'PWM2', bits = [{'PWM' : '0' }]) +pwm1.write_register( register = 'PWM1', bits = [{'PWM' : '0' }]) +pwm1.write_register( register = 'PWM0', bits = [{'PWM' : '0' }]) + +pwm2.write_register( register = 'PWM2', bits = [{'PWM' : '0' }]) +pwm2.write_register( register = 'PWM1', bits = [{'PWM' : '0' }]) +pwm2.write_register( register = 'PWM0', bits = [{'PWM' : '0' }]) diff --git a/python_test_scripts/pca_9632_i2c_rgb_2led.py b/python_test_scripts/pca_9632_i2c_rgb_2led.py new file mode 100755 index 0000000..276eab6 --- /dev/null +++ b/python_test_scripts/pca_9632_i2c_rgb_2led.py @@ -0,0 +1,103 @@ +#!/usr/bin/env python3 +# test script for RGB LED testing, in loop color will be rotated in palette and dimmed + +import sys +import time +import logging +print (sys.version) +from ecomet_i2c_sensors.pca9632 import pca9632 + +pwm1 = pca9632.PCA9632(address=0x60) +pwm2 = pca9632.PCA9632(address=0x62) +logging.basicConfig(level=logging.INFO, # change level looging to (INFO, DEBUG, ERROR) + format='%(asctime)s %(name)-12s %(levelname)-8s %(message)s', + datefmt='%m-%d %H:%M', + filename='pca9632.log', + filemode='w') +console = logging.StreamHandler() +console.setLevel(logging.DEBUG) +formatter = logging.Formatter('%(name)-12s: %(levelname)-8s %(message)s') +console.setFormatter(formatter) +logging.getLogger('').addHandler(console) +pwm1._logger = logging.getLogger('ecomet.pca9632') +pwm1._logger.info('Start logging ...') + +#reg_view = pca9632.read_pca9632(); +ret = pca9632.software_reset() +ret = pca9632.ledout_clear() +ret = pwm1.write_register( register = 'MODE1', bits = ['ALLCALL','SLEEP_N']) +ret = pwm1.write_register( register = 'MODE2', bits = ['DMBLNK_BLINKING']) +ret = pwm1.write_register( register = 'LEDOUT', bits = [{'LDR0' : 'PWM' }, {'LDR1' : 'PWM'}, {'LDR2' : 'PWM'}, {'LDR3' : 'OFF'}]) + +ret = pwm2.write_register( register = 'MODE1', bits = ['ALLCALL','SLEEP_N']) +ret = pwm2.write_register( register = 'MODE2', bits = ['DMBLNK_BLINKING']) +ret = pwm2.write_register( register = 'LEDOUT', bits = [{'LDR0' : 'PWM' }, {'LDR1' : 'PWM'}, {'LDR2' : 'PWM'}, {'LDR3' : 'OFF'}]) + +# RGB led connected to PWM1, PWM2, PWM3 +# PWM1 = BLUE, PWM2 = GREEN, PWM3 = RED + +blue = { 'R': 0, + 'G': 0, + 'B': 255 } +violet = { 'R': 128, + 'G': 0, + 'B': 255 } +magenta = { 'R': 255, + 'G': 0, + 'B': 255 } +rose = { 'R': 255, + 'G': 0, + 'B': 128 } +red = { 'R': 255, + 'G': 0, + 'B': 0 } +orange = { 'R': 255, + 'G': 128, + 'B': 0 } +yellow = { 'R': 255, + 'G': 255, + 'B': 0 } +chartre = { 'R': 128, + 'G': 255, + 'B': 0 } +green = { 'R': 0, + 'G': 255, + 'B': 0 } +springg = { 'R': 0, + 'G': 255, + 'B': 128 } +cyan = { 'R': 0, + 'G': 255, + 'B': 255 } +azure = { 'R': 0, + 'G': 128, + 'B': 255 } + +der = [1,2,4,8,10,12,14,16,18,20] + + +palette = [blue,violet,magenta,rose,red,orange,yellow,chartre,green,springg,cyan,azure] +#palette = [blue,red,green] +from time import sleep +for loop in range (1,2) : + for i in palette : + + pwm1.write_register( register = 'PWM2', bits = [{'PWM' : int(i['B'] / der[loop]) }]) + pwm1.write_register( register = 'PWM1', bits = [{'PWM' : int(i['R'] / der[loop]) }]) + pwm1.write_register( register = 'PWM0', bits = [{'PWM' : int(i['G'] / der[loop]) }]) + + pwm2.write_register( register = 'PWM2', bits = [{'PWM' : int(i['B'] / der[loop]) }]) + pwm2.write_register( register = 'PWM1', bits = [{'PWM' : int(i['R'] / der[loop]) }]) + pwm2.write_register( register = 'PWM0', bits = [{'PWM' : int(i['G'] / der[loop]) }]) + print ('palette: %s',i) + sleep(2) + +pwm1.write_register( register = 'PWM2', bits = [{'PWM' : '0' }]) +pwm1.write_register( register = 'PWM1', bits = [{'PWM' : '0' }]) +pwm1.write_register( register = 'PWM0', bits = [{'PWM' : '0' }]) + +pwm2.write_register( register = 'PWM2', bits = [{'PWM' : '0' }]) +pwm2.write_register( register = 'PWM1', bits = [{'PWM' : '0' }]) +pwm2.write_register( register = 'PWM0', bits = [{'PWM' : '0' }]) + +