Merge branch 'master' into Noisegate_sounddevice_update

Reviewed-on: http://git.vpn.cusano.net/Discord_Bot_Gang/Discord-Radio-Bot/pulls/11

.gitignore

@@ -2,10 +2,11 @@
 /Releases/
 /Old/
 **/__pycache__/
-/venv/
+**/venv/
 *.7z
 *.bat
 /DSDPlus/
-._.DS_Store
+**/._.DS_Store
 *.log
 *.ini
+**/logs/*

BotResources.py

@@ -1,17 +1,41 @@
 import configparser
+import logging
+import os
+from datetime import date
 from os.path import exists
-from NoiseGatev2 import AudioStream
+from NoiseGatev2 import AudioStream, query_devices
 
+# Handler configs
 PDB_ACCEPTABLE_HANDLERS = {'gqrx': {
                                'Modes': ['wfm', 'fm']
                            },
                            'op25': {
                                'Modes': ['d', 'p25']
                            }}
+
+# Known bot IDs
 PDB_KNOWN_BOT_IDS = {756327271597473863: "Greada", 915064996994633729: "Jorn", 943742040255115304: "Brent"}
 
+# Default value to set noisegate on new or unknown profiles
 DEFAULT_NOISEGATE_THRESHOLD = 50
 
+# Initialize the logger for this file
+LOGGER = logging.getLogger('Discord_Radio_Bot.Bot_Resources')
+
+# Location of the gqrx binary
+GQRX_BIN_LOCATION = "/usr/bin/"
+GQRX_BIN = "/usr/bin/gqrx"
+
+
+# Default radio settings
+DEFAULT_RADIO_SETTINGS = {
+    'profile_name': None,
+    'freq': "104700000",
+    'mode': "wfm",
+    'squelch': 0,
+    'noisegate_sensitivity': DEFAULT_NOISEGATE_THRESHOLD,
+}
+
 
 def check_if_config_exists():
     if exists('./config.ini'):
@@ -38,9 +62,9 @@ def read_config_file():
         'Handler': str(config['Config']['Handler'])
     }
 
-    print("Found config options:")
+    LOGGER.debug("Found config options:")
     for key in config_return.keys():
-        print(f"\t{key} : {config_return[key]}")
+        LOGGER.debug(f"\t{key} : {config_return[key]}")
 
     return config_return
 
@@ -91,14 +115,14 @@ def write_config_file(**kwargs):
     with open('./config.ini', 'w') as config_file:
         config.write(config_file)
 
-    print("Config Saved")
+    LOGGER.info("Config Saved")
 
     return True
 
 
 def get_device_list():
-    list_of_devices = sound.query_devices().items()
-    print(list_of_devices)
+    list_of_devices = query_devices().items()
+    LOGGER.debug(list_of_devices)
     return list_of_devices
 
 
@@ -106,38 +130,38 @@ def get_user_device_selection():
     device_list = get_device_list()
     org_device_list = []
     for device, dev_id in device_list:
-        print(f"{dev_id + 1}\t-\t{device}")
+        LOGGER.debug(f"{dev_id + 1}\t-\t{device}")
         org_device_list.append((dev_id, device))
     selected_list_id = None
     selected_device = None
     while not selected_list_id:
-        print(f"selected device: {selected_list_id}")
-        print(device_list)
+        LOGGER.debug(f"selected device: {selected_list_id}")
+        LOGGER.debug(device_list)
 
         try:
             selected_list_id = int(input(f"Please select the input device from above:\t"))            
 
         except Exception as e:
-            print(e)
+            LOGGER.warning(e)
             continue             
 
         if int(selected_list_id) < int(len(device_list)):
-            print("ford")
+            LOGGER.debug("Selected ID within range")
             continue
         elif selected_list_id > int(len(device_list)):
-            print("Out of range, try again...")
+            LOGGER.debug("Out of range, try again...")
             selected_list_id = None
             continue
         else:
             selected_list_id = None
-            print("Internal error, try again")
+            LOGGER.error("Internal error, try again")
             continue
 
     for dev_dict in org_device_list:
-        print(list(device_list)[selected_list_id-1][0])
+        LOGGER.debug(list(device_list)[selected_list_id-1][0])
         if dev_dict[1] == list(device_list)[selected_list_id-1][0]:            
             selected_device = dev_dict
-            print(selected_device)
+            LOGGER.debug(selected_device)
 
     return selected_device
 
@@ -149,7 +173,7 @@ def get_user_token():
         if len(token) == 59:
             return token
         else:
-            print('Length error in token, please try again...')
+            LOGGER.error('Length error in token, please try again...')
             token = None
             continue
 
@@ -168,7 +192,7 @@ def get_user_mention_channel_id():
         if len(str(channel_id)) == len('757379843792044102'):
             return channel_id
         else:
-            print("Length error in ID, please try again")
+            LOGGER.error("Length error in ID, please try again")
             channel_id = None
             continue
 
@@ -204,3 +228,45 @@ async def check_and_reply_to_ping(bot, message):
     else:
         await bot.process_commands(message)
         return False
+
+
+# Create the logger
+def init_global_logger(_verbose_level: str = "WARNING"):
+    numeric_log_level = getattr(logging, _verbose_level.upper(), None)
+    if not isinstance(numeric_log_level, int):
+        raise ValueError('Invalid log level: %s' % _verbose_level)
+    else:
+        # create logger
+        init_logger = logging.getLogger('Discord_Radio_Bot')
+        init_logger.setLevel(logging.DEBUG)
+
+        # create file handler which logs even debug messages
+        if not exists("./logs/"):
+            os.mkdir("./logs/")
+        fh = logging.FileHandler(f'./logs/DRB-{date.today()}.log')
+        fh.setLevel(logging.INFO)
+
+        fh_debug = logging.FileHandler(f'./logs/DRB-{date.today()}.DEBUG.log')
+        fh_debug.setLevel(logging.DEBUG)
+
+        # create terminal handler with a higher log level
+        th = logging.StreamHandler()
+        th.setLevel(numeric_log_level)
+
+        # create formatter and add it to the handlers
+        fh_debug_formatter = logging.Formatter('[%(asctime)s %(name)s->%(funcName)s():%(lineno)s] - %(levelname)s - %(message)s')
+        fh_formatter = logging.Formatter('[%(asctime)s %(name)s->%(funcName)s()] - %(levelname)s - %(message)s')
+        th_formatter = logging.Formatter('[%(asctime)s %(name)s->%(funcName)s()] - %(levelname)s - %(message)s')
+        fh_debug.setFormatter(fh_debug_formatter)
+        fh.setFormatter(fh_formatter)
+        th.setFormatter(th_formatter)
+
+        # add the handlers to the logger
+        init_logger.addHandler(fh)
+        init_logger.addHandler(th)
+        init_logger.addHandler(fh_debug)
+
+
+#if __name__ is not 'main':
+#    init_global_logger()
+#    LOGGER = logging.getLogger('Discord_Radio_Bot')

NoiseGatev2.py

@@ -1,103 +1,58 @@
 import audioop
+import logging
 import math
+import time
+import sounddevice
 import pyaudio
 import discord
 import numpy
+from pprint import pformat
 
 voice_connection = None
 
+LOGGER = logging.getLogger("Discord_Radio_Bot.NoiseGateV2")
+DEFAULT = 0
 
+
+# noinspection PyUnresolvedReferences
 class AudioStream:
     def __init__(self, _channels: int = 2, _sample_rate: int = 48000, _frames_per_buffer: int = 1024,
-                 _input_device_index: int = None, _output_device_index: int = None, _input: bool = True,
-                 _output: bool = True, _init_on_startup: bool = True):
-        self.paInstance_kwargs = {
-            'format': pyaudio.paInt16,
+                 _device_index: int = None, _init_on_startup: bool = True):
+        self.sd_kwargs = {
+            'dtype': 'int16',
             'channels': _channels,
-            'rate': _sample_rate,
-            'input': _input,
-            'output': _output,
-            'frames_per_buffer': _frames_per_buffer
+            'samplerate': _sample_rate,
+            'blocksize': _frames_per_buffer
         }
 
-        if _input_device_index:
-            if _input:
-                self.paInstance_kwargs['input_device_index'] = _input_device_index
-            else:
-                print(f"[AudioStream.__init__]:\tInput was not enabled."
-                      f" Reinitialize with '_input=True'")
+        if _device_index:
+            self.sd_kwargs['device'] = _device_index
 
-        if _output_device_index:
-            if _output:
-                self.paInstance_kwargs['output_device_index'] = _output_device_index
-            else:
-                print(f"[AudioStream.__init__]:\tOutput was not enabled."
-                      f" Reinitialize with '_output=True'")
+        # Define and initialize stream object if we have been passed a device ID (pyaudio.open)
+        self.stream = None
 
-        if _init_on_startup:
-            # Init PyAudio instance
-            print("Creating PyAudio instance")
-            self.paInstance = pyaudio.PyAudio()
-
-            # Define and initialize stream object if we have been passed a device ID (pyaudio.open)
-            self.stream = None
-
-        if _output_device_index or _input_device_index:
+        if _device_index:
             if _init_on_startup:
-                print("Init stream")
+                LOGGER.info("Init stream")
                 self.init_stream()
 
-    def init_stream(self, _new_output_device_index: int = None, _new_input_device_index: int = None):
+    def init_stream(self, _new_device_index: int = None):
         # Check what device was asked to be changed (or set)
-        if _new_input_device_index:
-            if self.paInstance_kwargs['input']:
-                self.paInstance_kwargs['input_device_index'] = _new_input_device_index
-            else:
-                print(f"[AudioStream.init_stream]:\tInput was not enabled when initialized."
-                      f" Reinitialize with '_input=True'")
-
-        if _new_output_device_index:
-            if self.paInstance_kwargs['output']:
-                self.paInstance_kwargs['output_device_index'] = _new_output_device_index
-            else:
-                print(f"[AudioStream.init_stream]:\tOutput was not enabled when initialized."
-                      f" Reinitialize with '_output=True'")
+        if _new_device_index:
+            self.sd_kwargs['device'] = _new_input_device_index
 
         self.close_if_open()
 
         # Open the stream
-        self.stream = self.paInstance.open(**self.paInstance_kwargs)
+        self.stream = sounddevice.RawStream(**self.sd_kwargs)
 
     def close_if_open(self):
         # Stop the stream if it is started
         if self.stream:
-            if self.stream.is_active():
-                self.stream.stop_stream()
+            if self.stream.active:
+                self.stream.stop()
                 self.stream.close()
-                print(f"[ReopenStream.close_if_open]:\t Stream was open; It was closed.")
-
-    def list_devices(self, _display_input_devices: bool = True, _display_output_devices: bool = True):
-        info = self.paInstance.get_host_api_info_by_index(0)
-        numdevices = info.get('deviceCount')
-
-        devices = {
-            'Input': {},
-            'Output': {}
-        }
-        for i in range(0, numdevices):
-            if (self.paInstance.get_device_info_by_host_api_device_index(0, i).get('maxInputChannels')) > 0:
-                input_device = self.paInstance.get_device_info_by_host_api_device_index(0, i).get('name')
-                devices['Input'][i] = input_device
-                if _display_input_devices:
-                    print("Input Device id ", i, " - ", input_device)
-
-            if (self.paInstance.get_device_info_by_host_api_device_index(0, i).get('maxOutputChannels')) > 0:
-                output_device = self.paInstance.get_device_info_by_host_api_device_index(0, i).get('name')
-                devices['Output'][i] = output_device
-                if _display_output_devices:
-                    print("Output Device id ", i, " - ", output_device)
-
-        return devices
+                LOGGER.debug(f"[ReopenStream.close_if_open]:\t Stream was open; It was closed.")
 
     async def stop(self):
         await voice_connection.disconnect()
@@ -106,6 +61,7 @@ class AudioStream:
         self.paInstance.terminate()
 
 
+# noinspection PyUnresolvedReferences
 class NoiseGate(AudioStream):
     def __init__(self, _voice_connection, _noise_gate_threshold: int, **kwargs):
         super(NoiseGate, self).__init__(_init_on_startup=True, **kwargs)
@@ -113,25 +69,43 @@ class NoiseGate(AudioStream):
         voice_connection = _voice_connection
         self.THRESHOLD = _noise_gate_threshold
         self.NGStream = NoiseGateStream(self)
+        self.Voice_Connection_Thread = None
 
     def run(self) -> None:
         global voice_connection
         # Start the audio stream
-        self.stream.start_stream()
-        voice_connection.play(self.NGStream)
+        LOGGER.debug(f"Starting stream")
+        self.stream.start()
+        # Start the stream to discord
+        self.core()
+
+    def core(self, error=None):
+        if error:
+            LOGGER.warning(error)
+
+        while not voice_connection.is_connected():
+            time.sleep(.2)
+
+        if not voice_connection.is_playing():
+            LOGGER.debug(f"Playing stream to discord")
+            voice_connection.play(self.NGStream, after=self.core)
 
     async def close(self):
+        LOGGER.debug(f"Closing")
         await voice_connection.disconnect()
-        if self.stream.is_active:
-            self.stream.stop_stream()
+        if self.stream.active:
+            self.stream.stop()
+            LOGGER.debug(f"Stopping stream")
 
+
+# noinspection PyUnresolvedReferences
 class NoiseGateStream(discord.AudioSource):
     def __init__(self, _stream):
         super(NoiseGateStream, self).__init__()
         self.stream = _stream       # The actual audio stream object
-        self.NG_fadeout = 480/20    # Fadeout value used to hold the noisegate after de-triggering
+        self.NG_fadeout = 240/20    # Fadeout value used to hold the noisegate after de-triggering
         self.NG_fadeout_count = 0   # A count set when the noisegate is triggered and was de-triggered
-        self.process_set_count = 0  # Counts how many processes have been made in order to limit the prints
+        self.process_set_count = 0  # Counts how many processes have been made
 
     def read(self):
         try:
@@ -142,7 +116,10 @@ class NoiseGateStream(discord.AudioSource):
                     buffer_decibel = 20 * math.log10(buffer_rms)
 
                     if self.process_set_count % 10 == 0:
-                        print(f"{buffer_decibel} db")
+                        if buffer_decibel >= self.stream.THRESHOLD:
+                            LOGGER.debug(f"[Noisegate Open] {buffer_decibel} db")
+                        else:
+                            LOGGER.debug(f"[Noisegate Closed] {buffer_decibel} db")
 
                     if buffer_decibel >= self.stream.THRESHOLD:
                         self.NG_fadeout_count = self.NG_fadeout
@@ -153,12 +130,13 @@ class NoiseGateStream(discord.AudioSource):
                     else:
                         if self.NG_fadeout_count > 0:
                             self.NG_fadeout_count -= 1
-                            print(f"Frames in fadeout remaining: {self.NG_fadeout_count}")
+                            LOGGER.debug(f"Frames in fadeout remaining: {self.NG_fadeout_count}")
                             self.process_set_count += 1
                             if curr_buffer:
                                 return bytes(curr_buffer)
 
         except OSError as e:
+            LOGGER.warning(e)
             pass
 
     def audio_datalist_set_volume(self, datalist, volume):
@@ -173,6 +151,31 @@ class NoiseGateStream(discord.AudioSource):
             datalist[i] = chunk.astype(numpy.int16)
 
 
+class DeviceNotFoundError(Exception):
+    def __init__(self):
+        self.devices = sounddevice.query_devices()
+        self.host_apis = sounddevice.query_hostapis()
+        super().__init__("No Devices Found")
+    def __str__(self):
+        return (
+            f"Devices \n"
+            f"{self.devices} \n "
+            f"Host APIs \n"
+            f"{pformat(self.host_apis)}"
+        )
+
+
+def query_devices():
+    options = {
+        device.get("name"): index
+        for index, device in enumerate(sounddevice.query_devices())
+        if (device.get("max_input_channels") > 0 and device.get("hostapi") == DEFAULT)
+    }
+    if not options:
+        raise DeviceNotFoundError()
+    return options
+
+
 if __name__ == '__main__':
 
     input_index = int(input("Input:\t"))

README.md

@@ -9,10 +9,11 @@ This project is intended to allow users in discord to be able to listen to their
 
 ## Setup
 1. Install the pip packages found in the ```Requirements.txt``` file
-2. Run ```main.py``` with Python
-3. Follow the prompts in the terminal
-4. Ensure your audio is playing on the selected device
-5. You're all set! Ask the bot to join!
+    - *Optional if you are using OP25* Run `echo 0 > /sys/module/usbcore/parameters/usbfs_memory_mb`
+3. Run ```main.py``` with Python 
+4. Follow the prompts in the terminal
+5. Ensure your audio is playing on the selected device
+5You're all set! Ask the bot to join!
 
 ### Understanding Audio Input
 This title can be a bit confusing. The bot will display both 'input' and 'output' devices but not always *all* devices connected.
@@ -22,4 +23,9 @@ Voicemeeter is **highly** recommended for this bot. See a detailed guide on how
 To change the audio source, simply delete the ```config.ini``` that was generated and restart the bot. 
 It will re-do the setup and allow you to select a new device. 
 
-### [To-Do](https://git.vpn.cusano.net/Discord_Bot_Gang/Discord-Radio-Bot/src/branch/master/TODO.md)
+### [To-Do](https://git.vpn.cusano.net/Discord_Bot_Gang/Discord-Radio-Bot/src/branch/master/TODO.md)
+
+
+**Notes for readme leter on**
+- Users need to save profile after any change in discord
+- 

TODO.md

@@ -1,20 +1,48 @@
-## To-Do
-### Main Bot
+# To-Do
+## Main Bot
+### Main Development
+#### Core
+- [ ] Add new handlers for GQRX: https://github.com/gqrx-sdr/gqrx/blob/master/resources/remote-control.txt
+- [ ] Add logging for Elasticstack https://www.elastic.co/guide/en/ecs-logging/python/master/installation.html
+  - [ ] Add a process handler to start/stop gqrx
 - [ ] Fix the bug where they *disconnect* after a period of time and must be manually moved out and back in to hear them
   - *May* have been fixed with the noise gate?
 - [ ] Fix bug that shows different index number for audio device selection on linux
+  - [ ] New bug on linux shows a bunch of ALSA output
 - [x] Add more proper help text with real examples for discord commands
 - [x] Add command line args with argparse for main bot
   - [x] Add method for user to change audio device without redoing entire config file
+- [ ] Need to create a method for the bot to toggle debug mode for OP25
+
+#### Features
+- [ ] Add to a linux service
+- [ ] Add a function to the bot to allow *authorized* users to; update, restart, git pull, etc.
+
+### Polishing
 - [ ] Clean up code
-- [ ] Transcode radio transmissions to text
-### Modules
-#### Willie Timer
+- [ ] Revise discord help text
+- [ ] Revise logging
+
+### Final
+- [ ] Create setup script
+  - [ ] Test setup
+- [ ] Revise readme
+
+--------------------------------------------
+## Modules
+### Willie Timer
+- [ ] Revise the current loop, ensure it re-enters itself after triggering
+  - [ ] Can we use a cron somehow?
 - [ ] Get more training data for WillieTimer
   - [ ] Use the ```Phrases.txt``` file as the random seed? 
-  - [ ] Figure out a way to give the model a suggestion 
+  - [ ] Figure out a way to give the model a suggestion
 
-### Done Previously
+-------------------------------
+## Dreams
+- [ ] Transcode radio transmissions to text
+
+---------------------
+## Done Previously
 - [x] Interact with soapysdr directly from the bot
   - [x] Allow chat interaction with soapysdr
 - [x] Move cogs to their own files

bot.py

@@ -1,4 +1,5 @@
 import asyncio
+import logging
 import os
 import platform
 import discord
@@ -17,6 +18,9 @@ class Bot(commands.Bot):
         commands.Bot.__init__(self, command_prefix=commands.when_mentioned_or(kwargs['command_prefix']),
                               activity=discord.Game(name=f"@ me"), status=discord.Status.idle)
 
+        # Create the logger for the bot
+        self.logger = logging.getLogger("Discord_Radio_Bot.Bot")
+
         # Init the core bot variables
         self.DEVICE_ID = kwargs['Device_ID']
         self.DEVICE_NAME = kwargs['Device_Name']
@@ -33,16 +37,14 @@ class Bot(commands.Bot):
         self.Bot_Connected = False
 
         # Init the audio devices list
-        #self.Devices_List = sound.query_devices().items()
-        self.Devices_List = NoiseGatev2.AudioStream().list_devices(_display_input_devices=False,
-                                                                   _display_output_devices=False)
+        self.Devices_List = NoiseGatev2.query_devices().items()
 
         # Init radio parameters
-        self.profile_name = None
-        self.freq = "104700000"
-        self.mode = "wfm"
-        self.squelch = 0
-        self.noisegate_sensitivity = BotResources.DEFAULT_NOISEGATE_THRESHOLD
+        self.profile_name = BotResources.DEFAULT_RADIO_SETTINGS['profile_name']
+        self.freq = BotResources.DEFAULT_RADIO_SETTINGS['freq']
+        self.mode = BotResources.DEFAULT_RADIO_SETTINGS['mode']
+        self.squelch = BotResources.DEFAULT_RADIO_SETTINGS['squelch']
+        self.noisegate_sensitivity = BotResources.DEFAULT_RADIO_SETTINGS['noisegate_sensitivity']
 
         # Init SDR Variables
         self.system_os_type = None
@@ -82,7 +84,7 @@ class Bot(commands.Bot):
                       brief="Joins the voice channel that the caller is in")
         async def join(ctx, *, member: discord.Member = None):
             member = member or ctx.author.display_name
-            print(f"Join requested by {member}")
+            self.logger.info(f"Join requested by {member}")
 
             if not self.Bot_Connected:
                 # Wait for the bot to be ready to connect
@@ -93,82 +95,88 @@ class Bot(commands.Bot):
 
                 if discord.opus.is_loaded():
                     channel = ctx.author.voice.channel
-                    print("Sending hello")
+                    self.logger.debug("Sending hello")
                     await ctx.send(f"Ok {str(member).capitalize()}, I'm joining {channel}")
 
                     # Join the voice channel with the audio stream
-                    print('Joining')
+                    self.logger.debug('Joining')
                     voice_connection = await channel.connect()
 
                     # Create an audio stream from selected device
-                    print("Starting noisegate/stream handler")
-                    self.streamHandler = NoiseGatev2.NoiseGate(_input_device_index=self.DEVICE_ID,
+                    self.logger.debug("Starting noisegate/stream handler")
+                    self.streamHandler = NoiseGatev2.NoiseGate(_device_index=self.DEVICE_ID,
                                                                _voice_connection=voice_connection,
                                                                _noise_gate_threshold=self.noisegate_sensitivity)
                     # Start the audio stream
                     self.streamHandler.run()
 
                     # Start the SDR and begin playing to the audio stream
-                    print("Starting SDR")
+                    self.logger.debug("Starting SDR")
                     self.start_sdr()
 
                     # Change the activity to the channel and band-type being used
-                    print("Changing presence")
+                    self.logger.debug("Changing presence")
                     await self.set_activity()
 
                     # 'Lock' the bot from connecting
-                    print("Locking the bot")
+                    self.logger.debug("Locking the bot")
                     self.Bot_Connected = True
 
                 else:
                     # Return that the opus library would not load
                     await ctx.send("Opus won't load")
-                    print("OPUS didn't load properly")
+                    self.logger.critical("OPUS didn't load properly")
 
             else:
                 await ctx.send(f"{str(member).capitalize()}, I'm already connected")
-                print("Bot is already in a channel")
+                self.logger.info("Bot is already in a channel")
 
         @self.command(help="Use this command to have the bot leave your channel",
                       brief="Leaves the current voice channel")
         async def leave(ctx, member: discord.Member = None):
             member = member or ctx.author.display_name
-            print(f"Leave requested by {member}")
+            self.logger.info(f"Leave requested by {member}")
 
             if self.Bot_Connected:
                 # Stop the sound handlers
                 # Disconnect the client from the voice channel
-                print("Disconnecting")
+                self.logger.debug("Disconnecting")
                 await self.streamHandler.close()
 
-                print("Changing presence")
+                self.logger.debug("Changing presence")
                 # Change the presence to away and '@ me'
                 await self.set_activity(False)
 
                 # Stop the SDR so it can cool off
-                print("Stopping SDR")
+                self.logger.debug("Stopping SDR")
                 self.stop_sdr()
 
-                print("Unlocking the bot")
+                self.logger.debug("Unlocking the bot")
                 # 'Unlock' the bot
                 self.Bot_Connected = False
 
-                print("Sending Goodbye")
+                self.logger.debug("Sending Goodbye")
                 await ctx.send(f"Goodbye {str(member).capitalize()}.")
             else:
                 await ctx.send(f"{str(member).capitalize()}, I'm not in a channel")
+                self.logger.info("Bot is not in a channel")
 
         # Add command to change the NoiseGate threshold
         @self.command(help="Use this command to change the threshold of the noisegate",
                       brief="Change noisegate sensitivity")
         async def chngth(ctx, _threshold: int, member: discord.Member = None):
             member = member or ctx.author.display_name
-            print(f"Change of NoiseGate threshold requested by {member}")
+            self.logger.info(f"Change of NoiseGate threshold requested by {member}")
             await ctx.send(f"Ok {str(member).capitalize()}, I'm changing the threshold from "
                            f"{self.streamHandler.THRESHOLD} to {_threshold}")
             self.streamHandler.THRESHOLD = _threshold
-            if self.sdr_started:
-                await self.set_activity()
+            self.noisegate_sensitivity = _threshold
+
+            # Reset the profile name since we have made a change
+            self.profile_name = None
+
+            # If the SDR is started, restart it with the updates
+            await self.use_current_radio_config()
 
         # Add commands for GQRX and OP25
         if self.Handler in BotResources.PDB_ACCEPTABLE_HANDLERS.keys():
@@ -182,6 +190,7 @@ class Bot(commands.Bot):
                 member = member or ctx.author.display_name
                 message = self.display_current_radio_config()
                 await ctx.send(f"Ok {str(member).capitalize()},\n{message}")
+                self.logger.info(f"Displaying current profile; requested by {member}")
 
             # Command to display the current config
             @self.command(name='displayprofiles',
@@ -193,6 +202,7 @@ class Bot(commands.Bot):
                 member = member or ctx.author.display_name
                 message = self.display_saved_radio_configs()
                 await ctx.send(f"Ok {str(member).capitalize()},\n{message}")
+                self.logger.info(f"Displaying all profiles; requested by {member}")
 
             # Command to change the current frequency and mode
             @self.command(name='chfreq', help="Use this command to change the frequency the bot is listening to.\n"
@@ -205,6 +215,7 @@ class Bot(commands.Bot):
             async def chfreq(ctx, mode: str, freq: str, member: discord.Member = None):
                 # Possible band-types that can be used
                 member = member or ctx.author.display_name
+                self.logger.info(f"{member} requested change of frequency to Mode: {mode}, Freq: {freq}")
 
                 # Check to make sure the frequency input matches the syntax needed
                 if len(freq) >= 6:
@@ -216,13 +227,11 @@ class Bot(commands.Bot):
                         await ctx.send(f"Ok {str(member).capitalize()}, I'm changing the mode to "
                                        f"{str(self.mode).upper()} and frequency to {self.freq}")
 
-                        # Reset the profile name since we have made a change to the freq
+                        # Reset the profile name since we have made a change
                         self.profile_name = None
 
                         # If the SDR is started, restart it with the updates
-                        if self.sdr_started:
-                            self.start_sdr()
-                            await self.set_activity()
+                        await self.use_current_radio_config()
                     else:
                         await ctx.send(f"{str(member).capitalize()}, {mode} is not valid."
                                        f" You may only enter {self.possible_modes}")
@@ -240,13 +249,16 @@ class Bot(commands.Bot):
                               brief="Changes radio squelch")
                 async def chsquelch(ctx, squelch: float, member: discord.Member = None):
                     member = member or ctx.author.display_name
+                    self.logger.info(f"{member} requested change of squelch to: {squelch}")
 
                     self.squelch = squelch
                     await ctx.send(f"Ok {str(member).capitalize()}, I'm changing the squelch to {self.squelch}")
 
+                    # Reset the profile name since we have made a change
+                    self.profile_name = None
+
                     # If the SDR is started, restart it with the updates
-                    if self.sdr_started:
-                        self.start_sdr()
+                    await self.use_current_radio_config()
 
             # Hidden admin commands
             @self.command(name='saveprofile', hidden=True)
@@ -289,13 +301,13 @@ class Bot(commands.Bot):
         async def on_ready():
             # Check the ./modules folder for any modules (cog.py)
             await self.check_for_modules()
-            print("Bot started!")
+            self.logger.info("Bot started!")
 
     # Check to see if other bots are online
     async def check_other_bots_online(self):
-        print('Checking if other bots are online')
+        self.logger.info('Checking if other bots are online')
         channel = self.get_channel(self.Default_Channel_ID)
-        print(f"Testing in: {channel}")
+        self.logger.debug(f"Testing in: {channel}")
 
         bots_online = []
 
@@ -315,7 +327,7 @@ class Bot(commands.Bot):
             except asyncio.exceptions.TimeoutError:
                 seconds_waited += 1
 
-        print(f"Bots Online: {bots_online}")
+        self.logger.debug(f"Bots Online: {bots_online}")
 
         if len(bots_online) == 0:
             return False
@@ -325,13 +337,14 @@ class Bot(commands.Bot):
     # Check the handler being used during init
     def check_handler(self):
         if self.Handler == "gqrx":
-            print("Starting GQRX handler")
+            self.logger.info("Starting GQRX handler")
             from gqrxHandler import GQRXHandler
             self.GQRXHandler = GQRXHandler()
+            self.GQRXHandler.start()
             self.possible_modes = BotResources.PDB_ACCEPTABLE_HANDLERS['gqrx']['Modes']
 
         elif self.Handler == 'op25':
-            print("Starting OP25 handler")
+            self.logger.info("Starting OP25 handler")
             from op25Handler import OP25Handler
             self.OP25Handler = OP25Handler()
             self.OP25Handler.start()
@@ -342,22 +355,22 @@ class Bot(commands.Bot):
         # Check the system type and load the correct library
         # Linux ARM AARCH64 running 32bit OS
         if self.system_os_type == 'Linux_ARMv7l':
-            print(f"Loaded OPUS library for {self.system_os_type}")
+            self.logger.debug(f"Loaded OPUS library for {self.system_os_type}")
             discord.opus.load_opus('./opus/libopus_armv7l.so')
         # Linux ARM AARCH64 running 64bit OS
         if self.system_os_type == 'Linux_AARCH64':
-            print(f"Loaded OPUS library for {self.system_os_type}")
+            self.logger.debug(f"Loaded OPUS library for {self.system_os_type}")
             discord.opus.load_opus('./opus/libopus_aarcch64.so')
         # Windows 64bit
         if self.system_os_type == 'Windows_x64':
-            print(f"Loaded OPUS library for {self.system_os_type}")
+            self.logger.debug(f"Loaded OPUS library for {self.system_os_type}")
             discord.opus.load_opus('./opus/libopus_amd64.dll')
 
     # Check to make sure the selected device is still available and has not changed its index
     def check_device(self, _override):
         # Check to see if an override has been passed
         if not _override:
-            print(f"Device list {self.Devices_List}")
+            self.logger.debug(f"Device list {self.Devices_List}")
             for device, index in self.Devices_List['Input']:
                 if int(index) == self.DEVICE_ID and str(device) == self.DEVICE_NAME:
                     return True
@@ -382,19 +395,19 @@ class Bot(commands.Bot):
                 if str(folder_name)[0] == '.':
                     continue
                 elif os.path.exists(os.path.join("modules", folder_name, "cog.py")):
-                    print(f"Loaded extension: {folder_name}")
+                    self.logger.debug(f"Loaded extension: {folder_name}")
                     self.load_extension(f"modules.{folder_name}.cog")
 
     # Reload a selected module for changes
     def reload_modules(self, module):
         try:
             self.unload_extension(f"modules.{module}.cog")
-            print(f"Unloaded {module}")
+            self.logger.debug(f"Unloaded {module}")
             self.load_extension(f"modules.{module}.cog")
-            print(f"Loaded {module}")
+            self.logger.debug(f"Loaded {module}")
             return True
         except Exception as e:
-            print(e)
+            self.logger.error(e)
             return False
 
     # Check and store the OS type of the system for later use
@@ -403,14 +416,14 @@ class Bot(commands.Bot):
         if os.name == 'nt':
             if processor == "AMD64":
                 self.system_os_type = 'Windows_x64'
-                print(f"OS/Arch is {self.system_os_type}")
+                self.logger.debug(f"OS/Arch is {self.system_os_type}")
         else:
             if processor == "aarch64":
                 self.system_os_type = 'Linux_AARCH64'
-                print(f"OS/Arch is {self.system_os_type}")
+                self.logger.debug(f"OS/Arch is {self.system_os_type}")
             elif processor == "armv7l":
                 self.system_os_type = 'Linux_ARMv7l'
-                print(f"OS/Arch is {self.system_os_type}")
+                self.logger.debug(f"OS/Arch is {self.system_os_type}")
 
     # Check to see if there is only one frequency
     def start_sdr(self):
@@ -421,14 +434,16 @@ class Bot(commands.Bot):
                 self.stop_sdr()
 
                 # Start the radio
-                print(f"Starting freq: {self.freq}")
+                self.logger.debug(f"Starting freq: {self.freq}")
 
                 if self.Handler == 'gqrx':
                     # Set the settings in GQRX
-                    self.GQRXHandler.set_all_settings(self.mode, self.squelch, self.freq)
+                    self.GQRXHandler.set_gqrx_parameters(_frequency=self.freq, _squelch=self.squelch,
+                                                         _fm_mode=self.mode, _output_device_name=self.DEVICE_NAME,
+                                                         _start=True)
 
                 elif self.Handler == 'op25':
-                    self.OP25Handler.set_op25_parameters(self.freq, _start=True)
+                    self.OP25Handler.set_op25_parameters(self.freq, _start=True, _output_device_name=self.DEVICE_NAME)
 
                 # Set the started variable for later checks
                 self.sdr_started = True
@@ -437,11 +452,16 @@ class Bot(commands.Bot):
     def stop_sdr(self):
         if self.sdr_started:
             # Wait for the running processes to close
+
+            # Close the GQRX handler
+            if self.Handler == 'gqrx':
+                self.GQRXHandler.set_gqrx_parameters(_stop=True)
+
             # Close the OP25 handler
             if self.Handler == 'op25':
                 self.OP25Handler.set_op25_parameters(_stop=True)
                 # self.OP25Handler.join()
-            # Need a way to 'close' GQRX
+
             self.sdr_started = False
 
     # Set the activity of the bot
@@ -466,7 +486,7 @@ class Bot(commands.Bot):
 
     # Save the current radio settings as a profile
     async def save_radio_config(self, _profile_name: str):
-        print(f"Saving profile {_profile_name}")
+        self.logger.debug(f"Saving profile {_profile_name}")
         config = configparser.SafeConfigParser()
 
         if os.path.exists('./profiles.ini'):
@@ -487,13 +507,24 @@ class Bot(commands.Bot):
 
         self.profile_name = profile_name
 
+        await self.use_current_radio_config()
+
+    async def use_current_radio_config(self):
         if self.sdr_started:
-            self.start_sdr()
+            # Set the loaded profile settings into GQRX
+            if self.Handler == "gqrx":
+                self.GQRXHandler.set_gqrx_parameters(_frequency=self.freq, _squelch=self.squelch,
+                                                     _fm_mode=self.mode)
+            # Restart OP25 to use the loaded profile
+            if self.Handler == "op25":
+                self.start_sdr()
+
+            # Set the activity to reflect the loaded profile
             await self.set_activity()
 
     # Load a saved profile into the current settings
     async def load_radio_config(self, profile_name):
-        print(f"Loading profile {profile_name}")
+        self.logger.debug(f"Loading profile {profile_name}")
         config = configparser.ConfigParser()
         if os.path.exists('./profiles.ini'):
             config.read('./profiles.ini')
@@ -505,15 +536,13 @@ class Bot(commands.Bot):
                 try:
                     self.noisegate_sensitivity = int(config[self.profile_name]['Noisegate_Sensitivity'])
                 except KeyError:
-                    print(f"Config does not contain a 'noisegate sensitivity' value, "
-                          f"creating one now with the default value: {BotResources.DEFAULT_NOISEGATE_THRESHOLD}")
+                    self.logger.warning(f"Config does not contain a 'noisegate sensitivity' value, "
+                                        f"creating one now with the default value: "
+                                        f"{BotResources.DEFAULT_NOISEGATE_THRESHOLD}")
                     self.noisegate_sensitivity = BotResources.DEFAULT_NOISEGATE_THRESHOLD
                     await self.save_radio_config(self.profile_name)
 
-                if self.sdr_started:
-                    self.start_sdr()
-                    await self.set_activity()
-
+                await self.use_current_radio_config()
                 return True
             else:
                 return False
@@ -544,7 +573,7 @@ class Bot(commands.Bot):
                 try:
                     message_body += f"\tNoisegate Sensitivity:\t{config[section]['Noisegate_Sensitivity']}\n"
                 except KeyError:
-                    print(f"Config does not contain a 'noisegate sensitivity' value. Please load the profile")
+                    self.logger.warning(f"Config does not contain a 'noisegate sensitivity' value. Please load the profile")
 
                 message_body += f"\tSquelch:\t\t\t\t{config[section]['Squelch']}\n"
 

gqrxHandler.py

@@ -1,40 +1,239 @@
+import configparser
+import shutil
+import logging
+import threading
+import subprocess
+import time
+from pathlib import Path
 from telnetlib import Telnet
-from BotResources import check_negative
+from BotResources import *
 from time import sleep
 
-class GQRXHandler():
-    def __init__(self, hostname: str = "localhost", port: int = 7356):
-        self.hostname = hostname
-        self.port = port
+
+def reset_crashed(_config_path):
+    config = configparser.SafeConfigParser()
+    config.read(_config_path)
+    if config.has_section('General'):
+        if config.getboolean('General', 'crashed'):
+            config['General']['crashed'] = 'false'
+            with open(_config_path, 'w') as config_file:
+                config.write(config_file)
+            return True
+    else:
+        return False
+
+
+def enable_agc(_config_path):
+    config = configparser.SafeConfigParser()
+    config.read(_config_path)
+    if config.has_option('receiver', 'agc_off'):
+        config.remove_option('receiver', 'agc_off')
+        with open(_config_path, 'w') as config_file:
+            config.write(config_file)
+        return True
+
+
+class GQRXHandler(threading.Thread):
+    def __init__(self):
+        super().__init__()
+        self.GQRX_Config_Path = Path(f"{Path.home()}/.config/gqrx/drb_defaults.conf")
+        self.GQRXDir: str = GQRX_BIN_LOCATION
+        self.GQRXEXE: str = shutil.which(GQRX_BIN)
+        self.GQRXProc = None
+        self.GQRX_Started = False
+
+        self.logger = logging.getLogger("Discord_Radio_Bot.GQRXHandler")
+
+        self.Frequency = None
+
+        self.Mode = DEFAULT_RADIO_SETTINGS['mode']
+        self.Frequency = DEFAULT_RADIO_SETTINGS['freq']
+        self.Squelch = DEFAULT_RADIO_SETTINGS['squelch']
+
+        self.Start_GQRX = False
+        self.Stop_GQRX = False
+
+        self.Output_Device_Name = None
+
+        self.hostname = "localhost"
+        self.port = 7356
 
         self.tel_conn = None
 
-        self.create_telnet_connection()
+    def run(self) -> None:
+        while True:
+            if self.Start_GQRX:
+                self.open_gqrx()
+
+                self.Start_GQRX = False
+                self.Stop_GQRX = False
+
+                self.logger.debug("GQRX is open, waiting for it to close")
+
+                while not self.Stop_GQRX:
+                    sleep(1)
+
+                self.logger.debug('Request to close GQRX')
+
+                self.close_gqrx()
+            sleep(.5)
+
+    def set_gqrx_parameters(self, _frequency: str = False, _start: bool = False, _stop: bool = False,
+                            _output_device_name: str = None, _fm_mode: str = None, _squelch: float = None,
+                            _hostname: str = None, _port: int = None, _start_dsp: bool = None):
+        if _frequency:
+            self.Frequency = _frequency
+            if self.GQRX_Started:
+                self.change_freq(_frequency)
+
+        if _output_device_name:
+            self.Output_Device_Name = _output_device_name
+
+        if _fm_mode:
+            self.Mode = _fm_mode
+            if self.GQRX_Started:
+                self.change_mode(_fm_mode)
+
+        if _squelch:
+            self.Squelch = _squelch
+            if self.GQRX_Started:
+                self.change_squelch(_squelch)
+
+        if _hostname:
+            self.hostname = _hostname
+            self.Start_GQRX = True
+
+        if _port:
+            self.port = _port
+            self.Start_GQRX = True
+
+        if _start_dsp:
+            self.start_dsp()
+
+        if _start:
+            self.Start_GQRX = _start
+
+        if _stop:
+            self.Stop_GQRX = _stop
+
+    def open_gqrx(self):
+        if self.GQRX_Started:
+            self.close_gqrx()
+
+        gqrx_kwargs = [f"gqrx", "-c", "drb_defaults.conf"]
+
+        self.logger.info(f"Resetting 'crashed' option in the GQRX config")
+
+        self.reset_or_create_config()
+
+        self.logger.info(f"Starting GQRX")
+
+        self.logger.debug(f"GQRX Keyword Args: {gqrx_kwargs}")
+
+        self.GQRXProc = subprocess.Popen(gqrx_kwargs, executable=self.GQRXEXE, shell=False)
+
+        while not self.tel_conn:
+            self.create_telnet_connection()
+            sleep(2)
+            self.logger.debug(f"Waiting for GQRX to start")
+
+        self.GQRX_Started = True
+
+        self.start_dsp()
+
+        self.set_all_settings(_squelch=self.Squelch, _mode=self.Mode, _freq=self.Frequency)
+        self.logger.debug('Finished opening GQRX')
+
+    def close_gqrx(self):
+        self.logger.info(f"Closing GQRX")
+        try:
+            self.GQRXProc.kill()
+
+            seconds_waited = 0
+            while self.GQRXProc.poll() is None:
+                # Terminate the process every 5 seconds
+                if seconds_waited % 5 == 0:
+                    self.logger.info("Terminating GQRX")
+                    self.GQRXProc.terminate()
+                sleep(1)
+                self.logger.debug(f"Waited {seconds_waited} seconds")
+                seconds_waited += 1
+            self.logger.debug("GQRX Closed")
+            self.GQRX_Started = False
+            self.tel_conn = None
+
+        except Exception as e:
+            self.logger.error(e)
 
     def create_telnet_connection(self):
-        print("Creating connection")
-        self.tel_conn = Telnet(self.hostname, self.port)
-        self.tel_conn.open(self.hostname, self.port)
+        self.logger.debug("Creating connection")
+        try:
+            self.tel_conn = Telnet(self.hostname, self.port)
+            self.tel_conn.open(self.hostname, self.port)
+            self.logger.debug(f"GQRX is open")
+            return True
+        except Exception as err:
+            self.logger.warning(err)
+            self.tel_conn = None
+            return False
+
+    def check_dsp(self):
+        self.logger.debug(f"Checking if DSP is running on GQRX")
+        self.tel_conn.write(bytes(f"u DSP", 'utf-8'))
+        if self.tel_conn.read_some() == b"1":
+            return True
+        else:
+            return False
+
+    def start_dsp(self):
+        if not self.check_dsp():
+            self.logger.debug(f"Starting DSP on GQRX")
+            self.tel_conn.write(bytes(f"U DSP 1", 'utf-8'))
+            self.tel_conn.read_until(b'RPRT 0')
 
     def change_freq(self, freq):
-        print(f"Changing freq to {freq}")
+        self.logger.debug(f"Changing freq to {freq}")
         self.tel_conn.write(bytes(f"F {int(freq)}", 'utf-8'))
         self.tel_conn.read_until(b'RPRT 0')
 
     def change_squelch(self, squelch):
         if not check_negative(squelch):
             squelch = float(-abs(squelch))
-        print(f"Changing squelch to {squelch}")
+        self.logger.debug(f"Changing squelch to {squelch}")
         self.tel_conn.write(bytes(f"L SQL {float(squelch)}", 'utf-8'))
         self.tel_conn.read_until(b'RPRT 0')
 
     def change_mode(self, mode):
-        print(f"Changing mode to {mode}")
+        self.logger.debug(f"Changing mode to {mode}")
         self.tel_conn.write(bytes(f"M {str(mode)}", 'utf-8'))
         self.tel_conn.read_until(b'RPRT 0')
 
-    def set_all_settings(self, mode, squelch, freq):
+    def set_all_settings(self, _mode, _squelch, _freq):
         self.change_squelch(0)
-        self.change_mode(mode)
-        self.change_freq(freq)
-        self.change_squelch(squelch)
+        self.change_mode(_mode)
+        self.change_freq(_freq)
+        self.change_squelch(_squelch)
+
+    def creat_config(self):
+        from templates.gqrx_config_template import drb_defaults
+        config = drb_defaults
+        try:
+            with open(self.GQRX_Config_Path, 'w+') as config_file:
+                config_file.write(config)
+        except OSError as err:
+            self.logger.error(err)
+
+    def reset_or_create_config(self):
+        if self.GQRX_Config_Path.is_file():
+            try:
+                self.logger.debug(f"Enabling AGC in the GQRX config")
+                enable_agc(_config_path=self.GQRX_Config_Path)
+
+                self.logger.debug(f"GQRX Config exists, resetting 'crashed' setting")
+                reset_crashed(_config_path=self.GQRX_Config_Path)
+            except configparser.DuplicateOptionError as err:
+                self.logger.warning(err)
+                self.creat_config()
+        else:
+            self.logger.debug(f"GQRX config does not exist, creating it from template")
+            self.creat_config()

main.py

@@ -1,8 +1,9 @@
+import logging
 import os
 import time
 import bot
 import argparse
-from BotResources import check_if_config_exists, write_config_file, read_config_file
+import BotResources
 
 # Jorn
 #token = 'OTE1MDY0OTk2OTk0NjMzNzI5.YaWKsA.Y9yaCGg_VXRL_qQVbs05vo7gSAc'
@@ -15,26 +16,28 @@ from BotResources import check_if_config_exists, write_config_file, read_config_
 
 #name = "VoiceMeeter Output"
 
+LOGGER = logging.getLogger("Discord_Radio_Bot.Main")
+
 
 class BotDeviceNotFound(Exception):
     def __init__(self, device):
-        print(f"Unable to find the device: {device}")
+        LOGGER.debug(f"Unable to find the device: {device}")
         try:
            os.remove('./config.ini')
         except OSError:
-            print("Config file not found, restarting.")
+            LOGGER.warning("Config file not found, restarting.")
             #os.execv(__file__, sys.argv)
 
 
 def main(**passed_config):
     # Don't create a config if the user passed parameters
     if len(passed_config.keys()) == 0:
-        print('Checking config file...')
-        if not check_if_config_exists():
-            print("No config file exists, please enter this information now")
-            write_config_file(init=True)
+        LOGGER.info('Checking config file...')
+        if not BotResources.check_if_config_exists():
+            LOGGER.warning("No config file exists, please enter this information now")
+            BotResources.write_config_file(init=True)
 
-    config = read_config_file()
+    config = BotResources.read_config_file()
 
     # Overwrite config options if they were passed
     if len(passed_config.keys()) == 0:
@@ -43,13 +46,13 @@ def main(**passed_config):
             if sub in passed_config and passed_config[sub]:
                 config[sub] = passed_config[sub]
 
-    print('Starting Bot...')
+    LOGGER.info('Starting Bot...')
 
     discord_bot_client = bot.Bot(Token=config['Bot Token'], Device_ID=config['Device ID'],
                                  Device_Name=config['Device Name'], Mention_Group=config['Mention Group'],
                                  Channel_ID=config['Channel ID'], Handler=config['Handler'])
 
-    print(f"Verifying audio device:\t{config['Device Name']}")
+    LOGGER.debug(f"Verifying audio device:\t{config['Device Name']}")
 
     if not discord_bot_client.check_device(_override=bool("Device ID" in passed_config.keys())):
         raise BotDeviceNotFound(config['Device Name'])
@@ -112,20 +115,21 @@ def cmd_arguments():
 
 if __name__ == '__main__':
     cmd_args = cmd_arguments()
+    BotResources.init_global_logger()
 
     if not all(cmd_args.values()):
-        print("Passed arguments:")
+        LOGGER.debug("Passed arguments:")
         for arg in cmd_args:
             if cmd_args[arg]:
-                print(f"\t{arg}:\t{cmd_args[arg]}")
+                LOGGER.debug(f"\t{arg}:\t{cmd_args[arg]}")
 
     try:
-        print('Starting...')
+        LOGGER.info('Starting...')
         while True:
             try:
                 main(**cmd_args)
             except BotDeviceNotFound:
-                print("Restarting...")
+                LOGGER.info("Restarting...")
                 time.sleep(2)
     except KeyboardInterrupt:
-        print("Exiting...")
+        LOGGER.error("Exiting...")

modules/ClearChannelMessages/cog.py

@@ -0,0 +1,52 @@
+import logging
+from discord.ext import commands
+
+LOGGER = logging.getLogger("Discord_Radio_Bot.LinkCop")
+
+
+class ClearMessages(commands.Cog):
+    def __init__(self, bot):
+        self.Bot = bot
+
+    @commands.command(name='clear',
+                      help="Use this command to clear a given number of messages from the channel it is called in.\n"
+                           "There is a limit of 100 messages. Please be patient, it may take a while to process a large request."
+                           "Example command:\n"
+                           "\t@ clear\n"
+                           "\t@ clear 10",
+                      breif="Clear x messages in the channel it's called in")
+    async def clear(self, ctx, amount=2):
+        member = ctx.author.display_name
+        member_id = ctx.author.id
+        mtn_member = f"<@{member_id}>"
+
+        if isinstance(amount, int):
+            if not amount > 0:
+                ctx.channel.send(f"{member}, the number needs to be positive...")
+
+            else:
+                LOGGER.info(f"Clear {amount} messages requested by {member}")
+
+                authors = {}
+                async for message in ctx.channel.history(limit=amount):
+                    if message.author not in authors:
+                        authors[message.author] = 1
+                    else:
+                        authors[message.author] += 1
+                    await message.delete()
+
+                msg = f"{mtn_member}, I deleted {sum(authors.values())} messages from {len(authors.keys())} users:\n"
+                LOGGER.debug(f"Deleted {sum(authors.values())} messages from {ctx.message.channel}")
+
+                for author in authors.keys():
+                    msg += f"\t{str(author).split('#', 1)[0]}: {authors[author]}\n"
+                    LOGGER.debug(f"Deleted {authors[author]} messages from {author}")
+
+                await ctx.channel.send(msg)
+
+        else:
+            ctx.channel.send(f"{member}, you should check out the 'help' section...")
+
+
+def setup(bot: commands.Bot):
+    bot.add_cog(ClearMessages(bot))

modules/LinkCop/cog.py

@@ -1,3 +1,4 @@
+import logging
 import re
 import discord
 from discord.ext import commands
@@ -26,6 +27,8 @@ random_message = ["{%mtn_user%}, tsk tsk. Links belong here:\n{%ref_og_msg%}", "
 # welcome 757379843792044102
 # the-round-table 367396189529833474
 
+LOGGER = logging.getLogger("Discord_Radio_Bot.LinkCop")
+
 class LinkCop(commands.Cog):
     def __init__(self, bot):
         self.bot = bot
@@ -59,7 +62,7 @@ class LinkCop(commands.Cog):
                     try:
                         if not any(item.id in self.whitelisted_groups for item in ctx.author.roles):
                             if check_message(ctx.content):
-                                print('Msg with links detected in a blocked channel')
+                                LOGGER.info('Msg with links detected in a blocked channel')
 
                                 response_text = self.generate_response(ctx)
 
@@ -68,8 +71,8 @@ class LinkCop(commands.Cog):
                                 # Delete the original message
                                 await ctx.delete()
                     except AttributeError as err:
-                        print(f"Link Cop Error: '{err}'")
-                        print(f"Bot or other non-user that has not been whitelisted sent a message")
+                        LOGGER.error(f"Link Cop Error: '{err}'\nBot or other non-user that has not "
+                                          f"been whitelisted sent a message")
 
             await check_and_reply_to_ping(self.bot, ctx)
 
@@ -123,7 +126,7 @@ def check_message(message_text):
 def get_links(message_text):
     links = regex_link.findall(message_text)
 
-    print(links)
+    LOGGER.error(links)
 
     if len(links) > 0:
         return links

op25Handler.py

@@ -1,9 +1,9 @@
+import logging
 import shutil
-import threading
 import subprocess
-import asyncio
-import os
+import threading
 import time
+from BotResources import DEFAULT_RADIO_SETTINGS
 
 
 class OP25Handler(threading.Thread):
@@ -13,7 +13,7 @@ class OP25Handler(threading.Thread):
         self.OP25EXE: str = shutil.which("/home/pi/op25/op25/gr-op25_repeater/apps/rx.py")
         self.OP25Proc = None
 
-        self.Frequency = None
+        self.Frequency = DEFAULT_RADIO_SETTINGS['freq']
 
         self.HTTP_ENABLED = False
 
@@ -21,6 +21,10 @@ class OP25Handler(threading.Thread):
 
         self.Stop_OP25 = False
 
+        self.Output_Device_Name = None
+
+        self.logger = logging.getLogger("Discord_Radio_Bot.OP25Handler")
+
     def run(self) -> None:
         while True:
             if self.Start_OP25:
@@ -36,7 +40,8 @@ class OP25Handler(threading.Thread):
 
             time.sleep(.5)
 
-    def set_op25_parameters(self, _frequency: str = False, _http_enabled: bool = True, _start: bool = False, _stop: bool = False):
+    def set_op25_parameters(self, _frequency: str = False, _http_enabled: bool = True, _start: bool = False,
+                            _stop: bool = False, _output_device_name: str = None):
         if _frequency:
             self.Frequency = _frequency
 
@@ -49,25 +54,28 @@ class OP25Handler(threading.Thread):
         if _http_enabled:
             self.HTTP_ENABLED = _http_enabled
 
+        if _output_device_name:
+            self.Output_Device_Name = _output_device_name
+
     def open_op25(self):
         if self.OP25Proc is not None:
             self.close_op25()
 
-        p25_kwargs = [f"./rx.py", "--args", "rtl", "-N", "LNA:49", "-s", "200000", "-o", "25600", "-U", "-f",
-                      f"{self.Frequency}e6", "-X", "-2"]
+        p25_kwargs = [f"./rx.py", "--args", "rtl", "-N", "LNA:49", "-s", "200000", "-o", "25600", "-w", "-U", "-O",
+                      f"{self.Output_Device_Name}", "-f", f"{self.Frequency}e6", "-X", "-2"]
 
-        print(f"Starting OP25")
+        self.logger.info(f"Starting OP25")
         # Change the interpreter's working directory (idr why)
         if self.HTTP_ENABLED:
             p25_kwargs.extend(["-l", "http:0.0.0.0:8080"])
 
-        print(f"OP25 Keyword Args: {p25_kwargs}")
+        self.logger.debug(f"OP25 Keyword Args: {p25_kwargs}")
 
-        self.OP25Proc = subprocess.Popen(p25_kwargs, executable=self.OP25EXE, shell=False, stdin=subprocess.PIPE,
-                                         stdout=subprocess.PIPE,  stderr=subprocess.STDOUT, cwd=self.OP25Dir)
+        self.OP25Proc = subprocess.Popen(p25_kwargs, executable=self.OP25EXE, shell=False, cwd=self.OP25Dir,
+                                         stdin=subprocess.DEVNULL, stdout=subprocess.DEVNULL, stderr=subprocess.STDOUT)
 
     def close_op25(self):
-        print(f"Closing OP25")
+        self.logger.info(f"Closing OP25")
         try:
             self.OP25Proc.kill()
 
@@ -75,11 +83,11 @@ class OP25Handler(threading.Thread):
             while self.OP25Proc.poll() is None:
                 # Terminate the process every 5 seconds
                 if seconds_waited % 5 == 0:
-                    print("Terminating OP25")
+                    self.logger.info("Terminating OP25")
                     self.OP25Proc.terminate()
                 time.sleep(1)
-                print(f"Waited {seconds_waited} seconds")
+                self.logger.debug(f"Waited {seconds_waited} seconds")
                 seconds_waited += 1
 
         except Exception as e:
-            print(e)
+            self.logger.error(e)

templates/gqrx_config_template.py

@@ -0,0 +1,41 @@
+drb_defaults = """[General]
+configversion=2
+crashed=false
+
+[audio]
+gain=-20
+udp_host=localhost
+
+[dxcluster]
+DXCAddress=localhost
+DXCFilter=
+DXCPort=7300
+DXCSpotTimeout=10
+DXCUsername=nocall
+
+[fft]
+averaging=85
+fft_window=5
+waterfall_span=1
+
+[gui]
+geometry=@ByteArray(\x1\xd9\xd0\xcb\0\x3\0\0\0\0\x4t\0\0\0$\0\0\a\x7f\0\0\x3\x12\0\0\x4v\0\0\0\x42\0\0\a\x7f\0\0\x3\x12\0\0\0\0\0\0\0\0\a\x80\0\0\x4v\0\0\0\x42\0\0\a\x7f\0\0\x3\x12)
+state=@ByteArray(\0\0\0\xff\0\0\0\0\xfd\0\0\0\x2\0\0\0\x1\0\0\x1G\0\0\x2t\xfc\x2\0\0\0\x2\xfc\0\0\0\x42\0\0\x1\x89\0\0\x1\x89\0\b\0!\xfa\0\0\0\x1\x2\0\0\0\x3\xfb\0\0\0\x18\0\x44\0o\0\x63\0k\0I\0n\0p\0u\0t\0\x43\0t\0l\x1\0\0\0\0\xff\xff\xff\xff\0\0\x1P\0\xff\xff\xff\xfb\0\0\0\x12\0\x44\0o\0\x63\0k\0R\0x\0O\0p\0t\x1\0\0\0\0\xff\xff\xff\xff\0\0\x1g\0\a\xff\xff\xfb\0\0\0\xe\0\x44\0o\0\x63\0k\0\x46\0\x66\0t\x1\0\0\0\0\xff\xff\xff\xff\0\0\0\xc8\0\a\xff\xff\xfc\0\0\x1\xd1\0\0\0\xe5\0\0\0\xc3\0\xff\xff\xff\xfa\0\0\0\0\x2\0\0\0\x2\xfb\0\0\0\x12\0\x44\0o\0\x63\0k\0\x41\0u\0\x64\0i\0o\x1\0\0\0\0\xff\xff\xff\xff\0\0\0\xc3\0\xff\xff\xff\xfb\0\0\0\xe\0\x44\0o\0\x63\0k\0R\0\x44\0S\0\0\0\0\0\xff\xff\xff\xff\0\0\0h\0\xff\xff\xff\0\0\0\x3\0\0\0\0\0\0\0\0\xfc\x1\0\0\0\x1\xfb\0\0\0\x1a\0\x44\0o\0\x63\0k\0\x42\0o\0o\0k\0m\0\x61\0r\0k\0s\0\0\0\0\0\xff\xff\xff\xff\0\0\x1\x42\0\xff\xff\xff\0\0\x1\xbd\0\0\x2t\0\0\0\x1\0\0\0\x2\0\0\0\b\0\0\0\x2\xfc\0\0\0\x1\0\0\0\x2\0\0\0\x1\0\0\0\x16\0m\0\x61\0i\0n\0T\0o\0o\0l\0\x42\0\x61\0r\x1\0\0\0\0\xff\xff\xff\xff\0\0\0\0\0\0\0\0)
+
+[input]
+dc_cancel=true
+device="rtl=0"
+frequency=154785000
+gains=@Variant(\0\0\0\b\0\0\0\x1\0\0\0\x6\0L\0N\0\x41\0\0\0\x2\0\0\x1P)
+sample_rate=1800000
+
+[receiver]
+demod=3
+filter_high_cut=2500
+filter_low_cut=-2500
+offset=-590400
+sql_level=-50
+
+[remote_control]
+allowed_hosts=localhost, 127.0.0.1, ::1
+enabled=true"""