ents 2.3.2__py3-none-any.whl

ents/__init__.py

@@ -0,0 +1,23 @@
+from .proto.encode import (
+    encode_response,
+    encode_power_measurement,
+    encode_teros12_measurement,
+    encode_phytos31_measurement,
+    encode_bme280_measurement,
+)
+
+from .proto.decode import decode_response, decode_measurement
+
+from .proto.esp32 import encode_esp32command, decode_esp32command
+
+__all__ = [
+    "encode_response",
+    "encode_power_measurement",
+    "encode_teros12_measurement",
+    "encode_phytos31_measurement",
+    "encode_bme280_measurement",
+    "decode_response",
+    "decode_measurement",
+    "encode_esp32command",
+    "decode_esp32command",
+]

ents/calibrate/PingSMU.py

@@ -0,0 +1,51 @@
+"""To test connection via socket to Kiethley 2450
+
+Stephen Taylor, 5/20/2024
+"""
+
+import socket
+
+
+def ping_smu(host, port):
+    try:
+        # Create a TCP/IP socket
+        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+
+        # Set a timeout for the connection attempt
+        sock.settimeout(1)
+
+        # Connect to the SMU
+        sock.connect((host, port))
+
+        # Send the *IDN? command
+        sock.sendall(b"*RST\n")
+        sock.sendall(b"*IDN?\n")
+
+        # Receive the response
+        response = sock.recv(1024)
+        response = response.strip()
+        print("Response from SMU:", response)
+
+        # Close the socket
+        sock.close()
+
+        # Return True if connection successful
+        return True
+    except Exception as e:
+        # Connection failed
+        print(f"Error: {e}")
+        return False
+
+
+if __name__ == "__main__":
+    # Specify the IP address or hostname of the SMU and its port
+    smu_host = (
+        "128.114.204.56"  # Replace with the actual IP address or hostname of the SMU
+    )
+    smu_port = 23  # Replace with the actual port used by the SMU
+
+    # Ping the SMU
+    if ping_smu(smu_host, smu_port):
+        print("SMU is reachable.")
+    else:
+        print("Failed to ping SMU.")

ents/calibrate/PingSPS.py

@@ -0,0 +1,66 @@
+"""To test connection to Soil Power Sensor over serial
+
+Stephen Taylor 5/20/2024
+"""
+
+import serial
+
+
+class SerialPing:
+    """Simple serial ping utility"""
+
+    def __init__(self, port, baudrate=115200, xonxoff=True):
+        """Constructor
+
+        Initializes serial connection.
+
+        Parameters
+        ----------
+        port : str
+            Serial port name (e.g., COM1, /dev/ttyUSB0)
+        baudrate : int, optional
+            Baud rate for serial communication (default is 115200, STM32 functions at 115200)
+        xonxoff  : bool, optional
+            Flow control (default is on)
+        """
+        self.ser = serial.Serial(port, baudrate=baudrate, xonxoff=xonxoff, timeout=1)
+        # Print serial port settings
+        print("Serial Port Settings:")
+        print("Port:", self.ser.port)
+        print("Baudrate:", self.ser.baudrate)
+        print("Byte size:", self.ser.bytesize)
+        print("Parity:", self.ser.parity)
+        print("Stop bits:", self.ser.stopbits)
+        print("Timeout:", self.ser.timeout)
+        print("Xon/Xoff:", self.ser.xonxoff)
+        print("Rts/cts:", self.ser.rtscts)
+        print("Dsr/dtr:", self.ser.dsrdtr)
+
+    def ping(self):
+        """Ping the device and return the response"""
+        # pdb.set_trace()
+        self.ser.write(b"check\n")  # Send ping command
+        response = self.ser.readline()  # Read response
+        return response
+
+    def close(self):
+        """Close serial connection"""
+        self.ser.close()
+
+
+# Example usage
+if __name__ == "__main__":
+    # Replace 'COM1' with the appropriate serial port on your system
+    port = "COM14"
+
+    # Create SerialPing object
+    serial_ping = SerialPing(port)
+
+    try:
+        # Ping the device
+        response = serial_ping.ping()
+        print("Response:", response)
+
+    finally:
+        # Close serial connection
+        serial_ping.close()

ents/calibrate/README.md

@@ -0,0 +1,3 @@
+# Performing calibration
+
+TODO: Write these instructions after merging the calibration and python resources.

ents/calibrate/linear_regression.py

@@ -0,0 +1,78 @@
+import numpy as np
+from sklearn import linear_model
+from sklearn.metrics import (
+    mean_absolute_error,
+    mean_squared_error,
+    r2_score,
+    mean_absolute_percentage_error,
+)
+from scipy.stats import norm
+
+
+def linear_regression(meas: list, actual: list):
+    """Performs linear regression between measured and actual values
+
+    Args:
+        meas: Measure values
+        actual: Ground truth values
+
+    Returns:
+        Linear regression model
+    """
+
+    model = linear_model.LinearRegression()
+    model.fit(meas, actual)
+
+    return model
+
+
+def print_eval(pred: list, actual: list):
+    """Prints various evaluation parameters of the model
+
+    The following metrics are used:
+        - Mean absolute error
+        - Root mean square error
+        - R2 score
+        - Mean absolute percentage error
+
+    Args:
+        pred: Predicted values
+        actual: Actual values
+    """
+    mae = mean_absolute_error(actual, pred)
+    print(f"Mean absolute error: {mae:.4f}")
+
+    rmse = np.sqrt(mean_squared_error(actual, pred))
+    print(f"Root mean square error: {rmse:.4f}")
+
+    r2 = r2_score(actual, pred)
+    print(f"R-squared: {r2:.4f}")
+
+    mape = mean_absolute_percentage_error(actual, pred)
+    print(f"Mean absolute percentage error: {mape:.4f}")
+
+
+def print_coef(model):
+    """Print coefficients of a model
+
+    Args:
+        model: Linear model
+    """
+
+    slope = model.coef_
+    inter = model.intercept_
+
+    print(f"Slope: {slope}")
+    print(f"Intercept: {inter}")
+
+
+def print_norm(residuals: list):
+    """Print mean offset and standard deviation
+
+    Args:
+        residuals: List of residuals
+    """
+
+    mu, std = norm.fit(residuals)
+    print(f"mu = {mu}")
+    print(f"std = {std}")

ents/calibrate/plots.py

@@ -0,0 +1,83 @@
+import matplotlib.pyplot as plt
+from scipy.stats import norm
+import numpy as np
+
+
+def plot_measurements(actual: list, meas: list, title: str = "", block: bool = False):
+    """Plot actual values vs measured values
+
+    Args:
+        actual: Actual values
+        meas: Measured values
+        title: Suffix of plot title
+        block: Wait for plot to close
+    """
+
+    fig, ax = plt.subplots()
+    ax.scatter(actual, meas, s=3)
+    ax.set_xlabel("Actual")
+    ax.set_ylabel("Measured")
+    ax.set_title(f"Measurements: {title}")
+    plt.show(block=block)
+
+
+def plot_calib(raw: list, pred: list, title: str = "", block: bool = False):
+    """Plot linear relationship between raw measured and calibrated measured
+
+    Args:
+        raw: Uncalibrated measurements
+        pred: Predicted voltages
+        title: Suffix of plot title
+        block: Wait for plot to close
+    """
+
+    fig, ax = plt.subplots()
+    ax.scatter(raw, pred, s=3)
+    ax.set_xlabel("Raw measurements")
+    ax.set_ylabel("Predicted measurements")
+    ax.set_title(f"Calibration: {title}")
+    plt.show(block=block)
+
+
+def plot_residuals(pred: list, residuals: list, title: str = "", block: bool = False):
+    """Plot residuals vs predicted measurements
+
+    Residuals is the difference between predicted values and actual values.
+
+    Args:
+        pred: Predicted measurements
+        residuals: List of residuals
+        title: Suffix of plot title
+        block: Wait for plot to close
+    """
+
+    fig, ax = plt.subplots()
+    ax.scatter(pred, residuals)
+    ax.axhline(y=0, color="r", linestyle="--")
+    ax.set_xlabel("Predicted measurement")
+    ax.set_ylabel("Residuals (pred - actual)")
+    ax.set_title(f"Residuals: {title}")
+    ax.legend()
+    plt.show(block=block)
+
+
+def plot_residuals_hist(residuals: list, title: str = "", block: bool = False):
+    """Plot a histogram of residual error
+
+    Args:
+        residuals: Residuals
+        title: Suffix of plot title
+        block: Wait for plot to close
+    """
+
+    mu, std = norm.fit(residuals)
+    normdist_x = np.linspace(mu - 3 * std, mu + 3 * std, 100)
+    normdist_y = norm.pdf(normdist_x, mu, std)
+
+    fig, ax = plt.subplots()
+    ax.hist(residuals, bins=30, edgecolor="black")
+    ax.plot(normdist_x, normdist_y, color="r")
+    ax.set_xlabel("Residuals")
+    ax.set_ylabel("Frequency")
+    ax.set_title(f"Histogram of Residuals: {title}")
+    plt.show(block=block)