qrss-ei 0.0.1__py3-none-any.whl

qrss_ei/__init__.py

@@ -0,0 +1,202 @@
+import argparse
+import collections.abc
+import logging
+import sys
+import time
+import typing
+
+from cw_enc.cw_coder import CWCoder, raise_on_notmorseable_char
+from cw_enc.paddle_samplecount import PaddleSampleCount
+
+from qrss_ei.qrss_paddle import QRSS_Paddle
+from qrss_ei.tx import AbstractConnectedTx, connect_to_rigctld_factory
+from qrss_ei.waiting import AbstractWaiter, Waiter
+
+QRSS_EI_VERSION = "0.0.1"
+
+logger = logging.getLogger(__name__)
+
+
+def count_dot_times(intext: str) -> int:
+    with PaddleSampleCount(
+        dit_samples=2, dah_samples=4, ci_silence_samples=2, iw_silence_samples=4
+    ) as dot_counter:
+        coder = CWCoder(paddle=dot_counter, on_missing=raise_on_notmorseable_char)
+        for c in intext:
+            coder.code(c)
+    return typing.cast(PaddleSampleCount, dot_counter).count()
+
+
+def inner_inner(
+    intext: str,
+    dot_length: float,
+    period_s: float,
+    repeats: int,
+    qrg: float,
+    deltaf: float,
+    connect_to_rigctld: typing.Callable[[], typing.ContextManager[AbstractConnectedTx]],
+    waiter: AbstractWaiter,
+    duration: float,
+) -> None:
+    if period_s < duration:
+        raise ValueError(
+            f"A {duration} seconds message does not fit into {period_s} s period."
+        )
+    start_of_everything_µs = waiter.get_now()
+    with connect_to_rigctld() as connected_tx:
+        start_for_loop_iteration_µs = waiter.get_now()
+        logger.debug(
+            "Starting to send at %.2f s into hour",
+            start_for_loop_iteration_µs % (3600 * 1000000) * 1e-6,
+        )
+        for loop_count in range(0, repeats):
+            with QRSS_Paddle(
+                dot_length, qrg, qrg + deltaf, connected_tx, waiter
+            ) as paddle:
+                coder = CWCoder(paddle=paddle, on_missing=raise_on_notmorseable_char)
+                for c in intext:
+                    coder.code(c)
+            if loop_count + 1 < repeats:
+                start_for_loop_iteration_µs += round(period_s * 1e6)
+                logger.debug(
+                    "Want to wait until %.2f s into hour",
+                    start_of_everything_µs % (3600 * 1000000) * 1e-6,
+                )
+
+                waiter.wait_until(start_for_loop_iteration_µs)
+
+
+def main_inner(
+    intext: str,
+    dot_length: float,
+    count_only: bool,
+    period_seconds: float,
+    repeats: int,
+    qrg: float,
+    deltaf: float,
+    host: str,
+    port: int,
+) -> None:
+    dot_count = count_dot_times(intext)
+    duration = dot_count * dot_length
+    logger.info(
+        'Message "%s" takes %d dot lengths %.1f s to tx.', intext, dot_count, duration
+    )
+    if count_only:
+        pass
+    else:
+        connect_to_rigctld = connect_to_rigctld_factory(host, port)
+        inner_inner(
+            intext,
+            dot_length,
+            period_seconds,
+            repeats,
+            qrg,
+            deltaf,
+            connect_to_rigctld,
+            Waiter(),
+            duration,
+        )
+
+
+def setup_logging(verbose: bool) -> None:
+    logging.Formatter.converter = time.gmtime
+    logging.basicConfig(
+        format="%(asctime)sZ %(levelname)5s: %(message)s",
+        level=logging.DEBUG if verbose else logging.INFO,
+    )
+
+
+def main(
+    parse_us: list[str] = sys.argv[1:],
+    inner: collections.abc.Callable[
+        [str, float, bool, float, int, float, float, str, int],
+        None,
+    ] = main_inner,
+) -> None:
+    argp = argparse.ArgumentParser(
+        prog="qrss_ei",
+        description="Simple software to send QRSS CW transmissions, "
+        "at home at https://codeberg.org/omwb/qrss-ei",
+    )
+
+    argp.add_argument(
+        "--intext", type=str, required=True, help="The text to be sent. Required."
+    )
+
+    argp.add_argument(
+        "--dotlength",
+        type=float,
+        default=3.0,
+        help="The dot length in seconds, float, default 3.0.",
+    )
+    argp.add_argument(
+        "--count",
+        action="store_true",
+        help="Only analyze the text length, without actually sending anything.",
+    )
+    argp.add_argument(
+        "--period",
+        type=float,
+        default=10,
+        help="After how many minutes to repeat the transmission (if at all), default 10.",
+    )
+    argp.add_argument(
+        "--repeats",
+        type=int,
+        default=1,
+        help="How often to transmit the same text, default 1.",
+    )
+    argp.add_argument(
+        "--qrg",
+        type=float,
+        default=10139842,
+        help="Lower (off) frequency on which you want to transmit, in Hz, default 10139842",
+    )
+    argp.add_argument(
+        "--deltaf",
+        type=float,
+        default=5,
+        help="Delta between off and on frequency, in Hz, default 5",
+    )
+
+    argp.add_argument(
+        "--host",
+        type=str,
+        help="Host running rigctld, default 127.0.0.1",
+        default="127.0.0.1",
+    )
+
+    argp.add_argument(
+        "--port",
+        type=int,
+        help="Port running rigctld, default 4532",
+        default=4532,
+    )
+
+    argp.add_argument(
+        "-v",
+        "--verbose",
+        action="store_true",
+        help="Produce detailed, verbose output telling you what's being done.",
+    )
+
+    args = argp.parse_args(parse_us)
+
+    setup_logging(args.verbose)
+
+    inner(
+        args.intext,
+        args.dotlength,
+        args.count,
+        args.period * 60,
+        args.repeats,
+        args.qrg,
+        args.deltaf,
+        args.host,
+        args.port,
+    )
+
+
+if __name__ == "__main__":
+    main()

qrss_ei/qrss_paddle.py

@@ -0,0 +1,69 @@
+import logging
+from types import TracebackType
+from typing import Literal, Optional, Type
+
+from cw_enc.paddle import Paddle
+
+from qrss_ei.tx import AbstractConnectedTx
+from qrss_ei.waiting import AbstractWaiter
+
+logger = logging.getLogger(__name__)
+
+
+class QRSS_Paddle(Paddle):
+    def __init__(
+        self,
+        dot_length: float,
+        qrg_up: float,
+        qrg_down: float,
+        tx: AbstractConnectedTx,
+        waiter: AbstractWaiter,
+    ):
+        self._dot_length_µs = round(dot_length * 1e6)
+        self._qrg_down = qrg_down
+        self._qrg_up = qrg_up
+        self._tx = tx
+        self._waiter = waiter
+        self._next_end_of_signal_µs = self._waiter.get_now()
+        self._start_of_everything = self._next_end_of_signal_µs
+
+    def _signal(self, µs_down: int, µs_up: int) -> None:
+        self._waiter.wait_until(self._next_end_of_signal_µs)
+        if 0 < µs_down:
+            self._tx.ptt_up()
+            self._tx.set_qrg(self._qrg_down)
+            self._tx.ptt_down()
+            self._waiter.wait_until(self._next_end_of_signal_µs + µs_down)
+            self._tx.ptt_up()
+            self._tx.set_qrg(self._qrg_up)
+            self._tx.ptt_down()
+        self._next_end_of_signal_µs += µs_down + µs_up
+
+    def dit(self) -> None:
+        logger.debug(
+            "Dit to start at %.2f s into hour",
+            (self._next_end_of_signal_µs % (3600 * 1000000)) * 1e-6,
+        )
+        self._signal(self._dot_length_µs, self._dot_length_µs)
+
+    def dah(self) -> None:
+        logger.debug(
+            "Dah to start at %.2f s into hour",
+            (self._next_end_of_signal_µs % (3600 * 1000000)) * 1e-6,
+        )
+        self._signal(self._dot_length_µs * 3, self._dot_length_µs)
+
+    def csilence(self) -> None:
+        self._signal(0, 2 * self._dot_length_µs)
+
+    def iwsilence(self) -> None:
+        self._signal(0, 4 * self._dot_length_µs)
+
+    def __exit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> Literal[False]:
+        self._waiter.wait_until(self._next_end_of_signal_µs)
+        return False

qrss_ei/tx.py

@@ -0,0 +1,93 @@
+import abc
+import contextlib
+import socket
+import typing
+
+
+class AbstractConnectedTx(abc.ABC):
+    @abc.abstractmethod
+    def ptt_down(self) -> None:
+        pass
+
+    @abc.abstractmethod
+    def ptt_up(self) -> None:
+        pass
+
+    @abc.abstractmethod
+    def set_qrg(self, qrg: float) -> None:
+        pass
+
+
+class ConnectedSocket(typing.Protocol):
+    def recv(self, bufsize: int) -> bytes:
+        pass
+
+    def sendall(self, b: bytes) -> None:
+        pass
+
+
+class CommunicationWithRigctldError(Exception):
+    pass
+
+
+class ConnectedTx(AbstractConnectedTx):
+    def __init__(self, rigctld_socket: ConnectedSocket) -> None:
+        self._rigctld_socket = rigctld_socket
+
+    def _ptt(self, digit: bytes) -> None:
+        self._rigctld_socket.sendall(b";\\set_ptt " + digit + b"\n")
+        answer = self._rigctld_socket.recv(1024)
+        answer_parts = answer.split(b";")
+        if len(answer_parts) != 2:
+            raise CommunicationWithRigctldError(
+                f'Rigctld did not send expected two ";"-separated parts, found {answer!r}'
+            )
+        if answer_parts[0] != b"set_ptt: " + digit:
+            raise CommunicationWithRigctldError(
+                f'Rigctld did not send expected initial "set_ptt: {str(digit, encoding="UTF-8")}", found {answer!r}'
+            )
+        if answer_parts[1] != b"RPRT 0\n":
+            raise CommunicationWithRigctldError(
+                f'Rigctld answer did not end with "RPRT 0\\n" as expected, found {answer!r}'
+            )
+
+    def ptt_down(self) -> None:
+        # Set PTT to data (3), so no accidental noise is transmitted.
+        self._ptt(b"3")
+
+    def ptt_up(self) -> None:
+        self._ptt(b"0")
+
+    def set_qrg(self, qrg: float) -> None:
+        freq_b = f"{qrg}".encode("UTF-8")
+        self._rigctld_socket.sendall(b";\\set_freq " + freq_b + b"\n")
+        answer = self._rigctld_socket.recv(1024)
+        answer_parts = answer.split(b";")
+        if len(answer_parts) != 2:
+            raise CommunicationWithRigctldError(
+                f'Rigctld did not send expected two ";"-separated parts, found {answer!r}'
+            )
+        if answer_parts[0] != b"set_freq: " + freq_b:
+            raise CommunicationWithRigctldError(
+                f'Rigctld did not send expected initial "set_freq {str(freq_b, encoding="UTF-8")}", found {answer!r}'
+            )
+        if answer_parts[1] != b"RPRT 0\n":
+            raise CommunicationWithRigctldError(
+                f'Rigctld answer did not end with "RPRT 0\\n" as expected, found {answer!r}'
+            )
+
+
+def connect_to_rigctld_factory(
+    host: str, port: int
+) -> typing.Callable[[], typing.ContextManager[ConnectedTx]]:
+
+    @contextlib.contextmanager
+    def connect_to_rigctld() -> typing.Iterator[ConnectedTx]:
+        with socket.create_connection((host, port)) as rigctld_connected_socket:
+            connected_tx = ConnectedTx(rigctld_connected_socket)
+            try:
+                yield connected_tx
+            finally:
+                connected_tx.ptt_up()
+
+    return connect_to_rigctld

qrss_ei/waiting.py

@@ -0,0 +1,36 @@
+import abc
+import logging
+import time
+
+logger = logging.getLogger(__name__)
+
+
+class AbstractWaiter(abc.ABC):
+    @abc.abstractmethod
+    def get_now(self) -> int:
+        """Return present time in µseconds since epoch"""
+        pass
+
+    @abc.abstractmethod
+    def wait_until(self, µseconds_since_epoch: int) -> None:
+        """Wait until"""
+        pass
+
+
+class Waiter(AbstractWaiter):
+
+    def get_now(self) -> int:
+        return (time.monotonic_ns() + 500) // 1000
+
+    def wait_until(self, µseconds_since_epoch: int) -> None:
+        now = self.get_now()
+        while now < µseconds_since_epoch:
+            need_to_sleep = (µseconds_since_epoch - now) * 1e-6
+            # logger.debug(
+            #     "Need to sleep for %.3f seconds, now %d, wake %d",
+            #     need_to_sleep,
+            #     now,
+            #     µseconds_since_epoch,
+            # )
+            time.sleep(need_to_sleep)
+            now = self.get_now()

qrss_ei-0.0.1.dist-info/METADATA

@@ -0,0 +1,116 @@
+Metadata-Version: 2.4
+Name: qrss-ei
+Version: 0.0.1
+Summary: A simple QRSS CW (very slow Morse code) transmit software.
+Author-email: "Dr. Andreas Krüger, DJ3EI" <dj3ei@famsik.de>
+License-Expression: MIT
+Project-URL: Homepage, https://codeberg.org/omwb/qrss-ei
+Project-URL: Repository, https://codeberg.org/omwb/qrss-ei
+Project-URL: Issues, https://codeberg.org/omwb/qrss-ei/issues
+Keywords: ham,amateur radio
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Communications :: Ham Radio
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: morse2sound~=1.0.7
+Dynamic: license-file
+
+# qrss-ei: Software to transmit QRSS CW signals
+
+## Introduction
+
+### What is QRSS CW?
+
+Very slow Morse code. In normal Morse code, the beginner's slow speed
+is 60 cpm (characters per minute), which is the same as 12 wpm (words
+per minute).  At that speed, the fundamental unit, the "dot length",
+is 100 ms.  In QRSS, the dot length is much longer, commonly 3 seconds
+or more.  In other words, QRSS is Morse code with a speed of 2 cpm =
+0.4 wpm or less.
+
+Normal CW is on-off-keying. QRSS is commonly sent as
+frequency-shift-keying, with the "key engaged" frequency typically
+being 5 Hz above the "key released" frequency.
+
+Finally, typical QRSS receiving software assumes that the QRSS
+transmission is repeated a few times each 10 minutes, preferably with
+exactly the same timing.  This is used to "integrate" serveral
+transmissions so they can be fished out of the noise better.
+
+QRSS is also very much a QRP mode.  Typical transceivers put out a few
+100 mW or so, some even less.
+
+The waterholes for people interested in this mode seems to be
+
+- To read up on it: [Scott Harden + Andy
+  resources](https://swharden.com/qrss/plus/)
+- To meet others doing it (and read up some more): [QRSS Knights
+  mailing list](https://groups.io/g/qrssknights)
+
+### What is this project?
+
+This software enables me to transmit QRSS signals.
+
+Management summary: This is a programm that talks to
+[rigctld](https://hamlib.sourceforge.net/html/rigctld.1.html) from the
+well-known [hamlib](https://hamlib.github.io/) software package.  The
+rig should be set to RTTY mode, which will cause a carrier to be sent
+whenever PTT is pressed. Alternatively, some other such mode can be
+tried (AM and FM would work as well).
+
+No actual characters are ever emitted to be sent via RTTY.  Also, this
+uses the "data" variety of "PTT", and as now data comes in, AM and FM
+should also send a bare, unmodulated carrier.
+
+On each frequency shift, the PTT is briefly released, the frequency
+shifted 5 Hz up or down, and the PTT again pressed.
+
+This is strictly a command-line utility.  It needs only plain Python
+without any modules that need compilation.  It does make use of the
+[morse2sound](https://gitlab.com/4ham/morse2sound) software by the
+same author which already has the code to convert text into Morse code
+characters.  But morse2sound is plain Python as well.
+
+### What do I use to *receive* QRSS CW?
+
+This software does not help you to receive QRSS CW.  To do that, I
+presently use [Lopora](https://www.qsl.net/pa2ohh/11lop.htm).
+
+#### Installation hints on that:
+
+The Lopora instructions address unconventional installation targets.
+On my plain Python installation on my plain Linux Debian Laptop, I
+found I just needed an active [virtual
+environment](https://docs.python.org/3/library/venv.html#creating-virtual-environments)
+with this pre-installation:
+
+```
+pip install numpy pillow pyaudio
+```
+
+On my Debian Linux Trixie box, I'm using 16 (pipewire) as the "audio
+device for input".  I set the input device actually used via the
+standard Gnome configuration.
+
+## Installation
+
+### Plain Python
+
+- Construct a plain Python [virtual
+  environment](https://docs.python.org/3/library/venv.html#creating-virtual-environments)
+- activate it
+- `pip install qrss-ei
+
+### uv
+
+If you use the [uv](https://docs.astral.sh/uv/) Python dependency
+manager:
+
+- Construct a uv virtual environment with `uv venv`
+- activate it
+- `uv pip install qrss-ei`
+

qrss_ei-0.0.1.dist-info/RECORD

@@ -0,0 +1,10 @@
+qrss_ei/__init__.py,sha256=pWuvdIQu9ZheNffFcR4xYkFL9XKV0R98tzx_iOQV5wQ,5469
+qrss_ei/qrss_paddle.py,sha256=Wdk-C2FIS5JrCw0LXVf5h47Hz2Pxahxh1AfoeBCanf8,2179
+qrss_ei/tx.py,sha256=74zsjUwxmPUed-A32v8B3Z3xIau9aGUq8j3Qx56cfhU,3057
+qrss_ei/waiting.py,sha256=ST97-ObRzZP-90-DfMTQGja-j-OoOpjvl94KmKCdmzo,955
+qrss_ei-0.0.1.dist-info/licenses/LICENSE,sha256=jwym1r_Ve0TNtRFGPFVocAx13lVuj9VQWAENgEqNiEY,1074
+qrss_ei-0.0.1.dist-info/METADATA,sha256=ew3epLxGhyCSaxaN61o4z5HEV13eFiTj5qdhpOTUrEk,4209
+qrss_ei-0.0.1.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+qrss_ei-0.0.1.dist-info/entry_points.txt,sha256=1-6IfMZC6s5_lbkeb6TA_EK2SKMdJx3wv17ULGVnx9w,41
+qrss_ei-0.0.1.dist-info/top_level.txt,sha256=1rIU2z0WhSNafJ8-A9d1UgaSZRqCGHhuHJepQ72KlRo,8
+qrss_ei-0.0.1.dist-info/RECORD,,

qrss_ei-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

qrss_ei-0.0.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+qrss_ei = qrss_ei:main

qrss_ei-0.0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,20 @@
+Copyright 2026 Dr. Andreas Krüger, DJ3EI
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+“Software”), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

qrss_ei-0.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+qrss_ei