def __init__(self, database):
Mode.__init__(self, database, "curtain")
self.__lock = threading.RLock()
self.__r1 = Relay(self.R1_GPIO_PIN)
self.__r2 = Relay(self.R2_GPIO_PIN)
self.__timer = None
self.stop()
def add_relay(self, name, neighbours):
'''
A relay is used to route the sparks across the network.
This method creates a new relay and updates the cortex network graph.
'''
# Input validation
name = str(name)
if name is None: return False
#if not isinstance(channels, list): return False
if not isinstance(neighbours, list): return False
# Add to graph
if name not in self.graph:
self.graph[name] = list()
self.graph[name].extend(str(neighbour) for neighbour in neighbours)
#self.trace('debug', ("Relay " + name + " not in graph, adding now "))
self.trace_debug("Relay " + name + " not in graph, adding now ")
else:
# Add all the neighbours to this relays graph, which haven't already been added
self.trace_debug("Relay " + name + " IS in graph")
for neighbour in neighbours:
if str(neighbour) not in self.graph[name]:
self.trace_debug("Relay " + name +
" IS in graph, neighbour " +
str(neighbour) +
" is being added to this relays graph")
self.graph[name].append(str(neighbour))
# Add to relays
if name not in self.relays:
self.trace_debug("Relay " + name + " not in relays, adding it now")
self.relays[name] = Relay(name=name)
# Add neighbours to graph, with this name as a neighbour
for neighbour in neighbours:
if str(neighbour) not in self.graph:
self.trace_debug("Relay " + name + " neighbour " +
str(neighbour) + " not in graph, adding now ")
self.graph[str(neighbour)] = list()
self.graph[str(neighbour)].append(name)
else:
# Neighbour is in graph, now make sure this relay is in that neighbours graph
if name not in self.graph[str(neighbour)]:
self.trace_debug("Relay " + name + " not in " +
str(neighbour) + "'s graph, adding now ")
self.graph[str(neighbour)].append(name)
# Add neighbours to relays
for neighbour in neighbours:
if str(neighbour) not in self.relays:
self.trace_debug("Relay " + name + " neighbour " +
str(neighbour) +
" not in self.relays, adding now ")
self.relays[str(neighbour)] = Relay(name=str(neighbour))
self.trace_line_debug()
def read_config():
# Example
#
# relays:
# - bus: 1
# data_address: 0
# description: ''
# device_address: 16
# name: Relay_0
# notes: ''
if os.path.exists(CONFIG_FILE):
# Read existing config
print("Reading " + CONFIG_FILE)
with open(CONFIG_FILE, 'r') as stream:
config = yaml.safe_load(stream)
relays_raw = config['relays']
for relay_raw in relays_raw:
Relays.append(Relay(**relay_raw))
else:
# Generate default config
print("Creating " + CONFIG_FILE)
config = {}
config['relays'] = []
# Save initial config
Relays.write_config()
def test_timed_switch(self):
relay = Relay("timeout_test", 3, 5)
relay.switchOn(8)
self.assertTrue(relay.time_remaining()>6)
self.assertTrue(relay.timer.is_alive())
time.sleep(8.1)
self.assertFalse(relay.timer.is_alive())
class Robot:
dcmotor = DC()
relay = Relay()
sensor = UltrasonicSensor()
status = 0
robotIsRight = True
def get_distance(self):
self.relay.switchRelay(1)
self.dcmotor.forward()
self.status = 1
while self.robotIsRight:
time.sleep(0.5)
dist = self.sensor.distance()
print(str(dist))
if dist < 10:
self.motorStop()
self.status = 0
else:
self.relay.switchRelay(1)
self.dcmotor.forward()
def startProgram(self):
x = threading.Thread(target=self.get_distance).start()
def motorStop(self):
self.dcmotor.stop()
self.relay.switchRelay(0)
def _initEmptyBoard(self):
"""
:return: the initialized board
"""
board = [[Square(None, i, j) for j in range(5)] for i in range(5)]
board[0][0] = Square(Note(False), 0, 0)
board[0][1] = Square(Governance(False), 0, 1)
board[0][2] = Square(Relay(False), 0, 2)
board[0][3] = Square(Shield(False), 0, 3)
board[0][4] = Square(Drive(False), 0, 4)
board[1][4] = Square(Preview(False), 1, 4)
board[3][0] = Square(Preview(True), 3, 0)
board[4][0] = Square(Drive(True), 4, 0)
board[4][1] = Square(Shield(True), 4, 1)
board[4][2] = Square(Relay(True), 4, 2)
board[4][3] = Square(Governance(True), 4, 3)
board[4][4] = Square(Note(True), 4, 4)
return board
def GetRelays():
configLines = GetConfigLines()
relayDict = eval(configLines[1])
relays = {}
for key, value in relayDict.iteritems():
relay = Relay(key, value)
relays[key] = relay
return relays
def __init__(self, *args, **kwargs):
self.args = args
self.kwargs = kwargs
PowerController._count += 1
self.id = PowerController._count
self.relays = []
for relay in self.settings['relays']:
self.relays.append(Relay(PIN=relay['PIN']))
def __init__(self):
self._settings = Settings()
self._status = Status()
self._program = Program()
self._hold_timer = None
self._step_timer = None
self._heat_timer = None
self._record_timer = None
self._history = []
self._lamp_on_time = 0
self._lamp_on_temp = 0
self._program_start_time = 0.0
self._step_start_time = 0.0
self._record_start_time = 0.0
self._heat = Relay(heat_pin)
self._vacuum = Relay(vacuum_pin)
self._callback = None
self._recording = False
self._last_temp = 0.0
def test_switch_off(self):
relay = Relay("switchoff_test", 4, 5)
relay.switchOn()
self.assertTrue(relay.time_remaining()>3)
self.assertTrue(relay.timer.is_alive())
relay.switchOff()
time.sleep(0.5)
self.assertFalse(relay.timer.is_alive())
self.assertFalse(relay.state)
self.assertTrue(relay.time_remaining()==0)
def __init__(self, config, verbose=0):
self.verbose = verbose
# ------------------------------------------------------------------------------------------------------------ #
self.exit = False
self.config = config
# ------------------------------------------------------------------------------------------------------------ #
self.sleep_ms = self.SLEEP_MS_DEFAULT
# ------------------------------------------------------------------------------------------------------------ #
# Initialise required services
# ------------------------------------------------------------------------------------------------------------ #
if self.config['pinout']['led'] is None:
from led import MockLed
self.led = MockLed()
else:
from led import Led
self.led = Led(self.config['pinout']['led']['pin'],
self.config['pinout']['led']['on_level'])
# ------------------------------------------------------------------------------------------------------------ #
if self.config['pinout']['button'] is None:
from button import MockButton
self.button = MockButton()
else:
from button import Button
self.button = Button(self.config['pinout']['button']['pin'],
self.config['pinout']['button']['on_level'])
# ------------------------------------------------------------------------------------------------------------ #
if self.config['pinout']['relay'] is None:
from relay import MockRelay
self.relay = MockRelay()
else:
from relay import Relay
self.relay = Relay(self.config['pinout']['relay']['pin'],
self.config['pinout']['relay']['on_level'])
# ------------------------------------------------------------------------------------------------------------ #
self.wifi = WiFi(self.config) # , verbose=self.verbose)
self.device_id = self.wifi.device_id()
self.messaging = Messaging(self.config, self.device_id)
# ------------------------------------------------------------------------------------------------------------ #
# Application ready feedback --------------------------------------------------------------------------------- #
self.led.on(poll=True)
sleep(2)
self.led.off(poll=True)
# ------------------------------------------------------------------------------------------------------------ #
if self.wifi.connected():
self.on_wifi_connected(be_verbose=False)
# ------------------------------------------------------------------------------------------------------------ #
if self.verbose:
print('<{} with id {}>'.format(self.config['device']['type'],
self.device_id))
print(self.led)
print(self.button)
print(self.relay)
print(self.wifi)
print(self.messaging)
def __init__(self, hostname, pin=2):
self.__wlan = None
self.__timeout = DEFAULT_TMOUT
self.__led = Relay(pin)
self.is_ok = False
self.gw = None
self.ip = None
self.dns = None
ConfigOp.__init__(self, 'wifi', CONFIG_NAME)
self.add_command(self.__get_info, GET)
self.add_command(self.__reconnect, SET, 'reconnect')
self.__hostname = hostname
def __init__(self, settings_path):
self.settings_path = settings_path
# load settings
self.settings = settings_handler.load_settings(settings_path)
# arrange paths
self.program_path = self.settings['paths']['program']
self.examples_path = self.settings['paths']['examples']
self.daily_log_path = self.settings['paths']['daily_log']
# get intervals
self.thermometer_poll = self.settings['poll_intervals']['temperature']
self.time_to_wait = self.settings['poll_intervals']['settings']
# parameters for UDP communication with thermometer
self.UDP_IP = self.settings['configs']['UDP_IP']
self.UDP_port = self.settings['configs']['UDP_port']
self.thermometer = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
self.thermometer.settimeout(1)
self.thermometer.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.temperature = self.settings['temperatures']['room']
# handle day change
if (self.settings['log']['last_day_on'] !=
util.get_now()['formatted_date']):
self.time_elapsed = 0
util.write_log(
self.daily_log_path, {
'date': self.settings['log']['last_day_on'],
'time_elapsed': util.format_seconds(self.time_elapsed)
})
self.time_elapsed = 0
else:
time_elapsed_restore = datetime.datetime.strptime(
self.settings['log'].get('time_elapsed', '0:00:00'),
'%H:%M:%S')
self.time_elapsed = round(
datetime.timedelta(
hours=time_elapsed_restore.hour,
minutes=time_elapsed_restore.minute,
seconds=time_elapsed_restore.second).total_seconds())
self.program_number = self.settings['mode']['program']
relay_settings = self.settings['relay']
self.heater_switch = Relay(relay_settings, self.settings_path)
self.last_current = None
self.loop_count = 0
self.count_start = time.perf_counter()
def test_relay_timeouts(self):
relay = Relay("default_timeout_test", 2, 5)
relay.switchOn()
self.assertTrue(relay.timer.is_alive())
self.assertTrue(relay.time_remaining()>0)
time.sleep(5.1)
self.assertFalse(relay.timer.is_alive())
self.assertTrue(relay.time_remaining()==0)
relay.switchOn()
self.assertTrue(relay.time_remaining()>3)
time.sleep(2)
relay.switchOn()
self.assertTrue(relay.time_remaining()>3)
def application():
# Temperature sensor device
from ds18b20 import sensor, TempSensor
sensor = TempSensor()
from register import register, Register
rurl = config.get_config('register')
auth = config.get_config('authorization')
if rurl:
register = Register(rurl, auth)
# Pir device
from pir import pir, PirDevice
pir = PirDevice()
# Relaye device
from relay import relay, Relay
pin = config.get_config('relay-pin')
try:
p = int(pin)
except:
p = 14
relay = Relay(p)
# The range application
from ranges import ranges, Ranges
ranges = Ranges()
r = config.get_config('ranges')
if r:
ranges.set(r)
# The control
from control import control, Control
timeout = config.get_config('timeout')
if not timeout: timeout = 20
control = Control(timeout)
# Http Server
from httpserver import Server
server = Server() # construct server object
server.activate(8805) # server activate with
try:
server.wait_connections(interface, 0) # activate and run for a while
control.loop()
except KeyboardInterrupt:
pass
except Exception as e:
sys.print_exception(e)
print(e)
async def test_async():
relay = Relay(2)
relay.on()
print("on")
asyncio.sleep(1)
relay.off()
print("off")
asyncio.sleep(1)
asyncio.create_task(relay.async_blink())
for i in range(0,10):
print(i)
if i == 5:
relay.stop_async_blink()
await asyncio.sleep(1)
def relay_action(pin_in):
global relay, running
logger.debug(f"relay[{pin_in}] action[ON] time[1]")
status = 200
hr = dt.datetime.now().hour
if start_time <= hr < end_time:
if not running:
relay = Relay(int(pin_in), complete)
relay.on()
running = True
else:
status = 503
return jsonify(message="Success",
statusCode=status), status
class TestRelays(unittest.TestCase):
relay = Relay("relay_test", 1, 5)
def test_is_initialized(self):
self.assertTrue(isinstance(self.relay, Relay))
self.assertTrue(self.relay.name=="relay_test")
def test_relay_change(self):
self.assertEqual(self.relay.state, 0)
self.relay.switchOn()
self.assertEqual(self.relay.state, 1)
self.relay.switchOff()
self.assertEqual(self.relay.state, 0)
self.relay.switch()
self.assertEqual(self.relay.state, 1)
self.relay.switch()
self.assertEqual(self.relay.state, 0)
def test_relay_timeouts(self):
relay = Relay("default_timeout_test", 2, 5)
relay.switchOn()
self.assertTrue(relay.timer.is_alive())
self.assertTrue(relay.time_remaining()>0)
time.sleep(5.1)
self.assertFalse(relay.timer.is_alive())
self.assertTrue(relay.time_remaining()==0)
relay.switchOn()
self.assertTrue(relay.time_remaining()>3)
time.sleep(2)
relay.switchOn()
self.assertTrue(relay.time_remaining()>3)
def test_timed_switch(self):
relay = Relay("timeout_test", 3, 5)
relay.switchOn(8)
self.assertTrue(relay.time_remaining()>6)
self.assertTrue(relay.timer.is_alive())
time.sleep(8.1)
self.assertFalse(relay.timer.is_alive())
def test_switch_off(self):
relay = Relay("switchoff_test", 4, 5)
relay.switchOn()
self.assertTrue(relay.time_remaining()>3)
self.assertTrue(relay.timer.is_alive())
relay.switchOff()
time.sleep(0.5)
self.assertFalse(relay.timer.is_alive())
self.assertFalse(relay.state)
self.assertTrue(relay.time_remaining()==0)
def getRelay(name):
_db_conn = mysql.connector.connect(host='192.168.2.34',
database='temperatures',
user='******',
password='******')
if _db_conn.is_connected():
print('Connected to MySQL database getRelay')
_db_cursor = _db_conn.cursor()
query = "SELECT * FROM relays WHERE name = '%s';" % (name)
_db_cursor.execute(query)
row = _db_cursor.fetchone()
relay = Relay(row[0], row[1], row[2], row[3])
_db_conn.close()
return relay
else:
print("Could not connect to Database getRelay")
def run_step(self):
self._step += 1
self._step_time = 0
self._run_time = 0
if self._timer is not None:
self._timer.cancel()
if not self._running or self._step >= self._step_cnt:
self.stop()
else:
log_msg = f"run_step() [{self._step + 1} of {self._step_cnt}]"
run = True
for step in self._p['steps']:
if step['step'] == self._step:
head = -1
pin = 0
zone = step['zone']
for z in self._s['zones']:
if z['zone'] == zone:
pin = z['pin']
head = z['type']
break
if pin > 0 and head >= 0:
self._r = Relay(pin, self.run_step)
if step['time'] > 0:
t = step['time'] * 60
else:
t = self.det_run_time(step['percent'] / 100.0,
head)
t = t * 12.0 / (28.0 / self._p['interval'])
log_msg += f" zone[{zone}] head[{head}] pin[{pin}] time[{int(t/60)}]"
if t > 0:
run = False
self._step_time = int(t)
self._r.set_run_time(int(t))
w = 3
if step['wait'] > 0:
w = step['wait'] * 60
self._r.set_wait(w)
self._r.on()
self._timer = threading.Timer(
60, self.set_run_time)
self._timer.start()
else:
run = True
module_logger.debug(log_msg)
if run:
self.run_step()
def main():
if "-v" in sys.argv:
log.setLevel(logging.DEBUG)
configfile = "data/options.json"
st = os.stat(configfile)
if bool(st.st_mode & (stat.S_IRGRP | stat.S_IROTH)):
raise Exception("Config file (%s) appears to be group- or "
"world-readable. Please `chmod 400` or similar." %
configfile)
with open(configfile) as f:
config = json.load(f)
rly = Relay(config)
rly.loop()
async def service_connected(self, reader, writer):
self.logger.info('service connected')
service = Service(reader, writer)
self.add_service(service)
while True:
await asyncio.sleep(1.0)
machine = None
try:
machine = await service.choose_machine(self.machines)
self.remove_service(service)
relay = Relay(machine, service)
self.logger.info('relay established')
await relay.do_relay()
except MachineDisconnectedException as machine_closed:
self.logger.info('machine disconnected')
machine.release_machine()
self.add_service(service)
except ServiceDisconnectedException as service_closed:
self.logger.info('service disconnected')
if machine:
machine.release_machine()
break
except Exception as exception:
self.logger.exception('unknown service error')
if machine:
machine.release_machine()
break
self.remove_service(service)
service.close()
def main():
# Relay GPIO Board Pin
RELAY_PIN = 37
# Setup relay
relay = Relay(RELAY_PIN)
# Setup Databases
credentials = []
with open("/home/pi/fecoteme_access_control/dbcredentials.txt") as f:
for line in f:
credentials.append(line.split())
# Read-Only Access Subscription Database
accessDB = Database(*credentials[0])
accessDB.connect()
# Write-Only Movements Register Database (Handled by daemon)
movQueue = multiprocessing.JoinableQueue(False)
movementsDB_Handler = multiprocessing.Process(target=mov_write_db_handle,
args=(credentials[1], movQueue))
movementsDB_Handler.daemon = True
movementsDB_Handler.start()
# Setup Access Control System
accessControl = AccessControl(accessDB, movQueue)
# Set Barscanners Callbacks
barscanner_cb = functools.partial(barscanner_handle,
relay=relay,
access_ctl=accessControl)
# Setup Barscanners
barscanner0 = Barscanner('/dev/barscanner0', "in", barscanner_cb)
barscanner1 = Barscanner('/dev/barscanner1', "out", barscanner_cb)
barscanners = {bs.device.fd: bs for bs in [barscanner0,barscanner1]}
devices = {bs.device.fd: bs.device for bs in [barscanner0,barscanner1]}
try:
while True:
r, w, x = select(devices, [], [])
for fd in r:
barscanners[fd].read_code_handler()
finally:
movQueue.join(10) # Wait for all DB transactions to complete
def __init__(self, target=68, relay_pin=None, temperature_pin=20):
self.stop_event = Event()
self.temperature_queue = Queue()
self.relay = Relay(relay_pin)
self.temperature_array = TemperatureArray(pin=temperature_pin)
self.temperature_process = Process(name='temperature',
target=read_temperatures,
args=(self.temperature_array,
self.temperature_queue,
self.stop_event, 1))
self.history = []
self.max_no_reading = 10
self.target = target
self.no_reading_count = 0
self.logger = get_logger(self.__class__.__name__)
self.logger.info('Starting log for DeliciousFoods')
self.current_temp = {}
self.pin = datetime.timedelta(seconds=30)
def __init__(self, filename):
# initialize relay controller
self.relay = Relay()
# initialize voltage reader
self.vreader = VReader()
# initialize voltage-to-temp converter
self.v_to_t = VtoT()
# initialize moving average with an appropriate number of samples
self.ma = MovingAverage(20)
# initialize the target temperature vs time
self.t_profile = TProfile(filename)
# initialize data logger
self.logger = Logger(chop_off_end(chop_off_folder(filename), ".csv"))
def __init__(self):
print("Starting lamp_bulb driver!")
self.sub = rospy.Subscriber(
rospy.get_param('/driver_params/bulb_topic'), Bool, self.callback)
self.state = False
self.ch = rospy.get_param("/driver_params/relay_channel")
while True:
try:
self.relay = Relay(rospy.get_param('/driver_params/relay_tty'))
except SerialException as se:
print(
"Could not configure relay board! Trying again in 3 seconds."
)
print(se.message)
rospy.sleep(3)
continue
break
def __init__(self):
# 读取配置和脚本文件
conf = ConfigParser.ConfigParser()
conf.read('../configs/global.ini')
process_file = ('../configs/process/' +
conf.get('ControlProcess', 'file') +
'.cp')
with open(process_file, 'r') as f:
self.__process = f.readlines()
# 去除注释和空行
self.__process = [i for i in self.__process
if not i.startswith(';') and i != '\r\n' and i != '\n']
self.__step_num = len(self.__process)
self.__step = 0
self.__record = Record()
self.__serial_com = SerialCom(self.__record.display_status)
self.__remote = Remote()
self.__relay = Relay()
thread.start_new_thread(self.__serial_com.read_ser, ())
self.log_name = self.__record.recording_log
def getAllRelays():
relays = []
_db_conn = mysql.connector.connect(host='192.168.2.34',
database='temperatures',
user='******',
password='******')
if _db_conn.is_connected():
print('Connected to MySQL database getAllRelays')
_db_cursor = _db_conn.cursor()
query = "SELECT * FROM relays;"
_db_cursor.execute(query)
row = _db_cursor.fetchone()
while row is not None:
relay = Relay(row[0], row[1], row[2], row[3])
relays.append(relay)
row = _db_cursor.fetchone()
_db_conn.close()
return relays
else:
print("Could not connect to Database getAllRelays")
def main():
RELAY_PIN = 37
VT_PIN = 18
GPIO.setmode(GPIO.BOARD)
relay = Relay(RELAY_PIN)
GPIO.setup(VT_PIN, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)
GPIO.setup(D0_PIN, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)
relay_cb = functools.partial(activate_relay, relay=relay)
# Add ISR to falling edge detected in valid pin
GPIO.add_event_detect(VT_PIN,
GPIO.RISING,
callback=relay_cb,
bouncetime=500)
while True:
time.sleep(1)
def demo():
from relay import Relay
import time
relay = Relay(2)
relay.off()
data = b"\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f"
frc = Mfrc522()
print("Checking Tag")
print(frc.read())
relay.on()
time.sleep(1)
relay.flip()
relay.blink()
print("Writting data to tag")
print(frc.write(data))
relay.stop_blink()
time.sleep(1)
relay.on()
print("Check again")
print(frc.read())
time.sleep(1)
relay.off()
