def __init__(self, servaddr, servport, device_args="", rx_txrx=False): self.pipe = None self.conproc = None self.logger = None self.setup_logger() self.radio = Radio(self.logger, device_args, rx_txrx) self.connector = ClientConnector(servaddr, servport)
def __init__(self): super(Main, self).__init__() ## initialize sensors self.sensorThread = False self.radioThread = False self.cameraThread = False try: self.sensorThread = Sensors() except: print("error initing sensor thread") try: pass #self.cameraThread = Camera('Mini') except: print("error initializing camera thread") try: self.radioThread = Radio(self) except: print("error initing radio thread") #self.numberGen = RandomThread() self.daemon = True self.fileLocation = str(os.getcwd()) + '/' self.data_file = self.fileLocation + str(datetime.now().replace(microsecond=0)) print("initialized") print(self.data_file)
async def init_radio(self): if not self.neighbourhood[1:]: self.srecovery = datetime.now().time() self.radio = Radio(RADIO_PORT, self.neighbourhood_watch) self.radio_started.set() print( f"1 Radio Started {self.port}, self id: {self.neighbourhood[0]}, neighbour list: {self.neighbourhood[1:]}" ) await self.radio.start()
def start_receiving(self, loop_sleep): self._receive_loop_sleep = loop_sleep if self._radio is None: self._radio = Radio(self._is_second_comms) self._is_receiving = True self._receiving_thread = threading.Thread(target=self.receiving_loop) # set to daemon mode so it will be easily killed self._receiving_thread.daemon = True self._receiving_thread.start()
def start_sending(self, loop_sleep): self._loop_sleep = loop_sleep if self._loop_sleep < Radio.MESSAGE_DELAY: print("WARNING: Comms loop sending faster than Radio can send") if self._radio is None: self._radio = Radio(self._is_second_comms) self._is_sending = True self._sending_thread = threading.Thread(target=self.sending_loop) # set to daemon mode so it will be easily killed self._sending_thread.daemon = True self._sending_thread.start()
def __init__(self, path, lst, port, id): self.path = path self.lst = lst self.port = port self.id = id self.radio = Radio(port, print) self.pub = Pub(port) self.sub = Sub(port) self.heartbeat_started = asyncio.Event() self.neigh_hood_check_started = asyncio.Event() self.sub_started = asyncio.Event()
def main(radio_idx): radio = Radio(int(radio_idx), mic_threshold=MIC_THRESHOLD, input_rate=INPUT_RATE, input_id=INPUT_ID, output_id=OUTPUT_ID) radio.connect(server=0) radio.start_speaker_stream() while True: radio.stream_mic_segment_to_server()
def main(): stations = [ Station( "https://wdr-1live-live.sslcast.addradio.de/wdr/1live/live/mp3/128/stream.mp3", "1Live"), Station("http://www.ndr.de/resources/metadaten/audio/m3u/ndr2_hh.m3u", "Ndr2"), Station( "https://swr-dasding-live.sslcast.addradio.de/swr/dasding/live/aac/96/stream.aac", "Das Ding") ] radio_inst = Radio(stations) radio_inst.listen_to_station(0) menue(radio_inst)
def user_experiment(set_size=2000): if set_size > 0: print("+ Extraindo " + str(set_size) + " músicas") extractSet(set_size=set_size) print('+ Carregando dados no sistema') groot = Radio(load_data_songs(), load_data_users()) print('+ Carregando Dados') groot.post_preference_set( preference_set=make_set_to_process( song_set=groot.get_song_set(), dict_set=statisticalOverview( songSet=groot.get_song_set(), preferenceSet=groot.get_preference_set(), DEBUG=False ), DEBUG=False ) ) print('+ Treinando a árvore') classifier, evaluate_results = plant_the_tree( set_to_process=preprocessing_data( data_set=groot.get_preference_set(), all_features=groot.get_all_features(), DEBUG=False ), features=groot.get_song_features(), important_feature=groot.get_important_feature(), DEBUG=True, ADMIN=False ) groot.post_classifier( new_classifier=classifier ) print('+ Obtendo similaridade entre as músicas') groot.post_distance_matrix( new_distance_matrix=get_song_distance( song_set=groot.get_song_set(), song_features=groot.get_song_features(), classifier_important=groot.get_feature_weight(), DEBUG=False ) ) print('+ Rádio Groot - Iniciando') time.sleep(3) os.system('clear||cls') start_and_end = interface_menu(groot) environment( groot=groot, song_stages=start_and_end )
def element_wyposazenia(self, typ: str) -> Wyposazenie: if typ == 'fotele': wyposazenie = Fotele({'typ': 'skorzane'}) elif typ == 'kierownica': wyposazenie = Kierownica({'typ': 'skorzana'}) elif typ == 'nawigacja': wyposazenie = Nawigacja() elif typ == 'radio': wyposazenie = Radio() elif typ == 'tapicerka': wyposazenie = Tapicerka({'typ': 'welurowa'}) else: wyposazenie = None return wyposazenie
def __init__(self): self.about_dialog = None self.icon = os.path.abspath('./tabletop_radio_.png') self.active_icon = None self.attention_icon = None self.radio = Radio() self.notification = Notify.Notification.new('', '', None) self.indicator = appindicator.Indicator.new( "DoubanRadio-Indicator", self.icon, appindicator.IndicatorCategory.APPLICATION_STATUS) self.indicator.set_attention_icon(self.icon) self.menu = self.get_menu() self.indicator.set_menu(self.menu) self.indicator.set_status(appindicator.IndicatorStatus.ACTIVE)
def admin_experiment(set_size=2000): if set_size > 0: print("+ Extraindo " + str(set_size) + " músicas") extractSet(set_size=set_size) print('+ Carregando dados no sistema') groot = Radio(load_data_songs(), load_data_users()) print('+ Processando dados') groot.post_preference_set( preference_set=make_set_to_process( song_set=groot.get_song_set(), dict_set=statisticalOverview( songSet=groot.get_song_set(), preferenceSet=groot.get_preference_set(), DEBUG=True ), DEBUG=True ) ) print('+ Treinando a árvore') classifier, evaluate_results = plant_the_tree( set_to_process=preprocessing_data( data_set=groot.get_preference_set(), all_features=groot.get_all_features(), DEBUG=True ), features=groot.get_song_features(), important_feature=groot.get_important_feature(), DEBUG=True, ADMIN=True ) groot.post_classifier( new_classifier=classifier ) print('+ Obtendo similaridade entre as músicas') groot.post_distance_matrix( new_distance_matrix=get_song_distance( song_set=groot.get_song_set(), song_features=groot.get_song_features(), classifier_important=groot.get_feature_weight(), DEBUG=True ) ) print('+ Iniciando a busca') similarity = environment( groot=groot, song_stages=random_choice(groot=groot), DEBUG=True ) print('+ Busca Terminada')
def main(radio_idx): global radio radio = Radio(int(radio_idx), mic_threshold=MIC_THRESHOLD, input_rate=INPUT_RATE, input_id=INPUT_ID, output_id=OUTPUT_ID) # initialize volume control # volume_thread = Thread(target=volume_main) # volume_thread.start() # # channel_selection_thread = Thread(target=channel_selection) # channel_selection_thread.start() # power button powerButton = Button(POWER_PIN, pull_up=False) # mute button muteButton = Button(MUTE_PIN, pull_up=False) powerButton.when_pressed = switchedOn powerButton.when_released = switchedOff muteButton.when_pressed = unmuteMic muteButton.when_released = muteMic # assign functions for change volume volControlB.when_pressed = volcw volControlA.when_pressed = volccw # assign functions for change channel chnlControlB.when_pressed = chnlcw chnlControlA.when_pressed = chnlccw radio.connect(server=0) radio.start_speaker_stream() #print("play poweron") #radio.play_bilingual_notification(POWERON) while True: radio.stream_mic_segment_to_server() # print("curr", radio.get_current_channel()) # print("new", channel) # print("now", time()) # print("last", lastUpdateTime) if radio.get_current_channel() != channel and time() - lastUpdateTime > 1: # print("changing channel...") radio.change_channel(channel) radio.play_bilingual_notification(CHNLS[channel])
def __init__(self): """ Instantiate the AUV object """ self.mc = MotorController() # Connection to onboard radio. try: # Jack Silberman's radio #self.radio = Radio('/dev/serial/by-id/usb-FTDI_FT230X_Basic_UART_DN038PQU-if00-port0') # Yonder's radio self.radio = Radio( '/dev/serial/by-id/usb-Silicon_Labs_CP2102_USB_to_UART_Bridge_Controller_0001-if00-port0') except Exception, e: print("Radio not found. Exception is: ", e) print("Exiting") exit(1)
def main(): """Runs the gateway""" loop = asyncio.get_event_loop() router = Router() loop.run_until_complete(router.connect_to_message_queue()) initialize_gpio() radio = Radio() router.set_send_packet(radio.send_packet) poll(loop, radio, router) try: loop.run_forever() finally: loop.close()
def __init__(self, jid, password, rooms, nick, token, groups): # XMPP super(Jabbergram, self).__init__(jid, password) self.add_event_handler('session_start', self.start) self.add_event_handler('groupchat_message', self.muc_message) self.muc_rooms = rooms.split() self.nick = nick self.token = token self.xmpp_users = {} self.jid = jid self.radio = Radio() for muc in self.muc_rooms: self.add_event_handler("muc::%s::got_online" % muc, self.muc_online) self.add_event_handler("muc::%s::got_offline" % muc, self.muc_offline) # Telegram self.groups = groups.split() self.bot = telegram.Bot(self.token) self.telegram_users = {} # put tg connector in a thread def start_read_tg_loop(): t = Thread(target=self.read_tg) t.daemon = True t.start() self.radio.once('http-upload-initialized', start_read_tg_loop) # initialize http upload on a thread since its needed to be connected # to xmpp t = Thread(target=self.init_http) t.daemon = True t.start() log('Please wait a couple of minutes until it\'s correctly ' 'connected.')
def main(): pa = Parser() naam, url, comm = pa.zendervinden() print naam, url, comm cursor.hide() fa = Fabriek() co = fa.returnCommunicatorObject(comm) rd = Radio() t = threading.Thread(target=rd.afspelen, args=(naam, url, co)) t.start() ## Afspelen stoppen na drukken op één van de EXITKEYS kp = Keypress() while kp.getexitkeypress() == False: time.sleep(0.2) cursor.show() rd.stoppen() return 0
def test_normal(self): radio = Radio() t1 = SenderTerminal("t1", "00:00:00:00:00:01", "192.168.0.1", radio) t1.x = 100 t1.y = 40 radio.add_node(t1) t2 = ReceiverTerminal("t2", "00:00:00:00:00:02", "192.168.0.2", radio) t2.x = 100 t2.y = -40 radio.add_node(t2) globals.now = 0 globals.events = sorted(globals.events, key=lambda x: x.time) while True: if len(globals.events) == 0: break globals.events = sorted(globals.events, key=lambda x: x.time) events_work = copy.copy(globals.events) event = globals.events[0] globals.now = event.time if globals.now > 10: break break for event in events_work: if event.time <= globals.now: event.call() globals.events.pop(0) else: break self.assertEqual(250000, t2.total_received_byte * 8 / globals.now)
def generate(): radio = Radio() data = radio.track() print(str(data)) return [str(data) + "\n"]
import sys sys.path.append("libs") import http.server import urllib.parse, json from myglobals import MyGlobals from checkbox import Checkbox from scatter import Scatter from radio import Radio from chart import Chart from excel import Excel from table import Table checkbox = Checkbox() scatter = Scatter() radio = Radio() chart = Chart() xl = Excel() table = Table() class Handler(http.server.BaseHTTPRequestHandler): def do_POST(self): jsonResponse = self.rfile.read(int(self.headers['Content-Length'])) self.send_response(200) self.end_headers() jsonAsString = jsonResponse.decode("UTF-8") results = json.loads(jsonAsString)
slots = jsonIntent["slots"] for i in range(len(slots)): if slots[i]['slotName'] == slot_name: return slots[i]['value']['value'] return default_value def end_session(intent, sentence): print('session: ' + intent + ': ' + sentence) return EndSession(sentence) @app.on_intent("PlayInternetRadio") async def startListening(intent: NluIntent): radio_station = get_slot_value_by_slot_name(intent, 'radio_station', None) sentence = radio.play_radio_station(radio_station) return end_session('Start Listening to Internet Radio', sentence) @app.on_intent("Stop") async def stopListening(intent: NluIntent): sentence = radio.stop_radio() return end_session('Stop Listening to Internet Radio', sentence) if __name__ == "__main__": config = read_configuration_file() language = read_language_file(config['setup']['language']) radio = Radio({"config": config, "language": language}) app.run()
def __init__(self, blockDevice, baudRate): signal.signal(signal.SIGALRM, ncursesSignalHandler) self.radio = Radio(blockDevice, baudRate)
def experiment_cicles(cicles=5, set_size=500): weight_df = pd.DataFrame(columns=list([])) evaluate_df = pd.DataFrame(columns=list([])) similarity_df = pd.DataFrame(columns=list()) for i in range(cicles): print('- * - Iniciando o Ciclo: ', str(i)) if set_size > 0: print("+ Extraindo " + str(set_size) + " músicas") extractSet(set_size=set_size) print('+ Carregando dados no sistema') groot = Radio(load_data_songs(), load_data_users()) print('+ Processando dados') groot.post_preference_set( preference_set=make_set_to_process( song_set=groot.get_song_set(), dict_set=statisticalOverview( songSet=groot.get_song_set(), preferenceSet=groot.get_preference_set(), DEBUG=False ), DEBUG=False ) ) print('+ Treinando a árvore') classifier, evaluate_results = plant_the_tree( set_to_process=preprocessing_data( data_set=groot.get_preference_set(), all_features=groot.get_all_features(), DEBUG=False ), features=groot.get_song_features(), important_feature=groot.get_important_feature(), DEBUG=False, ADMIN=False ) groot.post_classifier( new_classifier=classifier ) print('+ Obtendo similaridade entre as músicas') groot.post_distance_matrix( new_distance_matrix=get_song_distance( song_set=groot.get_song_set(), song_features=groot.get_song_features(), classifier_important=groot.get_feature_weight(), DEBUG=False ) ) print('+ Iniciando a busca') similarity = environment( groot=groot, song_stages=random_choice(groot=groot), DEBUG=False ) print('+ Busca Terminada') print('Salvando informações') # weight_df = pd.concat([weight_df, pd.DataFrame( [[i for i in list(groot.get_classifier().feature_importances_)]], columns=[i for i in list(groot.get_song_features())], )], sort=False) # evaluate_df = pd.concat([evaluate_df, pd.DataFrame( [[i for i in evaluate_results.values()]], columns=[x for x in evaluate_results], )], sort=False) # similarity_df = pd.concat([similarity_df, pd.DataFrame( [[i for i in similarity.values()]], columns=[x for x in similarity], )], sort=False) plot_feature_importance(weight_df) plot_evaluations(evaluate_df) plot_similarity(similarity_df['similaridade'].tolist()) plot_final_state(similarity_df['final_state'].tolist()) plot_nodes(similarity_df['total_visitas'].tolist())
def parse_config_file(self): """ This method parses the configuration file and check that all parameters follow the prerequisites. """ with open(self._filename) as f: # Opening configuration file tree = json.load(f) # Parsing json content # Closing file f.close() # First, let's load the list of radios for radio in tree['radios']: # Load attributes long_name = radio['long_name'] short_name = radio['short_name'] stream_url = radio['stream_url'] media_type = radio['type'] module_name = None if 'module_name' in radio: module_name = radio['module_name'] # Check radio attributes type if not isinstance(long_name, str): raise ConfigurationFileException( "radios.radio.long_name must be a string") if not isinstance(short_name, str): raise ConfigurationFileException( "radios.radio.short_name must be a string") if not isinstance(stream_url, str): raise ConfigurationFileException( "radios.radio.stream_url must be a string") if not isinstance(media_type, str): raise ConfigurationFileException( "radios.radio.type must be a string") if module_name is not None and not isinstance(module_name, str): raise ConfigurationFileException( "radios.radio.module_name must be a string") # Check attribute value and size if len(long_name) > 32: raise ConfigurationFileException( "radios.radio.long_name must not exceed 32 characters") if len(short_name) > 16: raise ConfigurationFileException( "radios.radio.short_name must not exceed 16 characters") if media_type != "stream" and media_type != "folder": raise ConfigurationFileException( "radios.radio.type must be either 'stream' or 'folder'") # Register new radio r = Radio(long_name, short_name, stream_url, media_type, module_name) self._radios.append(r) if len(self._radios) <= 0: raise ConfigurationFileException("No radio available.") # Then, load other mandatory properties self._name = tree['general']['name'] self._halt_message = tree['general']['halt_message'] self._default_volume = tree['general']['default_volume'] self._volume_step = tree['general']['volume_step'] self._volume_timer = tree['display']['volume_timer'] self._scroll_time_interval = tree['display']['scroll_time_interval'] self._scroll_time_pause = tree['display']['scroll_time_pause'] self._serial_device = tree['display']['serial_device'] self._serial_baud_rate = tree['display']['serial_baud_rate'] self._radio_info_check_interval = tree['general'][ 'radio_info_check_interval'] self._full_radio_name_pause = tree['general']['full_radio_name_pause'] self._save_file_path = tree['general']['save_file_path'] # Check var type if not isinstance(self._name, str): raise ConfigurationFileException( "general.name parameter must be a string") if not isinstance(self._halt_message, str): raise ConfigurationFileException( "general.halt_message parameter must be a string") if not isinstance(self._default_volume, numbers.Number): raise ConfigurationFileException( "general.default_volume parameter must be a number") if not isinstance(self._volume_step, numbers.Number): raise ConfigurationFileException( "general.volume_step parameter must be a number") if not isinstance(self._volume_timer, numbers.Number): raise ConfigurationFileException( "display.volume_timer parameter must be a number") if not isinstance(self._scroll_time_interval, numbers.Number): raise ConfigurationFileException( "display.scroll_time_interval parameter must be a number") if not isinstance(self._scroll_time_pause, numbers.Number): raise ConfigurationFileException( "display.scroll_time_pause parameter must be a number") if not isinstance(self._serial_device, str): raise ConfigurationFileException( "display.serial_device parameter must be a string") if not isinstance(self._serial_baud_rate, numbers.Number): raise ConfigurationFileException( "display.serial_baud_rate parameter must be a number") if not isinstance(self._radio_info_check_interval, numbers.Number): raise ConfigurationFileException( "general.radio_info_check_interval parameter must be a number") if not isinstance(self._full_radio_name_pause, numbers.Number): raise ConfigurationFileException( "general.full_radio_name_pause parameter must be a number") if not isinstance(self._save_file_path, str): raise ConfigurationFileException( "general.save_file_path parameter must be a string") # Check var value and size if len(self._name) > 32: raise ConfigurationFileException( "general.name must not exceed 32 characters") if len(self._halt_message) > 32: raise ConfigurationFileException( "general.halt_message must not exceed 32 characters") if self._default_volume > 100 or self._default_volume < 0: raise ConfigurationFileException( "general.default_volume must be between 0 and 100") if self._volume_step > 40 or self._volume_step <= 0: raise ConfigurationFileException( "general.volume_step must be between 1 and 40") if self._volume_timer < 0: raise ConfigurationFileException( "display.volume_timer must be a positive value (in seconds)") if self._scroll_time_interval <= 0: raise ConfigurationFileException( "display.scroll_time_interval must be a non-null positive value (in seconds)" ) if self._scroll_time_pause < 0: raise ConfigurationFileException( "display.scroll_time_pause must be a positive value (in seconds)" ) if self._serial_baud_rate <= 0: raise ConfigurationFileException( "display.serial_baud_rate must be a non-null positive value") if self._radio_info_check_interval <= 0: raise ConfigurationFileException( "general.radio_info_check_interval must be a non-null positive value (in seconds)" ) if self._full_radio_name_pause < 0: raise ConfigurationFileException( "general.full_radio_name_pause must be a positive value (in seconds)" ) # Now, let's try to load cached settings if exist self.load_cached_settings(self._save_file_path)
def start(self, station_id, station_from): log("Yandex.Radio::start") self.radio = Radio(client, station_id, station_from) self.radio.start_radio(self.__on_start)
from radio import Channel, Radio # The FM broadcast band, used for FM broadcast radio by radio stations, # differs between different parts of the world. # In Europe, Australia[1] and Africa - from 87.5 to 108 megahertz (MHz) # A Channel has a frequency (between 87.5 and 108), a name, and a playlist ch1 = Channel("VGOLOS", 107.2, ["Susy", "Without You", "That's Enough"]) assert(ch1.getFrequency() == 107.2) assert(str(ch1) == \ """Channel VGOLOS on 107.2, playlist: ['Susy', 'Without You', "That's Enough"]""") ch2 = Channel("Oles FM", 91.1, ["911"]) assert(str(ch2) == "Channel Oles FM on 91.1, playlist: ['911']") assert(ch2.playlist == ['911']) assert(ch2 == Channel("Oles FM", 91.1, ["911"])) assert(ch2 != ch1) assert(ch2 != "Oles FM") s = set() assert(ch2 not in s) s.add(ch2) assert(Channel("Oles FM", 91.1, ["911"]) in s) assert(ch1 not in s) # A Radio (FM Radio) can be tuned to receive channels # based on some different frequencies channels = { 107.2 : ch1, 91.1 : ch2 } radio = Radio(channels, 107.25) assert(radio.getCurrentFrequency() == 107.25) # A Radio receives a channel if it’s tuned within 0.05 Hz of that channel’s # frequency. You’re guaranteed that channel frequencies will always be # at least 0.05 Hz apart. assert(radio.getCurrentChannel() == ch1)
from radio import Radio objeto_radio = Radio(input("Ingrese una marca: ")) desea_continuar = True while desea_continuar: print("Marca: ", objeto_radio.marca) print("Encendido: ", objeto_radio.encendido) print("Volumen: ", objeto_radio.volumen) print("Fm: ", objeto_radio.en_fm) print("Emisora AM: ", objeto_radio.emisora_am) print("Emisora FM: ", objeto_radio.emisora_fm) if objeto_radio.encendido == False: opcion = int(input(("1. Encender: "))) if opcion == 1: objeto_radio.encender() if objeto_radio.encendido == True: opcion2 = int( input((""" 1. Apagar 2. Subir Volumen 3. Bajar Volumen 4. Cambiar Frecuencia 5. Subir Emisora 6. Bajar Emisora """))) if opcion2 == 1: objeto_radio.apagar()
#! /usr/bin/env python2 from radio import Radio from databaseController import DatabaseController from RaspberryAudioController import RaspberryAudioController login = '******' password = '******' ip = '127.0.0.1' database = 'radio' db = DatabaseController(login, password, ip, database) db.connect() stations = db.getStationsList() rd = Radio(stations) audioController = RaspberryAudioController(30) paused = True mapping = db.getGesturesDict() db.insertDescribedAction('volume_up', str(audioController.getVolume())) while True: print( "1. volume up\n2. volume down\n3. station up\n4. station down\n5. play\pause\n" ) action = int(input()) if action == mapping['volume_up']: audioController.volumeUp() db.insertDescribedAction('volume_up', str(audioController.getVolume())) if action == mapping['volume_down']: audioController.volumeDown()
from math import floor from random import random from time import sleep from yandex_music import Client from radio import Radio # API instance client = Client(token="YOUR_TOKEN_HERE") # Get random station _stations = client.rotor_stations_list() _station_random_index = floor(len(_stations) * random()) _station = _stations[_station_random_index].station _station_id = f'{_station.id.type}:{_station.id.tag}' _station_from = _station.id_for_from # Radio instance radio = Radio(client) # start radio and get first track first_track = radio.start_radio(_station_id, _station_from) print("[Radio] First track is:", first_track) # get new track every 5 sec while True: sleep(5) next_track = radio.play_next() print("[Radio] Next track is:", next_track)
args = parser.parse_args() if args.custom_coords is not None: lat, lon = args.custom_coords.strip().split(',') utils.REF_LAT, utils.REF_LON = float(lat), float(lon) else: utils.set_loc_ip() print(f'Using reference coordinates of: {utils.REF_LAT}, {utils.REF_LON}') msg_que = Queue() if args.input is not None: print(f"Using MockRadio with {args.input}") radio = MockRadio(msg_que, args.input, args.repeat, args.delay, args.delay) else: print('Setting up radio') radio = Radio(msg_que) print('Done') if args.gui: run_gui(radio, args.debug) else: while True: msgs = radio.get_all_queue() for m in msgs: if m.valid: print(m) if args.output is not None and (m.valid or args.output_invalid): args.output.write(f'{round(time.time())} {m.bin_msg}\n')