CrackNuts 0.1.0__tar.gz

cracknuts-0.1.0/PKG-INFO

@@ -0,0 +1,18 @@
+Metadata-Version: 2.1
+Name: CrackNuts
+Version: 0.1.0
+Summary: A library for nut cracker device.
+Author-email: Dingzb <dingzibiao@gmail.com>
+Maintainer-email: Dingzb <dingzibiao@gmail.com>
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: numpy>=2.0.1
+Requires-Dist: pandas>=2.2.2
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Provides-Extra: marimo
+Requires-Dist: marimo; extra == "marimo"
+
+# CrackNuts
+
+TODO

cracknuts-0.1.0/README.md

@@ -0,0 +1,3 @@
+# CrackNuts
+
+TODO

cracknuts-0.1.0/pyproject.toml

@@ -0,0 +1,39 @@
+[build-system]
+requires = ["setuptools >= 61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "CrackNuts"
+description = "A library for nut cracker device."
+dynamic = ["version"]
+requires-python = ">=3.12"
+readme = "README.md"
+authors = [
+    { name = "Dingzb", email = "dingzibiao@gmail.com" }
+]
+maintainers = [
+    { name = "Dingzb", email = "dingzibiao@gmail.com" }
+]
+dependencies = [
+    "numpy >= 2.0.1",
+    "pandas >= 2.2.2"
+]
+
+[project.optional-dependencies]
+
+test = [
+    'pytest'
+]
+
+marimo = [
+    'marimo'
+]
+
+[tool.setuptools.dynamic]
+version = { attr = "cracknuts.__version__" }
+
+[tool.pytest.ini_options]
+minversion = "6.0"
+addopts = "-ra -q"
+
+[tool.pdm]

cracknuts-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

cracknuts-0.1.0/src/CrackNuts.egg-info/PKG-INFO

@@ -0,0 +1,18 @@
+Metadata-Version: 2.1
+Name: CrackNuts
+Version: 0.1.0
+Summary: A library for nut cracker device.
+Author-email: Dingzb <dingzibiao@gmail.com>
+Maintainer-email: Dingzb <dingzibiao@gmail.com>
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: numpy>=2.0.1
+Requires-Dist: pandas>=2.2.2
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Provides-Extra: marimo
+Requires-Dist: marimo; extra == "marimo"
+
+# CrackNuts
+
+TODO

cracknuts-0.1.0/src/CrackNuts.egg-info/SOURCES.txt

@@ -0,0 +1,25 @@
+README.md
+pyproject.toml
+src/CrackNuts.egg-info/PKG-INFO
+src/CrackNuts.egg-info/SOURCES.txt
+src/CrackNuts.egg-info/dependency_links.txt
+src/CrackNuts.egg-info/requires.txt
+src/CrackNuts.egg-info/top_level.txt
+src/cracknuts/__init__.py
+src/cracknuts/logger.py
+src/cracknuts/acquisition/__init__.py
+src/cracknuts/acquisition/acquisition.py
+src/cracknuts/cracker/__init__.py
+src/cracknuts/cracker/abs_cracker.py
+src/cracknuts/cracker/basic_cracker.py
+src/cracknuts/cracker/protocol.py
+src/cracknuts/solver/__init__.py
+src/cracknuts/solver/trace.py
+src/cracknuts/support/__init__.py
+src/cracknuts/support/marimo/__init__.py
+src/cracknuts/support/marimo/cracker_panel.py
+src/cracknuts/support/marimo/ui/__init__.py
+src/cracknuts/support/marimo/ui/cracker_panel.py
+src/cracknuts/utils/__init__.py
+src/cracknuts/utils/hex_util.py
+tests/test_1.py

cracknuts-0.1.0/src/CrackNuts.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

cracknuts-0.1.0/src/CrackNuts.egg-info/requires.txt

@@ -0,0 +1,8 @@
+numpy>=2.0.1
+pandas>=2.2.2
+
+[marimo]
+marimo
+
+[test]
+pytest

cracknuts-0.1.0/src/CrackNuts.egg-info/top_level.txt

@@ -0,0 +1 @@
+cracknuts

cracknuts-0.1.0/src/cracknuts/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

cracknuts-0.1.0/src/cracknuts/acquisition/acquisition.py

@@ -0,0 +1,214 @@
+import abc
+import datetime
+import threading
+import time
+import typing
+
+import numpy as np
+import zarr
+
+from cracknuts import logger
+from cracknuts.cracker.abs_cracker import AbsCracker
+
+
+class Acquisition(abc.ABC):
+
+    def __init__(self, cracker: AbsCracker):
+        self._logger = logger.get_logger(self)
+        self._cracker = cracker
+        self._last_wave: np.ndarray | None = np.array([np.zeros(1000)])
+        self._running = False
+        self._trace_count = 1
+        self._on_wave_loaded_callback: typing.Callable = typing.Callable[[np.ndarray], None]
+        self._trigger_judge_wait_time: float = 0.2  # second
+        self._trigger_judge_timeout: float = 2000000  # microsecond
+
+    def on_wave_loaded(self, callback: typing.Callable[[np.ndarray], None]) -> None:
+        self._on_wave_loaded_callback = callback
+
+    def run(self, count=1):
+        self._logger.debug('Start run mode.')
+        self._run(save_data=True, count=count)
+
+    def run_sync(self, count=1):
+        self._do_run(save_data=True, count=count)
+
+    def test(self, count=1):
+        self._logger.debug('Start test mode.')
+        self._run(count=count)
+
+    def stop(self):
+        self._running = False
+
+    def _run(self, save_data: bool = False, count=1):
+        threading.Thread(target=self._do_run, kwargs={'save_data': save_data, 'count': count}).start()
+
+    def _do_run(self, save_data: bool = False, count=1):
+
+        self._running = True
+        # self.connect_scrat()
+        # self.config_cracker()
+        # self.connect_scrat()
+        # self.config_scrat()
+        # init
+        self._trace_count = count
+        self.pre_init()
+        self.init()  # self.transfer() 用户
+        self.save_dataset()
+        self.post_init()
+
+        self._loop()
+
+        self.pre_finish()
+        self.finish()
+        if save_data:
+            self.save_data()
+        self.post_finish()
+
+        self._running = True
+
+    def _loop(self):
+        for i in range(self._trace_count):
+            self._logger.debug('Get wave data: %s', i)
+            self.pre_do()
+            start = datetime.datetime.now()
+            self.do()
+            print('count: ', i, 'delay: ', datetime.datetime.now() - start)
+            trigger_judge_start_time = datetime.datetime.now().microsecond
+            # while self._running:
+            #     trigger_judge_time = datetime.datetime.now().microsecond - trigger_judge_start_time
+            #     if trigger_judge_time > self._trigger_judge_timeout:
+            #         self._logger.error("Triggered judge timeout and will get next waves, "
+            #                            "judge time: %s and timeout is %s",
+            #                            trigger_judge_time, self._trigger_judge_timeout)
+            #         break
+            #     self._logger.debug('Judge trigger status.')
+            #     # if self._is_triggered():
+            #         # self._last_wave = self._get_waves()
+            #         # if self._last_wave is not None:
+            #         #     self._logger.debug('Got wave: %s.', self._last_wave.shape)
+            #         # if self._on_wave_loaded_callback and callable(self._on_wave_loaded_callback):
+            #         #     try:
+            #         #         self._on_wave_loaded_callback(self._last_wave)
+            #         #     except Exception as e:
+            #         #         self._logger.error('Wave loaded event callback error: %s', e.args)
+            #         # time.sleep(1) # test
+            #         # break
+            #     break
+                # time.sleep(self._trigger_judge_wait_time)
+            self._save_wave()
+            self._post_do()
+
+    def _loop_without_log(self):
+        for i in range(self._trace_count):
+            # print('yes', self._logger.handlers[0].stream)
+            # self._logger.debug('Get wave data: %s', i)
+            self.pre_do()
+            self.do()
+            trigger_judge_start_time = datetime.datetime.now().microsecond
+            while self._running:
+                trigger_judge_time = datetime.datetime.now().microsecond - trigger_judge_start_time
+                if trigger_judge_time > self._trigger_judge_timeout:
+                    # self._logger.error("Triggered judge timeout and will get next waves, "
+                    #                    "judge time: %s and timeout is %s",
+                    #                    trigger_judge_time, self._trigger_judge_timeout)
+                    break
+                # self._logger.debug('Judge trigger status.')
+                if self._is_triggered():
+                    self._last_wave = self._get_waves()
+                    if self._last_wave is not None:
+                        ...
+                        # self._logger.debug('Got wave: %s.', self._last_wave.shape)
+                    if self._on_wave_loaded_callback and callable(self._on_wave_loaded_callback):
+                        try:
+                            self._on_wave_loaded_callback(self._last_wave)
+                        except Exception as e:
+                            ...
+                            # self._logger.error('Wave loaded event callback error: %s', e.args)
+                    time.sleep(1)
+                    break
+                time.sleep(self._trigger_judge_wait_time)
+            self._save_wave()
+            self._post_do()
+
+    def connect_scrat(self):
+        """
+        Connect to scrat device
+        :return:
+        """
+        ...
+
+    def connect_cracker(self):
+        """
+        Connect to cracker device.
+        :return:
+        """
+        self._cracker.connect()
+
+    def connect_net(self):
+        ...
+
+    def config_scrat(self):
+        ...
+
+    def config_cracker(self):
+        ...
+
+    def pre_init(self):
+        ...
+
+    def init(self):
+        ...
+
+
+    def post_init(self):
+        ...
+
+    def transfer(self):
+        ...
+
+    def pre_do(self):
+        ...
+
+    def do(self):
+       ...
+
+    def _post_do(self):
+        ...
+
+    def arm(self):
+        ...
+
+    def _is_triggered(self):
+        # for test
+        time.sleep(0.1)
+        return True
+
+    def _get_waves(self):
+        return np.array([np.random.random(1000)])
+
+    def _save_wave(self):
+        ...
+
+    def save_data(self, data_type: str = 'zarr'):
+        """
+        Save wave, key and other info to acquisition dataset file.
+        """
+        # if data_type == 'zarr':
+        #     zarr.create()
+        ...
+
+    def pre_finish(self):
+        ...
+
+    def post_finish(self):
+        ...
+
+    def save_dataset(self):
+        ...
+
+    def finish(self):
+        pass
+
+    def get_last_wave(self):
+        return self._last_wave

cracknuts-0.1.0/src/cracknuts/cracker/abs_cracker.py

@@ -0,0 +1,355 @@
+import socket
+import struct
+import typing
+from abc import ABC
+from abc import abstractmethod
+
+from cracknuts import logger
+from cracknuts.cracker import protocol
+import cracknuts.utils.hex_util as hex_util
+
+
+class Commands:
+    """
+    Protocol commands.
+    """
+    GET_ID = 0x0001
+    GET_NAME = 0x0002
+
+    SCRAT_ANALOG_CHANNEL_ENABLE = 0x0100
+    SCRAT_ANALOG_COUPLING = 0x0101
+    SCRAT_ANALOG_VOLTAGE = 0x0102
+    SCRAT_ANALOG_BIAS_VOLTAGE = 0x0103
+    SCRAT_ANALOG_GAIN = 0x0104
+
+    SCRAT_DIGITAL_CHANNEL_ENABLE = 0x0110
+    SCRAT_DIGITAL_VOLTAGE = 0x0111
+
+    SCRAT_TRIGGER_MODE = 0x0120
+
+    SCRAT_ANALOG_TRIGGER_SOURCE = 0x0121
+    SCRAT_DIGITAL_TRIGGER_SOURCE = 0x0122
+
+    SCRAT_ANALOG_TRIGGER_VOLTAGE = 0x0123
+
+    SCRAT_TRIGGER_DELAY = 0x0124
+
+    SCRAT_SAMPLE_LENGTH = 0x0125
+
+    SCRAT_ARM = 0x0126
+
+    SCRAT_IS_TRIGGERED = 0x0127
+
+    SCRAT_GET_ANALOG_WAVES = 0x0130
+    SCRAT_GET_DIGITAL_WAVES = 0x0130
+
+    CRACKER_NUT_ENABLE = 0x0200
+    CRACKER_NUT_VOLTAGE = 0x0201
+    CRACKER_NUT_INTERFACE = 0x0210
+    CRACKER_NUT_TIMEOUT = 0x0224
+
+    CRACKER_SERIAL_BAUD = 0x0220
+    CRACKER_SERIAL_WIDTH = 0x0221
+    CRACKER_SERIAL_STOP = 0x0222
+    CRACKER_SERIAL_ODD_EVE = 0x0223
+    CRACKER_SERIAL_DATA = 0x022A
+
+    CRACKER_SPI_CPOL = 0x0230
+    CRACKER_SPI_CPHA = 0x0231
+    CRACKER_SPI_DATA_LEN = 0x0232
+    CRACKER_SPI_FREQ = 0x0233
+    CRACKER_SPI_TIMEOUT = 0x0234
+    CRACKER_SPI_DATA = 0x023A
+
+    CRACKER_I2C_FREQ = 0x0240
+    CRACKER_I2C_TIMEOUT = 0x0244
+    CRACKER_I2C_DATA = 0x024A
+
+    CRACKER_CAN_FREQ = 0x0250
+    CRACKER_CAN_TIMEOUT = 0x0254
+    CRACKER_CA_DATA = 0x025A
+
+
+class AbsCracker(ABC):
+    """Cracker
+    Cracker
+    """
+
+    def __init__(self, server_address=None):
+        """
+        :param server_address: Cracker device address (ip, port)
+        """
+        self._logger = logger.get_logger(self)
+        self._server_address = server_address
+        self._socket: socket.socket | None = None
+        self._connection_status = False
+
+    def set_addr(self, ip, port) -> None:
+        self._server_address = ip, port
+
+    def connect(self):
+        """
+        Connect to Cracker device.
+        :return: Cracker self.
+        """
+        try:
+            if not self._socket:
+                self._socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+                self._socket.settimeout(5)
+            self._socket.connect(self._server_address)
+            self._connection_status = True
+            self._logger.info('Connected to cracker: {}'.format(self._server_address))
+        except socket.error as e:
+            self._logger.error('Connection failed: %s', e)
+            self._connection_status = False
+        return self
+
+    def disconnect(self):
+        """
+        Disconnect Cracker device.
+        :return: Cracker self.
+        """
+        try:
+            if self._socket:
+                self._socket.close()
+            self._socket = None
+            self._logger.info(f'Disconnect from {self._server_address}')
+        except socket.error as e:
+            self._logger.error('Disconnection failed: %s', e)
+        finally:
+            self._connection_status = False
+        return self
+
+    def reconnect(self):
+        """
+        Reconnect to Cracker device.
+        :return: Cracker self.
+        """
+        self.disconnect()
+        self.connect()
+
+    def get_connection_status(self):
+        """
+        Get connection status.
+        :return: True or False
+        """
+        return self._connection_status
+
+    def send_and_receive(self, message) -> None | bytes:
+        """
+        Send message to socket
+        :param message:
+        :return:
+        """
+        try:
+            if not self.get_connection_status():
+                self.connect()
+            self._logger.debug("Send message to %s: \n%s", self._server_address,
+                               hex_util.get_bytes_matrix(message))
+            self._socket.sendall(message)
+            resp_header = self._socket.recv(protocol.RESP_HEADER_SIZE)
+            self._logger.debug("Get response header from %s: \n%s", self._server_address,
+                               hex_util.get_bytes_matrix(resp_header))
+            magic, version, direction, status, length = struct.unpack(
+                protocol.RESP_HEADER_FORMAT, resp_header
+            )
+            self._logger.debug(
+                "Receive header from %s: %s",
+                self._server_address,
+                (magic, version, direction, status, length),
+            )
+
+            if length == 0:
+                return None
+            resp_payload = self._socket.recv(length)
+            self._logger.debug(
+                "Receive payload from %s: \n%s", self._server_address, hex_util.get_bytes_matrix(resp_payload)
+            )
+            return resp_payload
+        except socket.error as e:
+            self._logger.error('Send message failed: %s', e)
+            return None
+
+    def send_with_command(self, command: int | bytes, payload: str | bytes = None):
+        if isinstance(payload, str):
+            payload = bytes.fromhex(payload)
+        return self.send_and_receive(protocol.build_send_message(command, payload))
+
+    def echo(self, payload: str) -> str:
+        """
+        length <= 1024
+        """
+        self._socket.sendall(payload.encode('ascii'))
+        res = self._socket.recv(1024).decode('ascii')
+        self._logger.debug(f'Get response: {res}')
+        return res
+
+    def echo_hex(self, payload: str) -> str:
+        """
+        length <= 1024
+        """
+        payload = bytes.fromhex(payload)
+        self._socket.sendall(payload)
+        res = self._socket.recv(1024).hex()
+        self._logger.debug(f'Get response: {res}')
+        return res
+
+    @abstractmethod
+    def get_id(self) -> str:
+        ...
+
+    @abstractmethod
+    def get_name(self) -> str:
+        ...
+
+    @abstractmethod
+    def scrat_analog_channel_enable(self, enable: typing.Dict[int, bool]):
+        ...
+
+    @abstractmethod
+    def scrat_analog_coupling(self, coupling: typing.Dict[int, int]):
+        ...
+
+    @abstractmethod
+    def scrat_analog_voltage(self, channel: int, voltage: int):
+        ...
+
+    @abstractmethod
+    def scrat_analog_bias_voltage(self, channel: int, voltage: int):
+        ...
+
+    @abstractmethod
+    def scrat_digital_channel_enable(self, enable: typing.Dict[int, bool]):
+        ...
+
+    @abstractmethod
+    def scrat_digital_voltage(self, voltage: int):
+        ...
+
+    @abstractmethod
+    def scrat_trigger_mode(self, source: int, stop: int):
+        ...
+
+    @abstractmethod
+    def scrat_analog_trigger_source(self, channel: int):
+        ...
+
+    @abstractmethod
+    def scrat_digital_trigger_source(self, channel: int):
+        ...
+
+    @abstractmethod
+    def scrat_analog_trigger_voltage(self, voltage: int):
+        ...
+
+    @abstractmethod
+    def scrat_trigger_delay(self, delay: int):
+        ...
+
+    @abstractmethod
+    def scrat_sample_len(self, length: int):
+        ...
+
+    @abstractmethod
+    def scrat_arm(self):
+        ...
+
+    @abstractmethod
+    def scrat_is_triggered(self):
+        ...
+
+    @abstractmethod
+    def scrat_get_analog_wave(self, channel: int, offset: int, sample_count: int):
+        ...
+
+    @abstractmethod
+    def scrat_get_digital_wave(self, channel: int, offset: int, sample_count: int):
+        ...
+
+    @abstractmethod
+    def scrat_analog_gain(self, gain: int):
+        ...
+
+    @abstractmethod
+    def cracker_nut_enable(self, enable: int):
+        ...
+
+    @abstractmethod
+    def cracker_nut_voltage(self, voltage: int):
+        ...
+
+    @abstractmethod
+    def cracker_nut_interface(self, interface: typing.Dict[int, bool]):
+        ...
+
+    @abstractmethod
+    def cracker_nut_timeout(self, timeout: int):
+        ...
+
+    @abstractmethod
+    def cracker_serial_baud(self, baud: int):
+        ...
+
+    @abstractmethod
+    def cracker_serial_width(self, width: int):
+        ...
+
+    @abstractmethod
+    def cracker_serial_stop(self, stop: int):
+        ...
+
+    @abstractmethod
+    def cracker_serial_odd_eve(self, odd_eve: int):
+        ...
+
+    @abstractmethod
+    def cracker_serial_data(self, expect_len: int, data: bytes):
+        ...
+
+    @abstractmethod
+    def cracker_spi_cpol(self, cpol: int):
+        ...
+
+    @abstractmethod
+    def cracker_spi_cpha(self, cpha: int):
+        ...
+
+    @abstractmethod
+    def cracker_spi_data_len(self, cpha: int):
+        ...
+
+    @abstractmethod
+    def cracker_spi_freq(self, freq: int):
+        ...
+
+    @abstractmethod
+    def cracker_spi_timeout(self, timeout: int):
+        ...
+
+    @abstractmethod
+    def cracker_spi_data(self, expect_len: int, data: bytes):
+        ...
+
+    @abstractmethod
+    def cracker_i2c_freq(self, freq: int):
+        ...
+
+    @abstractmethod
+    def cracker_i2c_timeout(self, timeout: int):
+        ...
+
+    @abstractmethod
+    def cracker_i2c_data(self, expect_len: int, data: bytes):
+        ...
+
+    @abstractmethod
+    def cracker_can_freq(self, freq: int):
+        ...
+
+    @abstractmethod
+    def cracker_can_timeout(self, timeout: int):
+        ...
+
+    @abstractmethod
+    def cracker_can_data(self, expect_len: int, data: bytes):
+        ...