brilliant-msg 7.0.0__tar.gz

brilliant_msg-7.0.0/.gitignore

@@ -0,0 +1,22 @@
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+.pytest_cache/
+.venv/

brilliant_msg-7.0.0/LICENSE

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2025, CitizenOneX
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

brilliant_msg-7.0.0/PKG-INFO

@@ -0,0 +1,121 @@
+Metadata-Version: 2.4
+Name: brilliant-msg
+Version: 7.0.0
+Summary: Handles various message types for Brilliant Labs Frame and Halo devices
+Project-URL: Homepage, https://github.com/brilliantlabsAR/brilliant_sdk/tree/main/python/packages/brilliant_msg
+Project-URL: Bug Tracker, https://github.com/brilliantlabsAR/brilliant_sdk/issues
+Project-URL: Changelog, https://github.com/brilliantlabsAR/brilliant_sdk/blob/main/python/packages/brilliant_msg/CHANGELOG.md
+Author: luke-brilliant
+License-File: LICENSE
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.10
+Requires-Dist: brilliant-ble>=3.0.0
+Requires-Dist: lz4<5.0.0,>=4.4.3
+Requires-Dist: numpy<3.0.0,>=2.2.3
+Requires-Dist: pillow<12.0.0,>=11.1.0
+Provides-Extra: docs
+Requires-Dist: sphinx-rtd-theme>=2.0.0; extra == 'docs'
+Requires-Dist: sphinx>=7.0.0; extra == 'docs'
+Provides-Extra: tests
+Requires-Dist: opencv-python>=4.0.0; extra == 'tests'
+Requires-Dist: pvspeaker>=1.0.0; extra == 'tests'
+Requires-Dist: pytest-asyncio>=0.23; extra == 'tests'
+Requires-Dist: pytest>=8.0; extra == 'tests'
+Requires-Dist: qoi>=0.7.0; extra == 'tests'
+Description-Content-Type: text/markdown
+
+# Brilliant Message Package
+
+A Python package for handling rich application-level messages for [Brilliant Labs](https://brilliant.xyz/) Frame and Halo devices, including sprites, text, audio, IMU data, and photos.
+
+[Frame SDK documentation](https://docs.brilliant.xyz/frame/frame-sdk/).
+
+[Examples on GitHub](https://github.com/brilliantlabsAR/brilliant_sdk/tree/main/python/packages/brilliant_msg/examples).
+
+## Installation
+
+```bash
+uv add brilliant-msg
+```
+
+## Usage
+
+```python
+import asyncio
+from pathlib import Path
+
+from brilliant_msg import BrilliantMsg, TxSprite
+
+async def main():
+    """
+    Displays sample images on the Frame display.
+
+    The images are indexed (palette) PNG images, in 2, 4, and 16 colors (that is, 1-, 2- and 4-bits-per-pixel).
+    """
+    frame = BrilliantMsg()
+    try:
+        await frame.connect()
+
+        # Let the user know we're starting
+        await frame.print_short_text('Loading...')
+
+        # send the std lua files to Frame that handle data accumulation and sprite parsing
+        await frame.upload_stdlua_libs(lib_names=['data', 'sprite'])
+
+        # Send the main lua application from this project to Frame that will run the app
+        await frame.upload_frame_app(local_filename="lua/sprite_frame_app.lua")
+
+        # attach the print response handler so we can see stdout from Frame Lua print() statements
+        frame.attach_print_response_handler()
+
+        # "require" the main frame_app lua file to run it, and block until it has started.
+        await frame.start_frame_app()
+
+        # send the 1-bit image to Frame in chunks
+        sprite = TxSprite.from_indexed_png_bytes(Path("images/logo_1bit.png").read_bytes())
+        await frame.send_message(0x20, sprite.pack())
+
+        # send a 2-bit image
+        sprite = TxSprite.from_indexed_png_bytes(Path("images/street_2bit.png").read_bytes())
+        await frame.send_message(0x20, sprite.pack())
+
+        # send a 4-bit image
+        sprite = TxSprite.from_indexed_png_bytes(Path("images/hotdog_4bit.png").read_bytes())
+        await frame.send_message(0x20, sprite.pack())
+
+        await asyncio.sleep(5.0)
+
+        # unhook the print handler
+        frame.detach_print_response_handler()
+
+        # break out of the frame app loop and reboot Frame
+        await frame.stop_frame_app()
+
+    except Exception as e:
+        print(f"An error occurred: {e}")
+    finally:
+        # clean disconnection
+        await frame.disconnect()
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+## Running Tests
+
+From the workspace root:
+
+```bash
+cd python
+uv sync --all-packages --extra tests
+uv run pytest packages/brilliant_msg/tests/
+```
+
+The test suite covers all Tx message packing (TxCode, TxPlainText, TxSpriteCoords,
+TxCaptureSettings, TxAutoExpSettings, TxSprite bit-packing and factory methods,
+TxImageSpriteBlock, TxTextSpriteBlock) and Rx message parsing (RxAudio WAV
+conversion, RxMeteringData, RxAutoExpResult, RxIMU including IMUData pitch/roll
+and SensorBuffer smoothing, RxTap, and BrilliantMsg handler dispatch). No hardware
+is required.

brilliant_msg-7.0.0/README.md

@@ -0,0 +1,93 @@
+# Brilliant Message Package
+
+A Python package for handling rich application-level messages for [Brilliant Labs](https://brilliant.xyz/) Frame and Halo devices, including sprites, text, audio, IMU data, and photos.
+
+[Frame SDK documentation](https://docs.brilliant.xyz/frame/frame-sdk/).
+
+[Examples on GitHub](https://github.com/brilliantlabsAR/brilliant_sdk/tree/main/python/packages/brilliant_msg/examples).
+
+## Installation
+
+```bash
+uv add brilliant-msg
+```
+
+## Usage
+
+```python
+import asyncio
+from pathlib import Path
+
+from brilliant_msg import BrilliantMsg, TxSprite
+
+async def main():
+    """
+    Displays sample images on the Frame display.
+
+    The images are indexed (palette) PNG images, in 2, 4, and 16 colors (that is, 1-, 2- and 4-bits-per-pixel).
+    """
+    frame = BrilliantMsg()
+    try:
+        await frame.connect()
+
+        # Let the user know we're starting
+        await frame.print_short_text('Loading...')
+
+        # send the std lua files to Frame that handle data accumulation and sprite parsing
+        await frame.upload_stdlua_libs(lib_names=['data', 'sprite'])
+
+        # Send the main lua application from this project to Frame that will run the app
+        await frame.upload_frame_app(local_filename="lua/sprite_frame_app.lua")
+
+        # attach the print response handler so we can see stdout from Frame Lua print() statements
+        frame.attach_print_response_handler()
+
+        # "require" the main frame_app lua file to run it, and block until it has started.
+        await frame.start_frame_app()
+
+        # send the 1-bit image to Frame in chunks
+        sprite = TxSprite.from_indexed_png_bytes(Path("images/logo_1bit.png").read_bytes())
+        await frame.send_message(0x20, sprite.pack())
+
+        # send a 2-bit image
+        sprite = TxSprite.from_indexed_png_bytes(Path("images/street_2bit.png").read_bytes())
+        await frame.send_message(0x20, sprite.pack())
+
+        # send a 4-bit image
+        sprite = TxSprite.from_indexed_png_bytes(Path("images/hotdog_4bit.png").read_bytes())
+        await frame.send_message(0x20, sprite.pack())
+
+        await asyncio.sleep(5.0)
+
+        # unhook the print handler
+        frame.detach_print_response_handler()
+
+        # break out of the frame app loop and reboot Frame
+        await frame.stop_frame_app()
+
+    except Exception as e:
+        print(f"An error occurred: {e}")
+    finally:
+        # clean disconnection
+        await frame.disconnect()
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+## Running Tests
+
+From the workspace root:
+
+```bash
+cd python
+uv sync --all-packages --extra tests
+uv run pytest packages/brilliant_msg/tests/
+```
+
+The test suite covers all Tx message packing (TxCode, TxPlainText, TxSpriteCoords,
+TxCaptureSettings, TxAutoExpSettings, TxSprite bit-packing and factory methods,
+TxImageSpriteBlock, TxTextSpriteBlock) and Rx message parsing (RxAudio WAV
+conversion, RxMeteringData, RxAutoExpResult, RxIMU including IMUData pitch/roll
+and SensorBuffer smoothing, RxTap, and BrilliantMsg handler dispatch). No hardware
+is required.

brilliant_msg-7.0.0/pyproject.toml

@@ -0,0 +1,55 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "brilliant-msg"
+version = "7.0.0"
+dependencies = [
+    "lz4>=4.4.3,<5.0.0",
+    "numpy>=2.2.3,<3.0.0",
+    "pillow>=11.1.0,<12.0.0",
+    "brilliant-ble>=3.0.0"
+]
+authors = [
+    { name = "luke-brilliant" },
+]
+description = "Handles various message types for Brilliant Labs Frame and Halo devices"
+readme = "README.md"
+requires-python = ">=3.10"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: BSD License",
+    "Operating System :: OS Independent",
+]
+
+[project.optional-dependencies]
+tests = [
+    "pytest>=8.0",
+    "pytest-asyncio>=0.23",
+    "pvspeaker>=1.0.0",
+    "opencv-python>=4.0.0",
+    "qoi>=0.7.0",
+]
+docs = [
+    "sphinx>=7.0.0",
+    "sphinx-rtd-theme>=2.0.0",
+]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+testpaths = ["tests"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/brilliant_msg"]
+
+[tool.hatch.build.targets.sdist]
+include = [
+    "/src",
+    "/tests",
+]
+
+[project.urls]
+"Homepage" = "https://github.com/brilliantlabsAR/brilliant_sdk/tree/main/python/packages/brilliant_msg"
+"Bug Tracker" = "https://github.com/brilliantlabsAR/brilliant_sdk/issues"
+"Changelog" = "https://github.com/brilliantlabsAR/brilliant_sdk/blob/main/python/packages/brilliant_msg/CHANGELOG.md"

brilliant_msg-7.0.0/src/brilliant_msg/__init__.py

@@ -0,0 +1,24 @@
+"""
+brilliant_msg - Message Package defines Transmit- and Receive-related message classes and their associated Lua handlers for Brilliant Labs Frame and Halo devices (https://brilliant.xyz/)
+"""
+
+__version__ = "7.0.0"
+
+from .brilliant_msg import BrilliantMsg
+
+from .tx_auto_exp_settings import TxAutoExpSettings
+from .tx_capture_settings import TxCaptureSettings
+from .tx_code import TxCode
+from .tx_image_sprite_block import TxImageSpriteBlock
+from .tx_manual_exp_settings import TxManualExpSettings
+from .tx_plain_text import TxPlainText
+from .tx_sprite import TxSprite
+from .tx_sprite_coords import TxSpriteCoords
+from .tx_text_sprite_block import TxTextSpriteBlock
+
+from .rx_audio import RxAudio
+from .rx_auto_exp_result import RxAutoExpResult
+from .rx_imu import RxIMU
+from .rx_metering_data import RxMeteringData
+from .rx_photo import RxPhoto
+from .rx_tap import RxTap

brilliant_msg-7.0.0/src/brilliant_msg/brilliant_msg.py

@@ -0,0 +1,184 @@
+from typing import List
+from importlib.resources import files
+
+from brilliant_ble import BrilliantBle, BrilliantDeviceType
+from typing import Callable
+
+class BrilliantMsg:
+    """
+    A high-level library for interacting with Brilliant Labs Frame by passing structured messages
+    between a Frameside app and a hostside app.
+
+    """
+    def __init__(self):
+        """Initialize the BrilliantMsg class with a new BrilliantBle instance and a dictionary for registered data response handlers."""
+        self.ble = BrilliantBle()
+        self.data_response_handlers = {}
+
+    async def connect(self, initialize:bool=True):
+        """
+        Connect to the Frame device and optionally run the initialization sequence.
+
+        Args:
+            initialize (bool): If True, runs the break/reset/break sequence after connecting.
+                             Defaults to True.
+
+        Returns:
+            bool: True if connection and initialization were successful
+
+        Raises:
+            Any exceptions from the underlying BrilliantBle connection
+        """
+        try:
+            await self.ble.connect(data_response_handler=self._handle_data_response)
+
+            if initialize:
+                # Send break signal in case an application loop is running
+                await self.ble.send_break_signal()
+
+                # Reset signal to restart Lua VM and initialize memory
+                await self.ble.send_reset_signal()
+
+                # Another break signal in case of auto-starting main.lua
+                await self.ble.send_break_signal()
+
+            return True
+
+        except Exception as e:
+            # If anything fails during connection or initialization,
+            # ensure we're disconnected and re-raise the exception
+            if self.ble.is_connected():
+                await self.ble.disconnect()
+            raise e
+
+
+    async def disconnect(self):
+        """Disconnect from the Frame device"""
+        if self.ble.is_connected():
+            await self.ble.disconnect()
+
+    def is_connected(self):
+        """Check if currently connected to the Frame device."""
+        return self.ble.is_connected()
+
+    async def print_short_text(self, text:str=''):
+        """
+        Convenience wrapper around `frame.display.text()` that can only be used
+        prior to the main frame_app starting (e.g. immediately after connection).
+        """
+        sanitized_text = text.replace("'", "\\'").replace("\n", "")
+        lua_command = ""
+        if (self.ble.type == BrilliantDeviceType.FRAME):
+            lua_command = f"frame.display.text('{sanitized_text}',1,1);frame.display.show();print(0)"
+        else:
+            lua_command = f"frame.display.clear();frame.display.text('{sanitized_text}',50,50);print(0)"
+
+        await self.ble.send_lua(lua_command, await_print=True)
+
+    async def upload_stdlua_libs(self, lib_names: List[str]=['data'], minified: bool=True):
+        """Send the specified standard frame-msg Lua files to Frame that are used by the frame_app, e.g. ['data', 'camera'] """
+        for stdlua in lib_names:
+            suffix = ".min" if minified else ""
+            await self.ble.upload_file_from_string(files("brilliant_msg").joinpath(f"lua/{stdlua}{suffix}.lua").read_text(), f"{stdlua}{suffix}.lua")
+
+    async def upload_frame_app(self, local_filename: str, frame_filename: str='frame_app.lua'):
+        """ Send the main lua application from this project to Frame that will run the app (but doesn't run the file)"""
+        # We rename the file slightly when we copy it, although it isn't necessary
+        await self.ble.upload_file(local_filename, frame_filename)
+
+    async def start_frame_app(self, frame_app_name:str='frame_app', await_print:bool=True):
+        """
+        'require' the main lua file to run it
+
+        Note: This require() doesn't return - frame_app.lua has a main loop,
+        so we can't put a 'print(0)' after the require() statement and wait for it to print,
+        however if our main loop prints something (even a byte) once it has started up,
+        then the await_print can be used to determine that the frameside app is ready
+        rather than waiting for an app-dependent amount of time,
+        or sending messages to Frame too early.
+        Set await_print to False if the Frame app should be asynchronously started
+        and without waiting for any printed confirmation that the frameside app is ready.
+        """
+        await self.ble.send_lua(f"require('{frame_app_name}')", await_print=await_print)
+
+    async def stop_frame_app(self, reset=True):
+        """
+        Sends a break signal to terminate the running main loop on Frame, if applicable.
+        A custom app may prefer to send a specific TxCode to the Frameside app to instruct it
+        to shut down cleanly, but a break signal will also be caught by the exception handler
+        of the main loop and is enough to clean up the display, release memory etc.
+
+        If `reset` is True (default), then also send a reset signal that will reinitialize the Lua VM
+        and boot into a saved `main.lua`, if present.
+        """
+        await self.ble.send_break_signal()
+        if reset:
+            await self.ble.send_reset_signal()
+
+    def attach_print_response_handler(self, handler=print):
+        """Attach the print response handler so we can see stdout from Frame Lua print() statements"""
+        self.ble._user_print_response_handler = handler
+
+    def detach_print_response_handler(self):
+        """Detach the print response handler so we no longer see stdout from Frame Lua print() statements"""
+        self.ble._user_print_response_handler = None
+
+    async def send_message(self, msg_code: int, payload: bytes, show_me: bool=False) -> None:
+        """
+        Sends a structured message from hostside to the Frameside app, identified by the specified msg_code.
+        For example, if the frame_app is expecting a TxCaptureSettings message on msg_code 0x0d
+        to initiate a photo capture, you might send:
+        `frame.send_message(0x0d, TxCaptureSettings(resolution=720).pack())`
+        Wraps the brilliant_ble function of the same name
+        """
+        await self.ble.send_message(msg_code, payload, show_me)
+
+    def register_data_response_handler(self, subscriber, msg_codes: List[int], handler: Callable[[bytes], None]):
+        """
+        Register a handler for a subscriber that is interested in specific msg codes.
+
+        Args:
+            subscriber: The subscriber object.
+            msg_codes (List[int]): List of single byte msg codes the subscriber is interested in.
+            handler: The handler function to receive the data.
+        """
+        for code in msg_codes:
+            if code not in self.data_response_handlers:
+                self.data_response_handlers[code] = []
+            self.data_response_handlers[code].append((subscriber, handler))
+
+    def unregister_data_response_handler(self, subscriber):
+        """
+        Unregister a subscriber from receiving data responses.
+
+        Args:
+            subscriber: The subscriber object to unregister.
+        """
+        for code in list(self.data_response_handlers.keys()):
+            self.data_response_handlers[code] = [
+                (sub, handler) for sub, handler in self.data_response_handlers[code] if sub != subscriber
+            ]
+            if not self.data_response_handlers[code]:
+                del self.data_response_handlers[code]
+
+    async def _handle_data_response(self, data: bytes):
+        """
+        Internal method to handle incoming data responses and dispatch to the appropriate handlers.
+
+        Args:
+            data (bytes): The incoming data response.
+        """
+        if data:
+            msg_code = data[0]
+            if msg_code in self.data_response_handlers:
+                for subscriber, handler in self.data_response_handlers[msg_code]:
+                    # not awaited, synchronous call
+                    handler(data)
+
+    def __getattr__(self, name):
+        """
+        Delegate any unknown attributes to the underlying BrilliantBle instance.
+        This allows direct access to all BrilliantBle methods while keeping the
+        wrapper transparent.
+        """
+        return getattr(self.ble, name)

brilliant_msg-7.0.0/src/brilliant_msg/lua/audio.lua

@@ -0,0 +1,59 @@
+-- Module for sending raw PCM audio Data from Frame's microphone
+local _M = {}
+
+-- Frame to Host flags
+local AUDIO_DATA_FINAL_MSG = 0x06
+local AUDIO_DATA_NON_FINAL_MSG = 0x05
+
+-- 1 byte reserved for flag
+local MTU = frame.bluetooth.max_length() - 1
+-- data buffer needs to be even for reading from microphone
+if MTU % 2 == 1 then MTU = MTU - 1 end
+
+function _M.start(args)
+	-- if args provides a sample_rate or a bit_depth use them otherwise use the defaults
+	local rate = (args and args.sample_rate) or 8000
+	local depth = (args and args.bit_depth) or 8
+
+	pcall(frame.microphone.start, {sample_rate=rate, bit_depth=depth})
+end
+
+function _M.stop()
+	pcall(frame.microphone.stop)
+end
+
+-- reads an MTU-sized amount of audio data and sends it to the host
+-- ensure this function is called frequently enough to keep up with realtime audio
+-- as the Frame buffer is ~32k
+function _M.read_and_send_audio()
+	audio_data = frame.microphone.read(MTU)
+
+	-- If frame.microphone.stop() is called, a nil will be read() here
+	if audio_data == nil then
+		-- send an end-of-stream message back to the host
+		while true do
+			-- If the Bluetooth is busy, this simply tries again until it gets through
+			if (pcall(frame.bluetooth.send, string.char(AUDIO_DATA_FINAL_MSG))) then
+				break
+			end
+		end
+
+		return nil
+
+	-- send the data that was read
+	elseif audio_data ~= '' then
+		while true do
+			-- If the Bluetooth is busy, this simply tries again until it gets through
+			if (pcall(frame.bluetooth.send, string.char(AUDIO_DATA_NON_FINAL_MSG) .. audio_data)) then
+				break
+			end
+		end
+
+		return string.len(audio_data)
+	end
+
+	-- no data read, no data sent
+	return 0
+end
+
+return _M

brilliant_msg-7.0.0/src/brilliant_msg/lua/audio.min.lua

@@ -0,0 +1 @@
+local a={}local b=0x06;local c=0x05;local d=frame.bluetooth.max_length()-1;if d%2==1 then d=d-1 end;function a.start(e)local f=e and e.sample_rate or 8000;local g=e and e.bit_depth or 8;pcall(frame.microphone.start,{sample_rate=f,bit_depth=g})end;function a.stop()pcall(frame.microphone.stop)end;function a.read_and_send_audio()audio_data=frame.microphone.read(d)if audio_data==nil then while true do if pcall(frame.bluetooth.send,string.char(b))then break end end;return nil elseif audio_data~=''then while true do if pcall(frame.bluetooth.send,string.char(c)..audio_data)then break end end;return string.len(audio_data)end;return 0 end;return a

brilliant_msg-7.0.0/src/brilliant_msg/lua/battery.lua

@@ -0,0 +1,17 @@
+-- Module handling periodic battery level reports on a standard message code
+local _M = {}
+
+-- Frame to phone flags
+local BATTERY_MSG = 0x0c
+
+function _M.send_batt_if_elapsed(prev, interval)
+    local t = frame.time.utc()
+    if ((prev == 0) or ((t - prev) > interval)) then
+        pcall(frame.bluetooth.send, string.char(BATTERY_MSG) .. string.char(math.floor(frame.battery_level())))
+        return t
+    else
+        return prev
+    end
+end
+
+return _M

brilliant_msg-7.0.0/src/brilliant_msg/lua/battery.min.lua

@@ -0,0 +1 @@
+local _M={}local a=0x0c;function _M.send_batt_if_elapsed(b,c)local d=frame.time.utc()if b==0 or d-b>c then pcall(frame.bluetooth.send,string.char(a)..string.char(math.floor(frame.battery_level())))return d else return b end end;return _M