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 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 __init__(self,
debug,
database,
default,
robot,
redox,
ph,
temperature,
debounce_ms=10):
Mode.__init__(self, database, "pump")
self.__lock = threading.RLock()
Relay.__init__(self, self.PUMP_GPIO_PIN)
self.__debug = debug
self.__default = default
self.__robot = robot
self.__redox = redox
self.__ph = ph
self.__temperature = temperature
self.__guard = self.GUARD_PERIOD
self.__previousMode = None
self.__moveDebounce = None
GPIO.setup(self.LIQUID_MOVE_GPIO_PIN,
GPIO.IN,
pull_up_down=GPIO.PUD_UP)
GPIO.add_event_detect(self.LIQUID_MOVE_GPIO_PIN,
GPIO.BOTH,
callback=self.__moveGpioDetect,
bouncetime=debounce_ms)
self.autoPrograms = list()
self.programs = list()
self.fullAuto = True
class Bulb:
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 update(self, timerEvent):
self.relay.setRelay(self.ch, self.state)
def callback(self, msg):
self.state = msg.data
def start(self):
rospy.Timer(rospy.Duration(1.0 / 50), self.update)
rospy.spin()
def valveJob(setting): #(valve, onDuration)
print 'OPENING VALVE'
tft.markActiveJob(setting['id'], True);
durationLeft = int(setting['on_duration']) + 2
#binaryValveList = map(int, list(format(setting['valve'], '08b')))
#print binaryValveList
pump = Relay()
pump.on()
time.sleep(1)
#valves = Shiftregister()
#shiftreg.outputList(binaryValveList)
valves.outputDecimal(setting['valve'])
#valves.enable()
while durationLeft > 2:
time.sleep(1)
durationLeft -= 1
print 'TIME LEFT: %i' % (durationLeft - 1)
print 'CLOSING VALVE'
pump.off()
print 'reset shift register 1'
#valves.disable()
valves.reset()
time.sleep(1)
#valves.reset()
tft.markActiveJob(setting['id'], False);
db = DB()
db.addLogLine(setting, datetime.now())
return
def main():
with GPIO() as gpio:
tx = Transmitter(gpio.pin(26))
rx = Receiver(gpio.pin(15))
relay = Relay(rx, tx, input('Address: '))
print('Morse relay ready')
while True:
try:
address = input('To: ')
if len(address) > 0:
body = input('Message: ')
if len(body) > 0:
try:
relay.send(address, body)
except MorseEncodingError:
print('Could not convert to Morse code')
else:
print('Empty message not sent')
except(EOFError):
print('\nSending unsent messages')
rx.terminate()
tx.join()
break
message = relay.poll()
if message is None:
print('No new messages')
while message is not None:
print('Received: ' + message)
message = relay.poll()
def __init__(self, pin, freq=5000):
self.__pin = pin
self.__freq = freq
self.__dimmer = PWM(Pin(self.__pin), freq=self.__freq)
self.__duty = self.__dimmer.duty()
self.__async_fading = False
Relay.__init__(pin, 'dimmer')
self.add_sensor("dimmer", self.get_power)
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()
class Gate:
def __init__(self, relay_port):
self.relay = Relay(relay_port)
def open(self):
self.relay.open()
self.print_state()
def close(self):
self.relay.close()
self.print_state()
def toggle(self):
self.relay.open()
self.print_state()
time.sleep(10)
self.relay.close()
self.print_state()
def print_state(self):
val = self.relay.get_value()
if val == 0:
print("{\"state\":\"open\"}")
elif val == 1:
print("{\"state\":\"close\"}")
else:
print("{\"error\":\"unable to determine state\"}")
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 __init__(self, debug, database, default, analog):
Mode.__init__(self, database, "redox")
self.__lock = threading.RLock()
Relay.__init__(self, self.CL_GPIO_PIN)
self.__debug = debug
self.__default = default
self.__analog = analog
self.__injectionTimer = None
self.__current = 0
self.__waitTick = 0
self.__injection = 37.5 # 250ml
self.__wait = 600 / REFRESH_TICK # 10mn de stabilisation
self.offset = 0
self.idle = 650
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 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 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 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()
class Humidifier():
"""A Humidifier class."""
def __init__(self, power_pin, button_pin, name, status=0):
self.power_relay = Relay(power_pin, name + '_power_relay', 0)
self.button = Button(button_pin, name + '_button', 0)
self.status = 0
# self.nominal_status = 0
# 0 = Off - 1 = On - 2 = on for - 3 = pulse
self.advanced_status = 0
# active, pause time. It is valid only if self.status = 1
self.status_interval = []
# Interval used to activate the component after a certain time
self.interval = None
def get_status(self):
# convert to boolean
return not(not self.advanced_status)
def set_status(self, status):
if status == 0:
self.power_relay.off()
else:
self.power_relay.on()
self.button.switch_status()
def on(self):
# if self.status <> 1:
self.set_status(1)
self.status = 1
self.advanced_status = 1
def on_for(self, active_time):
logging.debug('Humidifier on_for: %s', active_time)
self.on()
time.sleep(active_time)
self.off()
self.advanced_status = 1
def pulse(self, active_time, sleep):
set_interval(on_for)
def off(self):
self.set_status(0)
self.status = 0
self.advanced_status = 0
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()
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)
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 __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 _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
class UBRSWebDaemon(Daemon):
def __init__(self):
Daemon.__init__(self, 'ubrs.pid')
self.ip = config.HTTP_IP
self.port = config.HTTP_PORT
self.relay = Relay(os.path.join(os.getcwd(), config.UBR_PATH))
self.app = UBRSApplication(self.relay)
# methode principale, appele par start()
# lance l'interface web tornado
def run(self):
self.app.listen(self.port)
tornado.ioloop.IOLoop.instance().start()
# on arrete proprement le serveur
def stop(self):
tornado.ioloop.IOLoop.instance().stop()
self.relay.stop_and_clean()
Daemon.stop(self)
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 __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, 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 __init__(self, power_pin, button_pin, name, status=0): self.power_relay = Relay(power_pin, name + '_power_relay', 0) self.button = Button(button_pin, name + '_button', 0) self.status = 0 # self.nominal_status = 0 # 0 = Off - 1 = On - 2 = on for - 3 = pulse self.advanced_status = 0 # active, pause time. It is valid only if self.status = 1 self.status_interval = [] # Interval used to activate the component after a certain time self.interval = None
def __init__(self, in_ws_q, out_ws_q, out_display_q):
self._in_ws_q = in_ws_q
self._out_ws_q = out_ws_q
self._out_display_q = out_display_q
self._target = 37.0
self._lower_limit = 36.5
self._water_level_target = 70 # Target in cm
self._total_temperature = -85
self._temp_low = TempSensor("28-0517a04776ff") # Lower
self._low_value = -85
self._temp_high = TempSensor("28-000008a5dd2c") # Upper
self._high_value = -85
self._temp_ambient = TempSensor("28-031724b16bff") # Ambient
self._ambient_value = -85
self._estimate = 0
self._heating_state = defs.OFF # ON/OFF/UPKEEP/FOFF
self._next_state = defs.OFF
self._relay = Relay()
self._magneticValve = MagneticValve()
self._floatSwitch = FloatSwitch()
self._pressureSender = PressureSender()
self._water_level = float(-1)
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)
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)
else:
logger.debug(
"gpio-subscriber: receive_command: unmatched %s not_in %s" % (args.name, str(message_json))) # debug
# parse arguments
parser = argparse.ArgumentParser()
parser.add_argument("-e", "--endpoint", help="AWS IoT endpoint", required=True)
parser.add_argument("-r", "--ca_file", help="Certificate Authority file", default='rootCA.pem')
parser.add_argument("-c", "--client_cert_file", help="Client certificate file", default='certificate.pem')
parser.add_argument("-k", "--client_key_file", help="Client Key File", default='private.pem')
parser.add_argument("-p", "--port", help="MQTT port", type=int, default=8883)
parser.add_argument("-q", "--qos", help="MQTT QoS", type=int, default=1)
parser.add_argument("-t", "--topic", help="MQTT topic")
parser.add_argument("-i", "--pin", help="gpio pin (using BCM numbering)", type=int, required=True)
parser.add_argument("-s", "--name", help="topic name", required=True)
parser.add_argument("-g", "--log_level", help="log level", type=int, default=logging.INFO)
args = parser.parse_args()
# logging setup
logger = set_logger(level=args.log_level)
relay = Relay(args.pin)
relay.start()
mqtt = MqttClient(args.endpoint, args.log_level, args.port)
mqtt.set_tls(args.ca_file, args.client_cert_file, args.client_key_file)
mqtt.add_callback(args.topic, receive_command)
mqtt.add_subscription(args.topic, qos=args.qos) # subscribe or not?
mqtt.run()
#from front import Front
from relay import Relay
if not os.path.isfile('/tmp/band.txt'):
print "File banda non trovato..."
AtomicWrite.writeFile('/tmp/band.txt', "40")
if not os.path.isfile('/tmp/tx.txt'):
print "File tx non trovato..."
AtomicWrite.writeFile('/tmp/tx.txt', "")
relay = Relay()
#front = Front()
#icomin = IcomIn("P9_33")
#band = Band(icomin)
settings = Settings()
#radioa = Radio("P9_15", "P9_29", "P8_19", "P8_7", "P8_9", "P8_11")
#radiob = Radio("P9_17", "P9_31", "P8_26", "P8_13", "P8_15", "P8_17")
preset = Preset()
#txing = ""
clear = True
lastband = "-1"
presetchanged = False
oldpresetA = ""
oldpresetB = ""
#def tx(R,S):
# AtomicWrite.writeFile("/tmp/tx"+R+".txt",str(S))
#!/usr/bin/env python3
import logging
logging.basicConfig(level=logging.DEBUG)
from relay import Relay, auto_join, auto_pong
from relay.constants import privmsg
bot = Relay("echobot")
@bot.handler(privmsg)
def echo(target, message, sender, *args, **kwargs):
if not message.startswith("!echo "):
return
sender_nick = sender.split('@')[0].split('!')[0] # We just want the nick
message = message[6:] # We just want whatever is after '!echo '
if target == bot.client['nick']:
result = "PRIVMSG {sender_nick} :{sender_nick}: {message}"
else:
result = "PRIVMSG {{target}} :{sender_nick}: {message}"
yield result.format(sender_nick=sender_nick, message=message)
if __name__ == "__main__":
bot.register(auto_pong)
bot.register(auto_join(['#tests']))
bot.config(from_env=True).run()
