class Math(CRUDMixin, db.Model):
__tablename__ = "math"
id = db.Column(db.Integer, unique=True, primary_key=True)
unique_id = db.Column(db.String,
nullable=False,
unique=True,
default=set_uuid) # ID for influxdb entries
name = db.Column(db.Text, default='Input Name')
math_type = db.Column(db.Text, default=None)
is_activated = db.Column(db.Boolean, default=False)
period = db.Column(db.Float, default=15.0) # Duration between readings
inputs = db.Column(db.Text, default='')
max_measure_age = db.Column(db.Integer, default=60.0)
measure = db.Column(db.Text, default='Measurement')
measure_units = db.Column(db.Text, default='unit')
def is_active(self):
"""
:return: Whether the sensor is currently activated
:rtype: bool
"""
return self.is_activated
def __repr__(self):
return "<{cls}(id={s.id})>".format(s=self, cls=self.__class__.__name__)
class Dashboard(CRUDMixin, db.Model):
__tablename__ = "dashboard"
__table_args__ = {'extend_existing': True}
id = db.Column(db.Integer, unique=True, primary_key=True)
unique_id = db.Column(db.String, nullable=False, unique=True, default=set_uuid)
name = db.Column(db.Text, nullable=False, unique=True)
class Function(CRUDMixin, db.Model):
__tablename__ = "function"
__table_args__ = {'extend_existing': True}
id = db.Column(db.Integer, unique=True, primary_key=True)
unique_id = db.Column(db.String, nullable=False, unique=True, default=set_uuid)
function_type = db.Column(db.Text, default='')
name = db.Column(db.Text, default='Function Name')
class EnergyUsage(CRUDMixin, db.Model):
__tablename__ = "energy_usage"
__table_args__ = {'extend_existing': True}
id = db.Column(db.Integer, unique=True, primary_key=True)
unique_id = db.Column(db.String, nullable=False, unique=True, default=set_uuid) # ID for influxdb entries
name = db.Column(db.Text, default='Name')
device_id = db.Column(db.Text, default='')
measurement_id = db.Column(db.Text, db.ForeignKey('device_measurements.unique_id'), default='')
class Method(CRUDMixin, db.Model):
__tablename__ = "method"
id = db.Column(db.Integer, unique=True, primary_key=True)
name = db.Column(db.Text, default='Method')
method_type = db.Column(db.Text, default='')
method_order = db.Column(db.Text, default='')
def __repr__(self):
return "<{cls}(id={s.id})>".format(s=self, cls=self.__class__.__name__)
class ConditionalConditions(CRUDMixin, db.Model):
__tablename__ = "conditional_data"
__table_args__ = {'extend_existing': True}
id = db.Column(db.Integer, unique=True, primary_key=True)
unique_id = db.Column(db.String,
nullable=False,
unique=True,
default=set_uuid)
conditional_id = db.Column(db.String,
db.ForeignKey('conditional.unique_id'),
default=None)
condition_type = db.Column(db.Text, default=None)
# Sensor/Math
measurement = db.Column(db.Text,
default='') # which measurement to monitor
max_age = db.Column(db.Integer, default=120) # max age of the measurement
# GPIO State
gpio_pin = db.Column(db.Integer, default=0)
# Output State
output_id = db.Column(db.Text, default='')
# Controller
controller_id = db.Column(db.Text, default='')
def __repr__(self):
return "<{cls}(id={s.id})>".format(s=self, cls=self.__class__.__name__)
class Remote(CRUDMixin, db.Model):
__tablename__ = "remote"
id = db.Column(db.Integer, unique=True, primary_key=True)
is_activated = db.Column(db.Boolean, default=False)
host = db.Column(db.Text, default='')
username = db.Column(db.Text, default='')
password_hash = db.Column(db.Text, default='')
def __reper__(self):
return "<{cls}(id={s.id})>".format(s=self, cls=self.__class__.__name__)
class Measurement(CRUDMixin, db.Model):
__tablename__ = "measurements"
__table_args__ = {'extend_existing': True}
id = db.Column(db.Integer, unique=True, primary_key=True)
unique_id = db.Column(db.String, nullable=False, unique=True, default=set_uuid)
name_safe = db.Column(db.Text)
name = db.Column(db.Text)
units = db.Column(db.Text)
def __repr__(self):
return "<{cls}(id={s.id})>".format(s=self, cls=self.__class__.__name__)
class Method(CRUDMixin, db.Model):
__tablename__ = "method"
__table_args__ = {'extend_existing': True}
id = db.Column(db.Integer, unique=True, primary_key=True)
unique_id = db.Column(db.String, nullable=False, unique=True, default=set_uuid)
name = db.Column(db.Text, default='Method')
method_type = db.Column(db.Text, default='')
method_order = db.Column(db.Text, default='')
def __repr__(self):
return "<{cls}(id={s.id})>".format(s=self, cls=self.__class__.__name__)
class NoteTags(CRUDMixin, db.Model):
__tablename__ = "note_tags"
__table_args__ = {'extend_existing': True}
id = db.Column(db.Integer, unique=True, primary_key=True)
unique_id = db.Column(db.String,
nullable=False,
unique=True,
default=set_uuid) # ID for influxdb entries
name = db.Column(db.Text, default=None)
def __repr__(self):
return "<{cls}(id={s.id})>".format(s=self, cls=self.__class__.__name__)
class Conversion(CRUDMixin, db.Model):
__tablename__ = "conversion"
__table_args__ = {'extend_existing': True}
id = db.Column(db.Integer, unique=True, primary_key=True)
unique_id = db.Column(db.String,
nullable=False,
unique=True,
default=set_uuid)
convert_unit_from = db.Column(db.Text)
convert_unit_to = db.Column(db.Text)
equation = db.Column(db.Text)
def __repr__(self):
return "<{cls}(id={s.id})>".format(s=self, cls=self.__class__.__name__)
class DisplayOrder(CRUDMixin, db.Model):
__tablename__ = "displayorder"
id = db.Column(db.Integer, unique=True, primary_key=True)
graph = db.Column(db.Text, default='')
lcd = db.Column(db.Text, default='')
math = db.Column(db.Text, default='')
method = db.Column(db.Text, default='')
pid = db.Column(db.Text, default='')
relay = db.Column(db.Text, default='')
remote_host = db.Column(db.Text, default='')
sensor = db.Column(db.Text, default='')
timer = db.Column(db.Text, default='')
def __repr__(self):
return "<{cls}(id={s.id})>".format(s=self, cls=self.__class__.__name__)
class Conditional(CRUDMixin, db.Model):
__tablename__ = "conditional"
__table_args__ = {'extend_existing': True}
id = db.Column(db.Integer, unique=True, primary_key=True)
unique_id = db.Column(db.String, nullable=False, unique=True, default=set_uuid)
name = db.Column(db.Text, default='Conditional')
is_activated = db.Column(db.Boolean, default=False)
log_level_debug = db.Column(db.Boolean, default=False)
conditional_statement = db.Column(db.Text, default='')
period = db.Column(db.Float, default=60.0)
start_offset = db.Column(db.Float, default=10.0)
message_include_code = db.Column(db.Boolean, default=False)
custom_options = db.Column(db.Text, default='')
class LCD(CRUDMixin, db.Model):
__tablename__ = "lcd"
id = db.Column(db.Integer, unique=True, primary_key=True)
name = db.Column(db.Text, default='LCD')
is_activated = db.Column(db.Boolean, default=False)
period = db.Column(db.Float, default=30.0)
location = db.Column(db.Text, default='27')
i2c_bus = db.Column(db.Integer, default=1)
multiplexer_address = db.Column(db.Text, default='')
multiplexer_channel = db.Column(db.Integer, default=0)
x_characters = db.Column(db.Integer, default=16)
y_lines = db.Column(db.Integer, default=2)
def __repr__(self):
return "<{cls}(id={s.id})>".format(s=self, cls=self.__class__.__name__)
class Timer(CRUDMixin, db.Model):
__tablename__ = "timer"
id = db.Column(db.Integer, unique=True, primary_key=True)
name = db.Column(db.Text, default='Timer')
is_activated = db.Column(db.Boolean, default=False)
timer_type = db.Column(db.Text, default=None)
relay_id = db.Column(db.Integer, db.ForeignKey('relay.id'), default=None)
state = db.Column(db.Text, default=None) # 'on' or 'off'
time_start = db.Column(db.Text, default=None)
time_end = db.Column(db.Text, default=None)
duration_on = db.Column(db.Float, default=None)
duration_off = db.Column(db.Float, default=None)
def __reper__(self):
return "<{cls}(id={s.id})>".format(s=self, cls=self.__class__.__name__)
class DisplayOrder(CRUDMixin, db.Model):
__tablename__ = "displayorder"
__table_args__ = {'extend_existing': True}
id = db.Column(db.Integer, unique=True, primary_key=True)
dashboard = db.Column(db.Text, default='')
function = db.Column(db.Text, default='')
inputs = db.Column(db.Text, default='')
lcd = db.Column(db.Text, default='')
math = db.Column(db.Text, default='')
method = db.Column(db.Text, default='')
output = db.Column(db.Text, default='')
remote_host = db.Column(db.Text, default='')
timer = db.Column(db.Text, default='')
def __repr__(self):
return "<{cls}(id={s.id})>".format(s=self, cls=self.__class__.__name__)
class MQTT(CRUDMixin, db.Model):
__tablename__ = "mqtt"
__table_args__ = {'extend_existing': True}
id = db.Column(db.Integer, unique=True, primary_key=True)
hostname = db.Column(db.Text, default='localhost')
port = db.Column(db.Integer, default=1883)
user = db.Column(db.Text, default='mycodo')
passw = db.Column(db.Text, default='password')
clientid = db.Column(db.Text, default='mycodo')
keep_alive = db.Column(db.Integer, default=60)
message_count = db.Column(db.Integer, default=0)
topic_prefix = db.Column(db.Text, default='mycodo/')
enabled = db.Column(db.Integer, default=0)
def __repr__(self):
return "<{cls}(id={s.id})>".format(s=self, cls=self.__class__.__name__)
class AlembicVersion(CRUDMixin, db.Model):
__tablename__ = "alembic_version"
__table_args__ = {'extend_existing': True}
version_num = db.Column(db.String(32), primary_key=True, nullable=False, default=config.ALEMBIC_VERSION)
def __repr__(self):
return "<{cls}(version_number={s.version_num})>".format(s=self, cls=self.__class__.__name__)
class SMTP(CRUDMixin, db.Model):
__tablename__ = "smtp"
__table_args__ = {'extend_existing': True}
id = db.Column(db.Integer, unique=True, primary_key=True)
host = db.Column(db.Text, default='smtp.gmail.com')
ssl = db.Column(db.Boolean, default=1)
port = db.Column(db.Integer, default=465)
user = db.Column(db.Text, default='*****@*****.**')
passw = db.Column(db.Text, default='password')
email_from = db.Column(db.Text, default='*****@*****.**')
hourly_max = db.Column(db.Integer, default=5)
email_count = db.Column(db.Integer, default=0)
smtp_wait_timer = db.Column(db.Integer, default=0)
def __repr__(self):
return "<{cls}(id={s.id})>".format(s=self, cls=self.__class__.__name__)
class User(UserMixin, CRUDMixin, db.Model):
__tablename__ = "users"
__table_args__ = {'extend_existing': True}
id = db.Column(db.Integer, primary_key=True)
unique_id = db.Column(db.String,
nullable=False,
unique=True,
default=set_uuid)
name = db.Column(db.VARCHAR(64), unique=True, index=True)
password_hash = db.Column(db.VARCHAR(255))
api_key = db.Column(db.BLOB, unique=True)
email = db.Column(db.VARCHAR(64), unique=True, index=True)
role_id = db.Column(db.Integer, db.ForeignKey('roles.id'), default=None)
theme = db.Column(db.VARCHAR(64))
landing_page = db.Column(db.Text, default='live')
language = db.Column(
db.Text,
default=None) # Force the web interface to use a specific language
# roles = db.relationship("Role", back_populates="user")
def __repr__(self):
output = "<User: <name='{name}', email='{email}' is_admin='{isadmin}'>"
return output.format(name=self.name,
email=self.email,
isadmin=bool(self.role_id == 1))
def set_password(self, new_password):
""" saves a password hash """
if isinstance(new_password, str):
new_password = new_password.encode('utf-8')
self.password_hash = bcrypt.hashpw(new_password, bcrypt.gensalt())
@staticmethod
def check_password(password, hashed_password):
""" validates a password """
# Check type of password hashed_password to determine if it is a str
# and should be encoded
if isinstance(password, str):
password = password.encode('utf-8')
if isinstance(hashed_password, str):
hashed_password = hashed_password.encode('utf-8')
hashes_match = bcrypt.hashpw(password, hashed_password)
return hashes_match
class User(UserMixin, CRUDMixin, db.Model):
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.VARCHAR(64), unique=True, index=True)
password_hash = db.Column(db.VARCHAR(255))
email = db.Column(db.VARCHAR(64), unique=True, index=True)
role = db.Column(db.Integer, db.ForeignKey('roles.id'), default=None)
theme = db.Column(db.VARCHAR(64))
language = db.Column(
db.Text,
default=None) # Force the web interface to use a specific language
roles = db.relationship("Role", back_populates="user")
def __repr__(self):
output = "<User: <name='{name}', email='{email}' is_admin='{isadmin}'>"
return output.format(name=self.name,
email=self.email,
isadmin=bool(self.role == 1))
def set_password(self, new_password):
""" saves a password hash """
self.password_hash = bcrypt.hashpw(new_password.encode('utf-8'),
bcrypt.gensalt())
@staticmethod
def check_password(password, hashed_password):
""" validates a password """
hashes_match = bcrypt.hashpw(password.encode('utf-8'),
hashed_password.encode('utf-8'))
return hashes_match
class CustomController(CRUDMixin, db.Model):
__tablename__ = "custom_controller"
__table_args__ = {'extend_existing': True}
id = db.Column(db.Integer, unique=True, primary_key=True)
unique_id = db.Column(db.String,
nullable=False,
unique=True,
default=set_uuid)
name = db.Column(db.Text, default='Conditional')
device = db.Column(db.Text, default='')
is_activated = db.Column(db.Boolean, default=False)
log_level_debug = db.Column(db.Boolean, default=False)
custom_options = db.Column(db.Text, default='')
def is_active(self):
"""
:return: Whether the sensor is currently activated
:rtype: bool
"""
return self.is_activated
def __repr__(self):
return "<{cls}(id={s.id})>".format(s=self, cls=self.__class__.__name__)
class ConditionalActions(CRUDMixin, db.Model):
__tablename__ = "conditional_data"
__table_args__ = {'extend_existing': True}
id = db.Column(db.Integer, unique=True, primary_key=True)
unique_id = db.Column(db.String, nullable=False, unique=True, default=set_uuid)
conditional_id = db.Column(db.String, db.ForeignKey('conditional.unique_id'), default=None)
# Actions
do_unique_id = db.Column(db.Text, default='')
do_action = db.Column(db.Text, default='') # what action, such as 'email', 'execute command', 'flash LCD'
do_action_string = db.Column(db.Text, default='') # string, such as the email address or command
do_output_state = db.Column(db.Text, default='') # 'on' or 'off'
do_output_duration = db.Column(db.Float, default=0.0)
do_output_pwm = db.Column(db.Float, default=0.0)
do_camera_duration = db.Column(db.Float, default=0.0)
def __repr__(self):
return "<{cls}(id={s.id})>".format(s=self, cls=self.__class__.__name__)
class LCD(CRUDMixin, db.Model):
__tablename__ = "lcd"
__table_args__ = {'extend_existing': True}
id = db.Column(db.Integer, unique=True, primary_key=True)
unique_id = db.Column(db.String, nullable=False, unique=True, default=set_uuid)
name = db.Column(db.Text, default='LCD')
is_activated = db.Column(db.Boolean, default=False)
period = db.Column(db.Float, default=30.0)
location = db.Column(db.Text, default='27')
i2c_bus = db.Column(db.Integer, default=1)
x_characters = db.Column(db.Integer, default=16)
y_lines = db.Column(db.Integer, default=2)
def __repr__(self):
return "<{cls}(id={s.id})>".format(s=self, cls=self.__class__.__name__)
class Role(CRUDMixin, db.Model):
__tablename__ = "roles"
id = db.Column(db.Integer, unique=True, primary_key=True)
name = db.Column(db.String, nullable=False, unique=True)
edit_settings = db.Column(db.Boolean, nullable=False, default=False)
edit_controllers = db.Column(db.Boolean, nullable=False, default=False)
edit_users = db.Column(db.Boolean, nullable=False, default=False)
view_settings = db.Column(db.Boolean, nullable=False, default=False)
view_camera = db.Column(db.Boolean, nullable=False, default=False)
view_stats = db.Column(db.Boolean, nullable=False, default=False)
view_logs = db.Column(db.Boolean, nullable=False, default=False)
user = db.relationship("User", back_populates="roles")
def __repr__(self):
return "<{cls}(id={s.id}, name='{s.name}')>".format(
s=self, cls=self.__class__.__name__)
class FunctionChannel(CRUDMixin, db.Model):
__tablename__ = "function_channel"
__table_args__ = {'extend_existing': True}
id = db.Column(db.Integer, unique=True, primary_key=True)
unique_id = db.Column(db.String, nullable=False, unique=True, default=set_uuid)
function_id = db.Column(db.Text, default=None)
channel = db.Column(db.Integer, default=None)
name = db.Column(db.Text, default='')
custom_options = db.Column(db.Text, default='')
def __repr__(self):
return "<{cls}(id={s.id})>".format(s=self, cls=self.__class__.__name__)
class Remote(CRUDMixin, db.Model):
__tablename__ = "remote"
__table_args__ = {'extend_existing': True}
id = db.Column(db.Integer, unique=True, primary_key=True)
unique_id = db.Column(db.String,
nullable=False,
unique=True,
default=set_uuid)
is_activated = db.Column(db.Boolean, default=False)
host = db.Column(db.Text, default='')
username = db.Column(db.Text, default='')
password_hash = db.Column(db.Text, default='')
def __repr__(self):
return "<{cls}(id={s.id})>".format(s=self, cls=self.__class__.__name__)
class Input(CRUDMixin, db.Model):
__tablename__ = "input"
__table_args__ = {'extend_existing': True}
id = db.Column(db.Integer, unique=True, primary_key=True)
unique_id = db.Column(db.String,
nullable=False,
unique=True,
default=set_uuid)
name = db.Column(db.Text, default='Input Name')
is_activated = db.Column(db.Boolean, default=False)
log_level_debug = db.Column(db.Boolean, default=False)
is_preset = db.Column(db.Boolean,
default=False) # Is config saved as a preset?
preset_name = db.Column(db.Text, default=None) # Name for preset
device = db.Column(
db.Text, default='') # Device name, such as DHT11, DHT22, DS18B20
interface = db.Column(
db.Text, default=None) # Communication interface (I2C, UART, etc.)
period = db.Column(db.Float, default=15.0) # Duration between readings
start_offset = db.Column(db.Float, default=0.0)
power_output_id = db.Column(db.String, default=None)
resolution = db.Column(db.Integer, default=0)
resolution_2 = db.Column(db.Integer, default=0)
sensitivity = db.Column(db.Integer, default=0)
thermocouple_type = db.Column(db.Text, default=None)
ref_ohm = db.Column(db.Integer, default=None)
calibrate_sensor_measure = db.Column(
db.Text, default=None) # sensor ID and measurement (CSV)
location = db.Column(
db.Text,
default='') # GPIO pin or i2c address to communicate with sensor
gpio_location = db.Column(
db.Integer, default=None) # Pin location for GPIO communication
# I2C
i2c_location = db.Column(
db.Text, default=None) # Address location for I2C communication
i2c_bus = db.Column(db.Integer,
default=1) # I2C bus the sensor is connected to
# FTDI
ftdi_location = db.Column(
db.Text, default=None) # Device location for FTDI communication
# Communication (SPI)
uart_location = db.Column(
db.Text, default=None) # Device location for UART communication
baud_rate = db.Column(db.Integer,
default=None) # Baud rate for UART communication
pin_clock = db.Column(db.Integer, default=None)
pin_cs = db.Column(db.Integer, default=None)
pin_mosi = db.Column(db.Integer, default=None)
pin_miso = db.Column(db.Integer, default=None)
# Communication (Bluetooth)
bt_adapter = db.Column(db.Text, default='hci0')
# Switch options
switch_edge = db.Column(db.Text, default='rising')
switch_bouncetime = db.Column(db.Integer, default=50)
switch_reset_period = db.Column(db.Integer, default=10)
# Pre-measurement output options
pre_output_id = db.Column(
db.String, db.ForeignKey('output.unique_id'),
default=None) # Output to turn on before sensor read
pre_output_duration = db.Column(
db.Float, default=0.0) # Duration to turn output on before sensor read
pre_output_during_measure = db.Column(db.Boolean, default=True)
# SHT sensor options
sht_voltage = db.Column(db.Text, default='3.5')
# Analog to digital converter options
adc_gain = db.Column(db.Integer, default=1)
adc_resolution = db.Column(db.Integer, default=18)
adc_sample_speed = db.Column(db.Text, default='')
# Command options
cmd_command = db.Column(db.Text, default=None)
# PWM and RPM options
weighting = db.Column(db.Float, default=0.0)
rpm_pulses_per_rev = db.Column(db.Float, default=1.0)
sample_time = db.Column(db.Float, default=2.0)
# Server options
port = db.Column(db.Integer, default=80)
times_check = db.Column(db.Integer, default=1)
deadline = db.Column(db.Integer, default=2)
# The Things Network: Data Storage
datetime = db.Column(db.DateTime, default=None)
custom_options = db.Column(db.Text, default='')
def is_active(self):
"""
:return: Whether the sensor is currently activated
:rtype: bool
"""
return self.is_activated
def __repr__(self):
return "<{cls}(id={s.id})>".format(s=self, cls=self.__class__.__name__)
class LCDData(CRUDMixin, db.Model):
__tablename__ = "lcd_data"
__table_args__ = {'extend_existing': True}
id = db.Column(db.Integer, unique=True, primary_key=True)
unique_id = db.Column(db.String,
nullable=False,
unique=True,
default=set_uuid)
lcd_id = db.Column(db.String, db.ForeignKey('lcd.unique_id'), default=None)
line_1_id = db.Column(db.Text, default='')
line_1_type = db.Column(db.Text, default='')
line_1_measurement = db.Column(db.Text, default='')
line_1_max_age = db.Column(db.Integer, default=360)
line_1_decimal_places = db.Column(db.Integer, default=2)
line_2_id = db.Column(db.Text, default='')
line_2_type = db.Column(db.Text, default='')
line_2_measurement = db.Column(db.Text, default='')
line_2_max_age = db.Column(db.Integer, default=360)
line_2_decimal_places = db.Column(db.Integer, default=2)
line_3_id = db.Column(db.Text, default='')
line_3_type = db.Column(db.Text, default='')
line_3_measurement = db.Column(db.Text, default='')
line_3_max_age = db.Column(db.Integer, default=360)
line_3_decimal_places = db.Column(db.Integer, default=2)
line_4_id = db.Column(db.Text, default='')
line_4_type = db.Column(db.Text, default='')
line_4_measurement = db.Column(db.Text, default='')
line_4_max_age = db.Column(db.Integer, default=360)
line_4_decimal_places = db.Column(db.Integer, default=2)
line_5_id = db.Column(db.Text, default='')
line_5_type = db.Column(db.Text, default='')
line_5_measurement = db.Column(db.Text, default='')
line_5_max_age = db.Column(db.Integer, default=360)
line_5_decimal_places = db.Column(db.Integer, default=2)
line_6_id = db.Column(db.Text, default='')
line_6_type = db.Column(db.Text, default='')
line_6_measurement = db.Column(db.Text, default='')
line_6_max_age = db.Column(db.Integer, default=360)
line_6_decimal_places = db.Column(db.Integer, default=2)
line_7_id = db.Column(db.Text, default='')
line_7_type = db.Column(db.Text, default='')
line_7_measurement = db.Column(db.Text, default='')
line_7_max_age = db.Column(db.Integer, default=360)
line_7_decimal_places = db.Column(db.Integer, default=2)
line_8_id = db.Column(db.Text, default='')
line_8_type = db.Column(db.Text, default='')
line_8_measurement = db.Column(db.Text, default='')
line_8_max_age = db.Column(db.Integer, default=360)
line_8_decimal_places = db.Column(db.Integer, default=2)
def __repr__(self):
return "<{cls}(id={s.id})>".format(s=self, cls=self.__class__.__name__)
class Sensor(CRUDMixin, db.Model):
__tablename__ = "sensor"
id = db.Column(db.Integer, unique=True, primary_key=True)
unique_id = db.Column(db.String,
nullable=False,
unique=True,
default=set_uuid) # ID for influxdb entries
name = db.Column(db.Text, default='Sensor')
is_activated = db.Column(db.Boolean, default=False)
is_preset = db.Column(db.Boolean,
default=False) # Is config saved as a preset?
preset_name = db.Column(db.Text, default=None) # Name for preset
device = db.Column(
db.Text, default='') # Device name, such as DHT11, DHT22, DS18B20
interface = db.Column(
db.Text, default=None) # Communication interface (I2C, UART, etc.)
device_loc = db.Column(
db.Text, default=None) # Device location for UART communication
calibrate_sensor_measure = db.Column(
db.Text, default=None) # sensor ID and measurement (CSV)
baud_rate = db.Column(db.Integer,
default=None) # Baud rate for UART communication
period = db.Column(db.Float, default=15.0) # Duration between readings
i2c_bus = db.Column(db.Integer,
default='') # I2C bus the sensor is connected to
location = db.Column(
db.Text,
default='') # GPIO pin or i2c address to communicate with sensor
power_relay_id = db.Column(db.Integer,
db.ForeignKey('relay.id'),
default=None) # Relay to power sensor
measurements = db.Column(db.Text,
default='') # Measurements separated by commas
resolution = db.Column(db.Integer, default=0)
sensitivity = db.Column(db.Integer, default=0)
# Multiplexer options
multiplexer_address = db.Column(db.Text, default=None)
multiplexer_bus = db.Column(db.Integer, default=1)
multiplexer_channel = db.Column(db.Integer, default=0)
# Switch options
switch_edge = db.Column(db.Text, default='rising')
switch_bouncetime = db.Column(db.Integer, default=50)
switch_reset_period = db.Column(db.Integer, default=10)
# Pre-measurement relay options
pre_relay_id = db.Column(
db.Integer, db.ForeignKey('relay.id'),
default=None) # Relay to turn on before sensor read
pre_relay_duration = db.Column(
db.Float, default=0.0) # Duration to turn relay on before sensor read
# SHT sensor options
sht_clock_pin = db.Column(db.Integer, default=0)
sht_voltage = db.Column(db.Text, default='3.5')
# Analog to digital converter options
adc_channel = db.Column(db.Integer, default=0)
adc_gain = db.Column(db.Integer, default=1)
adc_resolution = db.Column(db.Integer, default=18)
adc_measure = db.Column(db.Text, default='Condition')
adc_measure_units = db.Column(db.Text, default='unit')
adc_volts_min = db.Column(db.Float, default=None)
adc_volts_max = db.Column(db.Float, default=None)
adc_units_min = db.Column(db.Float, default=0)
adc_units_max = db.Column(db.Float, default=10)
def is_active(self):
"""
:return: Whether the sensor is currently activated
:rtype: bool
"""
return self.is_activated
def __reper__(self):
return "<{cls}(id={s.id})>".format(s=self, cls=self.__class__.__name__)
