thzdaqapi 0.1.0__py3-none-any.whl

thzdaqapi/Agilent/signal_generator.py

@@ -0,0 +1,157 @@
+import logging
+from typing import Any
+
+from thzdaqapi import settings
+from thzdaqapi.utils.classes import BaseInstrument
+
+logger = logging.getLogger(__name__)
+
+
+class SignalGenerator(BaseInstrument):
+    model = "E8247C"
+    ALC_RANGE = [-7.9, 2]
+    ATTENUATOR_RANGE = [0, 10, 20, 30, 40, 50, 60, 70, 80, 90]
+
+    def __init__(
+        self,
+        host: str = "169.254.156.103",
+        gpib: int = 19,
+        adapter: str = settings.PROLOGIX_ETHERNET,
+        port: int = 1234,
+        *args: Any,
+        **kwargs: Any,
+    ) -> None:
+        """Initialize device instance and configure connection parameters."""
+        super().__init__(host=host, gpib=gpib, adapter=adapter, port=port, *args, **kwargs)
+
+    def idn(self) -> str:
+        """Return instrument identification string."""
+        assert self.adapter is not None, "Adapter couldn't be None"
+        return self.adapter.query("*IDN?", eq_addr=self.gpib)
+
+    def test(self) -> bool:
+        # return self.adapter.query("*TST?", eq_addr=self.gpib)
+        """Run a lightweight communication check and return status."""
+        result = self.idn()
+        return "Agilent" in result
+
+    def reset(self) -> str:
+        """Reset the device to a known default state."""
+        assert self.adapter is not None, "Adapter couldn't be None"
+        return self.adapter.write("*RST", eq_addr=self.gpib)
+
+    def get_rf_output_state(self) -> bool:
+        """Read current rf output state from the device."""
+        assert self.adapter is not None, "Adapter couldn't be None"
+        return bool(int(self.adapter.query("OUTPut?", eq_addr=self.gpib)))
+
+    def set_rf_output_state(self, value: bool) -> None:
+        """Set rf output state on the device."""
+        output = 1 if value else 0
+        assert self.adapter is not None, "Adapter couldn't be None"
+        self.adapter.write(f"OUTPut {output}", eq_addr=self.gpib)
+
+    def get_frequency(self) -> float:
+        """Read current frequency from the device."""
+        assert self.adapter is not None, "Adapter couldn't be None"
+        return float(self.adapter.query(":FREQuency:FIXed? ", eq_addr=self.gpib))
+
+    def set_frequency(self, value: float) -> None:
+        """Set frequency on the device."""
+        assert self.adapter is not None, "Adapter couldn't be None"
+        self.adapter.write(f":FREQuency:FIXed {value} ", eq_addr=self.gpib)
+
+    def get_attenuation_level(self) -> float:
+        """Read current attenuation level from the device."""
+        assert self.adapter is not None, "Adapter couldn't be None"
+        return float(self.adapter.query(":POWer:ATTenuation?", eq_addr=self.gpib))
+
+    def set_attenuation_level(self, value: float) -> None:
+        """Set attenuation level on the device."""
+        assert self.adapter is not None, "Adapter couldn't be None"
+        return self.adapter.write(f":POWer:ATTenuation {value}", eq_addr=self.gpib)
+
+    def get_alc_level(self) -> float:
+        """Read current alc level from the device."""
+        assert self.adapter is not None, "Adapter couldn't be None"
+        return float(self.adapter.query(":POWer:ALC:LEVel?", eq_addr=self.gpib))
+
+    def set_alc_level(self, value: float) -> None:
+        """Set alc level on the device."""
+        assert self.adapter is not None, "Adapter couldn't be None"
+        return self.adapter.write(f":POWer:ALC:LEVel {value}", eq_addr=self.gpib)
+
+    def get_amplitude(self) -> float:
+        """Read current amplitude from the device."""
+        attenuation = self.get_attenuation_level()
+        asc = self.get_alc_level()
+        return asc - attenuation
+
+    def set_amplitude(self, value: float) -> None:
+        """Set amplitude on the device."""
+        if value > 25:
+            raise Exception("Value greater then 25 dBm unsupported!")
+        k = int(round((abs(value) - 10) / 10))
+        if k < 0 or value > 0:
+            k = 0
+        attenuation = self.ATTENUATOR_RANGE[k]
+        alc = value + attenuation
+        self.set_alc_level(0)
+        self.set_attenuation_level(attenuation)
+        self.set_alc_level(alc)
+
+    def set_power(self, value: float) -> None:
+        """Set power on the device."""
+        assert self.adapter is not None, "Adapter couldn't be None"
+        self.adapter.write(f"POW {value}dBm", eq_addr=self.gpib)
+
+    def get_power(self) -> float:
+        """Read current power from the device."""
+        assert self.adapter is not None, "Adapter couldn't be None"
+        return float(self.adapter.query("POW?", eq_addr=self.gpib))
+
+    def get_oem_status(self) -> str:
+        """ON|OFF|NONE|REAR|FRONT"""
+        assert self.adapter is not None, "Adapter couldn't be None"
+        return self.adapter.query(":SYSTem:OEMHead:SELect?", eq_addr=self.gpib)
+
+    def set_oem_status(self, value: str) -> None:
+        """ON|OFF|NONE|REAR|FRONT"""
+        assert self.adapter is not None, "Adapter couldn't be None"
+        self.adapter.write(f":SYSTem:OEMHead:SELect {value}", eq_addr=self.gpib)
+
+    def get_oem_frequency_start(self) -> float:
+        """Read current oem frequency start from the device."""
+        assert self.adapter is not None, "Adapter couldn't be None"
+        return float(self.adapter.query(":SYSTem:OEMHead:FREQuency:STARt?", eq_addr=self.gpib))
+
+    def set_oem_frequency_start(self, value: float) -> None:
+        """Set oem frequency start on the device."""
+        assert self.adapter is not None, "Adapter couldn't be None"
+        self.adapter.write(f":SYSTem:OEMHead:FREQuency:STARt {value}", eq_addr=self.gpib)
+
+    def get_oem_frequency_stop(self) -> float:
+        """Read current oem frequency stop from the device."""
+        assert self.adapter is not None, "Adapter couldn't be None"
+        return float(self.adapter.query(":SYSTem:OEMHead:FREQuency:STOP?", eq_addr=self.gpib))
+
+    def set_oem_frequency_stop(self, value: float) -> None:
+        """Set oem frequency stop on the device."""
+        assert self.adapter is not None, "Adapter couldn't be None"
+        self.adapter.write(f":SYSTem:OEMHead:FREQuency:STOP {value}", eq_addr=self.gpib)
+
+    def get_oem_multiplier(self) -> float:
+        """Read current oem multiplier from the device."""
+        assert self.adapter is not None, "Adapter couldn't be None"
+        return float(self.adapter.query(":SYST:OEMH:FREQ:MULT?", eq_addr=self.gpib))
+
+    def set_oem_multiplier(self, value: float) -> None:
+        """Set oem multiplier on the device."""
+        assert self.adapter is not None, "Adapter couldn't be None"
+        self.adapter.write(f":SYST:OEMH:FREQ:MULT {value}", eq_addr=self.gpib)
+
+
+if __name__ == "__main__":
+    dev = SignalGenerator(host="169.254.156.103", gpib=18)
+    print(dev.idn())
+    print(float(dev.adapter.query("POW?", eq_addr=dev.gpib)))

thzdaqapi/Arduino/__init__.py

@@ -0,0 +1 @@
+from .grid import GridDevice

thzdaqapi/Arduino/grid.py

@@ -0,0 +1,159 @@
+from __future__ import annotations
+
+import logging
+import sys
+from typing import Any, Protocol, TypeAlias, runtime_checkable
+
+from serial.tools.list_ports import main as list_ports
+
+from thzdaqapi.settings import ADAPTERS, HTTP, SERIAL
+from thzdaqapi.utils.exceptions import DeviceConnectionError
+from thzdaqapi.utils.functions import import_class
+
+logger = logging.getLogger(__name__)
+
+
+@runtime_checkable
+class _GridHttpAdapter(Protocol):
+    def post(self, url: str, data: dict[str, Any] | None = None) -> tuple[int, dict[str, Any]]: ...
+
+    def close(self) -> None: ...
+
+
+@runtime_checkable
+class _GridSerialAdapter(Protocol):
+    def write(self, cmd: str, **kwargs: Any) -> None: ...
+
+    def query(self, cmd: str, **kwargs: Any) -> str: ...
+
+    def close(self) -> None: ...
+
+
+GridAdapter: TypeAlias = _GridHttpAdapter | _GridSerialAdapter
+
+
+class GridDevice:
+    """Control Arduino grid rotation over HTTP or serial transport."""
+
+    DEFAULT_HOST = "169.254.0.52"
+
+    def __init__(
+        self,
+        host: str = DEFAULT_HOST,
+        adapter: str = HTTP,
+        current_angle: float = 0.0,
+        *args: Any,
+        **kwargs: Any,
+    ) -> None:
+        self.host = host
+        self.adapter_name = adapter
+        self.current_angle = float(current_angle)
+        self.finish = False
+        self.adapter: GridAdapter | None = None
+        self._set_adapter(adapter, *args, **kwargs)
+
+    def _set_adapter(self, adapter: str, *args: Any, **kwargs: Any) -> None:
+        adapter_path = ADAPTERS.get(adapter)
+        if adapter_path is None:
+            raise ValueError(f"Unsupported adapter for GridDevice: {adapter}")
+
+        adapter_class = import_class(adapter_path)
+        if adapter == SERIAL:
+            # For serial adapter `host` represents serial port path.
+            instance = adapter_class(port=self.host, *args, **kwargs)
+        else:
+            instance = adapter_class(host=self.host, *args, **kwargs)
+
+        if adapter == SERIAL and not isinstance(instance, _GridSerialAdapter):
+            raise TypeError(
+                f"Serial grid adapter `{instance.__class__.__name__}` has invalid interface"
+            )
+        if adapter == HTTP and not isinstance(instance, _GridHttpAdapter):
+            raise TypeError(
+                f"HTTP grid adapter `{instance.__class__.__name__}` has invalid interface"
+            )
+        self.adapter = instance
+
+    def rotate(
+        self, angle: float = 90, finish: bool = False, relative: bool = False
+    ) -> float | None:
+        """Rotate grid and update in-memory angle.
+
+        Args:
+            angle: Target angle (absolute by default).
+            finish: Stop flag for long-running scripts.
+            relative: Interpret `angle` as delta from current angle.
+        """
+        if self.finish:
+            return None
+
+        target_angle = self.current_angle + angle if relative else angle
+        delta = target_angle - self.current_angle
+        if abs(delta) < 1e-12:
+            return self.current_angle
+
+        if self.adapter_name == SERIAL:
+            if self.adapter is None:
+                raise RuntimeError("Grid adapter is not initialized")
+            self.adapter.write(str(target_angle))
+            self.current_angle = float(target_angle)
+            return self.current_angle
+
+        if self.adapter_name == HTTP:
+            if self.adapter is None:
+                raise RuntimeError("Grid adapter is not initialized")
+            status, _ = self.adapter.post(url="/rotate", data={"angle": delta})
+            if status == 200:
+                self.current_angle = float(target_angle)
+                return self.current_angle
+
+        self.finish = finish
+        return None
+
+    def rotate_relative(self, delta_angle: float) -> float | None:
+        """Rotate by a relative delta from current in-memory angle."""
+        return self.rotate(angle=delta_angle, relative=True)
+
+    def test(self) -> bool:
+        """Check communication with the grid controller."""
+        if self.adapter_name == SERIAL:
+            try:
+                if self.adapter is None:
+                    raise RuntimeError("Grid adapter is not initialized")
+                response = self.adapter.query("test", buffer_size=128).strip()
+                return response.upper() == "OK"
+            except Exception as exc:
+                logger.error("[%s.test] %s", self.__class__.__name__, exc)
+                raise DeviceConnectionError(str(exc)) from exc
+
+        if self.adapter_name == HTTP:
+            try:
+                if self.adapter is None:
+                    raise RuntimeError("Grid adapter is not initialized")
+                status, _ = self.adapter.post(url="/test", data={})
+                return status == 200
+            except Exception as exc:
+                logger.error("[%s.test] %s", self.__class__.__name__, exc)
+                raise DeviceConnectionError(str(exc)) from exc
+
+        raise ValueError(f"Unsupported adapter: {self.adapter_name}")
+
+    @staticmethod
+    def scan_ports() -> None:
+        list_ports()
+
+    def close(self) -> None:
+        if self.adapter is not None and hasattr(self.adapter, "close"):
+            self.adapter.close()
+
+    def __del__(self) -> None:  # pragma: no cover - best effort
+        try:
+            self.close()
+        except Exception:
+            pass
+
+
+if __name__ == "__main__":
+    angle = float(sys.argv[1])
+    ard = GridDevice()
+    ard.rotate(angle, relative=True)

thzdaqapi/Arduino/step_motor/grid_1/grid_1.ino

@@ -0,0 +1,164 @@
+#include <SPI.h>
+#include <Ethernet2.h>
+#include <ArduinoJson.h>
+
+const int dirPin = 1;
+const int stepPin = 2;
+const int resetPin = 3;
+const int sleepPin = 4;
+const int ms1Pin = 5;
+const int ms2Pin = 6;
+const int ms3Pin = 7;
+
+const int stepsPerRevolution = 16000;
+const int stepDelay = 350;
+
+byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
+IPAddress ip(169, 254, 0, 52);
+EthernetServer server(80);
+
+// Helpers
+void urlHandler(String request, EthernetClient client) {
+  Serial.print("Recieved request: " + String(request));
+  if (request.indexOf("POST /rotate") != -1) {
+    Serial.println("Calling stepperRotateView");
+    stepperRotateView(request, client);
+  }
+  if (request.indexOf("POST /test") != -1) {
+    Serial.println("Calling testStepperRotateView");
+    testStepperRotateView(request, client);
+  }
+}
+
+int getContentLength(String bodyFull) {
+  int contentLength = 0;
+  int contentLengthIndex = bodyFull.indexOf("Content-Length:");
+  if (contentLengthIndex != -1) {
+    contentLengthIndex += 16;
+    String contentLengthStr = bodyFull.substring(contentLengthIndex);
+    contentLength = contentLengthStr.toInt();
+  }
+  Serial.println("Request Length: " + String(contentLength));
+  return contentLength;
+}
+
+void sendResponse(EthernetClient client, String response) {
+  client.println("HTTP/1.1 200 OK");
+  client.println("Content-Type: application/json");
+  client.println("Connection: close");
+  client.print("Content-Length: ");
+  client.println(response.length());
+  client.println();
+  client.println(response);
+}
+
+// Serialization
+float serializeRequest(String request, EthernetClient client) {
+  String bodyFull = client.readString();
+  int contentLength = getContentLength(bodyFull);
+  int bodyFullLength = bodyFull.length();
+  String body = bodyFull.substring(bodyFullLength - contentLength, bodyFullLength);
+  body.replace("\n", "");
+  body.replace("\r", "");
+  body.replace(" ", "");
+  Serial.println("Body: " + body);
+  int ind1 = body.indexOf(":") + 1;
+  int ind2 = body.length() - 1;
+  float angle = body.substring(ind1, ind2).toFloat();
+  Serial.println("Angle: " + String(angle));
+  client.flush();
+  return angle;
+}
+
+String serializeResponse() {
+  DynamicJsonDocument responseDoc(1024);
+  responseDoc["status"] = "OK";
+  String response;
+  serializeJson(responseDoc, response);
+  return response;
+}
+
+void processResponse(EthernetClient client) {
+  String response = serializeResponse();
+  sendResponse(client, response);
+}
+
+// Views
+void stepperRotateView(String request, EthernetClient client) {
+  float angle = serializeRequest(request, client);
+  stepperRotate(angle);
+  processResponse(client);
+}
+
+void testStepperRotateView(String request, EthernetClient client) {
+  stepperRotate(45);
+  stepperRotate(-45);
+  processResponse(client);
+}
+
+// UseCases
+void stepperRotate(float angle) {
+  int stepsRev = abs(stepsPerRevolution * angle / 360);
+  Serial.println("Steps: " + String(stepsRev));
+  if (angle >= 0) {
+    digitalWrite(dirPin, HIGH);
+  } else {
+    digitalWrite(dirPin, LOW);
+  }
+
+  for (int i = 0; i < stepsRev; i++) {
+    digitalWrite(stepPin, HIGH);
+    delayMicroseconds(stepDelay);
+    digitalWrite(stepPin, LOW);
+    delayMicroseconds(stepDelay);
+  }
+}
+
+// Set Up
+void setup() {
+  // Init serial
+  Serial.begin(9600);
+  Serial.print("Serial init OK\r\n");
+  // Set pins outs
+  pinMode(dirPin, OUTPUT);
+  pinMode(stepPin, OUTPUT);
+  pinMode(sleepPin, OUTPUT);
+  pinMode(resetPin, OUTPUT);
+  pinMode(ms1Pin, OUTPUT);
+  pinMode(ms2Pin, OUTPUT);
+  pinMode(ms3Pin, OUTPUT);
+  // Init ethernet
+  Ethernet.begin(mac, ip);
+  server.begin();
+  Serial.print("Server is at ");
+  Serial.println(Ethernet.localIP());
+  // Enable driver motor
+  digitalWrite(resetPin, HIGH);
+  digitalWrite(sleepPin, HIGH);
+  digitalWrite(ms1Pin, HIGH);
+  digitalWrite(ms2Pin, HIGH);
+  digitalWrite(ms3Pin, HIGH);
+  Serial.println("Motor enabled");
+}
+
+// Main Loop
+void loop() {
+  EthernetClient client = server.available();
+  if (client) {
+    Serial.println("New client");
+    String request = "";
+    while (client.connected()) {
+      if (client.available()) {
+        char c = client.read();
+        request += c;
+        if (c == '\n') {
+          break;
+        }
+      }
+    }
+    urlHandler(request, client);
+    delay(0.1);
+    client.stop();
+    Serial.println("Client disconnected");
+  }
+}

thzdaqapi/Arduino/step_motor/grid_2/grid_2.ino

@@ -0,0 +1,170 @@
+#include <SPI.h>
+#include <Ethernet2.h>
+#include <ArduinoJson.h>
+
+const int dirPin = 2;
+const int stepPin = 3;
+const int sleepPin = 4;
+const int resetPin = 5;
+const int ms3Pin = 6;
+const int ms2Pin = 7;
+const int ms1Pin = 8;
+const int enablePin = 9;
+
+const int stepsPerRevolution = 16000;
+const int stepDelay = 350;
+
+byte mac[] = { 0x00, 0xAA, 0xBB, 0xCC, 0xDE, 0x02 };
+IPAddress ip(169, 254, 0, 53);
+EthernetServer server(80);
+
+// Helpers
+void urlHandler(String request, EthernetClient client) {
+  Serial.print("Recieved request: " + String(request));
+  if (request.indexOf("POST /rotate") != -1) {
+    Serial.println("Calling stepperRotateView");
+    stepperRotateView(request, client);
+  }
+  if (request.indexOf("POST /test") != -1) {
+    Serial.println("Calling testStepperRotateView");
+    testStepperRotateView(request, client);
+  }
+}
+
+int getContentLength(String bodyFull) {
+  int contentLength = 0;
+  int contentLengthIndex = bodyFull.indexOf("Content-Length:");
+  if (contentLengthIndex != -1) {
+    contentLengthIndex += 16;
+    String contentLengthStr = bodyFull.substring(contentLengthIndex);
+    contentLength = contentLengthStr.toInt();
+  }
+  Serial.println("Request Length: " + String(contentLength));
+  return contentLength;
+}
+
+void sendResponse(EthernetClient client, String response) {
+  client.println("HTTP/1.1 200 OK");
+  client.println("Content-Type: application/json");
+  client.println("Connection: close");
+  client.print("Content-Length: ");
+  client.println(response.length());
+  client.println();
+  client.println(response);
+}
+
+// Serialization
+float serializeRequest(String request, EthernetClient client) {
+  String bodyFull = client.readString();
+  int contentLength = getContentLength(bodyFull);
+  int bodyFullLength = bodyFull.length();
+  String body = bodyFull.substring(bodyFullLength - contentLength, bodyFullLength);
+  body.replace("\n", "");
+  body.replace("\r", "");
+  body.replace(" ", "");
+  Serial.println("Body: " + body);
+  int ind1 = body.indexOf(":") + 1;
+  int ind2 = body.length() - 1;
+  float angle = body.substring(ind1, ind2).toFloat();
+  Serial.println("Angle: " + String(angle));
+  client.flush();
+  return angle;
+}
+
+String serializeResponse() {
+  DynamicJsonDocument responseDoc(1024);
+  responseDoc["status"] = "OK";
+  String response;
+  serializeJson(responseDoc, response);
+  return response;
+}
+
+void processResponse(EthernetClient client) {
+  String response = serializeResponse();
+  sendResponse(client, response);
+}
+
+// Views
+void stepperRotateView(String request, EthernetClient client) {
+  float angle = serializeRequest(request, client);
+  stepperRotate(angle);
+  processResponse(client);
+}
+
+void testStepperRotateView(String request, EthernetClient client) {
+  stepperRotate(45);
+  stepperRotate(-45);
+  processResponse(client);
+}
+
+// UseCases
+void stepperRotate(float angle) {
+  int stepsRev = abs(stepsPerRevolution * angle / 360);
+  Serial.println("Steps: " + String(stepsRev));
+  if (angle >= 0) {
+    digitalWrite(dirPin, HIGH);
+  } else {
+    digitalWrite(dirPin, LOW);
+  }
+
+  for (int i = 0; i < stepsRev; i++) {
+    digitalWrite(stepPin, HIGH);
+    delayMicroseconds(stepDelay);
+    digitalWrite(stepPin, LOW);
+    delayMicroseconds(stepDelay);
+  }
+}
+
+// Set Up
+void setup() {
+  // Init serial
+  Serial.begin(9600);
+  Serial.print("Serial init OK\r\n");
+  // Set pins outs
+  pinMode(dirPin, OUTPUT);
+  pinMode(stepPin, OUTPUT);
+  pinMode(sleepPin, OUTPUT);
+  pinMode(resetPin, OUTPUT);
+  pinMode(ms1Pin, OUTPUT);
+  pinMode(ms2Pin, OUTPUT);
+  pinMode(ms3Pin, OUTPUT);
+  pinMode(enablePin, OUTPUT);
+  // pinMode(resetPin, OUTPUT);
+  // pinMode(sleepPin, OUTPUT);
+  // Init default pins values
+  // Init ethernet
+  Ethernet.begin(mac, ip);
+  server.begin();
+  Serial.print("Server is at ");
+  Serial.println(Ethernet.localIP());
+  // Enable driver motor
+  digitalWrite(enablePin, LOW);
+  digitalWrite(resetPin, HIGH);
+  digitalWrite(sleepPin, HIGH);
+  digitalWrite(ms1Pin, HIGH);
+  digitalWrite(ms2Pin, HIGH);
+  digitalWrite(ms3Pin, HIGH);
+  Serial.println("Motor enabled");
+}
+
+// Main Loop
+void loop() {
+  EthernetClient client = server.available();
+  if (client) {
+    Serial.println("New client");
+    String request = "";
+    while (client.connected()) {
+      if (client.available()) {
+        char c = client.read();
+        request += c;
+        if (c == '\n') {
+          break;
+        }
+      }
+    }
+    urlHandler(request, client);
+    delay(0.1);
+    client.stop();
+    Serial.println("Client disconnected");
+  }
+}