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()