Update modules

danic85 · danic85 · commit ebc5d3cc78fe · 2024-11-01T20:01:32.000Z
diff --git a/arduino_sketch/Config.h b/arduino_sketch/Config.h
@@ -80,10 +80,10 @@ int PosLookDown[SERVO_COUNT] = {NOVAL, NOVAL, NOVAL, NOVAL, NOVAL, NOVAL, 120, 9
 // Array of poses except PosRest and PosSleep (which are used for initialization and reset of position)
 int *Poses[] = {PosStand, PosLookLeft, PosLookRight, PosLookUp, PosLookDown, PosLookRandom};
 
-int backpackPin = 12;
+int backpackPin = PIN_A1;
 bool backpack = false;
 
-int restrainPin = PIN_A1;
+int restrainPin = 12;
 bool restrainingBolt = false;
 
 void blinkLED()
diff --git a/config/braillespeak.yml b/config/braillespeak.yml
@@ -1,5 +1,5 @@
 braillespeak:
-  enabled: true
+  enabled: false
   path: modules.audio.braillespeak.BrailleSpeak
   config:
     pin: 27
diff --git a/config/buzzer.yml b/config/buzzer.yml
@@ -1,5 +1,5 @@
 buzzer:
-  enabled: true
+  enabled: false
   path: "modules.audio.buzzer.Buzzer"
   config:
     pin: 27
diff --git a/config/chatgpt.yml b/config/chatgpt.yml
@@ -6,4 +6,6 @@ chatgpt:
   dependencies:
     python:
       - openai
-      - pypubsub
+      - pypubsub
+    additional:
+      - https://platform.openai.com/api-keys
diff --git a/config/neopixel.yml b/config/neopixel.yml
@@ -1,5 +1,4 @@
 neopixel:
-  
   enabled: true
   path: 'modules.neopixel.neopx.NeoPx'
   config:
diff --git a/config/rtlsdr.yml b/config/rtlsdr.yml
@@ -1,5 +1,5 @@
 rtl_sdr:
-  enabled: true
+  enabled: false
   path: modules.network.rtlsdr.RTLSDR
   config:
     udp_host: "127.0.0.1"
diff --git a/config/speechinput.yml b/config/speechinput.yml
@@ -2,4 +2,4 @@ speechinput:
   enabled: false
   path: modules.audio.speechinput.SpeechInput
   config:
-    device_index: 'lp'
+    device_name: lp
diff --git a/config/telegram.yml b/config/telegram.yml
@@ -1,8 +1,14 @@
 telegram:
-  path: modules.network.telegram.Telegram
+  path: modules.network.telegrambot.TelegramBot
   enabled: false
+  config:
+    user_whitelist: []
+    topics:
+      publish_received: "telegram/received"
+      subscribe_respond: "telegram/respond"
   dependencies:
     python:
+      - pypubsub
       - python-telegram-bot
     additional:
       - https://core.telegram.org/bots/tutorial#obtain-your-bot-token
diff --git a/config/translator.yml b/config/translator.yml
@@ -1,5 +1,5 @@
 translator:
-  enabled: true
+  enabled: false
   path: modules.translator.Translator
   config:
     default:
diff --git a/config/viam.yml b/config/viam.yml
@@ -16,4 +16,6 @@ viamobjectdetection:
     timelapse_location: '/home/archie/modular-biped/data/viamobjects'
   dependencies:
     python:
-      - viam-sdk
+      - viam-sdk
+    additional:
+      - https://docs.viam.com/installation/viam-server-setup/
diff --git a/main.py b/main.py
@@ -8,7 +8,7 @@
 from module_loader import ModuleLoader
 
 # Set up logging
-logging.basicConfig(filename=os.path.dirname(__file__) + '/app.log', level=logging.DEBUG, format='%(levelname)s: %(asctime)s %(message)s',
+logging.basicConfig(filename=os.path.dirname(__file__) + '/app.log', level=logging.INFO, format='%(levelname)s: %(asctime)s %(message)s',
                             datefmt='%m/%d/%Y %I:%M:%S %p') # this doesn't work unless it's here
 from modules.logwrapper import LogWrapper
 
@@ -36,6 +36,10 @@ def main():
     # print(module_instances.keys())
     # dict_keys(['ArduinoSerial', 'NeoPx', 'BrailleSpeak', 'Animate', 'Vision', 'PiTemperature', 'Servo_leg_l_hip', 'Servo_leg_l_knee', 'Servo_leg_l_ankle', 'Servo_leg_r_hip', 'Servo_leg_r_knee', 'Servo_leg_r_ankle', 'Servo_tilt', 'Servo_pan', 'Translator', 'Tracking_tracking', 'Sensor', 'Buzzer_buzzer'])
 
+    # Use animate to nod head
+    # pub.sendMessage('animate', action='head_nod')
+    # sleep(1)
+    # pub.sendMessage('animate', action='head_shake')
     
     # Enable translator in log wrapper
     # log.translator = module_instances['Translator'] # Set the translator for the log wrapper
@@ -46,21 +50,23 @@ def main():
     # Play happy birthday with buzzer
     # pub.sendMessage('play', song="happy birthday") # Also available: 'merry christmas'
 
-    # Use animate to nod head
-    # pub.sendMessage('animate', action='head_nod')
     
     # Check temperature of Raspberry Pi
     # pub.subscribe(self.handleTemp, 'temperature') # handleTemp should accept 'value' as a parameter
     
     # Move pi servo
-    # pub.sendMessage('piservo:move', percentage=50)
+    # pub.sendMessage('piservo:move', angle=30)
+    # pub.sendMessage('piservo:move', angle=-30)
     
     # Move servo
     # pub.sendMessage('servo:<identifier>:mv', percentage=50) # e.g. servo:pan:mv
     # pub.sendMessage('servo:<identifier>:mvabs', percentage=50) # Absolute position. e.g. servo:pan:mvabs
 
     # Test emotion analysis
-    pub.sendMessage('speech', text='I am so happy today!')
+    # pub.sendMessage('speech', text='I am so happy today!')
+    
+    # Test speech input
+    # pub.sendMessage('speech:listen')
 
     # Start loops or other tasks
     pub.sendMessage('log', msg="[Main] Loop started")
diff --git a/modules/audio/speechinput.py b/modules/audio/speechinput.py
@@ -11,13 +11,14 @@ def __init__(self, **kwargs):
         self.recognizer = sr.Recognizer()
         self.recognizer.pause_threshold = 1
 
-        self.device = kwargs.get('device_index', self.get_device_index('lp'))
+        self.device_name = kwargs.get('device_name', 'lp')
+        self.device = self.get_device_index(self.device_name)
         self.sample_rate = kwargs.get('sample_rate', 16000)
 
         self.mic = sr.Microphone(device_index=self.device, sample_rate=self.sample_rate)
         self.listening = False
 
-        pub.subscribe(self.start, 'wake')
+        pub.subscribe(self.start, 'speech:listen')
         pub.subscribe(self.stop, 'rest')
         pub.subscribe(self.stop, 'sleep')
         pub.subscribe(self.stop, 'exit')
diff --git a/modules/audio/tts.py b/modules/audio/tts.py
@@ -17,6 +17,8 @@ def __init__(self, **kwargs):
         
         Install: pip install pyttsx3 elevenlabs
         
+        Requires API key environment variable ELEVENLABS_KEY or use pyttsx3
+        
         Subscribes to 'tts' to speak message
         - Argument: msg (string) - message to speak
         
diff --git a/modules/neopixel/neopx.py b/modules/neopixel/neopx.py
@@ -131,10 +131,10 @@ def exit(self):
         self.i2c.deinit()
         sleep(1)
 
-    def speech(self, msg):
-        if 'light on' in msg:
+    def speech(self, text):
+        if 'light on' in text:
             self.flashlight(True)
-        if 'light off' in msg:
+        if 'light off' in text:
             self.flashlight(False)
 
     def set(self, identifiers, color, gradient=False):
diff --git a/modules/network/telegrambot.py b/modules/network/telegrambot.py
@@ -1,42 +1,23 @@
 #!/usr/bin/env python
 # pylint: disable=unused-argument
-# This program is dedicated to the public domain under the CC0 license.
-
-"""
-Simple Bot to reply to Telegram messages.
-
-First, a few handler functions are defined. Then, those functions are passed to
-the Application and registered at their respective places.
-Then, the bot is started and runs until we press Ctrl-C on the command line.
-
-Usage:
-Basic Echobot example, repeats messages.
-Press Ctrl-C on the command line or send a signal to the process to stop the
-bot.
-"""
 import logging
 import os
+import asyncio
+from pubsub import pub
 
 from telegram import ForceReply, Update
 from telegram.ext import Application, CommandHandler, ContextTypes, MessageHandler, filters
 
-# Enable logging
-logging.basicConfig(
-    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s", level=logging.INFO
-)
-# set higher logging level for httpx to avoid all GET and POST requests being logged
-logging.getLogger("httpx").setLevel(logging.WARNING)
-
-logger = logging.getLogger(__name__)
-
 class TelegramBot:
     def __init__(self, **kwargs):
         """
         Telegram Bot
         :param kwargs: token
-        
+
         Create a bot via Telegram's BotFather and get the token.
         
+        Set the token as an environment variable 'TELEGRAM_BOT_TOKEN' (preferred) or pass it as a keyword argument.
+        
         1. Search for BotFather in Telegram
         2. Start the BotFather
         3. Type /newbot
@@ -45,26 +26,40 @@ def __init__(self, **kwargs):
         6. Create an environment variable called TELEGRAM_BOT_TOKEN and set it to the token (can also be set in the config yaml)
         7. Run the script
         
+        Note: 
+        Currently the run_polling method will block the script from running any further code. 
+        Run the bot in a separate thread or process if you want to run other code alongside the bot.
+        
         """
-        # get token from environment variable
+        # Get token from environment variable
         self.token = os.getenv('TELEGRAM_BOT_TOKEN', kwargs.get('token', None))
-        
-        """Start the bot."""
-        # Create the Application and pass it your bot's token.
+        print(self.token)
+        # Topics for pubsub communication
+        self.topics = kwargs.get('topics', {
+            'publish_received': 'telegram/received',
+            'subscribe_respond': 'telegram/respond'
+        })
+        self.update = None
+        self.user_whitelist = kwargs.get('user_whitelist', [])
+
+        # Create the Application and pass it your bot's token
         application = Application.builder().token(self.token).build()
 
-        # on different commands - answer in Telegram
+        # Set up command handlers
         application.add_handler(CommandHandler("start", TelegramBot.start))
         application.add_handler(CommandHandler("help", TelegramBot.help_command))
 
-        # on non command i.e message - echo the message on Telegram
-        application.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, TelegramBot.echo))
+        # Set up message handlers
+        application.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, self.publish))
+
+        # Subscribe to the response topic with async wrapper
+        pub.subscribe(self.async_handle_wrapper, self.topics['subscribe_respond'])
+        
+        print("Starting Telegram bot...")
 
         # Run the bot until the user presses Ctrl-C
         application.run_polling(allowed_updates=Update.ALL_TYPES)
-        
-    # Define a few command handlers. These usually take the two arguments update and
-    # context.
+
     @staticmethod
     async def start(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
         """Send a message when the command /start is issued."""
@@ -79,11 +74,53 @@ async def help_command(update: Update, context: ContextTypes.DEFAULT_TYPE) -> No
         """Send a message when the command /help is issued."""
         await update.message.reply_text("Help!")
 
-    @staticmethod
-    async def echo(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
-        """Echo the user message."""
-        await update.message.reply_text(update.message.text)
+    async def publish(self, update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
+        """Publish the user's message to the application via pubsub."""
+        user_id = update.effective_user.id
+        message = update.message.text
+        
+        # Save the update for response handling
+        self.update = update
+        
+        # Publish the message to other parts of the application
+        pub.sendMessage(self.topics['publish_received'], user_id=user_id, message=message)
+        print(f"Published message from user {user_id}: {message} on topic {self.topics['publish_received']}")
+
+    async def handle(self, user_id: int, response: str) -> None:
+        """Handle responses from the application and send them back to the user."""
+        if (user_id not in self.user_whitelist):
+            print(f"User {user_id} not in whitelist, skipping response")
+            return
+        print(f"Handling response for user {user_id}: {response}")
+        
+        # Send the response back to the user on Telegram
+        if self.update and self.update.effective_user.id == user_id:
+            await self.update.message.reply_text(response)
 
+    def async_handle_wrapper(self, user_id: int, response: str) -> None:
+        """Wrapper to handle asynchronous calling of the handle coroutine."""
+        print(f"Scheduling async handling for user {user_id}")
+        asyncio.create_task(self.handle(user_id, response))
 
 if __name__ == "__main__":
-    bot = TelegramBot()
+    # Enable logging
+    logging.basicConfig(
+        format="%(asctime)s - %(name)s - %(levelname)s - %(message)s", level=logging.INFO
+    )
+    # Set higher logging level for httpx to avoid all GET and POST requests being logged
+    logging.getLogger("httpx").setLevel(logging.WARNING)
+
+    logger = logging.getLogger(__name__)
+
+    # Define the simulate_echo function, which will be triggered on 'publish_received'
+    def simulate_echo(user_id, message):
+        print(f"Simulating echo for user {user_id} with message: {message}")
+        # This would echo back as a response to the handle method
+        pub.sendMessage('telegram/respond', user_id=user_id, response=message)
+    
+    # Subscribe the simulate_echo function to the publish_received topic
+    pub.subscribe(simulate_echo, 'telegram/received')
+    print("Subscribed to 'telegram/received' topic")
+    
+    bot = TelegramBot()
+    bot.user_whitelist = []
diff --git a/modules/viam/viamclassifier.py b/modules/viam/viamclassifier.py
@@ -20,6 +20,12 @@ def __init__(self, **kwargs):
         Install the VIAM SDK before using.
         pip install viam-sdk
         
+        Requires secrets to be set in the environment variables:
+        - ROBOT_API_KEY
+        - ROBOT_API_KEY_ID
+        - ROBOT_ADDRESS
+        See wiki for more information.
+        
         Subscribes to:
         - vision:start
         - exit

Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,4 @@`
`1`	`1`	`neopixel:`
`2`		`-`
`3`	`2`	`enabled: true`
`4`	`3`	`path: 'modules.neopixel.neopx.NeoPx'`
`5`	`4`	`config:`