def __init__(self, teamID, UDP=False, dilationFactor=1, networkSize=4): self.teamID = teamID self.nextPlayer = False self.waitingControl = True self.finishedCounter = 0 self.networkSize = networkSize self.dilationFactor = dilationFactor self.tData = (0.005*3 + 0.005)*self.dilationFactor self.tACK = 0.04*self.dilationFactor self.savingFiles = [0]*self.networkSize self.senderFiles = [0]*self.networkSize for i in range(self.networkSize): if i != self.teamID: savingFilePath = os.path.join("./savingFiles" + str(self.teamID), "team" + str(i), "received_file.txt") self.savingFiles[i] = FileClass(reader=False, path=savingFilePath) senderFolder = os.path.join("./sendFiles" + str(self.teamID), "team" + str(i)) senderFilePath = os.path.join(senderFolder, os.listdir(senderFolder)[0]) self.senderFiles[i] = FileClass(reader=True, path=senderFilePath) self.pipeRX = [0xe7, 0xe7, 0xe7, 0xe7, 0xe7] self.pipeTX = [0xe7, 0xe7, 0xe7, 0xe7, 0xe7] pinTX = 22 pinValTx = 0 pinRX = 23 pinValRx = 1 # pinTX = 27 # pinRX = 17 self.radioTX = radio.Radio(self.pipeTX, rx=False, pins=[pinValTx, pinTX], teamID=self.teamID, UDP=UDP) self.radioRX = radio.Radio(self.pipeRX, rx=True, pins=[pinValRx, pinRX], teamID=self.teamID, UDP=UDP)
def __init__(self, id, eui64=None): # store params self.id = id # admin self.dataLock = threading.RLock() # singletons (quicker access, instead of recreating every time) self.log = SimEngine.SimLog.SimLog().log self.engine = SimEngine.SimEngine.SimEngine() self.settings = SimEngine.SimSettings.SimSettings() # stack state self.dagRoot = False self._init_eui64(eui64) self.ipv6_prefix = None # stack self.app = app.App(self) self.secjoin = secjoin.SecJoin(self) self.rpl = rpl.Rpl(self) self.sixlowpan = sixlowpan.Sixlowpan(self) self.trae = trae.TRAE(self) self.sf = sf.SchedulingFunction(self) self.sixp = sixp.SixP(self) self.tsch = tsch.Tsch(self) self.radio = radio.Radio(self) self.batt = batt.Batt(self)
def test_send_packet_with_eventual_success(self, encrypt_mock): expected_packet = [39, 0, 5, 4, 1, 2, 3, 4] expected_packet = bytes(expected_packet) encrypted_packet = bytes([8] * 32) radio_instance = radio.Radio() radio_instance.clients = [{ 'client_id': 1, 'address': MOCK_CLIENT_ADDRESS, 'server_counter': 10000 }] radio_instance.nrf24.openReadingPipe.reset_mock() radio_instance.nrf24.openWritingPipe.reset_mock() radio_instance.nrf24.startListening.reset_mock() radio_instance.nrf24.write.side_effect = [False, False, True] encrypt_mock.return_value = encrypted_packet success = radio_instance.send_packet(1, 5, bytes([1, 2, 3, 4])) self.assertEqual(len(encrypt_mock.call_args[0][0]), 32) self.assertEqual(encrypt_mock.call_args[0][0][:len(expected_packet)], expected_packet) self.assertEqual(encrypt_mock.call_args[0][0][-1], 16) radio_instance.nrf24.stopListening.assert_called_once_with() radio_instance.nrf24.openWritingPipe.assert_called_once_with( MOCK_CLIENT_ADDRESS) self.assertEqual(radio_instance.nrf24.write.call_count, 3) radio_instance.nrf24.startListening.assert_called_once() self.assertEqual(success, True)
def __init__(self, msgHandler, errHandler, lot, tid, address=None): self.messageHandler = msgHandler self.errorHandler = errHandler self.lot = lot self.tid = tid self.address = address self.pdmMessage = None self.radio = radio.Radio(0)
def __init__(self, puerto): self.nomApp = "InterfaceRadioArduino->" self.radio = radio.Radio() self.arduino = arduinoComunication.ArduinoComunication(self, puerto) #Cambiando esta variable a true, se deja de comunicar con arduino self.stop = false #Recoge la opcion enviada por arduino, por defecto es cero (vacio) self.opcion = 0 print("InterfaceRadioArduino")
def test_get_client_id_with_existing_client_address(self): radio_instance = radio.Radio() expected_client_id = random.randint(1, 255) radio_instance.clients.append({ 'client_id': expected_client_id, 'address': MOCK_CLIENT_ADDRESS }) self.assertEqual(radio_instance.get_client_id(MOCK_CLIENT_ADDRESS), expected_client_id)
def test_get_client_id_with_new_client_address(self): radio_instance = radio.Radio() number_already_registered = random.randint(0, 255) for i in range(number_already_registered): radio_instance.clients.append({ 'client_id': i + 1, 'address': OTHER_MOCK_CLIENT_ADDRESS }) self.assertEqual(radio_instance.get_client_id(MOCK_CLIENT_ADDRESS), number_already_registered + 1)
def test_get_client_address_without_remaining_client_ids(self): radio_instance = radio.Radio() number_already_registered = 254 for i in range(number_already_registered): radio_instance.clients.append({ 'client_id': i + 1, 'address': OTHER_MOCK_CLIENT_ADDRESS }) self.assertEqual(radio_instance.get_client_id(MOCK_CLIENT_ADDRESS), False)
def test_send_packet_with_error(self): radio_instance = radio.Radio() radio_instance.clients = [{ 'client_id': 1, 'address': MOCK_CLIENT_ADDRESS, 'server_counter': 10000 }] radio_instance.nrf24.write.return_value = False success = radio_instance.send_packet(1, 5, bytes([1, 2, 3, 4])) self.assertEqual(success, False) self.assertEqual(radio_instance.nrf24.write.call_count, 10)
def testradioIC910(self): ic910 = radio.Radio("IC910", "Sub", "CW") ic910.connect("/dev/ttyUSB0") #print ic910.getfreq() #ic910.getmode() ic910.changefreq(437.38590) #print "Sub FM" #ic910.chengemode("Sub","FM") print "Sub CW" ic910.changemode("Sub", "FM") #print "Main FM" #ic910.chengemode("Main","FM") #print "Main CW" #ic910.chengemode("Main","CW") ic910.close()
def test_has_client_id(self): client_id = 100 test_cases = [ ([{ 'client_id': 100 }], True), ([{ 'client_id': 101 }], False), ([], False), ] radio_instance = radio.Radio() for clients, expected in test_cases: with self.subTest(clients=clients, expected=expected): radio_instance.clients = clients self.assertEqual(radio_instance.has_client_id(client_id), expected)
def __init__(self, pktHandler, msgHandler, errHandler, lot=None, tid=None, address=None): self.pktHandler = pktHandler self.messageHandler = msgHandler self.errHandler = errHandler self.lot = lot self.tid = tid self.address = address self.nextPacketSequence = None self.packetSequences = dict() self.address = None self.message = None self.radio = radio.Radio(0)
def setup_for_test_get_packet(self): radio_instance = radio.Radio() radio_instance.nrf24.available.return_value = True radio_instance.has_client_id = Mock(return_value=True) radio_instance.is_counter_is_in_expected_range = Mock( return_value=True) client_id = 100 message_id = 101 payload = [1, 2, 3, 4] counter_byte_1 = 16 counter_byte_2 = 39 decrypted_packet = [ counter_byte_2, client_id, message_id, len(payload) ] decrypted_packet.extend(payload) decrypted_packet.extend([counter_byte_1]) radio.decrypt_packet.return_value = bytes(decrypted_packet) return radio_instance
def radio(action, id): listen = program.Radio(id) if action == "on": GPIO.setmode(GPIO.BCM) GPIO.setup(24, GPIO.OUT) GPIO.output(24, GPIO.HIGH) listen.start() return ("Radio Started: " + id) if action == "off": GPIO.setmode(GPIO.BCM) GPIO.setup(24, GPIO.OUT) GPIO.output(24, GPIO.LOW) listen.stop() return ("Radio off") if action == "status": res = listen.status() return (res)
def __init__(self, iface_name): self._radio = radio.Radio(iface_name) self.iface_name = iface_name self._up_state_pub = netlink_monitor.get_state_publisher( iface_name, IFSTATE.UP) self.activate_request = state_publisher.StatePublisher(False) self.is_active = state_publisher.StatePublisher(False) self.scanning_enabled = state_publisher.StatePublisher(False) self.associate_request = event.Event() self.disactivate_delay = 1 self.pre_up_sleep = 1 # Copy radio members that we are willing to expose self.unassociate = self._radio.unassociate self.associated = self._radio.associated self.scanning = self._radio.scanning self.scan = self._radio.scan self.scan_results_event = self._radio.scan_results_event self.frequency_list = self._radio.frequency_list
def __init__(self, logger): self.logger = logger self.queue = queue.Queue() self.radio = radio.Radio(self.logger) self.device = device.Device(self.logger, self.radio) self.scheduler = Scheduler(self.logger, asyncio.new_event_loop(), self) self.schedulerthread = threading.Thread(target=self.scheduler.run, name='scheduler', daemon=True) self.api = api.API(asyncio.new_event_loop(), self.queue, self.logger, os.environ.get('TOKEN')) self.apithread = threading.Thread(target=self.api.run, name='api', daemon=True) self.mode = 1 self.nightmode = 0 self.temp = 0 self.press = 0 self.humid = 0 self.etemp = 0
def __init__(self, id, eui64=None): # store params self.id = id # admin self.dataLock = threading.RLock() # singletons (quicker access, instead of recreating every time) self.log = SimEngine.SimLog.SimLog().log self.engine = SimEngine.SimEngine.SimEngine() self.settings = SimEngine.SimSettings.SimSettings() # stack state self.dagRoot = False self._init_eui64(eui64) self.ipv6_prefix = None # stack self.app = app.App(self) self.secjoin = secjoin.SecJoin(self) self.rpl = rpl.Rpl(self) self.sixlowpan = sixlowpan.Sixlowpan(self) self.sf = sf.SchedulingFunction(self) self.sixp = sixp.SixP(self) self.tsch = tsch.Tsch(self) self.radio = radio.Radio(self) self.batt = batt.Batt(self) # :) Low Delay Scheduling Function - Virtual Slot Frame proportional to CBR of the node. self.flow_gen_time = -1 # offset of subframe of flow of data self.hops = -1 # initialize hops self.lock_TX = 0 # locking TX before Scheduling self.start_tx = -1 self.tx_slot = -1 self.lock_schedule = 0 self.is_leaf = 1 # 1 - is leaf, 0- is relay node self.flip_flop = 0 # enable more childrens for DagRoot mote self.black_parent = [] #mac address
def __init__(self, id, eui64=None): # store params self.id = id # admin self.dataLock = threading.RLock() # singletons (quicker access, instead of recreating every time) self.log = SimEngine.SimLog.SimLog().log self.engine = SimEngine.SimEngine.SimEngine() self.settings = SimEngine.SimSettings.SimSettings() # stack state self.dagRoot = False self._init_eui64(eui64) self.ipv6_prefix = None # stack self.app = app.App(self) self.secjoin = secjoin.SecJoin(self) self.rpl = rpl.Rpl(self) self.sixlowpan = sixlowpan.Sixlowpan(self) self.sf = sf.SchedulingFunction(self) self.sixp = sixp.SixP(self) self.tsch = tsch.Tsch(self) self.radio = radio.Radio(self) self.batt = batt.Batt(self) # :) energy save self.lock_schedule = 0 # Generation of periodic traffic delay = self.settings.tsch_slotDuration + (self.settings.app_pkPeriod * random.random()) gen_timeslot = int(((self.engine.getAsn() + delay / 0.01) % self.settings.tsch_slotframeLength - 1)) print "~#ID", self.id, "Gen Timeslot", gen_timeslot self.gen_timeslot = gen_timeslot
def build(self): self.root = SampleWidget() self.root.buttonOperation.bind(on_press=self.buttonOperation_clicked) Clock.schedule_interval(self.callback_operation, 1) self.root.spinfreqmode.bind(text=self.spinchanged) self.conf = config.ConfigRead().read() self.gslat = self.conf['lat'] self.gslon = self.conf['lon'] self.gsantenna = self.conf['antenna'] self.gsheight = self.conf['height'] self.gsradio = self.conf['radio'] self.gsradioport = self.conf['radioport'] self.gsradiobaudrate = self.conf['radiobaudrate'] self.gsantennaport = self.conf['antennaport'] self.gsantennabaudrate = self.conf['antennabaudrate'] self.ant = antenna.Antenna(self.gsantenna) self.ant.connect(self.gsantennaport) self.ic910 = radio.Radio(self.gsradio, "Sub", "CW") self.ic910.connect(self.gsradioport) return self.root
def test_init(self): logging.basicConfig(level=logging.INFO) radio_instance = radio.Radio() radio_instance.nrf24.begin.assert_called_once_with(0, 0, 25, 24) radio_instance.nrf24.setRetries.assert_called_once_with(10, 10) radio_instance.nrf24.setPayloadSize.assert_called_once_with(32) radio_instance.nrf24.setChannel.assert_called_once_with(0x4c) radio_instance.nrf24.setDataRate.assert_called_once_with( MockNRF24.BR_250KBPS) radio_instance.nrf24.setPALevel.assert_called_once_with( MockNRF24.PA_HIGH) radio_instance.nrf24.setCRCLength.assert_called_once_with( MockNRF24.CRC_16) radio_instance.nrf24.setAutoAck.assert_called_once_with(True) radio_instance.nrf24.enableAckPayload.assert_called_once_with() radio_instance.nrf24.openReadingPipe.assert_called_once_with( 1, MOCK_SERVER_ADDRESS) radio_instance.nrf24.openWritingPipe.assert_called_once_with( MOCK_SERVER_ADDRESS) radio_instance.nrf24.startListening.assert_called_once_with() radio_instance.nrf24.printDetails.assert_called_once_with()
def test_is_counter_in_expected_range(self): client_id = 100 current_client_counter = 65533 test_cases = [ (100, False), (65533, False), (65534, True), (65535, True), (0, True), (7, True), (8, False), (10, False), ] radio_instance = radio.Radio() radio_instance.clients.append({ 'client_id': client_id, 'client_counter': current_client_counter }) for counter, expected in test_cases: with self.subTest(counter=counter, expected=expected): self.assertEqual( radio_instance.is_counter_is_in_expected_range( client_id, counter), expected)
def test_init_with_higher_loglevel(self): logging.basicConfig(level=logging.WARN) radio_instance = radio.Radio() self.assertFalse(radio_instance.nrf24.printDetails.called)
parser.add_argument("--wampl", default=0.3, type=float) return parser.parse_args() def do_alarm(runvar, duration): time.sleep(duration) print("whee!") runvar.value = False if __name__ == '__main__': args = parse_args() runvar = mp.Value('b', True) proc = mp.Process(target=do_alarm, args=(runvar, args.duration)) proc.start() endtime = time.time() + args.duration rad = radio.Radio() rad.tune(args.freq, args.gain) nsamps = 10000 * int(np.floor(args.rate / args.wfreq)) vals = np.ones((1, nsamps), dtype=np.complex64) * np.arange(nsamps) samps = args.wampl * np.exp(vals * 2j * np.pi * args.wfreq / args.rate) while runvar.value: for i in range(10): rad.send_samples(samps) proc.join()
"domaincontroller": None, # None: domain_controller.WsgiDAVDomainController(user_mapping) }) wsgidav = WsgiDAVApp(config) def wsgidav_application(environ, start_response): return wsgidav(environ, start_response) class Services: pass services = Services() services.radio = radio.Radio(irlp_home) services.player = playback.Player(services.radio) services.scheduler = scheduler.Scheduler(services.player, services.radio) # Put all top level module instances here that need to get stuff done def top_ticker(): services.radio.tick() services.player.tick() services.scheduler.tick() root = static.Data("", "text/plain") root.putChild("files", static.File("../files")) root.putChild("static", static.File("../static")) #simple = Simple()
to = str(to) mid = str(mid) wh = str(which) hm = str(howmany) ttl = str(ttl) prefix = to + mid + wh + hm + ttl message = bytes(prefix, 'utf-8') + mslice + bytes('\n', 'utf-8') print(message.decode('utf-8')) assert len(message) <= 64 return message def run(server_class=HTTPServer, handler_class=S, port=config.PORT): server_address = ('', port) httpd = server_class(server_address, handler_class) print("Starting httpd...") httpd.serve_forever() if __name__ == "__main__": from sys import argv # init radio, start thread that handles incoming packets from radio radio = radio.Radio(config.SERIALPORT, config.BAUD) listener_thread = Thread(target=listener.listen_forever, args=(radio, )) listener_thread.start() if len(argv) == 2: run(port=int(argv[1])) else: run()
import busio import adafruit_character_lcd.character_lcd_rgb_i2c as character_lcd from threading import Barrier import radio import phatbeat import subprocess import socket import threading i2c = busio.I2C(board.SCL, board.SDA) lcd = character_lcd.Character_LCD_RGB_I2C(i2c, 16, 2) global radio radio = radio.Radio(lcd) radio.play() os.system("ping -c 1 google.com") time.sleep(5) def lcd_buttonthread(): s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) while True: if lcd.select_button: try: s.connect(('10.255.255.255', 1)) IP = s.getsockname()[0] except: IP = '127.0.0.1'
import radio import parlante import os marca_zapatera=os.sys.argv[1] zapato_marca=os.sys.argv[2] zap1=parlante.Parlante(zapato_marca,42,"cuero","deportivo",1200) z1=radio.Radio(marca_zapatera,zap1,"madera",20,"americano") print("radio:"+z1.getMarca()) print("parlante:"+zap1.getMarca()) z1.setParlante(zap1) print(z1.reproducir())
#!/usr/bin/python3 from flask import Flask, render_template, request import radio as r import threading, os while (True): #wait for internet if (os.system("ping -c 1 google.com") == 0): break rad = r.Radio() rad.start() web = Flask(__name__) @web.route("/", methods=["POST", "GET"]) def home(): if (request.method == "POST"): tmp = int(request.form["state"]) if (tmp == -1): rad.Play(-1) print("Previous") elif (tmp == 0): rad.pause() print("Pause") elif (tmp == 1): rad.Play(1) print("Next") return render_template("radio.html", playing=rad.cPlay, volume=rad.volume)
import radio import SimpleEncoder import machine from machine import Pin import lcd_api import i2c_lcd import bounce import time import si5351 synth = si5351.SI5351( data=Pin(21), clock=Pin(22) ) lcd = i2c_lcd.I2cLcd( data=Pin(21), clock=Pin(22), num_lines=2, num_columns=16 ) button = bounce.Bounce( Pin(15, mode=Pin.IN, pull=Pin.PULL_UP)) enc = SimpleEncoder.Encoder( 26, 27 ) r = radio.Radio( button, enc, lcd, synth, 7010000 ) r.run()