From 33fbfbdc002993add8a1fa04ff09af73494ab67f Mon Sep 17 00:00:00 2001 From: Ludo-lab Date: Wed, 17 Jun 2026 14:29:12 +0200 Subject: [PATCH 01/37] first commit --- .gitignore | 5 + .vscode/extensions.json | 10 + 260605_amBIT_DEMO.ipynb | 508 +++++++++ HW_CONFORMANCE.md | 164 +++ MERGE_PLAN.md | 615 +++++++++++ include/README | 37 + lib/README | 46 + lib/openjii_proto/openjii_proto.cpp | 292 +++++ lib/openjii_proto/openjii_proto.h | 53 + platformio.ini | 45 + src/.gitignore | 2 + src/PAM.cpp | 1534 +++++++++++++++++++++++++++ src/PAM.h | 70 ++ src/ambit-1.ino | 205 ++++ src/config.h | 16 + src/core.cpp | 43 + src/core.h | 42 + src/data_utils.cpp | 497 +++++++++ src/data_utils.h | 83 ++ src/do_command.h | 434 ++++++++ src/frontend_cloud.cpp | 157 +++ src/nvs1.cpp | 117 ++ src/nvs1.h | 65 ++ src/run_esp.cpp | 489 +++++++++ src/self_test.cpp | 169 +++ src/serial.cpp | 116 ++ src/serial.h | 7 + src/src/adpd/ADPD_platform_ops.cpp | 82 ++ src/src/adpd/u_adpd6100.cpp | 1281 ++++++++++++++++++++++ src/src/adpd/u_adpd6100.h | 97 ++ src/src/adpd/u_adpd6100_typedef.h | 610 +++++++++++ src/src/as7341/Adafruit_AS7341.cpp | 1014 ++++++++++++++++++ src/src/as7341/Adafruit_AS7341.h | 354 +++++++ src/src/as7341/README.md | 50 + src/src/as7341/code-of-conduct.md | 127 +++ src/src/as7341/library.properties | 10 + src/src/as7341/license.txt | 26 + src/src/as7341/spec_meas.cpp | 278 +++++ src/src/as7341/spec_meas.h | 43 + src/src/devices_init.cpp | 104 ++ src/src/devices_init.h | 26 + src/src/mlx90632/mlx_dev.cpp | 729 +++++++++++++ src/src/mlx90632/mlx_dev.h | 466 ++++++++ src/src/mlx90632/u_mlx.cpp | 251 +++++ src/src/mlx90632/u_mlx.h | 30 + src/src/pin_config.h | 18 + src/upload.bat | 1 + src/uploader.py | 101 ++ test/README | 11 + 49 files changed, 11530 insertions(+) create mode 100644 .gitignore create mode 100644 .vscode/extensions.json create mode 100644 260605_amBIT_DEMO.ipynb create mode 100644 HW_CONFORMANCE.md create mode 100644 MERGE_PLAN.md create mode 100644 include/README create mode 100644 lib/README create mode 100644 lib/openjii_proto/openjii_proto.cpp create mode 100644 lib/openjii_proto/openjii_proto.h create mode 100644 platformio.ini create mode 100644 src/.gitignore create mode 100644 src/PAM.cpp create mode 100644 src/PAM.h create mode 100644 src/ambit-1.ino create mode 100644 src/config.h create mode 100644 src/core.cpp create mode 100644 src/core.h create mode 100644 src/data_utils.cpp create mode 100644 src/data_utils.h create mode 100644 src/do_command.h create mode 100644 src/frontend_cloud.cpp create mode 100644 src/nvs1.cpp create mode 100644 src/nvs1.h create mode 100644 src/run_esp.cpp create mode 100644 src/self_test.cpp create mode 100644 src/serial.cpp create mode 100644 src/serial.h create mode 100644 src/src/adpd/ADPD_platform_ops.cpp create mode 100644 src/src/adpd/u_adpd6100.cpp create mode 100644 src/src/adpd/u_adpd6100.h create mode 100644 src/src/adpd/u_adpd6100_typedef.h create mode 100644 src/src/as7341/Adafruit_AS7341.cpp create mode 100644 src/src/as7341/Adafruit_AS7341.h create mode 100644 src/src/as7341/README.md create mode 100644 src/src/as7341/code-of-conduct.md create mode 100644 src/src/as7341/library.properties create mode 100644 src/src/as7341/license.txt create mode 100644 src/src/as7341/spec_meas.cpp create mode 100644 src/src/as7341/spec_meas.h create mode 100644 src/src/devices_init.cpp create mode 100644 src/src/devices_init.h create mode 100644 src/src/mlx90632/mlx_dev.cpp create mode 100644 src/src/mlx90632/mlx_dev.h create mode 100644 src/src/mlx90632/u_mlx.cpp create mode 100644 src/src/mlx90632/u_mlx.h create mode 100644 src/src/pin_config.h create mode 100644 src/upload.bat create mode 100644 src/uploader.py create mode 100644 test/README diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..89cc49c --- /dev/null +++ b/.gitignore @@ -0,0 +1,5 @@ +.pio +.vscode/.browse.c_cpp.db* +.vscode/c_cpp_properties.json +.vscode/launch.json +.vscode/ipch diff --git a/.vscode/extensions.json b/.vscode/extensions.json new file mode 100644 index 0000000..080e70d --- /dev/null +++ b/.vscode/extensions.json @@ -0,0 +1,10 @@ +{ + // See http://go.microsoft.com/fwlink/?LinkId=827846 + // for the documentation about the extensions.json format + "recommendations": [ + "platformio.platformio-ide" + ], + "unwantedRecommendations": [ + "ms-vscode.cpptools-extension-pack" + ] +} diff --git a/260605_amBIT_DEMO.ipynb b/260605_amBIT_DEMO.ipynb new file mode 100644 index 0000000..140b979 --- /dev/null +++ b/260605_amBIT_DEMO.ipynb @@ -0,0 +1,508 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "import serial\n", + "import time\n", + "import matplotlib.pyplot as plt\n", + "from IPython import display\n", + "from datetime import datetime\n", + "import os \n", + "import re\n", + "import serial.tools.list_ports\n", + "\n", + "\n", + "plt.style.use(\"dark_background\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Function to find the connected devices on available serial ports\n", + "def findDevice(question=\"hello\", answer=\"Ready\", flush=True, timeout=3):\n", + " \"\"\"\n", + " Find the amBIT on an available serial port by sending `question` and looking\n", + " for `answer` in the reply. Returns the port name (str), or None if not found.\n", + " \"\"\"\n", + " if not question.endswith(\"\\n\"):\n", + " question += \"\\n\" # firmware is line-based\n", + " for p in serial.tools.list_ports.comports(): # only real ports, not COM1..COM256\n", + " port = p.device\n", + " try:\n", + " with serial.Serial(port, baudrate=115200, timeout=timeout) as ser:\n", + " ser.setRTS(False) # keep the ESP out of bootloader mode\n", + " ser.flush()\n", + " time.sleep(0.7) # let the device finish (re)booting\n", + " if flush:\n", + " ser.reset_input_buffer() # drop the boot-log / stale bytes\n", + " ser.write(question.encode())\n", + " time.sleep(0.5)\n", + "\n", + " reply = \"\"\n", + " t0 = time.monotonic()\n", + " while time.monotonic() - t0 < timeout:\n", + " line = ser.readline().decode(\"utf-8\", errors=\"replace\").strip()\n", + " if not line:\n", + " break\n", + " reply += line + \"\\n\"\n", + " if answer and answer in line:\n", + " break\n", + "\n", + " print(f\"[{port}] {p.description}: {reply.strip()!r}\")\n", + " if answer and answer in reply:\n", + " print(f\"Found device at: {port}\")\n", + " return port\n", + " except (OSError, serial.SerialException):\n", + " pass\n", + " print(\"No matching device found.\")\n", + " return None\n", + "\n", + " \n", + "def ensure_path_exists(path: str) -> None:\n", + " \"\"\"\n", + " Ensures that the given directory path exists.\n", + " If it does not exist, this function will create it (including any intermediate directories).\n", + "\n", + " :param path: The directory path to check (and potentially create).\n", + " \"\"\"\n", + " if not os.path.exists(path):\n", + " print(f\"Creating path: {path}\")\n", + " os.makedirs(path)\n", + " else:\n", + " print(f\"{path} exist\")\n", + "\n", + "def gen_cmd_arr_line(num: int, freq: int, actinic: int) -> list:\n", + " \"\"\"\n", + " Generate a single command-array entry of 8 parameters.\n", + " \n", + " :param num: Total number of measurement points (1-2000).\n", + " :param freq: Frequency measurement points (1-200).\n", + " :param actinic: Actinic light setting (0-255).\n", + " :return: List of 8 integer values representing the command.\n", + " \"\"\"\n", + " return [\n", + " 2, # Fixed flag or identifier\n", + " 0, # Another fixed flag or placeholder\n", + " num // 256, # High byte of 'num'\n", + " num % 256, # Low byte of 'num'\n", + " freq // 256, # High byte of 'freq'\n", + " freq % 256, # Low byte of 'freq'\n", + " actinic, # Actinic light parameter\n", + " 1 # Fixed flag or terminator\n", + " ]\n", + "\n", + "def calc_arr_param(cmd: list, persist: bool = False):\n", + " \"\"\"\n", + " Reshape a flat command list into a 2D array, construct a command string,\n", + " and calculate measurement timelines and actinic-array values.\n", + "\n", + " :param cmd: A 1D list of length 8*N (multiple commands concatenated).\n", + " :param persist: A flag indicating whether the command persists after completion.\n", + " :return: Tuple (cmd_str, mea_tml, mea_act)\n", + " - cmd_str: Formatted command string (e.g., for sending over serial).\n", + " - mea_tml: NumPy array of timestamps (scaled by 0.854).\n", + " - mea_act: List of actinic values (one per timestamp).\n", + " \"\"\"\n", + " # Reshape 'cmd' into an N x 8 array\n", + " cmd_arr = np.reshape(cmd, (-1, 8))\n", + " arr_length = cmd_arr.shape[0]\n", + "\n", + " # Create a comma-separated command string:\n", + " # e.g., \"arrun1,N,persist,,\\n\"\n", + " cmd_str = f\"arrun1,{arr_length},{persist},{str(cmd)[1:-1]},\\n\"\n", + " cmd_str = cmd_str.replace(\" \", \"\") # Remove spaces for a cleaner command\n", + "\n", + " # Parse the reshaped array into usable parameters\n", + " num_pts = cmd_arr[:, 2] * 256 + cmd_arr[:, 3] # Number of points (high/low bytes)\n", + " act_arr = cmd_arr[:, 6] # Actinic setting\n", + " mea_feq = 1 / (cmd_arr[:, 4] * 256 + cmd_arr[:, 5]) # Measurement frequency (1 / freq)\n", + "\n", + " # Build up the measurement timeline and actinic values\n", + " _t = 0\n", + " mea_tml = []\n", + " mea_act = []\n", + "\n", + " # For each command segment, create a timeline and corresponding actinic values\n", + " for _n, _f, _a in zip(num_pts, mea_feq, act_arr):\n", + " segment_times = (np.arange(_n) * _f) + _t\n", + " mea_tml.extend(segment_times) # Accumulate times\n", + " mea_act.extend([_a] * _n) # Repeat actinic value _n times\n", + " _t = segment_times[-1] # Update the offset for the next segment\n", + "\n", + " # Scale the entire timeline by 0.854\n", + " mea_tml = np.array(mea_tml) * 0.854\n", + "\n", + " return cmd_str, mea_tml, mea_act\n", + "\n", + "def send_read_command(port, string, required_string=None, baudrate=115200, timeout=10):\n", + " \"\"\"\n", + " Opens the serial port, sends a “hello” and then your command, and collects replies.\n", + " Stops reading when either:\n", + " • no more data arrives (an empty readline, i.e. per-read timeout fired), or\n", + " • we see `required_string` in the response, if given, or\n", + " • the overall `timeout` has elapsed.\n", + " Returns the list of lines read so far.\n", + " \"\"\"\n", + " lines = []\n", + " start = time.monotonic()\n", + " with serial.Serial(port, baudrate=baudrate, timeout=timeout) as ser:\n", + " # hand-shake / mode set\n", + " ser.setRTS(False)\n", + " ser.flush()\n", + " time.sleep(0.7)\n", + " ser.write(b\"hello\\n\")\n", + " time.sleep(0.5)\n", + " ser.write(f\"{string}\\n\".encode())\n", + " last_recv = time.monotonic()\n", + "\n", + " while True:\n", + " # Check idle timeout\n", + " now = time.monotonic()\n", + " if now - last_recv >= timeout:\n", + " print(f\"No (additional) responses within user-set timeout: {timeout}s\")\n", + " return lines\n", + " \n", + " try:\n", + " line = ser.readline().decode('utf-8', errors='replace').strip()\n", + " # print(line)\n", + " \n", + " last_recv = time.monotonic() # Reset idle timer since we got data\n", + " except Exception as e:\n", + " print(f\"Error reading line: {e!s}\")\n", + " break\n", + "\n", + " # if nothing arrived within per-read timeout, readline() returns b'' → line == ''\n", + " if not line:\n", + " print(f\"No (additional) responses within user-set timeout: {timeout}s\")\n", + " return lines\n", + " \n", + " lines.append(line)\n", + "\n", + " # if we were waiting for a specific marker, stop when we see it\n", + " if required_string and required_string in line:\n", + " break\n", + " return lines\n", + "\n", + "def parse_command_blocks(lines, cmd_prefix=\"cmd:\"):\n", + " \"\"\"\n", + " Parse a list of lines and group them by commands that match `cmd_prefix`.\n", + "\n", + " The function identifies lines containing commands (e.g., 'cmd: something')\n", + " and collects all subsequent lines into that command's \"block\" until the\n", + " next command (or end of list).\n", + "\n", + " :param lines: List of strings to parse.\n", + " :param cmd_prefix: The prefix that indicates a new command. Defaults to 'cmd:'.\n", + " :return: A dictionary mapping { command_name: [list_of_lines_until_next_command] }\n", + " If the same command appears multiple times, each occurrence will\n", + " overwrite previous data unless modified to handle duplicates.\n", + " \"\"\"\n", + " command_dict = {}\n", + " current_cmd = None\n", + " current_data = []\n", + "\n", + " for line in lines:\n", + " # Try to find a line that includes 'cmd:' (possibly with extra characters).\n", + " # The regex captures whatever follows 'cmd:' up to the first whitespace \n", + " # or end of string. E.g., 'cmd: hello' => group(1) = 'hello'.\n", + " match = re.search(r'cmd:\\s*([^\\s]+)', line)\n", + "\n", + " if match:\n", + " # If we have a \"current_cmd\", store its accumulated data first\n", + " if current_cmd is not None:\n", + " command_dict[current_cmd] = current_data\n", + "\n", + " # Extract the new command from the current line\n", + " current_cmd = match.group(1)\n", + " current_data = [] # Start a fresh list for data following this command\n", + " else:\n", + " # If this line does not declare a new command, and we've already seen a command,\n", + " # then add the line to the current command's block\n", + " if current_cmd is not None:\n", + " current_data.append(line)\n", + "\n", + " # At the end, if there is a command in progress, save its data\n", + " if current_cmd is not None:\n", + " command_dict[current_cmd] = current_data\n", + "\n", + " return command_dict\n", + "\n", + "\n", + "def parse_serial(lines):\n", + " \"\"\"\n", + " Efficiently parses a list of strings and returns a dictionary of lists for T, F, S, R, Sun, L.\n", + " Skips lines that do not match the expected format.\n", + " \"\"\"\n", + " import re\n", + " pattern = re.compile(r\"T:([\\d\\.]+),F:([\\d\\.]+),S:(\\d+),R:(\\d+),Sun:(\\d+),L:(\\d+)\")\n", + " result = {'T': [], 'F': [], 'S': [], 'R': [], 'Sun': [], 'L': []}\n", + " for line in lines:\n", + " m = pattern.search(line)\n", + " if m:\n", + " result['T'].append(float(m.group(1)))\n", + " result['F'].append(float(m.group(2)))\n", + " result['S'].append(int(m.group(3)))\n", + " result['R'].append(int(m.group(4)))\n", + " result['Sun'].append(int(m.group(5)))\n", + " result['L'].append(int(m.group(6)))\n", + " return result\n", + "\n", + "\n", + "def append_timeseries(base_series, *additional_series, additionalnumber=1):\n", + " \"\"\"\n", + " Appends one or more additional time series to an existing base series,\n", + " inserting a fixed gap (additionalnumber) between each appended series.\n", + "\n", + " :param base_series: List of time values (the initial series).\n", + " :param additional_series: One or more lists of time values to append.\n", + " :param additionalnumber: Gap to insert between each series (default 0).\n", + " :return: A new merged list with all timeseries concatenated and offset, including gaps.\n", + " \"\"\"\n", + " merged = list(base_series)\n", + " offset = merged[-1] if merged else 0\n", + " for s in additional_series:\n", + " if len(s) == 0:\n", + " continue\n", + " # Always add the gap before appending a new series (except before the first)\n", + " offset += additionalnumber\n", + " adjusted = [t + offset for t in s]\n", + " merged.extend(adjusted)\n", + " offset = adjusted[-1]\n", + " return merged\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "PORT = findDevice(question=\"hello\", answer=\"Ready\") #<----automatic find ambit\n", + "# PORT = \"COM5\" #<--- manual port selection (overrides the auto-detect above)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "SAVE = False\n", + "mytime = datetime.now().strftime(\"%y%m%d_%H%M_%S\")\n", + "\n", + "cmdA = []\n", + "cmdA += gen_cmd_arr_line(50, 10, 0) # 50 points, 10Hz, no actinic light\n", + "cmdA += gen_cmd_arr_line(8, 10, 255) # 8 points, 10Hz, no actinic light\n", + "cmdA += gen_cmd_arr_line(50, 10, 0) # 50 points, 10Hz, no actinic light\n", + "\n", + "cmd_strA, timelineA, act_arrA = calc_arr_param(cmdA, 0)\n", + "act_arrA = calc_arr_param(cmdA, 0)\n", + "data_serial = send_read_command(PORT, cmd_strA, required_string=\"Done\")\n", + "parsed_serial = parse_serial(data_serial)\n", + "\n", + "df = pd.DataFrame(parsed_serial)\n", + "df.insert(0,\"time (sec)\",timelineA)\n", + "\n", + "\n", + "plt.plot(df[\"time (sec)\"],df[\"F\"])\n", + "plt.xlabel(\"Time (sec)\")\n", + "plt.ylabel(\"Fluo. rel. yield\")\n", + "plt.title(\"Fluorescence Intensity over pulses\")\n", + "\n", + "\n", + "if SAVE:\n", + " df.to_csv(f\"{mytime}_output.csv\",sep=\",\", index=False)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "cmdA = []\n", + "cmdA += gen_cmd_arr_line(500, 500, 255) # 400 points, 200Hz, 255 actinic light (on scale of 0-255)\n", + "\n", + "cmd_strA, timelineA, act_arrA = calc_arr_param(cmdA, 0)\n", + "data_serial = send_read_command(PORT, cmd_strA, required_string=\"Done\")\n", + "parsed_serial = parse_serial(data_serial)\n", + "\n", + "df = pd.DataFrame(parsed_serial)\n", + "df.insert(0,\"time (sec)\",timelineA)\n", + "\n", + "\n", + "plt.plot(df[\"time (sec)\"],df[\"F\"])\n", + "plt.xscale(\"log\")\n", + "plt.xlabel(\"Time (sec)\")\n", + "plt.ylabel(\"Intensity\")\n", + "plt.title(\"Fluorescence Intensity over pulses\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "def STING(PORT, POINT_LOW = 10, FREQ_LOW = 10, POINT_HIGH = 40):\n", + " cmdA = gen_cmd_arr_line(POINT_LOW, FREQ_LOW, 0)\n", + " cmdA += gen_cmd_arr_line(POINT_HIGH, 1000, 0)\n", + " cmdA += gen_cmd_arr_line(POINT_LOW, FREQ_LOW, 0)\n", + " cmdA += gen_cmd_arr_line(POINT_HIGH, 1000, 0)\n", + " cmdA += gen_cmd_arr_line(POINT_LOW, FREQ_LOW, 0)\n", + " cmdA += gen_cmd_arr_line(POINT_HIGH, 1000, 0)\n", + " cmdA += gen_cmd_arr_line(POINT_LOW, FREQ_LOW, 0)\n", + " cmdA += gen_cmd_arr_line(POINT_HIGH, 1000, 0)\n", + " cmdA += gen_cmd_arr_line(POINT_LOW, FREQ_LOW, 0)\n", + " cmd_strA, timelineA, _ = calc_arr_param(cmdA, 0)\n", + " data_serial = send_read_command(PORT, cmd_strA, required_string=\"Done\")\n", + " parsed_serial = parse_serial(data_serial)\n", + " fluo =np.array(parsed_serial[\"F\"])\n", + " sun = np.array(parsed_serial[\"S\"])\n", + " leaf = np.array(parsed_serial[\"L\"])\n", + " return fluo, sun, leaf\n", + "\n", + "\n", + "results = []\n", + "for freq_low in [10,20,40,80,160]:\n", + " # time.sleep(30)\n", + " fluo, sun, leaf = STING(PORT, FREQ_LOW=freq_low)\n", + " results.append((freq_low,fluo, sun, leaf))\n", + " plt.plot(fluo,label=f\"Frequency low: {freq_low} Hz\")\n", + " plt.legend()\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "\n", + "results = []\n", + "for freq_low in [10,20,40,80,160]:\n", + " time.sleep(10)\n", + " fluo, sun, leaf, timeline = STING(PORT, FREQ_LOW=freq_low)\n", + " results.append((freq_low,fluo, sun, leaf, timeline))\n", + " plt.plot(fluo, label=f\"Frequency low: {freq_low} Hz\")\n", + " plt.legend()\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "\n", + "results = []\n", + "for freq_low in [10,20,40,80,160]:\n", + " time.sleep(10)\n", + " fluo, sun, leaf, timeline = STING(PORT, FREQ_LOW=freq_low)\n", + " results.append((freq_low,fluo, sun, leaf, timeline))\n", + " plt.plot(timeline, fluo, label=f\"Frequency low: {freq_low} Hz\")\n", + " plt.legend()\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "cmdA = gen_cmd_arr_line(1, 120, 0)\n", + "# cmdA += gen_cmd_arr_line(10, 100, 0)\n", + "cmd_strA, timelineA, _ = calc_arr_param(cmdA, 0)\n", + "data_serial = send_read_command(PORT, cmd_strA, required_string=\"Done\")\n", + "data_serial" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "def STING(PORT, POINT_LOW = 10, FREQ_LOW = 10, POINT_HIGH = 40):\n", + " cmdA = gen_cmd_arr_line(POINT_LOW, FREQ_LOW, 0)\n", + " cmdA += gen_cmd_arr_line(POINT_HIGH, 1000, 0)\n", + " cmdA += gen_cmd_arr_line(POINT_LOW, FREQ_LOW, 0)\n", + " cmdA += gen_cmd_arr_line(POINT_HIGH, 1000, 0)\n", + " cmdA += gen_cmd_arr_line(POINT_LOW, FREQ_LOW, 0)\n", + " cmdA += gen_cmd_arr_line(POINT_HIGH, 1000, 0)\n", + " cmdA += gen_cmd_arr_line(POINT_LOW, FREQ_LOW, 0)\n", + " cmdA += gen_cmd_arr_line(POINT_HIGH, 1000, 0)\n", + " cmdA += gen_cmd_arr_line(POINT_LOW, FREQ_LOW, 0)\n", + " cmd_strA, timelineA, _ = calc_arr_param(cmdA, 0)\n", + " data_serial = send_read_command(PORT, cmd_strA, required_string=\"Done\")\n", + " parsed_serial = parse_serial(data_serial)\n", + " fluo =np.array(parsed_serial[\"F\"])\n", + " sun = np.array(parsed_serial[\"S\"])\n", + " leaf = np.array(parsed_serial[\"L\"])\n", + " return fluo, sun, leaf\n", + "\n", + "results = []\n", + "for freq_low in [10,20,40,80,160]:\n", + " time.sleep(10)\n", + " fluo, sun, leaf, timeline = STING(PORT, FREQ_LOW=freq_low)\n", + " results.append((freq_low,fluo, sun, leaf, timeline))\n", + " plt.plot(timeline, fluo, label=f\"Frequency low: {freq_low} Hz\")\n", + " plt.legend()\n", + "\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.13.5" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/HW_CONFORMANCE.md b/HW_CONFORMANCE.md new file mode 100644 index 0000000..6496395 --- /dev/null +++ b/HW_CONFORMANCE.md @@ -0,0 +1,164 @@ +# amBIT HW Conformance Test — Step 4b (binary frontend → core) + +**Status: PASSED 2026-06-05.** Step 4b's binary path is HW-verified byte-conformant +against a real ambyte; the dirty-mark change (§4) was accepted. Keep this procedure as the +**reusable conformance gate** for any future change touching `run_esp.cpp` or the +`data_utils.cpp` FSM (Step 5 onward) — re-run it after each such change. + +It is the verification gate for the binary/ambyte wire contract (MERGE_PLAN §2, §13). + +--- + +## 0. What Step 4b changed (what's at risk) + +`run_esp.cpp` cmd `1/2/10/20/21` now call shared `core_*` functions instead of inline +logic. The intent is **zero change on the wire**: + +- Every `Serial.write(ESP_CMD_DONE/END)` and `Serial.readBytes(...)` is byte-for-byte + unchanged; only the internal config/run calls were factored out. +- Wire normalization still lives in the adapter: gains 1-indexed (1..6, stored −1), + current byte `≥127` = "no change", MPF length base-128 (`cmd[1]<<7 | cmd[2]`). + +**One intentional internal change** (not a wire change): binary `set_gains`/`set_currents` +(cmd 1/2) now mark the config *dirty* (they didn't before). Consequences: +- Normal flow `cmd1 → cmd2 → cmd10 → cmd21`: **identical** (cmd 10 re-applies config + regardless of the dirty flag). +- Degenerate flow `set gains/currents → cmd21 without cmd10`: now correctly re-applies + the just-set values (previously could run with stale config). This is the only + observable behavioural delta, and it is a fix — confirm no ambyte workflow relied on + the old stale-config behaviour. + +--- + +## 1. Setup + +- **DUT:** an amBIT flashed with the current `fw_new` (post-Step-4b): + ``` + cd fw_new + "$HOME/.platformio/penv/Scripts/pio.exe" run -t upload # add -t upload to flash + ``` +- **Host (one of):** + - **A real ambyte** (preferred) on the FFC/UART0 link, driving the amBIT via its + `device.ambit_*` Lua commands / CLI (`ambit_*`). This exercises the genuine binary + protocol end-to-end. + - **A logic analyzer / UART sniffer** on the FFC TX & RX (115200 8N1) to capture raw + bytes for the strict byte-diff (Test A). Best combined with the ambyte. +- **Reference build (for the strict diff):** a pre-Step-4 amBIT image — e.g. `git stash` + the working tree, or check out the commit before `core.{h,cpp}` was added, build, and + keep `firmware.bin` aside as `firmware_preStep4.bin`. + +--- + +## 2. Test A — byte-level framing conformance (gold standard) + +Goal: the **protocol framing** is identical pre- vs post-Step-4b. (Measurement *payload* +values vary run-to-run with sensor noise — only the framing/lengths/checksum validity are +deterministic; do not expect data bytes to match.) + +1. Flash `firmware_preStep4.bin`. With the sniffer capturing, drive the standard sequence + from the ambyte (see §3 for the sequence). Save the trace as `pre.bin`. +2. Flash the post-Step-4b image. Repeat the **identical** host sequence. Save `post.bin`. +3. Compare. For each command, the following must match exactly: + +| Command | Deterministic bytes that MUST match | +|---|---| +| wake | host `0xAA 0xAA 0xAA` → amBIT `0x80` | +| set_gains (1) | frame `0xA0`+8B cmd → `0xA1` (CMD_DONE). No data. | +| set_currents (2) | frame → `0xA1` | +| config (10) | frame → `0xA1` | +| get_spec (31) | `0xA1` + **24 B** + `0xF0` | +| get_temp (32) | `0xA1` + **4 B** + `0xF0` | +| get_info (33,2) | `0xA1` + **`sizeof(ambit_fw_info_t)` B** + `0xF0` | +| get_temp_raw (34) | `0xA1` + **14 B** + `0xF0` | +| run (21) / mpf (20) | `0xA1` … FSM arrays (`0xD3` wake, `0xD2` ack, `0xD4 0x96` len-hdr w/ checksum byte, data, `0xD4 .. checksum`, `0xB4` pass) … `0xF0`. **Array count, each array length, header checksum, and data byte-sum checksum must verify.** Data values may differ. | + +**Pass:** all framing/handshake/length/checksum bytes identical; only measurement payload +values differ. **Fail:** any framing byte, length field, command-ID echo, or checksum +*scheme* differs → a contract break; do not ship, diff the offending command. + +> If no sniffer is available, Test A reduces to "the ambyte completes every command in §3 +> with no timeout / no `checksum mismatch` / no `CMD_DONE not received` log" — a weaker but +> still useful gate (`uart_sensors.c` logs all three on failure). + +--- + +## 3. Test B — functional regression (per MERGE_PLAN §14) + +Drive each command class from the ambyte and confirm it completes and the numbers are +sane. Minimum sequence: + +- [ ] **wake / ping** — amBIT acks `0x80`; ambyte marks channel CONNECTED. +- [ ] **set_gains (cmd 1)** then **set_currents (cmd 2)** — each returns `CMD_DONE`. +- [ ] **config (cmd 10)** — `CMD_DONE`. +- [ ] **run (cmd 21)** with a small array — FSM round-trip completes, **all array + checksums pass**, array count = expected (env, fluor, fluoref, sun, leaf, 730, + 730ref), values in a plausible range. +- [ ] **run_mpf (cmd 20)** — completes; length decodes correctly (test a length >127 to + exercise the base-128 split, e.g. 200 → `cmd[1]=1, cmd[2]=72`). +- [ ] **get_spec (cmd 31)** / **get_temp (cmd 32)** / **get_temp_raw (cmd 34)** — correct + byte counts (24 / 4 / 14), values sane (temp ≈ ambient °C). +- [ ] **get_info (cmd 33)** subtypes 1/2/3 — struct sizes match `ambit_protocol.h` + (calibration ~136 B, fw_info ~48 B, metadata ~248 B). +- [ ] **baseline (cmd 6)**, **blink (cmd 5)**, **actinic (cmd 4)** — complete without error. +- [ ] **set_metadata (cmd 37)** with `eof_mark = 2025` — accepted and persisted. + +**Compare measurement values** from cmd 21/20 against the pre-Step-4 reference build on the +same target/sample: they should match within sensor noise (Step 4b does not change the +measurement math). + +--- + +## 4. Test C — the dirty-mark behavioural delta (the only intended change) + +Run this exact non-standard sequence **without a cmd 10 between set and run**: + +1. `cmd 10` (config) then `cmd 21` (run) with gains G1 — note the values. +2. `cmd 1` (set gains to a clearly different G2) **then `cmd 21` directly** (no cmd 10). + +- **Pre-Step-4b:** the run in step 2 used **G1** (stale — the bug). +- **Post-Step-4b:** the run in step 2 uses **G2** (re-applied — the fix). + +**Expected pass:** step-2 readings reflect G2. If any ambyte workflow *depended* on the old +stale-config behaviour, flag it — the dirty-mark can be removed from `core_set_gains` / +`core_set_currents` (drop the `adpd_mode = MPF_MODE` line) to restore the exact old binary +behaviour, at the cost of re-diverging from the text path. + +--- + +## 5. Result handling + +- **All pass** → mark Step 4b verified: update memory `merge-plan-ambit` ("4b verified on + HW ") and tick MERGE_PLAN §14's ambyte rows. +- **Framing diff (Test A fail)** → contract break; capture the offending command's pre/post + bytes and fix the adapter so the wire matches. +- **Test C unwanted** → remove the dirty-mark as noted in §4. + +This same harness (Tests A/B) is the reusable conformance gate for any future change that +touches `run_esp.cpp` or `data_utils.cpp`'s FSM (Step 5 onward). + +--- + +## 6. Re-verification log (changes that require re-running this gate) + +| Date | Change | Re-run | Status | +|------|--------|--------|--------| +| 2026-06-05 | Step 4b — binary frontend → core (`run_esp.cpp` cmd 1/2/10/20/21) | A + B + C | ✅ PASSED (incl. run(21)/mpf(20) FSM round-trip) | +| 2026-06-05 | Sweep #4 inc 1 — extracted `pam_send_results` from `run_arr_type1`; verbatim relocation of the `fsm_send_esp`/`send_serial` calls | A + B | ✅ PASSED — AMBYTE: run(21) = 5 arrays (idx0 len1 ENV + idx1-4 len30; 730/730ref correctly absent for no-IR), mpf(20) = 7 arrays. (COMPUTER `arrun` half is the same function's other branch — optional spot-check.) | +| 2026-06-05 | **#16 fix** — `serial_read_until`/`flush_serial` no longer echo non-target bytes (the echo injected the ambyte's 2nd `200` as ASCII `'2''0''0'` into the FSM **data phase** → checksum mismatch every run). **Not** a checksum-scheme bug: the amBIT byte-sums correctly (`u32_byte_sum`, data_utils.cpp:200/201/210, via `fsm_send_data`:432). | A + B | ✅ PASSED — array checksums clean, run/mpf complete | +| 2026-06-05 | Sweep #4 inc 2 — routed `run_trigger_spacer` (the mpf / cmd-20 path) through `pam_send_results` (`subsampling=1, has_730=true` → unconditional 7 channels; AMBYTE branch identical to the former inline block, COMPUTER branch inert as this path is never COMPUTER). `MPF` (2-channel idx 0/1), `external_trigger_run`/`_Flash`/`fluor_offset` (no FSM send) don't share this block. | B — the `mpf(20)` row of the Lua | ✅ PASSED — mpf(20) = 7 arrays, no checksum errors | +| 2026-06-05 | Cheap correctness sweep — **#10** init the comma-decl locals in `run_arr_type1`/`run_trigger_spacer`/`fluor_offset` (defensive; each was already assigned before use); **#8** `w`-length `uint8_t`→`uint16_t` + drop pointless `(uint16_t)` casts; **#9** delete 2 uncalled FSM fns (`fsm_wake_up_calls(void)`, `fsm_send_waitesp` — the latter had missing-return UB). | #10 → A+B (measurement path, behavior-neutral, very low risk). #8 text path (`w` over USB), #9 dead-code → no ambyte HW. | ☐ #10 prudent Lua re-run; #8/#9 done | +| 2026-06-08 | **Wire v2 (ambyte variant)** — (1) self-describing length header: the 2 spare bytes now carry `elem_width` (2\|4) + `dtype` (0 unsigned\|1 signed); csum formula unchanged (sum of bytes [0..6], now covers the new bytes); host defaults 4/0 when a byte is 0, so v1 still decodes. (2) ADC channels (Fluo/Fluoref/Sun/Leaf/730/730ref) sent as **uint16** (elem_width 2, dtype 0, each clamped to 0xFFFF); ENV as **int16** centi-°C (elem_width 2, dtype 1). Data-trailer csum = byte-sum of exactly the bytes sent. (3) new **TIMING** block idx 7 = `uint32[tick_begin, tick_end]` (µs from `esp_timer_get_time()`), emitted in `pam_send_results`. (4) **one wake per run**: `data_utils.cpp` FSM split into free `ambyte_wake()` + `dataclass::fsm_send_array(idx,elem_width,dtype)`; `pam_send_results` wakes once then streams each array back-to-back; host loops on the 212 marker, stops at the run's trailing 240. `fsm_send_esp` kept as a legacy wake+one-array(4/0) wrapper (MPF path). Host (ambyte) side updated to match. Both `pio run -e ambyte` and `-e cloud` build clean. | A + B | ☐ pending HW — one wake yields ENV(int16×N), Fluo/Fluoref/Sun/Leaf/730/730ref(uint16×N), TIMING(uint32×2), then 240; every header csum + data byte-sum must verify and each block decodes per `elem_width`/`dtype` | + +**Focused check for sweep-#4 inc 1** (the send block is shared by both transports, so verify +both halves): + +- **AMBYTE path** — drive a `run` (cmd 21) and an `mpf` (cmd 20) from the ambyte: the FSM + round-trip (array count, each array length, header + byte-sum checksums) must be identical + to the pre-change build; measurement values within sensor noise. +- **COMPUTER path** — drive `arrun` over the USB/text console: the 7 ASCII blocks + (`Data:ENV…`, `Fluo`, `Fluoref`, `SUN`, `leaf`, `730`, `730ref`) followed by `Data sent` + must be byte-identical to pre-change (this exercises the `send_serial` half). + +Passing both confirms the extracted `pam_send_results` reproduces the inline block exactly. +The next sweep-#4 increments (`PamBuffers` RAII / `#11` leak fix, then `read_one_frame`) +each get their own row here and must re-run A + B before being trusted. diff --git a/MERGE_PLAN.md b/MERGE_PLAN.md new file mode 100644 index 0000000..32c9c6e --- /dev/null +++ b/MERGE_PLAN.md @@ -0,0 +1,615 @@ +# Ambit Firmware Merge Plan (v2) — built around dialect + config unification + +Collapse the two diverged Ambit ESP32-C3 forks into **one** source tree that builds +both product variants from one codebase: + +- **`ambyte`** variant — binary FSM protocol over UART0/FFC, idle light-sleep, the + field/companion-board use case (today = `fw_new`, was `ambitPIO`). +- **`cloud`/`usb`** variant — text + JSON over native USB-CDC, feeds the OpenJII + platform / phone app (today = `fw_appCompatible`, was `openJII`). + +Sources: +- `T` = **`fw_new`** (ambyte/binary line, this repo) — the **trunk**. +- `A` = **`fw_appCompatible`** (cloud/JSON line) — a *capability fork*: it added the + JSON/line frontend but **deleted** the binary frontend, Wrench, and power + management. Donor of the text/USB frontend only. +- `H` = **`ambyte-iot-ludo`** (the datalogger) — **not** ambit FW. It is the + *authoritative spec* of the binary wire contract ([uart_sensors.c], [ambit_protocol.h]). + Treated here as the frozen reference, never modified. + +Back-compat of the **text** path is not a constraint; the **binary** path is a frozen +wire contract (§2). Git holds history. Reviewed 2026-06-05. + +--- + +## 0. Revision history + +### v3 (current) — openJII comms layer + +- **Core returns typed data, not a JSON tree.** The shared core is JSON-free; the JSON + tree is built only in the app-side (cloud) adapter, so the `ambyte`/binary image links + no JSON (§5, §7c). +- **The openJII text/JSON layer is a device-agnostic shared module** (§7d), built **fresh** + to [CommunicationProtocolOpenJIISerial.md] — CO2Dot is the doc's named reference but is + too old to lift (D5). +- **Envelope `set` is flat** (one element per executed command/repeat). **Snapshot → + tree; measurement → one streamed JSON value** per `set` position (D6). +- **Comms-layer workflow:** implement to the spec doc → HW-test against the real app (the + oracle) → revise the spec doc. The binary path is *not* iterated this way — it's frozen. + +### v2 — unification spine + +This revision is built around the **command-dialect + config unification** as the +headline task, not as one step among many. Specifically: + +- **D1 (Wrench): DELETE, not gate.** Tracing shows Wrench is reachable from exactly + one text-console entry point and exposes zero unique commands (§8). It goes away + entirely, behind a single stakeholder check. +- **The spine is now: one CORE + one CONFIG + three thin transport adapters** (§4–§7). + Every other task (JSON re-graft, PAM sink merge, framing fix, power mgmt) hangs off + that spine. +- **Constraint (c) is promoted to its own section (§2)** with an explicit, verified + list of frozen wire elements and a conformance gate, because the deployed ambyte + (`H`) already pins several of them — including the data checksum, which makes + `fw_new`'s "checksum fix" **mandatory for compatibility**, not optional. + +--- + +## Where we are — 2026-06-05 (resume here) + +Two build variants from one tree (`platformio.ini`): **`ambyte`** (binary FSM over +UART0/FFC, HW-verified field path) and **`cloud`** (openJII LINE+JSON over UART0 — the +test HW has no USB-C; the native-USB-CDC flags are kept in a comment for a future PCB). + +**Done + HW-verified** (commits through `51a7ffc`): +- Wrench deleted; the 3 config copies unified; transport-agnostic CORE (`core.*`); text + + binary frontends thin over it; `pam_send_results` shared; echo (#16) fixed; nvs checksum + (#6); dead-code purge (#3); cheap correctness (#8/#9/#10). Binary path byte-conformant vs + a real ambyte (`HW_CONFORMANCE.md`). +- **openJII module `lib/openjii_proto/`** (device-agnostic): first-byte mode detect, LINE + (bare scalar / JSON container + dot-path + `keys()`), JSON envelope (flat `set` + frame + token), §9 errors, receiver. Snapshot API `on()` + stream/measurement API `on_stream()`. +- **Cloud variant** (`src/frontend_cloud.cpp`): snapshots hello/temp/get_par/PAR (verified) + and **`arrun` measurement-in-envelope** (verified — runs `run_arr_type1`'s new + `json_output` path, emits `{"ENV":[..],"Fluo":[..],"Fluoref":[..],"SUN":[..],"leaf":[..]}`). + ENV channels byte-identical to fork A's `send_json`; ENV decoded from fw_new centi-°C. + +**Next (pick up here):** +1. **Expand command coverage.** Snapshots: `set_currents`/`set_gains`/`set_pd_gain`/`baseline`/ + `battery`/`set_act`/`set_name`/`set_emit`/`set_spec`/`clean_nvs`/`reboot`/`check` — each a + one `on()` tree-builder calling the CORE. Measurements: `q`/`w`/`mpf`/`ww`/`ff` — give + `run_trigger_spacer` (and `MPF`) the same `json_output` sink `run_arr_type1` has, register + via `on_stream`. +2. **Confirm formats against the app (D6/D2).** ENV is `{"temp_c":<°C>}` per point now (fork A + had `{"t_ms":..,"temp_c":..}` + step marks, dropped in fw_new). Adjust `send_env_json` if the + app needs the old shape. Check ArduinoJson float precision (trims trailing zeros vs the + spec's fixed 4 dp) is tolerated. +3. **Test the rest of LINE mode on HW:** dot-path queries, `keys()`, the error taxonomy. +4. **Open decisions:** D2/D3 (env centi-°C + ambient — consumer sign-off), D6 (measurement + shape — partly resolved by the working `arrun`). + +--- + +## 1. Headline: the disease and the cure + +**Disease.** The same ~25 logical operations are implemented as **four parallel +command parsers**, each with its own argument decoding *and* its own copy of the +device config: + +| Parser | File | Config it mutates | +|---|---|---| +| text/computer | [do_command.h] `hash()` switch | global `adpd_*_config` | +| binary/ambyte | [run_esp.cpp] `cmd_arr[0]` switch | `adpd_*_config_local` (file-static) | +| Wrench bridge | `do_c.cpp` native fns | `do_c.cpp` statics (3rd copy) | +| JSON/line (fork `A`) | [commands.cpp] `startsWith` chain | global `adpd_*_config` | + +Adding one command means editing up to four places; the same setting lives in three +structs that can silently diverge (set currents via text, run via binary → different +values applied). **This duplication is the root cause of the forks themselves.** + +**Cure.** Split every operation into: + +``` + wire bytes ─► [thin transport adapter] ─► normalized args ─► CORE op ─► result ─► [sink] + │ │ + (decodes that transport's one implementation, + own wire convention) one CONFIG struct +``` + +- **One CORE** ([core.cpp]): one function per logical operation, taking *normalized* + typed args and writing to a *sink*, never touching `Serial`/`printf` directly (§5). +- **One CONFIG** ([config.h]): a single `AmbitConfig` struct every path reads/writes (§6). +- **Three thin adapters**: binary (frozen wire), text-line, JSON (§7). Each adapter's + only job is wire⇄normalized-args translation + choosing the sink. No measurement or + config logic lives in an adapter. + +Note the realistic scope: because the binary wire is frozen (§2), we **do not** merge +the three *parsers* into one parser. We collapse the three *cores* and three *configs* +into one each, and make all three parsers thin shims over them. That is the achievable, +high-value unification. + +--- + +## 2. The frozen binary contract (constraint c) + +The binary path is a wire contract with **shipped ambyte firmware** (`H`). The contract +is defined by what [uart_sensors.c] / [ambit_protocol.h] already implement. Refactor +*behind* it freely; do **not** change the bytes. De-obscuring is allowed only on the +text/USB path. + +**Frozen elements (verified against `H`):** + +| Element | Value / encoding | Source of truth | +|---|---|---| +| Wake / ack | host `0xAA ×3` → ambit `0x80`; boot-idle `0x85` | [uart_sensors.c:32-37] | +| Cmd frame | header `0xA0` + 8-byte `cmd[8]` (+ optional extra) → `0xA1` done → … → `0xF0` end | [uart_sensors.c], [run_esp.cpp] | +| Command IDs | 1,2,10,20,21,31,32,33,34,37,4,5,6,17,18 | [ambit_protocol.h:15-31] | +| Info subtypes | 33 → 1=calib, 2=fw, 3=metadata | [ambit_protocol.h:33-37] | +| Response structs | calibration ~136 B, fw_info ~48 B, metadata ~248 B (ESP32 default alignment, `eof_mark==2025` to accept) | [ambit_protocol.h:39-87] | +| Raw responses | spec = 24 B (12×u16, last 4 = float PAR); temp = 4 B (2×i16 ×10); temp_raw = 14 B (7×i16) | [run_esp.cpp], [ambit_protocol.h:83-87] | +| FSM data handshake | wake 211, awake 210, data-hdr 212, len-marker 150, ready 200, data-pass 180, reset 222 | [data_utils.h:9-16], [uart_sensors.c:39-46] | +| FSM header checksum | sum of header bytes `[0..6]` == byte `[7]` | [uart_sensors.c:265-269] | +| **FSM data checksum** | **byte-sum of every payload byte mod 256** (`u32_byte_sum`) | [uart_sensors.c:323-330] | +| MPF length encoding | **base-128 split**: `cmd[1]=len>>7`, `cmd[2]=len&0x7F` | [device_commands.c:1027-1028], [run_esp.cpp:92] | +| Gain wire convention | cmd 1 gains are **1-indexed** on the wire (1..6), stored `−1` | [run_esp.cpp:58-63] | + +**Consequences for the merge:** + +1. **The byte-sum checksum is required, not optional.** `H` verifies it; `fw_original`'s + low-byte-only checksum would be rejected. `fw_new` already byte-sums — keep it. This + alone confirms `fw_new` (not `fw_original`) is the correct trunk for the binary path. +2. **Obscure-but-frozen encodings stay** (base-128 MPF length, 1-indexed gains, struct + alignment). We *document* them at the adapter boundary; we do not "clean them up." +3. **Per-transport wire conventions are decoded in the adapter, not the core.** The CORE + `set_gains` takes 0-indexed normalized gains; the binary adapter subtracts 1, the + text/JSON adapters pass through. Same for the base-128 length. +4. **Semantic (non-wire) contracts are a separate freeze (D2/D3).** `H`'s C layer + forwards env/data arrays **raw** (it does not decode env temperature), so changing + the env-temp *encoding* won't break the wire — but it changes what the *consumer* + (Lua/cloud) must parse. Freeze those by **decision + consumer sign-off**, not by the + conformance test. + +--- + +## 3. Decisions + +| # | Decision | Resolution | +|---|---|---| +| **D1** | Wrench scripting VM (`wrench.*` 17.4k LOC + `do_c.cpp`) | **DELETE entirely** (§8). One text-only entry point, zero unique commands. **Stakeholder check (the only gate):** confirm nobody sends multi-line `C…?` *scripts* (loops/control-flow) from the bench console today. Single primitive calls → pure win. Real scripting → that workflow moves host-side (the ambyte and app already drive primitive sequences themselves). | +| **D2** | Env-temperature wire/format | **Keep `fw_new` centi-°C** plain `int16` (de-obscured from the old `time<<16\|type<<12\|(mlx+20)*20`). Step-mark events are dropped. **Consumer sign-off required:** verify (a) the cloud/Lua consumer tolerates a plain centi-°C series, and (b) the dropped step-marks did not feed `H`'s `mark_event_*` subsystem ([device_commands.c:78]). | +| **D3** | Ambient (sun/leaf) correction | **Keep `fw_new`** offset-corrected (`>65000 ? x−65000 : 0`). If the cloud backend needs *raw*, branch at the `put()` on `CONNECTION_TYPE==CLOUD` only. **Verify with the data consumer before locking.** | +| **D4** | `SunRint`/`LeafRint` gain fields + `read_light_env()` (fork `A` only) | Keep **iff** the cloud/app variant needs the `set_pd_gain` / `read_light_env` snapshot. Otherwise drop the two fields and the function. Default: **keep** (the app uses `set_pd_gain`). | +| **D5** | openJII text/JSON implementation source | **Build the comms layer fresh** to [CommunicationProtocolOpenJIISerial.md] as a **device-agnostic shared module** (§7d). CO2Dot is the doc's named reference but is **too old to reuse** — do not lift its code. Reuse fork `A`'s parser/framing only as a starting skeleton, never its hand-printed command bodies. | +| **D6** | openJII measurement (`arrun`) in-envelope JSON shape | **Resolve by HW test, not now.** Observed app expectation is `arrun → [{…},{…}]` (one element per produced array). It appears to conflict with **command-as-root** (§2.1 of the spec): a bare array `[{…},{…}]` is command-as-root-compliant, a `{"arrun":[…]}` wrapper is not. The app is the oracle — confirm the exact shape on hardware, then revise the doc. | + +**Comms-layer workflow (D5/D6).** For the openJII text/JSON layer **only**: implement to the +spec doc → HW-test against the real app → revise the spec doc to match what the app +actually accepts. The binary/ambyte path is **not** iterated this way — it is frozen (§2). + +--- + +## 4. Target architecture + +``` + ┌─────────────────── one CORE (core.cpp) ───────────────────┐ + │ set_currents · set_gains · set_pd_gain · config_detector │ + host bytes │ run_array · run_mpf · external_trigger · flash_trigger │ + │ │ get_par · get_temp · get_temp_raw · baseline │ + ├─ binary adapter ───►│ set_actinic · set_name · set_metadata · set_emit/spec │ + │ (run_esp.cpp, │ blink · nvs_clean · nvs_update · info · check · reboot │ + │ FROZEN wire §2) │ read_light_env (D4) │ + │ └───────────────┬──────────────────────────┬────────────────┘ + ├─ text-line adapter ─────────────────┤ │ + │ (frontend_text.cpp) ▼ ▼ + │ one CONFIG (AmbitConfig) output via sink: + └─ json adapter ─────────► currents + gains + BINARY → fsm_send_esp / raw writes + (frontend_json.cpp, pd_gain + mode TEXT → send_serial / CSV + cloud/usb only) JSON → send_json + PLOT → CSV printf +``` + +- **Sink selector = `CONNECTION_TYPE`** (already the right seam in [config.h]). Extend + the enum with `CLOUD`; fork `A`'s `json_output` bool and `T`'s per-call branching both + collapse onto it. +- **Core functions take an explicit sink/connection arg or read the global + `CONNECTION_TYPE`** — but never hardcode a transport. + +--- + +## 5. The unified CORE (`core.cpp` / `core.h`) + +Extract each command body (currently duplicated across the four parsers) into **one** +function. Rules: + +- Parameters are **normalized typed values** (0-indexed gains, real `uint16` lengths) — + the adapter has already undone its wire convention. +- **Returns typed native data (structs/scalars), never formatted text and never a JSON + tree.** No `Serial`/`printf`/ArduinoJson inside the core — so the `ambyte` image links + no JSON. Snapshot ops return by value/out-param (e.g. `get_par(u16 spec[10]) -> float`); + the adapter renders it (binary bytes, LINE text, or the JSON tree built in the cloud + adapter §7c). +- **Streaming measurements** write raw frames through `dataclass`/the streaming sink, + keyed by `CONNECTION_TYPE`; the adapter decides framing (binary FSM bytes vs a streamed + JSON array element). The core never builds a tree for a run — runs are thousands of + points. +- Returns a typed status, so adapters can format errors per dialect (binary `CMD_END`, + text `BAD COMMAND`, JSON `{"error":…}`). + +Operation set (the single source of truth; the §11 coverage matrix maps each dialect +onto these): + +``` +set_currents(u8 i620, u8 i720, u8 ir) +set_gains(u8 fluo, u8 fluoRef, u8 ir, u8 irRef, u8 sun, u8 leaf) // 0-indexed +set_pd_gain(u8 sunTia, u8 sunRint, u8 leafTia, u8 leafRint) // D4 +config_detector(...) // conf_slow_FR_1 wrapper +run_array(u8 len, const u8* arr, u8 persist, bool allow_int) +run_mpf(u16 length, u8 interval, bool change_act, u8 act) +external_trigger(), flash_trigger(u32 gate, u32 dt, u16 num) +get_par(u16 spec[10]) -> float +get_temp(double* leaf, double* chip) +get_temp_raw(...) ; baseline(u32 ret[6], bool save) +set_actinic(float), set_name(const char*), set_metadata(const metadata_t*) +set_emit(double), set_spec(float) +blink(u8 id, u8 intensity) +nvs_clean(), nvs_update_scalar(...), nvs_update_array(...) +info(u8 subtype) ; check() ; reboot() +read_light_env() // D4 +``` + +--- + +## 6. The unified CONFIG (`AmbitConfig`) + +Collapse the three copies into one global struct, read/written by every adapter: + +```c +struct AmbitConfig { + struct { uint8_t i620, i720, ir; bool init; } current; + struct { uint8_t fluo, fluoRef, ir, irRef, sun, leaf; + uint8_t sunRint, leafRint; // D4 + bool init; } gain; // ALL 0-indexed (normalized) + uint8_t adpd_mode; // ADPD_CONFIG_MODE +}; +extern AmbitConfig g_cfg; +``` + +- Delete `adpd_current_config_local` / `adpd_gains_config_local` ([run_esp.cpp:21-22]) + and the `do_c.cpp` statics (gone with Wrench). +- **Preserve "set then apply on run" semantics.** Today the text path sets the global + and marks `adpd_mode = MPF_MODE` ("not applied"); the binary path applies at + `config_detector`/`run_array` time. Unify on: setters mutate `g_cfg` only; the + measurement core calls `config_detector` from `g_cfg` when `adpd_mode` requires it. +- **Init/default handling once.** Fork `A` force-sets `init=true` to silence the + "preset not initialized" logs ([commands.cpp:267-268]); the binary path warns. Pick one + rule (default-initialized config is valid) and apply it in the core. +- *Checkpoint after this step:* set currents/gains via the text adapter, run via the + binary adapter → identical values applied. + +--- + +## 7. The three adapters + +### 7a. Binary adapter (`run_esp.cpp`) — FROZEN wire +- Keep the `cmd_arr[0]` switch and **every byte** it reads/writes (§2). +- Each case: decode wire → undo wire convention (gain `−1`, base-128 length) → call the + **same core fn** the other adapters call → encode response in the frozen format. +- This is where §2's conformance gate applies. + +### 7b. Text-line adapter (`frontend_text.cpp`, replaces `do_command.h`) — de-obscure freely +- Keep the verb names (`set_currents`, `arrun`, `q`, `ww`, `ff`, `get_par`, …) as the + human/console surface; route each to a core fn. +- Replace the `hash()` dispatch (silent-collision risk, sweep #19) with a + `strcmp`/`string_view` table if cheap; not a blocker. + +### 7c. openJII text/JSON adapter (cloud/usb only) — built to the spec, not ported wholesale +- Implements [CommunicationProtocolOpenJIISerial.md]: first-byte mode detect (`{`/`[` → + JSON envelope, else LINE), flat `set` envelope, command-as-root, the error taxonomy. +- Reuse fork `A`'s parser/framing ([commands.cpp]) as a **skeleton only**; **discard its + hand-printed `Serial.printf("{…}")` bodies** — they are exactly the per-command + format-strings the spec forbids. Each command instead supplies a **tree-builder** that + consumes the core's typed result. +- **Snapshot commands → build a small tree → serialize.** **Measurement commands + (`arrun`/`q`/MPF) → stream one well-formed JSON value** (an array of frame objects) into + the command's single `set` position — no `stream_start`/`stream_end` side-objects, no + raw bytes (those corrupt the envelope). Exact shape per **D6** (HW-verified). +- ArduinoJson is pulled in **only** for the cloud env (§11); the `ambyte` image stays JSON-free. +- Brings the two `A`-only verbs (`set_pd_gain`, `read_light_env`) into the core (D4). + +### 7d. The shared openJII comms module (`lib/openjii_proto/`) — device-agnostic (D5) +The protocol machinery is **not** amBIT-specific. Factor spec §11's five pieces into a +reusable library other firmware can adopt verbatim: + +1. **Receiver** — first-non-whitespace byte selects mode; string-aware brace/bracket-depth + detects JSON completeness; overflow → `{"error":"rx_overflow"}`, JSON idle 1 s → + `{"error":"json_timeout"}`. +2. **JSON serializer** (strict JSON) + **3. scalar-aware LINE serializer** (scalar → bare, + container → JSON). +4. **Path resolver** — `.`-walk (map key / array index) + `keys()`, with the §9 error set. +5. **Envelope writer** — header → flat `set` (one element per executed command/repeat) → + frame token. + +Device-facing API is tiny: per command, the device registers a **tree-builder** (snapshot) +or a **stream-writer** (measurement) that consumes a core typed result. amBIT supplies +those; the module knows nothing about amBIT. Built **fresh** to the spec (CO2Dot too old — +D5); iterate the spec via HW tests (D5/D6 workflow). + +**Wire-convention boundary (the key correctness rule):** normalization happens in the +adapter. Example — gains: binary subtracts 1 and validates 1..6; text/JSON pass the raw +0-indexed value. The core only ever sees 0-indexed gains. + +--- + +## 8. Wrench deletion (D1) + +Tracing (this session) established Wrench's full footprint: + +- **Single entry point:** [do_command.h:60] `case hash("C")` reads chars until `?` and + calls `do_c(c)`. Text/computer console only. +- **Never on the binary or app paths:** [run_esp.cpp] has no Wrench reference; `H` never + sends a `C` script; fork `A` already shipped without Wrench. +- **Zero unique commands.** `do_c.cpp` registers 11 native fns (`set_currents`, + `set_gains`, `config`/`detector_preset`, `set_arr`, `reset`, `run`, `run_mpf`, + `get_par`, `get_temp`, `print`, `disp`) — every one is a thin wrapper over a core fn + that already exists as a text verb **and** a binary opcode. (`idle` is defined but + never registered — dead even inside the VM.) +- **It is the 3rd config copy:** `do_c.cpp`'s `set_currents`/`set_gains` write file-local + statics independent of both other configs. +- **It owns the `arr_reset` overflow** (sweep #5, now gone with it) and an 8-slot `wr_run_arr[]` + store referenced nowhere else. + +**Action:** delete `src/src/wrench.{cpp,h}`, `src/do_c.cpp`, the `C` case, and all +`#include "src/wrench.h"`. The only capability lost is **on-device control-flow scripting** +(loops/variables/the 8 pre-loaded array slots) on the bench console — which moves +host-side, matching how the ambyte and app already operate. + +**Wins:** −17.4k LOC from the default image, −1 config copy, −1 buffer overflow, −1 dead fn. + +--- + +## 9. PAM / data_utils / sink unification (folded) + +`PAM.cpp` diverged on two orthogonal axes — treat separately. + +- **Axis A (transport):** fork `A`'s `json_output` bool + 5-arg `run_arr_type1` overload + vs `T`'s `CONNECTION_TYPE` branches. **Resolution:** keep `T`'s structure; fold `A`'s + JSON branch in as `case CLOUD` at each send site (~4: `run_arr_type1`, + `external_trigger_run`, `MPF`, the env path). Delete the 5-arg overload + `json_output`. +- **Axis B (semantics):** the D2 centi-°C encoding and D3 ambient correction already + live in `T` ([PAM.cpp] diffs confirmed). Keep them; rewrite fork `A`'s + `send_env_json_decoded` for centi-°C (its old-format unpack is stale — sweep #7). +- `data_utils.cpp`: base = `T` (full FSM send + the **required** byte-sum checksum, §2). + **Re-graft `send_json(const char*)`** from `A` for the `CLOUD` sink (~10 lines, decl in + [data_utils.h]). +- While here, sweep the cheap co-located correctness items (uninit locals #10, + leak-on-early-return #11, unaligned `*(float*)&cmd_arr[3]` → `memcpy` #12). +- *Out of scope:* the `dataclass` ring-buffer over-engineering (#18). + +--- + +## 10. main loop + text-path framing (de-obscure, text only) + +Base = `T`'s [ambit-1.ino] (it has the power management — **keep**: `ambit_light_sleep()`, +UART/GPIO sleep-wake config, sleep thresholds, `AMBIT_BOOT_IDLE` heartbeat, triple-tap-BOOT +reset ISR). + +**Cherry-pick fork `A`'s framing** ([ambit-1.ino:89-111] in `A`) as the de-obscuring fix +for sweep #20: decide LINE vs JSON by the **first printable char** and drop junk +bytes while mode is `UNKNOWN`, instead of `T`'s glitch-sensitive `c > 127` MSB heuristic +that mis-fires on the DTR/RTS open glitch and emits `Unknown cmd`. This is a **text-path** +change and does not touch the binary contract. + +Also (sweep #16): **stop echoing parsed bytes** in `serial_read_until`/`flush_serial` +— that echo currently injects bytes into the binary stream that `H` has to discard as +"debug/echo bytes" ([uart_sensors.c:382]). Move these helpers' single definition into +`serial.*` (kills the 4-TU re-declaration, #15). + +**Variant separation over runtime auto-detect.** The ambyte is a separate product on a +dedicated FFC UART; the app is USB-CDC. Prefer **build-flag-separated frontends** (§11.5) +to runtime first-byte transport sniffing — cleaner and less bug-prone. Keep the framed/junk- +drop fix for robustness either way. + +--- + +## 11. platformio.ini + build flags + +```ini +[platformio] +default_envs = ambyte + +[env] +platform = espressif32 +board = esp32-c3-devkitm-1 +framework = arduino +monitor_speed = 115200 +build_flags = -DDEBUG=0 + +[env:ambyte] ; binary FSM over UART0/FFC, light-sleep +build_flags = + ${env.build_flags} + -DARDUINO_USB_CDC_ON_BOOT=0 + -DVARIANT_AMBYTE=1 + +[env:cloud] ; text+JSON over native USB-CDC +build_flags = + ${env.build_flags} + -DARDUINO_USB_MODE=1 + -DARDUINO_USB_CDC_ON_BOOT=1 + -DUSB_VID=0x16C0 + -DUSB_PID=0x0483 + '-DUSB_MANUFACTURER="JII"' + '-DUSB_PRODUCT="Ambit"' + -DVARIANT_CLOUD=1 +lib_deps = ${env.lib_deps} + bblanchon/ArduinoJson ; only the cloud image pays for JSON +``` + +- `VARIANT_AMBYTE` → binary adapter + FSM + light-sleep idle loop. +- `VARIANT_CLOUD` → JSON/line adapter + `send_json` + (D4) `read_light_env`. +- **No `ENABLE_WRENCH`** — Wrench is deleted (D1). +- Core (`core.*`, drivers, `AmbitConfig`) compiles in both. +- After changing envs, delete the per-env `sdkconfig.*` so it regenerates. + +### Coverage matrix (every dialect → the §5 core ops) + +| Core op | text (`do_command`) | binary (`run_esp` cmd) | JSON (`commands`) | +|---|:--:|:--:|:--:| +| set_currents | ✓ | 2 | ✓ | +| set_gains | ✓ | 1 | ✓ | +| set_pd_gain (D4) | — | (1) | ✓ | +| config_detector | (via run) | 10 | (via run) | +| run_array | `arrun` | 21 | `arrun` | +| run_mpf | `q` | 20 | `q` | +| get_par | ✓ | 31 | ✓ | +| get_temp / _raw | `temp` | 32 / 34 | `temp` | +| baseline | ✓ | 6 | ✓ | +| set_actinic | ✓ | 4 | ✓ | +| set_name | ✓ | 37 | ✓ | +| set_metadata | — | 37 | — | +| set_emit / set_spec | ✓ | — | ✓ | +| external / flash trigger | `ww` / `ff` | — | `ww` / `ff` | +| read_light_env (D4) | — | — | ✓ | +| nvs clean / update | `clean_nvs` | 17 / 18 | `clean_nvs` | +| info / check | `check` | 33 | `check` | +| reboot | `reboot` | — | `reboot` | +| blink | `a`/`aa` | 5 | `a`/`aa` | + +--- + +## 12. Execution order (unification-first) + +1. **Branch + scaffold.** Branch off `fw_new`. Add `CLOUD` to the `CONNECTION_TYPES` + enum; add the two PIO envs + flags (§11). *Checkpoint: `ambyte` env still builds/runs.* +2. **Delete Wrench (D1, §8).** Remove `wrench.*`, `do_c.cpp`, the `C` case, includes. + *Checkpoint: `ambyte` builds; every former Wrench op still reachable as a text verb.* +3. **Unify CONFIG (§6).** Collapse the three copies into `AmbitConfig`. *Checkpoint: set + via text, run via binary → identical currents/gains applied.* +4. **Extract CORE (§5).** Move each command body into one core fn; point the text and + binary adapters at the shared fns. Normalize wire conventions at the adapter boundary. + *Checkpoint: every §11 row reachable from both `ambyte` and text, same numbers.* +5. **Consolidate serial helpers + drop echo (§10).** Single prototype in `serial.*`, + no echo-on-parse. *Checkpoint: clean binary round-trip, no stray echoed bytes.* +6. **PAM + data_utils sink merge (§9).** Add `case CLOUD`, re-graft `send_json`, rewrite + env-JSON for centi-°C, sweep #10/#11/#12. *Checkpoint: AMBYTE numbers byte-identical + to pre-merge `fw_new`; CLOUD JSON validated vs backend schema.* +7. **Port JSON adapter (§7c).** Bring `commands.cpp`'s parser onto the core as + `frontend_json.cpp` (cloud env only); delete `commands.cpp/.h`. +8. **main-loop framing (§10).** Adopt fork `A`'s first-printable-char framing on the text + path; keep `fw_new`'s power management. *Checkpoint: DTR/RTS open glitch no longer + emits `Unknown cmd`.* +9. **Build both envs; HW-test both variants (§14).** + +--- + +## 13. Frozen-contract conformance gate (§2) + +> **Runnable procedure: [HW_CONFORMANCE.md](HW_CONFORMANCE.md).** Step 4b (binary frontend +> → core) was **HW-verified byte-conformant on 2026-06-05** against a real ambyte. Keep the +> procedure as the reusable gate for later `run_esp.cpp` / FSM changes (Step 5+). + +Before merging the binary adapter changes (step 4–5), establish a regression artifact and +keep it green through every later step: + +- **Capture a golden byte trace** of the current `fw_new` ↔ `H` exchange for each binary + command (or derive the expected frames from [uart_sensors.c] + [ambit_protocol.h]): + wake/ack, the 8-byte cmd frame, `CMD_DONE`/`CMD_END`, raw response sizes, and a full FSM + data round-trip (header checksum, **byte-sum** data checksum, length encoding). +- **Assert byte-for-byte identity** of the refactored binary adapter's output against the + golden trace. Any diff = a contract break. +- Explicitly assert the obscure-but-frozen encodings: base-128 MPF length, 1-indexed + gains, struct sizes (136 / 48 / 248), `eof_mark==2025`. +- The conformance gate covers the **wire**; D2/D3 semantic changes are gated separately by + **consumer sign-off** (§3), since `H` forwards those arrays raw. + +--- + +## 14. Risks & test checklist + +| Risk | Mitigation | +|---|---| +| Refactoring the binary adapter breaks the wire contract with shipped ambytes | §13 golden-trace conformance gate, kept green every step; freeze fw_new binary behavior as reference | +| D2/D3 semantic changes alter measured values / cloud ingestion | Consumer sign-off before step 6; freeze AMBYTE numbers; branch raw-vs-corrected on `CLOUD` only if needed | +| Dropped step-marks were feeding `H`'s `mark_event_*` | Confirm with `H` owner before locking D2; else add a dedicated marker channel | +| CONFIG unification changes "when config is applied" semantics | Preserve set-then-apply-on-run; checkpoint 3 verifies cross-adapter equivalence | +| Wrench deletion removes a used scripting workflow | D1 stakeholder check first; move scripting host-side | + +**Per-variant test checklist** +- [ ] `ambyte`: full wake→length→data FSM round-trip to a real ambyte; **byte-sum checksum OK**. +- [ ] `ambyte`: idle current drops to light-sleep between commands; triple-tap BOOT resets; UART wakes within threshold. +- [ ] `cloud`: line + JSON over USB-CDC; `set_pd_gain`/`read_light_env` (if D4=keep). +- [ ] both: `set_currents`/`set_gains` from any adapter reflected in the run (config unify). +- [ ] both: `get_par`, `get_temp`, `baseline`, `arrun`, `run_mpf` expected output. +- [ ] regression: AMBYTE measurement numbers byte-identical vs pre-merge `fw_new`. +- [ ] glitch: opening the USB port (DTR/RTS) does not emit `Unknown cmd`. + +--- + +## Appendix — file-by-file actions + +Legend: `TRUNK`=take `fw_new` · `MERGE`=reconcile · `PORT`=bring `A` feature onto core · +`DROP`=remove · `KEEP`=unchanged. + +| File | Action | +|---|---| +| `wrench.{cpp,h}`, `do_c.cpp` | **DROP** (D1, §8) | +| `do_command.h` | **MERGE** → `frontend_text.cpp` (thin text adapter, §7b) | +| `run_esp.cpp` | **TRUNK + MERGE** → binary adapter, frozen wire, calls core (§7a) | +| `commands.cpp/.h` (fork `A`) | **SKELETON ONLY** → openJII shared module `lib/openjii_proto/` (§7c/§7d); discard hand-printed bodies | +| new `lib/openjii_proto/` | **NEW** — device-agnostic openJII comms module, built fresh to the spec (§7d, D5) | +| `PAM.cpp` / `PAM.h` | **MERGE** — `CONNECTION_TYPE` sinks + `CLOUD`; D2/D3 kept; D4 re-add (§9) | +| `data_utils.cpp` | **MERGE** — FSM + byte-sum checksum (keep) + re-graft `send_json` (§9) | +| `data_utils.h` | TRUNK + re-add `send_json` decl | +| `config.h` | TRUNK + add `CLOUD`; home of `AmbitConfig` (§6) | +| new `core.cpp/.h` | **NEW** — the unified operation set (§5) | +| `serial.cpp/.h` | TRUNK + absorb `serial_read_until`/`flush_serial`, drop echo (§10) | +| `ambit-1.ino` | **MERGE** — `fw_new` power mgmt + `A` text framing (§10) | +| `nvs1.*`, `self_test.cpp`, `devices_init.*`, `pin_config.h`, drivers | KEEP (identical) — nvs checksum `&`→`|` done (#6) | +| `platformio.ini` | **MERGE** — multi-env + flags (§11) | +| `open-jii/`, `*.ipynb` | OUT OF SCOPE (server/tooling, not firmware) | + +--- + +## Appendix B — correctness & cleanup catalog (folded from REFACTOR_PLAN) + +The single-fork review's items, folded here so this file is the only plan. Referenced +above as `sweep #N` / `#N` (original numbering kept). **Status:** ✅ done · ▶ owned by a +named step (do it there) · ☐ open sweep item (cheap, isolated — fold into the nearest +step) · ⏸ deferred/optional. Line numbers are current as of this session. + +| # | Item | Where (current) | Status | +|---|------|-----------------|--------| +| 1 | Wrench VM (17.4k LOC) for ~8 commands | `wrench.*`, `do_c.cpp` | ✅ deleted | +| 2 | Three parallel config copies | global / `run_esp` `_local` / `do_c` statics | ✅ unified to the PAM global | +| 3 | Massive dead code | `PAM.cpp` `/* */` blocks + `data_utils.cpp` `//` block | ✅ deleted (PAM.cpp 1913→1418, data_utils.cpp 716→561; commented-out, so **zero binary change** — Flash identical) | +| 4 | Measurement loop copy-pasted 5–6× | `PAM.cpp` `run_arr_type1`(153)/`run_trigger_spacer`(402)/`external_trigger_run`(580)/`_Flash`(727)/`MPF`(910)/`fluor_offset`(1319) | ▶ Step 4 — extract `PamBuffers` RAII + `read_one_frame()` + `send_results()` | +| 5 | `arr_reset` buffer overflow | was `do_c.cpp` | ✅ gone with Wrench | +| 6 | FW-info checksum `&`→`\|` | `nvs1.cpp:16` | ✅ fixed this session | +| 7 | `PAM_retrieve_env` decode vs centi-°C encode | `PAM.cpp` env path | ▶ Step 6 — rewrite for centi-°C (D2) | +| 8 | Truncating casts in parsing | `w` length clipped to uint8_t; `a`/`aa` pointless casts | ✅ done — `w` length now uint16_t, casts dropped | +| 9 | Non-void FSM fns miss returns (UB) | uncalled `fsm_send_waitesp` (missing return) + dead `fsm_wake_up_calls(void)` | ✅ both deleted (uncalled). Reset-guards N/A — per-run `dataclass` objects reset on construction | +| 10 | Uninitialized locals | `run_arr_type1`/`run_trigger_spacer`/`fluor_offset` comma-decls | ✅ initialized (behavior-neutral; were assigned before use) | +| 11 | Leaks on early return | `PAM.cpp:180-186` 7× `new dataclass` then `return -1` | ☐ stack-allocate `dataclass`, drop new/delete | +| 12 | Unaligned/strict-alias float reads (trap on C3) | `run_esp.cpp:234,242,294,317` `*((float*)&cmd_arr[..])` | ☐ `memcpy` — **frozen wire, bytes unchanged** | +| 13 | Protocol magic numbers scattered | `data_utils.h` vs literals (`ambit-1.ino:167`, `run_esp.cpp`) | ▶ §2 freezes them; centralize into one `proto` header | +| 14 | Pins half-symbolic | `digitalWrite(10/1,…)`, raw `GPIO_NUM_*` | ☐ name pin 10, use symbols | +| 15 | `serial_read_until` re-declared in 4 TUs | `data_utils.cpp`, `PAM.cpp`, `run_esp.cpp`, `ambit-1.ino:59` | ▶ Step 5 — one prototype in `serial.*` | +| 16 | `serial_read_until`/`flush_serial` echo non-target bytes onto the link | corrupts the binary stream | ▶ Step 5 — drop echo | +| 17 | `load_calibration_info` `isKey()`+`getX()` ×~20 | `nvs1.cpp` | ⏸ deferred — dropping `isKey` makes absent keys use the `getX` default not the struct default (config semantics, needs sign-off) | +| 18 | `dataclass` ring-buffer over-engineered | `data_utils.cpp:142` wrap path likely dead; inverted `length`/`_length` | ⏸ deferred (out of scope) | +| 19 | `hash()` dispatch silent-collision risk | `do_command.h:20` | ⏸ optional — `strcmp`/`string_view` table | +| 20 | `c > 127` mode-switch glitch-sensitive | `ambit-1.ino:164` | ▶ Step 8 — framed sync / first-printable-char (text path) | + +[CommunicationProtocolOpenJIISerial.md]: ../CommunicationProtocolOpenJIISerial.md +[uart_sensors.c]: ../ambyte-iot-ludo/components/uart_sensors/uart_sensors.c +[ambit_protocol.h]: ../ambyte-iot-ludo/components/device_commands/include/ambit_protocol.h +[device_commands.c]: ../ambyte-iot-ludo/components/device_commands/device_commands.c +[do_command.h]: src/do_command.h +[run_esp.cpp]: src/run_esp.cpp +[commands.cpp]: ../fw_appCompatible/src/commands.cpp +[PAM.cpp]: src/PAM.cpp +[data_utils.h]: src/data_utils.h +[data_utils.cpp]: src/data_utils.cpp +[config.h]: src/config.h +[ambit-1.ino]: src/ambit-1.ino +[core.cpp]: src/core.cpp +[core.h]: src/core.h diff --git a/include/README b/include/README new file mode 100644 index 0000000..49819c0 --- /dev/null +++ b/include/README @@ -0,0 +1,37 @@ + +This directory is intended for project header files. + +A header file is a file containing C declarations and macro definitions +to be shared between several project source files. You request the use of a +header file in your project source file (C, C++, etc) located in `src` folder +by including it, with the C preprocessing directive `#include'. + +```src/main.c + +#include "header.h" + +int main (void) +{ + ... +} +``` + +Including a header file produces the same results as copying the header file +into each source file that needs it. Such copying would be time-consuming +and error-prone. With a header file, the related declarations appear +in only one place. If they need to be changed, they can be changed in one +place, and programs that include the header file will automatically use the +new version when next recompiled. The header file eliminates the labor of +finding and changing all the copies as well as the risk that a failure to +find one copy will result in inconsistencies within a program. + +In C, the convention is to give header files names that end with `.h'. + +Read more about using header files in official GCC documentation: + +* Include Syntax +* Include Operation +* Once-Only Headers +* Computed Includes + +https://gcc.gnu.org/onlinedocs/cpp/Header-Files.html diff --git a/lib/README b/lib/README new file mode 100644 index 0000000..9379397 --- /dev/null +++ b/lib/README @@ -0,0 +1,46 @@ + +This directory is intended for project specific (private) libraries. +PlatformIO will compile them to static libraries and link into the executable file. + +The source code of each library should be placed in a separate directory +("lib/your_library_name/[Code]"). + +For example, see the structure of the following example libraries `Foo` and `Bar`: + +|--lib +| | +| |--Bar +| | |--docs +| | |--examples +| | |--src +| | |- Bar.c +| | |- Bar.h +| | |- library.json (optional. for custom build options, etc) https://docs.platformio.org/page/librarymanager/config.html +| | +| |--Foo +| | |- Foo.c +| | |- Foo.h +| | +| |- README --> THIS FILE +| +|- platformio.ini +|--src + |- main.c + +Example contents of `src/main.c` using Foo and Bar: +``` +#include +#include + +int main (void) +{ + ... +} + +``` + +The PlatformIO Library Dependency Finder will find automatically dependent +libraries by scanning project source files. + +More information about PlatformIO Library Dependency Finder +- https://docs.platformio.org/page/librarymanager/ldf.html diff --git a/lib/openjii_proto/openjii_proto.cpp b/lib/openjii_proto/openjii_proto.cpp new file mode 100644 index 0000000..94b9062 --- /dev/null +++ b/lib/openjii_proto/openjii_proto.cpp @@ -0,0 +1,292 @@ +// openjii_proto implementation — see openjii_proto.h and +// CommunicationProtocolOpenJIISerial.md. Gated on VARIANT_CLOUD. +#ifdef VARIANT_CLOUD + +#include "openjii_proto.h" +#include + +namespace ojii { +namespace { + +constexpr const char* FRAME_TOKEN = "7A1E3AA1"; // §7.2 (reserved for a checksum) +constexpr size_t RX_MAX = 2048; // §4 +constexpr uint32_t JSON_IDLE_MS = 1000; // §4 +constexpr size_t MAX_CMDS = 48; + +struct Entry { const char* name; SnapshotFn fn; }; +Entry s_cmds[MAX_CMDS]; +size_t s_ncmds = 0; +struct SEntry { const char* name; StreamFn fn; }; +SEntry s_streams[MAX_CMDS]; +size_t s_nstreams = 0; +Identity s_id = { "device", "0", 0.0f }; + +// receiver state +String s_rx; +enum class Mode { UNKNOWN, LINE, JSON }; +Mode s_mode = Mode::UNKNOWN; +int s_brace = 0, s_bracket = 0; +bool s_inStr = false; +char s_prev = 0; +uint32_t s_last_byte_ms = 0; + +void reset_rx() { + s_rx = ""; + s_mode = Mode::UNKNOWN; + s_brace = 0; s_bracket = 0; s_inStr = false; s_prev = 0; +} + +SnapshotFn find(const String& name) { + for (size_t i = 0; i < s_ncmds; i++) + if (name == s_cmds[i].name) return s_cmds[i].fn; + return nullptr; +} + +StreamFn find_stream(const String& name) { + for (size_t i = 0; i < s_nstreams; i++) + if (name == s_streams[i].name) return s_streams[i].fn; + return nullptr; +} + +// Split a label into command name + comma-args ("set_currents,1,2,3" -> "set_currents","1,2,3"). +void split_label(const String& label, String& cmd, String& args) { + int comma = label.indexOf(','); + if (comma < 0) { cmd = label; args = ""; } + else { cmd = label.substring(0, comma); args = label.substring(comma + 1); } +} + +// ── errors (§9) ───────────────────────────────────────────────────────────── +void err(Print& out, const char* code, const char* k1 = nullptr, const String& v1 = String(), + const char* k2 = nullptr, const String& v2 = String()) { + out.print("{\"error\":\""); out.print(code); out.print('"'); + if (k1) { out.print(",\""); out.print(k1); out.print("\":\""); out.print(v1); out.print('"'); } + if (k2) { out.print(",\""); out.print(k2); out.print("\":\""); out.print(v2); out.print('"'); } + out.print("}\n"); +} + +// ── serialisers (§5.2 / §11) ──────────────────────────────────────────────── +bool bare_string_ok(const char* s) { + // A bare LINE string must not contain '\n' or edge whitespace (§8). + size_t n = strlen(s); + if (n == 0) return true; + if (s[0] == ' ' || s[n - 1] == ' ') return false; + for (size_t i = 0; i < n; i++) if (s[i] == '\n' || s[i] == '\r') return false; + return true; +} + +// LINE serialiser: scalar -> bare, container -> strict JSON. No trailing newline. +void render_line_node(JsonVariantConst node, Print& out) { + if (node.is() || node.is()) { + serializeJson(node, out); + } else if (node.is()) { + const char* s = node.as(); + if (bare_string_ok(s)) out.print(s); // bare (unquoted) + else serializeJson(node, out); // fall back to quoted JSON string + } else { + serializeJson(node, out); // number / bool / null -> bare + } +} + +// ── path resolver (§6) ────────────────────────────────────────────────────── +// Resolve `path` against `root`, render the result (LINE) or a §9 error. +// `full` is the whole request line (echoed in error "path"). +void resolve_and_render(JsonVariantConst root, const String& path, const String& full, Print& out) { + JsonVariantConst node = root; + int start = 0; + while (true) { + int dot = path.indexOf('.', start); + String seg = (dot < 0) ? path.substring(start) : path.substring(start, dot); + + // trailing method, e.g. keys() + if (seg.endsWith("()")) { + String method = seg.substring(0, seg.length() - 2); + if (method == "keys") { + if (!node.is()) { err(out, "not_a_container", "path", full, "at", seg); return; } + JsonDocument tmp; JsonArray arr = tmp.to(); + for (JsonPairConst kv : node.as()) arr.add(kv.key().c_str()); + serializeJson(tmp, out); out.print('\n'); return; + } + err(out, "bad_path", "path", full); return; + } + + if (node.is()) { + JsonObjectConst obj = node.as(); + JsonVariantConst child = obj[seg]; + if (child.isNull()) { // absent key (present-null is not used in payloads) + // build the available-keys list + String avail = "["; + bool f = true; + for (JsonPairConst kv : obj) { if (!f) avail += ','; avail += '"'; avail += kv.key().c_str(); avail += '"'; f = false; } + avail += ']'; + out.print("{\"error\":\"no_such_key\",\"path\":\""); out.print(full); + out.print("\",\"at\":\""); out.print(seg); + out.print("\",\"available\":"); out.print(avail); out.print("}\n"); + return; + } + node = child; + } else if (node.is()) { + // segment must be a non-negative index + bool numeric = seg.length() > 0; + for (size_t i = 0; i < seg.length(); i++) if (!isdigit((unsigned char)seg[i])) numeric = false; + JsonArrayConst arr = node.as(); + long idx = numeric ? seg.toInt() : -1; + if (!numeric || idx < 0 || (size_t)idx >= arr.size()) { err(out, "index_out_of_range", "path", full, "at", seg); return; } + node = arr[idx]; + } else { + // scalar — cannot descend + err(out, "not_a_container", "path", full, "at", seg); return; + } + + if (dot < 0) break; + start = dot + 1; + } + render_line_node(node, out); + out.print('\n'); +} + +// ── LINE dispatch (§5) ────────────────────────────────────────────────────── +void handle_line(const String& line, Print& out) { + int dot = line.indexOf('.'); + if (dot >= 0) { // query form: cmd.path + String cmd = line.substring(0, dot); + SnapshotFn fn = find(cmd); + if (!fn) { err(out, "unknown_command", "path", line); return; } + JsonDocument doc; JsonVariant root = doc.to(); + fn("", root); + resolve_and_render(doc.as(), line.substring(dot + 1), line, out); + } else { // action form: cmd[,args] + int comma = line.indexOf(','); + String cmd = (comma < 0) ? line : line.substring(0, comma); + String args = (comma < 0) ? String("") : line.substring(comma + 1); + StreamFn sfn = find_stream(cmd); + if (sfn) { sfn(args, out); out.print('\n'); return; } + SnapshotFn fn = find(cmd); + if (!fn) { err(out, "unknown_command", "path", line); return; } + JsonDocument doc; JsonVariant root = doc.to(); + fn(args, root); + render_line_node(doc.as(), out); out.print('\n'); + } +} + +// ── JSON envelope (§7) ────────────────────────────────────────────────────── +// Find the command list: _protocol_set_, an array of {set:[...]}, a bare array, +// or the first array-valued member of an object (§7.1, lenient). +JsonArrayConst extract_list(JsonVariantConst req) { + if (req["_protocol_set_"].is()) return req["_protocol_set_"].as(); + if (req.is()) { + JsonArrayConst arr = req.as(); + for (JsonObjectConst o : arr) if (o["set"].is()) return o["set"].as(); + return arr; // bare array used directly + } + if (req.is()) + for (JsonPairConst kv : req.as()) + if (kv.value().is()) return kv.value().as(); + return JsonArrayConst(); +} + +// Emit one command's payload as strict JSON (one flat `set` element, §7.2). +void emit_payload_json(const String& label, Print& out) { + String cmd, args; split_label(label, cmd, args); + StreamFn sfn = find_stream(cmd); + if (sfn) { sfn(args, out); return; } // measurement writes its own JSON value + SnapshotFn fn = find(cmd); + if (!fn) { out.print("{\"error\":\"unknown_command\",\"path\":\""); out.print(label); out.print("\"}"); return; } + JsonDocument doc; JsonVariant root = doc.to(); + fn(args, root); + serializeJson(doc, out); // strict JSON, all strings quoted +} + +void handle_json(const String& doc_str, Print& out) { + JsonDocument req; + DeserializationError e = deserializeJson(req, doc_str); + if (e) { err(out, "json_parse", "detail", e.c_str()); return; } + + JsonArrayConst list = extract_list(req); + + out.print("{\"device_name\":\""); out.print(s_id.device); + out.print("\",\"device_version\":\""); out.print(s_id.version); + out.print("\",\"device_battery\":0,\"device_firmware\":"); out.print(s_id.firmware, 3); + out.print(",\"sample\":[{\"protocol_id\":\"NaN\",\"set\":["); + bool first = true; + for (JsonObjectConst entry : list) { + const char* label = entry["label"]; + if (!label) continue; // §7.1 entries without a label are skipped + uint16_t repeats = entry["protocol_repeats"] | 1; + if (repeats == 0) repeats = 1; + for (uint16_t r = 0; r < repeats; r++) { // flat: N consecutive elements (§7.2) + if (!first) out.print(','); + first = false; + emit_payload_json(String(label), out); + } + } + out.print("]}]}"); out.print(FRAME_TOKEN); out.print('\n'); +} + +} // namespace + +// ── public API ────────────────────────────────────────────────────────────── +void on(const char* name, SnapshotFn fn) { + if (s_ncmds < MAX_CMDS) s_cmds[s_ncmds++] = { name, fn }; +} + +void on_stream(const char* name, StreamFn fn) { + if (s_nstreams < MAX_CMDS) s_streams[s_nstreams++] = { name, fn }; +} + +void identity(const Identity& id) { s_id = id; } + +void poll(Stream& io) { + while (io.available() > 0) { + char c = (char)io.read(); + if (c == '\r') continue; // §4: CR ignored + + if (s_mode == Mode::UNKNOWN) { + // drop leading framing/boot junk before a mode is locked + unsigned char uc = (unsigned char)c; + bool printable = (uc >= 0x20 && uc < 0x7F); + if (!printable && c != '\n') continue; + } + + s_rx += c; + s_last_byte_ms = millis(); + + if (s_mode == Mode::UNKNOWN) { // §4: first non-ws byte selects mode + int i = 0; + while (i < (int)s_rx.length() && isspace((unsigned char)s_rx[i])) i++; + if (i < (int)s_rx.length()) + s_mode = (s_rx[i] == '{' || s_rx[i] == '[') ? Mode::JSON : Mode::LINE; + } + + if (s_mode == Mode::LINE) { + if (c == '\n') { + s_rx.trim(); + if (s_rx.length() > 0) { handle_line(s_rx, io); io.flush(); } // empty line -> no response (§4) + reset_rx(); + } + } else if (s_mode == Mode::JSON) { // string-aware brace/bracket depth + if (c == '"' && s_prev != '\\') s_inStr = !s_inStr; + if (!s_inStr) { + if (c == '{') s_brace++; else if (c == '}') s_brace--; + else if (c == '[') s_bracket++; else if (c == ']') s_bracket--; + } + s_prev = c; + if (!s_inStr && s_brace == 0 && s_bracket == 0) { + s_rx.trim(); + if (s_rx.length() > 0) { handle_json(s_rx, io); io.flush(); } + reset_rx(); + } + } + + if (s_rx.length() > RX_MAX) { io.print("{\"error\":\"rx_overflow\"}\n"); reset_rx(); } + } + + // §4: incomplete JSON idle > 1 s + if (s_mode == Mode::JSON && s_rx.length() > 0 && (millis() - s_last_byte_ms) > JSON_IDLE_MS) { + io.print("{\"error\":\"json_timeout\"}\n"); + reset_rx(); + } +} + +} // namespace ojii + +#endif // VARIANT_CLOUD diff --git a/lib/openjii_proto/openjii_proto.h b/lib/openjii_proto/openjii_proto.h new file mode 100644 index 0000000..9cfeb80 --- /dev/null +++ b/lib/openjii_proto/openjii_proto.h @@ -0,0 +1,53 @@ +// openjii_proto — device-agnostic openJII serial protocol (LINE + JSON envelope). +// +// Implements CommunicationProtocolOpenJIISerial.md: first-byte mode detection, +// LINE mode (bare scalars / JSON containers, dot-path queries, keys()), and the +// JSON "openJII envelope" (flat `set`, frame token), with the §9 error taxonomy. +// +// A device registers per-command SNAPSHOT handlers that build a value tree +// (command-as-root); the framework owns the serializers, the path resolver, the +// envelope writer, and the receiver. Measurement/STREAM commands (one streamed +// JSON value per envelope position) are a separate API added once D6 is settled. +// +// Whole module is gated on VARIANT_CLOUD so the ambyte image links no JSON. +#pragma once +#ifdef VARIANT_CLOUD + +#include +#include + +namespace ojii { + +// Snapshot handler: populate `root` as this command's command-as-root payload +// (§2.1). `args` is the comma-separated remainder after the command name +// ("set_currents,1,2,3" -> "1,2,3"; "" if none). On error set root["error"] +// to a §9 code (the framework still serialises whatever the handler produced). +using SnapshotFn = void (*)(const String& args, JsonVariant root); + +// Stream/measurement handler: write ONE well-formed JSON value directly to `out` +// (for commands whose output is too large to buffer as a tree, e.g. a run). In an +// envelope it occupies one `set` slot; in LINE mode it is the bare response. +using StreamFn = void (*)(const String& args, Print& out); + +struct Identity { + const char* device; // e.g. "Ambit" -> hello.device, envelope device_name + const char* version; // e.g. "0.0.3" + float firmware; // e.g. 0.003f -> envelope device_firmware +}; + +// Register a snapshot command (name is matched case-sensitively). +void on(const char* name, SnapshotFn fn); + +// Register a stream/measurement command. +void on_stream(const char* name, StreamFn fn); + +// Set device identity used by the envelope header and the built-in hello. +void identity(const Identity& id); + +// Drive the protocol: consume available bytes from `io`, and when a full request +// is framed, dispatch it and write the response to `io`. Call every loop(). +void poll(Stream& io); + +} // namespace ojii + +#endif // VARIANT_CLOUD diff --git a/platformio.ini b/platformio.ini new file mode 100644 index 0000000..251f088 --- /dev/null +++ b/platformio.ini @@ -0,0 +1,45 @@ +; PlatformIO Project Configuration File +; https://docs.platformio.org/page/projectconf.html + +[platformio] +; Build OUTSIDE the Documents tree. That folder is OneDrive-synced / AV-scanned, +; which blocks fresh creation of .pio/build sub-dirs and makes the compiler fail with +; "opening dependency file <...>.cpp.d: No such file or directory" on a clean build. +; LOCALAPPDATA is local-only (and, unlike TEMP, not auto-cleaned). +build_dir = ${sysenv.LOCALAPPDATA}/pio_build/ambit_fw_new +default_envs = ambyte + +; ── shared base ───────────────────────────────────────────────────────────── +[env] +platform = espressif32 +board = esp32-c3-devkitm-1 +framework = arduino +monitor_speed = 115200 +; Pin the dual-OTA partition layout explicitly. This is the Arduino-ESP32 4 MB +; default (otadata + ota_0/ota_1 1.25 MB each + spiffs) the board was already +; using implicitly — naming it guarantees a future build can't silently switch +; to a single-app scheme and break OTA. SAME layout = no NVS shift, so the +; one-time bootstrap reflash preserves calibration. VERIFY a fielded unit's +; table matches before reflashing it (esptool read_flash 0x8000 0xc00). +board_build.partitions = default.csv +; ArduinoJson is header-only: it is in the shared deps so the dependency finder +; resolves it across the #ifdef VARIANT_CLOUD guards, but it instantiates no code +; in the ambyte image (nothing there includes it). +lib_deps = + adafruit/Adafruit BusIO + bblanchon/ArduinoJson@^7 + +; ── Field variant: binary FSM over UART0/FFC to the ambyte (HW-verified) ───── +[env:ambyte] +build_flags = + -DARDUINO_USB_CDC_ON_BOOT=0 ; Serial -> UART0 (GPIO20 RX / 21 TX), FFC to the ambyte + -DVARIANT_AMBYTE=1 + +; ── App variant: openJII LINE + JSON (CommunicationProtocolOpenJIISerial.md). +; This test HW has no native USB-C, so Serial is UART0 (GPIO20/21) — same wire as +; ambyte, just the LINE/JSON protocol. (For a future PCB with native USB, swap to +; ARDUINO_USB_MODE=1 / ARDUINO_USB_CDC_ON_BOOT=1 + USB_VID/PID/MANUFACTURER/PRODUCT.) +[env:cloud] +build_flags = + -DARDUINO_USB_CDC_ON_BOOT=0 ; Serial -> UART0 (GPIO20 RX / 21 TX) + -DVARIANT_CLOUD=1 diff --git a/src/.gitignore b/src/.gitignore new file mode 100644 index 0000000..9fe751a --- /dev/null +++ b/src/.gitignore @@ -0,0 +1,2 @@ +.vscode/c_cpp_properties.json +.upload.bat \ No newline at end of file diff --git a/src/PAM.cpp b/src/PAM.cpp new file mode 100644 index 0000000..c94ccd1 --- /dev/null +++ b/src/PAM.cpp @@ -0,0 +1,1534 @@ +#include "PAM.h" + +static const char* TAG = "PAM"; +static bool measure_temp = true; +static bool PAM_interrupt(bool, bool); + +uint8_t adpd_mode = 0; +adpd_current_config_t adpd_current_config; +adpd_gains_config_t adpd_gains_config; + + +int serial_read_until(uint8_t target1, uint8_t target2 = 0, uint8_t target3 = 0, uint16_t timeout = 20, bool remove = false); + +// use pre-set values +int conf_slow_FR_1(void){ + + if (adpd_gains_config.init == false) ESP_LOGE(TAG, "Gain preset not initized, use default!"); + if (adpd_current_config.init == false) ESP_LOGE(TAG, "Current preset not initized, use default!"); + return conf_slow_FR_1(adpd_current_config.I620, adpd_current_config.I720, adpd_current_config.IR, adpd_gains_config.Fluo, adpd_gains_config.FluoRef, adpd_gains_config.Sun, adpd_gains_config.Leaf, adpd_gains_config.IR, adpd_gains_config.IRRef); +} + + +// Slow measurements with 4 time slots +// @param I620 measuring light current (0 - 127) +// @param I730 IR reflection current (0 - 127) +// @param I_FR Far-red treatment current (0 - 127) +// @param G_Fluor fluorescence signal gain (0 - 5) +// @param G_FluorRef fluorescence rerefence gain (0 - 5) +// @param G_Sun Sun facing PD gain (0 - 5) +// @param G_IR Leaf facing PD gain (0 - 5) +// @param G_FR IR reflection signal gain (0 - 5) +// @param G_FRref IR reflection reference gain (0 - 5) +int conf_slow_FR_1(uint8_t I620, uint8_t I730, uint8_t I_FR, uint8_t G_Fluor, uint8_t G_FluorRef, uint8_t G_Sun, uint8_t G_IR, uint8_t G_FR, uint8_t G_FRref){ + + // Setup timeslot 1: two ambient light channels, 2 x 3 bytes + adpd.led_config.driver1_current = 0; + adpd.led_config.driver2_current = 0; + adpd.SNR_config.TIA_gain_CH2 = G_IR; // channel 2: leaf IR reflection + adpd.SNR_config.TIA_gain_CH1 = G_Sun; // channel 1: sun vis + adpd.preset_config_1(0, 4); + + + + // Setup timeslot 2: Fluor and Ref channels, 4 x 3 bytes + // LED 1A = 620nm + adpd.led_config.driver1_current = I620; + adpd.led_config.led1_channel = LED_A; + // LED 2A = 730nm + adpd.led_config.driver2_current = 0; + adpd.led_config.led2_channel = LED_A; + adpd.SNR_config.TIA_gain_CH1 = G_Fluor; + adpd.SNR_config.TIA_gain_CH2 = G_FluorRef; + adpd.preset_config_2(1, 1); + + + // Setup timeslot 3: IR leave reflection, 2 x 3 bytes + // LED 1A = 620nm + adpd.led_config.driver1_current = 0; + adpd.led_config.led1_channel = LED_A; + // LED 2A = 730nm + adpd.led_config.driver2_current = I730; + adpd.led_config.led2_channel = LED_A; + adpd.SNR_config.TIA_gain_CH1 = G_FR; + adpd.SNR_config.TIA_gain_CH2 = G_FRref; + + adpd.preset_config_3(2, 4); + + // Setup timeslot 4-5-6: Far-red illumination, 0 data + // LED 1A = 620nm + adpd.led_config.driver1_current = 0; + adpd.led_config.led1_channel = LED_A; + // LED 2A = 730nm + adpd.led_config.driver2_current = I_FR; + adpd.led_config.led2_channel = LED_A; + + //make 6 time slots, ~ 2 ms without repeats, can get 200 repeats ~ 400ms + adpd.preset_config_4(3); + adpd.preset_config_4(4); + adpd.preset_config_4(5); + adpd.preset_config_4(6); + adpd.preset_config_4(7); + adpd.preset_config_4(8); + + adpd_mode = ADPD_CONFIG_MODE::ARRAY_MODE1; + + return 0; +} + + +uint32_t arr_line_parse_type1(uint8_t* line, uint8_t* num1, uint16_t* num2, uint16_t* num3, uint8_t* num4, uint8_t* num5, uint16_t* data_count){ + // type 1: Must have measurements: Fluor/Ref + // optional measurements: leaf IR, sun VIs, Reflect/Ref + // 0 = no points, 1 = same freq, 2 = every 8 + // data_count 0: fluor, 1: ambient, 2: reflection + uint8_t type = line[0]; // run type 1 = steady state, 0 = skip, 2 = no ir + *num1 = line[1]; // FR on / off + *num2 = line[3] + (line[2] << 8); // sample number + *num3 = line[5] + (line[4] << 8); // frequency + *num4 = line[6]; // actinic + *num5 = line[7]; // sub-sampling factor + + if (data_count == NULL) return 0; + + if ((type == 1) || (type == 2)){ + data_count[0] = *num2; + if (line[7] == 0){ // no ambient + data_count[1] = 0; + data_count[2] = 0; + }else if (line[7] == 1){ // every + data_count[1] = *num2; + data_count[2] = *num2; + }else if (line[7] == 2){ // every 8 + data_count[1] = (*num2) / 8; + data_count[2] = (*num2) / 8; + }else{ + data_count[1] = 0; + data_count[2] = 0; + } + if (type == 2) data_count[2] = 0; + + return data_count[0] * 2 + data_count[1] * 2 + data_count[2] * 2; + + } + return 0; +} + + + +int run_preprocess_type1(uint8_t length, uint8_t* arr, uint16_t* data_counter){ + uint8_t pc = 0; + uint8_t _type = 0; + uint8_t para1, actinic, subsampling = 0; + uint16_t num_ptx = 0, freq = 0; + uint16_t _data_counter[4] = {0}; + + while (pc < length){ + _type = *(arr + pc * 8); + if ((_type == 1) || (_type == 2)){ + arr_line_parse_type1(arr + pc * 8, ¶1, &num_ptx, &freq, &actinic, &subsampling, _data_counter); + ESP_LOGV(TAG, "Run type:%d, number:%d, freq: %d, actinic: %d, subfactor %d", _type, num_ptx, freq, actinic, subsampling); + for (uint8_t i = 0; i < 4; i++) data_counter[i] += _data_counter[i]; + } + pc += 1; + } + return 0; +} + +// Shared output sink for a completed run: stream the 7 channel buffers over the +// active CONNECTION_TYPE. COMPUTER -> ASCII send_serial; AMBYTE -> binary FSM +// (env retried once; sun/leaf/730 only when present). Extracted verbatim from the +// per-run send block so every run path (sweep #4) shares one copy. Wire-touching: +// re-run HW_CONFORMANCE.md after changing it. +static void pam_send_results(dataclass* d_env, dataclass* d_fluor, dataclass* d_fluoRef, + dataclass* d_sun, dataclass* d_leaf, dataclass* d_730, + dataclass* d_730Ref, dataclass* d_timing, uint8_t subsampling, + bool has_730, bool allow_interrupt){ + if (CONNECTION_TYPE == CONNECTION_TYPES::COMPUTER){ + d_env->send_serial("env"); + d_fluor->send_serial("s_fluo"); + d_fluoRef->send_serial("r_fluo"); + d_sun->send_serial("sun"); + d_leaf->send_serial("leaf"); + d_730->send_serial("s_730"); + d_730Ref->send_serial("r_730"); + if (d_timing != NULL) d_timing->send_serial("timing"); + + Serial.println("Data sent"); + }else if(CONNECTION_TYPE == CONNECTION_TYPES::AMBYTE){ + // Change 4: one wake per run, then every array streams back-to-back as + // (length header + data + trailer); run_esp.cpp's trailing ESP_CMD_END (240) + // terminates the stream. If the ambyte never wakes, there is nothing to send. + if (ambyte_wake(allow_interrupt) != 1) return; + + // Per-array element width / dtype (Change 1 self-describing header, Change 2 widths): + // ENV -> int16 centi-degC (elem_width 2, dtype 1) + // ADC ch -> uint16 (16-bit ADPD regs) (elem_width 2, dtype 0, clamped to 0xFFFF) + // TIMING -> uint32 ticks (elem_width 4, dtype 0) + d_env->fsm_send_array(0, 2, 1); + d_fluor->fsm_send_array(1, 2, 0); + d_fluoRef->fsm_send_array(2, 2, 0); + if (subsampling > 0){ + d_sun->fsm_send_array(3, 2, 0); + d_leaf->fsm_send_array(4, 2, 0); + if (has_730){ + d_730->fsm_send_array(5, 2, 0); + d_730Ref->fsm_send_array(6, 2, 0); + } + } + if (d_timing != NULL) d_timing->fsm_send_array(7, 4, 0); // Change 3: TIMING block + } +} + +int run_arr_type1(uint8_t length, uint8_t* arr, bool led_persist){ + return run_arr_type1(length, arr, led_persist, false); +} + +// ── Async result holder (parallel trigger/poll/fetch protocol) ────────────── +// Holds the eight result buffers of one retained run plus the metadata +// pam_send_results() needs, until the host FETCHes them. One run at a time. +struct ambit_async_result_t { + dataclass *d_env = NULL, *d_fluor = NULL, *d_fluoRef = NULL, *d_sun = NULL, + *d_leaf = NULL, *d_730 = NULL, *d_730Ref = NULL, *d_timing = NULL; + uint8_t subsampling = 0; + bool has_730 = false; + bool allow_interrupt = false; + uint8_t state = AMBIT_ASYNC_IDLE; +}; +static ambit_async_result_t g_async; + +void ambit_async_clear(void){ + delete g_async.d_env; delete g_async.d_fluor; delete g_async.d_fluoRef; + delete g_async.d_sun; delete g_async.d_leaf; delete g_async.d_730; + delete g_async.d_730Ref; delete g_async.d_timing; + g_async = ambit_async_result_t(); // re-init all pointers to NULL, state IDLE +} + +uint8_t ambit_async_get_state(void){ return g_async.state; } + + +#ifdef VARIANT_CLOUD +// Cloud/openJII env channel: fw_new stores leaf temp as centi-degC in the low 16 bits. +static void send_env_json(dataclass* d){ + Serial.print("\"env\":["); + if (d->available){ + uint16_t n = d->get_length(); + for (uint16_t i = 0; i < n; i++){ + uint32_t raw = d->pop(); + float temp = (int16_t)(raw & 0xFFFF) / 100.0f; + if (i > 0) Serial.print(','); + Serial.printf("{\"temp_c\":%.2f}", temp); + } + } + Serial.print(']'); +} +#endif + +int run_arr_type1(uint8_t length, uint8_t* arr, bool led_persist, bool allow_interrupt, bool json_output, bool retain){ + (void) json_output; + + if (adpd_mode != ADPD_CONFIG_MODE::ARRAY_MODE1){ + conf_slow_FR_1(); + ESP_LOGW(TAG, "Run array was not configured!"); + } + // set to max possible bytes + uint8_t expected_readout = 8; + uint8_t expected_readout_bytes = expected_readout * 3; + const uint8_t num_integration = 1; + const unsigned int start_t0 = millis(); + const int64_t run_tick_begin = esp_timer_get_time(); // Change 3: TIMING - us at run start + + // Run protocol preprecess, get storage size + uint16_t data_count[] = {0, 0, 0, 0}; + if (run_preprocess_type1(length, arr, data_count) == -1) return -1; // calculate data counts + ESP_LOGV(TAG, "Sample & Ref: %d, optionals: %d", data_count[0], data_count[1]); + + dataclass *d_env = new dataclass; // + dataclass *d_fluor = new dataclass; // fluorescence signal + dataclass *d_fluoRef = new dataclass; // fluorescence reference + + dataclass *d_sun = new dataclass; // sun-side ambient + dataclass *d_leaf = new dataclass; // leaf-side ambient + dataclass *d_730 = new dataclass; // 730nm reflectance signal + dataclass *d_730Ref = new dataclass; // 730nm reference + dataclass *d_timing = new dataclass; // Change 3: [tick_begin, tick_end] controller ticks (us) + + + if (!(d_env->init(512))) return -1; + if (!(d_timing->init(2))) return -1; + if (!( (d_fluor->init(data_count[0])) && (d_fluoRef->init(data_count[0])) )) return -1; + if (data_count[1] > 0){ + if (!( (d_sun->init(data_count[1])) && (d_leaf->init(data_count[1])) )) return -1;} + if (data_count[2] > 0){ + if (!( (d_730->init(data_count[2])) && (d_730Ref->init(data_count[2])) )) return -1; + } + + + ESP_LOGV(TAG, "Memory allocation completed"); + + + // variables for each trace + uint8_t pc = 0; + uint8_t _type = 0; + uint8_t farred = 0, actinic = 0, subsampling = 0; + uint16_t num_ptx = 0, freq = 0; + + // data counter and buffer + // [sun-amb, leaf-ir, lit_leaf-ir, dark_leaf-ir, lit_leaf-ref, dark_leaf-ref] + uint32_t ret[expected_readout] = {0}; + uint32_t counter = 0, ploter1 = 0, ploter2 = 0; + uint16_t fifo_c = 0; + uint8_t watch_dog_timer = 0; + int32_t tmp_var = 0; + uint32_t buf_opt[4] = {0}; + uint32_t _tmparr = 0; + uint8_t _repeats = 1; + uint32_t light_sleep_time = 1; + float_t leaf_temp = 0.0; + unsigned int env_timer1 = millis(); + bool measure_temperature = false; + bool interrupt_run = false; + + _tmparr = PAM_get_env(4, start_t0); + d_env->put(_tmparr); + leaf_temp = (int16_t) (_tmparr & 0xFFFF) / 100.0; + + + adpd.STOP(); + while (pc < length){ + if (interrupt_run) break; + _type = *(arr + pc * 8); //get line type + if ((_type == 1) || (_type == 2)){ // all channels + arr_line_parse_type1((arr + pc * 8), &farred, &num_ptx, &freq, &actinic, &subsampling, NULL); + adpd.run_freq(freq); + adpd.clear_fifo(); + light_sleep_time = (1000/freq); + measure_temperature = (light_sleep_time > 20) && measure_temp && actinic < 50; + + + if (_type == 1){ // use IR reflect + if (farred == 1){ // whether use actinic IR + adpd.num_ts(9); + _repeats = int(400/freq); + if (freq < 3) _repeats = 250; + if (_repeats == 0) _repeats = 1; + for (uint8_t i = 3; i < 9;i++) adpd.repeats_only(i, 1, _repeats); + } + else{ + adpd.num_ts(3); + } + expected_readout = 8; + expected_readout_bytes = expected_readout * 3; + }else{ // NO IR + adpd.num_ts(2); + expected_readout = 6; + expected_readout_bytes = expected_readout * 3; + } + + if (actinic > 3){ + AS_LED_Current(actinic); + AS_LED_ON(); + }else{ + AS_LED_OFF(); + AS_LED_Current(0); + } + + + counter = 0; + for (uint8_t i = 0; i < 4; i++) buf_opt[i] = 0; + adpd.RUN(); + delay(2); + while (counter < num_ptx){ + if (interrupt_run) break; + fifo_c = adpd.fifo_count(); + while (fifo_c >= expected_readout_bytes){ // read all bytes from FIFO + adpd.readfifo(expected_readout, 3, ret); + fifo_c -= expected_readout_bytes; + if (counter == num_ptx) break; + // 0: sun-vis; 1: leaf-ir; 2: fluoS_dark; 3: fluoS_lit; 4: fluoR_dark; 5: fluoR_lit; 6: Reflect_signal; 7: reflect_ref + // save fluor signal and ref + d_fluor->put(calc_signal(ret[2], ret[3], num_integration)); + d_fluoRef->put(calc_signal(ret[4], ret[5], num_integration)); + + + // save option data + if (subsampling > 0){ + if (subsampling == 1){ // every point + d_sun->put(ret[0] > 65000 ? ret[0] - 65000 : 0); + d_leaf->put(ret[1] > 65000 ? ret[1] - 65000 : 0); + if (_type == 1){d_730->put(ret[6]);d_730Ref->put(ret[7]);} // ir enabled + + }else if (subsampling == 2){ + buf_opt[0] += (ret[0] > 65000 ? ret[0] - 65000 : 0); + buf_opt[1] += (ret[1] > 65000 ? ret[1] - 65000 : 0); + if (_type == 1){ + buf_opt[2] += ret[6]; + buf_opt[3] += ret[7]; + } + + if (counter % 8 == 7){ + d_sun->put(buf_opt[0]/8); + d_leaf->put(buf_opt[1]/8); + if(_type == 1){d_730->put(buf_opt[2]/8);d_730Ref->put(buf_opt[3]/8);} + for (uint8_t i = 0; i < 4; i++) buf_opt[i] = 0; + } + } + } + + if (CONNECTION_TYPE == CONNECTION_TYPES::PLOTTING){ + ploter1 = calc_signal(ret[2], ret[3], num_integration); + ploter2 = calc_signal(ret[4], ret[5], num_integration); + if (ploter2 == 0){ + ploter2 = 1; + ploter1 = 0; + } + if (_type == 1) { + Serial.printf("T:%2.3f,F:%3.4f,S:%d,R:%d,7:%d,7R:%d,Sun:%d,L:%d\n", leaf_temp, (float)ploter1/(float)ploter2, ploter1, ploter2, ret[6], ret[7], ret[0]-65000, ret[1]-65000); + }else if (_type == 2){ + Serial.printf("T:%2.3f,F:%3.4f,S:%d,R:%d,Sun:%d,L:%d\n", leaf_temp, (float)ploter1/(float)ploter2, ploter1, ploter2, ret[0]-65000, ret[1]-65000); } + Serial.flush(); + } + counter++; + watch_dog_timer = 0; + } + + // do light sleep + //esp_sleep_enable_timer_wakeup(1000); + if (counter + 10 < num_ptx){ // a lot of measurements + // do temperature measurement? + if (measure_temperature && (millis() - env_timer1 > 2000)){ + _tmparr = PAM_get_env(4, start_t0); + d_env->put(_tmparr); + leaf_temp = (int16_t) (_tmparr & 0xFFFF) / 100.0; + env_timer1 = millis(); + esp_sleep_enable_timer_wakeup(1000); + } + else esp_sleep_enable_timer_wakeup(light_sleep_time * 8000); + + }else if (counter + 2 < num_ptx){ // not many + esp_sleep_enable_timer_wakeup(light_sleep_time * 1000); + }else{ + esp_sleep_enable_timer_wakeup(1000); + } + // run interrupted by serial input "S" + interrupt_run = PAM_interrupt(allow_interrupt, false); + if (!interrupt_run) esp_light_sleep_start(); + interrupt_run = PAM_interrupt(allow_interrupt, true); + } + + adpd.STOP(); + if (!led_persist) AS_LED_OFF(); + digitalWrite(1, LOW); + } + pc += 1; + } + + if (interrupt_run){ + digitalWrite(STF_FLASH_PIN, LOW); + adpd.STOP(); + AS_LED_OFF(); + }; + + +#ifdef VARIANT_CLOUD + if (json_output) { // one JSON object: {"env":[..],"s_fluo":[..],...} + Serial.print('{'); + send_env_json(d_env); + Serial.print(','); d_fluor->send_json("s_fluo"); + Serial.print(','); d_fluoRef->send_json("r_fluo"); + if (d_sun->available) { Serial.print(','); d_sun->send_json("sun"); } + if (d_leaf->available) { Serial.print(','); d_leaf->send_json("leaf"); } + if (d_730->available) { Serial.print(','); d_730->send_json("s_730"); } + if (d_730Ref->available) { Serial.print(','); d_730Ref->send_json("r_730"); } + Serial.print('}'); + } else +#endif + { + d_timing->put((uint32_t) run_tick_begin); // Change 3: run start tick (us) + d_timing->put((uint32_t) esp_timer_get_time()); // run end tick (us) + if (retain){ + // Parallel protocol: transfer ownership of the buffers to the async holder + // instead of streaming + freeing. The host fetches them later (cmd 24). + g_async.d_env = d_env; g_async.d_fluor = d_fluor; g_async.d_fluoRef = d_fluoRef; + g_async.d_sun = d_sun; g_async.d_leaf = d_leaf; g_async.d_730 = d_730; + g_async.d_730Ref = d_730Ref; g_async.d_timing = d_timing; + g_async.subsampling = subsampling; g_async.has_730 = (data_count[2] > 0); + g_async.allow_interrupt = allow_interrupt; + return 0; // holder owns the buffers now — do NOT delete + } + pam_send_results(d_env, d_fluor, d_fluoRef, d_sun, d_leaf, d_730, d_730Ref, + d_timing, subsampling, data_count[2] > 0, allow_interrupt); + } + + delete d_fluor; + delete d_fluoRef; + delete d_sun; + delete d_leaf; + delete d_730; + delete d_730Ref; + delete d_env; + delete d_timing; + + return 0; + +} + +// ── Async run-start / fetch (parallel trigger/poll/fetch protocol) ────────── +// Blocks to completion (like the synchronous run) but retains the results, so +// the host can trigger every sensor back-to-back and collect them afterwards. +int ambit_async_run_start(uint8_t length, uint8_t* arr, bool led_persist, bool allow_interrupt){ + ambit_async_clear(); // drop any stale, un-fetched result first + int rc = run_arr_type1(length, arr, led_persist, allow_interrupt, false, true /*retain*/); + if (rc == 0 && g_async.d_env != NULL){ + g_async.state = AMBIT_ASYNC_DONE; + } else { + ambit_async_clear(); // partial/failed run — free whatever stuck + g_async.state = AMBIT_ASYNC_ERROR; + } + return rc; +} + +// Stream the retained arrays to the ambyte over the existing AMBYTE FSM, then +// free them. Caller (cmd 24) has already written ESP_CMD_DONE and will write +// ESP_CMD_END after this returns. +int ambit_async_fetch(void){ + if (g_async.state != AMBIT_ASYNC_DONE || g_async.d_env == NULL) return -1; + uint8_t saved = CONNECTION_TYPE; + CONNECTION_TYPE = CONNECTION_TYPES::AMBYTE; + pam_send_results(g_async.d_env, g_async.d_fluor, g_async.d_fluoRef, g_async.d_sun, + g_async.d_leaf, g_async.d_730, g_async.d_730Ref, g_async.d_timing, + g_async.subsampling, g_async.has_730, g_async.allow_interrupt); + CONNECTION_TYPE = saved; + ambit_async_clear(); + return 0; +} + + +void adpd_trigger(void){ + digitalWrite(10, HIGH); + delayMicroseconds(1); + digitalWrite(10, LOW); +} + + + +int run_trigger_spacer(uint16_t length, uint8_t interval, bool change_act, uint8_t act, bool interrrupt){ + + if (length > 3000) return -1; + adpd.STOP(); + + if (adpd_mode != ADPD_CONFIG_MODE::ARRAY_MODE1) conf_slow_FR_1(); + + digitalWrite(10, LOW); + adpd.gpio_config.GPIO0_cfg = 1; + adpd.gpio_config.SYNC_GPIO = 0; + adpd.gpio_config.EXT_SYNC_EN = 1; + adpd.gpio_setup(&(adpd.gpio_config)); + adpd_mode = ADPD_CONFIG_MODE::ARRAY_SLOW; + + gpio_sleep_set_direction(GPIO_NUM_10, GPIO_MODE_OUTPUT); + gpio_sleep_set_pull_mode(GPIO_NUM_10, GPIO_PULLDOWN_ONLY); + + + + // set to max possible bytes + uint8_t expected_readout = 8; + uint8_t expected_readout_bytes = expected_readout * 3; + const uint32_t _wait_time_ms = interval * 100; + const uint8_t num_integration = 1; + const unsigned int start_t0 = millis(); + const int64_t run_tick_begin = esp_timer_get_time(); // Change 3: TIMING - us at run start + + // data counter and buffer + // [sun-amb, leaf-ir, lit_leaf-ir, dark_leaf-ir, lit_leaf-ref, dark_leaf-ref] + uint32_t ret[expected_readout] = {0}; + uint16_t fifo_c = 0; + uint8_t watch_dog_timer = 0; + int32_t tmp_var = 0; + uint32_t buf_opt[4] = {0}; + uint32_t _tmparr = 0; + uint32_t read_fluor, read_fluoRef, read_sun, read_leaf, read_7, read_7Ref; + float_t leaf_temp = 0.0; + + unsigned int env_timer1 = millis(), trigger_timer = 0, expected_millis = 0; + int waiting_time = 0; + bool measure_temperature = false; + bool interrupt_run = false; + esp_sleep_enable_timer_wakeup(90000); + + dataclass *d_env = new dataclass; // + dataclass *d_fluor = new dataclass; // fluorescence signal + dataclass *d_fluoRef = new dataclass; // fluorescence reference + + dataclass *d_sun = new dataclass; // sun-side ambient + dataclass *d_leaf = new dataclass; // leaf-side ambient + dataclass *d_730 = new dataclass; // 730nm reflectance signal + dataclass *d_730Ref = new dataclass; // 730nm reference + dataclass *d_timing = new dataclass; // Change 3: [tick_begin, tick_end] controller ticks (us) + + int _func_ret = -1; + if (!(d_env->init(512))) goto del_classes; + if (!(d_timing->init(2))) goto del_classes; + if (!( (d_fluor->init(length)) && (d_fluoRef->init(length)) )) goto del_classes; + if (!( (d_sun->init(length)) && (d_leaf->init(length)) )) goto del_classes; + if (!( (d_730->init(length)) && (d_730Ref->init(length)) )) goto del_classes; + + + _tmparr = PAM_get_env(4, start_t0); + d_env->put(_tmparr); + leaf_temp = (int16_t) (_tmparr & 0xFFFF) / 100.0; + env_timer1 = millis(); + + + adpd.clear_fifo(); + adpd.run_freq(10); + adpd.num_ts(3); + adpd.RUN(); + delay(5); + + if(change_act){ + if (act == 0) AS_LED_OFF(); + if (act > 0) { + AS_LED_Current(act); + AS_LED_ON(); + } + } + + for (uint16_t n = 0; n < length; n++){ + fifo_c = 0; + adpd_trigger(); + trigger_timer = millis(); + expected_millis = trigger_timer + _wait_time_ms; + delay(1); + while (fifo_c != expected_readout_bytes){ + fifo_c = adpd.fifo_count(); + if (fifo_c >= expected_readout_bytes) break; + if (millis() - trigger_timer > 100) break; + } + if (fifo_c < expected_readout_bytes){ + ESP_LOGE(TAG, "NOT ENOUGH IN FIFO"); + break; + } + adpd.readfifo(expected_readout, 3, ret); + if (fifo_c > expected_readout_bytes){ + adpd.clear_fifo(); + ESP_LOGE(TAG, "Extra %d byte in FIFO", fifo_c - expected_readout_bytes); + } + + read_fluor = calc_signal(ret[2], ret[3], num_integration); d_fluor->put(read_fluor); + read_fluoRef = calc_signal(ret[4], ret[5], num_integration); d_fluoRef->put(read_fluoRef); + read_sun = ret[0]; d_sun->put(read_sun > 65000 ? read_sun - 65000 : 0); + read_leaf = ret[1]; d_leaf->put(read_leaf > 65000 ? read_leaf - 65000 : 0); + read_7 = ret[6]; d_730->put(read_7); + read_7Ref = ret[7]; d_730Ref->put(read_7Ref); + + + if (CONNECTION_TYPE == CONNECTION_TYPES::PLOTTING){ + Serial.printf("T:%2.3f,F:%3.4f,S:%d,R:%d,7:%d,7R:%d,Sun:%d,L:%d\n", leaf_temp, (float)read_fluor/(float)read_fluoRef, read_fluor, read_fluoRef, read_7, read_7Ref, read_sun-65000, read_leaf-65000); + Serial.flush(); + } + + + + if (interrupt_run) break; + if (millis() > expected_millis) continue; // overdue + waiting_time = expected_millis - millis(); + + if ((n % 8 == 7) && (waiting_time > 100)){ + if (millis() - env_timer1 > 2000){ + _tmparr = PAM_get_env(4, start_t0); + d_env->put(_tmparr); + leaf_temp = (int16_t) (_tmparr & 0xFFFF) / 100.0; + env_timer1 = millis(); + } + } + + + + + waiting_time = expected_millis - millis(); + while (waiting_time > 250){ + esp_sleep_enable_timer_wakeup((waiting_time - 50) * 1000); + interrupt_run = PAM_interrupt(interrrupt, false); + if (!interrupt_run) esp_light_sleep_start(); + interrupt_run = PAM_interrupt(interrrupt, true); + if (interrupt_run) break; + waiting_time = expected_millis - millis(); + } + if (interrupt_run) break; + waiting_time = expected_millis - millis(); + if (waiting_time > 1) delay(waiting_time); + } /// End of Loop + + + adpd.STOP(); + adpd.clear_fifo(); + + // Trigger-spacer always produces the full 7-channel set (subsampling=1, has_730=true), + // sent unconditionally. This path never runs as COMPUTER, so pam_send_results' COMPUTER + // branch is inert here; the AMBYTE branch is identical to the former inline block. + d_timing->put((uint32_t) run_tick_begin); // Change 3: run start tick (us) + d_timing->put((uint32_t) esp_timer_get_time()); // run end tick (us) + pam_send_results(d_env, d_fluor, d_fluoRef, d_sun, d_leaf, d_730, d_730Ref, + d_timing, 1, true, interrrupt); + + _func_ret = 0; + del_classes: + delete d_fluor; + delete d_fluoRef; + delete d_sun; + delete d_leaf; + delete d_730; + delete d_730Ref; + delete d_env; + delete d_timing; + + adpd.gpio_config.GPIO0_cfg = 0; + adpd.gpio_config.EXT_SYNC_EN = 0; + adpd.gpio_setup(&(adpd.gpio_config)); + adpd_mode = ADPD_CONFIG_MODE::ARRAY_MODE1; + return _func_ret; +} + + +int external_trigger_run(void){ + + adpd.STOP(); + conf_slow_FR_1(); + + adpd.led_config.driver1_current = adpd_current_config.I620; + adpd.led_config.led1_channel = LED_A; + adpd.led_config.driver2_current = 0; + adpd.led_config.led2_channel = LED_A; + adpd.SNR_config.TIA_gain_CH1 = adpd_gains_config.Fluo; + adpd.SNR_config.TIA_gain_CH2 = adpd_gains_config.FluoRef; + adpd.preset_config_2(1, 4); + + + digitalWrite(10, LOW); + adpd.gpio_config.GPIO0_cfg = 1; + adpd.gpio_config.SYNC_GPIO = 0; + adpd.gpio_config.EXT_SYNC_EN = 1; + adpd.gpio_setup(&(adpd.gpio_config)); + + + // set to max possible bytes + uint8_t expected_readout = 6, num_integration = 4; + uint8_t expected_readout_bytes = expected_readout * 3; + + // data counter and buffer + // [sun-amb, leaf-ir, lit_leaf-ir, dark_leaf-ir, lit_leaf-ref, dark_leaf-ref] + uint32_t ret[expected_readout] = {0}; + uint16_t fifo_c = 0; + uint32_t read_fluor, read_fluoRef, read_sun, read_leaf; + float_t leaf_temp = 0.0; + + adpd.clear_fifo(); + adpd.run_freq(10); + adpd.num_ts(2); + adpd.RUN(); + delay(5); + uint8_t unknown_input_counter = 0; + + unsigned int watchdog_timer = millis(), trigger_timer = 0, start_timer = millis(), temp_timer = millis(); + bool keep_running = true, do_measure = false, change_act = false; + double obj_T, chip_T; + char c, c1, c2; + + Serial.println("Run"); + + while(keep_running){ + + while (Serial.available() == 0){ + if (millis() - watchdog_timer > 30000){ + keep_running = false; + break; + } + delayMicroseconds(200); + } + if (!keep_running) break; + + while (Serial.available() > 0){ + c = Serial.read(); + if (c == 'G'){ + do_measure = true; + watchdog_timer = millis(); + }else if(c == 'E'){ + do_measure = false; + keep_running = false; + }else if(c == 'A'){ + delay(1); + c1 = 0; + if (Serial.available() > 0){ + c1 = Serial.read(); + change_act = true; + } + }else if(c == 'T'){ + temp_timer = millis(); + mlx_measure(&obj_T, &chip_T); + Serial.printf("T:%d,o:%.3f,a:%.3f,d:%d\n", millis() - start_timer, obj_T, chip_T, millis() - temp_timer); + Serial.flush(); + watchdog_timer = millis(); + continue; + } + else{ + unknown_input_counter += 1; + if (unknown_input_counter > 200) keep_running = false; + } + } + + if (!keep_running) break; + if (change_act){ + change_act = false; + if (c1 > 3){ + AS_LED_Current(c1); + AS_LED_ON(); + }else{ + AS_LED_OFF(); + } + } + if (!do_measure) continue; + + + fifo_c = 0; + adpd_trigger(); + do_measure = false; + trigger_timer = millis(); + delay(1); + while (fifo_c != expected_readout_bytes){ + fifo_c = adpd.fifo_count(); + if (fifo_c >= expected_readout_bytes) break; + if (millis() - trigger_timer > 100) break; + } + if (fifo_c < expected_readout_bytes){ + Serial.println("NOT ENOUGH IN FIFO"); + break; + } + adpd.readfifo(expected_readout, 3, ret); + if (fifo_c > expected_readout_bytes){ + adpd.clear_fifo(); + Serial.printf("Extra %d byte in FIFO", fifo_c - expected_readout_bytes); + } + + read_fluor = calc_signal(ret[2], ret[3], num_integration); + read_fluoRef = calc_signal(ret[4], ret[5], num_integration); + read_sun = ret[0]; + read_leaf = ret[1]; + + + + Serial.printf("T:%d,S:%d,R:%d,F:%d,B:%d\n", millis() - start_timer, read_fluor, read_fluoRef, read_sun-65000, read_leaf-65000); + Serial.flush(); + } /// End of Loop + + + adpd.STOP(); + adpd.clear_fifo(); + + adpd.gpio_config.GPIO0_cfg = 0; + adpd.gpio_config.EXT_SYNC_EN = 0; + adpd.gpio_setup(&(adpd.gpio_config)); + + AS_LED_Current(0); + AS_LED_OFF(); + + Serial.println("Stop"); + + return 0; +} + + +int external_trigger_run_Flash(unsigned int gate_time, unsigned int dt, const uint16_t num){ + adpd.STOP(); + const uint8_t _NUM_TS = 8; + + adpd.led_config.driver1_current = 80; + adpd.led_config.led1_channel = LED_A; + // LED 2A = 730nm + adpd.led_config.driver2_current = 0; + adpd.led_config.led2_channel = LED_A; + adpd.SNR_config.TIA_gain_CH1 = 1; + adpd.SNR_config.TIA_gain_CH2 = 5; + + for (uint8_t i = 0; i < 12; i++){ + adpd.preset_config_ext_fast(i, 2); + } + + digitalWrite(STF_FLASH_PIN, LOW); + digitalWrite(10, LOW); + adpd.gpio_config.GPIO0_cfg = 1; + adpd.gpio_config.SYNC_GPIO = 0; + adpd.gpio_config.EXT_SYNC_EN = 1; + adpd.gpio_setup(&(adpd.gpio_config)); + AS_LED_OFF(); + AS_LED_Current(dt); + + + // set to max possible bytes + uint8_t expected_readout = _NUM_TS * 4, num_integration = 2; + uint8_t expected_readout_bytes = expected_readout * 3; + + // data counter and buffer + + uint32_t ret[expected_readout] = {0}; + uint16_t fifo_c = 0; + uint32_t read_fluor, read_fluoRef, read_sun, read_leaf; + float_t leaf_temp = 0.0; + + adpd.clear_fifo(); + adpd.run_freq(10); + adpd.num_ts(_NUM_TS); + adpd.RUN(); + delay(5); + uint16_t _counter = 0; + + unsigned int watchdog_timer = millis(), trigger_timer = 0, start_timer = millis(), temp_timer = millis(); + bool keep_running = true, do_measure = false, change_act = false; + double obj_T, chip_T; + char c, c1, c2; + + dataclass *d_fluor = new dataclass; // fluorescence signal + dataclass *d_fluoRef = new dataclass; // fluorescence reference + + + + Serial.println("Run"); + unsigned long timer1 = micros(); + unsigned long timer2 = micros(); + unsigned int flash_duration = expected_readout; + uint16_t _num_sample = num < 20 ? num * _NUM_TS : 20 * _NUM_TS + (num - 20); + + + + if (!( (d_fluor->init(_num_sample + 1)) && (d_fluoRef->init(_num_sample + 1)) )) goto del_classes; + while(keep_running){ + _counter += 1; + if (_counter > num) break; + if (!keep_running) break; + fifo_c = 0; + //if ((_counter == 5) && (dt > 0)) AS_LED_ON(); + adpd_trigger(); + timer1 = micros(); + delayMicroseconds(1000); + fifo_c = adpd.fifo_count(); + while (fifo_c != expected_readout_bytes){ + fifo_c = adpd.fifo_count(); + if (fifo_c >= expected_readout_bytes) break; + if (micros() - timer1 > 10000) break; + } + //Serial.printf("%ld: %d\n", micros() - timer1, fifo_c); + + if (fifo_c < expected_readout_bytes){ + Serial.printf("NOT ENOUGH IN FIFO: %d < %d\n", fifo_c, expected_readout_bytes); + break; + } + + + if ((gate_time > 0) && (flash_duration > 0) && (_counter > 2)) digitalWrite(STF_FLASH_PIN, HIGH); + //if ((_counter == 15) && (dt > 0)) AS_LED_OFF(); + + timer1 = micros(); + for (uint8_t r = 0; r < expected_readout; r++){ + adpd.readfifo(1, 3, ret + r); + if (flash_duration == r) digitalWrite(STF_FLASH_PIN, LOW); + } + //Serial.println(micros() - timer1); + + + if (_counter <= 20){ + for (uint8_t r = 0; r < _NUM_TS; r++){ + d_fluor->put(calc_signal(ret[0 + r * 4], ret[1 + r * 4], num_integration)); + d_fluoRef->put(calc_signal(ret[2 + r * 4], ret[3 + r * 4], num_integration)); + } + }else{ + read_fluor = 0; read_fluoRef = 0; + for (uint8_t r = 0; r < _NUM_TS; r++){ + read_fluor += calc_signal(ret[0 + r * 4], ret[1 + r * 4], num_integration); + read_fluoRef += calc_signal(ret[2 + r * 4], ret[3 + r * 4], num_integration); + } + d_fluor->put(read_fluor / _NUM_TS); + d_fluoRef->put(read_fluoRef / _NUM_TS); + if (_counter == 100) flash_duration = 4; + if (_counter == 300) flash_duration = 2; + if (_counter == 500) flash_duration = 1; + if (_counter == 700) flash_duration = 32; + } + + + if (fifo_c > expected_readout_bytes){ + fifo_c = adpd.fifo_count(); + if (fifo_c > 0){ + adpd.clear_fifo(); + digitalWrite(STF_FLASH_PIN, LOW); + Serial.printf("Extra %d byte in FIFO\n", fifo_c - expected_readout_bytes); + } + } + + // flash_duration = gate_time - (micros() - timer1); + // if ((flash_duration > 1) && (flash_duration < 500)) delayMicroseconds(flash_duration - 1); + // digitalWrite(STF_FLASH_PIN, LOW); + // + + + //Serial.printf("T:%d,S:%d,R:%d,F:%d,B:%d\n", millis() - start_timer, read_fluor, read_fluoRef, read_sun-65000, read_leaf-65000); + // Serial.printf("T:%d,S:%d,R:%d\n", millis() - start_timer, read_fluor, read_fluoRef); + // flash_duration = gate_time - (micros() - timer1); + // if (flash_duration > 2){ + // digitalWrite(STF_FLASH_PIN, HIGH); + // delayMicroseconds(flash_duration - 1); + // } + + + + digitalWrite(STF_FLASH_PIN, LOW); + } /// End of Loop + //Serial.printf("%f for %dpoints\n", float(micros() - timer2)/num, num); + AS_LED_OFF(); + digitalWrite(STF_FLASH_PIN, LOW); + adpd.STOP(); + adpd.clear_fifo(); + + + + adpd.gpio_config.GPIO0_cfg = 0; + adpd.gpio_config.EXT_SYNC_EN = 0; + adpd.gpio_setup(&(adpd.gpio_config)); + + AS_LED_Current(0); + AS_LED_OFF(); + digitalWrite(STF_FLASH_PIN, LOW); + + for (uint16_t n = 2; n < _num_sample; n++){ + Serial.printf("%d,%d,%.4f\n", d_fluor->arr[n], d_fluoRef->arr[n], ((float) d_fluor->arr[n]) / d_fluoRef->arr[n]); + } + + del_classes: + delete d_fluor; + delete d_fluoRef; + + + return 0; +} + + + + +int MPF(uint16_t mode, uint16_t dc_current){ + if (adpd_gains_config.init == false) ESP_LOGE(TAG, "Gain preset not initized, use default!"); + if (adpd_current_config.init == false) ESP_LOGE(TAG, "Current preset not initized, use default!"); + return MPF(mode, adpd_current_config.I620, dc_current, adpd_gains_config.Fluo, adpd_gains_config.FluoRef); + +} + + +int MPF(uint16_t mode, uint16_t current, uint16_t dc_current, uint8_t sign_gain, uint8_t ref_gain){ + + + const uint8_t num_integration = 1; + const uint16_t _data_size = 1080; + + ESP_LOGV(TAG, "RUN MPF with mode:%d, pulse current:%d, DC current %d", mode, current, dc_current); + + dataclass *d_fluor = new dataclass; // fluorescence signal + dataclass *d_fluoRef = new dataclass; // fluorescence reference + if (!( (d_fluor->init(_data_size)) && (d_fluoRef->init(_data_size)) )) return -1; + ESP_LOGV(TAG, "Memory allocation completed"); + + + adpd.STOP(); + adpd.run_freq(10); + adpd.clear_fifo(); + adpd.gpio_config.GPIO0_cfg = 1; + adpd.gpio_config.SYNC_GPIO = 0; + adpd.gpio_config.EXT_SYNC_EN = 1; + adpd.gpio_setup(&(adpd.gpio_config)); + + adpd.led_config.driver1_current = current; + adpd.led_config.driver2_current = 0; + adpd.SNR_config.TIA_gain_CH2 = ref_gain; + adpd.SNR_config.TIA_gain_CH1 = sign_gain; + + adpd_mode = ADPD_CONFIG_MODE::MPF_MODE; + + + // data buffers + uint32_t ret[48] = {0}; + uint16_t fifo_c = 0; + int32_t tmp_var = 0; + uint32_t avg_arr1[12] = {0}; + uint32_t avg_buf[4] = {0}; + uint16_t as_current = 255; + uint8_t expected_readout = 12 * 4; // 12 timeslots, 4 data per ts + uint16_t decay_interval = 1; + // PHASE 0---------------------------------------------- + // Apply a baseline without actinic + // fixed at 2 Hz x 20 pts + if (mode == 0){ + AS_LED_OFF(); + AS_LED_Current(as_current); + adpd.preset_config_ext_fast(0); + expected_readout = 4; + adpd.RUN(); + delayMicroseconds(1500); + adpd_trigger(); + delayMicroseconds(1500); + ESP_LOGV(TAG, "Phase-0 Started"); + for (uint8_t i = 0; i < 20; i++){ + adpd_trigger(); + adpd.readfifo(expected_readout, 3, ret); + for (uint8_t m = 0; m < 4; m++){ // sign-dark, sign-lit, ref-dark, ref lit + avg_buf[m] = ret[m]; + } + d_fluor->put(calc_signal(avg_buf[0], avg_buf[1], num_integration)); + d_fluoRef->put(calc_signal(avg_buf[2], avg_buf[3], num_integration)); + delay(500); + } + ESP_LOGV(TAG, "Phase-0 Completed"); + } + + + // PHASE 1--------------------------------------------------- + // 12 timeslots + // Rapid induction, all timeslot saved + ESP_LOGV(TAG, "Phase-1 Config"); + expected_readout = 48; + for (uint8_t i = 0; i < 12; i++){ + adpd.preset_config_ext_fast(i); + } + adpd.RUN(); + // AS Light kept until this point + AS_LED_OFF(); + AS_LED_Current(0); + delay(2); + ESP_LOGV(TAG, "Phase-1 LED ON"); + // Light ON + AS_LED_ON(); + delayMicroseconds(1); + adpd_trigger(); + delayMicroseconds(1500); + + for (uint8_t i = 0; i < 4; i++){ + adpd_trigger(); + adpd.readfifo(expected_readout, 3, ret); + for (uint8_t j = 0; j < 12; j++){ + + d_fluor->put(calc_signal(ret[0 + j * 4], ret[1 + j * 4], num_integration)); + d_fluoRef->put(calc_signal(ret[2 + j * 4], ret[3 + j * 4], num_integration)); + } + delayMicroseconds(500); + } + ESP_LOGV(TAG, "Phase-1 Completed; Phase-2 start"); + + // PHASE 2------------------------------------ + // 300ms induction, 200x12ts, 200 final pts + for (uint8_t i = 0; i < 200; i++){ + adpd_trigger(); + adpd.readfifo(expected_readout, 3, ret); + // reset avg arrays + for (uint8_t m = 0; m < 4; m++){ // find median for sign-dark, sign-lit, ref-dark, ref lit + memset(avg_arr1, 0, sizeof(avg_arr1)); + for (uint8_t n = 0; n < 12; n++){ // put 12 ts into sorting array + sorted_insert(avg_arr1, 12, ret[m + n * 4]); + } + avg_buf[m] = (avg_arr1[5] + avg_arr1[6] + avg_arr1[7]) / 3; // pick the middle 3 numbers and average + } + + + // Serial.printf("P2, %d, %d, %d\n", avg_buf[0], avg_buf[1], calc_signal(avg_buf[0], avg_buf[1], num_integration)); + // Serial.printf("P2, %d, %d, %d\n", avg_buf[2], avg_buf[3], calc_signal(avg_buf[2], avg_buf[3], num_integration)); + + + d_fluor->put(calc_signal(avg_buf[0], avg_buf[1], num_integration)); + // Serial.println(d_fluor->arr[d_fluor->write_ptr - 1]); + d_fluoRef->put(calc_signal(avg_buf[2], avg_buf[3], num_integration)); + // Serial.println(d_fluoRef->arr[d_fluoRef->write_ptr - 1]); + delayMicroseconds(500); + } + + ESP_LOGV(TAG, "Phase-2 Completed; Phase-3 Start"); + + + // PHASE 3------------------------------------ + // 150ms induction X cycles, 100x12ts, 50 final pts + for (uint8_t j = 0; j < 8; j++){ + AS_LED_Current(220 - j * 30); + ESP_LOGV(TAG, "LED set to %d", 220 - j * 30); + memset(avg_buf, 0, sizeof(avg_buf)); + for (uint8_t i = 0; i < 40; i++){ + adpd_trigger(); + adpd.readfifo(expected_readout, 3, ret); + // reset avg arrays + for (uint8_t m = 0; m < 4; m++){ // find median for sign-dark, sign-lit, ref-dark, ref lit + memset(avg_arr1, 0, sizeof(avg_arr1)); + for (uint8_t n = 0; n < 12; n++){ // put 12 ts into sorting array + sorted_insert(avg_arr1, 12, ret[m + n * 4]); + } + avg_buf[m] += (avg_arr1[5] + avg_arr1[6] + avg_arr1[7]) / 3; // pick the middle 3 numbers and average + } + + if (i % 2 == 1){ + d_fluor->put(calc_signal(avg_buf[0] / 2, avg_buf[1] / 2, num_integration)); + d_fluoRef->put(calc_signal(avg_buf[2] / 2, avg_buf[3] / 2, num_integration)); + memset(avg_buf, 0, sizeof(avg_buf)); + } + delayMicroseconds(500); + } + } + + ESP_LOGV(TAG, "Phase-3 Completed; Phase-4 Start"); + // PHASE 4------------------------------------ + AS_LED_Current(as_current); + // prepare for single timeslot decay kinetic + expected_readout = 4; + adpd.preset_config_ext_fast(0); + adpd.clear_fifo(); + adpd.RUN(); + delayMicroseconds(1000); + adpd_trigger(); + delayMicroseconds(1500); + memset(avg_buf, 0, sizeof(avg_buf)); + + for (uint8_t i = 0; i < 200; i++){ + adpd_trigger(); + adpd.readfifo(expected_readout, 3, ret); + for (uint8_t m = 0; m < 4; m++){ // sign-dark, sign-lit, ref-dark, ref lit + avg_buf[m] += ret[m]; + } + if (i % 4 == 3){ + + + + // Serial.printf("P4, %d, %d, %d\n", avg_buf[0]/4, avg_buf[1]/4, calc_signal(avg_buf[0]/4, avg_buf[1]/4, num_integration)); + // Serial.printf("P4, %d, %d, %d\n", avg_buf[2]/4, avg_buf[3]/4, calc_signal(avg_buf[2]/4, avg_buf[3]/4, num_integration)); + + + d_fluor->put(calc_signal(avg_buf[0] / 4, avg_buf[1] / 4, num_integration)); + // Serial.println(d_fluor->arr[d_fluor->write_ptr - 1]); + d_fluoRef->put(calc_signal(avg_buf[2] / 4, avg_buf[3] / 4, num_integration)); + // Serial.println(d_fluoRef->arr[d_fluoRef->write_ptr - 1]); + memset(avg_buf, 0, sizeof(avg_buf)); + } + if (i == 149) { + if (mode == 0) AS_LED_OFF(); // dark mode, actinic OFF + if (mode == 1) AS_LED_Current(dc_current); // light mode, actinic set + } + delayMicroseconds(1400); + } + + ESP_LOGV(TAG, "Phase-4 Completed"); +// PHASE -1 --------------------------- +// Dark decay with increasing interval + if (mode == 0){ + ESP_LOGV(TAG, "Phase-minus1 Started"); + AS_LED_OFF(); + for (uint8_t i = 0; i < 160; i++){ + adpd_trigger(); + adpd.readfifo(expected_readout, 3, ret); + for (uint8_t m = 0; m < 4; m++){ // sign-dark, sign-lit, ref-dark, ref lit + avg_buf[m] += ret[m]; + } + if (i % 4 == 3){ + d_fluor->put(calc_signal(avg_buf[0] / 4, avg_buf[1] / 4, num_integration)); + d_fluoRef->put(calc_signal(avg_buf[2] / 4, avg_buf[3] / 4, num_integration)); + memset(avg_buf, 0, sizeof(avg_buf)); + decay_interval += 5; + } + delayMicroseconds(1400); + delay(decay_interval); + } + } + + ESP_LOGV(TAG, "Measurement Completed"); + // Completed + + adpd.STOP(); + + if (CONNECTION_TYPE == CONNECTION_TYPES::PLOTTING){ + uint16_t l = d_fluor->get_length(); + uint32_t ploter1, ploter2; + for (uint16_t i = 0; i < l; i++){ + ploter1 = d_fluor->pop(); + ploter2 = d_fluoRef->pop(); + Serial.printf("F:%3.4f,S:%d,R:%d\n", (float)ploter1/(float)ploter2, ploter1, ploter2); + } + }else if (CONNECTION_TYPE == CONNECTION_TYPES::AMBYTE){ + d_fluor->fsm_send_esp(0); + d_fluoRef->fsm_send_esp(1); + } + else{ + d_fluor->send_serial("s_fluo"); + d_fluoRef->send_serial("r_fluo"); + Serial.println("Data sent"); + } + + ESP_LOGV(TAG, "All Completed"); + + + adpd.gpio_config.GPIO0_cfg = 0; + adpd.gpio_config.SYNC_GPIO = 0; + adpd.gpio_config.EXT_SYNC_EN = 0; + adpd.gpio_setup(&(adpd.gpio_config)); + + delete d_fluor; + delete d_fluoRef; + return 0; +} + + +/* Leaf temperature as centi-degC (signed int16 in the low 16 bits). The old + * time/type bit-packing is gone: env arrays sent to the ambyte are now a plain + * centi-degC series. Absolute time comes from the ambyte RTC; within-run point + * timing from the run freq. Only mode 4 (leaf temp) is emitted now; mode/t0 are + * kept so call sites are unchanged. */ +uint32_t PAM_get_env(uint8_t mode, unsigned int t0){ + (void) t0; + if (mode == 4){ + int16_t centi = (int16_t) (mlx_measure() * 100.0); + return (uint32_t) (uint16_t) centi; + } + return 0; +} + +uint32_t PAM_retrieve_env(uint32_t r, uint8_t* mode, float_t* data_f, int16_t* data_i){ + int16_t data = (int16_t) (r & 0x00000FFF); + uint8_t d_type = (uint8_t) ((r & 0x0000F000) >> 12); + uint32_t t = ((r & 0xFFFF0000) >> 10); + + if (d_type < 4){ + t += data; + if (mode != NULL) *mode = d_type; + }else if (d_type == 4){ // temperature + if (data_f != NULL) *data_f = (data / 20.0 - 20); + if (mode != NULL) *mode = d_type; } + + + return t; +} + + + + + +int sandbox(uint8_t I620, uint8_t g1, uint8_t g2){ + + + // variables for each trace + + // data counter and buffer + // [sun-amb, leaf-ir, lit_leaf-ir, dark_leaf-ir, lit_leaf-ref, dark_leaf-ref] + uint32_t ret[16] = {0}; + uint16_t fifo_c = 0; + uint16_t fifo_c1 = 0; + + + adpd.STOP(); + adpd.gpio_config.GPIO0_cfg = 1; + adpd.gpio_config.SYNC_GPIO = 0; + adpd.gpio_config.EXT_SYNC_EN = 1; + adpd.gpio_setup(&(adpd.gpio_config)); + + adpd.led_config.driver1_current = I620; + adpd.led_config.driver2_current = 0; + adpd.SNR_config.TIA_gain_CH2 = 5; + adpd.SNR_config.TIA_gain_CH1 = 1; + + adpd.preset_config_ext_fast(0, 1); + adpd.preset_config_ext_fast(1, 2); + adpd.preset_config_ext_fast(2, 3); + adpd.preset_config_ext_fast(3, 4); + + adpd.run_freq(10); + adpd.clear_fifo(); + + adpd.RUN(); + delay(1); + int64_t timer = 0; + + + for (uint16_t i = 0; i < 200; i++){ + digitalWrite(10, HIGH); + delayMicroseconds(1); + digitalWrite(10, LOW); + timer = esp_timer_get_time(); + if (i > 0){ + + adpd.readfifo(16, 3, ret); + + Serial.printf("Data:%d,%d,%d,%d,", ret[0], ret[1], ret[2],ret[3]); + Serial.printf("%d,%d,%d,%d,", ret[4], ret[5], ret[6],ret[7]); + Serial.printf("%d,%d,%d,%d,", ret[8], ret[9], ret[10],ret[11]); + Serial.printf("%d,%d,%d,%d\n", ret[12], ret[13], ret[14],ret[15]); + + + delay(100); + + }else{ + delayMicroseconds(1500); + } + //Serial.println(esp_timer_get_time() - timer); + + } + //Serial.println(adpd.fifo_count()); + adpd.readfifo(16, 3, ret); + + adpd.STOP(); + + + return 0; + +} + + + +static bool PAM_interrupt(bool enable, bool check_sleep){ + uint8_t ret = 0; + if (!enable) return false; + if (check_sleep){ // after light sleep + if (esp_sleep_get_wakeup_cause() == 8){ // wake up serial + Serial.flush(); + ret = serial_read_until(177, 0, 0, 25, true); + } + }else{ + ret = serial_read_until(177, 0, 0, 15, true); + } + if (ret == 1) return true; + return false; +} + + +void actinic_test(uint8_t act1, uint8_t act2, uint8_t t1, uint8_t t2){ + AS_LED_Current(act1); + AS_LED_ON(); + delay(t1 * 1000); + AS_LED_Current(act2); + delay(3000); + AS_LED_OFF(); + AS_LED_Current(0); + + +} + + + + +int fluor_offset_test(uint8_t current, uint8_t num_integ, uint8_t lit_offset, uint8_t dark1_offset, uint8_t dark2_offset, uint8_t pulse_offset, uint8_t pulse_duration){ + + // Setup timeslot 2: Fluor and Ref channels, 4 x 3 bytes + // LED 1A = 620nm + adpd.led_config.driver1_current = current; + adpd.led_config.led1_channel = LED_A; + // LED 2A = 730nm + adpd.led_config.driver2_current = 0; + adpd.led_config.led2_channel = LED_A; + adpd.SNR_config.TIA_gain_CH1 = 1; + adpd.SNR_config.TIA_gain_CH2 = 5; + adpd.preset_config_2x(0, num_integ, lit_offset, dark1_offset, dark2_offset, pulse_offset, pulse_duration); + + adpd_mode = ADPD_CONFIG_MODE::ARRAY_MODE1; + + return 0; +} + + +int fluor_offset(uint32_t* fret){ + + if (adpd_mode != ADPD_CONFIG_MODE::ARRAY_MODE1){ + conf_slow_FR_1(); + ESP_LOGW(TAG, "Run array was not configured!"); + } + // set to max possible bytes + uint8_t expected_readout = 8; + uint8_t expected_readout_bytes = expected_readout * 3; + const uint8_t num_integration = 1; + const unsigned int start_t0 = millis(); + + + // variables for each trace + uint8_t pc = 0; + uint8_t _type = 0; + uint8_t farred = 0, actinic = 0, subsampling = 0; + uint16_t num_ptx = 0; + + // data counter and buffer + // [sun-amb, leaf-ir, lit_leaf-ir, dark_leaf-ir, lit_leaf-ref, dark_leaf-ref] + uint32_t ret[expected_readout] = {0}; + uint32_t counter = 0; + uint16_t fifo_c = 0; + uint8_t watch_dog_timer = 0; + int32_t tmp_var = 0; + uint32_t buf_opt[4] = {0}; + uint32_t _tmparr = 0; + uint8_t _repeats = 1; + + + + adpd.STOP(); + adpd.run_freq(100); + adpd.clear_fifo(); + adpd.num_ts(3); + expected_readout = 8; + expected_readout_bytes = expected_readout * 3; + AS_LED_OFF(); + AS_LED_Current(0); + + + num_ptx = 64; + + uint32_t fluor, fluoRef, sun, leaf, r730, r730Ref; + uint32_t ret_fluor = 0, ret_fluoRef = 0, ret_sun = 0, ret_leaf = 0, ret_r730 = 0, ret_r730Ref = 0; + + for (uint8_t n = 0; n < 4; n++){ + adpd.RUN(); + delay(1); + fluor = 0; fluoRef = 0; sun = 0; leaf = 0; r730 = 0; r730Ref = 0; + counter = 0; + + while (counter < num_ptx){ + fifo_c = adpd.fifo_count(); + while (fifo_c >= expected_readout_bytes){ // read all bytes from FIFO + adpd.readfifo(expected_readout, 3, ret); + fifo_c -= expected_readout_bytes; + if (counter == num_ptx) break; + // 0: sun-vis; 1: leaf-ir; 2: fluoS_dark; 3: fluoS_lit; 4: fluoR_dark; 5: fluoR_lit; 6: Reflect_signal; 7: reflect_ref + // save fluor signal and ref + fluor += calc_signal(ret[2], ret[3], num_integration); + fluoRef += calc_signal(ret[4], ret[5], num_integration); + r730 += ret[6]; + r730Ref += ret[7]; + sun += ret[0]; + leaf += ret[1]; + counter += 1; + } + + } + adpd.STOP(); + + if (counter > 10){ + ret_fluor += fluor / counter; + ret_fluoRef += fluoRef / counter; + ret_sun += sun / counter; + ret_leaf += leaf / counter; + ret_r730 += r730 / counter; + ret_r730Ref += r730Ref / counter; + } + + } + fret[0] = ret_fluor / 4; + fret[1] = ret_fluoRef / 4; + fret[2] = ret_sun / 4; + fret[3] = ret_leaf / 4; + fret[4] = ret_r730 / 4; + fret[5] = ret_r730Ref / 4; + return 0; + +} diff --git a/src/PAM.h b/src/PAM.h new file mode 100644 index 0000000..954ba39 --- /dev/null +++ b/src/PAM.h @@ -0,0 +1,70 @@ +#ifndef _PAM_H_ +#define _PAM_H_ +#include "src/adpd/u_adpd6100.h" +#include "src/as7341/spec_meas.h" +#include "src/devices_init.h" +#include "src/mlx90632/u_mlx.h" +#include "data_utils.h" +#include + + +extern ADPD6 adpd; +extern uint8_t adpd_mode; + +typedef struct{ + bool init = false; + uint8_t I620 = 110; + uint8_t I720 = 40; + uint8_t IR = 20; +} adpd_current_config_t; + +typedef struct { + bool init = false; + uint8_t Fluo = 1; + uint8_t FluoRef = 5; + uint8_t IR = 5; + uint8_t IRRef = 1; + uint8_t Sun = 5; + uint8_t Leaf = 5; +} adpd_gains_config_t; + + +extern adpd_current_config_t adpd_current_config; +extern adpd_gains_config_t adpd_gains_config; + + + +int conf_slow_FR_1(uint8_t I620, uint8_t I730, uint8_t I_FR, uint8_t G_Fluor, uint8_t G_FluorRef, uint8_t G_Sun, uint8_t G_IR, uint8_t G_FR, uint8_t G_FRref); +int conf_slow_FR_1(void); +int fluor_offset_test(uint8_t current, uint8_t num_integ, uint8_t lit_offset, uint8_t dark1_offset, uint8_t dark2_offset, uint8_t pulse_offset, uint8_t pulse_duration); + +int MPF(uint16_t mode, uint16_t current, uint16_t dc_current, uint8_t sign_gain, uint8_t ref_gain); +int MPF(uint16_t mode, uint16_t dc_current); +int run_arr_type1(uint8_t length, uint8_t* arr, bool led_persist); +// retain=true: keep the result buffers alive in the async holder (no FSM/serial +// send, no delete) so a later FETCH can stream them — used by the parallel +// trigger/poll/fetch protocol. Default false = legacy synchronous send+free. +int run_arr_type1(uint8_t length, uint8_t* arr, bool led_persist, bool allow_interrupt, bool json_output = false, bool retain = false); +int run_trigger_spacer(uint16_t length, uint8_t interval, bool change_act, uint8_t act, bool interrrupt); + +// ── Async (trigger/poll/fetch) result holder — parallel measurement protocol ── +// A run started via ambit_async_run_start() blocks the C3 to completion (as the +// synchronous run does today) but RETAINS its result arrays instead of streaming +// them, so the host can trigger all sensors, then poll state and fetch later. +enum { AMBIT_ASYNC_IDLE = 0, AMBIT_ASYNC_DONE = 1, AMBIT_ASYNC_ERROR = 2 }; +int ambit_async_run_start(uint8_t length, uint8_t* arr, bool led_persist, bool allow_interrupt); +uint8_t ambit_async_get_state(void); // AMBIT_ASYNC_IDLE | DONE | ERROR +int ambit_async_fetch(void); // stream retained arrays (AMBYTE FSM), then clear; 0 ok +void ambit_async_clear(void); // free any retained buffers, state -> IDLE +uint32_t PAM_get_env(uint8_t mode, unsigned int t0); +uint32_t PAM_retrieve_env(uint32_t r, uint8_t* mode, float_t* data_f = NULL, int16_t* data_i = NULL); +int fluor_offset(uint32_t* ret); +enum ADPD_CONFIG_MODE { + MPF_MODE, + IDLE, + ARRAY_MODE1, + ARRAY_SLOW, + FUTURE +}; + +#endif \ No newline at end of file diff --git a/src/ambit-1.ino b/src/ambit-1.ino new file mode 100644 index 0000000..7364882 --- /dev/null +++ b/src/ambit-1.ino @@ -0,0 +1,205 @@ +#include +#include "src/devices_init.h" +#include "src/adpd/u_adpd6100.h" +#include "src/as7341/spec_meas.h" +#include "src/mlx90632/u_mlx.h" +#include "serial.h" +#include "do_command.h" +#include "config.h" +#include "driver/uart.h" +#include "driver/gpio.h" +#include +#include "Esp.h" +#include "nvs1.h" + +static const char* TAG = "INO"; +ADPD6 adpd; +Preferences preferences; +uint8_t CONNECTION_TYPE = 0; +bool FLAG_DEICE = false; +static uint16_t sleep_threshod_ms = 100; + +static struct Reset_Button{ + unsigned int previous_toggle_t = millis(); + unsigned int counter = 0; +}RB; + +void ARDUINO_ISR_ATTR RB_toggle(){ + unsigned int t = millis(); + unsigned int dt = t - RB.previous_toggle_t; + RB.previous_toggle_t = t; + + if ((dt > 8) && (dt < 12)){ + RB.counter += 1; + }else{ + RB.counter = 0; + } + if (RB.counter > 3){ + RB.counter = 0; + esp_restart(); + return; + } + return; +} + + +void ambit_light_sleep(){ + detachInterrupt(BOOT_PIN); + gpio_sleep_set_direction(GPIO_NUM_9, GPIO_MODE_INPUT); + gpio_sleep_set_pull_mode(GPIO_NUM_9, GPIO_PULLUP_ONLY); + gpio_wakeup_enable(GPIO_NUM_9, GPIO_INTR_LOW_LEVEL); + esp_sleep_enable_gpio_wakeup(); + esp_light_sleep_start(); + attachInterrupt(BOOT_PIN, RB_toggle, CHANGE); +} + + + + +int serial_read_until(uint8_t target1, uint8_t target2 = 0, uint8_t target3 = 0, uint16_t timeout = 20, bool remove = false); +uint16_t flush_serial(uint8_t timeout); +void setup(){ +#ifdef VARIANT_CLOUD + extern void cloud_setup(); + cloud_setup(); + return; +#endif + esp_timer_early_init(); + pinMode(STF_FLASH_PIN, OUTPUT); + pinMode(BOOT_PIN, INPUT_PULLUP); + digitalWrite(STF_FLASH_PIN, LOW); + pinMode(10, OUTPUT); + digitalWrite(10, LOW); + attachInterrupt(BOOT_PIN, RB_toggle, CHANGE); + + + Serial.begin(115200); + delay(250); + Serial.println("BOOT"); + Serial.println(esp_timer_get_time()); + Serial.setTimeout(50); + + /* The binary FSM protocol shares UART0 with the ESP-IDF log console + * (Serial -> UART0). Silence all logging so it can't interleave ASCII into + * the binary stream sent to the ambyte over the FFC. */ + esp_log_level_set("*", ESP_LOG_NONE); + + + digitalWrite(STF_FLASH_PIN, HIGH); + delayMicroseconds(1); + digitalWrite(STF_FLASH_PIN, LOW); + init_i2c_bus(); + init_spi_bus(); + adpd.begin(); + if (as7341.begin()) ESP_LOGV(TAG, "AS7341 Found"); + check_AS7341(); + AS_LED_OFF(); + mlx_init(); + CONNECTION_TYPE = CONNECTION_TYPES::COMPUTER; + + uart_set_wakeup_threshold(UART_NUM_0, 3); + esp_sleep_enable_uart_wakeup(UART_NUM_0); + + gpio_sleep_set_direction(GPIO_NUM_20, GPIO_MODE_INPUT); + gpio_sleep_set_pull_mode(GPIO_NUM_20, GPIO_PULLUP_ONLY); + + gpio_sleep_set_direction(GPIO_NUM_1, GPIO_MODE_OUTPUT); + gpio_sleep_set_pull_mode(GPIO_NUM_1, GPIO_PULLDOWN_ONLY); + + load_info_from_nvs(true); + + + Serial.write(AMBIT_BOOT_IDLE); + + esp_sleep_enable_timer_wakeup(10000000); + + + FLAG_DEICE = false; + //esp_sleep_enable_timer_wakeup(200000); +} + + +int do_esp_cmd(); +int c = -1; +char choose[50]; + +void loop(){ +#ifdef VARIANT_CLOUD + extern void cloud_loop(); + cloud_loop(); + return; +#endif + c = -1; + int b; + unsigned int sleep_timer = millis(); + + for (;;) { + c = Serial.available(); + if (c > 0){ + sleep_timer = millis(); + c = Serial.peek(); + if (c == 255) Serial.read(); + if (c < 255) break; + }else{ + if (millis() - sleep_timer > sleep_threshod_ms){ + + + Serial.flush(); + flush_serial(20); + ambit_light_sleep(); + c = esp_sleep_get_wakeup_cause(); + sleep_timer = millis(); + if (c == 8){ + sleep_threshod_ms = 1000; + }else{ + sleep_threshod_ms = 200; + } + + Serial.write(AMBIT_BOOT_IDLE); + Serial.flush(); + + + //sleep_timer = millis(); + + + }else{ + delay(10); + //sleep_threshod_ms = 200; + } + } + + } + + c = Serial.peek(); + if (c > 127) { // not from computer + while (Serial.available() > 0){ + + b = serial_read_until(170, 160, 222, 50, false); + if (b == 1){ // wake up signal + flush_serial(5); + Serial.write(128); + sleep_threshod_ms = 500; + }else if(b == 2){// command + do_esp_cmd(); + break; + }else if (b == 3){ // data send reset signal + ESP_LOGE(TAG, "OUT of sync"); + Serial.read(); + Serial.write(128); + }else{ + ESP_LOGE(TAG, "Unknown cmd %d", c); + Serial.read(); + Serial.write(128); + break; + } + } + + }else{ + sleep_threshod_ms = 30000; + Serial_Input_Chars(choose, ":,", 200, sizeof(choose) - 1); + do_command(choose); + + } + + +} \ No newline at end of file diff --git a/src/config.h b/src/config.h new file mode 100644 index 0000000..6501972 --- /dev/null +++ b/src/config.h @@ -0,0 +1,16 @@ +#ifndef _CONFIG_H +#define _CONFIG_H + +#define STF_FLASH_PIN 1 +#define BOOT_PIN 9 +#define AMBIT_BOOT_IDLE 133 + +enum CONNECTION_TYPES { + PLOTTING, + AMBYTE, + COMPUTER, +}; + +extern uint8_t CONNECTION_TYPE; + +#endif diff --git a/src/core.cpp b/src/core.cpp new file mode 100644 index 0000000..959fa84 --- /dev/null +++ b/src/core.cpp @@ -0,0 +1,43 @@ +#include "core.h" +#include "PAM.h" + +void core_set_currents(uint8_t i620, uint8_t i720, uint8_t ir){ + adpd_current_config.I620 = i620; + adpd_current_config.I720 = i720; + adpd_current_config.IR = ir; + adpd_current_config.init = true; + adpd_mode = ADPD_CONFIG_MODE::MPF_MODE; // dirty: next array run re-applies +} + +void core_set_gains(uint8_t fluo, uint8_t fluo_ref, uint8_t ir, uint8_t ir_ref, + uint8_t sun, uint8_t leaf){ + adpd_gains_config.Fluo = fluo; + adpd_gains_config.FluoRef = fluo_ref; + adpd_gains_config.IR = ir; + adpd_gains_config.IRRef = ir_ref; + adpd_gains_config.Sun = sun; + adpd_gains_config.Leaf = leaf; + adpd_gains_config.init = true; + adpd_mode = ADPD_CONFIG_MODE::MPF_MODE; // dirty +} + +void core_config_detector(void){ + conf_slow_FR_1(); // reads the global config + adpd_mode = ADPD_CONFIG_MODE::ARRAY_MODE1; +} + +void core_ensure_array_config(void){ + if (adpd_mode != ADPD_CONFIG_MODE::ARRAY_MODE1){ + conf_slow_FR_1(); + adpd_mode = ADPD_CONFIG_MODE::ARRAY_MODE1; + } +} + +int core_run_array(uint8_t len, uint8_t* arr, uint8_t persist, bool allow_interrupt){ + core_ensure_array_config(); + return run_arr_type1(len, arr, persist, allow_interrupt); +} + +int core_run_mpf(uint16_t length, uint8_t interval, bool change_act, uint8_t act){ + return run_trigger_spacer(length, interval, change_act, act, true); +} diff --git a/src/core.h b/src/core.h new file mode 100644 index 0000000..badf782 --- /dev/null +++ b/src/core.h @@ -0,0 +1,42 @@ +#ifndef _CORE_H_ +#define _CORE_H_ +#include + +/* + * Transport-agnostic command core (MERGE_PLAN §5). + * + * Each function takes already-normalized values (gains 0-indexed, real widths) + * and operates on the single global config owned by PAM + * (adpd_current_config / adpd_gains_config / adpd_mode). It does NO wire I/O: + * no Serial / printf / JSON. The frontends (text do_command, binary run_esp, + * and later the openJII json adapter) parse their own wire format, resolve + * their own conventions (sentinels, 1-indexing), call these, then format output. + * + * Increment 1 covers the operations whose orchestration was duplicated across + * the text parser's arrun / arrun1 / arrun2 / q / r / w and set_currents / + * set_gains cases. The binary frontend adopts the same functions in a later + * increment, gated on the §13 wire-conformance check. + */ + +// Config setters. Values are final/normalized; the caller has already resolved +// its wire conventions. Marks the config dirty (adpd_mode = MPF_MODE) so the +// next array run re-applies it — the text path's "set, then apply on run". +void core_set_currents(uint8_t i620, uint8_t i720, uint8_t ir); +void core_set_gains(uint8_t fluo, uint8_t fluo_ref, uint8_t ir, uint8_t ir_ref, + uint8_t sun, uint8_t leaf); + +// Apply the current global config to the detector. core_config_detector applies +// unconditionally + enters array mode (binary cmd 10). core_ensure_array_config +// applies only if not already in array mode — for callers (binary cmd 21) that +// interleave wire I/O between the config step and the run step. +void core_config_detector(void); +void core_ensure_array_config(void); + +// Array-mode run: the single copy of "ensure config, then run". `persist` is +// treated as a bool (nonzero = LEDs persist), matching the legacy run_arr_type1. +int core_run_array(uint8_t len, uint8_t* arr, uint8_t persist, bool allow_interrupt); + +// Multi-phase (trigger-spacer) run; always interruptible (the legacy constant). +int core_run_mpf(uint16_t length, uint8_t interval, bool change_act, uint8_t act); + +#endif diff --git a/src/data_utils.cpp b/src/data_utils.cpp new file mode 100644 index 0000000..e4aa991 --- /dev/null +++ b/src/data_utils.cpp @@ -0,0 +1,497 @@ +#include "data_utils.h" + + +static const char* TAG = "DATA_UTIL"; +extern bool FLAG_DEICE; + + +// return 1, 2, 3 +// or -1 +int serial_read_until(uint8_t target1, uint8_t target2 = 0, uint8_t target3 = 0, uint16_t timeout = 20, bool remove = false){ + unsigned long start_t = millis(); + uint8_t counter, b = 0; + + while (((millis() - start_t) < timeout)){ + if (Serial.available() > 0){ + b = Serial.peek(); + if (b == target1){ + if (remove) Serial.read(); + return 1; + } else if ((target2 > 0) && (b == target2)){ + if (remove) Serial.read(); + return 2; + } else if ((target3 > 0) && (b == target3)){ + if (remove) Serial.read(); + return 3; + } + + b = Serial.read(); // non-target byte: discard (do NOT echo onto the link — + // an echo here injects bytes into the binary FSM stream) + } + else{ + delayMicroseconds(10); + } + } + return -1; +} + +uint16_t flush_serial(uint8_t timeout){ + uint16_t c = 0; + uint8_t r = 0; + delay(1); + unsigned long start_t = millis(); + if (Serial.available() < 1) return 0; + + while (((millis() - start_t) < timeout)){ + if (Serial.available() > 0){ + r = Serial.read(); // discard (do NOT echo onto the link — see serial_read_until) + c += 1; + }else{ + break; + } + } + return c; +} + + + +dataclass::dataclass(){ + dataclass::available = false; + dataclass::write_available = false; + dataclass::read_available = false; + ESP_LOGV(TAG, "DATACLASS Created"); + return; +}; + +dataclass::~dataclass(void){ + ESP_LOGV(TAG, "DATACLASS destroied"); + if (dataclass::available) dataclass:clean(); + return; +}; + +void dataclass::clean(void){ + if (dataclass::available) free((void*) (dataclass::arr)); + ESP_LOGV(TAG, "Memory freed"); + dataclass::arr = NULL; + dataclass::available = false; + dataclass::write_available = false; + dataclass::read_available = false; + return; +}; + + +bool dataclass::init(uint16_t length){ + if ((length > 0) and length < MAX_DATACLASS_SIZE){ + ESP_LOGV(TAG, "Allocation %d bytes", length * 4); + (dataclass::arr) = (uint32_t*) heap_caps_calloc(length, sizeof(uint32_t), MALLOC_CAP_32BIT); + if (dataclass::arr == NULL){ + ESP_LOGE(TAG, "Allocation %d bytes failed", length * 4); + return false; + } + dataclass::_length = length; + dataclass::available = true; + dataclass::clear(); + dataclass::write_available = true; + dataclass::write_ptr = 0; + dataclass::read_ptr = 0; + dataclass::read_available = false; + dataclass::_overwritten_counter = 0; + dataclass::loop_ahead = false; + return true; + } + else{ + ESP_LOGE(TAG, "Out-of-range: %d bytes ", length * 4); + return false; + } + return false; +}; + +// set data array to 0 +void dataclass::clear(void){ + if (dataclass::available){ + for(uint16_t i = 0; i < dataclass::_length; i++) (dataclass::arr)[i] = 0; + dataclass::write_ptr = 0; + dataclass::read_ptr = 0; + dataclass::loop_ahead = false; + ESP_LOGV(TAG, "ARR reset to 0"); + }else{ + ESP_LOGE(TAG,"RESET failed, not initialized"); + } +} + +// add the next point to the data array +// update loop_over +void dataclass::put(uint32_t data){ + if (!(dataclass::available)){ + ESP_LOGE(TAG, "Add failed, not initialized"); + return; + } + + // write point cycling around and reach read pointer + if ((dataclass::write_ptr >= dataclass::read_ptr) && (dataclass::loop_ahead)){ + dataclass::read_ptr = dataclass::write_ptr + 1; + dataclass::length -= dataclass::write_ptr - dataclass::read_ptr + 1; + if (dataclass::read_ptr >= dataclass::_length) dataclass::read_ptr = 0; + dataclass::_overwritten_counter += 1; + ESP_LOGW(TAG, "Data over-written, total: %d", dataclass::_overwritten_counter); + } + + dataclass::arr[write_ptr] = data; + dataclass::length += 1; + dataclass::write_ptr += 1; + + dataclass::read_available = true; + if (dataclass::write_ptr >= dataclass::_length){ + dataclass::write_ptr = 0; + dataclass::loop_ahead = true; + } + +} + +uint16_t dataclass::get_length(void){ + if (!(dataclass::available)){ + ESP_LOGE(TAG, "Add failed, not initialized"); + return 0; + } + if (!(dataclass::read_available)){ + ESP_LOGW(TAG, "No data available"); + return 0; + } + if (dataclass::loop_ahead){ + if (dataclass::write_ptr <= dataclass::read_ptr) return + dataclass::_length - dataclass::read_ptr + dataclass::write_ptr; + ESP_LOGW(TAG, "write_ptr > read_ptr After loop around!!!!"); + return 0; + }else{ + if (dataclass::write_ptr > dataclass::read_ptr) return (dataclass::write_ptr - dataclass::read_ptr); + if (dataclass::write_ptr == dataclass::read_ptr){ + dataclass::read_available = false; + return 0; + } + ESP_LOGW(TAG, "write_ptr < read_ptr WITHOUT loop around!!!!"); + return 0; + } + return 0; // should not reach here +} + + + +/* Sum of the 4 little-endian bytes of v. The data checksum is a byte-sum of + * the payload (matching the bytes send_binary_array transmits and the ambyte's + * verification) — summing the uint32 value into a uint8 would only cover the + * low byte. */ +static inline uint8_t u32_byte_sum(uint32_t v) +{ + return (uint8_t)v + (uint8_t)(v >> 8) + (uint8_t)(v >> 16) + (uint8_t)(v >> 24); +} + +// Pack `len` uint32 values into the wire format, write them to Serial, and return the +// byte-sum of exactly the bytes written (defined below). elem_width 2|4, dtype 0|1. +static uint8_t send_binary_array(uint32_t* arr, uint16_t len, uint8_t elem_width, uint8_t dtype); + +uint32_t dataclass::send(uint8_t elem_width, uint8_t dtype, uint8_t* c){ + uint8_t checksum = 0; + if (dataclass::get_length() == 0){ + dataclass::read_available = false; + ESP_LOGW(TAG, "No data available"); + return 0; + } + + if (dataclass::loop_ahead){ + if (dataclass::write_ptr <= dataclass::read_ptr){ + checksum += send_binary_array(this->arr + this->read_ptr, this->_length - this->read_ptr, elem_width, dtype); + checksum += send_binary_array(this->arr, this->read_ptr, elem_width, dtype); + *c = checksum; + return 1; + } + ESP_LOGW(TAG, "write_ptr > read_ptr After loop around!!!!"); + return 0; + }else{ + if (dataclass::write_ptr > dataclass::read_ptr){ + checksum += send_binary_array(this->arr + this->read_ptr, this->write_ptr - this->read_ptr, elem_width, dtype); + *c = checksum; + return 1;} + + if (dataclass::write_ptr == dataclass::read_ptr){ + dataclass::read_available = false; + return 0; + } + ESP_LOGW(TAG, "write_ptr < read_ptr WITHOUT loop around!!!!"); + return 0; + } + return 0; +} + +bool dataclass::pop(uint32_t* data){ + if (!(dataclass::available)){ + ESP_LOGE(TAG, "Add failed, not initialized"); + return false; + } + if (!(dataclass::read_available)){ + ESP_LOGW(TAG, "No data available"); + return false; + } + + if (dataclass::get_length() == 0){ + dataclass::read_available = false; + ESP_LOGW(TAG, "No data available"); + return false; + } + + if (dataclass::read_ptr >= dataclass::_length){ + ESP_LOGE(TAG, "Read_pointer outside range"); + return false; + } + + *data = dataclass::arr[dataclass::read_ptr]; + dataclass::read_ptr += 1; + dataclass::length -= 1; + if (dataclass::read_ptr >= dataclass::_length){ + dataclass::read_ptr = 0; + dataclass::loop_ahead = false; + } + return true; +} + +uint32_t dataclass::pop(void){ + uint32_t a; + if (dataclass::pop(&a)) return a; + return 0xABCDEF01; +} + +void dataclass::send_serial(const char* tag){ + + if (!this->available) return; + uint16_t tmp_var = dataclass::get_length(); + Serial.printf("Data:%s,Length:%d\t", tag, tmp_var); + if (tmp_var == 0){ + Serial.println(); + return; + } + for (uint16_t i = 0; i < tmp_var; i++){ + Serial.printf("%d,", dataclass::pop()); + } + Serial.print("\n"); + return; +} + +// "tag":[v0,v1,...] — channel array for the cloud/openJII JSON measurement sink. +void dataclass::send_json(const char* tag){ + if (!this->available) return; + uint16_t n = dataclass::get_length(); + Serial.printf("\"%s\":[", tag); + for (uint16_t i = 0; i < n; i++){ + if (i > 0) Serial.print(','); + Serial.print(dataclass::pop()); + } + Serial.print(']'); +} + +// Pack each value into elem_width bytes (little-endian low bytes), write to Serial, and +// return the byte-sum of exactly those bytes (Change 1: the data-trailer checksum is over +// the bytes actually sent). elem_width 4 = full uint32 (legacy/v1); 2 = low 16 bits with +// unsigned values (dtype 0) CLAMPED to 0xFFFF (Change 2 — calc_signal can exceed 16 bits +// near saturation; clamp, don't wrap). Signed (dtype 1) passes the stored int16 bit-pattern +// through unchanged; the host interprets the 2 bytes per dtype. +static uint8_t send_binary_array(uint32_t* arr, uint16_t len, uint8_t elem_width, uint8_t dtype){ + uint8_t checksum = 0; + if (elem_width >= 4){ + Serial.write((uint8_t*) arr, (size_t) len * 4); + for (uint16_t i = 0; i < len; i++) checksum += u32_byte_sum(arr[i]); + return checksum; + } + // elem_width == 2: low 16 bits, batched into a small buffer to avoid per-byte writes. + uint8_t buf[128]; + uint16_t bi = 0; + for (uint16_t i = 0; i < len; i++){ + uint32_t v = arr[i]; + uint16_t w = ((dtype == 0) && (v > 0xFFFF)) ? 0xFFFF : (uint16_t) v; + uint8_t lo = (uint8_t) w; + uint8_t hi = (uint8_t) (w >> 8); + buf[bi++] = lo; + buf[bi++] = hi; + checksum += lo + hi; + if (bi >= sizeof(buf)){ + Serial.write(buf, bi); + bi = 0; + } + } + if (bi > 0) Serial.write(buf, bi); + return checksum; +} + +// Link-level wake handshake (Change 4: one wake per run, then arrays stream back-to-back). +// Sends WAKE_AMBYTE until the ambyte acks AMBYTE_AWAKE / AMBYTE_CALLS / AMBYTE_CALLFORRESET. +// Power saving preserved: light-sleep between pulses after the first 10 fast tries (unless +// FLAG_DEICE forces the busy "power wasting" path). Returns 1 awake, ERR_LOST_SYNC on +// AMBYTE_CALLS, 0 on AMBYTE_CALLFORRESET, ERR_NO_DATA_REQUEST on timeout. The leftover +// AMBYTE_AWAKE byte is left in the buffer; the first fsm_send_array flushes it. +int ambyte_wake(bool interrupt){ + (void) interrupt; // abort byte handled by the run loop, not the wake; kept for the API + unsigned int timer1 = millis(); + int ret = -1; + uint8_t wake_up_reason, cmd_wait_time; + int16_t wake_call_counter = 0; + int16_t max_wake_try = 2000; + cmd_wait_time = 15; + flush_serial(10); + // sending wake up calls, first 10 in 10ms, remaining pulse every second w/ light sleep + while (wake_call_counter < max_wake_try){ + Serial.write(WAKE_AMBYTE); + Serial.flush(); + ret = serial_read_until(AMBYTE_AWAKE, AMBYTE_CALLS, AMBYTE_CALLFORRESET, cmd_wait_time, false); + if (ret > 0) break; + // after first 10 fast tries, pulse every second with light sleep + if (wake_call_counter == 10){ + esp_sleep_enable_timer_wakeup(1000000); // set up light sleep timer + cmd_wait_time = 100; + } + if (wake_call_counter > 10){ + wake_up_reason = 0; + + if (!FLAG_DEICE){ // Power saving mode + esp_light_sleep_start(); + wake_up_reason = esp_sleep_get_wakeup_cause(); + }else{ // Power wasting mode + for (uint8_t j = 0; j < 10; j++){ + ret = serial_read_until(AMBYTE_AWAKE, AMBYTE_CALLS, AMBYTE_CALLFORRESET, 100, false); + if (ret > 0) break; + } + } + + if (wake_up_reason == 8){ // wake up by uart + max_wake_try -= wake_call_counter; + wake_call_counter = 0; + } + } + wake_call_counter += 1; + if (millis() - timer1 > 3600000) break; + } + + if (ret == 1){ // Normal: ambyte awake + ESP_LOGV(TAG, "Ambyte awake in %d ms with %d tries", millis() - timer1, wake_call_counter); + return 1; + }else if (ret == 2){ // Lost sync + ESP_LOGE(TAG, "ERR_LOST_SYNC"); + Serial.read(); + return ERR_LOST_SYNC; + }else if (ret == 3){ + ESP_LOGE(TAG, "Ambyte calls for re-start"); + Serial.read(); + return 0; + }else{ // no response within timeout + return ERR_NO_DATA_REQUEST; + } +} + +// Stream one array to an already-awake ambyte (Change 4): length header + data + trailer. +// Header (Change 1, self-describing): {212, 150, arr_idx, lenHi, lenLo, elem_width, dtype, +// csum}, csum = sum of bytes [0..6]. Then length*elem_width data bytes, then the trailer +// {212, 0, 0, csum} whose csum is the byte-sum of exactly those data bytes. The host loops +// on the 212 marker and stops when run_esp.cpp emits the run's trailing 240 instead. +// Returns 0 on success, ERR_CHECKSUM_FAILED if the host keeps rejecting the data. +int dataclass::fsm_send_array(uint8_t arr_idx, uint8_t elem_width, uint8_t dtype){ + if (!this->available) return 1; + + uint16_t n = dataclass::get_length(); + + // --- length header --- + uint8_t hdr[8] = {212, 150, arr_idx, 0, 0, elem_width, dtype, 0}; + hdr[3] = ((n >> 8) & 0xFF); + hdr[4] = (n & 0xFF); + for (uint8_t i = 0; i < 7; i++) hdr[7] += hdr[i]; + flush_serial(5); // also clears the leftover AMBYTE_AWAKE from the wake + Serial.write(hdr, 8); + Serial.flush(); + + int ret = serial_read_until(AMBYTE_READY_FOR_ARRAY, 0, AMBYTE_CALLFORRESET, 200, true); + if (ret != 1){ + ESP_LOGE(TAG, "Array %d: no READY_FOR_ARRAY (got %d)", arr_idx, ret); + return 0; + } + + // --- data + trailer (retry while the host requests a resend) --- + for (uint8_t attempt = 0; attempt < 6; attempt++){ + uint8_t trailer[4] = {212, 0, 0, 0}; + flush_serial(5); + this->send(elem_width, dtype, &trailer[3]); // write data, fill the trailer checksum + Serial.flush(); + Serial.write(trailer, 4); + Serial.flush(); + + ret = serial_read_until(AMBYTE_DATA_PASS, AMBYTE_READY_FOR_ARRAY, AMBYTE_CALLFORRESET, 500, true); + if (ret == 1){ // pass + ESP_LOGV(TAG, "Array %d sent: %d elems x %d B", arr_idx, n, elem_width); + return 0; + }else if (ret == 2){ // host asked to resend (sent READY_FOR_ARRAY again) + ESP_LOGW(TAG, "Array %d: resend requested", arr_idx); + continue; + }else if (ret == 3){ // call for restart + ESP_LOGE(TAG, "Ambyte calls for re-start"); + return 0; + }else{ + ESP_LOGE(TAG, "Array %d: no DATA_PASS", arr_idx); + return 0; + } + } + return ERR_CHECKSUM_FAILED; +} + +int dataclass::fsm_send_esp(uint8_t arr_idx){ + return this->fsm_send_esp(arr_idx, false); +} + +// Legacy single-array convenience: wake the link then send one uint32 array (elem_width 4, +// dtype 0 -> host decodes as the v1 format). The primary run path (pam_send_results) instead +// wakes once via ambyte_wake() and streams every array with fsm_send_array(). +int dataclass::fsm_send_esp(uint8_t arr_idx, bool use_interrupt){ + if (!this->available) return 1; + if (ambyte_wake(use_interrupt) != 1) return ERR_NO_DATA_REQUEST; + this->fsm_send_array(arr_idx, 4, 0); + return 1; +} + +/* + insert a number to an array with order + large number will insert towards the end + used for get median + @param arr: array with sorted data + @param length: length of the array + @param c: new data to be inserted +*/ +void sorted_insert(uint32_t arr[], uint16_t length, uint32_t c){ + uint16_t n = 0; + uint16_t nM = length - 1; + + while (n < nM){ + if (arr[n] == 0){ + arr[n] = c; + break; + } + else if (c < arr[n]){ + for (uint8_t g = nM; g > n; g--){ + arr[g] = arr[g - 1]; + } + arr[n] = c; + break; + } else if (arr[n + 1] == 0){ + arr[n + 1] = c; + break; + }else{ + n += 1; + } + } + return; +} + + +uint32_t calc_signal(const uint32_t dark, const uint32_t lit, const uint8_t num){ + if (lit + 250 < dark) return 0; + uint32_t a = (lit - dark + 250); + int32_t b = a + 98 - dark * 0.006 / num; + + //int32_t tmp_var = (lit - dark + 250) - (0.006 / p) * (dark - 16384UL * p); + if (b > 0) return b; + return 0; +} + diff --git a/src/data_utils.h b/src/data_utils.h new file mode 100644 index 0000000..fe880e6 --- /dev/null +++ b/src/data_utils.h @@ -0,0 +1,83 @@ +#ifndef _DU_H +#define _DU_H + +#include +#include "config.h" + + +#define MAX_DATACLASS_SIZE 2000 +#define WAKE_AMBYTE 211 +#define AMBYTE_AWAKE 210 +#define AMBYTE_CALLS 170 +#define AMBYTE_CALLFORRESET 222 +#define AMBYTE_INTR 177 + +#define AMBYTE_READY_FOR_ARRAY 200 +#define AMBYTE_DATA_PASS 180 + +#define ERR_CHECKSUM_FAILED -10 +#define ERR_TOO_MANY_WKUP -4 +#define ERR_TOO_MANY_RETRY -9 +#define ERR_LOST_SYNC -2 +#define ERR_NO_DATA_REQUEST -5 + +class dataclass{ + + public: + uint32_t *arr = NULL; // data array handle + uint16_t write_ptr = 0; // pointer to next input location + uint16_t read_ptr = 0; // pointer to next read location + uint16_t peek_ptr = 0; // pointer to next read location + bool available = false; // indicator of memory allocation + bool write_available = false; // available to add data + bool read_available = false; // available to read data + uint16_t length = 0; + + uint16_t num_retry = 0; + + + + + dataclass(); + ~dataclass(); + + void clean(void); + void clear(void); + void put(uint32_t data); + uint16_t get_length(void); + bool pop(uint32_t* data); + uint32_t pop(void); + // Pack each stored uint32 into elem_width (2|4) bytes — low bytes, unsigned values + // clamped to the field — write them to Serial and return the byte-sum of exactly + // those bytes in *c. dtype (0 unsigned | 1 signed) is wire metadata for the host. + uint32_t send(uint8_t elem_width, uint8_t dtype, uint8_t* c); + bool init(uint16_t length); + void print_all(); + void send_serial(const char*); + void send_json(const char*); // "tag":[v0,v1,...] for the cloud/openJII sink + + //-- ambyte binary protocol --// + // Stream one array to an already-awake ambyte: length header + data + trailer. + // elem_width = 2|4 bytes/elem, dtype = 0 unsigned | 1 signed (Change 1/2/4). + int fsm_send_array(uint8_t arr_idx, uint8_t elem_width, uint8_t dtype); + // Legacy convenience: wake the link then send one uint32 array (elem_width 4, dtype 0). + int fsm_send_esp(uint8_t arr_idx); + int fsm_send_esp(uint8_t arr_idx, bool interrupt); + + + private: + bool loop_ahead = false; + uint16_t _overwritten_counter = 0; + uint16_t _length = 0; // size of data inside + +}; + +void sorted_insert(uint32_t arr[], uint16_t length, uint32_t c); +uint32_t calc_signal(uint32_t, uint32_t, uint8_t); + +// Link-level wake handshake for the ambyte binary protocol (Change 4: one wake per +// run, then arrays stream back-to-back). Returns 1 when the ambyte is awake. +int ambyte_wake(bool interrupt); + + +#endif \ No newline at end of file diff --git a/src/do_command.h b/src/do_command.h new file mode 100644 index 0000000..37ae9d6 --- /dev/null +++ b/src/do_command.h @@ -0,0 +1,434 @@ + +#include +#include +#include +#include + +#include "serial.h" +#include "src/mlx90632/u_mlx.h" +#include "src/as7341/spec_meas.h" +#include "data_utils.h" +#include "PAM.h" +#include "core.h" +#include "nvs1.h" +#include + +int check_connections(); +extern Preferences preferences; +extern bool FLAG_DEICE; +static const char* TAG1 = "do_Cmd"; + +constexpr unsigned hash(const char *string) +{ + return *string == 0 ? 17325 : *string + (*string * hash(string+1)); +} + +void do_command(char *choose){ + + int setting; + // char choose[50]; //buffer to hold commands + + //Serial_Input_Chars(choose, "+", 500, sizeof(choose) - 1); + + for (unsigned i = 0; i < strlen(choose); ++i) { // remove ctrl characters + if (!isprint(choose[i])) + choose[i] = 0; + } + + if (strlen(choose) < 1) { // short or null command, quietly ignore it + return; + } + + if (!isalnum(choose[0])) { + // Serial_Printf("error: not a-n\n"); + return; // go read another command + } + + unsigned val; // we accept int or alpha commands + if (isdigit(choose[0])) { + val = atoi(choose); + } + else { + val = hash(choose); // convert alpha command to an int + } + + + //Serial.printf("cmd: %s\n", choose); + // process single commands + switch (val) { + case hash("hello"): + { + Serial.print("NEW Name Here"); + Serial.println(" Ready"); + } + break; + + int external_trigger_run(void); + case hash("ww"): + { + Serial.println("Start"); + external_trigger_run(); + Serial.println("Exit"); + + } + break; + + int external_trigger_run_Flash(unsigned int gate_time, unsigned int dt, const uint16_t num); + case hash("ff"): + { + unsigned int t = Serial_Input_Long(",", 10); + unsigned int dt = Serial_Input_Long(",", 10); + unsigned int num = Serial_Input_Long(",", 10); + external_trigger_run_Flash(t, dt, num); + + } + break; + + + + case hash("set_currents"): + { + uint8_t i620 = (uint8_t) Serial_Input_Long(",", 10); + uint8_t i720 = (uint8_t) Serial_Input_Long(",", 10); + uint8_t ir = (uint8_t) Serial_Input_Long(",", 10); + core_set_currents(i620, i720, ir); + Serial.printf("Currents set to %d, %d, %d\n", adpd_current_config.I620, adpd_current_config.I720, adpd_current_config.IR); + } + break; + + case hash("set_gains"): + { + uint8_t fluo = (uint8_t) Serial_Input_Long(",", 10); + uint8_t fluoRef = (uint8_t) Serial_Input_Long(",", 10); + uint8_t ir = (uint8_t) Serial_Input_Long(",", 10); + uint8_t irRef = (uint8_t) Serial_Input_Long(",", 10); + uint8_t sun = (uint8_t) Serial_Input_Long(",", 10); + uint8_t leaf = (uint8_t) Serial_Input_Long(",", 10); + core_set_gains(fluo, fluoRef, ir, irRef, sun, leaf); + Serial.printf("Gains set to %d, %d, %d, %d, %d, %d\n", adpd_gains_config.Fluo, adpd_gains_config.FluoRef, adpd_gains_config.IR, adpd_gains_config.IRRef, adpd_gains_config.Sun, adpd_gains_config.Leaf); + } + break; + + case hash("mlx"): + { + unsigned int timer = millis(); + for (uint8_t i = 0; i < 100; i++){ + Serial.println(mlx_measure()); + } + Serial.printf("Spend %f ms per measurement", (millis() - timer)/100.0); + } + break; + + case hash("temp"): + { + // uint32_t ret; + // uint8_t mode = 5; + // float_t temp = 0.0; + + + // ret = PAM_get_env(0, 500); + // Serial.print(PAM_retrieve_env(ret, &mode)); + // Serial.printf(" %d \n", mode); + + // ret = PAM_get_env(4, 600); + // Serial.println(PAM_retrieve_env(ret, &mode, &temp)); + // Serial.printf(" %d %f \n", mode, temp); + double obj,amb,obj_r; + int16_t a1,a2,a3,a4; + + mlx_measure(&obj, &amb, &obj_r, &a1, &a2, &a3, &a4); + Serial.printf("%.4f\t%.4f\t%.4f\n", obj, amb, obj_r); + + + } + break; + + case hash("clean_nvs"): + { + nvs_flash_erase(); + nvs_flash_init(); + Serial.println("NVS cleaned"); + } + break; + + case hash("baseline"): + { + conf_slow_FR_1(100, 20, 0, 1, 5, 5, 1, 5, 5); + uint8_t c = Serial_Input_Long(",", 10); + adpd_mode = ADPD_CONFIG_MODE::ARRAY_MODE1; + uint32_t ret[6] = {0}; + fluor_offset(ret); + Serial.printf("%d,%d,%d,%d,%d,%d\n", ret[0], ret[1], ret[2], ret[3], ret[4], ret[5]); + if (c == 1){ + if (ret[0] > 400){ + Serial.println("Baseline too high"); + break; + } + preferences.begin("config", false); + preferences.putUInt("adpd_dark", ret[0]); + preferences.end(); + Serial.println("Baseline saved"); + } + } + break; + + case hash("tttt"): + Serial.println(sizeof(ambit_calibration_info_t)); + break; + + + + case hash("arrun"): + { + uint8_t len = (uint8_t) Serial_Input_Long(",", 10); + uint8_t persist = (uint8_t) Serial_Input_Long(",", 10); + uint8_t arr[128] = {0}; + uint8_t tmp_8 = 0; + for (uint8_t i = 0; i < len; i++){ + for (uint8_t j = 0; j < 8; j++){ + arr[i * 8 + j] = (uint8_t) Serial_Input_Long(",", 10); + } + } + + core_run_array(16, arr, persist, false); + } + break; + + case hash("arrun1"): + { + uint8_t len = (uint8_t) Serial_Input_Long(",", 10); + uint8_t persist = (uint8_t) Serial_Input_Long(",", 10); + uint8_t arr[128] = {0}; + uint8_t tmp_8 = 0; + CONNECTION_TYPE = CONNECTION_TYPES::PLOTTING; + + + for (uint8_t i = 0; i < len; i++){ + for (uint8_t j = 0; j < 8; j++){ + arr[i * 8 + j] = (uint8_t) Serial_Input_Long(",", 10); + } + } + + core_run_array(16, arr, persist, false); + } + Serial.println("Done"); + break; + + // arrun2 — like arrun1 but COMPUTER mode. Runs the whole trace, then dumps + // each data array as one ASCII block ("Data:,Length:N\t v,v,...,") + // ending with "Data sent". No per-point streaming → no inter-point UART + // gaps, so it stays in sync on the ambyte (device-to-device) link. + case hash("arrun2"): + { + uint8_t len = (uint8_t) Serial_Input_Long(",", 10); + uint8_t persist = (uint8_t) Serial_Input_Long(",", 10); + uint8_t arr[128] = {0}; + CONNECTION_TYPE = CONNECTION_TYPES::COMPUTER; + + for (uint8_t i = 0; i < len; i++){ + for (uint8_t j = 0; j < 8; j++){ + arr[i * 8 + j] = (uint8_t) Serial_Input_Long(",", 10); + } + } + + core_run_array(16, arr, persist, false); + } + break; + + + case hash("q"): + { + uint8_t a = (uint8_t) Serial_Input_Long(",", 10); + + uint8_t b = (uint8_t) Serial_Input_Long(",", 10); + uint8_t c = (uint8_t) Serial_Input_Long(",", 10); + + uint8_t arr[24] = {a, 0, 1, 0, 0, b, 0, 1, \ + a, 0, 1, 0, 0, b, c, 1,\ + a, 0, 1, 0, 0, b, 0, 1}; + + CONNECTION_TYPE = CONNECTION_TYPES::PLOTTING; + //CONNECTION_TYPE = CONNECTION_TYPES::COMPUTER; + core_run_array(3, arr, 0, false); + CONNECTION_TYPE = CONNECTION_TYPES::COMPUTER; + + } + break; + + case hash("get_par"): + { + uint16_t spec[10]; + Serial.println(get_PAR(spec)); + Serial.printf("%d,%d,%d,%d,%d,%d,%d,%d,%d,%d\n",spec[0],spec[1],spec[2],spec[3],spec[4],spec[5],spec[6],spec[7],spec[8],spec[9]); + } + break; + + case hash("PAR"): + { + uint16_t spec[10]; + Serial.println(get_PAR(spec) * ambit_calibration_local.spec_coef); + Serial.printf("%d,%d,%d,%d,%d,%d,%d,%d,%d,%d\n",spec[0],spec[1],spec[2],spec[3],spec[4],spec[5],spec[6],spec[7],spec[8],spec[9]); + } + break; + + + case hash("awake"): + { + + while(1){ + uint16_t spec[10]; + get_PAR(spec); + } + + } + break; + + + case hash("r"): + { + uint8_t a = (uint8_t) Serial_Input_Long(",", 10); + uint8_t b = (uint8_t) Serial_Input_Long(",", 10); + uint8_t c = (uint8_t) Serial_Input_Long(",", 10); + + uint8_t arr[24] = {a, 0, 1, 0, 0, b, 0, 1, \ + a, 0, 1, 0, 0, b, c, 1,\ + a, 0, 1, 0, 0, b, 0, 1}; + + CONNECTION_TYPE = CONNECTION_TYPES::AMBYTE; + //CONNECTION_TYPE = CONNECTION_TYPES::COMPUTER; + FLAG_DEICE = true; + core_run_array(3, arr, 0, true); + FLAG_DEICE = false; + CONNECTION_TYPE = CONNECTION_TYPES::COMPUTER; + + } + break; + + case hash("w"): + { + CONNECTION_TYPE = CONNECTION_TYPES::PLOTTING; + uint16_t length = Serial_Input_Long(",", 10); + uint8_t interval = (uint8_t) Serial_Input_Long(",", 10); + uint8_t act = (uint8_t) Serial_Input_Long(",", 10); + core_run_mpf(length, interval, false, act); + } + break; + + + case hash("a"): + { + uint8_t a = Serial_Input_Long(",", 10); + uint8_t b = Serial_Input_Long(",", 10); + + as7431_blink(a, b); + + + } + break; + + + case hash("aa"): + { + uint8_t a = Serial_Input_Long(",", 10); + + for (uint8_t i = 0; i < 4; i++){ + as7431_blink(i, a); + } + + for (uint8_t i = 0; i < 4; i++){ + as7431_blink(i, a); + } + + for (uint8_t i = 0; i < 4; i++){ + as7431_blink(i, a); + } + + for (uint8_t i = 0; i < 4; i++){ + as7431_blink(i, a); + } + + + } + break; + + + + + + case hash("set_act"): + { + float_t a = (float_t) Serial_Input_Double(",", 10); + preferences.begin("config", false); + preferences.putFloat("actinic", a); + preferences.end(); + } + break; + + case hash("set_name"): + { + char s[16]; + + Serial_Input_Chars(s, ",\n\r", 10, 15); + preferences.begin("config", false); + preferences.putString("name", s); + preferences.end(); + } + break; + + case hash("set_emit"): + { + double a = Serial_Input_Double(",", 10); + preferences.begin("config", false); + preferences.putDouble("emit", a); + preferences.end(); + } + break; + + case hash("set_spec"): + { + float_t f = (float_t) Serial_Input_Double(",", 10); + preferences.begin("config", false); + preferences.putFloat("spec", f); + preferences.end(); + } + break; + + case hash("reboot"): + { + ESP.restart(); + } + break; + + case hash("check"): + { + check_connections(); + } + break; + + int optic_test(); + case hash("test"): + { + optic_test(); + } + break; + + int optic_test(uint8_t current, uint8_t num_integ, uint8_t lit_offset, uint8_t dark1_offset, uint8_t dark2_offset, uint8_t pulse_offset, uint8_t pulse_duration); + + case hash("test1"): + { + uint8_t current = (uint8_t) Serial_Input_Long(",", 10); + uint8_t num_integ = (uint8_t) Serial_Input_Long(",", 10); + uint8_t lit_offset = (uint8_t) Serial_Input_Long(",", 10); + uint8_t dark1_offset = (uint8_t) Serial_Input_Long(",", 10); + uint8_t dark2_offset = (uint8_t) Serial_Input_Long(",", 10); + uint8_t pulse_offset = (uint8_t) Serial_Input_Long(",", 10); + uint8_t pulse_duration = (uint8_t) Serial_Input_Long(",", 10); + optic_test(current, num_integ, lit_offset, dark1_offset, dark2_offset, pulse_offset, pulse_duration); + } + break; + default: + Serial.println("BAD COMMAND"); + break; + + } +} \ No newline at end of file diff --git a/src/frontend_cloud.cpp b/src/frontend_cloud.cpp new file mode 100644 index 0000000..0f8a880 --- /dev/null +++ b/src/frontend_cloud.cpp @@ -0,0 +1,157 @@ +// frontend_cloud — cloud/app (USB-CDC) variant: wires the device's snapshot +// commands into the openJII protocol module and drives it. Gated on VARIANT_CLOUD +// so it is empty in the ambyte image. +// +// Increment 1: snapshot commands only (hello / temp / get_par / PAR). Measurement +// commands (arrun/q/mpf as one streamed JSON value per envelope position) are +// added once D6 — the app's exact in-envelope measurement shape — is settled. +#ifdef VARIANT_CLOUD + +#include +#include +#include "openjii_proto.h" +#include "src/devices_init.h" +#include "src/adpd/u_adpd6100.h" +#include "src/as7341/spec_meas.h" +#include "src/mlx90632/u_mlx.h" +#include "nvs1.h" +#include "config.h" +#include "PAM.h" + +extern ADPD6 adpd; // defined in ambit-1.ino + +// ── snapshot command handlers (command-as-root, §2.1) ─────────────────────── + +static void cmd_hello(const String& args, JsonVariant root) { + root["device"] = "Ambit"; + root["version"] = "0.0.3"; + root["name"] = ambit_calibration_local.ambit_name; +} + +static void cmd_temp(const String& args, JsonVariant root) { + double leaf, ambient, reflect; + int16_t a1, a2, a3, a4; + mlx_measure(&leaf, &ambient, &reflect, &a1, &a2, &a3, &a4); + root["leaf"] = leaf; + root["ambient"] = ambient; + root["reflect"] = reflect; +} + +static void cmd_get_par(const String& args, JsonVariant root) { + uint16_t spec[10]; + float par = get_PAR(spec); + root["par_raw"] = par; + JsonArray ch = root["channels"].to(); + for (int i = 0; i < 10; i++) ch.add(spec[i]); +} + +static void cmd_PAR(const String& args, JsonVariant root) { + uint16_t spec[10]; + float par = get_PAR(spec) * ambit_calibration_local.spec_coef; + root["par"] = par; + JsonArray ch = root["channels"].to(); + for (int i = 0; i < 10; i++) ch.add(spec[i]); +} + +// ── entry points called from ambit-1.ino under VARIANT_CLOUD ──────────────── + +// ── measurement command (one streamed JSON value per envelope slot) ───────── +// n-th comma token of `a` (token 0 is before the first comma). +static long arg_long(const String& a, uint8_t n, long def = 0) { + int start = 0; + for (uint8_t i = 0; i < n; i++) { + start = a.indexOf(',', start); + if (start < 0) return def; + start++; + } + return a.substring(start).toInt(); +} + +// Parse comma-separated uint8 values from token index `from` into arr. +static uint8_t arg_array8(const String& a, uint8_t from, uint8_t* arr, uint8_t maxLen) { + uint8_t count = 0; + int pos = 0; + for (uint8_t i = 0; i < from; i++) { + pos = a.indexOf(',', pos); + if (pos < 0) return 0; + pos++; + } + while (pos >= 0 && pos < (int)a.length() && count < maxLen) { + int next = a.indexOf(',', pos); + if (next < 0) next = a.length(); + arr[count++] = (uint8_t) a.substring(pos, next).toInt(); + pos = next + 1; + if (next == (int)a.length()) break; + } + return count; +} + +// arrun,,,<8*len array bytes> — runs an array-mode measurement and +// emits one JSON object {"env":[..],"s_fluo":[..],...}. run_arr_type1's json_output +// path writes it to Serial, which IS the openJII output stream in the cloud build. +static void cmd_arrun(const String& args, Print& out) { + uint8_t len = (uint8_t) arg_long(args, 0); + uint8_t persist = (uint8_t) arg_long(args, 1); + uint8_t arr[128] = {0}; + uint8_t parsed = arg_array8(args, 2, arr, len * 8); + if (len == 0 || parsed == 0) { out.print("{\"error\":\"bad_arrun\"}"); return; } + + if (!adpd_gains_config.init) adpd_gains_config.init = true; + if (!adpd_current_config.init) adpd_current_config.init = true; + if (adpd_mode != ADPD_CONFIG_MODE::ARRAY_MODE1) { + conf_slow_FR_1(); + adpd_mode = ADPD_CONFIG_MODE::ARRAY_MODE1; + } + CONNECTION_TYPE = CONNECTION_TYPES::COMPUTER; // no inline plotting; JSON emitted at the end + run_arr_type1(16, arr, persist, false, true); // json_output -> writes the JSON object to Serial +} + +// printf reaches the ESP-IDF console (USB-Serial/JTAG) regardless of CDC DTR, so +// these per-step markers show exactly where init reaches / hangs. +#define INIT_STEP(label, expr) do { printf("[init] " label "...\n"); expr; printf("[init] " label " ok\n"); } while (0) + +void cloud_setup() { + // Pin setup + STF strobe pulse BEFORE device init — mirrors fork A's proven + // app-compatible startup; skipping the strobe can hang the detector init. + esp_timer_early_init(); + pinMode(STF_FLASH_PIN, OUTPUT); + digitalWrite(STF_FLASH_PIN, LOW); + pinMode(10, OUTPUT); + digitalWrite(10, LOW); + + Serial.begin(115200); + Serial.setTimeout(50); + printf("\n[init] boot (cloud)\n"); + esp_log_level_set("*", ESP_LOG_NONE); + + digitalWrite(STF_FLASH_PIN, HIGH); + delayMicroseconds(1); + digitalWrite(STF_FLASH_PIN, LOW); + + INIT_STEP("i2c_bus", init_i2c_bus()); + INIT_STEP("spi_bus", init_spi_bus()); + INIT_STEP("adpd", adpd.begin()); + INIT_STEP("as7341", as7341.begin()); + INIT_STEP("check_as", check_AS7341()); + INIT_STEP("led_off", AS_LED_OFF()); + INIT_STEP("mlx", mlx_init()); + INIT_STEP("nvs", load_info_from_nvs(false)); + + esp_log_level_set("*", ESP_LOG_NONE); // UART0 is also the protocol port — keep it clean + CONNECTION_TYPE = CONNECTION_TYPES::COMPUTER; + + ojii::identity({ "Ambit", "0.0.3", 0.003f }); + ojii::on("hello", cmd_hello); + ojii::on("temp", cmd_temp); + ojii::on("get_par", cmd_get_par); + ojii::on("PAR", cmd_PAR); + ojii::on_stream("arrun", cmd_arrun); + + printf("[init] Ready (cloud)\n"); +} + +void cloud_loop() { + ojii::poll(Serial); +} + +#endif // VARIANT_CLOUD diff --git a/src/nvs1.cpp b/src/nvs1.cpp new file mode 100644 index 0000000..da1123d --- /dev/null +++ b/src/nvs1.cpp @@ -0,0 +1,117 @@ +#include "nvs1.h" +#include "src/mlx90632/u_mlx.h" +#include + +extern Preferences preferences; +struct ambit_calibration_info_t ambit_calibration_local, ambit_calibration_income; +struct ambit_FW_info_t ambit_FW_info; +struct metadata_t metadata_epprom, metadata_incoming; + + + +static void get_FW_info(void){ + ambit_FW_info.MAC = ESP.getEfuseMac(); + ambit_FW_info.Size = ESP.getSketchSize(); + strncpy(ambit_FW_info.FW_date, __DATE__, 12); + ambit_FW_info.Checksum = 0xFF & ((MAJOR_VERSION << 4) | (MINOR_VERSION << 2) | (BATCH_VERSION << 0)); + + return; +} + + +static void load_metadata(void){ + preferences.begin("metadata", true); + if (preferences.isKey("lon")) metadata_epprom.lon = preferences.getDouble("lon", 1.0); + if (preferences.isKey("lat")) metadata_epprom.lat = preferences.getDouble("lat", 1.0); + if (preferences.isKey("alt")) metadata_epprom.alt = preferences.getFloat("alt", 1.0); + if (preferences.isKey("time")) metadata_epprom.time = preferences.getUInt("time", 1); + if (preferences.isKey("acc")) metadata_epprom.acc = preferences.getFloat("acc", 1.0); + if (preferences.isKey("vacc")) metadata_epprom.vacc = preferences.getFloat("vacc", 1.0); + if (preferences.isKey("info1")) preferences.getString("info1", metadata_epprom.info1, 200); + if (preferences.isKey("x")) metadata_epprom.x = preferences.getFloat("x", 0.0); + if (preferences.isKey("y")) metadata_epprom.y = preferences.getFloat("y", 0.0); + if (preferences.isKey("z")) metadata_epprom.z = preferences.getFloat("z", 0.0); + preferences.end(); + memcpy(&metadata_incoming, &metadata_epprom, sizeof(metadata_t)); + return; +} + +void save_metadata(void){ + //QC + if (metadata_incoming.lon < -180.0 || metadata_incoming.lon > 360.0) return; + if (metadata_incoming.lat < -90.0 || metadata_incoming.lat > 90.0) return; + if (metadata_incoming.alt < -500.0 || metadata_incoming.alt > 30000.0) return; + // Save metadata to NVS + preferences.begin("metadata", false); + preferences.putDouble("lon", metadata_incoming.lon); + preferences.putDouble("lat", metadata_incoming.lat); + preferences.putFloat("alt", metadata_incoming.alt); + preferences.putUInt("time", metadata_incoming.time); + preferences.putFloat("acc", metadata_incoming.acc); + preferences.putFloat("vacc", metadata_incoming.vacc); + preferences.putString("info1", metadata_incoming.info1); + preferences.putFloat("x", metadata_incoming.x); + preferences.putFloat("y", metadata_incoming.y); + preferences.putFloat("z", metadata_incoming.z); + preferences.end(); + return; +} + + +static void load_calibration_info(){ + preferences.begin("config", true); + if (preferences.isKey("actinic")) ambit_calibration_local.actinic_coef = preferences.getFloat("actinic", 0.1); + if (preferences.isKey("spec")) ambit_calibration_local.spec_coef = preferences.getFloat("spec", 1.0); + if (preferences.isKey("emit")) ambit_calibration_local.mlx_emissivity = preferences.getDouble("emit", 1.0); + if (preferences.isKey("sun")) ambit_calibration_local.sun_coef = preferences.getFloat("sun", 1.0); + if (preferences.isKey("name")) preferences.getString("name", ambit_calibration_local.ambit_name, 20); + if (preferences.isKey("temp_offset")) ambit_calibration_local.temp_offset = preferences.getFloat("temp_offset", 0.0); + if (preferences.isKey("temp_slope")) ambit_calibration_local.temp_slope = preferences.getFloat("temp_slope", 1.0); + + if (preferences.isKey("act_50")) ambit_calibration_local.act_50 = preferences.getUShort("act_50", 1); + if (preferences.isKey("act_100")) ambit_calibration_local.act_100 = preferences.getUShort("act_100", 2); + if (preferences.isKey("act_150")) ambit_calibration_local.act_150 = preferences.getUShort("act_150", 3); + if (preferences.isKey("act_200")) ambit_calibration_local.act_200 = preferences.getUShort("act_200", 4); + if (preferences.isKey("act_250")) ambit_calibration_local.act_250 = preferences.getUShort("act_250", 5); + + if (preferences.isKey("adpd_lit")) ambit_calibration_local.adpd[1] = preferences.getUInt("adpd_lit", 0); + if (preferences.isKey("adpd_dark")) ambit_calibration_local.adpd[0] = preferences.getUInt("adpd_dark", 0); + if (preferences.isKey("adpd_sun")) ambit_calibration_local.adpd[2] = preferences.getUInt("adpd_sun", 0); + if (preferences.isKey("adpd_leaf")) ambit_calibration_local.adpd[3] = preferences.getUInt("adpd_leaf", 0); + if (preferences.isKey("adpd_730")) ambit_calibration_local.adpd[4] = preferences.getUInt("adpd_730", 0); + if (preferences.isKey("adpd_730r")) ambit_calibration_local.adpd[5] = preferences.getUInt("adpd_730r", 0); + preferences.end(); + mlx_read_coe(ambit_calibration_local.mlx_coef); + memcpy(&ambit_calibration_income, &ambit_calibration_local, sizeof(ambit_calibration_info_t)); +} + + + + + +void load_info_from_nvs(bool print){ + load_metadata(); + if (print){ + Serial.printf("Metadata: lon:%f\tlat:%f\talt:%f\ttime:%d\tacc:%f\tvacc:%f\tinfo1:%s\tx:%f\ty:%f\tz:%f\n", metadata_epprom.lon, metadata_epprom.lat, metadata_epprom.alt, metadata_epprom.time, metadata_epprom.acc, metadata_epprom.vacc, metadata_epprom.info1, metadata_epprom.x, metadata_epprom.y, metadata_epprom.z); + } + load_calibration_info(); + if (print){ + // print all ambit_calibration_local + Serial.printf("Calibration: Name:%s\tActinic:%f\tSpec:%f\tEmit:%f\tSun:%f\tTemp_offset:%f\tTemp_slope:%f\n", ambit_calibration_local.ambit_name, ambit_calibration_local.actinic_coef, ambit_calibration_local.spec_coef, ambit_calibration_local.mlx_emissivity, ambit_calibration_local.sun_coef, ambit_calibration_local.temp_offset, ambit_calibration_local.temp_slope); + Serial.printf("Calibration: Act_50:%d\tAct_100:%d\tAct_150:%d\tAct_200:%d\tAct_250:%d\n", ambit_calibration_local.act_50, ambit_calibration_local.act_100, ambit_calibration_local.act_150, ambit_calibration_local.act_200, ambit_calibration_local.act_250); + Serial.printf("Calibration: ADPD: %d\t%d\t%d\t%d\t%d\t%d\n", ambit_calibration_local.adpd[0], ambit_calibration_local.adpd[1], ambit_calibration_local.adpd[2], ambit_calibration_local.adpd[3], ambit_calibration_local.adpd[4], ambit_calibration_local.adpd[5]); + + Serial.printf("MLX: "); + for (int i = 0; i < 14; i++){ + Serial.printf("%d\t", ambit_calibration_local.mlx_coef[i]); + } + Serial.printf("\n"); + } + get_FW_info(); + if (print){ + Serial.printf("FW: MAC:%012llx\tSize:%d\tDate:%s\n", ambit_FW_info.MAC, ambit_FW_info.Size, ambit_FW_info.FW_date); + Serial.printf("FW: %d.%d.%d\n", ambit_FW_info.Major, ambit_FW_info.Minor, ambit_FW_info.Batch); + } + return; +} + diff --git a/src/nvs1.h b/src/nvs1.h new file mode 100644 index 0000000..57ee48b --- /dev/null +++ b/src/nvs1.h @@ -0,0 +1,65 @@ +#ifndef _NVS1_H_ +#define _NVS1_H_ +#include +#include "nvs_flash.h" + +#define MAJOR_VERSION 0 +#define MINOR_VERSION 0 +#define BATCH_VERSION 6 // bump on every hosted build: a post-OTA cmd 33/2 version read confirms the update landed + +struct ambit_calibration_info_t +{ + char ambit_name[20] = "AmbitV003"; + int32_t mlx_coef[14] = {0}; + uint32_t adpd[6] = {0}; + float_t temp_offset = 0.0; + float_t temp_slope = 1.0; + float_t actinic_coef = 0.1; + float_t spec_coef = 1.0; + uint16_t act_50 = 5; + uint16_t act_100 = 4; + uint16_t act_150 = 3; + uint16_t act_200 = 2; + uint16_t act_250 = 1; + float_t mlx_emissivity = 1.0; + float_t sun_coef = 1.0; + float_t tick_factor = 0.854; // PAM point-period scale (ms tick -> s); surfaced to the ambyte +}; + +extern struct ambit_calibration_info_t ambit_calibration_local, ambit_calibration_income; + +struct ambit_FW_info_t +{ + uint8_t Major = MAJOR_VERSION; + uint8_t Minor = MINOR_VERSION; + uint8_t Batch = BATCH_VERSION; + uint32_t Size = 0; + uint64_t MAC = 0; + char FW_date[12]; + char reserved[12]; + uint8_t Checksum = 0; +}; + +extern struct ambit_FW_info_t ambit_FW_info; + +struct metadata_t +{ + double lon = 1.0; + double lat = 1.0; + float alt = 1.0; + float acc = 1.0; + float vacc = 1.0; + uint32_t time = 0; + float x = 0.0; + float y = 0.0; + float z = 0.0; + char info1[200] = "New_Ambit"; + uint16_t EOF_MARK = 2025; // end of file marker, used to check if the metadata is valid +}; + +extern struct metadata_t metadata_epprom, metadata_incoming; + +void load_info_from_nvs(bool print); +void save_metadata(void); + +#endif // _NVS1_H_ \ No newline at end of file diff --git a/src/run_esp.cpp b/src/run_esp.cpp new file mode 100644 index 0000000..44c7763 --- /dev/null +++ b/src/run_esp.cpp @@ -0,0 +1,489 @@ +#include +#include "data_utils.h" +#include "src/as7341/spec_meas.h" +#include "src/mlx90632/u_mlx.h" +#include "PAM.h" +#include "core.h" +#include +#include "nvs1.h" +#include +#include "esp_ota_ops.h" + +#define TAG "ESP" +#define ESP_CMD_HEADER 160 +#define ESP_CMD_DONE 161 +#define ESP_CMD_END 240 +#define ESP_WAKE_FOR_CMD 170 +#define MAX_ARR_LEN 16 + + + + + +// Config is the single global owned by PAM (adpd_current_config / adpd_gains_config). +// The binary frontend reads/writes the SAME struct as the text frontend, so a value +// set over one transport is applied by a run triggered over the other. +extern Preferences preferences; + +extern uint8_t CONNECTION_TYPE; +int serial_read_until(uint8_t target1, uint8_t target2 = 0, uint8_t target3 = 0, uint16_t timeout = 20, bool remove = false); + +// ── OTA-over-UART receiver state (cmds 25-28) ─────────────────────────────── +// The ambyte streams a new firmware image in CRC16-checked, sequenced chunks; we +// write each straight into the spare OTA partition via Arduino's Update, then +// reboot into it on OTA_END. There is no HW watchdog here, so multi-ms flash +// writes are safe; USB-Serial-JTAG (GPIO18/19) is the recovery path for a bad +// image. Update verifies the whole image (MD5/size) in end() before switching. +static uint16_t ota_expected_seq = 0; + +static uint16_t crc16_ccitt(const uint8_t *data, size_t len) +{ + uint16_t crc = 0xFFFF; + for (size_t i = 0; i < len; i++) { + crc ^= (uint16_t)data[i] << 8; + for (uint8_t b = 0; b < 8; b++) + crc = (crc & 0x8000) ? (uint16_t)((crc << 1) ^ 0x1021) : (uint16_t)(crc << 1); + } + return crc; +} + +/* Rollback safety: defer OTA image confirmation. The Arduino core auto-marks a + * freshly-OTA'd PENDING_VERIFY image valid at boot unless this weak hook returns + * true. We return true so a new image stays UNCONFIRMED until the ambyte sends + * OTA_CONFIRM (cmd 29) — i.e. until the ambyte has seen the rebooted image + * answer. If it never confirms (bad/unreachable image), the bootloader + * (CONFIG_BOOTLOADER_APP_ROLLBACK_ENABLE) rolls back to the previous image on + * the next reboot. A USB-flashed image is VALID (not pending), so unaffected. */ +extern "C" bool verifyRollbackLater() { return true; } + +// extern char ambit_name[]; +// float_t actinic_coef = 1.0; +// float_t spec_coef = 1.0; +// extern double mlx_emissivity; + + +int do_esp_cmd(){ + uint8_t cmd_arr[8], c, ret; + ESP_LOGV(TAG, "parse ESP commands"); + + //search for cmd header + ret = serial_read_until(ESP_CMD_HEADER, 0, 0, 100, true); + if (ret != 1){ + ESP_LOGE(TAG, "ESP cmd header failed"); + return -1; + } + + CONNECTION_TYPE = CONNECTION_TYPES::AMBYTE; + + // the real cmd will follows + c = Serial.readBytes(cmd_arr, 8); + if (c < 8){ + ESP_LOGE(TAG, "ESP cmd parse failed"); + return -1; + } + //Serial.printf("cmd is %d, %d, %d, %d, %d, %d, %d, %d\n", cmd_arr[0], cmd_arr[1], cmd_arr[2], cmd_arr[3], cmd_arr[4], cmd_arr[5], cmd_arr[6], cmd_arr[7]); + + switch (cmd_arr[0]) + { + case 1: // set PD gains + // wire convention: gains 1-indexed (1..6), value outside that = "no change" + core_set_gains( + (cmd_arr[1] > 0 && cmd_arr[1] < 7) ? cmd_arr[1] - 1 : adpd_gains_config.Fluo, + (cmd_arr[2] > 0 && cmd_arr[2] < 7) ? cmd_arr[2] - 1 : adpd_gains_config.FluoRef, + (cmd_arr[3] > 0 && cmd_arr[3] < 7) ? cmd_arr[3] - 1 : adpd_gains_config.IR, + (cmd_arr[4] > 0 && cmd_arr[4] < 7) ? cmd_arr[4] - 1 : adpd_gains_config.IRRef, + (cmd_arr[5] > 0 && cmd_arr[5] < 7) ? cmd_arr[5] - 1 : adpd_gains_config.Sun, + (cmd_arr[6] > 0 && cmd_arr[6] < 7) ? cmd_arr[6] - 1 : adpd_gains_config.Leaf); + ESP_LOGV(TAG, "gains are %d, %d, %d, %d, %d, %d", adpd_gains_config.Fluo, adpd_gains_config.FluoRef, adpd_gains_config.IR, adpd_gains_config.IRRef, adpd_gains_config.Sun, adpd_gains_config.Leaf); + Serial.write(ESP_CMD_DONE); + break; + + case 2: // set currents + // wire convention: current byte >= 127 = "no change" + core_set_currents( + (cmd_arr[1] < 127) ? cmd_arr[1] : adpd_current_config.I620, + (cmd_arr[2] < 127) ? cmd_arr[2] : adpd_current_config.I720, + (cmd_arr[3] < 127) ? cmd_arr[3] : adpd_current_config.IR); + ESP_LOGV(TAG, "currents are %d, %d, %d", adpd_current_config.I620, adpd_current_config.I720, adpd_current_config.IR); + Serial.write(ESP_CMD_DONE); + break; + + case 10: // array run config + core_config_detector(); // applies the global config + enters array mode + Serial.write(ESP_CMD_DONE); + break; + + case 20: // run mpf + { + if (adpd_gains_config.init == false) ESP_LOGE(TAG, "Gain preset not initized, use default!"); + if (adpd_current_config.init == false) ESP_LOGE(TAG, "Current preset not initized, use default!"); + + uint16_t length = (((uint16_t) cmd_arr[1]) << 7) + cmd_arr[2]; + uint8_t interval = cmd_arr[3]; + bool change_act = (bool) cmd_arr[4]; + uint8_t act = cmd_arr[5]; + + //Serial.printf("%d, %d, %d, %d\n", length, interval, change_act, act); + + Serial.write(ESP_CMD_DONE); + core_run_mpf(length, interval, change_act, act); + Serial.write(ESP_CMD_END); + } + break; + + case 21:// run + { + uint8_t arr_length = cmd_arr[1]; + uint8_t led_persist = cmd_arr[2]; + bool allow_interrupt = (bool) cmd_arr[3]; + + uint8_t cc = 0; + if ((arr_length == 0) || (arr_length > MAX_ARR_LEN)){ + ESP_LOGE(TAG, "run array wrong length: %d", arr_length); + break; + } + uint8_t run_arr[arr_length * 8]; + core_ensure_array_config(); + + cc = Serial.readBytes(run_arr, arr_length * 8); + if (cc != (arr_length * 8)){ + ESP_LOGE(TAG, "run array elements count %d not match config %d", cc, arr_length); + break; + } + Serial.write(ESP_CMD_DONE); + run_arr_type1(arr_length, run_arr, led_persist, allow_interrupt); + Serial.write(ESP_CMD_END); + + } + break; + + // ── Parallel measurement protocol (trigger → poll → fetch) ────────────── + case 22: // run start (async): ack, then run to completion into retained + // buffers. Same payload as cmd 21. The host gets CMD_DONE and moves + // on to the next sensor; no CMD_END (host trigger is ACK_ONLY). + { + uint8_t arr_length = cmd_arr[1]; + uint8_t led_persist = cmd_arr[2]; + bool allow_interrupt = (bool) cmd_arr[3]; + + if ((arr_length == 0) || (arr_length > MAX_ARR_LEN)){ + ESP_LOGE(TAG, "run start wrong length: %d", arr_length); + break; + } + uint8_t run_arr[arr_length * 8]; + core_ensure_array_config(); + + uint8_t cc = Serial.readBytes(run_arr, arr_length * 8); + if (cc != (arr_length * 8)){ + ESP_LOGE(TAG, "run start elements count %d not match config %d", cc, arr_length); + break; + } + Serial.write(ESP_CMD_DONE); + Serial.flush(); // ack must reach the host before the line goes quiet for the run + ambit_async_run_start(arr_length, run_arr, led_persist, allow_interrupt); + } + break; + + case 23: // poll async state -> 1 status byte (0 IDLE | 1 DONE | 2 ERROR) + { + Serial.write(ESP_CMD_DONE); + Serial.write(ambit_async_get_state()); + Serial.write(ESP_CMD_END); + } + break; + + case 24: // fetch retained async result: stream arrays over the AMBYTE FSM + { + Serial.write(ESP_CMD_DONE); + ambit_async_fetch(); // streams the held arrays, or nothing if none ready + Serial.write(ESP_CMD_END); + } + break; + + case 31: // get spec + { + uint16_t spec[12] = {0}; + float par = get_PAR(spec); + memcpy(spec + 10, &par, 4); + Serial.write(ESP_CMD_DONE); + Serial.write((uint8_t*) spec, 24); + Serial.write(ESP_CMD_END); + } + break; + + case 32: // get temp + { + double leaf, chip; + mlx_measure(&leaf, &chip); + Serial.write(ESP_CMD_DONE); + int16_t t1 = (int16_t) (leaf * 10); + int16_t t2 = (int16_t) (chip * 10); + Serial.write((uint8_t*) (&t1), 2); + Serial.write((uint8_t*) (&t2), 2); + Serial.write(ESP_CMD_END); + } + break; + + case 33: // retrieve ambit info + { + if (cmd_arr[1] == 1){ // send calibration info + Serial.write(ESP_CMD_DONE); + Serial.write((uint8_t*) &ambit_calibration_local, sizeof(ambit_calibration_info_t)); + Serial.write(ESP_CMD_END); + }else if (cmd_arr[1] == 2){ // send FW info + Serial.write(ESP_CMD_DONE); + Serial.write((uint8_t*) &ambit_FW_info, sizeof(ambit_FW_info_t)); + Serial.write(ESP_CMD_END); + }else if (cmd_arr[1] == 3){ // send metadata + Serial.write(ESP_CMD_DONE); + Serial.write((uint8_t*) &metadata_epprom, sizeof(metadata_t)); + Serial.write(ESP_CMD_END); + }else{ + Serial.write(ESP_CMD_END); + } + } + break; + + + + + case 34: // get temp and raw + { + double leaf, leaf_1, chip; + int16_t a1, a2, a3, a4; + mlx_measure(&leaf, &chip, &leaf_1, &a1, &a2, &a3, &a4); + Serial.write(ESP_CMD_DONE); + int16_t t1 = (int16_t) (leaf * 10); + int16_t t2 = (int16_t) (leaf_1 * 10); + int16_t t3 = (int16_t) (chip * 10); + Serial.write((uint8_t*) (&t1), 2); + Serial.write((uint8_t*) (&t2), 2); + Serial.write((uint8_t*) (&t3), 2); + Serial.write((uint8_t*) (&a1), 2); + Serial.write((uint8_t*) (&a2), 2); + Serial.write((uint8_t*) (&a3), 2); + Serial.write((uint8_t*) (&a4), 2); + Serial.write(ESP_CMD_END); + } + break; + + + case 37: // set metadata + { + Serial.write(ESP_CMD_DONE); + Serial.readBytes((uint8_t*) (&metadata_incoming), sizeof(metadata_t)); + Serial.write(ESP_CMD_END); + if (metadata_incoming.EOF_MARK == 2025) save_metadata(); + load_info_from_nvs(false); + } + break; + + + + case 4: // try/set actinic + { + AS_LED_OFF(); + Serial.write(ESP_CMD_DONE); + uint8_t type = cmd_arr[1]; + uint8_t var = cmd_arr[2]; + uint8_t var2 = cmd_arr[3]; + float_t _factor = 1.0; + if (type == 1){ // try actinics + AS_LED_Current(50); + AS_LED_ON(); + delay(3000); + AS_LED_Current(var); + delay(3000); + AS_LED_OFF(); + AS_LED_Current(0); + }else if (type == 2){ // set actinic offset + _factor = *((float *) &(cmd_arr[3])); + if ((_factor > 0.01) && (_factor < 1.01)){ + preferences.begin("config", false); + preferences.putFloat("actinic", _factor); + preferences.end(); + ambit_calibration_local.actinic_coef = _factor; + } + }else if (type == 4){ // set actinic offset + _factor = *((float *) &(cmd_arr[3])); + if ((_factor > 0.05) && (_factor < 100.01)){ + //preferences.begin("config", false); + //preferences.putFloat("spec", _factor); + //preferences.end(); + ambit_calibration_local.spec_coef = _factor; + } + }else if (type == 5){ + AS_LED_Current(var); + AS_LED_ON(); + delay(var2 * 100); + AS_LED_OFF(); + } + Serial.write(ESP_CMD_END); + } + break; + + + case 5: + { + uint8_t ambit_id = cmd_arr[1]; + uint8_t intensity = cmd_arr[2]; + Serial.write(ESP_CMD_DONE); + if ((ambit_id < 4) && (intensity > 4) && (intensity < 254)) as7431_blink(ambit_id, intensity); + Serial.write(ESP_CMD_END); + } + break; + + case 6: // do adpd baseline flash + { + Serial.write(ESP_CMD_DONE); + uint32_t ret[6] = {0}; + fluor_offset(ret); + preferences.begin("config", false); + preferences.putUInt("adpd_lit", ret[1]); + preferences.putUInt("adpd_sun", ret[2]); + preferences.putUInt("adpd_leaf", ret[3]); + preferences.putUInt("adpd_730", ret[4]); + preferences.putUInt("adpd_730r", ret[5]); + preferences.end(); + Serial.write(ESP_CMD_END); + load_info_from_nvs(false); + + } + break; + + case 17: // nvs update scalar + { + uint8_t type = cmd_arr[1]; // 1: actinic + uint8_t dtype = cmd_arr[2]; // 1: float + if ((type == 1) && (dtype == 1)){ // update actinic coef + Serial.write(ESP_CMD_DONE); + float_t _factor = *((float *) &(cmd_arr[3])); + if ((_factor > 0.01) && (_factor < 1.01)){ + preferences.begin("config", false); + preferences.putFloat("actinic", _factor); + preferences.end(); + ambit_calibration_local.actinic_coef = _factor; + load_info_from_nvs(false); + } + Serial.write(ESP_CMD_END); + } + + } + break; + + case 18: // nvs update array + { + uint8_t type = cmd_arr[1]; // 1: actinic linear test + float_t _factor = 1.0; + if (type == 1){ // update actinic linear readings + uint16_t _readingsf[6] = {0}; + Serial.write(ESP_CMD_DONE); + Serial.readBytes((uint8_t*) _readingsf, 12); + uint16_t checksum = 0; + _factor = *((float *) &(cmd_arr[4])); + for (int i = 0; i < 5; i++){ + checksum += _readingsf[i]; + } + if (checksum == _readingsf[5]){ + preferences.begin("config", false); + preferences.putUShort("act_50", _readingsf[0]); + preferences.putUShort("act_100", _readingsf[1]); + preferences.putUShort("act_150", _readingsf[2]); + preferences.putUShort("act_200", _readingsf[3]); + preferences.putUShort("act_250", _readingsf[4]); + preferences.putFloat("actinic", _factor); + preferences.end(); + load_info_from_nvs(false); + } + Serial.write(ESP_CMD_END); + } + + } + break; + + + + + + + // ── OTA-over-UART (cmds 25-28): host streams a new image; write via Update ── + case 25: // OTA_BEGIN: cmd_arr[1..4] = total image size (LE u32) + { + uint32_t size = (uint32_t)cmd_arr[1] | ((uint32_t)cmd_arr[2] << 8) | + ((uint32_t)cmd_arr[3] << 16) | ((uint32_t)cmd_arr[4] << 24); + if (Update.isRunning()) Update.abort(); + bool ok = (size > 0) && Update.begin(size); // selects the next OTA partition + erases it + ota_expected_seq = 0; + Serial.write(ESP_CMD_DONE); + Serial.write(ok ? 0 : 1); // 0 ok | 1 begin-fail (size/partition) + Serial.write(ESP_CMD_END); + } + break; + + case 26: // OTA_DATA: cmd_arr[1]=len(1..200), cmd_arr[2..3]=seq(LE u16); + // extra payload = len data bytes + 2-byte CRC16-CCITT(LE) over the data + { + uint8_t len = cmd_arr[1]; + uint16_t seq = (uint16_t)cmd_arr[2] | ((uint16_t)cmd_arr[3] << 8); + uint8_t status; + if (len == 0 || len > 200) { + status = 4; // bad length (no payload consumed) + } else { + uint8_t buf[202]; + size_t got = Serial.readBytes(buf, (size_t)len + 2); + if (got != (size_t)len + 2) status = 5; // short read + else { + uint16_t rx_crc = (uint16_t)buf[len] | ((uint16_t)buf[len + 1] << 8); + if (crc16_ccitt(buf, len) != rx_crc) status = 1; // CRC fail -> host resends same seq + else if (seq != ota_expected_seq) status = 2; // out-of-order (desync) + else if (!Update.isRunning()) status = 6; // no OTA_BEGIN + else if (Update.write(buf, len) != len) status = 3; // flash write fail + else { ota_expected_seq++; status = 0; } // accepted + } + } + Serial.write(ESP_CMD_DONE); + Serial.write(status); + Serial.write(ESP_CMD_END); + } + break; + + case 27: // OTA_END: finalize + verify image + set boot partition, then reboot into it + { + bool ok = Update.isRunning() && Update.end(); // end() requires the full image (MD5/size check) + Serial.write(ESP_CMD_DONE); + Serial.write(ok ? 0 : 1); // 0 ok (about to reboot) | 1 verify-fail + Serial.write(ESP_CMD_END); + Serial.flush(); // ack must reach the host before we restart + if (ok) { delay(100); ESP.restart(); } // boots the freshly-written slot; no return + } + break; + + case 28: // OTA_ABORT: discard a partial update, stay on the current image + { + if (Update.isRunning()) Update.abort(); + ota_expected_seq = 0; + Serial.write(ESP_CMD_DONE); + Serial.write(0); + Serial.write(ESP_CMD_END); + } + break; + + case 29: // OTA_CONFIRM: mark the running (PENDING_VERIFY) image valid — cancels + // the pending rollback. Sent by the ambyte once it has seen this image + // answer after the OTA reboot. A no-op error if not pending (already valid). + { + esp_err_t err = esp_ota_mark_app_valid_cancel_rollback(); + Serial.write(ESP_CMD_DONE); + Serial.write(err == ESP_OK ? 0 : 1); + Serial.write(ESP_CMD_END); + } + break; + + default: + ESP_LOGE(TAG, "Bad command"); + break; + } + + return 0; +} + diff --git a/src/self_test.cpp b/src/self_test.cpp new file mode 100644 index 0000000..e0e87f5 --- /dev/null +++ b/src/self_test.cpp @@ -0,0 +1,169 @@ +#include +#include "PAM.h" +#include "src/devices_init.h" +#include "src/adpd/u_adpd6100.h" +#include "src/as7341/spec_meas.h" +#include "src/mlx90632/u_mlx.h" + + +extern ADPD6 adpd; +static char STR_SUC[] = "Success"; +static char STR_FAIL[] = "Failed"; + + +char* str_results[3] = {STR_FAIL, STR_SUC, STR_FAIL}; + + +static int check_adpd(){ + uint8_t ret = (uint8_t)adpd.begin(); + if (ret < 2) Serial.printf("ADPD check %s", str_results[ret]); + return ret; +} + +static int check_spec(){ + uint8_t ret = (uint8_t)check_AS7341(); + if (ret < 2) Serial.printf("AS7341 check %s", str_results[ret]); + return ret; +} + + +static int check_mlx(){ + uint8_t ret = (uint8_t)mlx_init(); + if (ret < 2) Serial.printf("MLX90632 check %s", str_results[ret]); + return ret; +} + + +static int test_optic_path(){ + adpd.STOP(); + conf_slow_FR_1(40, 20, 0, 5, 5, 5, 5, 5, 3); + + adpd.num_ts(3); + uint8_t expected_readout_bytes = 24; + uint8_t expected_readout = 8; + uint32_t ret[expected_readout] = {0}; + uint16_t fifo_c = 0; + uint32_t counter = 0; + uint32_t num_ptx = 500; + + AS_LED_OFF(); + AS_LED_Current(50); + adpd.run_freq(50); + + adpd.RUN(); + while (counter < num_ptx){ + fifo_c = adpd.fifo_count(); + while (fifo_c >= expected_readout_bytes){ // read all bytes from FIFO + adpd.readfifo(expected_readout, 3, ret); + fifo_c -= expected_readout_bytes; + if (counter == num_ptx) break; + Serial.printf("%d,%d,%d,%d,%d,%d,%d,%d\n", ret[0],ret[1],ret[2],ret[3],ret[4],ret[5],ret[6],ret[7]); + counter++; + if (counter == 250) AS_LED_ON(); + if (counter == 480) AS_LED_OFF(); + } + } + + adpd.STOP(); + AS_LED_OFF(); + AS_LED_Current(0); + return 0; +} + + + + +int check_connections(){ + // check_adpd(); + // check_spec(); + // check_mlx(); + double temperature_before, temperature_after, t; + + + mlx_measure(&t, &temperature_before); + test_optic_path(); + mlx_measure(&t, &temperature_after); + + + Serial.printf("#obj:%f-%f-%f\n", t, temperature_before, temperature_after); + + + return 0; +} + + +int optic_test(){ + adpd.STOP(); + conf_slow_FR_1(100, 20, 0, 1, 5, 5, 5, 5, 1); + + adpd.num_ts(3); + uint8_t expected_readout_bytes = 24; + uint8_t expected_readout = 8; + uint32_t ret[expected_readout] = {0}; + uint16_t fifo_c = 0; + uint32_t counter = 0; + uint32_t num_ptx = 2000; + uint32_t sig = 0; + + AS_LED_OFF(); + AS_LED_Current(50); + adpd.run_freq(25); + + adpd.RUN(); + while (counter < num_ptx){ + fifo_c = adpd.fifo_count(); + while (fifo_c >= expected_readout_bytes){ // read all bytes from FIFO + adpd.readfifo(expected_readout, 3, ret); + fifo_c -= expected_readout_bytes; + if (counter == num_ptx) break; + sig = calc_signal(ret[2], ret[3], 1); + Serial.printf("%d,%d,%d,%d,%d,%d,%d\n", ret[0]-65000,ret[1]-65000,ret[2]-16000,ret[3]-16000,ret[4]-16000,ret[5]-16000,sig); + counter++; + } + } + + adpd.STOP(); + AS_LED_OFF(); + AS_LED_Current(0); + return 0; +} + + +int optic_test(uint8_t current, uint8_t num_integ, uint8_t lit_offset, uint8_t dark1_offset, uint8_t dark2_offset, uint8_t pulse_offset, uint8_t pulse_duration){ + adpd.STOP(); + fluor_offset_test(current, num_integ, lit_offset, dark1_offset, dark2_offset, pulse_offset, pulse_duration); + + adpd.num_ts(1); + uint8_t expected_readout_bytes = 12; + uint8_t expected_readout = 4; + uint32_t ret[expected_readout] = {0}; + uint16_t fifo_c = 0; + uint32_t counter = 0; + uint32_t num_ptx = 300; + uint32_t sig = 0; + + AS_LED_OFF(); + AS_LED_Current(100); + adpd.run_freq(25); + + adpd.RUN(); + while (counter < num_ptx){ + fifo_c = adpd.fifo_count(); + while (fifo_c >= expected_readout_bytes){ // read all bytes from FIFO + adpd.readfifo(expected_readout, 3, ret); + fifo_c -= expected_readout_bytes; + if (counter == num_ptx) break; + if (counter == 100) AS_LED_ON(); + if (counter == 200) AS_LED_OFF(); + sig = calc_signal(ret[0], ret[1], num_integ); + Serial.printf("%d,%d,%d,%d,%d\n", ret[0]-16000*num_integ, ret[1]-16000*num_integ,ret[2]-16000*num_integ,ret[3]-16000*num_integ, ret[1] - ret[0]); + counter++; + } + } + + adpd.STOP(); + AS_LED_OFF(); + AS_LED_Current(0); + return 0; +} + diff --git a/src/serial.cpp b/src/serial.cpp new file mode 100644 index 0000000..36c2be4 --- /dev/null +++ b/src/serial.cpp @@ -0,0 +1,116 @@ + +// Serial routines that can read/write to either or both Serial devices (Serial (USB) and Serial1 (BLE)) based on a setting +// It also maintains and prints a CRC value +// Can use a packet mode that resends + +// Jon Zeeff 2016 + +// WARNING: Serial_Printf() is limited to 200 characters per call +// Zero is used as a string terminator - it can't be sent. Nor can ETX. + +// Should change this to C++ and a class + +// Remove BLE related now, may add later HJC 2022 + +#include +#include + +int Serial_Peek() +{ + + if (Serial && Serial.available()) + return Serial.peek(); + + return -1; +} + + +char *Serial_Input_Chars(char *string, const char *terminators, long unsigned int timeout, unsigned int max_length) { // terminating characters must be single characters or a list of single characters (so "+" will terminal on +, while "+-" will terminal on either + or -). + unsigned long start = millis(); + unsigned count = 0; + + // loop forever or until a condition is met + for (;;) { + unsigned now = millis(); + + if (timeout > 0 && (now - start) > timeout) // timeout + break; // done + + int c = Serial_Peek(); + if (c == -1) { + //sleep_cpu(); + //sleep_cpu_2(); // save power + continue; // nothing available + } + + if (c > 127) break; + + char b = Serial.read(); + + if (strchr(terminators, b)) { + //test_char = b; + break; + + } // terminator char seen - throw it away //AND END THE LOOP! + + if (strchr("\r\n", b)) { // remove characetrs that can break a JSON. This occurs AFTER the detection of terminators + //test_char = b; + continue; + + } // terminator char seen - throw it away //AND END THE LOOP! + + start = now; // restart interval + + string[count] = b; // add to string + count++; + if (max_length > 0 && count >= max_length){ // too long + //Serial_Print("JSON too long"); + string[max_length - 1] = 0; + return string; + } + } // for ever + + string[count] = 0; // always null terminate the string + + return string; + +} // Serial_Input_Chars() + + +// read a double value (see above) +// empty string returns NAN + +double Serial_Input_Double(const char *terminators, long unsigned int timeout) { + char S[25]; + Serial_Input_Chars(S, terminators, timeout, sizeof(S) - 1); + if (strlen(S) == 0) + return NAN; + return strtod(S, 0); +} // Serial_Input_Double() + + +// read a long value (see above) +// invalid strings return 0 + +long Serial_Input_Long(const char *terminators, long unsigned int timeout) { + char S[25]; + Serial_Input_Chars(S, terminators, timeout, sizeof(S) - 1); + return atol(S); +} // Serial_Input_Long() + + +// Caution: only good for short strings + +String Serial_Input_String(const char *terminators, long unsigned int timeout) +{ + static String serial_string; + char str[100 + 1]; // caution - fixed size buffer + + Serial_Input_Chars(str, terminators, timeout, sizeof(str) - 1); + + serial_string = str; + + // assert(strlen(str) < 100); + + return serial_string; +} // user_enter_str() diff --git a/src/serial.h b/src/serial.h new file mode 100644 index 0000000..4df211c --- /dev/null +++ b/src/serial.h @@ -0,0 +1,7 @@ + + +int Serial_Peek(); +char *Serial_Input_Chars(char *string, const char *terminators, long unsigned int timeout, unsigned int max_length); +double Serial_Input_Double(const char *terminators, long unsigned int timeout); +long Serial_Input_Long(const char *terminators, long unsigned int timeout); + diff --git a/src/src/adpd/ADPD_platform_ops.cpp b/src/src/adpd/ADPD_platform_ops.cpp new file mode 100644 index 0000000..4b3bfaa --- /dev/null +++ b/src/src/adpd/ADPD_platform_ops.cpp @@ -0,0 +1,82 @@ +#include "driver/spi_common.h" +#include "driver/spi_master.h" +#include "../pin_config.h" + +#include "lib/ADPD6000/adi_adpd6000.h" + + + + + + +uint8_t check_adpd(spi_device_handle_t handle){ + /// @brief Check ADPD connected + /// @param ADPD number + /// @return + esp_err_t err = 1; + uint16_t ret = 1; + + spi_transaction_t check_adpd = { + .addr = 0x0010, + .length = 16, + .rxlength = 16, + .rx_buffer = &ret, + }; + + err = spi_device_polling_transmit(handle, &check_adpd); + + if (err != ESP_OK) {Serial.print("SPI communication failed: "); Serial.println(esp_err_to_name(err));return 1;} + ret = SPI_SWAP_DATA_RX(ret, 16); + Serial.println(ret); + + return 1; + +} + + +int32_t spi_read(void* user_data, uint8_t *rd_buf, uint32_t rd_len, uint8_t *wr_buf, uint32_t wr_len){ + + spi_device_handle_t handle = * ((spi_device_handle_t*) user_data); + + esp_err_t err; + uint16_t addr = 0x0000; + addr |= wr_buf[0] << 8; + addr |= wr_buf[1]; + + spi_transaction_t spi_read_and_write = { + .addr = addr, + .length = rd_len * 8, + .rxlength = rd_len * 8, + .rx_buffer = rd_buf + }; + err = spi_device_polling_transmit(handle, &spi_read_and_write); + if (err != ESP_OK) Serial.println(esp_err_to_name(err)); + return 0; + +} +int32_t spi_write(void* user_data, uint8_t *wr_buf, uint32_t len){ + + spi_device_handle_t handle = * ((spi_device_handle_t*) user_data); + + esp_err_t err; + uint16_t addr = 0x0000; + addr |= wr_buf[0] << 8; + addr |= wr_buf[1]; + + spi_transaction_t spi_read_and_write = { + .addr = addr, + .length = (len - 2)<<3, + .rxlength = (len - 2)<<3, + .tx_buffer = &wr_buf[2], + .rx_buffer = &wr_buf[2] + }; + err = spi_device_polling_transmit(handle, &spi_read_and_write); + if (err != ESP_OK) Serial.println(esp_err_to_name(err)); + return 0; +} + +int32_t log_print(void* user_data, char *string){ + Serial.println(string); + return 0; +} + diff --git a/src/src/adpd/u_adpd6100.cpp b/src/src/adpd/u_adpd6100.cpp new file mode 100644 index 0000000..fc71c0e --- /dev/null +++ b/src/src/adpd/u_adpd6100.cpp @@ -0,0 +1,1281 @@ +#include "u_adpd6100.h" +int32_t spi_read(void* user_data, uint8_t *rd_buf, uint32_t rd_len, uint8_t *wr_buf, uint32_t wr_len); +int32_t spi_write(void* user_data, uint8_t *wr_buf, uint32_t len); +int32_t log_print(void* user_data, char *string); + +static const char* TAG = "ADPD"; + + +ADPD6::ADPD6(void){ + ADPD6::adpd1_spi_handle= NULL; // ESP32 Spi device handle + + ADPD6::adpd_spi_dev = { // spi configuration + .command_bits = 0, + .address_bits = 16, + .dummy_bits = 0, + .mode = 3, + .clock_speed_hz = SPI_MASTER_FREQ_10M, + .spics_io_num = ADPD1_CS, + .queue_size=1 + }; + // handle for spi IO + ADPD6::handle = { + .user_data = &adpd1_spi_handle, + .read = *spi_read, + .write = *spi_write, + .log_write = *log_print + }; + + ADPD6::load_default(&(ADPD6::sys_config)); + ADPD6::load_default(&(ADPD6::led_config)); + ADPD6::load_default(&(ADPD6::SNR_config)); + ADPD6::load_default(&(ADPD6::DI_config)); + ADPD6::load_default(&(ADPD6::AI_config)); + ADPD6::load_default(&(ADPD6::signal_config)); +}; + +ADPD6::~ADPD6(void){ + +}; + + +bool ADPD6::begin(void){ + esp_err_t err = 1; + if (_spi_device_attached){ + spi_bus_remove_device(ADPD6::adpd1_spi_handle); + ADPD6::_spi_device_attached = false; + ADPD6::chip_check = false; + ESP_LOGI(TAG, "ADPD reset"); + } + + ESP_LOGV(TAG, "ADPD Initate:"); + + err = spi_bus_add_device(SPI2_HOST, &(ADPD6::adpd_spi_dev), &(ADPD6::adpd1_spi_handle)); + if (err != ESP_OK){ + ESP_LOGE(TAG, "SPI Bus error: %s", esp_err_to_name(err)); + return false; + } + ESP_LOGI(TAG, "ADPD attached as SPI device"); + + ADPD6::_spi_device_attached = true; + uint8_t ret1 = 0; + uint8_t ret2 = 0; + adi_adpd6000_device_get_id(&(ADPD6::handle), &ret1, &ret2); + + if (ret1 == 196) { + ADPD6::chip_check = true; + Serial.printf("ADPD Found, chip version: %d\n", ret2); + err = adi_adpd6000_device_sw_reset(&(ADPD6::handle)); + ADPD6000_ERROR_RETURN(err); + ADPD6::load_default(&(ADPD6::sys_config)); + ADPD6::global_setup(&(ADPD6::sys_config)); + return true; + }else{ + ADPD6::chip_check = false; + ESP_LOGE(TAG, "ADPD not found"); + return false; + } + return false; + +} + +int32_t ADPD6::clear_fifo(void){ + return adi_adpd6000_device_clr_fifo(&(ADPD6::handle)); +} + +int32_t ADPD6::run_freq(uint32_t freq){ + return adi_adpd6000_device_set_slot_freq(&(ADPD6::handle), 960000, freq); +} + +int32_t ADPD6::RUN(){ + return adi_adpd6000_device_enable_slot_operation_mode_go(&(ADPD6::handle), true); +} + +int32_t ADPD6::STOP(){ + return adi_adpd6000_device_enable_slot_operation_mode_go(&(ADPD6::handle), false); +} + +uint16_t ADPD6::fifo_count(){ + uint16_t ret = 0; + adi_adpd6000_device_get_fifo_count(&(ADPD6::handle), &ret); + if (ret < 641) return ret; + return 0; +} + +int32_t ADPD6::readfifo(uint16_t num_samples, uint8_t width, uint32_t* data){ + uint16_t i, j; + uint8_t readout[width]; + for (i = 0; i < num_samples; i++){ + data[i] = 0; + adi_adpd6000_device_fifo_read_bytes(&(ADPD6::handle), readout, width); + for (j = 0; j < width; j++){ + data[i] += readout[j] << ((width - j - 1) * 8); + } + } + return 0; +} + +int32_t ADPD6::write_reg(uint32_t reg_addr, uint16_t *reg_data){ + return adi_adpd6000_hal_reg_write(&(ADPD6::handle), reg_addr, *reg_data); +} + +int32_t ADPD6::read_reg(uint32_t reg_addr){ + uint16_t reg_data = 0; + adi_adpd6000_hal_reg_read(&(ADPD6::handle), reg_addr, ®_data); + return reg_data; +} + + +int32_t ADPD6::num_ts(uint8_t mode){ + return adi_adpd6000_ppg_set_slot_mode(&(ADPD6::handle), (adi_adpd6000_ppg_slot_mode_e)mode); +} + + +void ADPD6::load_default(struct ts_led *ts){ + ts->driver1_current = 0; + ts->driver2_current = 0; + ts->led1_channel = LED_A; + ts->led2_channel = LED_A; + ts->led1_mode = 0; + ts->led2_mode = 0; +} + +int32_t ADPD6::ts_setup(adi_adpd6000_slot_e timeslot_no, struct ts_led *init) +{ + int32_t ret; + uint16_t data = 0; + + /* Set LED power and A/B channels*/ + data = init->led2_channel << 15| + init->driver2_current << 8| + init->led1_channel << 7| + init->driver1_current << 0; + + ret = ADPD6::write_reg(REG_LED_POW12_A_ADDR + (timeslot_no) * 0x20, &data); + if(ret != API_ADPD6000_ERROR_OK) + return ret; + + /* Set LED power and A/B channels*/ + data = init->led2_mode << 1| + init->led1_mode << 0; + + ret = ADPD6::write_reg(REG_LED_MODE_A_ADDR + (timeslot_no) * 0x20, &data); + if(ret != API_ADPD6000_ERROR_OK) + return ret; + return API_ADPD6000_ERROR_OK; +} + + +void ADPD6::load_default(struct ts_SNR *ts){ + ts->ch1_dac = 0; + ts->ch1_led_offset = 0; + ts->ch2_dac = 0; + ts->ch2_led_offset = 0; + ts->TIA_ceiling_det = 0; + ts->Ch2_R_int = 0; + ts->Ch1_R_int = 0; + ts->Vref_pulse = 0; + ts->Vref_VPD = 2; + ts->Vref_VPD_pulse = 3; + ts->TIA_gain_CH2 = 1; + ts->TIA_gain_CH1 = 1; + ts->C_int_CH2 = 0; + ts->C_int_CH1 = 0; +} + + +int32_t ADPD6::ts_setup(adi_adpd6000_slot_e timeslot_no, struct ts_SNR *init) +{ + int32_t ret; + uint16_t data = 0; + + /* Set TIA AC Dac for channel 1*/ + data = init->ch1_dac << 7| + init->ch1_led_offset << 0; + + ret = ADPD6::write_reg(REG_AFE_DAC1_A_ADDR + (timeslot_no) * 0x20, &data); + if(ret != API_ADPD6000_ERROR_OK) + return ret; + + /* Set TIA AC Dac for channel 1*/ + data = init->ch2_dac << 7| + init->ch2_led_offset << 0; + + ret = ADPD6::write_reg(REG_AFE_DAC2_A_ADDR + (timeslot_no) * 0x20, &data); + if(ret != API_ADPD6000_ERROR_OK) + return ret; + + + data = init->TIA_ceiling_det << 15| + init->Ch2_R_int << 13| + init->Ch1_R_int << 11| + init->Vref_pulse << 10| + init->Vref_VPD << 8| + init->Vref_pulse << 6| + init->TIA_gain_CH2 << 3| + init->TIA_gain_CH1 << 0; + + ret = ADPD6::write_reg(REG_AFE_TRIM1_A_ADDR + (timeslot_no) * 0x20, &data); + if(ret != API_ADPD6000_ERROR_OK) + return ret; + + data = 0; + data = init->C_int_CH2 << 13| + init->C_int_CH1 << 12; + + ret = ADPD6::write_reg(REG_AFE_TRIM2_A_ADDR + (timeslot_no) * 0x20, &data); + if(ret != API_ADPD6000_ERROR_OK) + return ret; + return API_ADPD6000_ERROR_OK; +} + +void ADPD6::load_default(struct ts_signal *ts){ + ts->pre_condition_width = 4; + ts->ac_type = 0; + ts->gpio_out = 0; + ts->INT2BUT = 0; + ts->AFE_PATh = 0x28; // 0x28 + ts->IN34 = 0; + ts->IN12 = 1; + ts->pre_condition_type = 0; + ts->VC2_pulse_type = 0; + ts->VC2_pulse_to = 0; + ts->VC2_active = 2; + ts->VC1_pulse_type = 0; + ts->VC1_pulse_to = 0; + ts->VC1_active = 2; // set vc1 to vref + 215mV +} + + +int32_t ADPD6::ts_setup(adi_adpd6000_slot_e timeslot_no, struct ts_signal *init) +{ + int32_t ret; + uint16_t data = 0; + + /* Set TIA AC Dac for channel 1*/ + data = init->pre_condition_width << 12| + init->ac_type << 10| + init->gpio_out << 9| + init->INT2BUT << 8| + init->AFE_PATh << 0; + + ret = ADPD6::write_reg(REG_TS_PATH_A_ADDR + (timeslot_no) * 0x20, &data); + if(ret != API_ADPD6000_ERROR_OK) + return ret; + + /* Set TIA AC Dac for channel 1*/ + data = init->IN34 << 4| + init->IN12 << 0; + + ret = ADPD6::write_reg(REG_INPUTS_A_ADDR + (timeslot_no) * 0x20, &data); + if(ret != API_ADPD6000_ERROR_OK) + return ret; + + + data = init->pre_condition_type << 12| + init->VC2_pulse_type << 10| + init->VC2_pulse_to << 8| + init->VC2_active << 6| + init->VC1_pulse_type << 4| + init->VC1_pulse_to << 2| + init->VC1_active << 0; + + ret = ADPD6::write_reg(REG_CATHODE_A_ADDR + (timeslot_no) * 0x20, &data); + if(ret != API_ADPD6000_ERROR_OK) + return ret; + return API_ADPD6000_ERROR_OK; +} + +void ADPD6::load_default(struct ts_DI_timing *ts){ + ts->num_integration = 1; + ts->num_repeats = 1; + ts->Modulation_type = 0; + ts->period_min = 0; + ts->LED_pulse_width = 2; + ts->LED_pulse_offset = 0x10; + ts->LED_pulse2_offset = 0x13; + ts->LIT_OFFSET = 0x26; + ts->DARK_OFFSET1 = 0x06; + ts->DARK_OFFSET2 = 0x40; + ts->subsample_en = 0; + ts->ch2_en = 0; + ts->sample_type = 3; // two-region digital integration + ts->ts_offset = 0; + ts->dark_shift = 0; + ts->dark_size = 0; + ts->signal_shift = 0; + ts->signal_size = 3; + ts->lit_shift = 0; + ts->lit_size = 0; +} + + +int32_t ADPD6::ts_setup(adi_adpd6000_slot_e timeslot_no, struct ts_DI_timing *init){ + int32_t ret; + uint16_t data = 0; + + + data = init->num_integration << 8| + init->num_repeats << 0; + ret = ADPD6::write_reg(REG_COUNTS_A_ADDR + (timeslot_no) * 0x20, &data); + if(ret != API_ADPD6000_ERROR_OK) + return ret; + + data = init->Modulation_type << 12| + init->period_min << 0; + ret = ADPD6::write_reg(REG_PERIOD_A_ADDR + (timeslot_no) * 0x20, &data); + if(ret != API_ADPD6000_ERROR_OK) + return ret; + + data = 0; + data = init->LED_pulse_width << 8| + init->LED_pulse_offset << 0; + ret = ADPD6::write_reg(REG_LED_PULSE1_A_ADDR + (timeslot_no) * 0x20, &data); + if(ret != API_ADPD6000_ERROR_OK) + return ret; + data = 0; + data = init->LED_pulse2_offset << 0; + ret = ADPD6::write_reg(REG_LED_PULSE2_A_ADDR + (timeslot_no) * 0x20, &data); + if(ret != API_ADPD6000_ERROR_OK) + return ret; + + data = 0; + data = init->LIT_OFFSET << 0; + ret = ADPD6::write_reg(REG_DIGINT_LIT_A_ADDR + (timeslot_no) * 0x20, &data); + if(ret != API_ADPD6000_ERROR_OK) + return ret; + + data = 0; + data = init->DARK_OFFSET2 << 7| + init->DARK_OFFSET1 << 0; + ret = ADPD6::write_reg(REG_DIGINT_DARK_A_ADDR + (timeslot_no) * 0x20, &data); + if(ret != API_ADPD6000_ERROR_OK) + return ret; + + data = 0; + data = init->subsample_en << 15| + init->ch2_en << 14| + init->sample_type << 11| + init->ts_offset << 0; + ret = ADPD6::write_reg(REG_TS_CTRL_A_ADDR + (timeslot_no) * 0x20, &data); + if(ret != API_ADPD6000_ERROR_OK) + return ret; + + data = 0; + data = init->dark_shift << 11| + init->dark_size << 8| + init->signal_shift << 3| + init->signal_size << 0; + ret = ADPD6::write_reg(REG_DATA1_A_ADDR + (timeslot_no) * 0x20, &data); + if(ret != API_ADPD6000_ERROR_OK) + return ret; + + data = 0; + data = init->lit_shift << 3| + init->lit_size << 0; + ret = ADPD6::write_reg(REG_DATA2_A_ADDR + (timeslot_no) * 0x20, &data); + if(ret != API_ADPD6000_ERROR_OK) + return ret; +} + +void ADPD6::load_default(struct ts_AI_timing *ts){ + ts->num_integration = 1; + ts->num_repeats = 1; + ts->Modulation_type = 0; + ts->period_min = 0; + ts->LED_pulse_width = 2; + ts->LED_pulse_offset = 0x10; + ts->LED_pulse2_offset = 0x13; + ts->SINGLE_INTEG = 0; + ts->CH2_DIS_AMP = 0; + ts->CH1_DIS_AMP = 0; + ts->ADC_count = 0; + ts->integration_width = 3; + ts->offset_us = 0xD; + ts->offset_ns = 0; + ts->pattern_LED_disable = 0; + ts->pattern_MOD_disable = 0; + ts->pattern_subtract = 0; + ts->pattern_reverse_int = 0; + ts->subsample_en = 0; + ts->ch2_en = 0; + ts->sample_type = 0; + ts->ts_offset = 0; + +} + +int32_t ADPD6::ts_setup(adi_adpd6000_slot_e timeslot_no, struct ts_AI_timing *init){ + int32_t ret; + uint16_t data = 0; + + data = init->Modulation_type << 12| + init->period_min << 0; + ret = ADPD6::write_reg(REG_PERIOD_A_ADDR + (timeslot_no) * 0x20, &data); + if(ret != API_ADPD6000_ERROR_OK) + return ret; + + data = 0; + data = init->LED_pulse_width << 8| + init->LED_pulse_offset << 0; + ret = ADPD6::write_reg(REG_LED_PULSE1_A_ADDR + (timeslot_no) * 0x20, &data); + if(ret != API_ADPD6000_ERROR_OK) + return ret; + data = 0; + data = init->LED_pulse2_offset << 0; + ret = ADPD6::write_reg(REG_LED_PULSE2_A_ADDR + (timeslot_no) * 0x20, &data); + if(ret != API_ADPD6000_ERROR_OK) + return ret; + + //0x012E INTEG_WIDTH_A + data = 0; + data = init->SINGLE_INTEG << 15| + init->CH2_DIS_AMP << 11| + init->CH1_DIS_AMP << 7| + init->ADC_count << 5| + init->integration_width << 0; + ret = ADPD6::write_reg(REG_INTEG_WIDTH_A_ADDR + (timeslot_no) * 0x20, &data); + if(ret != API_ADPD6000_ERROR_OK) + return ret; + + //0x012F INTEG_OFFSET_A + data = 0; + data = init->offset_us << 5| + init->offset_ns << 0; + ret = ADPD6::write_reg(REG_INTEG_OFFSET_A_ADDR + (timeslot_no) * 0x20, &data); + if(ret != API_ADPD6000_ERROR_OK) + return ret; + + //0x130 MOD_PULSE_A + data = 0; + data = init->modulation_width << 8| + init->modulation_offset << 0; + ret = ADPD6::write_reg(REG_MOD_PULSE_A_ADDR + (timeslot_no) * 0x20, &data); + if(ret != API_ADPD6000_ERROR_OK) + return ret; + + //0x0131 PATTERN1_A + data = 0; + data = init->pattern_LED_disable << 12| + init->pattern_MOD_disable << 8| + init->pattern_subtract << 4| + init->pattern_reverse_int << 0; + ret = ADPD6::write_reg(REG_PATTERN1_A_ADDR + (timeslot_no) * 0x20, &data); + if(ret != API_ADPD6000_ERROR_OK) + return ret; + + + //0x0120 TS_CTRL_A + data = 0; + data = init->subsample_en << 15| + init->ch2_en << 14| + init->sample_type << 11| + init->ts_offset << 0; + ret = ADPD6::write_reg(REG_TS_CTRL_A_ADDR + (timeslot_no) * 0x20, &data); + if(ret != API_ADPD6000_ERROR_OK) + return ret; +} + +void ADPD6::load_default(struct system_config *ts){ + ts->IN34_sleep = 0; + ts->IN12_sleep = 0; + ts->VC2_sleep = 0; + ts->VC1_sleep = 0; + ts->PAIR34 = 0; + ts->PAIR12 = 0; + ts->GPIO_slew = 0; + ts->GPIO_drv = 0; + ts->GPIO2_cfg = 0; + ts->GPIO1_cfg = 0; + ts->GPIO0_cfg = 0; + ts->GPIO1_output = 0; + ts->GPIO0_output = 0; + ts->GPIO2_output = 0; + ts->IOVDD = 0; + ts->SPI_drv = 0; + ts->SPI_slew = 0; + ts->alt_clock = 0; + ts->alt_clock_gpio = 0; + ts->ext_clock_freq = 0; + ts->internal_clock_en = 1; +} + + +int32_t ADPD6::global_setup(struct system_config *init){ + int32_t ret; + uint16_t data = 0; + + data = 0x2004; + ret = ADPD6::write_reg(0x0046, &data); + if(ret != API_ADPD6000_ERROR_OK) + return ret; + + data = 0x400b; + ret = ADPD6::write_reg(0x004c, &data); + if(ret != API_ADPD6000_ERROR_OK) + return ret; + + data = 0; + data = init->IN34_sleep << 4| + init->IN12_sleep << 0; + ret = ADPD6::write_reg(REG_INPUT_SLEEP_ADDR, &data); + if(ret != API_ADPD6000_ERROR_OK) + return ret; + + + data = 0; + data = init->VC2_sleep << 6| + init->VC1_sleep << 4| + init->PAIR34 << 1| + init->PAIR12 << 0; + ret = ADPD6::write_reg(REG_INPUT_CFG_ADDR, &data); + if(ret != API_ADPD6000_ERROR_OK) + return ret; + + data = 0; + data = init->GPIO_slew << 14| + init->GPIO_drv << 12| + init->GPIO2_cfg << 6| + init->GPIO1_cfg << 3| + init->GPIO0_cfg << 0; + ret = ADPD6::write_reg(REG_GPIO_CFG_ADDR, &data); + if(ret != API_ADPD6000_ERROR_OK) + return ret; + + + data = 0; + data = init->GPIO1_output << 8| + init->GPIO0_output << 0; + ret = ADPD6::write_reg(REG_GPIO01_ADDR, &data); + if(ret != API_ADPD6000_ERROR_OK) + return ret; + + data = 0; + data = init->GPIO2_output << 0; + ret = ADPD6::write_reg(REG_GPIO23_ADDR, &data); + if(ret != API_ADPD6000_ERROR_OK) + return ret; + + data = 0; + data = init->IOVDD << 6| + 1 << 4| + init->SPI_slew << 2| + init->SPI_drv << 0; + ret = ADPD6::write_reg(REG_IO_ADJUST_ADDR, &data); + if(ret != API_ADPD6000_ERROR_OK) + return ret; + + data = 0; + data = init->alt_clock << 8| + init->alt_clock_gpio << 6| + init->ext_clock_freq << 2| + init->internal_clock_en << 1; + ret = ADPD6::write_reg(REG_SYS_CTL_ADDR, &data); + if(ret != API_ADPD6000_ERROR_OK) + return ret; +} + +void ADPD6::load_default(struct GPIO0_config *ts){ + ts->GPIO0_cfg = 0; + ts->GPIO0_output = 0; + ts->EXT_SYNC_EN = 0; + ts->SYNC_GPIO = 0; +} + +int32_t ADPD6::gpio_setup(struct GPIO0_config *init){ + int32_t ret; + uint16_t data = 0; + data = init->EXT_SYNC_EN << 2| + init->SYNC_GPIO << 0; + ret = ADPD6::write_reg(REG_GPIO_EXT_ADDR, &data); + if(ret != API_ADPD6000_ERROR_OK) return ret; + + data = 0; + data = init->GPIO0_output << 0; + ret = ADPD6::write_reg(REG_GPIO01_ADDR, &data); + if(ret != API_ADPD6000_ERROR_OK) return ret; + + data = 0; + data = init->GPIO0_cfg; + ret = ADPD6::write_reg(REG_GPIO_CFG_ADDR, &data); + if(ret != API_ADPD6000_ERROR_OK) return ret; + + return 0; +} + + + + + + +int32_t ADPD6::preset_config_1(uint8_t ts, uint8_t num_integ){ + if (!(ADPD6::chip_check)){ + ESP_LOGE(TAG, "ADPD Not init in preset1"); + return -2; + } + + ESP_LOGV(TAG, "Preset_config 1 set for timeslot:%d. Two ambient channels. Total 2 x 3 bytes", ts); + // Channel 1: PD1 (sun-facing), channel 2: PD2 (leaf-facing IR) + + ADPD6::STOP(); + ADPD6::DI_config.period_min = 58; + ADPD6::DI_config.LIT_OFFSET = 64; + ADPD6::DI_config.DARK_OFFSET1 = 48; + ADPD6::DI_config.DARK_OFFSET2 = 90; + ADPD6::DI_config.LED_pulse_offset = 60; + ADPD6::DI_config.LED_pulse_width = 19; + ADPD6::DI_config.sample_type = 3; + ADPD6::DI_config.signal_size = 0; + ADPD6::DI_config.num_integration = num_integ; + ADPD6::DI_config.num_repeats = 1; + ADPD6::DI_config.dark_size = 3; + ADPD6::DI_config.lit_size = 0; + + ADPD6::signal_config.pre_condition_type = 5; + ADPD6::SNR_config.Ch1_R_int = 1; + ADPD6::SNR_config.C_int_CH1 = 1; + ADPD6::SNR_config.Ch2_R_int = 1; + ADPD6::SNR_config.C_int_CH2 = 1; + ADPD6::signal_config.INT2BUT = 1; + ADPD6::signal_config.ac_type = 0; + + ADPD6::DI_config.ch2_en = true; + ADPD6::signal_config.IN12 = 0B0101; + ADPD6::signal_config.IN34 = 0B0000; + + ADPD6::num_ts(ts + 1); + + ADPD6::ts_setup((adi_adpd6000_slot_e)ts, &(ADPD6::DI_config)); + ADPD6::ts_setup((adi_adpd6000_slot_e)ts, &(ADPD6::signal_config)); + ADPD6::ts_setup((adi_adpd6000_slot_e)ts, &(ADPD6::SNR_config)); + ADPD6::ts_setup((adi_adpd6000_slot_e)ts, &(ADPD6::led_config)); + + return 0; + +} + + +// fluo and ref channel setup +int32_t ADPD6::preset_config_2(uint8_t ts, uint8_t num_integ){ + if (!(ADPD6::chip_check)){ + ESP_LOGE(TAG, "ADPD Not init in preset 2"); + return -2; + } + + ESP_LOGV(TAG, "Preset_config 2 set for timeslot:%d. Total 2 x 2 x 3 bytes", ts); + // Channel 1: PD2 (leaf-facing IR), channel 2: PD4 (leaf-facing Vis) + + ADPD6::STOP(); + ADPD6::DI_config.period_min = 58; + ADPD6::DI_config.LIT_OFFSET = 72;//64; + ADPD6::DI_config.DARK_OFFSET1 = 48; + ADPD6::DI_config.DARK_OFFSET2 = 90; + ADPD6::DI_config.LED_pulse_offset = 60; + ADPD6::DI_config.LED_pulse_width = 15;//19; + ADPD6::DI_config.sample_type = 3; + ADPD6::DI_config.signal_size = 0; + ADPD6::DI_config.num_integration = num_integ; + ADPD6::DI_config.num_repeats = 1; + ADPD6::DI_config.dark_size = 3; + ADPD6::DI_config.lit_size = 3; + + ADPD6::signal_config.pre_condition_type = 5; + ADPD6::SNR_config.Ch1_R_int = 1; + ADPD6::SNR_config.C_int_CH1 = 1; + ADPD6::SNR_config.Ch2_R_int = 2; // 1 + ADPD6::SNR_config.C_int_CH2 = 1; + ADPD6::signal_config.INT2BUT = 1; + ADPD6::signal_config.ac_type = 2; + + ADPD6::DI_config.ch2_en = true; + ADPD6::signal_config.IN12 = 0B0011; + ADPD6::signal_config.IN34 = 0B0100; + + + + ADPD6::num_ts(ts + 1); + + ADPD6::ts_setup((adi_adpd6000_slot_e)ts, &(ADPD6::DI_config)); + ADPD6::ts_setup((adi_adpd6000_slot_e)ts, &(ADPD6::signal_config)); + ADPD6::ts_setup((adi_adpd6000_slot_e)ts, &(ADPD6::SNR_config)); + ADPD6::ts_setup((adi_adpd6000_slot_e)ts, &(ADPD6::led_config)); + + return 0; +} + +int32_t ADPD6::preset_config_2x(uint8_t ts, uint8_t num_integ, uint8_t lit_offset, uint8_t dark1_offset, uint8_t dark2_offset, uint8_t pulse_offset, uint8_t pulse_duration){ + if (!(ADPD6::chip_check)){ + ESP_LOGE(TAG, "ADPD Not init in preset 2"); + return -2; + } + + ESP_LOGV(TAG, "Preset_config 2 set for timeslot:%d. Total 2 x 2 x 3 bytes", ts); + // Channel 1: PD2 (leaf-facing IR), channel 2: PD4 (leaf-facing Vis) + + ADPD6::STOP(); + ADPD6::DI_config.period_min = 58; + ADPD6::DI_config.LIT_OFFSET = lit_offset; + ADPD6::DI_config.DARK_OFFSET1 = dark1_offset; + ADPD6::DI_config.DARK_OFFSET2 = dark2_offset; + ADPD6::DI_config.LED_pulse_offset = pulse_offset; + ADPD6::DI_config.LED_pulse_width = pulse_duration; + ADPD6::DI_config.sample_type = 3; + ADPD6::DI_config.signal_size = 0; + ADPD6::DI_config.num_integration = num_integ; + ADPD6::DI_config.num_repeats = 1; + ADPD6::DI_config.dark_size = 3; + ADPD6::DI_config.lit_size = 3; + + ADPD6::signal_config.pre_condition_type = 5; + ADPD6::SNR_config.Ch1_R_int = 1; + ADPD6::SNR_config.C_int_CH1 = 1; + ADPD6::SNR_config.Ch2_R_int = 1; + ADPD6::SNR_config.C_int_CH2 = 1; + ADPD6::signal_config.INT2BUT = 1; + ADPD6::signal_config.ac_type = 2; + + ADPD6::DI_config.ch2_en = true; + ADPD6::signal_config.IN12 = 0B0011; + ADPD6::signal_config.IN34 = 0B0100; + + + + ADPD6::num_ts(ts + 1); + + ADPD6::ts_setup((adi_adpd6000_slot_e)ts, &(ADPD6::DI_config)); + ADPD6::ts_setup((adi_adpd6000_slot_e)ts, &(ADPD6::signal_config)); + ADPD6::ts_setup((adi_adpd6000_slot_e)ts, &(ADPD6::SNR_config)); + ADPD6::ts_setup((adi_adpd6000_slot_e)ts, &(ADPD6::led_config)); + + return 0; +} + +// reflection channel setup +int32_t ADPD6::preset_config_3(uint8_t ts, uint8_t num_integ){ + if (!(ADPD6::chip_check)){ + ESP_LOGE(TAG, "ADPD Not init in preset 2"); + return -2; + } + + ESP_LOGV(TAG, "Preset_config 3 set for timeslot:%d. Total 2 x 3 bytes", ts); + // Channel 1: PD2 (leaf-facing IR), channel 2: PD4 (leaf-facing Vis) + + ADPD6::STOP(); + ADPD6::DI_config.period_min = 58; + ADPD6::DI_config.LIT_OFFSET = 72;//64; + ADPD6::DI_config.DARK_OFFSET1 = 48; + ADPD6::DI_config.DARK_OFFSET2 = 90; + ADPD6::DI_config.LED_pulse_offset = 60; + ADPD6::DI_config.LED_pulse_width = 19; + ADPD6::DI_config.sample_type = 3; + ADPD6::DI_config.signal_size = 3; + ADPD6::DI_config.num_integration = num_integ; + ADPD6::DI_config.num_repeats = 1; + ADPD6::DI_config.dark_size = 0; + ADPD6::DI_config.lit_size = 0; + + ADPD6::signal_config.pre_condition_type = 5; + ADPD6::SNR_config.Ch1_R_int = 1; + ADPD6::SNR_config.C_int_CH1 = 1; + ADPD6::SNR_config.Ch2_R_int = 1; + ADPD6::SNR_config.C_int_CH2 = 1; + ADPD6::signal_config.INT2BUT = 1; + ADPD6::signal_config.ac_type = 2; + + ADPD6::DI_config.ch2_en = true; + ADPD6::signal_config.IN12 = 0B0011; + ADPD6::signal_config.IN34 = 0B0100; + + + ADPD6::num_ts(ts + 1); + + ADPD6::ts_setup((adi_adpd6000_slot_e)ts, &(ADPD6::DI_config)); + ADPD6::ts_setup((adi_adpd6000_slot_e)ts, &(ADPD6::signal_config)); + ADPD6::ts_setup((adi_adpd6000_slot_e)ts, &(ADPD6::SNR_config)); + ADPD6::ts_setup((adi_adpd6000_slot_e)ts, &(ADPD6::led_config)); + + return 0; +} + + + +// far-red +int32_t ADPD6::preset_config_4(uint8_t ts){ + if (!(ADPD6::chip_check)){ + ESP_LOGE(TAG, "ADPD Not init in preset 3"); + return -2; + } + + ESP_LOGV(TAG, "Preset_config 4 set for timeslot:%d. Total 0 bytes", ts); + // Channel 1: PD2 (leaf-facing IR), channel 2: PD4 (leaf-facing Vis) + + ADPD6::STOP(); + ADPD6::DI_config.period_min = 320; + ADPD6::DI_config.LIT_OFFSET = 100; + ADPD6::DI_config.DARK_OFFSET1 = 48; + ADPD6::DI_config.DARK_OFFSET2 = 300; + ADPD6::DI_config.LED_pulse_offset = 60; + ADPD6::DI_config.LED_pulse_width = 200; + ADPD6::DI_config.sample_type = 3; + ADPD6::DI_config.signal_size = 0; + ADPD6::DI_config.num_integration = 1; + ADPD6::DI_config.num_repeats = 1; + ADPD6::DI_config.dark_size = 0; + ADPD6::DI_config.lit_size = 0; + + ADPD6::signal_config.pre_condition_type = 5; + ADPD6::SNR_config.Ch1_R_int = 1; + ADPD6::SNR_config.C_int_CH1 = 1; + ADPD6::SNR_config.Ch2_R_int = 1; + ADPD6::SNR_config.C_int_CH2 = 1; + ADPD6::signal_config.INT2BUT = 1; + ADPD6::signal_config.ac_type = 0; + + ADPD6::DI_config.ch2_en = false; + ADPD6::signal_config.IN12 = 0B0011; + ADPD6::signal_config.IN34 = 0B0100; + + + + ADPD6::num_ts(ts + 1); + + ADPD6::ts_setup((adi_adpd6000_slot_e)ts, &(ADPD6::DI_config)); + ADPD6::ts_setup((adi_adpd6000_slot_e)ts, &(ADPD6::signal_config)); + ADPD6::ts_setup((adi_adpd6000_slot_e)ts, &(ADPD6::SNR_config)); + ADPD6::ts_setup((adi_adpd6000_slot_e)ts, &(ADPD6::led_config)); + + return 0; +} + +int32_t ADPD6::repeats_only(uint8_t ts, uint16_t num_integration, uint8_t num_repeats){ + uint16_t data = 0; + int32_t ret; + data = num_integration << 8| + num_repeats << 0; + ret = ADPD6::write_reg(REG_COUNTS_A_ADDR + (ts) * 0x20, &data); + if(ret != API_ADPD6000_ERROR_OK) + return ret; +} + +// external trigger +int32_t ADPD6::preset_config_ext_fast(uint8_t ts){ + return ADPD6::preset_config_ext_fast(ts, 1); + +} + +int32_t ADPD6::preset_config_ext_fast(uint8_t ts, uint8_t integ){ + if (!(ADPD6::chip_check)){ + ESP_LOGE(TAG, "ADPD Not init in preset 2"); + return -2; + } + + ESP_LOGV(TAG, "External trigger test: %d", ts); + // Channel 1: PD2 (leaf-facing IR), channel 2: PD4 (leaf-facing Vis) + + ADPD6::STOP(); + ADPD6::DI_config.period_min = 50; + ADPD6::DI_config.LIT_OFFSET = 70; + ADPD6::DI_config.DARK_OFFSET1 = 48; + ADPD6::DI_config.DARK_OFFSET2 = 85; + ADPD6::DI_config.LED_pulse_offset = 60; + ADPD6::DI_config.LED_pulse_width = 15; + ADPD6::DI_config.sample_type = 3; + ADPD6::DI_config.signal_size = 0; + ADPD6::DI_config.num_integration = integ; + ADPD6::DI_config.num_repeats = 1; + ADPD6::DI_config.dark_size = 3; + ADPD6::DI_config.lit_size = 3; + + ADPD6::signal_config.pre_condition_type = 5; + ADPD6::SNR_config.Ch1_R_int = 1; + ADPD6::SNR_config.C_int_CH1 = 1; + ADPD6::SNR_config.Ch2_R_int = 2; + ADPD6::SNR_config.C_int_CH2 = 1; + ADPD6::signal_config.INT2BUT = 1; + ADPD6::signal_config.ac_type = 2; + + ADPD6::DI_config.ch2_en = true; + ADPD6::signal_config.IN12 = 0B0011; + ADPD6::signal_config.IN34 = 0B0100; + + + + ADPD6::num_ts(ts + 1); + ADPD6::ts_setup((adi_adpd6000_slot_e)ts, &(ADPD6::DI_config)); + ADPD6::ts_setup((adi_adpd6000_slot_e)ts, &(ADPD6::signal_config)); + ADPD6::ts_setup((adi_adpd6000_slot_e)ts, &(ADPD6::SNR_config)); + ADPD6::ts_setup((adi_adpd6000_slot_e)ts, &(ADPD6::led_config)); + + return 0; +} + + + + + +// int32_t ADPD6::current_sweep(uint8_t led, uint8_t PD_IN, uint8_t gain, uint32_t *data){ +// if (!(ADPD6::chip_check)){ +// Serial.println("adpd not init1"); +// return -2; +// } + +// if (data == NULL) return -1; +// for (uint8_t i = 0; i < 60; i++) data[i] = 0; + +// ADPD6::STOP(); +// ADPD6::DI_config.period_min = 58; +// ADPD6::DI_config.LIT_OFFSET = 64; +// ADPD6::DI_config.DARK_OFFSET1 = 48; +// ADPD6::DI_config.DARK_OFFSET2 = 90; +// ADPD6::DI_config.LED_pulse_offset = 60; +// ADPD6::DI_config.LED_pulse_width = 19; +// ADPD6::DI_config.sample_type = 3; +// ADPD6::DI_config.num_integration = 1; + +// if ((led == 1)|(led == 3)){ +// ADPD6::led_config.led1_channel = LED_A; +// ADPD6::led_config.led2_channel = LED_A; +// } +// if ((led == 2)|(led == 4)){ +// ADPD6::led_config.led1_channel = LED_B; +// ADPD6::led_config.led2_channel = LED_B; +// } + +// ADPD6::signal_config.IN12 = 0; +// ADPD6::signal_config.IN34 = 0; +// switch (PD_IN) +// { +// case 1: +// ADPD6::signal_config.IN12 = 1; +// break; +// case 2: +// ADPD6::signal_config.IN12 = 3; +// break; +// case 3: +// ADPD6::signal_config.IN34 = 1; +// break; +// case 4: +// ADPD6::signal_config.IN34 = 3; +// break; +// default: +// break; +// } + +// ADPD6::signal_config.pre_condition_type = 5; +// ADPD6::SNR_config.Ch1_R_int = 3; +// ADPD6::SNR_config.C_int_CH1 = 1; +// ADPD6::signal_config.INT2BUT = 1; +// ADPD6::signal_config.ac_type = 2; + +// ADPD6::SNR_config.TIA_gain_CH1 = gain; +// ADPD6::led_config.driver1_current = 0; +// ADPD6::led_config.driver2_current = 0; + + +// uint8_t* p_I_led_driver = &(ADPD6::led_config.driver1_current); +// *p_I_led_driver = 0; +// if (led > 2) p_I_led_driver = &(ADPD6::led_config.driver2_current); +// ADPD6::num_ts(12); + +// for (uint8_t i = 0; i < 12; i++){ +// ADPD6::ts_setup((adi_adpd6000_slot_e)i, &(ADPD6::DI_config)); +// ADPD6::ts_setup((adi_adpd6000_slot_e)i, &(ADPD6::signal_config)); +// ADPD6::ts_setup((adi_adpd6000_slot_e)i, &(ADPD6::SNR_config)); +// } + +// ADPD6::run_freq(500); +// uint32_t ret[12]; +// uint8_t cycle_counter = 0; + +// for (uint8_t c = 0; c < 5; c++){ + +// for (uint8_t i = 0; i < 12; i++){ +// *p_I_led_driver = i * 10 + c * 2; +// ADPD6::ts_setup((adi_adpd6000_slot_e)i, &(ADPD6::led_config)); +// } + +// ADPD6::clear_fifo(); +// ADPD6::RUN(); +// while (ADPD6::fifo_count() < 12 * 3 * 4){ +// delay(10); +// } +// ADPD6::STOP(); + + +// for (uint8_t n = 0; n < 4; n++){ +// ADPD6::readfifo(12, 3, ret); +// for (uint8_t i = 0; i < 12; i++){ +// data[i * 5 + c] += ret[i]; +// } +// } +// } + +// for (uint8_t i = 0; i < 60; i++){ +// data[i] = (data[i] >> 2); +// } +// return 0; +// } + + +// int32_t ADPD6::augogain(uint8_t led, uint8_t PD_IN, uint8_t mode, struct light_gain_setting * output){ +// uint32_t trace[60]; +// uint8_t idx = 0; + +// for (int8_t g = 5; g > -1; g--){ +// ADPD6::current_sweep(led, PD_IN, g, trace); +// idx = 59; +// for (uint8_t i = 0; i < 60; i++){ +// //Serial.println(trace[i]); +// if (trace[i] > 8000){ +// idx = i; +// break; +// } +// } +// if (idx < 10) break; + +// if ( (idx < 30) || ((idx < 59) && (mode == 0)) ){ // Led saturated with half the current or low gain high current mode +// // Serial.print(g); +// // Serial.print(idx); + +// output->current = idx * 2; +// output->gain = g; +// return 0 ; +// } +// output->gain = g; +// } +// output->current = idx * 2; +// return 0; +// } + +// int32_t ADPD6::augogain(uint8_t led, uint8_t PD_IN, uint8_t mode){ +// struct light_gain_setting output; +// ADPD6::augogain(led, PD_IN, mode, &output); +// Serial.println(output.current); +// Serial.println(output.gain); +// return 0; +// } + +// int32_t ADPD6::led_input_preset(struct light_gain_setting* output){ +// if (output == NULL) return -1; +// if (!(ADPD6::chip_check)){ +// Serial.println("adpd not init2"); +// return -2; +// } +// ADPD6::STOP(); + +// ADPD6::led_config.led1_channel = (driverside) output->led_side; +// ADPD6::led_config.led2_channel = (driverside)output->led_side; + +// ADPD6::led_config.driver1_current = 0; +// ADPD6::led_config.driver2_current = 0; +// if (output->led_driver == 1) ADPD6::led_config.driver1_current = output->current; +// if (output->led_driver == 2) ADPD6::led_config.driver2_current = output->current; + +// ADPD6::signal_config.IN12 = 0; +// ADPD6::signal_config.IN34 = 0; + +// if (output->PD == 1) ADPD6::signal_config.IN12 = 1; +// if (output->PD == 2) ADPD6::signal_config.IN12 = 3; +// if (output->PD == 3) ADPD6::signal_config.IN34 = 1; +// if (output->PD == 4) ADPD6::signal_config.IN34 = 3; + +// ADPD6::SNR_config.TIA_gain_CH1 = output->gain; +// return 0; +// } + +// int32_t ADPD6::DI_FluoRef(uint8_t ts, uint8_t num_integ){ +// if (!(ADPD6::chip_check)){ +// Serial.println("adpd not init3"); +// return -2; +// } + +// ADPD6::STOP(); +// ADPD6::DI_config.period_min = 58; +// ADPD6::DI_config.LIT_OFFSET = 64; +// ADPD6::DI_config.DARK_OFFSET1 = 48; +// ADPD6::DI_config.DARK_OFFSET2 = 90; +// ADPD6::DI_config.LED_pulse_offset = 60; +// ADPD6::DI_config.LED_pulse_width = 19; +// ADPD6::DI_config.sample_type = 3; +// ADPD6::DI_config.signal_size = 3; +// ADPD6::DI_config.num_integration = num_integ; +// ADPD6::DI_config.lit_size = 0; +// ADPD6::DI_config.dark_size = 0; + +// ADPD6::signal_config.pre_condition_type = 5; +// ADPD6::SNR_config.Ch1_R_int = 3; +// ADPD6::SNR_config.C_int_CH1 = 1; +// ADPD6::SNR_config.Ch2_R_int = 3; +// ADPD6::SNR_config.C_int_CH2 = 1; +// ADPD6::signal_config.INT2BUT = 1; +// ADPD6::signal_config.ac_type = 2; + +// ADPD6::DI_config.ch2_en = true; +// ADPD6::signal_config.IN12 = 0B0011; +// ADPD6::signal_config.IN34 = 0B0100; + +// ADPD6::num_ts(ts + 1); + +// ADPD6::ts_setup((adi_adpd6000_slot_e)ts, &(ADPD6::DI_config)); +// ADPD6::ts_setup((adi_adpd6000_slot_e)ts, &(ADPD6::signal_config)); +// ADPD6::ts_setup((adi_adpd6000_slot_e)ts, &(ADPD6::SNR_config)); +// ADPD6::ts_setup((adi_adpd6000_slot_e)ts, &(ADPD6::led_config)); + +// return 0; + +// } + +// int32_t ADPD6::DI_ambient(uint8_t ts, uint8_t num_integ){ +// if (!(ADPD6::chip_check)){ +// Serial.println("adpd not init3"); +// return -2; +// } + +// ADPD6::STOP(); +// ADPD6::DI_config.period_min = 58; +// ADPD6::DI_config.LIT_OFFSET = 64; +// ADPD6::DI_config.DARK_OFFSET1 = 48; +// ADPD6::DI_config.DARK_OFFSET2 = 90; +// ADPD6::DI_config.LED_pulse_offset = 60; +// ADPD6::DI_config.LED_pulse_width = 19; +// ADPD6::DI_config.sample_type = 3; +// ADPD6::DI_config.num_integration = num_integ; +// ADPD6::DI_config.dark_size = 3; +// ADPD6::DI_config.lit_size = 0; +// ADPD6::DI_config.signal_size = 0; + +// ADPD6::signal_config.pre_condition_type = 5; +// ADPD6::SNR_config.Ch1_R_int = 3; +// ADPD6::SNR_config.C_int_CH1 = 1; +// ADPD6::SNR_config.Ch2_R_int = 3; +// ADPD6::SNR_config.C_int_CH2 = 1; +// ADPD6::signal_config.INT2BUT = 1; +// ADPD6::signal_config.ac_type = 0; + +// ADPD6::DI_config.ch2_en = false; +// ADPD6::signal_config.IN12 = 0B0001; +// ADPD6::signal_config.IN34 = 0B0000; + +// ADPD6::num_ts(ts + 1); + +// ADPD6::ts_setup((adi_adpd6000_slot_e)ts, &(ADPD6::DI_config)); +// ADPD6::ts_setup((adi_adpd6000_slot_e)ts, &(ADPD6::signal_config)); +// ADPD6::ts_setup((adi_adpd6000_slot_e)ts, &(ADPD6::SNR_config)); +// ADPD6::ts_setup((adi_adpd6000_slot_e)ts, &(ADPD6::led_config)); + +// return 0; + +// } + + + + + +// int32_t ADPD6::current_sweep2(uint8_t led, uint8_t PD_IN, uint8_t gain, uint8_t ac, uint32_t *data){ +// if (!(ADPD6::chip_check)){ +// Serial.println("adpd not init1"); +// return -2; +// } + +// if (data == NULL) return -1; +// for (uint8_t i = 0; i < 60; i++) data[i] = 0; + +// ADPD6::STOP(); +// ADPD6::DI_config.period_min = 58; +// ADPD6::DI_config.LIT_OFFSET = 64; +// ADPD6::DI_config.DARK_OFFSET1 = 48; +// ADPD6::DI_config.DARK_OFFSET2 = 90; +// ADPD6::DI_config.LED_pulse_offset = 60; +// ADPD6::DI_config.LED_pulse_width = 19; +// ADPD6::DI_config.sample_type = 3; +// ADPD6::DI_config.num_integration = 1; + +// if ((led == 1)|(led == 3)){ +// ADPD6::led_config.led1_channel = LED_A; +// ADPD6::led_config.led2_channel = LED_A; +// } +// if ((led == 2)|(led == 4)){ +// ADPD6::led_config.led1_channel = LED_B; +// ADPD6::led_config.led2_channel = LED_B; +// } + +// ADPD6::signal_config.IN12 = 0; +// ADPD6::signal_config.IN34 = 0; +// switch (PD_IN) +// { +// case 1: +// ADPD6::signal_config.IN12 = 1; +// break; +// case 2: +// ADPD6::signal_config.IN12 = 3; +// break; +// case 3: +// ADPD6::signal_config.IN34 = 1; +// break; +// case 4: +// ADPD6::signal_config.IN34 = 3; +// break; +// default: +// break; +// } + +// ADPD6::signal_config.pre_condition_type = 5; +// ADPD6::SNR_config.Ch1_R_int = 3; +// ADPD6::SNR_config.C_int_CH1 = 1; +// ADPD6::signal_config.INT2BUT = 1; +// if (ac < 3) ADPD6::signal_config.ac_type = ac; +// if (ac > 3){ +// ADPD6::signal_config.ac_type = 3; +// ADPD6::SNR_config.ch1_dac = ac * 10; +// } + + +// ADPD6::SNR_config.TIA_gain_CH1 = gain; +// ADPD6::led_config.driver1_current = 0; +// ADPD6::led_config.driver2_current = 0; + + +// uint8_t* p_I_led_driver = &(ADPD6::led_config.driver1_current); +// *p_I_led_driver = 0; +// if (led > 2) p_I_led_driver = &(ADPD6::led_config.driver2_current); +// ADPD6::num_ts(12); + +// for (uint8_t i = 0; i < 12; i++){ +// ADPD6::ts_setup((adi_adpd6000_slot_e)i, &(ADPD6::DI_config)); +// ADPD6::ts_setup((adi_adpd6000_slot_e)i, &(ADPD6::signal_config)); +// ADPD6::ts_setup((adi_adpd6000_slot_e)i, &(ADPD6::SNR_config)); +// } + +// ADPD6::run_freq(500); +// uint32_t ret[12]; +// uint8_t cycle_counter = 0; + +// for (uint8_t c = 0; c < 5; c++){ + +// for (uint8_t i = 0; i < 12; i++){ +// *p_I_led_driver = i * 10 + c * 2; +// ADPD6::ts_setup((adi_adpd6000_slot_e)i, &(ADPD6::led_config)); +// } + +// ADPD6::clear_fifo(); +// ADPD6::RUN(); +// while (ADPD6::fifo_count() < 12 * 3 * 4){ +// delay(10); +// } +// ADPD6::STOP(); +// //Serial.println(ADPD6::read_reg(REG_AFE_DAC1_A_ADDR)); + + + +// for (uint8_t n = 0; n < 4; n++){ +// ADPD6::readfifo(12, 3, ret); +// for (uint8_t i = 0; i < 12; i++){ +// data[i * 5 + c] += ret[i]; +// } +// } +// } + +// for (uint8_t i = 0; i < 60; i++){ +// data[i] = (data[i] >> 2); +// } +// return 0; +// } \ No newline at end of file diff --git a/src/src/adpd/u_adpd6100.h b/src/src/adpd/u_adpd6100.h new file mode 100644 index 0000000..f946204 --- /dev/null +++ b/src/src/adpd/u_adpd6100.h @@ -0,0 +1,97 @@ +/*! + * @brief ADPD6000 configuration header + * @copyright MSU-PRL Kramer Lab + * @author Jingcheng Huang + * @date 20230224 + */ + +#ifndef __U_ADPD6000_H__ +#define __U_ADPD6000_H__ + +#include +#include "lib/ADPD6000/adi_adpd6000.h" +#include "driver/spi_common.h" +#include "driver/spi_master.h" +#include "../pin_config.h" +#include "u_adpd6100_typedef.h" +class ADPD6; + +class ADPD6{ + public: + + adi_adpd6000_device_t handle; + ADPD6(); + ~ADPD6(); + bool begin(); + int32_t write_reg(uint32_t reg_addr, uint16_t *reg_data); + int32_t read_reg(uint32_t reg_addr); + int32_t clear_fifo(); + int32_t run_freq(uint32_t freq); + int32_t num_ts(uint8_t); + int32_t RUN(); + int32_t STOP(); + uint16_t fifo_count(); + int32_t readfifo(uint16_t num_samples, uint8_t width, uint32_t* data); + bool chip_check = false; + struct system_config sys_config; + struct ts_led led_config; + struct ts_SNR SNR_config; + struct ts_DI_timing DI_config; + struct ts_AI_timing AI_config; + struct ts_signal signal_config; + struct GPIO0_config gpio_config; + + + int32_t ts_setup(adi_adpd6000_slot_e timeslot_no,struct ts_led *init); + int32_t ts_setup(adi_adpd6000_slot_e timeslot_no, struct ts_SNR *init); + int32_t ts_setup(adi_adpd6000_slot_e timeslot_no, struct ts_signal *init); + int32_t ts_setup(adi_adpd6000_slot_e timeslot_no, struct ts_DI_timing *init); + int32_t ts_setup(adi_adpd6000_slot_e timeslot_no, struct ts_AI_timing *init); + + int32_t gpio_setup(struct GPIO0_config *init); + int32_t global_setup(struct system_config *init); + + + int32_t preset_config_1(uint8_t ts, uint8_t num_integ); + int32_t preset_config_2(uint8_t ts, uint8_t num_integ); + int32_t preset_config_2x(uint8_t ts, uint8_t num_integ, uint8_t lit_offset, uint8_t dark1_offset, uint8_t dark2_offset, uint8_t pulse_offset, uint8_t pulse_duration); + int32_t preset_config_3(uint8_t ts, uint8_t num_integ); + int32_t preset_config_4(uint8_t ts); + int32_t repeats_only(uint8_t ts, uint16_t num_integration, uint8_t num_repeats); + int32_t preset_config_ext_fast(uint8_t ts); + int32_t preset_config_ext_fast(uint8_t ts, uint8_t); + + + + + // int32_t current_sweep(uint8_t led, uint8_t PD_IN, uint8_t gain, uint32_t *data); + // int32_t augogain(uint8_t led, uint8_t PD_IN, uint8_t mode, struct light_gain_setting * output); + // int32_t augogain(uint8_t led, uint8_t PD_IN, uint8_t mode); + // int32_t led_input_preset(struct light_gain_setting * output); + // int32_t DI_FluoRef(uint8_t ts, uint8_t num_integ); + // int32_t DI_ambient(uint8_t ts, uint8_t num_integ); + // int32_t current_sweep2(uint8_t led, uint8_t PD_IN, uint8_t gain, uint8_t ac, uint32_t *data); + + + + + + + + private: + bool _spi_device_attached = false; + spi_device_interface_config_t adpd_spi_dev; + spi_device_handle_t adpd1_spi_handle = NULL; + + + void load_default(struct ts_led *ts); + void load_default(struct ts_SNR *ts); + void load_default(struct ts_signal *ts); + void load_default(struct ts_DI_timing *ts); + void load_default(struct ts_AI_timing *ts); + void load_default(struct system_config *ts); + void load_default(struct GPIO0_config *ts); + +}; + +#endif \ No newline at end of file diff --git a/src/src/adpd/u_adpd6100_typedef.h b/src/src/adpd/u_adpd6100_typedef.h new file mode 100644 index 0000000..d05e977 --- /dev/null +++ b/src/src/adpd/u_adpd6100_typedef.h @@ -0,0 +1,610 @@ + +struct light_gain_setting{ + uint8_t led_driver; + uint8_t led_side; + uint8_t gain; + uint8_t current; + uint8_t PD; +}; + + +enum driverside{ + LED_A, + LED_B +}; + +struct ts_led{ + uint8_t driver2_current; /*LED 2 output and current control 0 - 127 (200mA) */ + uint8_t driver1_current; /* LED 1 output and current control 0 - 127 (200mA) */ + enum driverside led2_channel; /* LED 2 Channel LED_A or LED_B */ + enum driverside led1_channel; /* LED 1 Channel LED_A or LED_B */ + uint8_t led2_mode; /* Choose the operation mode of LED2x. 0: high SNR mode. 1: low compliance mode. */ + uint8_t led1_mode; /* Choose the operation mode of LED1x. 0: high SNR mode. 1: low compliance mode. */ +}; + +struct ts_SNR{ + + /** + * Channel 1 ambient cancellation DAC code from 0 μA to 300 μA + * with 0.6 μA/LSB step. + */ + uint16_t ch1_dac; + + /** + * Channel 1 LED dc offset cancellation DAC code from 0 μA to 190 μA with 1.5 μA/LSB step. + * Set to 0 to disable. + */ + uint8_t ch1_led_offset; + + /** + * Channel 2 ambient cancellation DAC code from 0 μA to 300 μA with 0.6 μA/LSB step. + */ + uint16_t ch2_dac; + + /** + * Channel 2 LED dc offset cancellation DAC code from 0 μA to 190 μA with 1.5 μA/LSB step. Set to 0 to disable. + */ + uint8_t ch2_led_offset; + + /** + * Enable TIA saturation detection. Set to 1 to enable TIA saturation detection circuitry. + * Enables Channel 1 and also Channel 2 if Channel 2 is enabled. + * + */ + uint8_t TIA_ceiling_det; + + /* + * Channel 2 integrator resistor or buffer gain. + * 00: RIN = 400 kΩ or buffer gain = 1 (RF/RIN = 200 kΩ/200 kΩ). << + * 01: RIN = 200 kΩ or buffer gain = 2 (RF/RIN = 200 kΩ/100 kΩ). + * 10: RIN = 100 kΩ or buffer gain = 1 (RF/RIN = 100 kΩ/100 kΩ). + * 11: RIN = 50 kΩ or buffer gain = 2 (RF/RIN = 100 kΩ/50 kΩ). + */ + uint8_t Ch2_R_int; + + /**Channel 1 integrator resistor or buffer gain. + * 00: RIN = 400 kΩ or buffer gain = 1 (RF/RIN = 200 kΩ/200 kΩ). << + * 01: RIN = 200 kΩ or buffer gain = 2 (RF/RIN = 200 kΩ/100 kΩ). + * 10: RIN = 100 kΩ or buffer gain = 1 (RF/RIN = 100 kΩ/100 kΩ). + * 11: RIN = 50 kΩ or buffer gain = 2 (RF/RIN = 100 kΩ/50 kΩ). + */ + uint8_t Ch1_R_int; + + /**TIA_VREF pulse control. + * 0: no pulsing. + * 1: pulse TIA_VREF based on modulate pulse. + */ + uint8_t Vref_pulse; + /** Voltage trim for ref buffer. + * 00: TIA_VREF = 0.8855 V, PD reverse bias = 600 mV. + * 01: TIA_VREF = 0.8855 V, PD reverse bias = 400 mV. + * 10: TIA_VREF = 0.8855 V, PD reverse bias = 200 mV. << + * 11: TIA_VREF = 1.265 V, PD reverse bias = 200 mV. + */ + uint8_t Vref_VPD; + /**TIA_VREF pulse alternate value. + * 00: TIA_VREF = 0.8855 V, PD reverse bias = 600 mV. + * 01: TIA_VREF = 0.8855 V, PD reverse bias = 400 mV. + * 10: TIA_VREF = 0.8855 V, PD reverse bias = 200 mV. + * 11: TIA_VREF = 1.265 V, PD reverse bias = 200 mV. << + */ + uint8_t Vref_VPD_pulse; + + /** TIA resistor gain setting for Channel 2. + * 000: 400 kΩ. + * 001: 200 kΩ. << + * 010: 100 kΩ. + * 011: 50 kΩ. + * 100: 25 kΩ. + * 101: 12.5 kΩ. + */ + uint8_t TIA_gain_CH2; + + /** TIA resistor gain setting for Channel 1. + * 000: 400 kΩ. + * 001: 200 kΩ. << + * 010: 100 kΩ. + * 011: 50 kΩ. + * 100: 25 kΩ. + * 101: 12.5 kΩ. + */ + uint8_t TIA_gain_CH1; + + + /** Channel2 integrator capacitor. + * 0: 6.3 pF. << + * 1: 12.6 pF. + */ + uint8_t C_int_CH2; + + /** Channel1 integrator capacitor. + * 0: 6.3 pF. << + * 1: 12.6 pF. + */ + uint8_t C_int_CH1; +}; + + +struct ts_signal{ + // 0x0121 REG_TS_PATH_A_ADDR + + /** Precondition duration for this time slot. This value is in 2 μs + * increments. A value of 0 skips the precondition state. 4 = 8us + */ + uint8_t pre_condition_width; + + /**Select the control type for the ambient cancellation DAC. + * 00: disable the ambient cancellation loop. <-- + * 01: enable coarse and fine loop. + * 10: enable coarse loop only. + * 11: enable MCU control. + */ + uint8_t ac_type; + /**Timeslot specific GPIO value for this time slot.*/ + uint8_t gpio_out; + /**Convert integrator to buffer. = 0*/ + uint8_t INT2BUT; + /**Bypass and input mux select. Integrator is either an integrator or + * buffer based on mode and AFE_INT_C_BUF for the active time + * slot. + * 0x20: TIA, integrator/buffer, and ADC (2× TIA configuration). <-- + * 0x28: TIA, buffer, and ADC (1× TIA configuration). + * 0x31: TIA, integrator, and ADC (1× TIA configuration). + * 0x35: integrator and ADC. + * 0x41: ADC.*/ + uint8_t AFE_PATh; + + //0x0122 INPUTS_A + /**IN3 and IN4 input pair enable. + * 0000: input pair disabled. IN3 and IN4 disconnected. + * 0001: IN3 connected to Channel 1. IN4 disconnected. + * 0010: IN3 connected to Channel 2. IN4 disconnected. + * 0011: IN4 connected to Channel 1. IN3 disconnected. + * 0100: IN4 connected to Channel 2. IN3 disconnected. + * 0101: IN3 connected to Channel 1. IN4 connected to Channel 2. + * 0110: IN4 connected to Channel 1. IN3 connected to Channel 2. + * (Not implemented) + * 0111: IN3 and IN4 connected to Channel 1. Single-ended or differential, based on PAIR34. None to channel 2. + * 1000: IN3 and IN4 connected to Channel 2. Single-ended or differential, based on PAIR34.*/ + uint8_t IN34; + /**IN1 and IN2 input pair enable. + * 0000: input pair disabled. IN1 and IN2 disconnected. + * 0001: IN1 connected to Channel 1. IN2 disconnected. + * 0010: IN1 connected to Channel 2. IN2 disconnected. + * 0011: IN2 connected to Channel 1. IN1 disconnected. + * 0100: IN2 connected to Channel 2. IN1 disconnected. + * 0101: IN1 connected to Channel 1. IN2 connected to Channel 2. + * 0110: IN2 connected to Channel 1. IN1 connected to Channel 2. + * * (Not implemented) + * 0111: IN1 and IN2 connected to Channel 1. Single-ended or differential, based on PAIR12. None to channel 2. + * 1000: IN1 and IN2 connected to Channel 2. Single-ended or differential, based on PAIR12.*/ + uint8_t IN12; + + //0x0123 CATHODE_A + /**Precondition value for enabled inputs during this time slot. + * 000: float inputs. <--- + * 001: precondition to VC1. + * 010: precondition to VC2. + * 011: precondition to VICM. + * 100: precondition with TIA input. + * 101: precondition with TIA_VREF. + * 110: Precondition by shorting differential pair. + */ + uint8_t pre_condition_type; + + /**VC2 pulse control. + * 00: no pulsing. <--- + * 01: alternate odd/even time slots. + * 10: pulse to alternate value using modulate pulse. + * 11: leave VC2 floating.*/ + uint8_t VC2_pulse_type; + /**VC2 alternate pulsed state for this time slot. + * 00: AVDD. <--- + * 01: TIA_VREF. + * 10: TIA_VREF + 215 mV (V_DELTA). + * 11: GND. + */ + uint8_t VC2_pulse_to; + /**VC2 active state for this time slot. + * 00: AVDD. <--- + * 01: TIA_VREF. + * 10: TIA_VREF + 215 mV (V_DELTA). + * 11: GND. + */ + uint8_t VC2_active; + + /**VC2 pulse control. + * 00: no pulsing. <--- + * 01: alternate odd/even time slots. + * 10: pulse to alternate value using modulate pulse. + * 11: leave VC2 floating.*/ + uint8_t VC1_pulse_type; + /**VC2 alternate pulsed state for this time slot. + * 00: AVDD. <--- + * 01: TIA_VREF. + * 10: TIA_VREF + 215 mV (V_DELTA). + * 11: GND. + */ + uint8_t VC1_pulse_to; + /**VC2 active state for this time slot. + * 00: AVDD. <--- + * 01: TIA_VREF. + * 10: TIA_VREF + 215 mV (V_DELTA). + * 11: GND. + */ + uint8_t VC1_active; + +}; + +struct ts_DI_timing{ + /**Number of ADC cycles or acquisition width. Number of analog + * integration cycles per ADC conversion or the acquisition width + * for digital integration. A setting of 0 is not allowed. + * = 1*/ + uint16_t num_integration; + /**Number of sequence repeats. Total number of pulses = + * NUM_INT_x × NUM_REPEAT_x. A setting of 0 is not allowed. + = 1*/ + uint8_t num_repeats; + + /**Modulation connection type. + * 00: TIA is continuously connected to input after precondition. No connection modulation. << + * 01: float type operation. Pulse connection from input to TIA with modulate pulse, floating between pulses. + * 10: nonfloat type connection modulation. Pulse connection from input to TIA. Connect to precondition value between pulses. + */ + uint8_t Modulation_type; + + /**Minimum period for pulse repetition. + * Override for the automatically calculated period. + * Used in float type operations to set the floating time of second and subsequent floats using the following formula: + * Float Time = MIN_PERIOD_x − MOD_WIDTH_x. + * = 0 + */ + uint16_t period_min; + /**LED pulse width. = 2*/ + uint16_t LED_pulse_width; + /**LED pulse offset. = 0x10*/ + uint8_t LED_pulse_offset; + + /**LED pulse offset for the second LED phase. = 0x13*/ + uint8_t LED_pulse2_offset; + /*Acquisition window lit offset for Time Slot x. + = 0x26 */ + uint16_t LIT_OFFSET; + /*Acquisition window Dark Offset 2 for Time Slot x. + 0x1*/ + uint16_t DARK_OFFSET2; + /*Acquisition window Dark Offset 1 for Time Slot x. + 0x6*/ + uint8_t DARK_OFFSET1; + //0x0120 TS_CTRL_A + /**Subsample using DECIMATE_FACTOR_x. When this bit is set, + * operate the time slot only once per (DECIMATE_FACTOR_X + 1) time slot sequences. + * This subsampling aligns to other time slots using the same decimate factor. + * Subsampling skips DECMATE_FACTOR_x times and then executes the time slot. << 0*/ + uint8_t subsample_en; + /**Channel 2 enable. + * 0: Channel 2 disabled. << + * 1: Channel 2 enabled. + */ + uint8_t ch2_en; + /**Time slot sampling type. + * 000: normal sampling mode. << + * 001: two phase normal sampling mode. + * 010: on-region digital integrate mode. + * 011: two-region digital integrate mode. + */ + uint8_t sample_type; + /**Time Slot X offset in 64 × 960 kHz or 64 × (external 960 kHz) + * cycles. = 0*/ + uint16_t ts_offset; + + /** + * Dark data shift = 0 + */ + uint8_t dark_shift; + /** + * Dark data size = 0 + */ + uint8_t dark_size; + /** + * Signal data shift = 0 + */ + uint8_t signal_shift; + /** + * Signal data size = 3 + */ + uint8_t signal_size; + /** + * Lit data shift = 0 + */ + uint8_t lit_shift; + /** + * Signal data size = 0 + */ + uint8_t lit_size; + + +}; + + +struct ts_AI_timing{ + /**Number of ADC cycles or acquisition width. Number of analog + * integration cycles per ADC conversion or the acquisition width + * for digital integration. A setting of 0 is not allowed. + * = 1*/ + uint16_t num_integration; + /**Number of sequence repeats. Total number of pulses = + * NUM_INT_x × NUM_REPEAT_x. A setting of 0 is not allowed. + = 1*/ + uint8_t num_repeats; + + /**Modulation connection type. + * 00: TIA is continuously connected to input after precondition. No connection modulation. << + * 01: float type operation. Pulse connection from input to TIA with modulate pulse, floating between pulses. + * 10: nonfloat type connection modulation. Pulse connection from input to TIA. Connect to precondition value between pulses. + */ + uint8_t Modulation_type; + + /**Minimum period for pulse repetition. + * Override for the automatically calculated period. + * Used in float type operations to set the floating time of second and subsequent floats using the following formula: + * Float Time = MIN_PERIOD_x − MOD_WIDTH_x. + * = 0 + */ + uint16_t period_min; + /**LED pulse width. = 2*/ + uint16_t LED_pulse_width; + /**LED pulse offset. = 0x10*/ + uint8_t LED_pulse_offset; + + /**LED pulse offset for the second LED phase. = 0x13*/ + uint8_t LED_pulse2_offset; + + //0x012E INTEG_WIDTH_A + /**Use single integrator pulse. + * 0: use both generated integrator clocks. << + * 1: skip the second integrator clock. + */ + uint8_t SINGLE_INTEG; + /**Amplifier disables for power control. Set the appropriate bit to disable the Channel 2 amplifier in Time Slot x. + * 0: TIA. << + * 1: integrator.*/ + uint8_t CH2_DIS_AMP; + /**Amplifier disables for power control. Set the appropriate bit to disable the Channel 1 amplifier in Time Slot x. + * 0: TIA. << + * 1: integrator.*/ + uint8_t CH1_DIS_AMP; + /**ADC conversions per pulse. Number of conversions = ADC_COUNT + 1.*/ + uint8_t ADC_count; + /**Integrator clock width. = 3us*/ + uint16_t integration_width; + + //0x012F INTEG_OFFSET_A + /**Integrator clock coarse offset. + * 0xD + */ + uint8_t offset_us; + /**Integrator clock fine offset. << 0*/ + uint8_t offset_ns; + + uint16_t modulation_width; + uint8_t modulation_offset; + + //0x0131 PATTERN1_A + /**Four-pulse LED disable pattern. Set to 1 to disable the LED + * pulse in the matching position in a group of four pulses. The LSB + * maps to the first pulse.*/ + uint8_t pattern_LED_disable; + /**Four-pulse modulation disable pattern. Set to 1 to disable the + * modulation pulse in the matching position in a group of four + * pulses. The LSB maps to the first pulse.*/ + uint8_t pattern_MOD_disable; + /**Four-pulse subtract pattern. Set to 1 to negate the math + * operation in the matching position in a group of four pulses. + * The LSB maps to the first pulse.*/ + uint8_t pattern_subtract; + /**Four-pulse integration reverse pattern. Set to 1 to reverse the + * integrator pos/neg pulse order in the matching position in a + * group of four pulses. The LSB maps to the first pulse.*/ + uint8_t pattern_reverse_int; + + //0x0120 TS_CTRL_A + /**Subsample using DECIMATE_FACTOR_x. When this bit is set, + * operate the time slot only once per (DECIMATE_FACTOR_X + 1) time slot sequences. + * This subsampling aligns to other time slots using the same decimate factor. + * Subsampling skips DECMATE_FACTOR_x times and then executes the time slot. << 0*/ + uint8_t subsample_en; + /**Channel 2 enable. + * 0: Channel 2 disabled. << + * 1: Channel 2 enabled. + */ + uint8_t ch2_en; + /**Time slot sampling type. + * 000: normal sampling mode. << + * 001: two phase normal sampling mode. + * 010: on-region digital integrate mode. + * 011: two-region digital integrate mode. + */ + uint8_t sample_type; + /**Time Slot X offset in 64 × 960 kHz or 64 × (external 960 kHz) + * cycles. = 0*/ + uint16_t ts_offset; +}; + +struct system_config{ + //0x0020 INPUT_SLEEP + /**Input pair sleep state for IN3 and IN4 inputs. + * 0x0: both inputs float. << + * 0x1: floating short of IN3 to IN4. Only if PAIR34 is set to 1. + * 0x2: IN3 and IN4 connected to VC1. Shorted together if PAIR34 is set to 1. + * 0x3: IN3 and IN4 connected to VC2. Shorted together if PAIR34 is set to 1. + * 0x4: IN3 connected to VC1. IN4 floating. + * 0x5: IN3 connected to VC1. IN4 connected to VC2. + * 0x6: IN3 connected to VC1. IN4 floating. + * 0x7: IN3 connected to VC2. IN4 connected to VC1. + * 0x8: IN3 floating. IN4 connected to VC1. + * 0x9: IN3 floating. IN4 connected to VC2. + */ + uint8_t IN34_sleep; + /**Input pair sleep state for IN1 and IN2 inputs. + * 0x0: both inputs float. << + * 0x1: floating short of IN1 to IN2. Only if PAIR12 is set to 1. + * 0x2: IN1 and IN2 connected to VC1. Shorted together if PAIR12 is set to 1. + * 0x3: IN1 and IN2 connected to VC2. Shorted together if PAIR12 is set to 1. + * 0x4: IN1 connected to VC1. IN2 floating. + * 0x5: IN1 connected to VC1. IN2 connected to VC2. + * 0x6: IN1 connected to VC1. IN2 floating. + * 0x7: IN1 connected to VC2. IN2 connected to VC1. + * 0x8: IN1 floating. IN2 connected to VC1. + * 0x9: IN1 floating. IN2 connected to VC2. + */ + uint8_t IN12_sleep; + //0x0021 INPUT_CFG + /**VC2 sleep state. + * 00: VC2 set to AVDD during sleep. << + * 01: VC2 set to GND during sleep. + * 10: VC2 floating during sleep. + * */ + uint8_t VC2_sleep; + /**VC1 sleep state. + * 00: VC1 set to AVDD during sleep. << + * 01: VC1 set to GND during sleep. + * 10: VC1 floating during sleep. + * */ + uint8_t VC1_sleep; + /**Input pair configuration. + * 0: use as two single-ended inputs. << + * 1: use as a differential pair. + * */ + uint8_t PAIR34; + /**Input pair configuration. + * 0: use as two single-ended inputs. << + * 1: use as a differential pair. + * */ + uint8_t PAIR12; + //0x0022 GPIO_CFG + /**Slew control for GPIOx pins. + * 00: slowest. << + * 01: slow. + * 10: fastest. + * 11: fast.*/ + uint8_t GPIO_slew; + /**Drive control for GPIOx pins. + * 00: medium. << + * 01: weak. + * 10: strong. + * 11: strong.*/ + uint8_t GPIO_drv; + /**GPIO2 pin configuration. + * 000: disabled (tristate, input buffer off). << + * 001: enabled input. + * 010: output–normal. + * 011: output–inverted. + * 100: pull-down only–normal. + * 101: pull-down only–inverted. + * 110: pull-up only–normal. + * 111: pull-up only–inverted. + */ + uint8_t GPIO2_cfg; + /**GPIO1 pin configuration. + * 000: disabled (tristate, input buffer off). << + * 001: enabled input. + * 010: output–normal. + * 011: output–inverted. + * 100: pull-down only–normal. + * 101: pull-down only–inverted. + * 110: pull-up only–normal. + * 111: pull-up only–inverted. + */ + uint8_t GPIO1_cfg; + /**GPIO0 pin configuration. + * 000: disabled (tristate, input buffer off). << + * 001: enabled input. + * 010: output–normal. + * 011: output–inverted. + * 100: pull-down only–normal. + * 101: pull-down only–inverted. + * 110: pull-up only–normal. + * 111: pull-up only–inverted. + */ + uint8_t GPIO0_cfg; + /**GPIO1 output signal select.*/ + uint8_t GPIO1_output; + /**GPIO0 output signal select.*/ + uint8_t GPIO0_output; + /**GPIO2 output signal select.*/ + uint8_t GPIO2_output; + /**Set to 0x0 if IOVDD of 3 V or higher is used. Default value of 0x1 is used for IOVDD lower than 3 V, because the typical value of IOVDD is 1.8 V.*/ + uint8_t IOVDD; + /**Slew control for SPI pins. + * 00: slowest. << + * 01: slow. + * 10: fastest. + * 11: fast.*/ + uint8_t SPI_slew; + /**Drive control for SPI pins. + * 00: medium. << + * 01: weak. + * 10: strong. + * 11: strong.*/ + uint8_t SPI_drv; + /*External clock select. + 000: use internal clocks. + 001: use GPIO for low frequency oscillator (960 kHz). Timer clock also uses this as the source. + 010: use GPIO for high frequency oscillator (32 MHz). + 011: use GPIO for high frequency oscillator (32 MHz), and generate low frequency oscillator (1 MHz) from high frequency oscillator. This feature must be disabled when the ECG is enabled. + 100: use GPIO for timer clock, 32 kHz or 960 kHz. + = 0*/ + uint8_t alt_clock; + /*Alternate clock GPIO select. + 00: use GPIO0 for alternate clock. + 01: use GPIO1 for alternate clock. + 10: use GPIO2 for alternate clock. + 11: reserved. + = 0 + */ + uint8_t alt_clock_gpio; + /*Select low frequency clock between 960 kHz and 32 kHz. This bit must be used when ALT_CLOCKS is 3'b100. + 0: use the 32 kHz external source from GPIO as the timer clock. + 1: use the 960 kHz external source from GPIO as the low frequency clock. + = 0*/ + uint8_t ext_clock_freq; + /*Enable low frequency oscillator. This bit turns on the 960 kHz low frequency oscillator, which must be left running during all operations using this oscillator. + = 0*/ + uint8_t internal_clock_en; + + +}; + + + +struct GPIO0_config{ + + /**GPIO0 pin configuration. + * 000: disabled (tristate, input buffer off). << + * 001: enabled input. + * 010: output–normal. + * 011: output–inverted. + * 100: pull-down only–normal. + * 101: pull-down only–inverted. + * 110: pull-up only–normal. + * 111: pull-up only–inverted. + */ + uint8_t GPIO0_cfg; + + /*GPIO0 output signal select.*/ + uint8_t GPIO0_output; + + /* External sync enable. When enabled, use the GPIO selected + by EXT_SYNC_GPIO to trigger samples rather than the period + counter. = 0(1) + */ + uint8_t EXT_SYNC_EN; + + /* External sync GPIO select. = 0 (0, 01, 10)*/ + uint8_t SYNC_GPIO; + +}; + + diff --git a/src/src/as7341/Adafruit_AS7341.cpp b/src/src/as7341/Adafruit_AS7341.cpp new file mode 100644 index 0000000..02010d6 --- /dev/null +++ b/src/src/as7341/Adafruit_AS7341.cpp @@ -0,0 +1,1014 @@ +/*! + * @file Adafruit_AS7341.cpp + * + * I2C Driver for the Library for the AS7341 11-Channel Spectral Sensor + * + * This is a library for the Adafruit AS7341 breakout: + * https://www.adafruit.com/product/4698 + * + * Adafruit invests time and resources providing this open source code, + * please support Adafruit and open-source hardware by purchasing products from + * Adafruit! + * + * Copyright 2020 Bryan Siepert for Adafruit Industries + * + * BSD (see license.txt) + */ + +#include "Arduino.h" +#include + +#include "Adafruit_AS7341.h" + +/** + * @brief Construct a new Adafruit_AS7341::Adafruit_AS7341 object + * + */ +Adafruit_AS7341::Adafruit_AS7341(void) {} + +/** + * @brief Destroy the Adafruit_AS7341::Adafruit_AS7341 object + * + */ +Adafruit_AS7341::~Adafruit_AS7341(void) { + // if (temp_sensor) + // delete temp_sensor; + // if (pressure_sensor) + // delete pressure_sensor; +} + +/*! + * @brief Sets up the hardware and initializes I2C + * @param i2c_address + * The I2C address to be used. + * @param wire + * The Wire object to be used for I2C connections. + * @param sensor_id + * The unique ID to differentiate the sensors from others + * @return True if initialization was successful, otherwise false. + */ +bool Adafruit_AS7341::begin(uint8_t i2c_address, TwoWire *wire, + int32_t sensor_id) { + if (i2c_dev) { + delete i2c_dev; // remove old interface + } + + i2c_dev = new Adafruit_I2CDevice(i2c_address, wire); + + if (!i2c_dev->begin()) { + return false; + } + + return _init(sensor_id); +} + +/*! @brief Initializer for post i2c/spi init + * @param sensor_id Optional unique ID for the sensor set + * @returns True if chip identified and initialized + */ +bool Adafruit_AS7341::_init(int32_t sensor_id) { + + Adafruit_BusIO_Register chip_id = + Adafruit_BusIO_Register(i2c_dev, AS7341_WHOAMI); + + // make sure we're talking to the right chip + if ((chip_id.read() & 0xFC) != (AS7341_CHIP_ID << 2)) { + return false; + } + + powerEnable(true); + return true; +} + +/********************* EXAMPLE EXTRACTS **************/ +// maybe return a typedef enum +/** + * @brief Returns the flicker detection status + * + * @return int8_t + */ +int8_t Adafruit_AS7341::getFlickerDetectStatus(void) { + Adafruit_BusIO_Register flicker_val = + Adafruit_BusIO_Register(i2c_dev, AS7341_FD_STATUS); + return (int8_t)flicker_val.read(); +} + +/** + * @brief Returns the ADC data for a given channel + * + * @param channel The ADC channel to read + * @return uint16_t The measured data for the currently configured sensor + */ +uint16_t Adafruit_AS7341::readChannel(as7341_adc_channel_t channel) { + // each channel has two bytes, so offset by two for each next channel + Adafruit_BusIO_Register channel_data_reg = Adafruit_BusIO_Register( + i2c_dev, (AS7341_CH0_DATA_L + 2 * channel), 2, LSBFIRST); + + return channel_data_reg.read(); +} + +/** + * @brief Returns the reading data for the specified color channel + * + * call `readAllChannels` before reading to update the stored readings + * + * @param channel The color sensor channel to read + * @return uint16_t The measured data for the selected sensor channel + */ +uint16_t Adafruit_AS7341::getChannel(as7341_color_channel_t channel) { + return _channel_readings[channel]; +} + +/** + * @brief fills the provided buffer with the current measurements for Spectral + * channels F1-8, Clear and NIR + * + * @param readings_buffer Pointer to a buffer of length 10 or more to fill with + * sensor data + * @return true: success false: failure + */ +bool Adafruit_AS7341::readAllChannels(uint16_t *readings_buffer) { + + setSMUXLowChannels(true); // Configure SMUX to read low channels + enableSpectralMeasurement(true); // Start integration + delayForData(0); // I'll wait for you for all time + + Adafruit_BusIO_Register channel_data_reg = + Adafruit_BusIO_Register(i2c_dev, AS7341_CH0_DATA_L, 2); + + bool low_success = channel_data_reg.read((uint8_t *)readings_buffer, 12); + + setSMUXLowChannels(false); // Configure SMUX to read high channels + enableSpectralMeasurement(true); // Start integration + delayForData(0); // I'll wait for you for all time + + return low_success && + channel_data_reg.read((uint8_t *)&readings_buffer[6], 12); +} + +/** + * @brief starts the process of getting readings from all channels without using + * delays + * + * @return true: success false: failure (a bit arbitrary) + */ +bool Adafruit_AS7341::startReading(void) { + _readingState = AS7341_WAITING_START; // Start the measurement please + checkReadingProgress(); // Call the check function to start it + return true; +} + +/** + * @brief runs the process of getting readings from all channels without using + * delays. Should be called regularly (ie. in loop()) Need to call + * startReading() to initialise the process Need to call getAllChannels() to + * transfer the data into an external buffer + * + * @return true: reading is complete false: reading is incomplete (or failed) + */ +bool Adafruit_AS7341::checkReadingProgress() { + if (_readingState == AS7341_WAITING_START) { + setSMUXLowChannels(true); // Configure SMUX to read low channels + enableSpectralMeasurement(true); // Start integration + _readingState = AS7341_WAITING_LOW; + return false; + } + + if (!getIsDataReady() || _readingState == AS7341_WAITING_DONE) + return false; + + if (_readingState == + AS7341_WAITING_LOW) // Check of getIsDataRead() is already done + { + Adafruit_BusIO_Register channel_data_reg = + Adafruit_BusIO_Register(i2c_dev, AS7341_CH0_DATA_L, 2); + + // bool low_success = channel_data_reg.read((uint8_t *)_channel_readings, + // 12); + channel_data_reg.read((uint8_t *)_channel_readings, 12); + + setSMUXLowChannels(false); // Configure SMUX to read high channels + enableSpectralMeasurement(true); // Start integration + _readingState = AS7341_WAITING_HIGH; + return false; + } + + if (_readingState == + AS7341_WAITING_HIGH) // Check of getIsDataRead() is already done + { + _readingState = AS7341_WAITING_DONE; + Adafruit_BusIO_Register channel_data_reg = + Adafruit_BusIO_Register(i2c_dev, AS7341_CH0_DATA_L, 2); + // return low_success && //low_success is lost since it + // was last call + channel_data_reg.read((uint8_t *)&_channel_readings[6], 12); + return true; + } + + return false; +} + +/** + * @brief transfer all the values from the private result buffer into one + * nominated + * + * @param readings_buffer Pointer to a buffer of length 12 (THERE IS NO ERROR + * CHECKING, YE BE WARNED!) + * + * @return true: success false: failure + */ +bool Adafruit_AS7341::getAllChannels(uint16_t *readings_buffer) { + for (int i = 0; i < 12; i++) + readings_buffer[i] = _channel_readings[i]; + return true; +} + +/** + * @brief Delay while waiting for data, with option to time out and recover + * + * @param waitTime the maximum amount of time to wait + * @return none + */ +void Adafruit_AS7341::delayForData(int waitTime) { + if (waitTime == 0) // Wait forever + { + while (!getIsDataReady()) { + delay(1); + } + return; + } + if (waitTime > 0) // Wait for that many milliseconds + { + uint32_t elapsedMillis = 0; + while (!getIsDataReady() && elapsedMillis < waitTime) { + delay(1); + elapsedMillis++; + } + return; + } + if (waitTime < 0) { + // For future use? + return; + } +} + +/** + * @brief Take readings for F1-8, Clear and NIR and store them in a buffer + * + * @return true: success false: failure + */ +bool Adafruit_AS7341::readAllChannels(void) { + return readAllChannels(_channel_readings); +} + +void Adafruit_AS7341::setSMUXLowChannels(bool f1_f4) { + enableSpectralMeasurement(false); + setSMUXCommand(AS7341_SMUX_CMD_WRITE); + if (f1_f4) { + setup_F1F4_Clear_NIR(); + } else { + setup_F5F8_Clear_NIR(); + } + enableSMUX(); +} + +/** + * @brief Sets the power state of the sensor + * + * @param enable_power true: on false: off + */ +void Adafruit_AS7341::powerEnable(bool enable_power) { + Adafruit_BusIO_Register enable_reg = + Adafruit_BusIO_Register(i2c_dev, AS7341_ENABLE); + Adafruit_BusIO_RegisterBits pon_en = + Adafruit_BusIO_RegisterBits(&enable_reg, 1, 0); + pon_en.write(enable_power); +} + +/** + * @brief Disable Spectral reading, flicker detection, and power + * + * */ +void Adafruit_AS7341::disableAll(void) { + Adafruit_BusIO_Register enable_reg = + Adafruit_BusIO_Register(i2c_dev, AS7341_ENABLE); + + enable_reg.write(0); +} + +/** + * @brief Enables measurement of spectral data + * + * @param enable_measurement true: enabled false: disabled + * @return true: success false: failure + */ +bool Adafruit_AS7341::enableSpectralMeasurement(bool enable_measurement) { + + Adafruit_BusIO_Register enable_reg = + Adafruit_BusIO_Register(i2c_dev, AS7341_ENABLE); + + Adafruit_BusIO_RegisterBits spec_enable_bit = + Adafruit_BusIO_RegisterBits(&enable_reg, 1, 1); + return spec_enable_bit.write(enable_measurement); +} + +bool Adafruit_AS7341::enableSMUX(void) { + + Adafruit_BusIO_Register enable_reg = + Adafruit_BusIO_Register(i2c_dev, AS7341_ENABLE); + Adafruit_BusIO_RegisterBits smux_enable_bit = + Adafruit_BusIO_RegisterBits(&enable_reg, 1, 4); + bool success = smux_enable_bit.write(true); + + int timeOut = 1000; // Arbitrary value, but if it takes 1000 milliseconds then + // something is wrong + int count = 0; + while (smux_enable_bit.read() && count < timeOut) { + delay(1); + count++; + } + if (count >= timeOut) + return false; + else + return success; +} + +bool Adafruit_AS7341::enableFlickerDetection(bool enable_fd) { + + Adafruit_BusIO_Register enable_reg = + Adafruit_BusIO_Register(i2c_dev, AS7341_ENABLE); + Adafruit_BusIO_RegisterBits fd_enable_bit = + Adafruit_BusIO_RegisterBits(&enable_reg, 1, 6); + return fd_enable_bit.write(enable_fd); +} + +/** + * @brief Get the GPIO pin direction setting + * + * @return `AS7341_OUTPUT` or `AS7341_INPUT` + */ +as7341_gpio_dir_t Adafruit_AS7341::getGPIODirection(void) { + Adafruit_BusIO_Register gpio2_reg = + Adafruit_BusIO_Register(i2c_dev, AS7341_GPIO2); + Adafruit_BusIO_RegisterBits gpio_input_enable = + Adafruit_BusIO_RegisterBits(&gpio2_reg, 1, 2); + + return (as7341_gpio_dir_t)gpio_input_enable.read(); +} + +/** + * @brief Set the GPIO pin to be used as an input or output + * + * @param gpio_direction The IO direction to set + * @return true: success false: failure + */ +bool Adafruit_AS7341::setGPIODirection(as7341_gpio_dir_t gpio_direction) { + Adafruit_BusIO_Register gpio2_reg = + Adafruit_BusIO_Register(i2c_dev, AS7341_GPIO2); + Adafruit_BusIO_RegisterBits gpio_input_enable = + Adafruit_BusIO_RegisterBits(&gpio2_reg, 1, 2); + + return gpio_input_enable.write(gpio_direction); +} + +/** + * @brief Get the output inversion setting for the GPIO pin + * + * @return true: GPIO output inverted false: GPIO output normal + */ +bool Adafruit_AS7341::getGPIOInverted(void) { + Adafruit_BusIO_Register gpio2_reg = + Adafruit_BusIO_Register(i2c_dev, AS7341_GPIO2); + Adafruit_BusIO_RegisterBits gpio_output_inverted_bit = + Adafruit_BusIO_RegisterBits(&gpio2_reg, 1, 3); + + return gpio_output_inverted_bit.read(); +} + +/** + * @brief Invert the logic of then GPIO pin when used as an output + * + * @param gpio_inverted **When true** setting the gpio value to **true will + * connect** the GPIO pin to ground. When set to **false**, setting the GPIO pin + * value to **true will disconnect** the GPIO pin from ground + * @return true: success false: failure + */ +bool Adafruit_AS7341::setGPIOInverted(bool gpio_inverted) { + Adafruit_BusIO_Register gpio2_reg = + Adafruit_BusIO_Register(i2c_dev, AS7341_GPIO2); + Adafruit_BusIO_RegisterBits gpio_output_inverted_bit = + Adafruit_BusIO_RegisterBits(&gpio2_reg, 1, 3); + + return gpio_output_inverted_bit.write(gpio_inverted); +} + +/** + * @brief Read the digital level of the GPIO pin, high or low + * + * @return true: GPIO pin level is high false: GPIO pin level is low + */ +bool Adafruit_AS7341::getGPIOValue(void) { + Adafruit_BusIO_Register gpio2_reg = + Adafruit_BusIO_Register(i2c_dev, AS7341_GPIO2); + Adafruit_BusIO_RegisterBits gpio_input_value_bit = + Adafruit_BusIO_RegisterBits(&gpio2_reg, 1, 0); + + return gpio_input_value_bit.read(); +} + +/** + * @brief Set the digital level of the GPIO pin, high or low + * + * @param gpio_high The GPIO level to set. Set to true to disconnect the pin + * from ground. Set to false to connect the gpio pin to ground. This can be used + * to connect the cathode of an LED to ground to turn it on. + * @return true: success false: failure + */ +bool Adafruit_AS7341::setGPIOValue(bool gpio_high) { + Adafruit_BusIO_Register gpio2_reg = + Adafruit_BusIO_Register(i2c_dev, AS7341_GPIO2); + Adafruit_BusIO_RegisterBits gpio_output_value_bit = + Adafruit_BusIO_RegisterBits(&gpio2_reg, 1, 1); + + return gpio_output_value_bit.write(gpio_high); +} + +bool Adafruit_AS7341::setSMUXCommand(as7341_smux_cmd_t command) { + Adafruit_BusIO_Register cfg6_reg = + Adafruit_BusIO_Register(i2c_dev, AS7341_CFG6); + Adafruit_BusIO_RegisterBits smux_command_bits = + Adafruit_BusIO_RegisterBits(&cfg6_reg, 2, 3); + + return smux_command_bits.write(command); +} + +/** + * @brief Enable control of an attached LED on the LDR pin + * + * @param enable_led true: LED enabled false: LED disabled + * @return true: success false: failure + */ +bool Adafruit_AS7341::enableLED(bool enable_led) { + Adafruit_BusIO_Register config_reg = + Adafruit_BusIO_Register(i2c_dev, AS7341_CONFIG); + // Enables control of the LED via the LDR pin + // 1=control enabled 0 = control disabled + Adafruit_BusIO_RegisterBits led_sel_bit = + Adafruit_BusIO_RegisterBits(&config_reg, 1, 3); + + Adafruit_BusIO_Register led_reg = + Adafruit_BusIO_Register(i2c_dev, AS7341_LED); + // turns the LED on or off + Adafruit_BusIO_RegisterBits led_act_bit = + Adafruit_BusIO_RegisterBits(&led_reg, 1, 7); + + setBank(true); // Access 0x60-0x74 + bool result = led_sel_bit.write(enable_led) && led_act_bit.write(enable_led); + setBank(false); // Access registers 0x80 and above (default) + return result; +} + +/** + * @brief Set the current limit for the LED + * + * @param led_current_ma the value to set in milliamps. With a minimum of 4. Any + * amount under 4 will be rounded up to 4 + * + * Range is 4mA to 258mA + * @return true: success false: failure + */ +bool Adafruit_AS7341::setLEDCurrent(uint16_t led_current_ma) { + // check within permissible range + if (led_current_ma > 258) { + return false; + } + if (led_current_ma < 4) { + led_current_ma = 4; + } + setBank(true); // Access 0x60 0x74 + + Adafruit_BusIO_Register led_reg = + Adafruit_BusIO_Register(i2c_dev, AS7341_LED); + + // true = led on , false = off + Adafruit_BusIO_RegisterBits led_current_bits = + Adafruit_BusIO_RegisterBits(&led_reg, 7, 0); + + bool result = led_current_bits.write((uint8_t)((led_current_ma - 4) / 2)); + setBank(false); // Access registers 0x80 and above (default) + return result; +} + +/** + * @brief Sets the active register bank + * + * The AS7341 uses banks to organize the register making it nescessary to set + * the correct bank to access a register. + * + + * @param low **true**: + * **false**: Set the current bank to allow access to registers with addresses + of `0x80` and above + * @return true: success false: failure + */ +bool Adafruit_AS7341::setBank(bool low) { + Adafruit_BusIO_Register cfg0_reg = + Adafruit_BusIO_Register(i2c_dev, AS7341_CFG0); + // register map says shift 3, 0xA9 description says shift 4 with 3 being + // reserved + Adafruit_BusIO_RegisterBits bank_bit = + Adafruit_BusIO_RegisterBits(&cfg0_reg, 1, 4); + + return bank_bit.write(low); +} + +/** + * @brief Sets the threshold below which spectral measurements will trigger + * interrupts when the APERS count is reached + * + * @param low_threshold the new threshold + * @return true: success false: failure + */ +bool Adafruit_AS7341::setLowThreshold(uint16_t low_threshold) { + Adafruit_BusIO_Register sp_low_threshold_reg = + Adafruit_BusIO_Register(i2c_dev, AS7341_SP_LOW_TH_L, 2, LSBFIRST); + return sp_low_threshold_reg.write(low_threshold); +} + +/** + * @brief Returns the current low thighreshold for spectral measurements + * + * @return int16_t The current low threshold + */ +uint16_t Adafruit_AS7341::getLowThreshold(void) { + Adafruit_BusIO_Register sp_low_threshold_reg = + Adafruit_BusIO_Register(i2c_dev, AS7341_SP_LOW_TH_L, 2, LSBFIRST); + return sp_low_threshold_reg.read(); +} + +/** + * @brief Sets the threshold above which spectral measurements will trigger + * interrupts when the APERS count is reached + * + * @param high_threshold + * @return true: success false: failure + */ +bool Adafruit_AS7341::setHighThreshold(uint16_t high_threshold) { + Adafruit_BusIO_Register sp_high_threshold_reg = + Adafruit_BusIO_Register(i2c_dev, AS7341_SP_HIGH_TH_L, 2, LSBFIRST); + return sp_high_threshold_reg.write(high_threshold); +} + +/** + * @brief Returns the current high thighreshold for spectral measurements + * + * @return int16_t The current high threshold + */ +uint16_t Adafruit_AS7341::getHighThreshold(void) { + Adafruit_BusIO_Register sp_high_threshold_reg = + Adafruit_BusIO_Register(i2c_dev, AS7341_SP_HIGH_TH_L, 2, LSBFIRST); + return sp_high_threshold_reg.read(); +} + +/** + * @brief Enable Interrupts based on spectral measurements + * + * @param enable_int true: enable false: disable + * @return true: success false: falure + */ +bool Adafruit_AS7341::enableSpectralInterrupt(bool enable_int) { + Adafruit_BusIO_Register int_enable_reg = + Adafruit_BusIO_Register(i2c_dev, AS7341_INTENAB); + Adafruit_BusIO_RegisterBits sp_int_bit = + Adafruit_BusIO_RegisterBits(&int_enable_reg, 1, 3); + return sp_int_bit.write(enable_int); +} + +/** + * @brief Enabled system interrupts + * + * @param enable_int Set to true to enable system interrupts + * @return true: success false: failure + */ +bool Adafruit_AS7341::enableSystemInterrupt(bool enable_int) { + Adafruit_BusIO_Register int_enable_reg = + Adafruit_BusIO_Register(i2c_dev, AS7341_INTENAB); + Adafruit_BusIO_RegisterBits sien_int_bit = + Adafruit_BusIO_RegisterBits(&int_enable_reg, 1, 0); + return sien_int_bit.write(enable_int); +} + +// Spectral Interrupt Persistence. +// Defines a filter for the number of consecutive +// occurrences that spectral data must remain outside +// the threshold range between SP_TH_L and +// SP_TH_H before an interrupt is generated. The +// spectral data channel used for the persistence filter +// is set by SP_TH_CHANNEL. Any sample that is +// inside the threshold range resets the counter to 0. + +/** + * @brief Sets the number of times an interrupt threshold must be exceeded + * before an interrupt is triggered + * + * @param cycle_count The number of cycles to trigger an interrupt + * @return true: success false: failure + */ +bool Adafruit_AS7341::setAPERS(as7341_int_cycle_count_t cycle_count) { + Adafruit_BusIO_Register pers_reg = + Adafruit_BusIO_Register(i2c_dev, AS7341_PERS); + Adafruit_BusIO_RegisterBits apers_bits = + Adafruit_BusIO_RegisterBits(&pers_reg, 4, 0); + return apers_bits.write(cycle_count); +} + +/** + * @brief Set the ADC channel to use for spectral thresholds including + * interrupts, automatic gain control, and persistance settings + * + * @param channel The channel to use for spectral thresholds. Must be a + * as7341_adc_channel_t **except for** `AS7341_ADC_CHANNEL_5` + * @return true: success false: failure + */ +bool Adafruit_AS7341::setSpectralThresholdChannel( + as7341_adc_channel_t channel) { + if (channel == AS7341_ADC_CHANNEL_5) { + return false; + } + Adafruit_BusIO_Register cfg_12_reg = + Adafruit_BusIO_Register(i2c_dev, AS7341_CFG12); + Adafruit_BusIO_RegisterBits spectral_threshold_ch_bits = + Adafruit_BusIO_RegisterBits(&cfg_12_reg, 3, 0); + return spectral_threshold_ch_bits.write(channel); +} + +/** + * @brief Returns the current value of the Interupt status register + * + * @return uint8_t + */ +uint8_t Adafruit_AS7341::getInterruptStatus(void) { + Adafruit_BusIO_Register int_status_reg = + Adafruit_BusIO_Register(i2c_dev, AS7341_STATUS); + return (uint8_t)int_status_reg.read(); +} + +/** + * @brief Returns the status of the spectral measurement threshold interrupts + * + * @return true: interrupt triggered false: interrupt not triggered + */ +bool Adafruit_AS7341::spectralInterruptTriggered(void) { + Adafruit_BusIO_Register int_status_reg = + Adafruit_BusIO_Register(i2c_dev, AS7341_STATUS); + Adafruit_BusIO_RegisterBits aint_bit = + Adafruit_BusIO_RegisterBits(&int_status_reg, 1, 3); + + return aint_bit.read(); +} + +/** + * @brief Clear the interrupt status register + * + * @return true: success false: failure + */ +bool Adafruit_AS7341::clearInterruptStatus(void) { + Adafruit_BusIO_Register int_status_reg = + Adafruit_BusIO_Register(i2c_dev, AS7341_STATUS); + + return int_status_reg.write(0xFF); +} + +/** + * @brief The current state of the spectral measurement interrupt status + * register + * + * @return uint8_t The current status register + */ +uint8_t Adafruit_AS7341::spectralInterruptSource(void) { + Adafruit_BusIO_Register status3_reg = + Adafruit_BusIO_Register(i2c_dev, AS7341_STATUS3); + + uint8_t spectral_int_source = status3_reg.read(); + last_spectral_int_source = spectral_int_source; + return spectral_int_source; +} + +/** + * @brief The status of the low threshold interrupt + * + * @return true: low interrupt triggered false: interrupt not triggered + */ +bool Adafruit_AS7341::spectralLowTriggered(void) { + return (last_spectral_int_source & AS7341_SPECTRAL_INT_LOW_MSK) > 0; +} + +/** + * @brief The status of the high threshold interrupt + * + * @return true: high interrupt triggered false: interrupt not triggered + */ +bool Adafruit_AS7341::spectralHighTriggered(void) { + return (last_spectral_int_source & AS7341_SPECTRAL_INT_HIGH_MSK) > 0; +} + +/** + * @brief + * + * @return true: success false: failure + */ +bool Adafruit_AS7341::getIsDataReady() { + Adafruit_BusIO_Register status2_reg = + Adafruit_BusIO_Register(i2c_dev, AS7341_STATUS2); + Adafruit_BusIO_RegisterBits avalid_bit = + Adafruit_BusIO_RegisterBits(&status2_reg, 1, 6); + + return avalid_bit.read(); +} + +/** + * @brief Configure SMUX for sensors F1-4, Clear and NIR + * + */ +void Adafruit_AS7341::setup_F1F4_Clear_NIR() { + // SMUX Config for F1,F2,F3,F4,NIR,Clear + writeRegister(byte(0x00), byte(0x30)); // F3 left set to ADC2 + writeRegister(byte(0x01), byte(0x01)); // F1 left set to ADC0 + writeRegister(byte(0x02), byte(0x00)); // Reserved or disabled + writeRegister(byte(0x03), byte(0x00)); // F8 left disabled + writeRegister(byte(0x04), byte(0x00)); // F6 left disabled + writeRegister( + byte(0x05), + byte(0x42)); // F4 left connected to ADC3/f2 left connected to ADC1 + writeRegister(byte(0x06), byte(0x00)); // F5 left disbled + writeRegister(byte(0x07), byte(0x00)); // F7 left disbled + writeRegister(byte(0x08), byte(0x50)); // CLEAR connected to ADC4 + writeRegister(byte(0x09), byte(0x00)); // F5 right disabled + writeRegister(byte(0x0A), byte(0x00)); // F7 right disabled + writeRegister(byte(0x0B), byte(0x00)); // Reserved or disabled + writeRegister(byte(0x0C), byte(0x20)); // F2 right connected to ADC1 + writeRegister(byte(0x0D), byte(0x04)); // F4 right connected to ADC3 + writeRegister(byte(0x0E), byte(0x00)); // F6/F8 right disabled + writeRegister(byte(0x0F), byte(0x30)); // F3 right connected to AD2 + writeRegister(byte(0x10), byte(0x01)); // F1 right connected to AD0 + writeRegister(byte(0x11), byte(0x50)); // CLEAR right connected to AD4 + writeRegister(byte(0x12), byte(0x00)); // Reserved or disabled + writeRegister(byte(0x13), byte(0x06)); // NIR connected to ADC5 +} + +/** + * @brief Configure SMUX for sensors F5-8, Clear and NIR + * + */ +void Adafruit_AS7341::setup_F5F8_Clear_NIR() { + // SMUX Config for F5,F6,F7,F8,NIR,Clear + writeRegister(byte(0x00), byte(0x00)); // F3 left disable + writeRegister(byte(0x01), byte(0x00)); // F1 left disable + writeRegister(byte(0x02), byte(0x00)); // reserved/disable + writeRegister(byte(0x03), byte(0x40)); // F8 left connected to ADC3 + writeRegister(byte(0x04), byte(0x02)); // F6 left connected to ADC1 + writeRegister(byte(0x05), byte(0x00)); // F4/ F2 disabled + writeRegister(byte(0x06), byte(0x10)); // F5 left connected to ADC0 + writeRegister(byte(0x07), byte(0x03)); // F7 left connected to ADC2 + writeRegister(byte(0x08), byte(0x50)); // CLEAR Connected to ADC4 + writeRegister(byte(0x09), byte(0x10)); // F5 right connected to ADC0 + writeRegister(byte(0x0A), byte(0x03)); // F7 right connected to ADC2 + writeRegister(byte(0x0B), byte(0x00)); // Reserved or disabled + writeRegister(byte(0x0C), byte(0x00)); // F2 right disabled + writeRegister(byte(0x0D), byte(0x00)); // F4 right disabled + writeRegister( + byte(0x0E), + byte(0x24)); // F8 right connected to ADC2/ F6 right connected to ADC1 + writeRegister(byte(0x0F), byte(0x00)); // F3 right disabled + writeRegister(byte(0x10), byte(0x00)); // F1 right disabled + writeRegister(byte(0x11), byte(0x50)); // CLEAR right connected to AD4 + writeRegister(byte(0x12), byte(0x00)); // Reserved or disabled + writeRegister(byte(0x13), byte(0x06)); // NIR connected to ADC5 +} + +/** + * @brief Configure SMUX for flicker detection + * + */ +void Adafruit_AS7341::FDConfig() { + // SMUX Config for Flicker- register (0x13)left set to ADC6 for flicker + // detection + writeRegister(byte(0x00), byte(0x00)); // disabled + writeRegister(byte(0x01), byte(0x00)); // disabled + writeRegister(byte(0x02), byte(0x00)); // reserved/disabled + writeRegister(byte(0x03), byte(0x00)); // disabled + writeRegister(byte(0x04), byte(0x00)); // disabled + writeRegister(byte(0x05), byte(0x00)); // disabled + writeRegister(byte(0x06), byte(0x00)); // disabled + writeRegister(byte(0x07), byte(0x00)); // disabled + writeRegister(byte(0x08), byte(0x00)); // disabled + writeRegister(byte(0x09), byte(0x00)); // disabled + writeRegister(byte(0x0A), byte(0x00)); // disabled + writeRegister(byte(0x0B), byte(0x00)); // Reserved or disabled + writeRegister(byte(0x0C), byte(0x00)); // disabled + writeRegister(byte(0x0D), byte(0x00)); // disabled + writeRegister(byte(0x0E), byte(0x00)); // disabled + writeRegister(byte(0x0F), byte(0x00)); // disabled + writeRegister(byte(0x10), byte(0x00)); // disabled + writeRegister(byte(0x11), byte(0x00)); // disabled + writeRegister(byte(0x12), byte(0x00)); // Reserved or disabled + writeRegister(byte(0x13), + byte(0x60)); // Flicker connected to ADC5 to left of 0x13 +} + +// TODO; check for valid values +/** + * @brief Sets the integration time step count + * + * Total integration time will be `(ATIME + 1) * (ASTEP + 1) * 2.78µS` + * + * @param atime_value The integration time step count + * @return true: success false: failure + */ +bool Adafruit_AS7341::setATIME(uint8_t atime_value) { + Adafruit_BusIO_Register atime_reg = + Adafruit_BusIO_Register(i2c_dev, AS7341_ATIME); + return atime_reg.write(atime_value); +} + +/** + * @brief Returns the integration time step count + * + * Total integration time will be `(ATIME + 1) * (ASTEP + 1) * 2.78µS` + * + * @return uint8_t The current integration time step count + */ +uint8_t Adafruit_AS7341::getATIME() { + Adafruit_BusIO_Register atime_reg = + Adafruit_BusIO_Register(i2c_dev, AS7341_ATIME); + return atime_reg.read(); +} + +/** + * @brief Sets the integration time step size + * + * @param astep_value Integration time step size in 2.78 microsecon increments + * Step size is `(astep_value+1) * 2.78 uS` + * @return true: success false: failure + */ +bool Adafruit_AS7341::setASTEP(uint16_t astep_value) { + Adafruit_BusIO_Register astep_reg = + Adafruit_BusIO_Register(i2c_dev, AS7341_ASTEP_L, 2, LSBFIRST); + return astep_reg.write(astep_value); +} + +/** + * @brief Returns the integration time step size + * + * Step size is `(astep_value+1) * 2.78 uS` + * + * @return uint16_t The current integration time step size + */ +uint16_t Adafruit_AS7341::getASTEP() { + Adafruit_BusIO_Register astep_reg = + Adafruit_BusIO_Register(i2c_dev, AS7341_ASTEP_L, 2, LSBFIRST); + return astep_reg.read(); +} + +/** + * @brief Sets the ADC gain multiplier + * + * @param gain_value The gain amount. must be an `as7341_gain_t` + * @return true: success false: failure + */ +bool Adafruit_AS7341::setGain(as7341_gain_t gain_value) { + Adafruit_BusIO_Register cfg1_reg = + Adafruit_BusIO_Register(i2c_dev, AS7341_CFG1); + return cfg1_reg.write(gain_value); + // AGAIN bitfield is only[0:4] but the rest is empty +} + +/** + * @brief Returns the ADC gain multiplier + * + * @return as7341_gain_t The current ADC gain multiplier + */ +as7341_gain_t Adafruit_AS7341::getGain() { + Adafruit_BusIO_Register cfg1_reg = + Adafruit_BusIO_Register(i2c_dev, AS7341_CFG1); + return (as7341_gain_t)cfg1_reg.read(); +} + +/** + * @brief Returns the integration time + * + * The integration time is `(ATIME + 1) * (ASTEP + 1) * 2.78µS` + * + * @return long The current integration time in ms + */ +long Adafruit_AS7341::getTINT() { + uint16_t astep = getASTEP(); + uint8_t atime = getATIME(); + + return (atime + 1) * (astep + 1) * 2.78 / 1000; +} + +/** + * @brief Converts raw ADC values to basic counts + * + * The basic counts are `RAW/(GAIN * TINT)` + * + * @param raw The raw ADC values to convert + * + * @return float The basic counts + */ +float Adafruit_AS7341::toBasicCounts(uint16_t raw) { + float gain_val = 0; + as7341_gain_t gain = getGain(); + switch (gain) { + case AS7341_GAIN_0_5X: + gain_val = 0.5; + break; + case AS7341_GAIN_1X: + gain_val = 1; + break; + case AS7341_GAIN_2X: + gain_val = 2; + break; + case AS7341_GAIN_4X: + gain_val = 4; + break; + case AS7341_GAIN_8X: + gain_val = 8; + break; + case AS7341_GAIN_16X: + gain_val = 16; + break; + case AS7341_GAIN_32X: + gain_val = 32; + break; + case AS7341_GAIN_64X: + gain_val = 64; + break; + case AS7341_GAIN_128X: + gain_val = 128; + break; + case AS7341_GAIN_256X: + gain_val = 256; + break; + case AS7341_GAIN_512X: + gain_val = 512; + break; + } + return raw / (gain_val * (getATIME() + 1) * (getASTEP() + 1) * 2.78 / 1000); +} + +/** + * @brief Detect a flickering light + * @return The frequency of a detected flicker or 1 if a flicker of + * unknown frequency is detected + */ +uint16_t Adafruit_AS7341::detectFlickerHz(void) { + // bool isEnabled = true; + // bool isFdmeasReady = false; + + // disable everything; Flicker detect, smux, wait, spectral, power + disableAll(); + // re-enable power + powerEnable(true); + + // Write SMUX configuration from RAM to set SMUX chain registers (Write 0x10 + // to CFG6) + setSMUXCommand(AS7341_SMUX_CMD_WRITE); + + // Write new configuration to all the 20 registers for detecting Flicker + FDConfig(); + + // Start SMUX command + enableSMUX(); + + // Enable SP_EN bit + enableSpectralMeasurement(true); + + // Enable flicker detection bit + writeRegister(byte(AS7341_ENABLE), byte(0x41)); + delay(500); // SF 2020-08-12 Does this really need to be so long? + uint16_t flicker_status = getFlickerDetectStatus(); + enableFlickerDetection(false); + switch (flicker_status) { + case 44: + return 1; + case 45: + return 100; + case 46: + return 120; + default: + return 0; + } +} + +/** + * @brief Write a byte to the given register + * + * @param addr Register address + * @param val The value to set the register to + */ +void Adafruit_AS7341::writeRegister(byte addr, byte val) { + Adafruit_BusIO_Register reg = Adafruit_BusIO_Register(i2c_dev, addr); + reg.write(val); +} diff --git a/src/src/as7341/Adafruit_AS7341.h b/src/src/as7341/Adafruit_AS7341.h new file mode 100644 index 0000000..62e9740 --- /dev/null +++ b/src/src/as7341/Adafruit_AS7341.h @@ -0,0 +1,354 @@ +/*! + * @file Adafruit_AS7341.h + + * @mainpage Adafruit AS7341 11-Channel Spectral Sensor + * + * @section intro_sec Introduction + * + * I2C Driver for the Library for the AS7341 11-Channel Spectral Sensor + * + * This is a library for the Adafruit AS7341 breakout: + * https://www.adafruit.com/product/4698 + * + * Adafruit invests time and resources providing this open source code, + * please support Adafruit and open-source hardware by purchasing products from + * Adafruit! + * + * @section dependencies Dependencies + * This library depends on the Adafruit BusIO library + * + * @section author Author + * + * Bryan Siepert for Adafruit Industries + * + * @section license License + * + * BSD (see license.txt) + * + * @section HISTORY + * + * v1.0 - First release + */ + +/* + This library is adapted from an example with the following Copyright and + Warranty: + + This is a Hello world example code written for the AS7241 XWing Spectral + Sensor I2C interface with Arduino µC. The main idea is to get fimilar with the + register configuration. This code helps to learn basic settings and procedure + to read out raw values with different SMUX configuration. Also defined the + procedure to set the default flicker detection for 100 and 120 Hz. + + Written by Sijo John @ ams AG, Application Support in October, 2018 + + Development environment specifics: Arduino IDE 1.8.5 + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + +*/ + +#ifndef _ADAFRUIT_AS7341_H +#define _ADAFRUIT_AS7341_H + +#include "Arduino.h" +#include +#include +#include +#define AS7341_I2CADDR_DEFAULT 0x39 ///< AS7341 default i2c address +#define AS7341_CHIP_ID 0x09 ///< AS7341 default device id from WHOAMI + +#define AS7341_WHOAMI 0x92 ///< Chip ID register + +#define AS7341_ASTATUS 0x60 ///< AS7341_ASTATUS (unused) +#define AS7341_CH0_DATA_L_ 0x61 ///< AS7341_CH0_DATA_L (unused) +#define AS7341_CH0_DATA_H_ 0x62 ///< AS7341_CH0_DATA_H (unused) +#define AS7341_ITIME_L 0x63 ///< AS7341_ITIME_L (unused) +#define AS7341_ITIME_M 0x64 ///< AS7341_ITIME_M (unused) +#define AS7341_ITIME_H 0x65 ///< AS7341_ITIME_H (unused) +#define AS7341_CONFIG 0x70 ///< Enables LED control and sets light sensing mode +#define AS7341_STAT 0x71 ///< AS7341_STAT (unused) +#define AS7341_EDGE 0x72 ///< AS7341_EDGE (unused) +#define AS7341_GPIO 0x73 ///< Connects photo diode to GPIO or INT pins +#define AS7341_LED 0x74 ///< LED Register; Enables and sets current limit +#define AS7341_ENABLE \ + 0x80 ///< Main enable register. Controls SMUX, Flicker Detection, Spectral + ///< Measurements and Power +#define AS7341_ATIME 0x81 ///< Sets ADC integration step count +#define AS7341_WTIME 0x83 ///< AS7341_WTIME (unused) +#define AS7341_SP_LOW_TH_L 0x84 ///< Spectral measurement Low Threshold low byte +#define AS7341_SP_LOW_TH_H \ + 0x85 ///< Spectral measurement Low Threshold high byte +#define AS7341_SP_HIGH_TH_L \ + 0x86 ///< Spectral measurement High Threshold low byte +#define AS7341_SP_HIGH_TH_H \ + 0x87 ///< Spectral measurement High Threshold low byte +#define AS7341_AUXID 0x90 ///< AS7341_AUXID (unused) +#define AS7341_REVID 0x91 ///< AS7341_REVID (unused) +#define AS7341_ID 0x92 ///< AS7341_ID (unused) +#define AS7341_STATUS \ + 0x93 ///< Interrupt status registers. Indicates the occourance of an interrupt +#define AS7341_ASTATUS_ 0x94 ///< AS7341_ASTATUS, same as 0x60 (unused) +#define AS7341_CH0_DATA_L 0x95 ///< ADC Channel Data +#define AS7341_CH0_DATA_H 0x96 ///< ADC Channel Data +#define AS7341_CH1_DATA_L 0x97 ///< ADC Channel Data +#define AS7341_CH1_DATA_H 0x98 ///< ADC Channel Data +#define AS7341_CH2_DATA_L 0x99 ///< ADC Channel Data +#define AS7341_CH2_DATA_H 0x9A ///< ADC Channel Data +#define AS7341_CH3_DATA_L 0x9B ///< ADC Channel Data +#define AS7341_CH3_DATA_H 0x9C ///< ADC Channel Data +#define AS7341_CH4_DATA_L 0x9D ///< ADC Channel Data +#define AS7341_CH4_DATA_H 0x9E ///< ADC Channel Data +#define AS7341_CH5_DATA_L 0x9F ///< ADC Channel Data +#define AS7341_CH5_DATA_H 0xA0 ///< ADC Channel Data +#define AS7341_STATUS2 0xA3 ///< Measurement status flags; saturation, validity +#define AS7341_STATUS3 \ + 0xA4 ///< Spectral interrupt source, high or low threshold +#define AS7341_STATUS5 0xA6 ///< AS7341_STATUS5 (unused) +#define AS7341_STATUS6 0xA7 ///< AS7341_STATUS6 (unused) +#define AS7341_CFG0 \ + 0xA9 ///< Sets Low power mode, Register bank, and Trigger lengthening +#define AS7341_CFG1 0xAA ///< Controls ADC Gain +#define AS7341_CFG3 0xAC ///< AS7341_CFG3 (unused) +#define AS7341_CFG6 0xAF ///< Used to configure Smux +#define AS7341_CFG8 0xB1 ///< AS7341_CFG8 (unused) +#define AS7341_CFG9 \ + 0xB2 ///< Enables flicker detection and smux command completion system + ///< interrupts +#define AS7341_CFG10 0xB3 ///< AS7341_CFG10 (unused) +#define AS7341_CFG12 \ + 0xB5 ///< Spectral threshold channel for interrupts, persistence and auto-gain +#define AS7341_PERS \ + 0xBD ///< Number of measurement cycles outside thresholds to trigger an + ///< interupt +#define AS7341_GPIO2 \ + 0xBE ///< GPIO Settings and status: polarity, direction, sets output, reads + ///< input +#define AS7341_ASTEP_L 0xCA ///< Integration step size ow byte +#define AS7341_ASTEP_H 0xCB ///< Integration step size high byte +#define AS7341_AGC_GAIN_MAX 0xCF ///< AS7341_AGC_GAIN_MAX (unused) +#define AS7341_AZ_CONFIG 0xD6 ///< AS7341_AZ_CONFIG (unused) +#define AS7341_FD_TIME1 0xD8 ///< Flicker detection integration time low byte +#define AS7341_FD_TIME2 0xDA ///< Flicker detection gain and high nibble +#define AS7341_FD_CFG0 0xD7 ///< AS7341_FD_CFG0 (unused) +#define AS7341_FD_STATUS \ + 0xDB ///< Flicker detection status; measurement valid, saturation, flicker + ///< type +#define AS7341_INTENAB 0xF9 ///< Enables individual interrupt types +#define AS7341_CONTROL 0xFA ///< Auto-zero, fifo clear, clear SAI active +#define AS7341_FIFO_MAP 0xFC ///< AS7341_FIFO_MAP (unused) +#define AS7341_FIFO_LVL 0xFD ///< AS7341_FIFO_LVL (unused) +#define AS7341_FDATA_L 0xFE ///< AS7341_FDATA_L (unused) +#define AS7341_FDATA_H 0xFF ///< AS7341_FDATA_H (unused) + +#define AS7341_SPECTRAL_INT_HIGH_MSK \ + 0b00100000 ///< bitmask to check for a high threshold interrupt +#define AS7341_SPECTRAL_INT_LOW_MSK \ + 0b00010000 ///< bitmask to check for a low threshold interrupt + +/** + * @brief Allowable gain multipliers for `setGain` + * + */ +typedef enum { + AS7341_GAIN_0_5X, + AS7341_GAIN_1X, + AS7341_GAIN_2X, + AS7341_GAIN_4X, + AS7341_GAIN_8X, + AS7341_GAIN_16X, + AS7341_GAIN_32X, + AS7341_GAIN_64X, + AS7341_GAIN_128X, + AS7341_GAIN_256X, + AS7341_GAIN_512X, +} as7341_gain_t; + +/** + * @brief Available SMUX configuration commands + * + */ +typedef enum { + AS7341_SMUX_CMD_ROM_RESET, ///< ROM code initialization of SMUX + AS7341_SMUX_CMD_READ, ///< Read SMUX configuration to RAM from SMUX chain + AS7341_SMUX_CMD_WRITE, ///< Write SMUX configuration from RAM to SMUX chain +} as7341_smux_cmd_t; +/** + * @brief ADC Channel specifiers for configuration + * + */ +typedef enum { + AS7341_ADC_CHANNEL_0, + AS7341_ADC_CHANNEL_1, + AS7341_ADC_CHANNEL_2, + AS7341_ADC_CHANNEL_3, + AS7341_ADC_CHANNEL_4, + AS7341_ADC_CHANNEL_5, +} as7341_adc_channel_t; +/** + * @brief Spectral Channel specifiers for configuration and reading + * + */ +typedef enum { + AS7341_CHANNEL_415nm_F1, + AS7341_CHANNEL_445nm_F2, + AS7341_CHANNEL_480nm_F3, + AS7341_CHANNEL_515nm_F4, + AS7341_CHANNEL_CLEAR_0, + AS7341_CHANNEL_NIR_0, + AS7341_CHANNEL_555nm_F5, + AS7341_CHANNEL_590nm_F6, + AS7341_CHANNEL_630nm_F7, + AS7341_CHANNEL_680nm_F8, + AS7341_CHANNEL_CLEAR, + AS7341_CHANNEL_NIR, +} as7341_color_channel_t; + +/** + * @brief The number of measurement cycles with spectral data outside of a + * threshold required to trigger an interrupt + * + */ +typedef enum { + AS7341_INT_COUNT_ALL, ///< 0 + AS7341_INT_COUNT_1, ///< 1 + AS7341_INT_COUNT_2, ///< 2 + AS7341_INT_COUNT_3, ///< 3 + AS7341_INT_COUNT_5, ///< 4 + AS7341_INT_COUNT_10, ///< 5 + AS7341_INT_COUNT_15, ///< 6 + AS7341_INT_COUNT_20, ///< 7 + AS7341_INT_COUNT_25, ///< 8 + AS7341_INT_COUNT_30, ///< 9 + AS7341_INT_COUNT_35, ///< 10 + AS7341_INT_COUNT_40, ///< 11 + AS7341_INT_COUNT_45, ///< 12 + AS7341_INT_COUNT_50, ///< 13 + AS7341_INT_COUNT_55, ///< 14 + AS7341_INT_COUNT_60, ///< 15 +} as7341_int_cycle_count_t; + +/** + * @brief Pin directions to set how the GPIO pin is to be used + * + */ +typedef enum { + AS7341_GPIO_OUTPUT, ///< THhe GPIO pin is configured as an open drain output + AS7341_GPIO_INPUT, ///< The GPIO Pin is set as a high-impedence input +} as7341_gpio_dir_t; + +/** + * @brief Wait states for async reading + */ +typedef enum { + AS7341_WAITING_START, // + AS7341_WAITING_LOW, // + AS7341_WAITING_HIGH, // + AS7341_WAITING_DONE, // +} as7341_waiting_t; + +class Adafruit_AS7341; + +/*! + * @brief Class that stores state and functions for interacting with + * the AS7341 11-Channel Spectral Sensor + */ +class Adafruit_AS7341 { +public: + Adafruit_AS7341(); + ~Adafruit_AS7341(); + + bool begin(uint8_t i2c_addr = AS7341_I2CADDR_DEFAULT, TwoWire *wire = &Wire, + int32_t sensor_id = 0); + + bool setASTEP(uint16_t astep_value); + bool setATIME(uint8_t atime_value); + bool setGain(as7341_gain_t gain_value); + + uint16_t getASTEP(); + uint8_t getATIME(); + as7341_gain_t getGain(); + + long getTINT(); + float toBasicCounts(uint16_t raw); + + bool readAllChannels(void); + bool readAllChannels(uint16_t *readings_buffer); + void delayForData(int waitTime = 0); + uint16_t readChannel(as7341_adc_channel_t channel); + uint16_t getChannel(as7341_color_channel_t channel); + + bool startReading(void); + bool checkReadingProgress(); + bool getAllChannels(uint16_t *readings_buffer); + + uint16_t detectFlickerHz(void); + + void setup_F1F4_Clear_NIR(void); + void setup_F5F8_Clear_NIR(void); + + void powerEnable(bool enable_power); + bool enableSpectralMeasurement(bool enable_measurement); + + bool setHighThreshold(uint16_t high_threshold); + bool setLowThreshold(uint16_t low_threshold); + + uint16_t getHighThreshold(void); + uint16_t getLowThreshold(void); + + bool enableSpectralInterrupt(bool enable_int); + bool enableSystemInterrupt(bool enable_int); + + bool setAPERS(as7341_int_cycle_count_t cycle_count); + bool setSpectralThresholdChannel(as7341_adc_channel_t channel); + + uint8_t getInterruptStatus(void); + bool clearInterruptStatus(void); + + bool spectralInterruptTriggered(void); + uint8_t spectralInterruptSource(void); + bool spectralLowTriggered(void); + bool spectralHighTriggered(void); + + bool enableLED(bool enable_led); + bool setLEDCurrent(uint16_t led_current_ma); + + void disableAll(void); + + bool getIsDataReady(); + bool setBank(bool low); // low true gives access to 0x60 to 0x74 + + as7341_gpio_dir_t getGPIODirection(void); + bool setGPIODirection(as7341_gpio_dir_t gpio_direction); + bool getGPIOInverted(void); + bool setGPIOInverted(bool gpio_inverted); + bool getGPIOValue(void); + bool setGPIOValue(bool); + + bool enableSMUX(void); + bool enableFlickerDetection(bool enable_fd); + void FDConfig(void); + int8_t getFlickerDetectStatus(void); + bool setSMUXCommand(as7341_smux_cmd_t command); + void writeRegister(byte addr, byte val); + void setSMUXLowChannels(bool f1_f4); + + Adafruit_I2CDevice *i2c_dev = NULL; ///< Pointer to I2C bus interface + +protected: + virtual bool _init(int32_t sensor_id); + uint8_t last_spectral_int_source = + 0; ///< The value of the last reading of the spectral interrupt source + ///< register + + + +private: + + uint16_t _channel_readings[12]; + as7341_waiting_t _readingState; +}; + +#endif diff --git a/src/src/as7341/README.md b/src/src/as7341/README.md new file mode 100644 index 0000000..97fa32d --- /dev/null +++ b/src/src/as7341/README.md @@ -0,0 +1,50 @@ +# Adafruit AS7341 [![Build Status](https://github.com/adafruit/Adafruit_AS7341/workflows/Arduino%20Library%20CI/badge.svg)](https://github.com/adafruit/Adafruit_AS7341/actions) + +This is the Adafruit AS7341 11-Channel Spectral Sensor for Arduino + +Tested and works great with the Adafruit AS7341 Breakout Board +[](https://www.adafruit.com/products/4698) +This chip uses I2C to communicate, 2 pins are required to interface + +Adafruit invests time and resources providing this open source code, please support Adafruit and open-source hardware by purchasing products from Adafruit! + +# Installation +To install, use the Arduino Library Manager and search for "Adafruit AS7341" and install the library. + +# Dependencies +* [Adafruit_BusIO](https://github.com/adafruit/Adafruit_BusIO) +# Contributing + +Contributions are welcome! Please read our [Code of Conduct](https://github.com/adafruit/Adafruit_AS7341/blob/master/CODE_OF_CONDUCT.md>) +before contributing to help this project stay welcoming. + +## Documentation and doxygen +Documentation is produced by doxygen. Contributions should include documentation for any new code added. + +Some examples of how to use doxygen can be found in these guide pages: + +https://learn.adafruit.com/the-well-automated-arduino-library/doxygen + +https://learn.adafruit.com/the-well-automated-arduino-library/doxygen-tips + +## Formatting and clang-format +This library uses [`clang-format`](https://releases.llvm.org/download.html) to standardize the formatting of `.cpp` and `.h` files. +Contributions should be formatted using `clang-format`: + +The `-i` flag will make the changes to the file. +```bash +clang-format -i *.cpp *.h +``` +If you prefer to make the changes yourself, running `clang-format` without the `-i` flag will print out a formatted version of the file. You can save this to a file and diff it against the original to see the changes. + +Note that the formatting output by `clang-format` is what the automated formatting checker will expect. Any diffs from this formatting will result in a failed build until they are addressed. **Using the `-i` flag is highly recommended.** + +### clang-format resources + * [Binary builds and source available on the LLVM downloads page](https://releases.llvm.org/download.html) + * [Documentation and IDE integration](https://clang.llvm.org/docs/ClangFormat.html) + +## About this Driver + +Written by Bryan Siepert for Adafruit Industries. +BSD license, check license.txt for more information +All text above must be included in any redistribution diff --git a/src/src/as7341/code-of-conduct.md b/src/src/as7341/code-of-conduct.md new file mode 100644 index 0000000..8ee6e44 --- /dev/null +++ b/src/src/as7341/code-of-conduct.md @@ -0,0 +1,127 @@ +# Adafruit Community Code of Conduct + +## Our Pledge + +In the interest of fostering an open and welcoming environment, we as +contributors and leaders pledge to making participation in our project and +our community a harassment-free experience for everyone, regardless of age, body +size, disability, ethnicity, gender identity and expression, level or type of +experience, education, socio-economic status, nationality, personal appearance, +race, religion, or sexual identity and orientation. + +## Our Standards + +We are committed to providing a friendly, safe and welcoming environment for +all. + +Examples of behavior that contributes to creating a positive environment +include: + +* Be kind and courteous to others +* Using welcoming and inclusive language +* Being respectful of differing viewpoints and experiences +* Collaborating with other community members +* Gracefully accepting constructive criticism +* Focusing on what is best for the community +* Showing empathy towards other community members + +Examples of unacceptable behavior by participants include: + +* The use of sexualized language or imagery and sexual attention or advances +* The use of inappropriate images, including in a community member's avatar +* The use of inappropriate language, including in a community member's nickname +* Any spamming, flaming, baiting or other attention-stealing behavior +* Excessive or unwelcome helping; answering outside the scope of the question + asked +* Trolling, insulting/derogatory comments, and personal or political attacks +* Public or private harassment +* Publishing others' private information, such as a physical or electronic + address, without explicit permission +* Other conduct which could reasonably be considered inappropriate + +The goal of the standards and moderation guidelines outlined here is to build +and maintain a respectful community. We ask that you don’t just aim to be +"technically unimpeachable", but rather try to be your best self. + +We value many things beyond technical expertise, including collaboration and +supporting others within our community. Providing a positive experience for +other community members can have a much more significant impact than simply +providing the correct answer. + +## Our Responsibilities + +Project leaders are responsible for clarifying the standards of acceptable +behavior and are expected to take appropriate and fair corrective action in +response to any instances of unacceptable behavior. + +Project leaders have the right and responsibility to remove, edit, or +reject messages, comments, commits, code, issues, and other contributions +that are not aligned to this Code of Conduct, or to ban temporarily or +permanently any community member for other behaviors that they deem +inappropriate, threatening, offensive, or harmful. + +## Moderation + +Instances of behaviors that violate the Adafruit Community Code of Conduct +may be reported by any member of the community. Community members are +encouraged to report these situations, including situations they witness +involving other community members. + +You may report in the following ways: + +In any situation, you may send an email to . + +On the Adafruit Discord, you may send an open message from any channel +to all Community Helpers by tagging @community helpers. You may also send an +open message from any channel, or a direct message to @kattni#1507, +@tannewt#4653, @Dan Halbert#1614, @cater#2442, @sommersoft#0222, or +@Andon#8175. + +Email and direct message reports will be kept confidential. + +In situations on Discord where the issue is particularly egregious, possibly +illegal, requires immediate action, or violates the Discord terms of service, +you should also report the message directly to Discord. + +These are the steps for upholding our community’s standards of conduct. + +1. Any member of the community may report any situation that violates the +Adafruit Community Code of Conduct. All reports will be reviewed and +investigated. +2. If the behavior is an egregious violation, the community member who +committed the violation may be banned immediately, without warning. +3. Otherwise, moderators will first respond to such behavior with a warning. +4. Moderators follow a soft "three strikes" policy - the community member may +be given another chance, if they are receptive to the warning and change their +behavior. +5. If the community member is unreceptive or unreasonable when warned by a +moderator, or the warning goes unheeded, they may be banned for a first or +second offense. Repeated offenses will result in the community member being +banned. + +## Scope + +This Code of Conduct and the enforcement policies listed above apply to all +Adafruit Community venues. This includes but is not limited to any community +spaces (both public and private), the entire Adafruit Discord server, and +Adafruit GitHub repositories. Examples of Adafruit Community spaces include +but are not limited to meet-ups, audio chats on the Adafruit Discord, or +interaction at a conference. + +This Code of Conduct applies both within project spaces and in public spaces +when an individual is representing the project or its community. As a community +member, you are representing our community, and are expected to behave +accordingly. + +## Attribution + +This Code of Conduct is adapted from the [Contributor Covenant][homepage], +version 1.4, available at +, +and the [Rust Code of Conduct](https://www.rust-lang.org/en-US/conduct.html). + +For other projects adopting the Adafruit Community Code of +Conduct, please contact the maintainers of those projects for enforcement. +If you wish to use this code of conduct for your own project, consider +explicitly mentioning your moderation policy or making a copy with your +own moderation policy so as to avoid confusion. diff --git a/src/src/as7341/library.properties b/src/src/as7341/library.properties new file mode 100644 index 0000000..192d989 --- /dev/null +++ b/src/src/as7341/library.properties @@ -0,0 +1,10 @@ +name=Adafruit AS7341 +version=1.3.3 +author=Adafruit +maintainer=Adafruit +sentence=Arduino library for the AS7341 sensors in the Adafruit shop +paragraph=Arduino library for the AS7341 sensors in the Adafruit shop +category=Sensors +url=https://github.com/adafruit/Adafruit_AS7341 +architectures=* +depends=Adafruit BusIO diff --git a/src/src/as7341/license.txt b/src/src/as7341/license.txt new file mode 100644 index 0000000..bc90c68 --- /dev/null +++ b/src/src/as7341/license.txt @@ -0,0 +1,26 @@ +Software License Agreement (BSD License) + +Copyright (c) 2019 Bryan Siepert for Adafruit Industries +All rights reserved. + +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 holders 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 ''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 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. diff --git a/src/src/as7341/spec_meas.cpp b/src/src/as7341/spec_meas.cpp new file mode 100644 index 0000000..90bca85 --- /dev/null +++ b/src/src/as7341/spec_meas.cpp @@ -0,0 +1,278 @@ +#include "spec_meas.h" +#include "Adafruit_AS7341.h" +static const char* TAG = "SPEC"; + + +Adafruit_AS7341 as7341; + + +bool as7341_setup = false; + +bool check_AS7341(){ + if (as7341.begin()) { + as7341_setup = true; + return true; + } + else{ + ESP_LOGE(TAG, "AS7341 init failed"); + as7341_setup = false; + return false; + } +} + +void AS_LED_ON(){ + as7341.enableLED(true); +} + +void AS_LED_OFF(){ + as7341.enableLED(false); +} + +void AS_LED_Current(uint16_t current){ + as7341.setLEDCurrent(current); // set actinic LED current + if (current == 0) as7341.enableLED(false); +} + + + +void AS_all_channel(uint16_t T1, uint16_t T2, uint16_t *spec){ + if (!as7341_setup){ + check_AS7341(); + } + //(T1 + 1) * (T2 + 1) * 2.78 / 1000 + + as7341.setATIME(T1); + as7341.setASTEP(T2); + as7341.setGain(AS7341_GAIN_2X); + + if (!as7341.readAllChannels(spec)){ + Serial.println("Error reading all channels!"); + } +} + +void AS_all_channel(uint16_t T1, uint16_t T2){ + uint16_t spec[12]; + AS_all_channel(T1, T2, spec); + for (uint8_t i = 0; i < 11; i++){ + Serial.print(spec[i]); + Serial.print(","); + } + Serial.print(spec[11]); + Serial.println(""); +} + +// double get_PAR(uint16_t *spec){ +// if (!as7341_setup){ +// check_AS7341(); +// } +// double par = 0; + +// as7341.setATIME(29); +// as7341.setASTEP(499); +// as7341.setGain(AS7341_GAIN_2X); + +// if (!as7341.readAllChannels(spec)){ +// Serial.println("Error reading all channels!"); +// return 0; +// } + +// par = spec[0] + spec[1] + spec[2] + spec[3] + spec[6] + spec[7] + spec[8] + spec[9]/2; +// if (par < 100){ +// as7341.setGain(AS7341_GAIN_256X); +// if (!as7341.readAllChannels(spec)){ +// Serial.println("Error reading all channels!"); +// return 0; +// } +// par = par * 128; +// par = (par + spec[0] + spec[1] + spec[2] + spec[3] + spec[6] + spec[7] + spec[8] + spec[9]/2)/2; +// }else{ +// par = par * 128; +// } +// return par/36; +// } + +// double raw_PAR(uint16_t *spec, as7341_gain_t gain){ +// if (!as7341_setup){ +// check_AS7341(); +// } +// double par = 0; + +// as7341.setATIME(29); +// as7341.setASTEP(499); +// as7341.setGain(gain); + +// if (!as7341.readAllChannels(spec)){ +// Serial.println("Error reading all channels!"); +// return 0; +// } + +// uint16_t ir = (spec[5] + spec[11])/16; +// uint16_t clear = (spec[4] + spec[10])/8; + +// par = spec[0] * PAR_COE1 + spec[1] * PAR_COE2 + spec[2] * PAR_COE3 + spec[3] * PAR_COE4 + spec[6] * PAR_COE5 + spec[7] * PAR_COE6 + \ +// spec[8] * PAR_COE7 + spec[9] * PAR_COE8 + clear * PAR_COE9 + ir * PAR_COE10; + +// return par; +// } + + +// double get_PAR(uint16_t *spec){ +// double par = raw_PAR(spec, AS7341_GAIN_8X); +// if (par < 200){ +// par = raw_PAR(spec, AS7341_GAIN_256X)/32; +// for (uint8_t n = 0; n < 12; n++) spec[n] = spec[n]/32; +// } +// return par * PAR_OFFSET; +// } + +// double get_PAR(){ +// uint16_t spec[12]; +// return get_PAR(spec); +// } + +void dual_exposure(as7341_gain_t gain1,as7341_gain_t gain2, uint16_t readings_buffer[]){ + if (!as7341_setup){ + check_AS7341(); + } + + + as7341.setATIME(99); + as7341.setASTEP(499); + as7341.setGain(gain1); + + as7341.setSMUXLowChannels(true); // Configure SMUX to read low channels + as7341.enableSpectralMeasurement(true); // Start integration + as7341.delayForData(0); // I'll wait for you for all time + + Adafruit_BusIO_Register channel_data_reg = + Adafruit_BusIO_Register(as7341.i2c_dev, AS7341_CH0_DATA_L, 2); + bool low_success = channel_data_reg.read((uint8_t *)readings_buffer, 12); + + as7341.setGain(gain2); + as7341.setSMUXLowChannels(false); // Configure SMUX to read low channels + as7341.enableSpectralMeasurement(true); // Start integration + as7341.delayForData(0); // I'll wait for you for all time + + low_success = channel_data_reg.read((uint8_t *)&readings_buffer[6], 12); +} + +void cali_PAR(){ + if (!as7341_setup){ + check_AS7341(); + } + uint16_t spec[12]; + uint16_t calc_spec[10]; + + dual_exposure(AS7341_GAIN_8X, AS7341_GAIN_8X, spec); + + calc_spec[0] = spec[0] * Spec_COE1; + calc_spec[1] = spec[1] * Spec_COE2; + calc_spec[2] = spec[2] * Spec_COE3; + calc_spec[3] = spec[3] * Spec_COE4; + calc_spec[4] = spec[6] * Spec_COE5; + calc_spec[5] = spec[7] * Spec_COE6; + calc_spec[6] = spec[8] * Spec_COE7; + calc_spec[7] = spec[9] * Spec_COE8; + calc_spec[8] = spec[11] * Spec_COE9; + calc_spec[9] = spec[10]; + + for (uint8_t n = 0; n < 10; n++){ + Serial.print(calc_spec[n]); + Serial.print(","); + } + + Serial.println(); + + return; +} + +double get_PAR(uint16_t *calc_spec){ + if (!as7341_setup){ + check_AS7341(); + } + uint16_t spec[12]; + float calc_par = 0; + + //uint16_t calc_spec[10]; + + dual_exposure(AS7341_GAIN_2X, AS7341_GAIN_2X, spec); + + calc_spec[0] = spec[0] * Spec_COE1; + calc_spec[1] = spec[1] * Spec_COE2; + calc_spec[2] = spec[2] * Spec_COE3; + calc_spec[3] = spec[3] * Spec_COE4; + calc_spec[4] = spec[6] * Spec_COE5; + calc_spec[5] = spec[7] * Spec_COE6; + calc_spec[6] = spec[8] * Spec_COE7; + calc_spec[7] = spec[9] * Spec_COE8; + calc_spec[8] = spec[11] * Spec_COE9; + calc_spec[9] = spec[10]; + + for (uint8_t n = 0; n < 8; n++){ + calc_par += calc_spec[n]; + } + calc_par = calc_par * 0.006 - calc_spec[8] * 0.0075; + return calc_par * PAR_OFFSET; +} + + +double get_PAR(){ + uint16_t spec[10]; + return get_PAR(spec); +} + + + +uint8_t as7431_reg_write(uint8_t reg, uint8_t data){ + Wire.beginTransmission(AS7341_I2CADDR_DEFAULT); + Wire.write(reg); + Wire.write(data); + return Wire.endTransmission(); +} + + +uint8_t as7431_reg_read(uint8_t reg, uint8_t* data, uint16_t len){ + Wire.beginTransmission(AS7341_I2CADDR_DEFAULT); + Wire.write(reg); + Wire.endTransmission(); + Wire.requestFrom((uint8_t)AS7341_I2CADDR_DEFAULT, (uint8_t)len, (uint8_t)0); + for (uint16_t i = 0; i < len; i++) { + data[i] = Wire.read(); + } + return 0; +} + + +void as7431_blink(uint8_t n, uint8_t intensity){ + + while (Serial.available()) Serial.print(Serial.read()); + + uint8_t reg = intensity >> 1; + if (intensity < 4) reg = 1; + reg |= 0b10000000; + + as7431_reg_write(0xA9, 0b00010000); + as7431_reg_write(0x70, 0b00001000); + as7431_reg_write(0x74, 0x00); + + + + unsigned long timer = millis(); + uint8_t a,b; + a = 18 - n * 2; + b = 30 - a; + + while(millis() - timer < 60000){ + for (uint8_t z = 0; z < 128; z++){ + as7431_reg_write(0x74, reg); + delayMicroseconds(a * 1024); + as7431_reg_write(0x74, 0x00); + delayMicroseconds(b * 1024); + } + if (Serial.available() > 1) break; + } + as7431_reg_write(0x74, 0x00); + as7431_reg_write(0xA9, 0x0); + + return; +} \ No newline at end of file diff --git a/src/src/as7341/spec_meas.h b/src/src/as7341/spec_meas.h new file mode 100644 index 0000000..92341a2 --- /dev/null +++ b/src/src/as7341/spec_meas.h @@ -0,0 +1,43 @@ +#include "Adafruit_AS7341.h" +#include "../pin_config.h" + +#define PAR_COE1 -0.515 +#define PAR_COE2 0.801 +#define PAR_COE3 -0.385 +#define PAR_COE4 -0.202 +#define PAR_COE5 0.301 +#define PAR_COE6 0.183 +#define PAR_COE7 0.055 +#define PAR_COE8 0.081 +#define PAR_COE9 -0.033 + +#define Spec_COE1 12 +#define Spec_COE2 10 +#define Spec_COE3 11 +#define Spec_COE4 10 +#define Spec_COE5 10 +#define Spec_COE6 9 +#define Spec_COE7 7 +#define Spec_COE8 4 +#define Spec_COE9 1 + +#define PAR_OFFSET 4 + +extern Adafruit_AS7341 as7341; + +extern bool as7341_setup; +bool check_AS7341(); +void AS_LED_Current(uint16_t current); +void AS_LED_ON(); +void AS_LED_OFF(); + +void AS_all_channel(uint16_t T1, uint16_t T2, uint16_t *spec); +void AS_all_channel(uint16_t T1, uint16_t T2); +double get_PAR(); +double get_PAR(uint16_t *spec); + + + +uint8_t as7431_reg_write(uint8_t reg, uint8_t data); +uint8_t as7431_reg_read(uint8_t reg, uint8_t* data, uint16_t len); +void as7431_blink(uint8_t n, uint8_t intensity); diff --git a/src/src/devices_init.cpp b/src/src/devices_init.cpp new file mode 100644 index 0000000..350370c --- /dev/null +++ b/src/src/devices_init.cpp @@ -0,0 +1,104 @@ +#include "devices_init.h" + + +static const char* TAG = "Device_init"; +bool SPI_bus_initialized = false; +bool I2C_bus_initialized = false; + +spi_bus_config_t SPI_bus_cfg = { + .mosi_io_num=ADPD_SPI_MOSI, + .miso_io_num=ADPD_SPI_MISO, + .sclk_io_num=ADPD_SPI_SCK, + .quadwp_io_num=-1, + .quadhd_io_num=-1, + .max_transfer_sz = 4092, + }; + +bool init_spi_bus(void){ + esp_err_t err = 1; + + ESP_LOGV(TAG, "Initiate SPI BUS"); + if (!SPI_bus_initialized){ + err = spi_bus_initialize(SPI2_HOST, &SPI_bus_cfg, SPI_DMA_CH_AUTO); + if (err == ESP_OK) { + SPI_bus_initialized = true; + ESP_LOGI(TAG, "SPI BUS initiated"); + return true; + } + else{ + ESP_LOGE(TAG, "SPI BUS init FAILED: %s", esp_err_to_name(err)); + SPI_bus_initialized = false; + return false; + } + }else{ + ESP_LOGI(TAG, "SPI bus previously initialized"); + return true; + } +} + +bool init_i2c_bus(void){ + bool err = false; + ESP_LOGV(TAG, "Initiate I2C BUS"); + if (!I2C_bus_initialized){ + err = Wire.begin(I2C_SDA, I2C_SCL, 400000UL); + if (err == true) { + I2C_bus_initialized = true; + ESP_LOGI(TAG, "I2C BUS initiated"); + return true; + } + else{ + ESP_LOGE(TAG, "I2C BUS Failed"); + I2C_bus_initialized = false; + return false; + } + }else{ + ESP_LOGI(TAG, "I2C bus previously initialized"); + return true; + } +} + +void i2c_scan(){ + if (!I2C_bus_initialized) init_i2c_bus(); + if (!I2C_bus_initialized) return; + + for (uint8_t i = 1; i < 127; i++){ + Wire.beginTransmission(i); + if (Wire.endTransmission() == 0){ + + switch (i){ + case ADDR_I2C_AS7341: + { + Serial.print("AS7341 found at "); + } + break; + + + + case ADDR_I2C_MLX90632: + { + Serial.print("MLX90632 found at "); + } + break; + + default: + { + Serial.print("Something else found at "); + } + + } + Serial.println(i); + } + } +} + +// bool i2c_scan(uint8_t i){ +// if (!I2C_bus_initialized) init_i2c_bus(); +// if (!I2C_bus_initialized) return false; + +// Wire.beginTransmission(i); +// if (Wire.endTransmission() == 0){ +// Serial.println("Found"); +// return true; +// } +// return false; +// } \ No newline at end of file diff --git a/src/src/devices_init.h b/src/src/devices_init.h new file mode 100644 index 0000000..1a5632e --- /dev/null +++ b/src/src/devices_init.h @@ -0,0 +1,26 @@ +#ifndef __DEVINIT_H__ +#define __DEVINIT_H__ + +#include "pin_config.h" + +#include "Wire.h" +#include "driver/spi_common.h" +#include "driver/spi_master.h" +#include "esp_check.h" +#include + +#define DEBUGGING 1 + +extern bool SPI_bus_initialized; +extern bool I2C_bus_initialized; + +bool init_spi_bus(void); +bool init_i2c_bus(void); +void i2c_scan(void); +// bool i2c_scan(uint8_t); +// void miniPorQ_air (int pumps, int pump_voltage); + + + + +#endif \ No newline at end of file diff --git a/src/src/mlx90632/mlx_dev.cpp b/src/src/mlx90632/mlx_dev.cpp new file mode 100644 index 0000000..4803b60 --- /dev/null +++ b/src/src/mlx90632/mlx_dev.cpp @@ -0,0 +1,729 @@ +/** + * @file mlx90632.c + * @brief MLX90632 driver with virtual i2c communication + * @internal + * + * @copyright (C) 2017 Melexis N.V. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * @endinternal + * + * @details + * + * @addtogroup mlx90632_private MLX90632 Internal library functions + * @{ + * + */ + +#include +#include "mlx_dev.h" +#include "u_mlx.h" + +#define POW10 10000000000LL + +int mlx90632_start_measurement(void) +{ + int ret, tries = MLX90632_MAX_NUMBER_MESUREMENT_READ_TRIES; + uint16_t reg_status; + + ret = mlx90632_i2c_read(MLX90632_REG_STATUS, ®_status); + if (ret < 0) + return ret; + + ret = mlx90632_i2c_write(MLX90632_REG_STATUS, reg_status & (~MLX90632_STAT_DATA_RDY)); + if (ret < 0) + return ret; + + while (tries-- > 0) + { + ret = mlx90632_i2c_read(MLX90632_REG_STATUS, ®_status); + if (ret < 0) + return ret; + if (reg_status & MLX90632_STAT_DATA_RDY) + break; + /* minimum wait time to complete measurement + * should be calculated according to refresh rate + * atm 10ms - 11ms + */ + delay(20); + } + + if (tries < 0) + { + // data not ready + return -ETIMEDOUT; + } + + return (reg_status & MLX90632_STAT_CYCLE_POS) >> 2; +} + +/** Based on @link mlx90632_start_measurement @endlink return value fill channel_new and channel_old + * variables with proper values. This is to provide a bit more flexibility in case other channels are + * returned and need a bit more mingeling than usual maths can provide. + * + * So far there are just two use cases. If returned value is not 1 or 2, it will leave channel_new + * and channel_old unassigned. + * + * @param[in] ret @link mlx90632_start_measurement @endlink return value + * @param[out] *channel_new Pointer to memory location where new channel value is stored + * @param[out] *channel_old Pointer to memory location where old channel value is stored + * + * @retval 0 When both memory locations are updated as per ret + * @retval -EINVAL channel_new and channel_old were not updated + */ +static int32_t mlx90632_channel_new_select(int32_t ret, uint8_t *channel_new, uint8_t *channel_old) +{ + switch (ret) + { + case 1: + *channel_new = 1; + *channel_old = 2; + break; + + case 2: + *channel_new = 2; + *channel_old = 1; + break; + + default: + return -EINVAL; + } + return 0; +} + + +/** Read ambient raw old and new values based on @link mlx90632_start_measurement @endlink return value. + * + * Two i2c_reads are needed to obtain necessary raw ambient values from the sensor, as they are then + * preprocessed before going to calculation functions. Because one value is newer than other (see @link + * mlx90632_start_measurement @endlink) this function provides dynamics based on return value of the + * @link mlx90632_start_measurement @endlink. + * + * @param[out] *ambient_new_raw Pointer to memory location where new ambient value from sensor is stored + * @param[out] *ambient_old_raw Pointer to memory location where old ambient value from sensor is stored + * + * @retval 0 Successfully read both values + * @retval <0 Something went wrong. Check errno.h for more details. + */ +static int32_t mlx90632_read_temp_ambient_raw(int16_t *ambient_new_raw, int16_t *ambient_old_raw) +{ + int32_t ret; + uint16_t read_tmp; + + ret = mlx90632_i2c_read(MLX90632_RAM_3(1), &read_tmp); + if (ret < 0) + return ret; + *ambient_new_raw = (int16_t)read_tmp; + + ret = mlx90632_i2c_read(MLX90632_RAM_3(2), &read_tmp); + if (ret < 0) + return ret; + *ambient_old_raw = (int16_t)read_tmp; + + return ret; +} + + +/** Read object raw old and new values based on @link mlx90632_start_measurement @endlink return value. + * + * Four i2c_reads are needed to obtain necessary raw object values from the sensor. These values are grouped per new + * and old and then averaged before return of the function. After that they are then preprocessed before going to + * calculation functions. Because one value is newer than other (see @link mlx90632_start_measurement @endlink) this + * function provides dynamics based on return value of the @link mlx90632_start_measurement @endlink. + * + * @param[in] start_measurement_ret Return value of @link mlx90632_start_measurement @endlink + * @param[out] *object_new_raw Pointer to memory location where average of new object values from sensor is stored + * @param[out] *object_old_raw Pointer to memory location where average of old object values from sensor is stored + * + * @retval 0 Successfully read both values + * @retval <0 Something went wrong. Check errno.h for more details. + */ +static int32_t mlx90632_read_temp_object_raw(int32_t start_measurement_ret, + int16_t *object_new_raw, int16_t *object_old_raw) +{ + int32_t ret; + uint16_t read_tmp; + int16_t read; + uint8_t channel, channel_old; + + ret = mlx90632_channel_new_select(start_measurement_ret, &channel, &channel_old); + if (ret != 0) + return -EINVAL; + + ret = mlx90632_i2c_read(MLX90632_RAM_2(channel), &read_tmp); + if (ret < 0) + return ret; + + read = (int16_t)read_tmp; + + ret = mlx90632_i2c_read(MLX90632_RAM_1(channel), &read_tmp); + if (ret < 0) + return ret; + *object_new_raw = (read + (int16_t)read_tmp) / 2; + + ret = mlx90632_i2c_read(MLX90632_RAM_2(channel_old), &read_tmp); + if (ret < 0) + return ret; + read = (int16_t)read_tmp; + + ret = mlx90632_i2c_read(MLX90632_RAM_1(channel_old), &read_tmp); + if (ret < 0) + return ret; + *object_old_raw = (read + (int16_t)read_tmp) / 2; + + return ret; +} + + +int32_t mlx90632_read_temp_raw(int16_t *ambient_new_raw, int16_t *ambient_old_raw, + int16_t *object_new_raw, int16_t *object_old_raw) +{ + int32_t ret, start_measurement_ret; + + // trigger and wait for measurement to complete + start_measurement_ret = mlx90632_start_measurement(); + if (start_measurement_ret < 0) + return start_measurement_ret; + + /** Read new and old **ambient** values from sensor */ + ret = mlx90632_read_temp_ambient_raw(ambient_new_raw, ambient_old_raw); + if (ret < 0) + return ret; + + /** Read new and old **object** values from sensor */ + ret = mlx90632_read_temp_object_raw(start_measurement_ret, object_new_raw, object_old_raw); + + return ret; +} + + +int32_t mlx90632_read_temp_raw_burst(int16_t *ambient_new_raw, int16_t *ambient_old_raw, + int16_t *object_new_raw, int16_t *object_old_raw) +{ + int32_t ret, start_measurement_ret; + + // trigger and wait for measurement to complete + start_measurement_ret = mlx90632_start_measurement_burst(); + if (start_measurement_ret < 0) + return start_measurement_ret; + + /** Read new and old **ambient** values from sensor */ + ret = mlx90632_read_temp_ambient_raw(ambient_new_raw, ambient_old_raw); + if (ret < 0) + return ret; + + /** Read new and old **object** values from sensor */ + ret = mlx90632_read_temp_object_raw(2, object_new_raw, object_old_raw); + + return ret; +} + + +/* DSPv5 */ +double mlx90632_preprocess_temp_ambient(int16_t ambient_new_raw, int16_t ambient_old_raw, int16_t Gb) +{ + double VR_Ta, kGb; + + kGb = ((double)Gb) / 1024.0; + + VR_Ta = ambient_old_raw + kGb * (ambient_new_raw / (MLX90632_REF_3)); + return ((ambient_new_raw / (MLX90632_REF_3)) / VR_Ta) * 524288.0; +} + +double mlx90632_preprocess_temp_object(int16_t object_new_raw, int16_t object_old_raw, + int16_t ambient_new_raw, int16_t ambient_old_raw, + int16_t Ka) +{ + double VR_IR, kKa; + + kKa = ((double)Ka) / 1024.0; + + VR_IR = ambient_old_raw + kKa * (ambient_new_raw / (MLX90632_REF_3)); + return ((((object_new_raw + object_old_raw) / 2) / (MLX90632_REF_12)) / VR_IR) * 524288.0; +} + +double mlx90632_calc_temp_ambient(int16_t ambient_new_raw, int16_t ambient_old_raw, int32_t P_T, + int32_t P_R, int32_t P_G, int32_t P_O, int16_t Gb) +{ + double Asub, Bsub, Ablock, Bblock, Cblock, AMB; + + AMB = mlx90632_preprocess_temp_ambient(ambient_new_raw, ambient_old_raw, Gb); + + Asub = ((double)P_T) / (double)17592186044416.0; + Bsub = (double)AMB - ((double)P_R / (double)256.0); + Ablock = Asub * (Bsub * Bsub); + Bblock = (Bsub / (double)P_G) * (double)1048576.0; + Cblock = (double)P_O / (double)256.0; + + return Bblock + Ablock + Cblock; +} + + + +/** Iterative calculation of object temperature + * + * DSPv5 requires 3 iterations to reduce noise for object temperature. Since + * each iteration requires same calculations this helper function is + * implemented. + * + * @param[in] prev_object_temp previously calculated object temperature. If + * there is no previously calculated temperature + * input 25.0 + * @param[in] object object temperature from @link mlx90632_preprocess_temp_object @endlink + * @param[in] TAdut ambient temperature coefficient + * @param[in] Ga Register value on @link MLX90632_EE_Ga @endlink + * @param[in] Fa Register value on @link MLX90632_EE_Fa @endlink + * @param[in] Fb Register value on @link MLX90632_EE_Fb @endlink + * @param[in] Ha Register value on @link MLX90632_EE_Ha @endlink + * @param[in] Hb Register value on @link MLX90632_EE_Hb @endlink + * @param[in] emissivity Value provided by user of the object emissivity + * + * @return Calculated object temperature for current iteration in milliCelsius + */ +static double mlx90632_calc_temp_object_iteration(double prev_object_temp, int32_t object, double TAdut, + int32_t Ga, int32_t Fa, int32_t Fb, int16_t Ha, int16_t Hb, + double emissivity) +{ + double calcedGa, calcedGb, calcedFa, TAdut4, first_sqrt; + // temp variables + double KsTAtmp, Alpha_corr; + double Ha_customer, Hb_customer; + + + Ha_customer = Ha / ((double)16384.0); + Hb_customer = Hb / ((double)1024.0); + calcedGa = ((double)Ga * (prev_object_temp - 25)) / ((double)68719476736.0); + KsTAtmp = (double)Fb * (TAdut - 25); + calcedGb = KsTAtmp / ((double)68719476736.0); + Alpha_corr = (((double)(Fa * POW10)) * Ha_customer * (double)(1 + calcedGa + calcedGb)) / + ((double)70368744177664.0); + calcedFa = object / (emissivity * (Alpha_corr / POW10)); + TAdut4 = (TAdut + 273.15) * (TAdut + 273.15) * (TAdut + 273.15) * (TAdut + 273.15); + + first_sqrt = sqrt(calcedFa + TAdut4); + + return sqrt(first_sqrt) - 273.15 - Hb_customer; +} + +/** Iterative calculation of object temperature when the environment temperature differs from the sensor temperature + * + * DSPv5 requires 3 iterations to reduce noise for object temperature. Since + * each iteration requires same calculations this helper function is + * implemented. + * + * @param[in] prev_object_temp previously calculated object temperature. If + * there is no previously calculated temperature + * input 25.0 + * @param[in] object object temperature from @link mlx90632_preprocess_temp_object @endlink + * @param[in] TAdut ambient temperature coefficient + * @param[in] TaTr4 compensation coefficient for reflected (environment) temperature. The compensation + * coefficient is calculated from ambient temperature either from a sensor different than the MLX90632 or + * acquired by other means. + * @param[in] Ga Register value on @link MLX90632_EE_Ga @endlink + * @param[in] Fa Register value on @link MLX90632_EE_Fa @endlink + * @param[in] Fb Register value on @link MLX90632_EE_Fb @endlink + * @param[in] Ha Register value on @link MLX90632_EE_Ha @endlink + * @param[in] Hb Register value on @link MLX90632_EE_Hb @endlink + * @param[in] emissivity Value provided by user of the object emissivity + * + * @return Calculated object temperature for current iteration in milliCelsius + */ +static double mlx90632_calc_temp_object_iteration_reflected(double prev_object_temp, int32_t object, double TAdut, double TaTr4, + int32_t Ga, int32_t Fa, int32_t Fb, int16_t Ha, int16_t Hb, + double emissivity) +{ + double calcedGa, calcedGb, calcedFa, first_sqrt; + // temp variables + double KsTAtmp, Alpha_corr; + double Ha_customer, Hb_customer; + + Ha_customer = Ha / ((double)16384.0); + Hb_customer = Hb / ((double)1024.0); + calcedGa = ((double)Ga * (prev_object_temp - 25)) / ((double)68719476736.0); + KsTAtmp = (double)Fb * (TAdut - 25); + calcedGb = KsTAtmp / ((double)68719476736.0); + Alpha_corr = (((double)(Fa * POW10)) * Ha_customer * (double)(1 + calcedGa + calcedGb)) / + ((double)70368744177664.0); + calcedFa = object / (emissivity * (Alpha_corr / POW10)); + + first_sqrt = sqrt(calcedFa + TaTr4); + + return sqrt(first_sqrt) - 273.15 - Hb_customer; +} + +static double emissivity = 0.0; +void mlx90632_set_emissivity(double value) +{ + emissivity = value; +} + +double mlx90632_get_emissivity(void) +{ + if (emissivity == 0.0) + { + return 1.0; + } + else + { + return emissivity; + } +} + +double mlx90632_calc_temp_object(int32_t object, int32_t ambient, + int32_t Ea, int32_t Eb, int32_t Ga, int32_t Fa, int32_t Fb, + int16_t Ha, int16_t Hb) +{ + double kEa, kEb, TAdut; + double temp = 25.0; + double tmp_emi = mlx90632_get_emissivity(); + int8_t i; + + kEa = ((double)Ea) / ((double)65536.0); + kEb = ((double)Eb) / ((double)256.0); + TAdut = (((double)ambient) - kEb) / kEa + 25; + + //iterate through calculations + for (i = 0; i < 5; ++i) + { + temp = mlx90632_calc_temp_object_iteration(temp, object, TAdut, Ga, Fa, Fb, Ha, Hb, tmp_emi); + } + return temp; +} + +double mlx90632_calc_temp_object_reflected(int32_t object, int32_t ambient, double reflected, + int32_t Ea, int32_t Eb, int32_t Ga, int32_t Fa, int32_t Fb, + int16_t Ha, int16_t Hb) +{ + double kEa, kEb, TAdut; + double temp = 25.0; + double tmp_emi = mlx90632_get_emissivity(); + double TaTr4; + double ta4; + int8_t i; + + kEa = ((double)Ea) / ((double)65536.0); + kEb = ((double)Eb) / ((double)256.0); + TAdut = (((double)ambient) - kEb) / kEa + 25; + + TaTr4 = reflected + 273.15; + TaTr4 = TaTr4 * TaTr4; + TaTr4 = TaTr4 * TaTr4; + ta4 = TAdut + 273.15; + ta4 = ta4 * ta4; + ta4 = ta4 * ta4; + TaTr4 = TaTr4 - (TaTr4 - ta4) / tmp_emi; + + //iterate through calculations + for (i = 0; i < 5; ++i) + { + temp = mlx90632_calc_temp_object_iteration_reflected(temp, object, TAdut, TaTr4, Ga, Fa, Fb, Ha, Hb, tmp_emi); + } + return temp; +} + +int32_t mlx90632_init(void) +{ + int32_t ret; + uint16_t eeprom_version, reg_status; + + ret = mlx90632_i2c_read(MLX90632_EE_VERSION, &eeprom_version); + if (ret < 0) + { + return ret; + } + + if ((eeprom_version & 0x00FF) != MLX90632_DSPv5) + { + // this here can fail because of big/little endian of cpu/i2c + return -EPROTONOSUPPORT; + } + + ret = mlx90632_i2c_read(MLX90632_REG_STATUS, ®_status); + if (ret < 0) + return ret; + + // Prepare a clean start with setting NEW_DATA to 0 + ret = mlx90632_i2c_write(MLX90632_REG_STATUS, reg_status & ~(MLX90632_STAT_DATA_RDY)); + if (ret < 0) + return ret; + + if ((eeprom_version & 0x7F00) == MLX90632_XTD_RNG_KEY) + { + return ERANGE; + } + + return 0; +} + +int32_t mlx90632_addressed_reset(void) +{ + int32_t ret; + uint16_t reg_ctrl; + uint16_t reg_value; + + ret = mlx90632_i2c_read(MLX90632_REG_CTRL, ®_value); + if (ret < 0) + return ret; + + reg_ctrl = reg_value & ~MLX90632_CFG_PWR_MASK; + reg_ctrl |= MLX90632_PWR_STATUS_STEP; + ret = mlx90632_i2c_write(MLX90632_REG_CTRL, reg_ctrl); + if (ret < 0) + return ret; + + ret = mlx90632_i2c_write(0x3005, MLX90632_RESET_CMD); + if (ret < 0) + return ret; + + usleep(150, 200); + + ret = mlx90632_i2c_write(MLX90632_REG_CTRL, reg_value); + + return ret; +} + +int32_t mlx90632_get_measurement_time(uint16_t meas) +{ + int32_t ret; + uint16_t reg; + + ret = mlx90632_i2c_read(meas, ®); + if (ret < 0) + return ret; + + reg &= MLX90632_EE_REFRESH_RATE_MASK; + reg = reg >> 8; + + return MLX90632_MEAS_MAX_TIME >> reg; +} + +int32_t mlx90632_get_meas_type(void) +{ + int32_t ret; + uint16_t reg_ctrl; + uint16_t reg_temp; + + ret = mlx90632_i2c_read(MLX90632_REG_CTRL, ®_temp); + if (ret < 0) + return ret; + + reg_ctrl = MLX90632_MTYP(reg_temp); + + if ((reg_ctrl != MLX90632_MTYP_MEDICAL) & (reg_ctrl != MLX90632_MTYP_EXTENDED)) + return -EINVAL; + + reg_temp = MLX90632_CFG_PWR(reg_temp); + + if (reg_temp == MLX90632_PWR_STATUS_SLEEP_STEP) + return MLX90632_BURST_MEASUREMENT_TYPE(reg_ctrl); + + if (reg_temp != MLX90632_PWR_STATUS_CONTINUOUS) + return -EINVAL; + + return reg_ctrl; +} + + + +int32_t mlx90632_calculate_dataset_ready_time(void) +{ + int32_t ret; + int32_t refresh_time; + + ret = mlx90632_get_meas_type(); + if (ret < 0) + return ret; + + if ((ret != MLX90632_MTYP_MEDICAL_BURST) && (ret != MLX90632_MTYP_EXTENDED_BURST)) + return -EINVAL; + + if (ret == MLX90632_MTYP_MEDICAL_BURST) + { + ret = mlx90632_get_measurement_time(MLX90632_EE_MEDICAL_MEAS1); + if (ret < 0) + return ret; + + refresh_time = ret; + + ret = mlx90632_get_measurement_time(MLX90632_EE_MEDICAL_MEAS2); + if (ret < 0) + return ret; + + refresh_time = refresh_time + ret; + } + else + { + ret = mlx90632_get_measurement_time(MLX90632_EE_EXTENDED_MEAS1); + if (ret < 0) + return ret; + + refresh_time = ret; + + ret = mlx90632_get_measurement_time(MLX90632_EE_EXTENDED_MEAS2); + if (ret < 0) + return ret; + + refresh_time = refresh_time + ret; + + ret = mlx90632_get_measurement_time(MLX90632_EE_EXTENDED_MEAS3); + if (ret < 0) + return ret; + + refresh_time = refresh_time + ret; + } + + return refresh_time; +} + +int32_t mlx90632_start_measurement_burst(void) +{ + int32_t ret; + int tries = MLX90632_MAX_NUMBER_MESUREMENT_READ_TRIES; + uint16_t reg; + + ret = mlx90632_i2c_read(MLX90632_REG_CTRL, ®); + if (ret < 0) + return ret; + + reg |= MLX90632_START_BURST_MEAS; + + ret = mlx90632_i2c_write(MLX90632_REG_CTRL, reg); + if (ret < 0) + return ret; + + ret = mlx90632_calculate_dataset_ready_time(); + if (ret < 0) + return ret; + delay(ret); /* Waiting for refresh of all the measurement tables */ + + while (tries-- > 0) + { + ret = mlx90632_i2c_read(MLX90632_REG_STATUS, ®); + if (ret < 0) + return ret; + if ((reg & MLX90632_STAT_BUSY) == 0) + break; + /* minimum wait time to complete measurement + * should be calculated according to refresh rate + * atm 10ms - 11ms + */ + usleep(10000, 11000); + } + + if (tries < 0) + { + // data not ready + return -ETIMEDOUT; + } + + return 0; +} + + +static int32_t mlx90632_unlock_eeporm() +{ + return mlx90632_i2c_write(0x3005, MLX90632_EEPROM_WRITE_KEY); +} + +static int32_t mlx90632_wait_for_eeprom_not_busy() +{ + uint16_t reg_status; + int32_t ret = mlx90632_i2c_read(MLX90632_REG_STATUS, ®_status); + + while (ret >= 0 && reg_status & MLX90632_STAT_EE_BUSY) + { + ret = mlx90632_i2c_read(MLX90632_REG_STATUS, ®_status); + } + + return ret; +} + +static int32_t mlx90632_erase_eeprom(uint16_t address) +{ + int32_t ret = mlx90632_unlock_eeporm(); + + if (ret < 0) + return ret; + + ret = mlx90632_i2c_write(address, 0x00); + if (ret < 0) + return ret; + + ret = mlx90632_wait_for_eeprom_not_busy(); + return ret; +} + +static int32_t mlx90632_write_eeprom(uint16_t address, uint16_t data) +{ + int32_t ret = mlx90632_erase_eeprom(address); + + if (ret < 0) + return ret; + + ret = mlx90632_unlock_eeporm(); + if (ret < 0) + return ret; + + ret = mlx90632_i2c_write(address, data); + if (ret < 0) + return ret; + + ret = mlx90632_wait_for_eeprom_not_busy(); + return ret; +} + +int32_t mlx90632_set_refresh_rate(mlx90632_meas_t measRate) +{ + uint16_t meas1, meas2; + + int32_t ret = mlx90632_i2c_read(MLX90632_EE_MEDICAL_MEAS1, &meas1); + + if (ret < 0) + return ret; + + uint16_t new_value = MLX90632_NEW_REG_VALUE(meas1, measRate, MLX90632_EE_REFRESH_RATE_START, MLX90632_EE_REFRESH_RATE_SHIFT); + + if (meas1 != new_value) + { + ret = mlx90632_write_eeprom(MLX90632_EE_MEDICAL_MEAS1, new_value); + if (ret < 0) + return ret; + } + + ret = mlx90632_i2c_read(MLX90632_EE_MEDICAL_MEAS2, &meas2); + if (ret < 0) + return ret; + + new_value = MLX90632_NEW_REG_VALUE(meas2, measRate, MLX90632_EE_REFRESH_RATE_START, MLX90632_EE_REFRESH_RATE_SHIFT); + if (meas2 != new_value) + { + ret = mlx90632_write_eeprom(MLX90632_EE_MEDICAL_MEAS2, new_value); + } + + return ret; +} + +mlx90632_meas_t mlx90632_get_refresh_rate(void) +{ + int32_t ret; + uint16_t meas1; + + ret = mlx90632_i2c_read(MLX90632_EE_MEDICAL_MEAS1, &meas1); + if (ret < 0) + return MLX90632_MEAS_HZ_ERROR; + + return (mlx90632_meas_t)MLX90632_REFRESH_RATE(meas1); +} + +///@} diff --git a/src/src/mlx90632/mlx_dev.h b/src/src/mlx90632/mlx_dev.h new file mode 100644 index 0000000..da194eb --- /dev/null +++ b/src/src/mlx90632/mlx_dev.h @@ -0,0 +1,466 @@ +/** + * @file mlx90632.h + * @brief MLX90632 driver with virtual i2c communication + * @internal + * + * @copyright (C) 2017 Melexis N.V. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * @endinternal + * + * @addtogroup mlx90632_API MLX90632 Driver Library API + * Implementation of MLX90632 driver with virtual i2c read/write functions + * + * @details + * Copy of Kernel driver, except that it is stripped of Linux kernel specifics + * which are replaced by simple i2c read/write functions. There are some Linux + * kernel macros left behind as they make code more readable and easier to + * understand, but if you already have your own implementation then preprocessor + * should handle it just fine. + * + * Repository contains README.md for compilation and unit-test instructions. + * + * @{ + * + */ +#ifndef _MLX90632_LIB_ +#define _MLX90632_LIB_ + +/* Including CRC calculation functions */ +// #include +// #include "mlx90632_extended_meas.h" + +/* Solve errno not defined values */ +#ifndef ETIMEDOUT +#define ETIMEDOUT 110 /**< From linux errno.h */ +#endif +#ifndef EINVAL +#define EINVAL 22 /**< From linux errno.h */ +#endif +#ifndef EPROTONOSUPPORT +#define EPROTONOSUPPORT 93 /**< From linux errno.h */ +#endif +#ifndef ERANGE +#define ERANGE 34 /**< From linux errno.h */ +#endif +#ifndef ENOKEY +#define ENOKEY 126 /**< From linux errno.h */ +#endif + + +/* BIT, GENMASK and ARRAY_SIZE macros are imported from kernel */ +#ifndef BIT +#define BIT(x)(1UL << (x)) +#endif +#ifndef GENMASK +#ifndef BITS_PER_LONG +#warning "Using default BITS_PER_LONG value" +#define BITS_PER_LONG 32 /**< Define how many bits per long your CPU has */ +#endif +#define GENMASK(h, l) \ + (((~0UL) << (l)) & (~0UL >> (BITS_PER_LONG - 1 - (h)))) +#endif +#ifndef ARRAY_SIZE +#define ARRAY_SIZE(arr) (sizeof(arr) / sizeof(arr[0])) /**< Return number of elements in array */ +#endif + +/* Memory sections addresses */ +#define MLX90632_ADDR_RAM 0x4000 /**< Start address of ram */ +#define MLX90632_ADDR_EEPROM 0x2480 /**< Start address of user eeprom */ + +/* EEPROM addresses - used at startup */ +#define MLX90632_EE_CTRL 0x24d4 /**< Control register initial value */ +#define MLX90632_EE_CONTROL MLX90632_EE_CTRL /**< More human readable for Control register */ + +#define MLX90632_EE_I2C_ADDRESS 0x24d5 /**< I2C address register initial value */ +#define MLX90632_EE_VERSION 0x240b /**< EEPROM version reg - assumed 0x101 */ + +#define MLX90632_EE_P_R 0x240c /**< Calibration constant ambient reference register 32bit */ +#define MLX90632_EE_P_G 0x240e /**< Calibration constant ambient gain register 32bit */ +#define MLX90632_EE_P_T 0x2410 /**< Calibration constant ambient tc2 register 32bit */ +#define MLX90632_EE_P_O 0x2412 /**< Calibration constant ambient offset register 32bit */ +#define MLX90632_EE_Aa 0x2414 /**< Aa calibration const register 32bit */ +#define MLX90632_EE_Ab 0x2416 /**< Ab calibration const register 32bit */ +#define MLX90632_EE_Ba 0x2418 /**< Ba calibration const register 32bit */ +#define MLX90632_EE_Bb 0x241a /**< Bb calibration const register 32bit */ +#define MLX90632_EE_Ca 0x241c /**< Ca calibration const register 32bit */ +#define MLX90632_EE_Cb 0x241e /**< Cb calibration const register 32bit */ +#define MLX90632_EE_Da 0x2420 /**< Da calibration const register 32bit */ +#define MLX90632_EE_Db 0x2422 /**< Db calibration const register 32bit */ +#define MLX90632_EE_Ea 0x2424 /**< Ea calibration constant register 32bit */ +#define MLX90632_EE_Eb 0x2426 /**< Eb calibration constant register 32bit */ +#define MLX90632_EE_Fa 0x2428 /**< Fa calibration constant register 32bit */ +#define MLX90632_EE_Fb 0x242a /**< Fb calibration constant register 32bit */ +#define MLX90632_EE_Ga 0x242c /**< Ga calibration constant register 32bit */ +#define MLX90632_EE_Gb 0x242e /**< Ambient Beta calibration constant 16bit */ +#define MLX90632_EE_Ka 0x242f /**< IR Beta calibration constant 16bit */ +#define MLX90632_EE_Ha 0x2481 /**< Ha customer calibration value register 16bit */ +#define MLX90632_EE_Hb 0x2482 /**< Hb customer calibration value register 16bit */ + +#define MLX90632_EE_MEDICAL_MEAS1 0x24E1 /**< Medical measurement 1 16bit */ +#define MLX90632_EE_MEDICAL_MEAS2 0x24E2 /**< Medical measurement 2 16bit */ +#define MLX90632_EE_EXTENDED_MEAS1 0x24F1 /**< Extended measurement 1 16bit */ +#define MLX90632_EE_EXTENDED_MEAS2 0x24F2 /**< Extended measurement 2 16bit */ +#define MLX90632_EE_EXTENDED_MEAS3 0x24F3 /**< Extended measurement 3 16bit */ + +/* Refresh Rate */ +typedef enum mlx90632_meas_e { + MLX90632_MEAS_HZ_ERROR = -1, + MLX90632_MEAS_HZ_HALF = 0, + MLX90632_MEAS_HZ_1 = 1, + MLX90632_MEAS_HZ_2 = 2, + MLX90632_MEAS_HZ_4 = 3, + MLX90632_MEAS_HZ_8 = 4, + MLX90632_MEAS_HZ_16 = 5, + MLX90632_MEAS_HZ_32 = 6, + MLX90632_MEAS_HZ_64 = 7, +} mlx90632_meas_t; +#define MLX90632_EE_REFRESH_RATE_START 10 /**< Refresh Rate Start bit */ +#define MLX90632_EE_REFRESH_RATE_SHIFT 8 /**< Refresh Rate shift */ +#define MLX90632_EE_REFRESH_RATE_MASK GENMASK(MLX90632_EE_REFRESH_RATE_START, MLX90632_EE_REFRESH_RATE_SHIFT) /**< Refresh Rate Mask */ +#define MLX90632_EE_REFRESH_RATE(ee_val) (ee_val & MLX90632_EE_REFRESH_RATE_MASK) /**< Extract the Refresh Rate bits*/ +#define MLX90632_REFRESH_RATE(ee_val) (MLX90632_EE_REFRESH_RATE(ee_val) >> MLX90632_EE_REFRESH_RATE_SHIFT) /**< Extract Refresh Rate from ee register */ +#define MLX90632_REFRESH_RATE_STATUS(mlx90632_meas) (mlx90632_meas << MLX90632_EE_REFRESH_RATE_SHIFT) /**< Extract the Refresh Rate bits */ + +/* Register addresses - volatile */ +#define MLX90632_REG_I2C_ADDR 0x3000 /**< Chip I2C address register */ + +/* Control register address - volatile */ +#define MLX90632_REG_CTRL 0x3001 /**< Control Register address */ +#define MLX90632_CFG_SOC_SHIFT 3 /**< Start measurement in step mode */ +#define MLX90632_CFG_SOC_MASK BIT(MLX90632_CFG_SOC_SHIFT) +#define MLX90632_CFG_PWR_MASK GENMASK(2, 1) /**< PowerMode Mask */ +#define MLX90632_CFG_PWR(ctrl_val) (ctrl_val & MLX90632_CFG_PWR_MASK) /**< Extract the PowerMode bits*/ +#define MLX90632_CFG_MTYP_SHIFT 4 /**< Meas select start shift */ +#define MLX90632_CFG_MTYP_MASK GENMASK(8, MLX90632_CFG_MTYP_SHIFT) /**< Meas select Mask */ +#define MLX90632_CFG_MTYP(ctrl_val) (ctrl_val & MLX90632_CFG_MTYP_MASK) /**< Extract the MeasType bits*/ +#define MLX90632_CFG_SOB_SHIFT 11 /**< Start burst measurement in step mode */ +#define MLX90632_CFG_SOB_MASK BIT(MLX90632_CFG_SOB_SHIFT) +#define MLX90632_CFG_SOB(ctrl_val) (ctrl_val << MLX90632_CFG_SOB_SHIFT) + +/* PowerModes statuses */ +#define MLX90632_PWR_STATUS(ctrl_val) (ctrl_val << 1) +#define MLX90632_PWR_STATUS_HALT MLX90632_PWR_STATUS(0) /**< Pwrmode hold */ +#define MLX90632_PWR_STATUS_SLEEP_STEP MLX90632_PWR_STATUS(1) /**< Pwrmode sleep step*/ +#define MLX90632_PWR_STATUS_STEP MLX90632_PWR_STATUS(2) /**< Pwrmode step */ +#define MLX90632_PWR_STATUS_CONTINUOUS MLX90632_PWR_STATUS(3) /**< Pwrmode continuous*/ +/* Measurement type select*/ +#define MLX90632_MTYP_STATUS(ctrl_val) (ctrl_val << MLX90632_CFG_MTYP_SHIFT) +#define MLX90632_MTYP_STATUS_MEDICAL MLX90632_MTYP_STATUS(0) /**< Medical measurement type */ +#define MLX90632_MTYP_STATUS_EXTENDED MLX90632_MTYP_STATUS(17) /**< Extended measurement type*/ +#define MLX90632_MTYP(reg_val) (MLX90632_CFG_MTYP(reg_val) >> MLX90632_CFG_MTYP_SHIFT) /**< Extract MTYP from Control register */ +/* Start of burst measurement options */ +#define MLX90632_START_BURST_MEAS MLX90632_CFG_SOB(1) +#define MLX90632_BURST_MEAS_NOT_PENDING MLX90632_CFG_SOB(0) + +/* Device status register - volatile */ +#define MLX90632_REG_STATUS 0x3fff /**< Device status register */ +#define MLX90632_STAT_BUSY BIT(10) /**< Device busy indicator */ +#define MLX90632_STAT_EE_BUSY BIT(9) /**< Device EEPROM busy indicator */ +#define MLX90632_STAT_BRST BIT(8) /**< Device brown out reset indicator */ +#define MLX90632_STAT_CYCLE_POS GENMASK(6, 2) /**< Data position in measurement table */ +#define MLX90632_STAT_DATA_RDY BIT(0) /**< Data ready indicator */ + +/* RAM_MEAS address-es for each channel */ +#define MLX90632_RAM_1(meas_num) (MLX90632_ADDR_RAM + 3 * meas_num) +#define MLX90632_RAM_2(meas_num) (MLX90632_ADDR_RAM + 3 * meas_num + 1) +#define MLX90632_RAM_3(meas_num) (MLX90632_ADDR_RAM + 3 * meas_num + 2) + +/* Timings (ms) */ +#define MLX90632_TIMING_EEPROM 100 /**< Time between EEPROM writes */ + +/* Magic constants */ +#define MLX90632_DSPv5 0x05 /* EEPROM DSP version */ +#define MLX90632_EEPROM_VERSION MLX90632_ID_MEDICAL /**< Legacy define - to be deprecated */ +#define MLX90632_EEPROM_WRITE_KEY 0x554C /**< EEPROM write key 0x55 and 0x4c */ +#define MLX90632_RESET_CMD 0x0006 /**< Reset sensor (address or global) */ +#define MLX90632_MAX_MEAS_NUM 31 /**< Maximum number of measurements in list */ +#define MLX90632_EE_SEED 0x3f6d /**< Seed for the CRC calculations */ +#define MLX90632_REF_12 12.0 /**< ResCtrlRef value of Channel 1 or Channel 2 */ +#define MLX90632_REF_3 12.0 /**< ResCtrlRef value of Channel 3 */ +#define MLX90632_XTD_RNG_KEY 0x0500 /**Extended range support indication key */ + +/* Measurement types - the MSBit is for software purposes only and has no hardware bit related to it. It indicates continuous '0' or sleeping step burst - '1' measurement mode*/ +#define MLX90632_MTYP_MEDICAL 0x00 +#define MLX90632_MTYP_EXTENDED 0x11 +#define MLX90632_MTYP_MEDICAL_BURST 0x80 +#define MLX90632_MTYP_EXTENDED_BURST 0x91 +#define MLX90632_BURST_MEASUREMENT_TYPE(meas_type) (meas_type + 0x80) /**< The MSBit is only used in the software to indicate burst type measurement. The 5 LS Bits define medical or extended measurement and are used to set the hardware */ + +#define MLX90632_MEASUREMENT_TYPE_STATUS(mtyp_type) (mtyp_type & 0x7F) /**< Extract the measurement type from MTYP */ +#define MLX90632_MEASUREMENT_BURST_STATUS(mtyp_type) (mtyp_type & 0x80) /**< Extract the measurement burst/continuous type from MTYP */ + +#define MLX90632_MEAS_MAX_TIME 2000 /**< Maximum measurement time in ms for the lowest possible refresh rate */ +#define MLX90632_MAX_NUMBER_MESUREMENT_READ_TRIES 100 /**< Maximum number of read tries before quiting with timeout error */ + +/* Gets a new register value based on the old register value - only writing the value based on the desired bits + * Masks the old register and shifts the new value in + */ +#define MLX90632_NEW_REG_VALUE(old_reg, new_value, h, l) \ + ((old_reg & (0xFFFF ^ GENMASK(h, l))) | (new_value << MLX90632_EE_REFRESH_RATE_SHIFT)) + +/** Read raw ambient and object temperature + * + * Trigger and read raw ambient and object temperatures. This values still need + * to be pre-processed via @link mlx90632_preprocess_temp_ambient @endlink and @link + * mlx90632_preprocess_temp_object @endlink functions and then processed via @link + * mlx90632_calc_temp_ambient @endlink and @link mlx90632_calc_temp_object @endlink + * to retrieve values in milliCelsius + * + * @param[out] ambient_new_raw Pointer to where new raw ambient temperature is written + * @param[out] object_new_raw Pointer to where new raw object temperature is written + * @param[out] ambient_old_raw Pointer to where old raw ambient temperature is written + * @param[out] object_old_raw Pointer to where old raw object temperature is written + * + * @retval 0 Successfully read both temperatures + * @retval <0 Something went wrong. Check errno.h for more details + */ +int32_t mlx90632_read_temp_raw(int16_t *ambient_new_raw, int16_t *ambient_old_raw, + int16_t *object_new_raw, int16_t *object_old_raw); + +/** Read raw ambient and object temperature in sleeping step mode + * + * Trigger and read raw ambient and object temperatures. This values still need + * to be pre-processed via @link mlx90632_preprocess_temp_ambient @endlink and @link + * mlx90632_preprocess_temp_object @endlink functions and then processed via @link + * mlx90632_calc_temp_ambient @endlink and @link mlx90632_calc_temp_object @endlink + * to retrieve values in milliCelsius + * + * @param[out] ambient_new_raw Pointer to where new raw ambient temperature is written + * @param[out] object_new_raw Pointer to where new raw object temperature is written + * @param[out] ambient_old_raw Pointer to where old raw ambient temperature is written + * @param[out] object_old_raw Pointer to where old raw object temperature is written + * + * @retval 0 Successfully read both temperatures + * @retval <0 Something went wrong. Check errno.h for more details + */ +int32_t mlx90632_read_temp_raw_burst(int16_t *ambient_new_raw, int16_t *ambient_old_raw, + int16_t *object_new_raw, int16_t *object_old_raw); + +/** Calculation of raw ambient output + * + * Preprocessing of the raw ambient value + * + * @param[in] ambient_new_raw ambient temperature from @link MLX90632_RAM_3 @endlink. The meas_num 1 or 2 is + * determined by value in @link MLX90632_STAT_CYCLE_POS @endlink + * @param[in] ambient_old_raw ambient temperature from @link MLX90632_RAM_3 @endlink. The meas_num 1 or 2 is + * determined by value not in @link MLX90632_STAT_CYCLE_POS @endlink + * @param[in] Gb Register value on @link MLX90632_EE_Gb @endlink + * + * @return Calculated ambient raw output + */ +double mlx90632_preprocess_temp_ambient(int16_t ambient_new_raw, int16_t ambient_old_raw, int16_t Gb); + +/** Calculation of raw object output + * + * Preprocessing of the raw object value + * + * @param[in] object_new_raw object temperature from @link MLX90632_RAM_1 @endlink or @link MLX90632_RAM_2 @endlink. + * The meas_number 1 or 2 is determined by value in @link MLX90632_STAT_CYCLE_POS @endlink + * @param[in] object_old_raw object temperature from @link MLX90632_RAM_1 @endlink or @link MLX90632_RAM_2 @endlink. + * The meas_number 1 or 2 is determined by value not in @link MLX90632_STAT_CYCLE_POS @endlink + * @param[in] ambient_new_raw ambient temperature from @link MLX90632_RAM_3 @endlink. The meas_number 1 or 2 is + * determined by value in @link MLX90632_STAT_CYCLE_POS @endlink + * @param[in] ambient_old_raw ambient temperature from @link MLX90632_RAM_3 @endlink. The meas_number 1 or 2 is + * determined by value not in @link MLX90632_STAT_CYCLE_POS @endlink + * @param[in] Ka Register value on @link MLX90632_EE_Ka @endlink + * + * @return Calculated object raw output + */ +double mlx90632_preprocess_temp_object(int16_t object_new_raw, int16_t object_old_raw, + int16_t ambient_new_raw, int16_t ambient_old_raw, + int16_t Ka); + +/** Calculation of ambient temperature + * + * DSPv5 implementation of ambient temperature calculation + * + * @param[in] ambient_new_raw ambient temperature from @link MLX90632_RAM_3 @endlink. The channel 1 or 2 is + * determined by value in @link MLX90632_STAT_CYCLE_POS @endlink + * @param[in] ambient_old_raw ambient temperature from @link MLX90632_RAM_3 @endlink. The channel 1 or 2 is + * determined by value not in @link MLX90632_STAT_CYCLE_POS @endlink + * @param[in] P_T Register value on @link MLX90632_EE_P_T @endlink + * @param[in] P_R Register value on @link MLX90632_EE_P_R @endlink + * @param[in] P_G Register value on @link MLX90632_EE_P_G @endlink + * @param[in] P_O Register value on @link MLX90632_EE_P_O @endlink + * @param[in] Gb Register value on @link MLX90632_EE_Gb @endlink + * + * @return Calculated ambient temperature degrees Celsius + */ +double mlx90632_calc_temp_ambient(int16_t ambient_new_raw, int16_t ambient_old_raw, int32_t P_T, + int32_t P_R, int32_t P_G, int32_t P_O, int16_t Gb); + +/** Calculation of object temperature + * + * DSPv5 implementation of object temperature calculation with customer + * calibration data + * + * @param[in] object object temperature from @link mlx90632_preprocess_temp_object @endlink + * @param[in] ambient ambient temperature from @link mlx90632_preprocess_temp_ambient @endlink + * @param[in] Ea Register value on @link MLX90632_EE_Ea @endlink + * @param[in] Eb Register value on @link MLX90632_EE_Eb @endlink + * @param[in] Ga Register value on @link MLX90632_EE_Ga @endlink + * @param[in] Fb Register value on @link MLX90632_EE_Fb @endlink + * @param[in] Fa Register value on @link MLX90632_EE_Fa @endlink + * @param[in] Ha Register value on @link MLX90632_EE_Ha @endlink + * @param[in] Hb Register value on @link MLX90632_EE_Hb @endlink + * + * @note emissivity Value provided by user of the object emissivity + * using @link mlx90632_set_emissivity @endlink function. + * + * @return Calculated object temperature in milliCelsius + */ +double mlx90632_calc_temp_object(int32_t object, int32_t ambient, + int32_t Ea, int32_t Eb, int32_t Ga, int32_t Fa, int32_t Fb, + int16_t Ha, int16_t Hb); + +/** Calculation of object temperature when the environment temperature differs from the sensor temperature + * + * when the object has emissivity lower than 1 then it does not just emit InfraRed light, but also reflects it. + * That is why measurement of the ambient temperature around object is important to help calculating more precise object temperature. + * This function makes it possible to add object environment temperature and offset it with sensor's ambient temperature to calculate more precise + * object temperature. DSPv5 implementation of object temperature calculation with customer + * calibration data + * + * @param[in] object object temperature from @link mlx90632_preprocess_temp_object @endlink + * @param[in] ambient sensor ambient temperature from @link mlx90632_preprocess_temp_ambient @endlink + * @param[in] reflected reflected (environment) temperature from a sensor different than the MLX90632 or acquired by other means + * @param[in] Ea Register value on @link MLX90632_EE_Ea @endlink + * @param[in] Eb Register value on @link MLX90632_EE_Eb @endlink + * @param[in] Ga Register value on @link MLX90632_EE_Ga @endlink + * @param[in] Fb Register value on @link MLX90632_EE_Fb @endlink + * @param[in] Fa Register value on @link MLX90632_EE_Fa @endlink + * @param[in] Ha Register value on @link MLX90632_EE_Ha @endlink + * @param[in] Hb Register value on @link MLX90632_EE_Hb @endlink + * + * @note emissivity Value provided by user of the object emissivity + * using @link mlx90632_set_emissivity @endlink function. + * + * @return Calculated object temperature in milliCelsius + */ +double mlx90632_calc_temp_object_reflected(int32_t object, int32_t ambient, double reflected, + int32_t Ea, int32_t Eb, int32_t Ga, int32_t Fa, int32_t Fb, + int16_t Ha, int16_t Hb); + +/** Initialize MLX90632 driver and confirm EEPROM version + * + * EEPROM version is important to match sensor EEPROM content and calculations. + * This is why this function checks for correct EEPROM version before it does + * checksum validation of the EEPROM content. + * + * @note EEPROM version can have swapped high and low bytes due to CPU or I2C. + * Please confirm that i2c read (16bit) is functioning as expected. + * + * @retval 0 Successfully initialized MLX90632 driver, extended range measurement not supported + * @retval @link ERANGE @endlink Successfully initialized MLX90632 driver, extended range measurement is supported + * @retval <0 Something went wrong. Consult errno.h for more details. + */ +int32_t mlx90632_init(void); + +/** Trigger start measurement for mlx90632 + * + * Trigger measurement cycle and wait for data to be ready. It does not read anything, just triggers and completes. + * + * @retval <0 Something failed. Check errno.h for more information + * @retval >=0 Channel position where new (recently updated) measurement can be found + * + * @note This function is using usleep so it is blocking! + */ +int mlx90632_start_measurement(void); + +/** Set emissivity which is retained in single variable. + * + * @param[in] value Value provided by user of object emissivity. Defaults to 1.0 and cannot be 0.0. + * + * @warning This is not suitable for multi-process calculations as we do not use instances + */ +void mlx90632_set_emissivity(double value); + +/** Read value of emissivity + */ +double mlx90632_get_emissivity(void); + +/** Trigger start of burst measurement for mlx90632 + * + * Trigger a single measurement cycle and wait for data to be ready. It does not read anything, just triggers and completes. + * The SOB bit is set so that the complete measurement table is re-freshed. + * + * @note The SOB bit is cleared internally by the mlx90632 immediately after the measurement has started. + * + * @retval <0 Something failed. Check errno.h for more information + * @retval 0 New data is available and waiting to be processed + * + * @note This function is using usleep and msleep. Because of usleep it is blocking, while msleep implementation can have a thread switch! + * In case both are blocking expect up to 2 second freeze of CPU in worse case scenario (depending on Refresh rate setting), so + * you might also need to take care of Watch Dog. + */ +int32_t mlx90632_start_measurement_burst(void); + +/** Reads the refresh rate and calculates the time needed for a single measurment from the EEPROM settings. + * + * @param[in] meas Measurement to read the frefresh rate for + * + * @retval >=0 Refresh time in ms + * @retval <0 Something went wrong. Check errno.h for more details. + */ +int32_t mlx90632_get_measurement_time(uint16_t meas); + +/** Reads the refresh rate and calculates the time needed for a whole measurment table from the EEPROM settings. + * + * The function is returning valid measurement time only for burst mode measurements. + * An error will be returned if it is called with a continuous measurement type parameter. + * + * @retval >=0 Refresh time in ms + * @retval <0 Something went wrong. Check errno.h for more details. + */ +int32_t mlx90632_calculate_dataset_ready_time(void); + +/** Trigger system reset for mlx90632 + * + * Perform full reset of mlx90632 using reset command. + * It also waits for at least 150us to ensure the mlx90632 device is properly reset and ready for further communications. + * + * @retval <0 Something failed. Check errno.h for more information + * @retval 0 The mlx90632 device was properly reset and is now ready for communication. + * + * @note This function is using usleep so it is blocking! + */ +int32_t mlx90632_addressed_reset(void); + +/** Sets the refresh rate of the sensor using the MLX90632_EE_MEAS_1 and MLX90632_EE_MEAS_2 registers + * + * @param[in] measRate refresh rate to set with #mlx90632_meas_e + * + * @retval <0 Something went wrong. Consult errno.h for more details. + */ +int32_t mlx90632_set_refresh_rate(mlx90632_meas_t measRate); + +/** Gets the value in MLX90632_EE_MEAS_1 and converts it to the appropriate MLX90632_MEAS enum + * + * @retval MLX90632_MEAS_HZ_ERROR if there is an error + * @retval refresh_rate as the #mlx90632_meas_e + */ +mlx90632_meas_t mlx90632_get_refresh_rate(void); +int32_t mlx90632_get_meas_type(void); + +///@} + +#ifdef TEST +int32_t mlx90632_read_temp_ambient_raw(int16_t *ambient_new_raw, int16_t *ambient_old_raw); +int32_t mlx90632_read_temp_object_raw(int32_t start_measurement_ret, + int16_t *object_new_raw, int16_t *object_old_raw); + +#endif + +#endif diff --git a/src/src/mlx90632/u_mlx.cpp b/src/src/mlx90632/u_mlx.cpp new file mode 100644 index 0000000..a0896cb --- /dev/null +++ b/src/src/mlx90632/u_mlx.cpp @@ -0,0 +1,251 @@ +#include "u_mlx.h" + +Adafruit_I2CDevice *mlx = NULL; +static const char* TAG = "MLX"; +double mlx_emissivity = 1.0; + + + + + + + + +int32_t mlx_cali_PR = 0x00587f5b; +int32_t mlx_cali_PG = 0x04a10289; +int32_t mlx_cali_PT = 0xfff966f8; +int32_t mlx_cali_PO = 0x00001e0f; +int32_t mlx_cali_Ea = 4859535; +int32_t mlx_cali_Eb = 5686508; +int32_t mlx_cali_Fa = 53855361; +int32_t mlx_cali_Fb = 42874149; +int32_t mlx_cali_Ga = -14556410; +int16_t mlx_cali_Ha = 16384; +int16_t mlx_cali_Hb = 0; +int16_t mlx_cali_Gb = 9728; +int16_t mlx_cali_Ka = 10752; + + int32_t mlx90632_i2c_read(int16_t register_address, uint16_t *value){ + uint8_t addr[2] = {0, 0}; + uint8_t read_buff[2] = {0, 0}; + addr[0] = (uint8_t)(register_address >> 8); + addr[1] = (uint8_t)(register_address & 0x00FF); + mlx->write_then_read(addr, 2, read_buff, 2, false); + *value = 0; + *value += (read_buff[0] << 8); + *value += read_buff[1]; + return 0; + } + + int16_t mlx90632_i2c_read16(int16_t register_address){ + uint8_t addr[2] = {0, 0}; + uint8_t read_buff[2] = {0, 0}; + int16_t value = 0; + addr[0] = (uint8_t)(register_address >> 8); + addr[1] = (uint8_t)(register_address & 0x00FF); + mlx->write_then_read(addr, 2, read_buff, 2, false); + value = read_buff[1]; + value |=( (read_buff[0] << 8) & 0xFF00); + return value; + } + + + int32_t mlx90632_i2c_read32(int16_t register_address){ + uint8_t addr[2] = {0, 0}; + uint8_t readout[4] = {0, 0, 0, 0}; + int32_t value = 0; + uint16_t n1 = 0; + uint16_t n2 = 0; + addr[0] = (uint8_t)(register_address >> 8); + addr[1] = (uint8_t)(register_address & 0x00FF); + + mlx->write(addr, 2, false); + mlx->read(readout, 4); + + n1 += (readout[0] << 8); + n1 += (readout[1]); + + n2 += (readout[2] << 8); + n2 += (readout[3]); + value = n1; + value |= n2 << 16 & 0xFFFF0000; + return value; + } + + int32_t mlx90632_i2c_write(int16_t register_address, uint16_t value){ + uint8_t addr[4] = {0, 0, 0, 0}; + addr[0] = (uint8_t)(register_address >> 8); + addr[1] = (uint8_t)(register_address & 0x00FF); + addr[2] = (uint8_t)(value >> 8); + addr[3] = (uint8_t)(value & 0x00FF); + mlx->write(addr, 4); + return 0; + } + + +void usleep(int min_range, int max_range){ + delayMicroseconds(min_range); +} + +void msleep(int msecs){ + delay(msecs); +} + + + +bool mlx_init(void){ + ESP_LOGV(TAG, "MLX90632 initate"); + mlx = new Adafruit_I2CDevice(ADDR_I2C_MLX90632); + if (!mlx->begin()){ + ESP_LOGE(TAG, "MLX device not found on I2C bus"); + return false; + } + + if (mlx90632_init() < 0){ + ESP_LOGE(TAG, "MLX device communication failed"); + return false; + } + + mlx_cali_PR = mlx90632_i2c_read32(0x240C); + mlx_cali_PG = mlx90632_i2c_read32(0x240E); + mlx_cali_PT = mlx90632_i2c_read32(0x2410); + mlx_cali_PO = mlx90632_i2c_read32(0x2412); + mlx_cali_Ea = mlx90632_i2c_read32(0x2424); + mlx_cali_Eb = mlx90632_i2c_read32(0x2426); + mlx_cali_Fa = mlx90632_i2c_read32(0x2428); + mlx_cali_Fb = mlx90632_i2c_read32(0x242A); + mlx_cali_Ga = mlx90632_i2c_read32(0x242C); + mlx_cali_Gb = mlx90632_i2c_read16(0x242E); + mlx_cali_Ka = mlx90632_i2c_read16(0x242F); + mlx_cali_Ha = mlx90632_i2c_read16(0x2481); + mlx_cali_Hb = mlx90632_i2c_read16(0x2482); + mlx90632_set_refresh_rate(MLX90632_MEAS_HZ_16); + + mlx90632_set_emissivity(mlx_emissivity); + + ESP_LOGI(TAG, "MLX90632 initate OK"); + + return true; + +} + +double mlx_measure(double* object, double* ambient){ + + int32_t ret = 0; /**< Variable will store return values */ + // double ambient; /**< Ambient temperature in degrees Celsius */ + // double object; /**< Object temperature in degrees Celsius */ + int16_t ambient_new_raw = 120; + int16_t ambient_old_raw = 320; + int16_t object_new_raw = 3210; + int16_t object_old_raw = 1230; + + + ret = mlx90632_read_temp_raw(&ambient_new_raw, &ambient_old_raw, + &object_new_raw, &object_old_raw); + *ambient = mlx90632_calc_temp_ambient(ambient_new_raw, ambient_old_raw, mlx_cali_PT, mlx_cali_PR, mlx_cali_PG, mlx_cali_PO, mlx_cali_Gb); + double pre_ambient = mlx90632_preprocess_temp_ambient(ambient_new_raw, ambient_old_raw, mlx_cali_Gb); + double pre_object = mlx90632_preprocess_temp_object(object_new_raw, object_old_raw,ambient_new_raw, ambient_old_raw, mlx_cali_Ka); + *object = mlx90632_calc_temp_object(pre_object, pre_ambient, mlx_cali_Ea, mlx_cali_Eb, mlx_cali_Ga, mlx_cali_Fa, mlx_cali_Fb, mlx_cali_Ha, mlx_cali_Hb); + + //ESP_LOGI(TAG, "MLX90632 Run"); + return *object; +} + +double mlx_measure(){ + double object, ambient; + mlx_measure(&object, &ambient); + return object; +} + +double mlx_measure(double* obj, double* amb, double* obj_r, int16_t* a1, int16_t* a2, int16_t* a3, int16_t* a4){ + int32_t ret = 0; /**< Variable will store return values */ + // double ambient; /**< Ambient temperature in degrees Celsius */ + // double object; /**< Object temperature in degrees Celsius */ + int16_t ambient_new_raw = 120; + int16_t ambient_old_raw = 320; + int16_t object_new_raw = 3210; + int16_t object_old_raw = 1230; + double pre_ambient, pre_object, ambient, object, obj2; + + ret = mlx90632_read_temp_raw(&ambient_new_raw, &ambient_old_raw, &object_new_raw, &object_old_raw); + pre_ambient = mlx90632_preprocess_temp_ambient(ambient_new_raw, ambient_old_raw, mlx_cali_Gb); /// AMB + pre_object = mlx90632_preprocess_temp_object(object_new_raw, object_old_raw,ambient_new_raw, ambient_old_raw, mlx_cali_Ka); /// ST0 + ambient = mlx90632_calc_temp_ambient(ambient_new_raw, ambient_old_raw, mlx_cali_PT, mlx_cali_PR, mlx_cali_PG, mlx_cali_PO, mlx_cali_Gb); // Ta + object = mlx90632_calc_temp_object(pre_object, pre_ambient, mlx_cali_Ea, mlx_cali_Eb, mlx_cali_Ga, mlx_cali_Fa, mlx_cali_Fb, mlx_cali_Ha, mlx_cali_Hb); + obj2 = mlx90632_calc_temp_object_reflected(pre_object, pre_ambient, ambient, mlx_cali_Ea, mlx_cali_Eb, mlx_cali_Ga, mlx_cali_Fa, mlx_cali_Fb, mlx_cali_Ha, mlx_cali_Hb); + + *obj = object; + *amb = ambient; + *obj_r = obj2; + *a1 = ambient_new_raw; + *a2 = ambient_old_raw; + *a3 = object_new_raw; + *a4 = object_old_raw; + return obj2; +} + + +void mlx_print_paras(double e){ + + // Serial.printf("%d,%d,%d,%d,%d,%d,%d,%d\n",mlx_cali_PR,mlx_cali_PG,mlx_cali_PT,mlx_cali_PO,mlx_cali_Ea,mlx_cali_Eb,mlx_cali_Fa,mlx_cali_Fb); + // Serial.printf("%d,%d,%d,%d,%d\n",mlx_cali_Ga,mlx_cali_Ha,mlx_cali_Hb,mlx_cali_Gb,mlx_cali_Ka); + + int32_t ret = 0; /**< Variable will store return values */ + // double ambient; /**< Ambient temperature in degrees Celsius */ + // double object; /**< Object temperature in degrees Celsius */ + int16_t ambient_new_raw = 120; + int16_t ambient_old_raw = 320; + int16_t object_new_raw = 3210; + int16_t object_old_raw = 1230; + + double pre_ambient, pre_object, ambient, object, obj2; + mlx90632_set_emissivity(e); + + + + unsigned int timer = millis(); + while (millis() - timer < 25000){ + ret = mlx90632_read_temp_raw(&ambient_new_raw, &ambient_old_raw, &object_new_raw, &object_old_raw); + pre_ambient = mlx90632_preprocess_temp_ambient(ambient_new_raw, ambient_old_raw, mlx_cali_Gb); /// AMB + pre_object = mlx90632_preprocess_temp_object(object_new_raw, object_old_raw,ambient_new_raw, ambient_old_raw, mlx_cali_Ka); /// ST0 + ambient = mlx90632_calc_temp_ambient(ambient_new_raw, ambient_old_raw, mlx_cali_PT, mlx_cali_PR, mlx_cali_PG, mlx_cali_PO, mlx_cali_Gb); // Ta + object = mlx90632_calc_temp_object(pre_object, pre_ambient, mlx_cali_Ea, mlx_cali_Eb, mlx_cali_Ga, mlx_cali_Fa, mlx_cali_Fb, mlx_cali_Ha, mlx_cali_Hb); + obj2 = mlx90632_calc_temp_object_reflected(pre_object, pre_ambient, ambient, mlx_cali_Ea, mlx_cali_Eb, mlx_cali_Ga, mlx_cali_Fa, mlx_cali_Fb, mlx_cali_Ha, mlx_cali_Hb); + + + Serial.printf("%d,%d,%d,%d,%f,%f,%f,%f\n",ambient_new_raw,ambient_old_raw,object_new_raw,object_old_raw, pre_ambient, ambient, object,obj2); + } + + //ret = mlx90632_read_temp_raw(&ambient_new_raw, &ambient_old_raw, &object_new_raw, &object_old_raw); + + + //Serial.printf("%d,%d,%d,%d,%d\n",ambient_new_raw,ambient_old_raw,object_new_raw,object_old_raw); + + // double object, ambient; + // mlx_measure(&object, &ambient); + + // Serial.printf("%f, %f\n", object, ambient); + +} + + +void mlx_read_coe(int32_t* arr){ + arr[0] = mlx_cali_PR; + arr[1] = mlx_cali_PG; + arr[2] = mlx_cali_PT; + arr[3] = mlx_cali_PO; + arr[4] = mlx_cali_Ea; + arr[5] = mlx_cali_Eb; + arr[6] = mlx_cali_Fa; + arr[7] = mlx_cali_Fb; + arr[8] = mlx_cali_Ga; + arr[9] = mlx_cali_Ha; + arr[10] = mlx_cali_Hb; + arr[11] = mlx_cali_Gb; + arr[12] = mlx_cali_Ka; + arr[13] = 0; + for (uint8_t i = 0; i < 13; i++){ + arr[13] += arr[i]; + } + return; +} \ No newline at end of file diff --git a/src/src/mlx90632/u_mlx.h b/src/src/mlx90632/u_mlx.h new file mode 100644 index 0000000..72cd20b --- /dev/null +++ b/src/src/mlx90632/u_mlx.h @@ -0,0 +1,30 @@ +#ifndef __u_MLX_H_ +#define __u_MLX_H_ + +#include +#include +#include "../pin_config.h" +#include "mlx_dev.h" + +int32_t mlx90632_i2c_read(int16_t register_address, uint16_t *value); +int16_t mlx90632_i2c_read16(int16_t register_address); +int32_t mlx90632_i2c_read32(int16_t register_address); +int32_t mlx90632_i2c_write(int16_t register_address, uint16_t value); +extern bool FLAG_DEICE; + +void usleep(int min_range, int max_range); +void msleep(int msecs); + + +bool mlx_init(void); +double mlx_measure(double* object, double* ambient); +double mlx_measure(double* object, double* ambient, double* reflect_obj, int16_t* a1, int16_t* a2, int16_t* a3, int16_t* a4); +double mlx_measure(); + +void mlx_print_paras(double e); +void mlx_read_coe(int32_t*); + + + + +#endif \ No newline at end of file diff --git a/src/src/pin_config.h b/src/src/pin_config.h new file mode 100644 index 0000000..c205564 --- /dev/null +++ b/src/src/pin_config.h @@ -0,0 +1,18 @@ +#ifndef __PINCONFIG_H__ +#define __PINCONFIG_H__ +#include + + +#define I2C_SCL 4 +#define I2C_SDA 3 + +#define ADPD_SPI_SCK 6 +#define ADPD_SPI_MISO 7 +#define ADPD_SPI_MOSI 5 +#define ADPD1_CS 8 + +#define ADDR_I2C_AS7341 (0x39) +#define ADDR_I2C_MLX90632 (0x3A) + + +#endif \ No newline at end of file diff --git a/src/upload.bat b/src/upload.bat new file mode 100644 index 0000000..53024a8 --- /dev/null +++ b/src/upload.bat @@ -0,0 +1 @@ +..\esptool.exe --chip esp32c3 --port "COM10" --baud 921600 --before default_reset --after hard_reset write_flash -z --flash_mode keep --flash_freq keep --flash_size keep 0x0 "../tmp/ambit-1.ino.bootloader.bin" 0x8000 "../tmp/ambit-1.ino.partitions.bin" 0xe000 "%localappdata%/Arduino15\packages\esp32\hardware\esp32\3.1.1/tools/partitions/boot_app0.bin" 0x10000 "../tmp/ambit-1.ino.bin" \ No newline at end of file diff --git a/src/uploader.py b/src/uploader.py new file mode 100644 index 0000000..8f232ed --- /dev/null +++ b/src/uploader.py @@ -0,0 +1,101 @@ +import serial +import serial.tools.list_ports +import subprocess, os +import sys +import time + + + +def serial_ports(): + ports = serial.tools.list_ports.comports() + Flasherport = [] + for port, desc, hwid in sorted(ports): + if hwid[:4] == "USB ": + devices = hwid[4:].split(" ") + if len(devices) > 1 and len(devices[0]) > 9: + if devices[0][-9:] == "1A86:55D4": + Flasherport.append(port) + + return Flasherport + + + +if __name__ == '__main__': + + files = os.listdir("../tmp/") + if not 'ambit-1.ino.bin' in files: + print("FW NOT found") + sys.exit() + if not 'ambit-1.ino.bootloader.bin' in files: + print("Bootloader NOT found") + sys.exit() + + if not 'ambit-1.ino.partitions.bin' in files: + print("Partitions NOT found") + sys.exit() + + if not 'boot_app0.bin' in files: + print("Boot app NOT found") + sys.exit() + + if not 'esptool.exe' in files: + print("esptool NOT found") + sys.exit() + + ports = serial_ports() + if len(ports) == 1: + port = ports[0] + else: + print("more than one flasher found") + sys.exit() + + + + while True: + flash_new_ambit = False + + with serial.Serial(port, 115200) as ser: + t0 = time.time() + s = "" + counter = 0 + while time.time() - t0 < 5: + while (ser.in_waiting > 0) and (counter < 300): + c = ser.read() + if c > bytes([9]) and c < bytes([127]): + counter += 1 + s += c.decode() + + if (counter > 20): + if "invalid header" in s: + flash_new_ambit = True + break + else: + if c.isascii(): + print(c.decode(), end="") + if (counter >= 49): break + if flash_new_ambit: break + time.sleep(.25) + print(".", end="") + + if flash_new_ambit: + subprocess.call('../tmp/esptool.exe --chip esp32c3 --baud 921600 --port "' + port + '" --before default_reset --after hard_reset write_flash -z --flash_mode keep --flash_freq keep --flash_size keep 0x0 "../tmp/ambit-1.ino.bootloader.bin" 0x8000 "../tmp/ambit-1.ino.partitions.bin" 0xe000 "../tmp/boot_app0.bin" 0x10000 "../tmp/ambit-1.ino.bin" ') + #print("Flash") + + + + + while False: + print(f'Upload to {port}:\t Y/N') + c = input() + if c in ["y", "Y"] or c == "": + print("upload") + + subprocess.call('../tmp/esptool.exe --chip esp32c3 --baud 921600 --port "' + port + '" --before default_reset --after hard_reset write_flash -z --flash_mode keep --flash_freq keep --flash_size keep 0x0 "../tmp/ambit-1.ino.bootloader.bin" 0x8000 "../tmp/ambit-1.ino.partitions.bin" 0xe000 "../tmp/boot_app0.bin" 0x10000 "../tmp/ambit-1.ino.bin" ') + + + else: + print("skip") + sys.exit() + + + diff --git a/test/README b/test/README new file mode 100644 index 0000000..9b1e87b --- /dev/null +++ b/test/README @@ -0,0 +1,11 @@ + +This directory is intended for PlatformIO Test Runner and project tests. + +Unit Testing is a software testing method by which individual units of +source code, sets of one or more MCU program modules together with associated +control data, usage procedures, and operating procedures, are tested to +determine whether they are fit for use. Unit testing finds problems early +in the development cycle. + +More information about PlatformIO Unit Testing: +- https://docs.platformio.org/en/latest/advanced/unit-testing/index.html From 41e7df3b775751ada5136680704ddfd698a71cab Mon Sep 17 00:00:00 2001 From: Ludo-lab Date: Wed, 17 Jun 2026 14:49:23 +0200 Subject: [PATCH 02/37] first commit --- .gitignore | 1 + HW_CONFORMANCE.md | 164 ----------- MERGE_PLAN.md | 615 ----------------------------------------- src/frontend_cloud.cpp | 23 ++ 4 files changed, 24 insertions(+), 779 deletions(-) delete mode 100644 HW_CONFORMANCE.md delete mode 100644 MERGE_PLAN.md diff --git a/.gitignore b/.gitignore index 89cc49c..db04e5f 100644 --- a/.gitignore +++ b/.gitignore @@ -3,3 +3,4 @@ .vscode/c_cpp_properties.json .vscode/launch.json .vscode/ipch +.plans/ \ No newline at end of file diff --git a/HW_CONFORMANCE.md b/HW_CONFORMANCE.md deleted file mode 100644 index 6496395..0000000 --- a/HW_CONFORMANCE.md +++ /dev/null @@ -1,164 +0,0 @@ -# amBIT HW Conformance Test — Step 4b (binary frontend → core) - -**Status: PASSED 2026-06-05.** Step 4b's binary path is HW-verified byte-conformant -against a real ambyte; the dirty-mark change (§4) was accepted. Keep this procedure as the -**reusable conformance gate** for any future change touching `run_esp.cpp` or the -`data_utils.cpp` FSM (Step 5 onward) — re-run it after each such change. - -It is the verification gate for the binary/ambyte wire contract (MERGE_PLAN §2, §13). - ---- - -## 0. What Step 4b changed (what's at risk) - -`run_esp.cpp` cmd `1/2/10/20/21` now call shared `core_*` functions instead of inline -logic. The intent is **zero change on the wire**: - -- Every `Serial.write(ESP_CMD_DONE/END)` and `Serial.readBytes(...)` is byte-for-byte - unchanged; only the internal config/run calls were factored out. -- Wire normalization still lives in the adapter: gains 1-indexed (1..6, stored −1), - current byte `≥127` = "no change", MPF length base-128 (`cmd[1]<<7 | cmd[2]`). - -**One intentional internal change** (not a wire change): binary `set_gains`/`set_currents` -(cmd 1/2) now mark the config *dirty* (they didn't before). Consequences: -- Normal flow `cmd1 → cmd2 → cmd10 → cmd21`: **identical** (cmd 10 re-applies config - regardless of the dirty flag). -- Degenerate flow `set gains/currents → cmd21 without cmd10`: now correctly re-applies - the just-set values (previously could run with stale config). This is the only - observable behavioural delta, and it is a fix — confirm no ambyte workflow relied on - the old stale-config behaviour. - ---- - -## 1. Setup - -- **DUT:** an amBIT flashed with the current `fw_new` (post-Step-4b): - ``` - cd fw_new - "$HOME/.platformio/penv/Scripts/pio.exe" run -t upload # add -t upload to flash - ``` -- **Host (one of):** - - **A real ambyte** (preferred) on the FFC/UART0 link, driving the amBIT via its - `device.ambit_*` Lua commands / CLI (`ambit_*`). This exercises the genuine binary - protocol end-to-end. - - **A logic analyzer / UART sniffer** on the FFC TX & RX (115200 8N1) to capture raw - bytes for the strict byte-diff (Test A). Best combined with the ambyte. -- **Reference build (for the strict diff):** a pre-Step-4 amBIT image — e.g. `git stash` - the working tree, or check out the commit before `core.{h,cpp}` was added, build, and - keep `firmware.bin` aside as `firmware_preStep4.bin`. - ---- - -## 2. Test A — byte-level framing conformance (gold standard) - -Goal: the **protocol framing** is identical pre- vs post-Step-4b. (Measurement *payload* -values vary run-to-run with sensor noise — only the framing/lengths/checksum validity are -deterministic; do not expect data bytes to match.) - -1. Flash `firmware_preStep4.bin`. With the sniffer capturing, drive the standard sequence - from the ambyte (see §3 for the sequence). Save the trace as `pre.bin`. -2. Flash the post-Step-4b image. Repeat the **identical** host sequence. Save `post.bin`. -3. Compare. For each command, the following must match exactly: - -| Command | Deterministic bytes that MUST match | -|---|---| -| wake | host `0xAA 0xAA 0xAA` → amBIT `0x80` | -| set_gains (1) | frame `0xA0`+8B cmd → `0xA1` (CMD_DONE). No data. | -| set_currents (2) | frame → `0xA1` | -| config (10) | frame → `0xA1` | -| get_spec (31) | `0xA1` + **24 B** + `0xF0` | -| get_temp (32) | `0xA1` + **4 B** + `0xF0` | -| get_info (33,2) | `0xA1` + **`sizeof(ambit_fw_info_t)` B** + `0xF0` | -| get_temp_raw (34) | `0xA1` + **14 B** + `0xF0` | -| run (21) / mpf (20) | `0xA1` … FSM arrays (`0xD3` wake, `0xD2` ack, `0xD4 0x96` len-hdr w/ checksum byte, data, `0xD4 .. checksum`, `0xB4` pass) … `0xF0`. **Array count, each array length, header checksum, and data byte-sum checksum must verify.** Data values may differ. | - -**Pass:** all framing/handshake/length/checksum bytes identical; only measurement payload -values differ. **Fail:** any framing byte, length field, command-ID echo, or checksum -*scheme* differs → a contract break; do not ship, diff the offending command. - -> If no sniffer is available, Test A reduces to "the ambyte completes every command in §3 -> with no timeout / no `checksum mismatch` / no `CMD_DONE not received` log" — a weaker but -> still useful gate (`uart_sensors.c` logs all three on failure). - ---- - -## 3. Test B — functional regression (per MERGE_PLAN §14) - -Drive each command class from the ambyte and confirm it completes and the numbers are -sane. Minimum sequence: - -- [ ] **wake / ping** — amBIT acks `0x80`; ambyte marks channel CONNECTED. -- [ ] **set_gains (cmd 1)** then **set_currents (cmd 2)** — each returns `CMD_DONE`. -- [ ] **config (cmd 10)** — `CMD_DONE`. -- [ ] **run (cmd 21)** with a small array — FSM round-trip completes, **all array - checksums pass**, array count = expected (env, fluor, fluoref, sun, leaf, 730, - 730ref), values in a plausible range. -- [ ] **run_mpf (cmd 20)** — completes; length decodes correctly (test a length >127 to - exercise the base-128 split, e.g. 200 → `cmd[1]=1, cmd[2]=72`). -- [ ] **get_spec (cmd 31)** / **get_temp (cmd 32)** / **get_temp_raw (cmd 34)** — correct - byte counts (24 / 4 / 14), values sane (temp ≈ ambient °C). -- [ ] **get_info (cmd 33)** subtypes 1/2/3 — struct sizes match `ambit_protocol.h` - (calibration ~136 B, fw_info ~48 B, metadata ~248 B). -- [ ] **baseline (cmd 6)**, **blink (cmd 5)**, **actinic (cmd 4)** — complete without error. -- [ ] **set_metadata (cmd 37)** with `eof_mark = 2025` — accepted and persisted. - -**Compare measurement values** from cmd 21/20 against the pre-Step-4 reference build on the -same target/sample: they should match within sensor noise (Step 4b does not change the -measurement math). - ---- - -## 4. Test C — the dirty-mark behavioural delta (the only intended change) - -Run this exact non-standard sequence **without a cmd 10 between set and run**: - -1. `cmd 10` (config) then `cmd 21` (run) with gains G1 — note the values. -2. `cmd 1` (set gains to a clearly different G2) **then `cmd 21` directly** (no cmd 10). - -- **Pre-Step-4b:** the run in step 2 used **G1** (stale — the bug). -- **Post-Step-4b:** the run in step 2 uses **G2** (re-applied — the fix). - -**Expected pass:** step-2 readings reflect G2. If any ambyte workflow *depended* on the old -stale-config behaviour, flag it — the dirty-mark can be removed from `core_set_gains` / -`core_set_currents` (drop the `adpd_mode = MPF_MODE` line) to restore the exact old binary -behaviour, at the cost of re-diverging from the text path. - ---- - -## 5. Result handling - -- **All pass** → mark Step 4b verified: update memory `merge-plan-ambit` ("4b verified on - HW ") and tick MERGE_PLAN §14's ambyte rows. -- **Framing diff (Test A fail)** → contract break; capture the offending command's pre/post - bytes and fix the adapter so the wire matches. -- **Test C unwanted** → remove the dirty-mark as noted in §4. - -This same harness (Tests A/B) is the reusable conformance gate for any future change that -touches `run_esp.cpp` or `data_utils.cpp`'s FSM (Step 5 onward). - ---- - -## 6. Re-verification log (changes that require re-running this gate) - -| Date | Change | Re-run | Status | -|------|--------|--------|--------| -| 2026-06-05 | Step 4b — binary frontend → core (`run_esp.cpp` cmd 1/2/10/20/21) | A + B + C | ✅ PASSED (incl. run(21)/mpf(20) FSM round-trip) | -| 2026-06-05 | Sweep #4 inc 1 — extracted `pam_send_results` from `run_arr_type1`; verbatim relocation of the `fsm_send_esp`/`send_serial` calls | A + B | ✅ PASSED — AMBYTE: run(21) = 5 arrays (idx0 len1 ENV + idx1-4 len30; 730/730ref correctly absent for no-IR), mpf(20) = 7 arrays. (COMPUTER `arrun` half is the same function's other branch — optional spot-check.) | -| 2026-06-05 | **#16 fix** — `serial_read_until`/`flush_serial` no longer echo non-target bytes (the echo injected the ambyte's 2nd `200` as ASCII `'2''0''0'` into the FSM **data phase** → checksum mismatch every run). **Not** a checksum-scheme bug: the amBIT byte-sums correctly (`u32_byte_sum`, data_utils.cpp:200/201/210, via `fsm_send_data`:432). | A + B | ✅ PASSED — array checksums clean, run/mpf complete | -| 2026-06-05 | Sweep #4 inc 2 — routed `run_trigger_spacer` (the mpf / cmd-20 path) through `pam_send_results` (`subsampling=1, has_730=true` → unconditional 7 channels; AMBYTE branch identical to the former inline block, COMPUTER branch inert as this path is never COMPUTER). `MPF` (2-channel idx 0/1), `external_trigger_run`/`_Flash`/`fluor_offset` (no FSM send) don't share this block. | B — the `mpf(20)` row of the Lua | ✅ PASSED — mpf(20) = 7 arrays, no checksum errors | -| 2026-06-05 | Cheap correctness sweep — **#10** init the comma-decl locals in `run_arr_type1`/`run_trigger_spacer`/`fluor_offset` (defensive; each was already assigned before use); **#8** `w`-length `uint8_t`→`uint16_t` + drop pointless `(uint16_t)` casts; **#9** delete 2 uncalled FSM fns (`fsm_wake_up_calls(void)`, `fsm_send_waitesp` — the latter had missing-return UB). | #10 → A+B (measurement path, behavior-neutral, very low risk). #8 text path (`w` over USB), #9 dead-code → no ambyte HW. | ☐ #10 prudent Lua re-run; #8/#9 done | -| 2026-06-08 | **Wire v2 (ambyte variant)** — (1) self-describing length header: the 2 spare bytes now carry `elem_width` (2\|4) + `dtype` (0 unsigned\|1 signed); csum formula unchanged (sum of bytes [0..6], now covers the new bytes); host defaults 4/0 when a byte is 0, so v1 still decodes. (2) ADC channels (Fluo/Fluoref/Sun/Leaf/730/730ref) sent as **uint16** (elem_width 2, dtype 0, each clamped to 0xFFFF); ENV as **int16** centi-°C (elem_width 2, dtype 1). Data-trailer csum = byte-sum of exactly the bytes sent. (3) new **TIMING** block idx 7 = `uint32[tick_begin, tick_end]` (µs from `esp_timer_get_time()`), emitted in `pam_send_results`. (4) **one wake per run**: `data_utils.cpp` FSM split into free `ambyte_wake()` + `dataclass::fsm_send_array(idx,elem_width,dtype)`; `pam_send_results` wakes once then streams each array back-to-back; host loops on the 212 marker, stops at the run's trailing 240. `fsm_send_esp` kept as a legacy wake+one-array(4/0) wrapper (MPF path). Host (ambyte) side updated to match. Both `pio run -e ambyte` and `-e cloud` build clean. | A + B | ☐ pending HW — one wake yields ENV(int16×N), Fluo/Fluoref/Sun/Leaf/730/730ref(uint16×N), TIMING(uint32×2), then 240; every header csum + data byte-sum must verify and each block decodes per `elem_width`/`dtype` | - -**Focused check for sweep-#4 inc 1** (the send block is shared by both transports, so verify -both halves): - -- **AMBYTE path** — drive a `run` (cmd 21) and an `mpf` (cmd 20) from the ambyte: the FSM - round-trip (array count, each array length, header + byte-sum checksums) must be identical - to the pre-change build; measurement values within sensor noise. -- **COMPUTER path** — drive `arrun` over the USB/text console: the 7 ASCII blocks - (`Data:ENV…`, `Fluo`, `Fluoref`, `SUN`, `leaf`, `730`, `730ref`) followed by `Data sent` - must be byte-identical to pre-change (this exercises the `send_serial` half). - -Passing both confirms the extracted `pam_send_results` reproduces the inline block exactly. -The next sweep-#4 increments (`PamBuffers` RAII / `#11` leak fix, then `read_one_frame`) -each get their own row here and must re-run A + B before being trusted. diff --git a/MERGE_PLAN.md b/MERGE_PLAN.md deleted file mode 100644 index 32c9c6e..0000000 --- a/MERGE_PLAN.md +++ /dev/null @@ -1,615 +0,0 @@ -# Ambit Firmware Merge Plan (v2) — built around dialect + config unification - -Collapse the two diverged Ambit ESP32-C3 forks into **one** source tree that builds -both product variants from one codebase: - -- **`ambyte`** variant — binary FSM protocol over UART0/FFC, idle light-sleep, the - field/companion-board use case (today = `fw_new`, was `ambitPIO`). -- **`cloud`/`usb`** variant — text + JSON over native USB-CDC, feeds the OpenJII - platform / phone app (today = `fw_appCompatible`, was `openJII`). - -Sources: -- `T` = **`fw_new`** (ambyte/binary line, this repo) — the **trunk**. -- `A` = **`fw_appCompatible`** (cloud/JSON line) — a *capability fork*: it added the - JSON/line frontend but **deleted** the binary frontend, Wrench, and power - management. Donor of the text/USB frontend only. -- `H` = **`ambyte-iot-ludo`** (the datalogger) — **not** ambit FW. It is the - *authoritative spec* of the binary wire contract ([uart_sensors.c], [ambit_protocol.h]). - Treated here as the frozen reference, never modified. - -Back-compat of the **text** path is not a constraint; the **binary** path is a frozen -wire contract (§2). Git holds history. Reviewed 2026-06-05. - ---- - -## 0. Revision history - -### v3 (current) — openJII comms layer - -- **Core returns typed data, not a JSON tree.** The shared core is JSON-free; the JSON - tree is built only in the app-side (cloud) adapter, so the `ambyte`/binary image links - no JSON (§5, §7c). -- **The openJII text/JSON layer is a device-agnostic shared module** (§7d), built **fresh** - to [CommunicationProtocolOpenJIISerial.md] — CO2Dot is the doc's named reference but is - too old to lift (D5). -- **Envelope `set` is flat** (one element per executed command/repeat). **Snapshot → - tree; measurement → one streamed JSON value** per `set` position (D6). -- **Comms-layer workflow:** implement to the spec doc → HW-test against the real app (the - oracle) → revise the spec doc. The binary path is *not* iterated this way — it's frozen. - -### v2 — unification spine - -This revision is built around the **command-dialect + config unification** as the -headline task, not as one step among many. Specifically: - -- **D1 (Wrench): DELETE, not gate.** Tracing shows Wrench is reachable from exactly - one text-console entry point and exposes zero unique commands (§8). It goes away - entirely, behind a single stakeholder check. -- **The spine is now: one CORE + one CONFIG + three thin transport adapters** (§4–§7). - Every other task (JSON re-graft, PAM sink merge, framing fix, power mgmt) hangs off - that spine. -- **Constraint (c) is promoted to its own section (§2)** with an explicit, verified - list of frozen wire elements and a conformance gate, because the deployed ambyte - (`H`) already pins several of them — including the data checksum, which makes - `fw_new`'s "checksum fix" **mandatory for compatibility**, not optional. - ---- - -## Where we are — 2026-06-05 (resume here) - -Two build variants from one tree (`platformio.ini`): **`ambyte`** (binary FSM over -UART0/FFC, HW-verified field path) and **`cloud`** (openJII LINE+JSON over UART0 — the -test HW has no USB-C; the native-USB-CDC flags are kept in a comment for a future PCB). - -**Done + HW-verified** (commits through `51a7ffc`): -- Wrench deleted; the 3 config copies unified; transport-agnostic CORE (`core.*`); text + - binary frontends thin over it; `pam_send_results` shared; echo (#16) fixed; nvs checksum - (#6); dead-code purge (#3); cheap correctness (#8/#9/#10). Binary path byte-conformant vs - a real ambyte (`HW_CONFORMANCE.md`). -- **openJII module `lib/openjii_proto/`** (device-agnostic): first-byte mode detect, LINE - (bare scalar / JSON container + dot-path + `keys()`), JSON envelope (flat `set` + frame - token), §9 errors, receiver. Snapshot API `on()` + stream/measurement API `on_stream()`. -- **Cloud variant** (`src/frontend_cloud.cpp`): snapshots hello/temp/get_par/PAR (verified) - and **`arrun` measurement-in-envelope** (verified — runs `run_arr_type1`'s new - `json_output` path, emits `{"ENV":[..],"Fluo":[..],"Fluoref":[..],"SUN":[..],"leaf":[..]}`). - ENV channels byte-identical to fork A's `send_json`; ENV decoded from fw_new centi-°C. - -**Next (pick up here):** -1. **Expand command coverage.** Snapshots: `set_currents`/`set_gains`/`set_pd_gain`/`baseline`/ - `battery`/`set_act`/`set_name`/`set_emit`/`set_spec`/`clean_nvs`/`reboot`/`check` — each a - one `on()` tree-builder calling the CORE. Measurements: `q`/`w`/`mpf`/`ww`/`ff` — give - `run_trigger_spacer` (and `MPF`) the same `json_output` sink `run_arr_type1` has, register - via `on_stream`. -2. **Confirm formats against the app (D6/D2).** ENV is `{"temp_c":<°C>}` per point now (fork A - had `{"t_ms":..,"temp_c":..}` + step marks, dropped in fw_new). Adjust `send_env_json` if the - app needs the old shape. Check ArduinoJson float precision (trims trailing zeros vs the - spec's fixed 4 dp) is tolerated. -3. **Test the rest of LINE mode on HW:** dot-path queries, `keys()`, the error taxonomy. -4. **Open decisions:** D2/D3 (env centi-°C + ambient — consumer sign-off), D6 (measurement - shape — partly resolved by the working `arrun`). - ---- - -## 1. Headline: the disease and the cure - -**Disease.** The same ~25 logical operations are implemented as **four parallel -command parsers**, each with its own argument decoding *and* its own copy of the -device config: - -| Parser | File | Config it mutates | -|---|---|---| -| text/computer | [do_command.h] `hash()` switch | global `adpd_*_config` | -| binary/ambyte | [run_esp.cpp] `cmd_arr[0]` switch | `adpd_*_config_local` (file-static) | -| Wrench bridge | `do_c.cpp` native fns | `do_c.cpp` statics (3rd copy) | -| JSON/line (fork `A`) | [commands.cpp] `startsWith` chain | global `adpd_*_config` | - -Adding one command means editing up to four places; the same setting lives in three -structs that can silently diverge (set currents via text, run via binary → different -values applied). **This duplication is the root cause of the forks themselves.** - -**Cure.** Split every operation into: - -``` - wire bytes ─► [thin transport adapter] ─► normalized args ─► CORE op ─► result ─► [sink] - │ │ - (decodes that transport's one implementation, - own wire convention) one CONFIG struct -``` - -- **One CORE** ([core.cpp]): one function per logical operation, taking *normalized* - typed args and writing to a *sink*, never touching `Serial`/`printf` directly (§5). -- **One CONFIG** ([config.h]): a single `AmbitConfig` struct every path reads/writes (§6). -- **Three thin adapters**: binary (frozen wire), text-line, JSON (§7). Each adapter's - only job is wire⇄normalized-args translation + choosing the sink. No measurement or - config logic lives in an adapter. - -Note the realistic scope: because the binary wire is frozen (§2), we **do not** merge -the three *parsers* into one parser. We collapse the three *cores* and three *configs* -into one each, and make all three parsers thin shims over them. That is the achievable, -high-value unification. - ---- - -## 2. The frozen binary contract (constraint c) - -The binary path is a wire contract with **shipped ambyte firmware** (`H`). The contract -is defined by what [uart_sensors.c] / [ambit_protocol.h] already implement. Refactor -*behind* it freely; do **not** change the bytes. De-obscuring is allowed only on the -text/USB path. - -**Frozen elements (verified against `H`):** - -| Element | Value / encoding | Source of truth | -|---|---|---| -| Wake / ack | host `0xAA ×3` → ambit `0x80`; boot-idle `0x85` | [uart_sensors.c:32-37] | -| Cmd frame | header `0xA0` + 8-byte `cmd[8]` (+ optional extra) → `0xA1` done → … → `0xF0` end | [uart_sensors.c], [run_esp.cpp] | -| Command IDs | 1,2,10,20,21,31,32,33,34,37,4,5,6,17,18 | [ambit_protocol.h:15-31] | -| Info subtypes | 33 → 1=calib, 2=fw, 3=metadata | [ambit_protocol.h:33-37] | -| Response structs | calibration ~136 B, fw_info ~48 B, metadata ~248 B (ESP32 default alignment, `eof_mark==2025` to accept) | [ambit_protocol.h:39-87] | -| Raw responses | spec = 24 B (12×u16, last 4 = float PAR); temp = 4 B (2×i16 ×10); temp_raw = 14 B (7×i16) | [run_esp.cpp], [ambit_protocol.h:83-87] | -| FSM data handshake | wake 211, awake 210, data-hdr 212, len-marker 150, ready 200, data-pass 180, reset 222 | [data_utils.h:9-16], [uart_sensors.c:39-46] | -| FSM header checksum | sum of header bytes `[0..6]` == byte `[7]` | [uart_sensors.c:265-269] | -| **FSM data checksum** | **byte-sum of every payload byte mod 256** (`u32_byte_sum`) | [uart_sensors.c:323-330] | -| MPF length encoding | **base-128 split**: `cmd[1]=len>>7`, `cmd[2]=len&0x7F` | [device_commands.c:1027-1028], [run_esp.cpp:92] | -| Gain wire convention | cmd 1 gains are **1-indexed** on the wire (1..6), stored `−1` | [run_esp.cpp:58-63] | - -**Consequences for the merge:** - -1. **The byte-sum checksum is required, not optional.** `H` verifies it; `fw_original`'s - low-byte-only checksum would be rejected. `fw_new` already byte-sums — keep it. This - alone confirms `fw_new` (not `fw_original`) is the correct trunk for the binary path. -2. **Obscure-but-frozen encodings stay** (base-128 MPF length, 1-indexed gains, struct - alignment). We *document* them at the adapter boundary; we do not "clean them up." -3. **Per-transport wire conventions are decoded in the adapter, not the core.** The CORE - `set_gains` takes 0-indexed normalized gains; the binary adapter subtracts 1, the - text/JSON adapters pass through. Same for the base-128 length. -4. **Semantic (non-wire) contracts are a separate freeze (D2/D3).** `H`'s C layer - forwards env/data arrays **raw** (it does not decode env temperature), so changing - the env-temp *encoding* won't break the wire — but it changes what the *consumer* - (Lua/cloud) must parse. Freeze those by **decision + consumer sign-off**, not by the - conformance test. - ---- - -## 3. Decisions - -| # | Decision | Resolution | -|---|---|---| -| **D1** | Wrench scripting VM (`wrench.*` 17.4k LOC + `do_c.cpp`) | **DELETE entirely** (§8). One text-only entry point, zero unique commands. **Stakeholder check (the only gate):** confirm nobody sends multi-line `C…?` *scripts* (loops/control-flow) from the bench console today. Single primitive calls → pure win. Real scripting → that workflow moves host-side (the ambyte and app already drive primitive sequences themselves). | -| **D2** | Env-temperature wire/format | **Keep `fw_new` centi-°C** plain `int16` (de-obscured from the old `time<<16\|type<<12\|(mlx+20)*20`). Step-mark events are dropped. **Consumer sign-off required:** verify (a) the cloud/Lua consumer tolerates a plain centi-°C series, and (b) the dropped step-marks did not feed `H`'s `mark_event_*` subsystem ([device_commands.c:78]). | -| **D3** | Ambient (sun/leaf) correction | **Keep `fw_new`** offset-corrected (`>65000 ? x−65000 : 0`). If the cloud backend needs *raw*, branch at the `put()` on `CONNECTION_TYPE==CLOUD` only. **Verify with the data consumer before locking.** | -| **D4** | `SunRint`/`LeafRint` gain fields + `read_light_env()` (fork `A` only) | Keep **iff** the cloud/app variant needs the `set_pd_gain` / `read_light_env` snapshot. Otherwise drop the two fields and the function. Default: **keep** (the app uses `set_pd_gain`). | -| **D5** | openJII text/JSON implementation source | **Build the comms layer fresh** to [CommunicationProtocolOpenJIISerial.md] as a **device-agnostic shared module** (§7d). CO2Dot is the doc's named reference but is **too old to reuse** — do not lift its code. Reuse fork `A`'s parser/framing only as a starting skeleton, never its hand-printed command bodies. | -| **D6** | openJII measurement (`arrun`) in-envelope JSON shape | **Resolve by HW test, not now.** Observed app expectation is `arrun → [{…},{…}]` (one element per produced array). It appears to conflict with **command-as-root** (§2.1 of the spec): a bare array `[{…},{…}]` is command-as-root-compliant, a `{"arrun":[…]}` wrapper is not. The app is the oracle — confirm the exact shape on hardware, then revise the doc. | - -**Comms-layer workflow (D5/D6).** For the openJII text/JSON layer **only**: implement to the -spec doc → HW-test against the real app → revise the spec doc to match what the app -actually accepts. The binary/ambyte path is **not** iterated this way — it is frozen (§2). - ---- - -## 4. Target architecture - -``` - ┌─────────────────── one CORE (core.cpp) ───────────────────┐ - │ set_currents · set_gains · set_pd_gain · config_detector │ - host bytes │ run_array · run_mpf · external_trigger · flash_trigger │ - │ │ get_par · get_temp · get_temp_raw · baseline │ - ├─ binary adapter ───►│ set_actinic · set_name · set_metadata · set_emit/spec │ - │ (run_esp.cpp, │ blink · nvs_clean · nvs_update · info · check · reboot │ - │ FROZEN wire §2) │ read_light_env (D4) │ - │ └───────────────┬──────────────────────────┬────────────────┘ - ├─ text-line adapter ─────────────────┤ │ - │ (frontend_text.cpp) ▼ ▼ - │ one CONFIG (AmbitConfig) output via sink: - └─ json adapter ─────────► currents + gains + BINARY → fsm_send_esp / raw writes - (frontend_json.cpp, pd_gain + mode TEXT → send_serial / CSV - cloud/usb only) JSON → send_json - PLOT → CSV printf -``` - -- **Sink selector = `CONNECTION_TYPE`** (already the right seam in [config.h]). Extend - the enum with `CLOUD`; fork `A`'s `json_output` bool and `T`'s per-call branching both - collapse onto it. -- **Core functions take an explicit sink/connection arg or read the global - `CONNECTION_TYPE`** — but never hardcode a transport. - ---- - -## 5. The unified CORE (`core.cpp` / `core.h`) - -Extract each command body (currently duplicated across the four parsers) into **one** -function. Rules: - -- Parameters are **normalized typed values** (0-indexed gains, real `uint16` lengths) — - the adapter has already undone its wire convention. -- **Returns typed native data (structs/scalars), never formatted text and never a JSON - tree.** No `Serial`/`printf`/ArduinoJson inside the core — so the `ambyte` image links - no JSON. Snapshot ops return by value/out-param (e.g. `get_par(u16 spec[10]) -> float`); - the adapter renders it (binary bytes, LINE text, or the JSON tree built in the cloud - adapter §7c). -- **Streaming measurements** write raw frames through `dataclass`/the streaming sink, - keyed by `CONNECTION_TYPE`; the adapter decides framing (binary FSM bytes vs a streamed - JSON array element). The core never builds a tree for a run — runs are thousands of - points. -- Returns a typed status, so adapters can format errors per dialect (binary `CMD_END`, - text `BAD COMMAND`, JSON `{"error":…}`). - -Operation set (the single source of truth; the §11 coverage matrix maps each dialect -onto these): - -``` -set_currents(u8 i620, u8 i720, u8 ir) -set_gains(u8 fluo, u8 fluoRef, u8 ir, u8 irRef, u8 sun, u8 leaf) // 0-indexed -set_pd_gain(u8 sunTia, u8 sunRint, u8 leafTia, u8 leafRint) // D4 -config_detector(...) // conf_slow_FR_1 wrapper -run_array(u8 len, const u8* arr, u8 persist, bool allow_int) -run_mpf(u16 length, u8 interval, bool change_act, u8 act) -external_trigger(), flash_trigger(u32 gate, u32 dt, u16 num) -get_par(u16 spec[10]) -> float -get_temp(double* leaf, double* chip) -get_temp_raw(...) ; baseline(u32 ret[6], bool save) -set_actinic(float), set_name(const char*), set_metadata(const metadata_t*) -set_emit(double), set_spec(float) -blink(u8 id, u8 intensity) -nvs_clean(), nvs_update_scalar(...), nvs_update_array(...) -info(u8 subtype) ; check() ; reboot() -read_light_env() // D4 -``` - ---- - -## 6. The unified CONFIG (`AmbitConfig`) - -Collapse the three copies into one global struct, read/written by every adapter: - -```c -struct AmbitConfig { - struct { uint8_t i620, i720, ir; bool init; } current; - struct { uint8_t fluo, fluoRef, ir, irRef, sun, leaf; - uint8_t sunRint, leafRint; // D4 - bool init; } gain; // ALL 0-indexed (normalized) - uint8_t adpd_mode; // ADPD_CONFIG_MODE -}; -extern AmbitConfig g_cfg; -``` - -- Delete `adpd_current_config_local` / `adpd_gains_config_local` ([run_esp.cpp:21-22]) - and the `do_c.cpp` statics (gone with Wrench). -- **Preserve "set then apply on run" semantics.** Today the text path sets the global - and marks `adpd_mode = MPF_MODE` ("not applied"); the binary path applies at - `config_detector`/`run_array` time. Unify on: setters mutate `g_cfg` only; the - measurement core calls `config_detector` from `g_cfg` when `adpd_mode` requires it. -- **Init/default handling once.** Fork `A` force-sets `init=true` to silence the - "preset not initialized" logs ([commands.cpp:267-268]); the binary path warns. Pick one - rule (default-initialized config is valid) and apply it in the core. -- *Checkpoint after this step:* set currents/gains via the text adapter, run via the - binary adapter → identical values applied. - ---- - -## 7. The three adapters - -### 7a. Binary adapter (`run_esp.cpp`) — FROZEN wire -- Keep the `cmd_arr[0]` switch and **every byte** it reads/writes (§2). -- Each case: decode wire → undo wire convention (gain `−1`, base-128 length) → call the - **same core fn** the other adapters call → encode response in the frozen format. -- This is where §2's conformance gate applies. - -### 7b. Text-line adapter (`frontend_text.cpp`, replaces `do_command.h`) — de-obscure freely -- Keep the verb names (`set_currents`, `arrun`, `q`, `ww`, `ff`, `get_par`, …) as the - human/console surface; route each to a core fn. -- Replace the `hash()` dispatch (silent-collision risk, sweep #19) with a - `strcmp`/`string_view` table if cheap; not a blocker. - -### 7c. openJII text/JSON adapter (cloud/usb only) — built to the spec, not ported wholesale -- Implements [CommunicationProtocolOpenJIISerial.md]: first-byte mode detect (`{`/`[` → - JSON envelope, else LINE), flat `set` envelope, command-as-root, the error taxonomy. -- Reuse fork `A`'s parser/framing ([commands.cpp]) as a **skeleton only**; **discard its - hand-printed `Serial.printf("{…}")` bodies** — they are exactly the per-command - format-strings the spec forbids. Each command instead supplies a **tree-builder** that - consumes the core's typed result. -- **Snapshot commands → build a small tree → serialize.** **Measurement commands - (`arrun`/`q`/MPF) → stream one well-formed JSON value** (an array of frame objects) into - the command's single `set` position — no `stream_start`/`stream_end` side-objects, no - raw bytes (those corrupt the envelope). Exact shape per **D6** (HW-verified). -- ArduinoJson is pulled in **only** for the cloud env (§11); the `ambyte` image stays JSON-free. -- Brings the two `A`-only verbs (`set_pd_gain`, `read_light_env`) into the core (D4). - -### 7d. The shared openJII comms module (`lib/openjii_proto/`) — device-agnostic (D5) -The protocol machinery is **not** amBIT-specific. Factor spec §11's five pieces into a -reusable library other firmware can adopt verbatim: - -1. **Receiver** — first-non-whitespace byte selects mode; string-aware brace/bracket-depth - detects JSON completeness; overflow → `{"error":"rx_overflow"}`, JSON idle 1 s → - `{"error":"json_timeout"}`. -2. **JSON serializer** (strict JSON) + **3. scalar-aware LINE serializer** (scalar → bare, - container → JSON). -4. **Path resolver** — `.`-walk (map key / array index) + `keys()`, with the §9 error set. -5. **Envelope writer** — header → flat `set` (one element per executed command/repeat) → - frame token. - -Device-facing API is tiny: per command, the device registers a **tree-builder** (snapshot) -or a **stream-writer** (measurement) that consumes a core typed result. amBIT supplies -those; the module knows nothing about amBIT. Built **fresh** to the spec (CO2Dot too old — -D5); iterate the spec via HW tests (D5/D6 workflow). - -**Wire-convention boundary (the key correctness rule):** normalization happens in the -adapter. Example — gains: binary subtracts 1 and validates 1..6; text/JSON pass the raw -0-indexed value. The core only ever sees 0-indexed gains. - ---- - -## 8. Wrench deletion (D1) - -Tracing (this session) established Wrench's full footprint: - -- **Single entry point:** [do_command.h:60] `case hash("C")` reads chars until `?` and - calls `do_c(c)`. Text/computer console only. -- **Never on the binary or app paths:** [run_esp.cpp] has no Wrench reference; `H` never - sends a `C` script; fork `A` already shipped without Wrench. -- **Zero unique commands.** `do_c.cpp` registers 11 native fns (`set_currents`, - `set_gains`, `config`/`detector_preset`, `set_arr`, `reset`, `run`, `run_mpf`, - `get_par`, `get_temp`, `print`, `disp`) — every one is a thin wrapper over a core fn - that already exists as a text verb **and** a binary opcode. (`idle` is defined but - never registered — dead even inside the VM.) -- **It is the 3rd config copy:** `do_c.cpp`'s `set_currents`/`set_gains` write file-local - statics independent of both other configs. -- **It owns the `arr_reset` overflow** (sweep #5, now gone with it) and an 8-slot `wr_run_arr[]` - store referenced nowhere else. - -**Action:** delete `src/src/wrench.{cpp,h}`, `src/do_c.cpp`, the `C` case, and all -`#include "src/wrench.h"`. The only capability lost is **on-device control-flow scripting** -(loops/variables/the 8 pre-loaded array slots) on the bench console — which moves -host-side, matching how the ambyte and app already operate. - -**Wins:** −17.4k LOC from the default image, −1 config copy, −1 buffer overflow, −1 dead fn. - ---- - -## 9. PAM / data_utils / sink unification (folded) - -`PAM.cpp` diverged on two orthogonal axes — treat separately. - -- **Axis A (transport):** fork `A`'s `json_output` bool + 5-arg `run_arr_type1` overload - vs `T`'s `CONNECTION_TYPE` branches. **Resolution:** keep `T`'s structure; fold `A`'s - JSON branch in as `case CLOUD` at each send site (~4: `run_arr_type1`, - `external_trigger_run`, `MPF`, the env path). Delete the 5-arg overload + `json_output`. -- **Axis B (semantics):** the D2 centi-°C encoding and D3 ambient correction already - live in `T` ([PAM.cpp] diffs confirmed). Keep them; rewrite fork `A`'s - `send_env_json_decoded` for centi-°C (its old-format unpack is stale — sweep #7). -- `data_utils.cpp`: base = `T` (full FSM send + the **required** byte-sum checksum, §2). - **Re-graft `send_json(const char*)`** from `A` for the `CLOUD` sink (~10 lines, decl in - [data_utils.h]). -- While here, sweep the cheap co-located correctness items (uninit locals #10, - leak-on-early-return #11, unaligned `*(float*)&cmd_arr[3]` → `memcpy` #12). -- *Out of scope:* the `dataclass` ring-buffer over-engineering (#18). - ---- - -## 10. main loop + text-path framing (de-obscure, text only) - -Base = `T`'s [ambit-1.ino] (it has the power management — **keep**: `ambit_light_sleep()`, -UART/GPIO sleep-wake config, sleep thresholds, `AMBIT_BOOT_IDLE` heartbeat, triple-tap-BOOT -reset ISR). - -**Cherry-pick fork `A`'s framing** ([ambit-1.ino:89-111] in `A`) as the de-obscuring fix -for sweep #20: decide LINE vs JSON by the **first printable char** and drop junk -bytes while mode is `UNKNOWN`, instead of `T`'s glitch-sensitive `c > 127` MSB heuristic -that mis-fires on the DTR/RTS open glitch and emits `Unknown cmd`. This is a **text-path** -change and does not touch the binary contract. - -Also (sweep #16): **stop echoing parsed bytes** in `serial_read_until`/`flush_serial` -— that echo currently injects bytes into the binary stream that `H` has to discard as -"debug/echo bytes" ([uart_sensors.c:382]). Move these helpers' single definition into -`serial.*` (kills the 4-TU re-declaration, #15). - -**Variant separation over runtime auto-detect.** The ambyte is a separate product on a -dedicated FFC UART; the app is USB-CDC. Prefer **build-flag-separated frontends** (§11.5) -to runtime first-byte transport sniffing — cleaner and less bug-prone. Keep the framed/junk- -drop fix for robustness either way. - ---- - -## 11. platformio.ini + build flags - -```ini -[platformio] -default_envs = ambyte - -[env] -platform = espressif32 -board = esp32-c3-devkitm-1 -framework = arduino -monitor_speed = 115200 -build_flags = -DDEBUG=0 - -[env:ambyte] ; binary FSM over UART0/FFC, light-sleep -build_flags = - ${env.build_flags} - -DARDUINO_USB_CDC_ON_BOOT=0 - -DVARIANT_AMBYTE=1 - -[env:cloud] ; text+JSON over native USB-CDC -build_flags = - ${env.build_flags} - -DARDUINO_USB_MODE=1 - -DARDUINO_USB_CDC_ON_BOOT=1 - -DUSB_VID=0x16C0 - -DUSB_PID=0x0483 - '-DUSB_MANUFACTURER="JII"' - '-DUSB_PRODUCT="Ambit"' - -DVARIANT_CLOUD=1 -lib_deps = ${env.lib_deps} - bblanchon/ArduinoJson ; only the cloud image pays for JSON -``` - -- `VARIANT_AMBYTE` → binary adapter + FSM + light-sleep idle loop. -- `VARIANT_CLOUD` → JSON/line adapter + `send_json` + (D4) `read_light_env`. -- **No `ENABLE_WRENCH`** — Wrench is deleted (D1). -- Core (`core.*`, drivers, `AmbitConfig`) compiles in both. -- After changing envs, delete the per-env `sdkconfig.*` so it regenerates. - -### Coverage matrix (every dialect → the §5 core ops) - -| Core op | text (`do_command`) | binary (`run_esp` cmd) | JSON (`commands`) | -|---|:--:|:--:|:--:| -| set_currents | ✓ | 2 | ✓ | -| set_gains | ✓ | 1 | ✓ | -| set_pd_gain (D4) | — | (1) | ✓ | -| config_detector | (via run) | 10 | (via run) | -| run_array | `arrun` | 21 | `arrun` | -| run_mpf | `q` | 20 | `q` | -| get_par | ✓ | 31 | ✓ | -| get_temp / _raw | `temp` | 32 / 34 | `temp` | -| baseline | ✓ | 6 | ✓ | -| set_actinic | ✓ | 4 | ✓ | -| set_name | ✓ | 37 | ✓ | -| set_metadata | — | 37 | — | -| set_emit / set_spec | ✓ | — | ✓ | -| external / flash trigger | `ww` / `ff` | — | `ww` / `ff` | -| read_light_env (D4) | — | — | ✓ | -| nvs clean / update | `clean_nvs` | 17 / 18 | `clean_nvs` | -| info / check | `check` | 33 | `check` | -| reboot | `reboot` | — | `reboot` | -| blink | `a`/`aa` | 5 | `a`/`aa` | - ---- - -## 12. Execution order (unification-first) - -1. **Branch + scaffold.** Branch off `fw_new`. Add `CLOUD` to the `CONNECTION_TYPES` - enum; add the two PIO envs + flags (§11). *Checkpoint: `ambyte` env still builds/runs.* -2. **Delete Wrench (D1, §8).** Remove `wrench.*`, `do_c.cpp`, the `C` case, includes. - *Checkpoint: `ambyte` builds; every former Wrench op still reachable as a text verb.* -3. **Unify CONFIG (§6).** Collapse the three copies into `AmbitConfig`. *Checkpoint: set - via text, run via binary → identical currents/gains applied.* -4. **Extract CORE (§5).** Move each command body into one core fn; point the text and - binary adapters at the shared fns. Normalize wire conventions at the adapter boundary. - *Checkpoint: every §11 row reachable from both `ambyte` and text, same numbers.* -5. **Consolidate serial helpers + drop echo (§10).** Single prototype in `serial.*`, - no echo-on-parse. *Checkpoint: clean binary round-trip, no stray echoed bytes.* -6. **PAM + data_utils sink merge (§9).** Add `case CLOUD`, re-graft `send_json`, rewrite - env-JSON for centi-°C, sweep #10/#11/#12. *Checkpoint: AMBYTE numbers byte-identical - to pre-merge `fw_new`; CLOUD JSON validated vs backend schema.* -7. **Port JSON adapter (§7c).** Bring `commands.cpp`'s parser onto the core as - `frontend_json.cpp` (cloud env only); delete `commands.cpp/.h`. -8. **main-loop framing (§10).** Adopt fork `A`'s first-printable-char framing on the text - path; keep `fw_new`'s power management. *Checkpoint: DTR/RTS open glitch no longer - emits `Unknown cmd`.* -9. **Build both envs; HW-test both variants (§14).** - ---- - -## 13. Frozen-contract conformance gate (§2) - -> **Runnable procedure: [HW_CONFORMANCE.md](HW_CONFORMANCE.md).** Step 4b (binary frontend -> → core) was **HW-verified byte-conformant on 2026-06-05** against a real ambyte. Keep the -> procedure as the reusable gate for later `run_esp.cpp` / FSM changes (Step 5+). - -Before merging the binary adapter changes (step 4–5), establish a regression artifact and -keep it green through every later step: - -- **Capture a golden byte trace** of the current `fw_new` ↔ `H` exchange for each binary - command (or derive the expected frames from [uart_sensors.c] + [ambit_protocol.h]): - wake/ack, the 8-byte cmd frame, `CMD_DONE`/`CMD_END`, raw response sizes, and a full FSM - data round-trip (header checksum, **byte-sum** data checksum, length encoding). -- **Assert byte-for-byte identity** of the refactored binary adapter's output against the - golden trace. Any diff = a contract break. -- Explicitly assert the obscure-but-frozen encodings: base-128 MPF length, 1-indexed - gains, struct sizes (136 / 48 / 248), `eof_mark==2025`. -- The conformance gate covers the **wire**; D2/D3 semantic changes are gated separately by - **consumer sign-off** (§3), since `H` forwards those arrays raw. - ---- - -## 14. Risks & test checklist - -| Risk | Mitigation | -|---|---| -| Refactoring the binary adapter breaks the wire contract with shipped ambytes | §13 golden-trace conformance gate, kept green every step; freeze fw_new binary behavior as reference | -| D2/D3 semantic changes alter measured values / cloud ingestion | Consumer sign-off before step 6; freeze AMBYTE numbers; branch raw-vs-corrected on `CLOUD` only if needed | -| Dropped step-marks were feeding `H`'s `mark_event_*` | Confirm with `H` owner before locking D2; else add a dedicated marker channel | -| CONFIG unification changes "when config is applied" semantics | Preserve set-then-apply-on-run; checkpoint 3 verifies cross-adapter equivalence | -| Wrench deletion removes a used scripting workflow | D1 stakeholder check first; move scripting host-side | - -**Per-variant test checklist** -- [ ] `ambyte`: full wake→length→data FSM round-trip to a real ambyte; **byte-sum checksum OK**. -- [ ] `ambyte`: idle current drops to light-sleep between commands; triple-tap BOOT resets; UART wakes within threshold. -- [ ] `cloud`: line + JSON over USB-CDC; `set_pd_gain`/`read_light_env` (if D4=keep). -- [ ] both: `set_currents`/`set_gains` from any adapter reflected in the run (config unify). -- [ ] both: `get_par`, `get_temp`, `baseline`, `arrun`, `run_mpf` expected output. -- [ ] regression: AMBYTE measurement numbers byte-identical vs pre-merge `fw_new`. -- [ ] glitch: opening the USB port (DTR/RTS) does not emit `Unknown cmd`. - ---- - -## Appendix — file-by-file actions - -Legend: `TRUNK`=take `fw_new` · `MERGE`=reconcile · `PORT`=bring `A` feature onto core · -`DROP`=remove · `KEEP`=unchanged. - -| File | Action | -|---|---| -| `wrench.{cpp,h}`, `do_c.cpp` | **DROP** (D1, §8) | -| `do_command.h` | **MERGE** → `frontend_text.cpp` (thin text adapter, §7b) | -| `run_esp.cpp` | **TRUNK + MERGE** → binary adapter, frozen wire, calls core (§7a) | -| `commands.cpp/.h` (fork `A`) | **SKELETON ONLY** → openJII shared module `lib/openjii_proto/` (§7c/§7d); discard hand-printed bodies | -| new `lib/openjii_proto/` | **NEW** — device-agnostic openJII comms module, built fresh to the spec (§7d, D5) | -| `PAM.cpp` / `PAM.h` | **MERGE** — `CONNECTION_TYPE` sinks + `CLOUD`; D2/D3 kept; D4 re-add (§9) | -| `data_utils.cpp` | **MERGE** — FSM + byte-sum checksum (keep) + re-graft `send_json` (§9) | -| `data_utils.h` | TRUNK + re-add `send_json` decl | -| `config.h` | TRUNK + add `CLOUD`; home of `AmbitConfig` (§6) | -| new `core.cpp/.h` | **NEW** — the unified operation set (§5) | -| `serial.cpp/.h` | TRUNK + absorb `serial_read_until`/`flush_serial`, drop echo (§10) | -| `ambit-1.ino` | **MERGE** — `fw_new` power mgmt + `A` text framing (§10) | -| `nvs1.*`, `self_test.cpp`, `devices_init.*`, `pin_config.h`, drivers | KEEP (identical) — nvs checksum `&`→`|` done (#6) | -| `platformio.ini` | **MERGE** — multi-env + flags (§11) | -| `open-jii/`, `*.ipynb` | OUT OF SCOPE (server/tooling, not firmware) | - ---- - -## Appendix B — correctness & cleanup catalog (folded from REFACTOR_PLAN) - -The single-fork review's items, folded here so this file is the only plan. Referenced -above as `sweep #N` / `#N` (original numbering kept). **Status:** ✅ done · ▶ owned by a -named step (do it there) · ☐ open sweep item (cheap, isolated — fold into the nearest -step) · ⏸ deferred/optional. Line numbers are current as of this session. - -| # | Item | Where (current) | Status | -|---|------|-----------------|--------| -| 1 | Wrench VM (17.4k LOC) for ~8 commands | `wrench.*`, `do_c.cpp` | ✅ deleted | -| 2 | Three parallel config copies | global / `run_esp` `_local` / `do_c` statics | ✅ unified to the PAM global | -| 3 | Massive dead code | `PAM.cpp` `/* */` blocks + `data_utils.cpp` `//` block | ✅ deleted (PAM.cpp 1913→1418, data_utils.cpp 716→561; commented-out, so **zero binary change** — Flash identical) | -| 4 | Measurement loop copy-pasted 5–6× | `PAM.cpp` `run_arr_type1`(153)/`run_trigger_spacer`(402)/`external_trigger_run`(580)/`_Flash`(727)/`MPF`(910)/`fluor_offset`(1319) | ▶ Step 4 — extract `PamBuffers` RAII + `read_one_frame()` + `send_results()` | -| 5 | `arr_reset` buffer overflow | was `do_c.cpp` | ✅ gone with Wrench | -| 6 | FW-info checksum `&`→`\|` | `nvs1.cpp:16` | ✅ fixed this session | -| 7 | `PAM_retrieve_env` decode vs centi-°C encode | `PAM.cpp` env path | ▶ Step 6 — rewrite for centi-°C (D2) | -| 8 | Truncating casts in parsing | `w` length clipped to uint8_t; `a`/`aa` pointless casts | ✅ done — `w` length now uint16_t, casts dropped | -| 9 | Non-void FSM fns miss returns (UB) | uncalled `fsm_send_waitesp` (missing return) + dead `fsm_wake_up_calls(void)` | ✅ both deleted (uncalled). Reset-guards N/A — per-run `dataclass` objects reset on construction | -| 10 | Uninitialized locals | `run_arr_type1`/`run_trigger_spacer`/`fluor_offset` comma-decls | ✅ initialized (behavior-neutral; were assigned before use) | -| 11 | Leaks on early return | `PAM.cpp:180-186` 7× `new dataclass` then `return -1` | ☐ stack-allocate `dataclass`, drop new/delete | -| 12 | Unaligned/strict-alias float reads (trap on C3) | `run_esp.cpp:234,242,294,317` `*((float*)&cmd_arr[..])` | ☐ `memcpy` — **frozen wire, bytes unchanged** | -| 13 | Protocol magic numbers scattered | `data_utils.h` vs literals (`ambit-1.ino:167`, `run_esp.cpp`) | ▶ §2 freezes them; centralize into one `proto` header | -| 14 | Pins half-symbolic | `digitalWrite(10/1,…)`, raw `GPIO_NUM_*` | ☐ name pin 10, use symbols | -| 15 | `serial_read_until` re-declared in 4 TUs | `data_utils.cpp`, `PAM.cpp`, `run_esp.cpp`, `ambit-1.ino:59` | ▶ Step 5 — one prototype in `serial.*` | -| 16 | `serial_read_until`/`flush_serial` echo non-target bytes onto the link | corrupts the binary stream | ▶ Step 5 — drop echo | -| 17 | `load_calibration_info` `isKey()`+`getX()` ×~20 | `nvs1.cpp` | ⏸ deferred — dropping `isKey` makes absent keys use the `getX` default not the struct default (config semantics, needs sign-off) | -| 18 | `dataclass` ring-buffer over-engineered | `data_utils.cpp:142` wrap path likely dead; inverted `length`/`_length` | ⏸ deferred (out of scope) | -| 19 | `hash()` dispatch silent-collision risk | `do_command.h:20` | ⏸ optional — `strcmp`/`string_view` table | -| 20 | `c > 127` mode-switch glitch-sensitive | `ambit-1.ino:164` | ▶ Step 8 — framed sync / first-printable-char (text path) | - -[CommunicationProtocolOpenJIISerial.md]: ../CommunicationProtocolOpenJIISerial.md -[uart_sensors.c]: ../ambyte-iot-ludo/components/uart_sensors/uart_sensors.c -[ambit_protocol.h]: ../ambyte-iot-ludo/components/device_commands/include/ambit_protocol.h -[device_commands.c]: ../ambyte-iot-ludo/components/device_commands/device_commands.c -[do_command.h]: src/do_command.h -[run_esp.cpp]: src/run_esp.cpp -[commands.cpp]: ../fw_appCompatible/src/commands.cpp -[PAM.cpp]: src/PAM.cpp -[data_utils.h]: src/data_utils.h -[data_utils.cpp]: src/data_utils.cpp -[config.h]: src/config.h -[ambit-1.ino]: src/ambit-1.ino -[core.cpp]: src/core.cpp -[core.h]: src/core.h diff --git a/src/frontend_cloud.cpp b/src/frontend_cloud.cpp index 0f8a880..0ecb81d 100644 --- a/src/frontend_cloud.cpp +++ b/src/frontend_cloud.cpp @@ -17,6 +17,7 @@ #include "nvs1.h" #include "config.h" #include "PAM.h" +#include "core.h" extern ADPD6 adpd; // defined in ambit-1.ino @@ -106,6 +107,26 @@ static void cmd_arrun(const String& args, Print& out) { run_arr_type1(16, arr, persist, false, true); // json_output -> writes the JSON object to Serial } +// ── config setters (snapshot: ack with the applied values; command-as-root) ── +// 0-indexed values; they take effect on the next run (core marks config dirty). +static void cmd_set_currents(const String& args, JsonVariant root) { + core_set_currents((uint8_t) arg_long(args, 0), (uint8_t) arg_long(args, 1), (uint8_t) arg_long(args, 2)); + root["I620"] = adpd_current_config.I620; + root["I720"] = adpd_current_config.I720; + root["IR"] = adpd_current_config.IR; +} + +static void cmd_set_gains(const String& args, JsonVariant root) { + core_set_gains((uint8_t) arg_long(args, 0), (uint8_t) arg_long(args, 1), (uint8_t) arg_long(args, 2), + (uint8_t) arg_long(args, 3), (uint8_t) arg_long(args, 4), (uint8_t) arg_long(args, 5)); + root["Fluo"] = adpd_gains_config.Fluo; + root["FluoRef"] = adpd_gains_config.FluoRef; + root["IR"] = adpd_gains_config.IR; + root["IRRef"] = adpd_gains_config.IRRef; + root["Sun"] = adpd_gains_config.Sun; + root["Leaf"] = adpd_gains_config.Leaf; +} + // printf reaches the ESP-IDF console (USB-Serial/JTAG) regardless of CDC DTR, so // these per-step markers show exactly where init reaches / hangs. #define INIT_STEP(label, expr) do { printf("[init] " label "...\n"); expr; printf("[init] " label " ok\n"); } while (0) @@ -145,6 +166,8 @@ void cloud_setup() { ojii::on("temp", cmd_temp); ojii::on("get_par", cmd_get_par); ojii::on("PAR", cmd_PAR); + ojii::on("set_currents", cmd_set_currents); + ojii::on("set_gains", cmd_set_gains); ojii::on_stream("arrun", cmd_arrun); printf("[init] Ready (cloud)\n"); From c53709ada4a7df1e7197e7de360bcfaf1672bf97 Mon Sep 17 00:00:00 2001 From: Ludo-lab Date: Wed, 17 Jun 2026 17:20:48 +0200 Subject: [PATCH 03/37] first commit --- plans/HW_CONFORMANCE.md | 164 +++++++++++ plans/MERGE_PLAN.md | 615 ++++++++++++++++++++++++++++++++++++++++ 2 files changed, 779 insertions(+) create mode 100644 plans/HW_CONFORMANCE.md create mode 100644 plans/MERGE_PLAN.md diff --git a/plans/HW_CONFORMANCE.md b/plans/HW_CONFORMANCE.md new file mode 100644 index 0000000..6496395 --- /dev/null +++ b/plans/HW_CONFORMANCE.md @@ -0,0 +1,164 @@ +# amBIT HW Conformance Test — Step 4b (binary frontend → core) + +**Status: PASSED 2026-06-05.** Step 4b's binary path is HW-verified byte-conformant +against a real ambyte; the dirty-mark change (§4) was accepted. Keep this procedure as the +**reusable conformance gate** for any future change touching `run_esp.cpp` or the +`data_utils.cpp` FSM (Step 5 onward) — re-run it after each such change. + +It is the verification gate for the binary/ambyte wire contract (MERGE_PLAN §2, §13). + +--- + +## 0. What Step 4b changed (what's at risk) + +`run_esp.cpp` cmd `1/2/10/20/21` now call shared `core_*` functions instead of inline +logic. The intent is **zero change on the wire**: + +- Every `Serial.write(ESP_CMD_DONE/END)` and `Serial.readBytes(...)` is byte-for-byte + unchanged; only the internal config/run calls were factored out. +- Wire normalization still lives in the adapter: gains 1-indexed (1..6, stored −1), + current byte `≥127` = "no change", MPF length base-128 (`cmd[1]<<7 | cmd[2]`). + +**One intentional internal change** (not a wire change): binary `set_gains`/`set_currents` +(cmd 1/2) now mark the config *dirty* (they didn't before). Consequences: +- Normal flow `cmd1 → cmd2 → cmd10 → cmd21`: **identical** (cmd 10 re-applies config + regardless of the dirty flag). +- Degenerate flow `set gains/currents → cmd21 without cmd10`: now correctly re-applies + the just-set values (previously could run with stale config). This is the only + observable behavioural delta, and it is a fix — confirm no ambyte workflow relied on + the old stale-config behaviour. + +--- + +## 1. Setup + +- **DUT:** an amBIT flashed with the current `fw_new` (post-Step-4b): + ``` + cd fw_new + "$HOME/.platformio/penv/Scripts/pio.exe" run -t upload # add -t upload to flash + ``` +- **Host (one of):** + - **A real ambyte** (preferred) on the FFC/UART0 link, driving the amBIT via its + `device.ambit_*` Lua commands / CLI (`ambit_*`). This exercises the genuine binary + protocol end-to-end. + - **A logic analyzer / UART sniffer** on the FFC TX & RX (115200 8N1) to capture raw + bytes for the strict byte-diff (Test A). Best combined with the ambyte. +- **Reference build (for the strict diff):** a pre-Step-4 amBIT image — e.g. `git stash` + the working tree, or check out the commit before `core.{h,cpp}` was added, build, and + keep `firmware.bin` aside as `firmware_preStep4.bin`. + +--- + +## 2. Test A — byte-level framing conformance (gold standard) + +Goal: the **protocol framing** is identical pre- vs post-Step-4b. (Measurement *payload* +values vary run-to-run with sensor noise — only the framing/lengths/checksum validity are +deterministic; do not expect data bytes to match.) + +1. Flash `firmware_preStep4.bin`. With the sniffer capturing, drive the standard sequence + from the ambyte (see §3 for the sequence). Save the trace as `pre.bin`. +2. Flash the post-Step-4b image. Repeat the **identical** host sequence. Save `post.bin`. +3. Compare. For each command, the following must match exactly: + +| Command | Deterministic bytes that MUST match | +|---|---| +| wake | host `0xAA 0xAA 0xAA` → amBIT `0x80` | +| set_gains (1) | frame `0xA0`+8B cmd → `0xA1` (CMD_DONE). No data. | +| set_currents (2) | frame → `0xA1` | +| config (10) | frame → `0xA1` | +| get_spec (31) | `0xA1` + **24 B** + `0xF0` | +| get_temp (32) | `0xA1` + **4 B** + `0xF0` | +| get_info (33,2) | `0xA1` + **`sizeof(ambit_fw_info_t)` B** + `0xF0` | +| get_temp_raw (34) | `0xA1` + **14 B** + `0xF0` | +| run (21) / mpf (20) | `0xA1` … FSM arrays (`0xD3` wake, `0xD2` ack, `0xD4 0x96` len-hdr w/ checksum byte, data, `0xD4 .. checksum`, `0xB4` pass) … `0xF0`. **Array count, each array length, header checksum, and data byte-sum checksum must verify.** Data values may differ. | + +**Pass:** all framing/handshake/length/checksum bytes identical; only measurement payload +values differ. **Fail:** any framing byte, length field, command-ID echo, or checksum +*scheme* differs → a contract break; do not ship, diff the offending command. + +> If no sniffer is available, Test A reduces to "the ambyte completes every command in §3 +> with no timeout / no `checksum mismatch` / no `CMD_DONE not received` log" — a weaker but +> still useful gate (`uart_sensors.c` logs all three on failure). + +--- + +## 3. Test B — functional regression (per MERGE_PLAN §14) + +Drive each command class from the ambyte and confirm it completes and the numbers are +sane. Minimum sequence: + +- [ ] **wake / ping** — amBIT acks `0x80`; ambyte marks channel CONNECTED. +- [ ] **set_gains (cmd 1)** then **set_currents (cmd 2)** — each returns `CMD_DONE`. +- [ ] **config (cmd 10)** — `CMD_DONE`. +- [ ] **run (cmd 21)** with a small array — FSM round-trip completes, **all array + checksums pass**, array count = expected (env, fluor, fluoref, sun, leaf, 730, + 730ref), values in a plausible range. +- [ ] **run_mpf (cmd 20)** — completes; length decodes correctly (test a length >127 to + exercise the base-128 split, e.g. 200 → `cmd[1]=1, cmd[2]=72`). +- [ ] **get_spec (cmd 31)** / **get_temp (cmd 32)** / **get_temp_raw (cmd 34)** — correct + byte counts (24 / 4 / 14), values sane (temp ≈ ambient °C). +- [ ] **get_info (cmd 33)** subtypes 1/2/3 — struct sizes match `ambit_protocol.h` + (calibration ~136 B, fw_info ~48 B, metadata ~248 B). +- [ ] **baseline (cmd 6)**, **blink (cmd 5)**, **actinic (cmd 4)** — complete without error. +- [ ] **set_metadata (cmd 37)** with `eof_mark = 2025` — accepted and persisted. + +**Compare measurement values** from cmd 21/20 against the pre-Step-4 reference build on the +same target/sample: they should match within sensor noise (Step 4b does not change the +measurement math). + +--- + +## 4. Test C — the dirty-mark behavioural delta (the only intended change) + +Run this exact non-standard sequence **without a cmd 10 between set and run**: + +1. `cmd 10` (config) then `cmd 21` (run) with gains G1 — note the values. +2. `cmd 1` (set gains to a clearly different G2) **then `cmd 21` directly** (no cmd 10). + +- **Pre-Step-4b:** the run in step 2 used **G1** (stale — the bug). +- **Post-Step-4b:** the run in step 2 uses **G2** (re-applied — the fix). + +**Expected pass:** step-2 readings reflect G2. If any ambyte workflow *depended* on the old +stale-config behaviour, flag it — the dirty-mark can be removed from `core_set_gains` / +`core_set_currents` (drop the `adpd_mode = MPF_MODE` line) to restore the exact old binary +behaviour, at the cost of re-diverging from the text path. + +--- + +## 5. Result handling + +- **All pass** → mark Step 4b verified: update memory `merge-plan-ambit` ("4b verified on + HW ") and tick MERGE_PLAN §14's ambyte rows. +- **Framing diff (Test A fail)** → contract break; capture the offending command's pre/post + bytes and fix the adapter so the wire matches. +- **Test C unwanted** → remove the dirty-mark as noted in §4. + +This same harness (Tests A/B) is the reusable conformance gate for any future change that +touches `run_esp.cpp` or `data_utils.cpp`'s FSM (Step 5 onward). + +--- + +## 6. Re-verification log (changes that require re-running this gate) + +| Date | Change | Re-run | Status | +|------|--------|--------|--------| +| 2026-06-05 | Step 4b — binary frontend → core (`run_esp.cpp` cmd 1/2/10/20/21) | A + B + C | ✅ PASSED (incl. run(21)/mpf(20) FSM round-trip) | +| 2026-06-05 | Sweep #4 inc 1 — extracted `pam_send_results` from `run_arr_type1`; verbatim relocation of the `fsm_send_esp`/`send_serial` calls | A + B | ✅ PASSED — AMBYTE: run(21) = 5 arrays (idx0 len1 ENV + idx1-4 len30; 730/730ref correctly absent for no-IR), mpf(20) = 7 arrays. (COMPUTER `arrun` half is the same function's other branch — optional spot-check.) | +| 2026-06-05 | **#16 fix** — `serial_read_until`/`flush_serial` no longer echo non-target bytes (the echo injected the ambyte's 2nd `200` as ASCII `'2''0''0'` into the FSM **data phase** → checksum mismatch every run). **Not** a checksum-scheme bug: the amBIT byte-sums correctly (`u32_byte_sum`, data_utils.cpp:200/201/210, via `fsm_send_data`:432). | A + B | ✅ PASSED — array checksums clean, run/mpf complete | +| 2026-06-05 | Sweep #4 inc 2 — routed `run_trigger_spacer` (the mpf / cmd-20 path) through `pam_send_results` (`subsampling=1, has_730=true` → unconditional 7 channels; AMBYTE branch identical to the former inline block, COMPUTER branch inert as this path is never COMPUTER). `MPF` (2-channel idx 0/1), `external_trigger_run`/`_Flash`/`fluor_offset` (no FSM send) don't share this block. | B — the `mpf(20)` row of the Lua | ✅ PASSED — mpf(20) = 7 arrays, no checksum errors | +| 2026-06-05 | Cheap correctness sweep — **#10** init the comma-decl locals in `run_arr_type1`/`run_trigger_spacer`/`fluor_offset` (defensive; each was already assigned before use); **#8** `w`-length `uint8_t`→`uint16_t` + drop pointless `(uint16_t)` casts; **#9** delete 2 uncalled FSM fns (`fsm_wake_up_calls(void)`, `fsm_send_waitesp` — the latter had missing-return UB). | #10 → A+B (measurement path, behavior-neutral, very low risk). #8 text path (`w` over USB), #9 dead-code → no ambyte HW. | ☐ #10 prudent Lua re-run; #8/#9 done | +| 2026-06-08 | **Wire v2 (ambyte variant)** — (1) self-describing length header: the 2 spare bytes now carry `elem_width` (2\|4) + `dtype` (0 unsigned\|1 signed); csum formula unchanged (sum of bytes [0..6], now covers the new bytes); host defaults 4/0 when a byte is 0, so v1 still decodes. (2) ADC channels (Fluo/Fluoref/Sun/Leaf/730/730ref) sent as **uint16** (elem_width 2, dtype 0, each clamped to 0xFFFF); ENV as **int16** centi-°C (elem_width 2, dtype 1). Data-trailer csum = byte-sum of exactly the bytes sent. (3) new **TIMING** block idx 7 = `uint32[tick_begin, tick_end]` (µs from `esp_timer_get_time()`), emitted in `pam_send_results`. (4) **one wake per run**: `data_utils.cpp` FSM split into free `ambyte_wake()` + `dataclass::fsm_send_array(idx,elem_width,dtype)`; `pam_send_results` wakes once then streams each array back-to-back; host loops on the 212 marker, stops at the run's trailing 240. `fsm_send_esp` kept as a legacy wake+one-array(4/0) wrapper (MPF path). Host (ambyte) side updated to match. Both `pio run -e ambyte` and `-e cloud` build clean. | A + B | ☐ pending HW — one wake yields ENV(int16×N), Fluo/Fluoref/Sun/Leaf/730/730ref(uint16×N), TIMING(uint32×2), then 240; every header csum + data byte-sum must verify and each block decodes per `elem_width`/`dtype` | + +**Focused check for sweep-#4 inc 1** (the send block is shared by both transports, so verify +both halves): + +- **AMBYTE path** — drive a `run` (cmd 21) and an `mpf` (cmd 20) from the ambyte: the FSM + round-trip (array count, each array length, header + byte-sum checksums) must be identical + to the pre-change build; measurement values within sensor noise. +- **COMPUTER path** — drive `arrun` over the USB/text console: the 7 ASCII blocks + (`Data:ENV…`, `Fluo`, `Fluoref`, `SUN`, `leaf`, `730`, `730ref`) followed by `Data sent` + must be byte-identical to pre-change (this exercises the `send_serial` half). + +Passing both confirms the extracted `pam_send_results` reproduces the inline block exactly. +The next sweep-#4 increments (`PamBuffers` RAII / `#11` leak fix, then `read_one_frame`) +each get their own row here and must re-run A + B before being trusted. diff --git a/plans/MERGE_PLAN.md b/plans/MERGE_PLAN.md new file mode 100644 index 0000000..32c9c6e --- /dev/null +++ b/plans/MERGE_PLAN.md @@ -0,0 +1,615 @@ +# Ambit Firmware Merge Plan (v2) — built around dialect + config unification + +Collapse the two diverged Ambit ESP32-C3 forks into **one** source tree that builds +both product variants from one codebase: + +- **`ambyte`** variant — binary FSM protocol over UART0/FFC, idle light-sleep, the + field/companion-board use case (today = `fw_new`, was `ambitPIO`). +- **`cloud`/`usb`** variant — text + JSON over native USB-CDC, feeds the OpenJII + platform / phone app (today = `fw_appCompatible`, was `openJII`). + +Sources: +- `T` = **`fw_new`** (ambyte/binary line, this repo) — the **trunk**. +- `A` = **`fw_appCompatible`** (cloud/JSON line) — a *capability fork*: it added the + JSON/line frontend but **deleted** the binary frontend, Wrench, and power + management. Donor of the text/USB frontend only. +- `H` = **`ambyte-iot-ludo`** (the datalogger) — **not** ambit FW. It is the + *authoritative spec* of the binary wire contract ([uart_sensors.c], [ambit_protocol.h]). + Treated here as the frozen reference, never modified. + +Back-compat of the **text** path is not a constraint; the **binary** path is a frozen +wire contract (§2). Git holds history. Reviewed 2026-06-05. + +--- + +## 0. Revision history + +### v3 (current) — openJII comms layer + +- **Core returns typed data, not a JSON tree.** The shared core is JSON-free; the JSON + tree is built only in the app-side (cloud) adapter, so the `ambyte`/binary image links + no JSON (§5, §7c). +- **The openJII text/JSON layer is a device-agnostic shared module** (§7d), built **fresh** + to [CommunicationProtocolOpenJIISerial.md] — CO2Dot is the doc's named reference but is + too old to lift (D5). +- **Envelope `set` is flat** (one element per executed command/repeat). **Snapshot → + tree; measurement → one streamed JSON value** per `set` position (D6). +- **Comms-layer workflow:** implement to the spec doc → HW-test against the real app (the + oracle) → revise the spec doc. The binary path is *not* iterated this way — it's frozen. + +### v2 — unification spine + +This revision is built around the **command-dialect + config unification** as the +headline task, not as one step among many. Specifically: + +- **D1 (Wrench): DELETE, not gate.** Tracing shows Wrench is reachable from exactly + one text-console entry point and exposes zero unique commands (§8). It goes away + entirely, behind a single stakeholder check. +- **The spine is now: one CORE + one CONFIG + three thin transport adapters** (§4–§7). + Every other task (JSON re-graft, PAM sink merge, framing fix, power mgmt) hangs off + that spine. +- **Constraint (c) is promoted to its own section (§2)** with an explicit, verified + list of frozen wire elements and a conformance gate, because the deployed ambyte + (`H`) already pins several of them — including the data checksum, which makes + `fw_new`'s "checksum fix" **mandatory for compatibility**, not optional. + +--- + +## Where we are — 2026-06-05 (resume here) + +Two build variants from one tree (`platformio.ini`): **`ambyte`** (binary FSM over +UART0/FFC, HW-verified field path) and **`cloud`** (openJII LINE+JSON over UART0 — the +test HW has no USB-C; the native-USB-CDC flags are kept in a comment for a future PCB). + +**Done + HW-verified** (commits through `51a7ffc`): +- Wrench deleted; the 3 config copies unified; transport-agnostic CORE (`core.*`); text + + binary frontends thin over it; `pam_send_results` shared; echo (#16) fixed; nvs checksum + (#6); dead-code purge (#3); cheap correctness (#8/#9/#10). Binary path byte-conformant vs + a real ambyte (`HW_CONFORMANCE.md`). +- **openJII module `lib/openjii_proto/`** (device-agnostic): first-byte mode detect, LINE + (bare scalar / JSON container + dot-path + `keys()`), JSON envelope (flat `set` + frame + token), §9 errors, receiver. Snapshot API `on()` + stream/measurement API `on_stream()`. +- **Cloud variant** (`src/frontend_cloud.cpp`): snapshots hello/temp/get_par/PAR (verified) + and **`arrun` measurement-in-envelope** (verified — runs `run_arr_type1`'s new + `json_output` path, emits `{"ENV":[..],"Fluo":[..],"Fluoref":[..],"SUN":[..],"leaf":[..]}`). + ENV channels byte-identical to fork A's `send_json`; ENV decoded from fw_new centi-°C. + +**Next (pick up here):** +1. **Expand command coverage.** Snapshots: `set_currents`/`set_gains`/`set_pd_gain`/`baseline`/ + `battery`/`set_act`/`set_name`/`set_emit`/`set_spec`/`clean_nvs`/`reboot`/`check` — each a + one `on()` tree-builder calling the CORE. Measurements: `q`/`w`/`mpf`/`ww`/`ff` — give + `run_trigger_spacer` (and `MPF`) the same `json_output` sink `run_arr_type1` has, register + via `on_stream`. +2. **Confirm formats against the app (D6/D2).** ENV is `{"temp_c":<°C>}` per point now (fork A + had `{"t_ms":..,"temp_c":..}` + step marks, dropped in fw_new). Adjust `send_env_json` if the + app needs the old shape. Check ArduinoJson float precision (trims trailing zeros vs the + spec's fixed 4 dp) is tolerated. +3. **Test the rest of LINE mode on HW:** dot-path queries, `keys()`, the error taxonomy. +4. **Open decisions:** D2/D3 (env centi-°C + ambient — consumer sign-off), D6 (measurement + shape — partly resolved by the working `arrun`). + +--- + +## 1. Headline: the disease and the cure + +**Disease.** The same ~25 logical operations are implemented as **four parallel +command parsers**, each with its own argument decoding *and* its own copy of the +device config: + +| Parser | File | Config it mutates | +|---|---|---| +| text/computer | [do_command.h] `hash()` switch | global `adpd_*_config` | +| binary/ambyte | [run_esp.cpp] `cmd_arr[0]` switch | `adpd_*_config_local` (file-static) | +| Wrench bridge | `do_c.cpp` native fns | `do_c.cpp` statics (3rd copy) | +| JSON/line (fork `A`) | [commands.cpp] `startsWith` chain | global `adpd_*_config` | + +Adding one command means editing up to four places; the same setting lives in three +structs that can silently diverge (set currents via text, run via binary → different +values applied). **This duplication is the root cause of the forks themselves.** + +**Cure.** Split every operation into: + +``` + wire bytes ─► [thin transport adapter] ─► normalized args ─► CORE op ─► result ─► [sink] + │ │ + (decodes that transport's one implementation, + own wire convention) one CONFIG struct +``` + +- **One CORE** ([core.cpp]): one function per logical operation, taking *normalized* + typed args and writing to a *sink*, never touching `Serial`/`printf` directly (§5). +- **One CONFIG** ([config.h]): a single `AmbitConfig` struct every path reads/writes (§6). +- **Three thin adapters**: binary (frozen wire), text-line, JSON (§7). Each adapter's + only job is wire⇄normalized-args translation + choosing the sink. No measurement or + config logic lives in an adapter. + +Note the realistic scope: because the binary wire is frozen (§2), we **do not** merge +the three *parsers* into one parser. We collapse the three *cores* and three *configs* +into one each, and make all three parsers thin shims over them. That is the achievable, +high-value unification. + +--- + +## 2. The frozen binary contract (constraint c) + +The binary path is a wire contract with **shipped ambyte firmware** (`H`). The contract +is defined by what [uart_sensors.c] / [ambit_protocol.h] already implement. Refactor +*behind* it freely; do **not** change the bytes. De-obscuring is allowed only on the +text/USB path. + +**Frozen elements (verified against `H`):** + +| Element | Value / encoding | Source of truth | +|---|---|---| +| Wake / ack | host `0xAA ×3` → ambit `0x80`; boot-idle `0x85` | [uart_sensors.c:32-37] | +| Cmd frame | header `0xA0` + 8-byte `cmd[8]` (+ optional extra) → `0xA1` done → … → `0xF0` end | [uart_sensors.c], [run_esp.cpp] | +| Command IDs | 1,2,10,20,21,31,32,33,34,37,4,5,6,17,18 | [ambit_protocol.h:15-31] | +| Info subtypes | 33 → 1=calib, 2=fw, 3=metadata | [ambit_protocol.h:33-37] | +| Response structs | calibration ~136 B, fw_info ~48 B, metadata ~248 B (ESP32 default alignment, `eof_mark==2025` to accept) | [ambit_protocol.h:39-87] | +| Raw responses | spec = 24 B (12×u16, last 4 = float PAR); temp = 4 B (2×i16 ×10); temp_raw = 14 B (7×i16) | [run_esp.cpp], [ambit_protocol.h:83-87] | +| FSM data handshake | wake 211, awake 210, data-hdr 212, len-marker 150, ready 200, data-pass 180, reset 222 | [data_utils.h:9-16], [uart_sensors.c:39-46] | +| FSM header checksum | sum of header bytes `[0..6]` == byte `[7]` | [uart_sensors.c:265-269] | +| **FSM data checksum** | **byte-sum of every payload byte mod 256** (`u32_byte_sum`) | [uart_sensors.c:323-330] | +| MPF length encoding | **base-128 split**: `cmd[1]=len>>7`, `cmd[2]=len&0x7F` | [device_commands.c:1027-1028], [run_esp.cpp:92] | +| Gain wire convention | cmd 1 gains are **1-indexed** on the wire (1..6), stored `−1` | [run_esp.cpp:58-63] | + +**Consequences for the merge:** + +1. **The byte-sum checksum is required, not optional.** `H` verifies it; `fw_original`'s + low-byte-only checksum would be rejected. `fw_new` already byte-sums — keep it. This + alone confirms `fw_new` (not `fw_original`) is the correct trunk for the binary path. +2. **Obscure-but-frozen encodings stay** (base-128 MPF length, 1-indexed gains, struct + alignment). We *document* them at the adapter boundary; we do not "clean them up." +3. **Per-transport wire conventions are decoded in the adapter, not the core.** The CORE + `set_gains` takes 0-indexed normalized gains; the binary adapter subtracts 1, the + text/JSON adapters pass through. Same for the base-128 length. +4. **Semantic (non-wire) contracts are a separate freeze (D2/D3).** `H`'s C layer + forwards env/data arrays **raw** (it does not decode env temperature), so changing + the env-temp *encoding* won't break the wire — but it changes what the *consumer* + (Lua/cloud) must parse. Freeze those by **decision + consumer sign-off**, not by the + conformance test. + +--- + +## 3. Decisions + +| # | Decision | Resolution | +|---|---|---| +| **D1** | Wrench scripting VM (`wrench.*` 17.4k LOC + `do_c.cpp`) | **DELETE entirely** (§8). One text-only entry point, zero unique commands. **Stakeholder check (the only gate):** confirm nobody sends multi-line `C…?` *scripts* (loops/control-flow) from the bench console today. Single primitive calls → pure win. Real scripting → that workflow moves host-side (the ambyte and app already drive primitive sequences themselves). | +| **D2** | Env-temperature wire/format | **Keep `fw_new` centi-°C** plain `int16` (de-obscured from the old `time<<16\|type<<12\|(mlx+20)*20`). Step-mark events are dropped. **Consumer sign-off required:** verify (a) the cloud/Lua consumer tolerates a plain centi-°C series, and (b) the dropped step-marks did not feed `H`'s `mark_event_*` subsystem ([device_commands.c:78]). | +| **D3** | Ambient (sun/leaf) correction | **Keep `fw_new`** offset-corrected (`>65000 ? x−65000 : 0`). If the cloud backend needs *raw*, branch at the `put()` on `CONNECTION_TYPE==CLOUD` only. **Verify with the data consumer before locking.** | +| **D4** | `SunRint`/`LeafRint` gain fields + `read_light_env()` (fork `A` only) | Keep **iff** the cloud/app variant needs the `set_pd_gain` / `read_light_env` snapshot. Otherwise drop the two fields and the function. Default: **keep** (the app uses `set_pd_gain`). | +| **D5** | openJII text/JSON implementation source | **Build the comms layer fresh** to [CommunicationProtocolOpenJIISerial.md] as a **device-agnostic shared module** (§7d). CO2Dot is the doc's named reference but is **too old to reuse** — do not lift its code. Reuse fork `A`'s parser/framing only as a starting skeleton, never its hand-printed command bodies. | +| **D6** | openJII measurement (`arrun`) in-envelope JSON shape | **Resolve by HW test, not now.** Observed app expectation is `arrun → [{…},{…}]` (one element per produced array). It appears to conflict with **command-as-root** (§2.1 of the spec): a bare array `[{…},{…}]` is command-as-root-compliant, a `{"arrun":[…]}` wrapper is not. The app is the oracle — confirm the exact shape on hardware, then revise the doc. | + +**Comms-layer workflow (D5/D6).** For the openJII text/JSON layer **only**: implement to the +spec doc → HW-test against the real app → revise the spec doc to match what the app +actually accepts. The binary/ambyte path is **not** iterated this way — it is frozen (§2). + +--- + +## 4. Target architecture + +``` + ┌─────────────────── one CORE (core.cpp) ───────────────────┐ + │ set_currents · set_gains · set_pd_gain · config_detector │ + host bytes │ run_array · run_mpf · external_trigger · flash_trigger │ + │ │ get_par · get_temp · get_temp_raw · baseline │ + ├─ binary adapter ───►│ set_actinic · set_name · set_metadata · set_emit/spec │ + │ (run_esp.cpp, │ blink · nvs_clean · nvs_update · info · check · reboot │ + │ FROZEN wire §2) │ read_light_env (D4) │ + │ └───────────────┬──────────────────────────┬────────────────┘ + ├─ text-line adapter ─────────────────┤ │ + │ (frontend_text.cpp) ▼ ▼ + │ one CONFIG (AmbitConfig) output via sink: + └─ json adapter ─────────► currents + gains + BINARY → fsm_send_esp / raw writes + (frontend_json.cpp, pd_gain + mode TEXT → send_serial / CSV + cloud/usb only) JSON → send_json + PLOT → CSV printf +``` + +- **Sink selector = `CONNECTION_TYPE`** (already the right seam in [config.h]). Extend + the enum with `CLOUD`; fork `A`'s `json_output` bool and `T`'s per-call branching both + collapse onto it. +- **Core functions take an explicit sink/connection arg or read the global + `CONNECTION_TYPE`** — but never hardcode a transport. + +--- + +## 5. The unified CORE (`core.cpp` / `core.h`) + +Extract each command body (currently duplicated across the four parsers) into **one** +function. Rules: + +- Parameters are **normalized typed values** (0-indexed gains, real `uint16` lengths) — + the adapter has already undone its wire convention. +- **Returns typed native data (structs/scalars), never formatted text and never a JSON + tree.** No `Serial`/`printf`/ArduinoJson inside the core — so the `ambyte` image links + no JSON. Snapshot ops return by value/out-param (e.g. `get_par(u16 spec[10]) -> float`); + the adapter renders it (binary bytes, LINE text, or the JSON tree built in the cloud + adapter §7c). +- **Streaming measurements** write raw frames through `dataclass`/the streaming sink, + keyed by `CONNECTION_TYPE`; the adapter decides framing (binary FSM bytes vs a streamed + JSON array element). The core never builds a tree for a run — runs are thousands of + points. +- Returns a typed status, so adapters can format errors per dialect (binary `CMD_END`, + text `BAD COMMAND`, JSON `{"error":…}`). + +Operation set (the single source of truth; the §11 coverage matrix maps each dialect +onto these): + +``` +set_currents(u8 i620, u8 i720, u8 ir) +set_gains(u8 fluo, u8 fluoRef, u8 ir, u8 irRef, u8 sun, u8 leaf) // 0-indexed +set_pd_gain(u8 sunTia, u8 sunRint, u8 leafTia, u8 leafRint) // D4 +config_detector(...) // conf_slow_FR_1 wrapper +run_array(u8 len, const u8* arr, u8 persist, bool allow_int) +run_mpf(u16 length, u8 interval, bool change_act, u8 act) +external_trigger(), flash_trigger(u32 gate, u32 dt, u16 num) +get_par(u16 spec[10]) -> float +get_temp(double* leaf, double* chip) +get_temp_raw(...) ; baseline(u32 ret[6], bool save) +set_actinic(float), set_name(const char*), set_metadata(const metadata_t*) +set_emit(double), set_spec(float) +blink(u8 id, u8 intensity) +nvs_clean(), nvs_update_scalar(...), nvs_update_array(...) +info(u8 subtype) ; check() ; reboot() +read_light_env() // D4 +``` + +--- + +## 6. The unified CONFIG (`AmbitConfig`) + +Collapse the three copies into one global struct, read/written by every adapter: + +```c +struct AmbitConfig { + struct { uint8_t i620, i720, ir; bool init; } current; + struct { uint8_t fluo, fluoRef, ir, irRef, sun, leaf; + uint8_t sunRint, leafRint; // D4 + bool init; } gain; // ALL 0-indexed (normalized) + uint8_t adpd_mode; // ADPD_CONFIG_MODE +}; +extern AmbitConfig g_cfg; +``` + +- Delete `adpd_current_config_local` / `adpd_gains_config_local` ([run_esp.cpp:21-22]) + and the `do_c.cpp` statics (gone with Wrench). +- **Preserve "set then apply on run" semantics.** Today the text path sets the global + and marks `adpd_mode = MPF_MODE` ("not applied"); the binary path applies at + `config_detector`/`run_array` time. Unify on: setters mutate `g_cfg` only; the + measurement core calls `config_detector` from `g_cfg` when `adpd_mode` requires it. +- **Init/default handling once.** Fork `A` force-sets `init=true` to silence the + "preset not initialized" logs ([commands.cpp:267-268]); the binary path warns. Pick one + rule (default-initialized config is valid) and apply it in the core. +- *Checkpoint after this step:* set currents/gains via the text adapter, run via the + binary adapter → identical values applied. + +--- + +## 7. The three adapters + +### 7a. Binary adapter (`run_esp.cpp`) — FROZEN wire +- Keep the `cmd_arr[0]` switch and **every byte** it reads/writes (§2). +- Each case: decode wire → undo wire convention (gain `−1`, base-128 length) → call the + **same core fn** the other adapters call → encode response in the frozen format. +- This is where §2's conformance gate applies. + +### 7b. Text-line adapter (`frontend_text.cpp`, replaces `do_command.h`) — de-obscure freely +- Keep the verb names (`set_currents`, `arrun`, `q`, `ww`, `ff`, `get_par`, …) as the + human/console surface; route each to a core fn. +- Replace the `hash()` dispatch (silent-collision risk, sweep #19) with a + `strcmp`/`string_view` table if cheap; not a blocker. + +### 7c. openJII text/JSON adapter (cloud/usb only) — built to the spec, not ported wholesale +- Implements [CommunicationProtocolOpenJIISerial.md]: first-byte mode detect (`{`/`[` → + JSON envelope, else LINE), flat `set` envelope, command-as-root, the error taxonomy. +- Reuse fork `A`'s parser/framing ([commands.cpp]) as a **skeleton only**; **discard its + hand-printed `Serial.printf("{…}")` bodies** — they are exactly the per-command + format-strings the spec forbids. Each command instead supplies a **tree-builder** that + consumes the core's typed result. +- **Snapshot commands → build a small tree → serialize.** **Measurement commands + (`arrun`/`q`/MPF) → stream one well-formed JSON value** (an array of frame objects) into + the command's single `set` position — no `stream_start`/`stream_end` side-objects, no + raw bytes (those corrupt the envelope). Exact shape per **D6** (HW-verified). +- ArduinoJson is pulled in **only** for the cloud env (§11); the `ambyte` image stays JSON-free. +- Brings the two `A`-only verbs (`set_pd_gain`, `read_light_env`) into the core (D4). + +### 7d. The shared openJII comms module (`lib/openjii_proto/`) — device-agnostic (D5) +The protocol machinery is **not** amBIT-specific. Factor spec §11's five pieces into a +reusable library other firmware can adopt verbatim: + +1. **Receiver** — first-non-whitespace byte selects mode; string-aware brace/bracket-depth + detects JSON completeness; overflow → `{"error":"rx_overflow"}`, JSON idle 1 s → + `{"error":"json_timeout"}`. +2. **JSON serializer** (strict JSON) + **3. scalar-aware LINE serializer** (scalar → bare, + container → JSON). +4. **Path resolver** — `.`-walk (map key / array index) + `keys()`, with the §9 error set. +5. **Envelope writer** — header → flat `set` (one element per executed command/repeat) → + frame token. + +Device-facing API is tiny: per command, the device registers a **tree-builder** (snapshot) +or a **stream-writer** (measurement) that consumes a core typed result. amBIT supplies +those; the module knows nothing about amBIT. Built **fresh** to the spec (CO2Dot too old — +D5); iterate the spec via HW tests (D5/D6 workflow). + +**Wire-convention boundary (the key correctness rule):** normalization happens in the +adapter. Example — gains: binary subtracts 1 and validates 1..6; text/JSON pass the raw +0-indexed value. The core only ever sees 0-indexed gains. + +--- + +## 8. Wrench deletion (D1) + +Tracing (this session) established Wrench's full footprint: + +- **Single entry point:** [do_command.h:60] `case hash("C")` reads chars until `?` and + calls `do_c(c)`. Text/computer console only. +- **Never on the binary or app paths:** [run_esp.cpp] has no Wrench reference; `H` never + sends a `C` script; fork `A` already shipped without Wrench. +- **Zero unique commands.** `do_c.cpp` registers 11 native fns (`set_currents`, + `set_gains`, `config`/`detector_preset`, `set_arr`, `reset`, `run`, `run_mpf`, + `get_par`, `get_temp`, `print`, `disp`) — every one is a thin wrapper over a core fn + that already exists as a text verb **and** a binary opcode. (`idle` is defined but + never registered — dead even inside the VM.) +- **It is the 3rd config copy:** `do_c.cpp`'s `set_currents`/`set_gains` write file-local + statics independent of both other configs. +- **It owns the `arr_reset` overflow** (sweep #5, now gone with it) and an 8-slot `wr_run_arr[]` + store referenced nowhere else. + +**Action:** delete `src/src/wrench.{cpp,h}`, `src/do_c.cpp`, the `C` case, and all +`#include "src/wrench.h"`. The only capability lost is **on-device control-flow scripting** +(loops/variables/the 8 pre-loaded array slots) on the bench console — which moves +host-side, matching how the ambyte and app already operate. + +**Wins:** −17.4k LOC from the default image, −1 config copy, −1 buffer overflow, −1 dead fn. + +--- + +## 9. PAM / data_utils / sink unification (folded) + +`PAM.cpp` diverged on two orthogonal axes — treat separately. + +- **Axis A (transport):** fork `A`'s `json_output` bool + 5-arg `run_arr_type1` overload + vs `T`'s `CONNECTION_TYPE` branches. **Resolution:** keep `T`'s structure; fold `A`'s + JSON branch in as `case CLOUD` at each send site (~4: `run_arr_type1`, + `external_trigger_run`, `MPF`, the env path). Delete the 5-arg overload + `json_output`. +- **Axis B (semantics):** the D2 centi-°C encoding and D3 ambient correction already + live in `T` ([PAM.cpp] diffs confirmed). Keep them; rewrite fork `A`'s + `send_env_json_decoded` for centi-°C (its old-format unpack is stale — sweep #7). +- `data_utils.cpp`: base = `T` (full FSM send + the **required** byte-sum checksum, §2). + **Re-graft `send_json(const char*)`** from `A` for the `CLOUD` sink (~10 lines, decl in + [data_utils.h]). +- While here, sweep the cheap co-located correctness items (uninit locals #10, + leak-on-early-return #11, unaligned `*(float*)&cmd_arr[3]` → `memcpy` #12). +- *Out of scope:* the `dataclass` ring-buffer over-engineering (#18). + +--- + +## 10. main loop + text-path framing (de-obscure, text only) + +Base = `T`'s [ambit-1.ino] (it has the power management — **keep**: `ambit_light_sleep()`, +UART/GPIO sleep-wake config, sleep thresholds, `AMBIT_BOOT_IDLE` heartbeat, triple-tap-BOOT +reset ISR). + +**Cherry-pick fork `A`'s framing** ([ambit-1.ino:89-111] in `A`) as the de-obscuring fix +for sweep #20: decide LINE vs JSON by the **first printable char** and drop junk +bytes while mode is `UNKNOWN`, instead of `T`'s glitch-sensitive `c > 127` MSB heuristic +that mis-fires on the DTR/RTS open glitch and emits `Unknown cmd`. This is a **text-path** +change and does not touch the binary contract. + +Also (sweep #16): **stop echoing parsed bytes** in `serial_read_until`/`flush_serial` +— that echo currently injects bytes into the binary stream that `H` has to discard as +"debug/echo bytes" ([uart_sensors.c:382]). Move these helpers' single definition into +`serial.*` (kills the 4-TU re-declaration, #15). + +**Variant separation over runtime auto-detect.** The ambyte is a separate product on a +dedicated FFC UART; the app is USB-CDC. Prefer **build-flag-separated frontends** (§11.5) +to runtime first-byte transport sniffing — cleaner and less bug-prone. Keep the framed/junk- +drop fix for robustness either way. + +--- + +## 11. platformio.ini + build flags + +```ini +[platformio] +default_envs = ambyte + +[env] +platform = espressif32 +board = esp32-c3-devkitm-1 +framework = arduino +monitor_speed = 115200 +build_flags = -DDEBUG=0 + +[env:ambyte] ; binary FSM over UART0/FFC, light-sleep +build_flags = + ${env.build_flags} + -DARDUINO_USB_CDC_ON_BOOT=0 + -DVARIANT_AMBYTE=1 + +[env:cloud] ; text+JSON over native USB-CDC +build_flags = + ${env.build_flags} + -DARDUINO_USB_MODE=1 + -DARDUINO_USB_CDC_ON_BOOT=1 + -DUSB_VID=0x16C0 + -DUSB_PID=0x0483 + '-DUSB_MANUFACTURER="JII"' + '-DUSB_PRODUCT="Ambit"' + -DVARIANT_CLOUD=1 +lib_deps = ${env.lib_deps} + bblanchon/ArduinoJson ; only the cloud image pays for JSON +``` + +- `VARIANT_AMBYTE` → binary adapter + FSM + light-sleep idle loop. +- `VARIANT_CLOUD` → JSON/line adapter + `send_json` + (D4) `read_light_env`. +- **No `ENABLE_WRENCH`** — Wrench is deleted (D1). +- Core (`core.*`, drivers, `AmbitConfig`) compiles in both. +- After changing envs, delete the per-env `sdkconfig.*` so it regenerates. + +### Coverage matrix (every dialect → the §5 core ops) + +| Core op | text (`do_command`) | binary (`run_esp` cmd) | JSON (`commands`) | +|---|:--:|:--:|:--:| +| set_currents | ✓ | 2 | ✓ | +| set_gains | ✓ | 1 | ✓ | +| set_pd_gain (D4) | — | (1) | ✓ | +| config_detector | (via run) | 10 | (via run) | +| run_array | `arrun` | 21 | `arrun` | +| run_mpf | `q` | 20 | `q` | +| get_par | ✓ | 31 | ✓ | +| get_temp / _raw | `temp` | 32 / 34 | `temp` | +| baseline | ✓ | 6 | ✓ | +| set_actinic | ✓ | 4 | ✓ | +| set_name | ✓ | 37 | ✓ | +| set_metadata | — | 37 | — | +| set_emit / set_spec | ✓ | — | ✓ | +| external / flash trigger | `ww` / `ff` | — | `ww` / `ff` | +| read_light_env (D4) | — | — | ✓ | +| nvs clean / update | `clean_nvs` | 17 / 18 | `clean_nvs` | +| info / check | `check` | 33 | `check` | +| reboot | `reboot` | — | `reboot` | +| blink | `a`/`aa` | 5 | `a`/`aa` | + +--- + +## 12. Execution order (unification-first) + +1. **Branch + scaffold.** Branch off `fw_new`. Add `CLOUD` to the `CONNECTION_TYPES` + enum; add the two PIO envs + flags (§11). *Checkpoint: `ambyte` env still builds/runs.* +2. **Delete Wrench (D1, §8).** Remove `wrench.*`, `do_c.cpp`, the `C` case, includes. + *Checkpoint: `ambyte` builds; every former Wrench op still reachable as a text verb.* +3. **Unify CONFIG (§6).** Collapse the three copies into `AmbitConfig`. *Checkpoint: set + via text, run via binary → identical currents/gains applied.* +4. **Extract CORE (§5).** Move each command body into one core fn; point the text and + binary adapters at the shared fns. Normalize wire conventions at the adapter boundary. + *Checkpoint: every §11 row reachable from both `ambyte` and text, same numbers.* +5. **Consolidate serial helpers + drop echo (§10).** Single prototype in `serial.*`, + no echo-on-parse. *Checkpoint: clean binary round-trip, no stray echoed bytes.* +6. **PAM + data_utils sink merge (§9).** Add `case CLOUD`, re-graft `send_json`, rewrite + env-JSON for centi-°C, sweep #10/#11/#12. *Checkpoint: AMBYTE numbers byte-identical + to pre-merge `fw_new`; CLOUD JSON validated vs backend schema.* +7. **Port JSON adapter (§7c).** Bring `commands.cpp`'s parser onto the core as + `frontend_json.cpp` (cloud env only); delete `commands.cpp/.h`. +8. **main-loop framing (§10).** Adopt fork `A`'s first-printable-char framing on the text + path; keep `fw_new`'s power management. *Checkpoint: DTR/RTS open glitch no longer + emits `Unknown cmd`.* +9. **Build both envs; HW-test both variants (§14).** + +--- + +## 13. Frozen-contract conformance gate (§2) + +> **Runnable procedure: [HW_CONFORMANCE.md](HW_CONFORMANCE.md).** Step 4b (binary frontend +> → core) was **HW-verified byte-conformant on 2026-06-05** against a real ambyte. Keep the +> procedure as the reusable gate for later `run_esp.cpp` / FSM changes (Step 5+). + +Before merging the binary adapter changes (step 4–5), establish a regression artifact and +keep it green through every later step: + +- **Capture a golden byte trace** of the current `fw_new` ↔ `H` exchange for each binary + command (or derive the expected frames from [uart_sensors.c] + [ambit_protocol.h]): + wake/ack, the 8-byte cmd frame, `CMD_DONE`/`CMD_END`, raw response sizes, and a full FSM + data round-trip (header checksum, **byte-sum** data checksum, length encoding). +- **Assert byte-for-byte identity** of the refactored binary adapter's output against the + golden trace. Any diff = a contract break. +- Explicitly assert the obscure-but-frozen encodings: base-128 MPF length, 1-indexed + gains, struct sizes (136 / 48 / 248), `eof_mark==2025`. +- The conformance gate covers the **wire**; D2/D3 semantic changes are gated separately by + **consumer sign-off** (§3), since `H` forwards those arrays raw. + +--- + +## 14. Risks & test checklist + +| Risk | Mitigation | +|---|---| +| Refactoring the binary adapter breaks the wire contract with shipped ambytes | §13 golden-trace conformance gate, kept green every step; freeze fw_new binary behavior as reference | +| D2/D3 semantic changes alter measured values / cloud ingestion | Consumer sign-off before step 6; freeze AMBYTE numbers; branch raw-vs-corrected on `CLOUD` only if needed | +| Dropped step-marks were feeding `H`'s `mark_event_*` | Confirm with `H` owner before locking D2; else add a dedicated marker channel | +| CONFIG unification changes "when config is applied" semantics | Preserve set-then-apply-on-run; checkpoint 3 verifies cross-adapter equivalence | +| Wrench deletion removes a used scripting workflow | D1 stakeholder check first; move scripting host-side | + +**Per-variant test checklist** +- [ ] `ambyte`: full wake→length→data FSM round-trip to a real ambyte; **byte-sum checksum OK**. +- [ ] `ambyte`: idle current drops to light-sleep between commands; triple-tap BOOT resets; UART wakes within threshold. +- [ ] `cloud`: line + JSON over USB-CDC; `set_pd_gain`/`read_light_env` (if D4=keep). +- [ ] both: `set_currents`/`set_gains` from any adapter reflected in the run (config unify). +- [ ] both: `get_par`, `get_temp`, `baseline`, `arrun`, `run_mpf` expected output. +- [ ] regression: AMBYTE measurement numbers byte-identical vs pre-merge `fw_new`. +- [ ] glitch: opening the USB port (DTR/RTS) does not emit `Unknown cmd`. + +--- + +## Appendix — file-by-file actions + +Legend: `TRUNK`=take `fw_new` · `MERGE`=reconcile · `PORT`=bring `A` feature onto core · +`DROP`=remove · `KEEP`=unchanged. + +| File | Action | +|---|---| +| `wrench.{cpp,h}`, `do_c.cpp` | **DROP** (D1, §8) | +| `do_command.h` | **MERGE** → `frontend_text.cpp` (thin text adapter, §7b) | +| `run_esp.cpp` | **TRUNK + MERGE** → binary adapter, frozen wire, calls core (§7a) | +| `commands.cpp/.h` (fork `A`) | **SKELETON ONLY** → openJII shared module `lib/openjii_proto/` (§7c/§7d); discard hand-printed bodies | +| new `lib/openjii_proto/` | **NEW** — device-agnostic openJII comms module, built fresh to the spec (§7d, D5) | +| `PAM.cpp` / `PAM.h` | **MERGE** — `CONNECTION_TYPE` sinks + `CLOUD`; D2/D3 kept; D4 re-add (§9) | +| `data_utils.cpp` | **MERGE** — FSM + byte-sum checksum (keep) + re-graft `send_json` (§9) | +| `data_utils.h` | TRUNK + re-add `send_json` decl | +| `config.h` | TRUNK + add `CLOUD`; home of `AmbitConfig` (§6) | +| new `core.cpp/.h` | **NEW** — the unified operation set (§5) | +| `serial.cpp/.h` | TRUNK + absorb `serial_read_until`/`flush_serial`, drop echo (§10) | +| `ambit-1.ino` | **MERGE** — `fw_new` power mgmt + `A` text framing (§10) | +| `nvs1.*`, `self_test.cpp`, `devices_init.*`, `pin_config.h`, drivers | KEEP (identical) — nvs checksum `&`→`|` done (#6) | +| `platformio.ini` | **MERGE** — multi-env + flags (§11) | +| `open-jii/`, `*.ipynb` | OUT OF SCOPE (server/tooling, not firmware) | + +--- + +## Appendix B — correctness & cleanup catalog (folded from REFACTOR_PLAN) + +The single-fork review's items, folded here so this file is the only plan. Referenced +above as `sweep #N` / `#N` (original numbering kept). **Status:** ✅ done · ▶ owned by a +named step (do it there) · ☐ open sweep item (cheap, isolated — fold into the nearest +step) · ⏸ deferred/optional. Line numbers are current as of this session. + +| # | Item | Where (current) | Status | +|---|------|-----------------|--------| +| 1 | Wrench VM (17.4k LOC) for ~8 commands | `wrench.*`, `do_c.cpp` | ✅ deleted | +| 2 | Three parallel config copies | global / `run_esp` `_local` / `do_c` statics | ✅ unified to the PAM global | +| 3 | Massive dead code | `PAM.cpp` `/* */` blocks + `data_utils.cpp` `//` block | ✅ deleted (PAM.cpp 1913→1418, data_utils.cpp 716→561; commented-out, so **zero binary change** — Flash identical) | +| 4 | Measurement loop copy-pasted 5–6× | `PAM.cpp` `run_arr_type1`(153)/`run_trigger_spacer`(402)/`external_trigger_run`(580)/`_Flash`(727)/`MPF`(910)/`fluor_offset`(1319) | ▶ Step 4 — extract `PamBuffers` RAII + `read_one_frame()` + `send_results()` | +| 5 | `arr_reset` buffer overflow | was `do_c.cpp` | ✅ gone with Wrench | +| 6 | FW-info checksum `&`→`\|` | `nvs1.cpp:16` | ✅ fixed this session | +| 7 | `PAM_retrieve_env` decode vs centi-°C encode | `PAM.cpp` env path | ▶ Step 6 — rewrite for centi-°C (D2) | +| 8 | Truncating casts in parsing | `w` length clipped to uint8_t; `a`/`aa` pointless casts | ✅ done — `w` length now uint16_t, casts dropped | +| 9 | Non-void FSM fns miss returns (UB) | uncalled `fsm_send_waitesp` (missing return) + dead `fsm_wake_up_calls(void)` | ✅ both deleted (uncalled). Reset-guards N/A — per-run `dataclass` objects reset on construction | +| 10 | Uninitialized locals | `run_arr_type1`/`run_trigger_spacer`/`fluor_offset` comma-decls | ✅ initialized (behavior-neutral; were assigned before use) | +| 11 | Leaks on early return | `PAM.cpp:180-186` 7× `new dataclass` then `return -1` | ☐ stack-allocate `dataclass`, drop new/delete | +| 12 | Unaligned/strict-alias float reads (trap on C3) | `run_esp.cpp:234,242,294,317` `*((float*)&cmd_arr[..])` | ☐ `memcpy` — **frozen wire, bytes unchanged** | +| 13 | Protocol magic numbers scattered | `data_utils.h` vs literals (`ambit-1.ino:167`, `run_esp.cpp`) | ▶ §2 freezes them; centralize into one `proto` header | +| 14 | Pins half-symbolic | `digitalWrite(10/1,…)`, raw `GPIO_NUM_*` | ☐ name pin 10, use symbols | +| 15 | `serial_read_until` re-declared in 4 TUs | `data_utils.cpp`, `PAM.cpp`, `run_esp.cpp`, `ambit-1.ino:59` | ▶ Step 5 — one prototype in `serial.*` | +| 16 | `serial_read_until`/`flush_serial` echo non-target bytes onto the link | corrupts the binary stream | ▶ Step 5 — drop echo | +| 17 | `load_calibration_info` `isKey()`+`getX()` ×~20 | `nvs1.cpp` | ⏸ deferred — dropping `isKey` makes absent keys use the `getX` default not the struct default (config semantics, needs sign-off) | +| 18 | `dataclass` ring-buffer over-engineered | `data_utils.cpp:142` wrap path likely dead; inverted `length`/`_length` | ⏸ deferred (out of scope) | +| 19 | `hash()` dispatch silent-collision risk | `do_command.h:20` | ⏸ optional — `strcmp`/`string_view` table | +| 20 | `c > 127` mode-switch glitch-sensitive | `ambit-1.ino:164` | ▶ Step 8 — framed sync / first-printable-char (text path) | + +[CommunicationProtocolOpenJIISerial.md]: ../CommunicationProtocolOpenJIISerial.md +[uart_sensors.c]: ../ambyte-iot-ludo/components/uart_sensors/uart_sensors.c +[ambit_protocol.h]: ../ambyte-iot-ludo/components/device_commands/include/ambit_protocol.h +[device_commands.c]: ../ambyte-iot-ludo/components/device_commands/device_commands.c +[do_command.h]: src/do_command.h +[run_esp.cpp]: src/run_esp.cpp +[commands.cpp]: ../fw_appCompatible/src/commands.cpp +[PAM.cpp]: src/PAM.cpp +[data_utils.h]: src/data_utils.h +[data_utils.cpp]: src/data_utils.cpp +[config.h]: src/config.h +[ambit-1.ino]: src/ambit-1.ino +[core.cpp]: src/core.cpp +[core.h]: src/core.h From 3b97bc660af228b8b46c340263936feb9fbfd2d9 Mon Sep 17 00:00:00 2001 From: Ludo-lab Date: Wed, 17 Jun 2026 17:37:06 +0200 Subject: [PATCH 04/37] cloud: add get_gains / get_currents (read back staged ADPD config) Co-Authored-By: Claude Opus 4.8 (1M context) --- src/frontend_cloud.cpp | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) diff --git a/src/frontend_cloud.cpp b/src/frontend_cloud.cpp index 0ecb81d..29c0e4a 100644 --- a/src/frontend_cloud.cpp +++ b/src/frontend_cloud.cpp @@ -127,6 +127,22 @@ static void cmd_set_gains(const String& args, JsonVariant root) { root["Leaf"] = adpd_gains_config.Leaf; } +// ── config getters (read back the staged config; command-as-root) ─────────── +static void cmd_get_currents(const String& args, JsonVariant root) { + root["I620"] = adpd_current_config.I620; + root["I720"] = adpd_current_config.I720; + root["IR"] = adpd_current_config.IR; +} + +static void cmd_get_gains(const String& args, JsonVariant root) { + root["Fluo"] = adpd_gains_config.Fluo; + root["FluoRef"] = adpd_gains_config.FluoRef; + root["IR"] = adpd_gains_config.IR; + root["IRRef"] = adpd_gains_config.IRRef; + root["Sun"] = adpd_gains_config.Sun; + root["Leaf"] = adpd_gains_config.Leaf; +} + // printf reaches the ESP-IDF console (USB-Serial/JTAG) regardless of CDC DTR, so // these per-step markers show exactly where init reaches / hangs. #define INIT_STEP(label, expr) do { printf("[init] " label "...\n"); expr; printf("[init] " label " ok\n"); } while (0) @@ -168,6 +184,8 @@ void cloud_setup() { ojii::on("PAR", cmd_PAR); ojii::on("set_currents", cmd_set_currents); ojii::on("set_gains", cmd_set_gains); + ojii::on("get_currents", cmd_get_currents); + ojii::on("get_gains", cmd_get_gains); ojii::on_stream("arrun", cmd_arrun); printf("[init] Ready (cloud)\n"); From 0e537765f395554f55afb94c034c355577588cfd Mon Sep 17 00:00:00 2001 From: Ludo-lab Date: Wed, 17 Jun 2026 17:37:31 +0200 Subject: [PATCH 05/37] cloud mode --- platformio.ini | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/platformio.ini b/platformio.ini index 251f088..a5eb754 100644 --- a/platformio.ini +++ b/platformio.ini @@ -7,7 +7,7 @@ ; "opening dependency file <...>.cpp.d: No such file or directory" on a clean build. ; LOCALAPPDATA is local-only (and, unlike TEMP, not auto-cleaned). build_dir = ${sysenv.LOCALAPPDATA}/pio_build/ambit_fw_new -default_envs = ambyte +default_envs = cloud ; ── shared base ───────────────────────────────────────────────────────────── [env] @@ -43,3 +43,4 @@ build_flags = build_flags = -DARDUINO_USB_CDC_ON_BOOT=0 ; Serial -> UART0 (GPIO20 RX / 21 TX) -DVARIANT_CLOUD=1 + From c4b7ccdcdd8ce1a60c82cc399359ec5443aebbfb Mon Sep 17 00:00:00 2001 From: Ludo-lab Date: Wed, 17 Jun 2026 17:37:59 +0200 Subject: [PATCH 06/37] cloud mode --- src/ambit-1.ino.cpp | 212 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 212 insertions(+) create mode 100644 src/ambit-1.ino.cpp diff --git a/src/ambit-1.ino.cpp b/src/ambit-1.ino.cpp new file mode 100644 index 0000000..c0582d8 --- /dev/null +++ b/src/ambit-1.ino.cpp @@ -0,0 +1,212 @@ +# 1 "C:\\Users\\LUDOVI~1\\AppData\\Local\\Temp\\tmpf7rss69b" +#include +# 1 "C:/Users/LudovicoCaracciolo/Documents/Git-repo/ambit-IoT/src/ambit-1.ino" +#include +#include "src/devices_init.h" +#include "src/adpd/u_adpd6100.h" +#include "src/as7341/spec_meas.h" +#include "src/mlx90632/u_mlx.h" +#include "serial.h" +#include "do_command.h" +#include "config.h" +#include "driver/uart.h" +#include "driver/gpio.h" +#include +#include "Esp.h" +#include "nvs1.h" + +static const char* TAG = "INO"; +ADPD6 adpd; +Preferences preferences; +uint8_t CONNECTION_TYPE = 0; +bool FLAG_DEICE = false; +static uint16_t sleep_threshod_ms = 100; + +static struct Reset_Button{ + unsigned int previous_toggle_t = millis(); + unsigned int counter = 0; +}RB; +void ARDUINO_ISR_ATTR RB_toggle(); +void ambit_light_sleep(); +void setup(); +void loop(); +#line 27 "C:/Users/LudovicoCaracciolo/Documents/Git-repo/ambit-IoT/src/ambit-1.ino" +void ARDUINO_ISR_ATTR RB_toggle(){ + unsigned int t = millis(); + unsigned int dt = t - RB.previous_toggle_t; + RB.previous_toggle_t = t; + + if ((dt > 8) && (dt < 12)){ + RB.counter += 1; + }else{ + RB.counter = 0; + } + if (RB.counter > 3){ + RB.counter = 0; + esp_restart(); + return; + } + return; +} + + +void ambit_light_sleep(){ + detachInterrupt(BOOT_PIN); + gpio_sleep_set_direction(GPIO_NUM_9, GPIO_MODE_INPUT); + gpio_sleep_set_pull_mode(GPIO_NUM_9, GPIO_PULLUP_ONLY); + gpio_wakeup_enable(GPIO_NUM_9, GPIO_INTR_LOW_LEVEL); + esp_sleep_enable_gpio_wakeup(); + esp_light_sleep_start(); + attachInterrupt(BOOT_PIN, RB_toggle, CHANGE); +} + + + + +int serial_read_until(uint8_t target1, uint8_t target2 = 0, uint8_t target3 = 0, uint16_t timeout = 20, bool remove = false); +uint16_t flush_serial(uint8_t timeout); +void setup(){ +#ifdef VARIANT_CLOUD + extern void cloud_setup(); + cloud_setup(); + return; +#endif + esp_timer_early_init(); + pinMode(STF_FLASH_PIN, OUTPUT); + pinMode(BOOT_PIN, INPUT_PULLUP); + digitalWrite(STF_FLASH_PIN, LOW); + pinMode(10, OUTPUT); + digitalWrite(10, LOW); + attachInterrupt(BOOT_PIN, RB_toggle, CHANGE); + + + Serial.begin(115200); + delay(250); + Serial.println("BOOT"); + Serial.println(esp_timer_get_time()); + Serial.setTimeout(50); + + + + + esp_log_level_set("*", ESP_LOG_NONE); + + + digitalWrite(STF_FLASH_PIN, HIGH); + delayMicroseconds(1); + digitalWrite(STF_FLASH_PIN, LOW); + init_i2c_bus(); + init_spi_bus(); + adpd.begin(); + if (as7341.begin()) ESP_LOGV(TAG, "AS7341 Found"); + check_AS7341(); + AS_LED_OFF(); + mlx_init(); + CONNECTION_TYPE = CONNECTION_TYPES::COMPUTER; + + uart_set_wakeup_threshold(UART_NUM_0, 3); + esp_sleep_enable_uart_wakeup(UART_NUM_0); + + gpio_sleep_set_direction(GPIO_NUM_20, GPIO_MODE_INPUT); + gpio_sleep_set_pull_mode(GPIO_NUM_20, GPIO_PULLUP_ONLY); + + gpio_sleep_set_direction(GPIO_NUM_1, GPIO_MODE_OUTPUT); + gpio_sleep_set_pull_mode(GPIO_NUM_1, GPIO_PULLDOWN_ONLY); + + load_info_from_nvs(true); + + + Serial.write(AMBIT_BOOT_IDLE); + + esp_sleep_enable_timer_wakeup(10000000); + + + FLAG_DEICE = false; + +} + + +int do_esp_cmd(); +int c = -1; +char choose[50]; + +void loop(){ +#ifdef VARIANT_CLOUD + extern void cloud_loop(); + cloud_loop(); + return; +#endif + c = -1; + int b; + unsigned int sleep_timer = millis(); + + for (;;) { + c = Serial.available(); + if (c > 0){ + sleep_timer = millis(); + c = Serial.peek(); + if (c == 255) Serial.read(); + if (c < 255) break; + }else{ + if (millis() - sleep_timer > sleep_threshod_ms){ + + + Serial.flush(); + flush_serial(20); + ambit_light_sleep(); + c = esp_sleep_get_wakeup_cause(); + sleep_timer = millis(); + if (c == 8){ + sleep_threshod_ms = 1000; + }else{ + sleep_threshod_ms = 200; + } + + Serial.write(AMBIT_BOOT_IDLE); + Serial.flush(); + + + + + + }else{ + delay(10); + + } + } + + } + + c = Serial.peek(); + if (c > 127) { + while (Serial.available() > 0){ + + b = serial_read_until(170, 160, 222, 50, false); + if (b == 1){ + flush_serial(5); + Serial.write(128); + sleep_threshod_ms = 500; + }else if(b == 2){ + do_esp_cmd(); + break; + }else if (b == 3){ + ESP_LOGE(TAG, "OUT of sync"); + Serial.read(); + Serial.write(128); + }else{ + ESP_LOGE(TAG, "Unknown cmd %d", c); + Serial.read(); + Serial.write(128); + break; + } + } + + }else{ + sleep_threshod_ms = 30000; + Serial_Input_Chars(choose, ":,", 200, sizeof(choose) - 1); + do_command(choose); + + } + + +} \ No newline at end of file From 50f0a8dd994bc697364e42e7fc54b6e98b92e26b Mon Sep 17 00:00:00 2001 From: Ludo-lab Date: Wed, 17 Jun 2026 17:39:52 +0200 Subject: [PATCH 07/37] cloude mode --- src/ambit-1.ino.cpp | 212 -------------------------------------------- 1 file changed, 212 deletions(-) delete mode 100644 src/ambit-1.ino.cpp diff --git a/src/ambit-1.ino.cpp b/src/ambit-1.ino.cpp deleted file mode 100644 index c0582d8..0000000 --- a/src/ambit-1.ino.cpp +++ /dev/null @@ -1,212 +0,0 @@ -# 1 "C:\\Users\\LUDOVI~1\\AppData\\Local\\Temp\\tmpf7rss69b" -#include -# 1 "C:/Users/LudovicoCaracciolo/Documents/Git-repo/ambit-IoT/src/ambit-1.ino" -#include -#include "src/devices_init.h" -#include "src/adpd/u_adpd6100.h" -#include "src/as7341/spec_meas.h" -#include "src/mlx90632/u_mlx.h" -#include "serial.h" -#include "do_command.h" -#include "config.h" -#include "driver/uart.h" -#include "driver/gpio.h" -#include -#include "Esp.h" -#include "nvs1.h" - -static const char* TAG = "INO"; -ADPD6 adpd; -Preferences preferences; -uint8_t CONNECTION_TYPE = 0; -bool FLAG_DEICE = false; -static uint16_t sleep_threshod_ms = 100; - -static struct Reset_Button{ - unsigned int previous_toggle_t = millis(); - unsigned int counter = 0; -}RB; -void ARDUINO_ISR_ATTR RB_toggle(); -void ambit_light_sleep(); -void setup(); -void loop(); -#line 27 "C:/Users/LudovicoCaracciolo/Documents/Git-repo/ambit-IoT/src/ambit-1.ino" -void ARDUINO_ISR_ATTR RB_toggle(){ - unsigned int t = millis(); - unsigned int dt = t - RB.previous_toggle_t; - RB.previous_toggle_t = t; - - if ((dt > 8) && (dt < 12)){ - RB.counter += 1; - }else{ - RB.counter = 0; - } - if (RB.counter > 3){ - RB.counter = 0; - esp_restart(); - return; - } - return; -} - - -void ambit_light_sleep(){ - detachInterrupt(BOOT_PIN); - gpio_sleep_set_direction(GPIO_NUM_9, GPIO_MODE_INPUT); - gpio_sleep_set_pull_mode(GPIO_NUM_9, GPIO_PULLUP_ONLY); - gpio_wakeup_enable(GPIO_NUM_9, GPIO_INTR_LOW_LEVEL); - esp_sleep_enable_gpio_wakeup(); - esp_light_sleep_start(); - attachInterrupt(BOOT_PIN, RB_toggle, CHANGE); -} - - - - -int serial_read_until(uint8_t target1, uint8_t target2 = 0, uint8_t target3 = 0, uint16_t timeout = 20, bool remove = false); -uint16_t flush_serial(uint8_t timeout); -void setup(){ -#ifdef VARIANT_CLOUD - extern void cloud_setup(); - cloud_setup(); - return; -#endif - esp_timer_early_init(); - pinMode(STF_FLASH_PIN, OUTPUT); - pinMode(BOOT_PIN, INPUT_PULLUP); - digitalWrite(STF_FLASH_PIN, LOW); - pinMode(10, OUTPUT); - digitalWrite(10, LOW); - attachInterrupt(BOOT_PIN, RB_toggle, CHANGE); - - - Serial.begin(115200); - delay(250); - Serial.println("BOOT"); - Serial.println(esp_timer_get_time()); - Serial.setTimeout(50); - - - - - esp_log_level_set("*", ESP_LOG_NONE); - - - digitalWrite(STF_FLASH_PIN, HIGH); - delayMicroseconds(1); - digitalWrite(STF_FLASH_PIN, LOW); - init_i2c_bus(); - init_spi_bus(); - adpd.begin(); - if (as7341.begin()) ESP_LOGV(TAG, "AS7341 Found"); - check_AS7341(); - AS_LED_OFF(); - mlx_init(); - CONNECTION_TYPE = CONNECTION_TYPES::COMPUTER; - - uart_set_wakeup_threshold(UART_NUM_0, 3); - esp_sleep_enable_uart_wakeup(UART_NUM_0); - - gpio_sleep_set_direction(GPIO_NUM_20, GPIO_MODE_INPUT); - gpio_sleep_set_pull_mode(GPIO_NUM_20, GPIO_PULLUP_ONLY); - - gpio_sleep_set_direction(GPIO_NUM_1, GPIO_MODE_OUTPUT); - gpio_sleep_set_pull_mode(GPIO_NUM_1, GPIO_PULLDOWN_ONLY); - - load_info_from_nvs(true); - - - Serial.write(AMBIT_BOOT_IDLE); - - esp_sleep_enable_timer_wakeup(10000000); - - - FLAG_DEICE = false; - -} - - -int do_esp_cmd(); -int c = -1; -char choose[50]; - -void loop(){ -#ifdef VARIANT_CLOUD - extern void cloud_loop(); - cloud_loop(); - return; -#endif - c = -1; - int b; - unsigned int sleep_timer = millis(); - - for (;;) { - c = Serial.available(); - if (c > 0){ - sleep_timer = millis(); - c = Serial.peek(); - if (c == 255) Serial.read(); - if (c < 255) break; - }else{ - if (millis() - sleep_timer > sleep_threshod_ms){ - - - Serial.flush(); - flush_serial(20); - ambit_light_sleep(); - c = esp_sleep_get_wakeup_cause(); - sleep_timer = millis(); - if (c == 8){ - sleep_threshod_ms = 1000; - }else{ - sleep_threshod_ms = 200; - } - - Serial.write(AMBIT_BOOT_IDLE); - Serial.flush(); - - - - - - }else{ - delay(10); - - } - } - - } - - c = Serial.peek(); - if (c > 127) { - while (Serial.available() > 0){ - - b = serial_read_until(170, 160, 222, 50, false); - if (b == 1){ - flush_serial(5); - Serial.write(128); - sleep_threshod_ms = 500; - }else if(b == 2){ - do_esp_cmd(); - break; - }else if (b == 3){ - ESP_LOGE(TAG, "OUT of sync"); - Serial.read(); - Serial.write(128); - }else{ - ESP_LOGE(TAG, "Unknown cmd %d", c); - Serial.read(); - Serial.write(128); - break; - } - } - - }else{ - sleep_threshod_ms = 30000; - Serial_Input_Chars(choose, ":,", 200, sizeof(choose) - 1); - do_command(choose); - - } - - -} \ No newline at end of file From 875bc4cad56407e2617f74db98dbb4731e3e5e4c Mon Sep 17 00:00:00 2001 From: Ludo-lab Date: Wed, 17 Jun 2026 21:37:42 +0200 Subject: [PATCH 08/37] Add CERN-OHL-S-2.0 licence --- LICENSE.txt | 289 ++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 289 insertions(+) create mode 100644 LICENSE.txt diff --git a/LICENSE.txt b/LICENSE.txt new file mode 100644 index 0000000..114486f --- /dev/null +++ b/LICENSE.txt @@ -0,0 +1,289 @@ +CERN Open Hardware Licence Version 2 - Strongly Reciprocal + + +Preamble + +CERN has developed this licence to promote collaboration among +hardware designers and to provide a legal tool which supports the +freedom to use, study, modify, share and distribute hardware designs +and products based on those designs. Version 2 of the CERN Open +Hardware Licence comes in three variants: CERN-OHL-P (permissive); and +two reciprocal licences: CERN-OHL-W (weakly reciprocal) and this +licence, CERN-OHL-S (strongly reciprocal). + +The CERN-OHL-S is copyright CERN 2020. Anyone is welcome to use it, in +unmodified form only. + +Use of this Licence does not imply any endorsement by CERN of any +Licensor or their designs nor does it imply any involvement by CERN in +their development. + + +1 Definitions + + 1.1 'Licence' means this CERN-OHL-S. + + 1.2 'Compatible Licence' means + + a) any earlier version of the CERN Open Hardware licence, or + + b) any version of the CERN-OHL-S, or + + c) any licence which permits You to treat the Source to which + it applies as licensed under CERN-OHL-S provided that on + Conveyance of any such Source, or any associated Product You + treat the Source in question as being licensed under + CERN-OHL-S. + + 1.3 'Source' means information such as design materials or digital + code which can be applied to Make or test a Product or to + prepare a Product for use, Conveyance or sale, regardless of its + medium or how it is expressed. It may include Notices. + + 1.4 'Covered Source' means Source that is explicitly made available + under this Licence. + + 1.5 'Product' means any device, component, work or physical object, + whether in finished or intermediate form, arising from the use, + application or processing of Covered Source. + + 1.6 'Make' means to create or configure something, whether by + manufacture, assembly, compiling, loading or applying Covered + Source or another Product or otherwise. + + 1.7 'Available Component' means any part, sub-assembly, library or + code which: + + a) is licensed to You as Complete Source under a Compatible + Licence; or + + b) is available, at the time a Product or the Source containing + it is first Conveyed, to You and any other prospective + licensees + + i) as a physical part with sufficient rights and + information (including any configuration and + programming files and information about its + characteristics and interfaces) to enable it either to + be Made itself, or to be sourced and used to Make the + Product; or + ii) as part of the normal distribution of a tool used to + design or Make the Product. + + 1.8 'Complete Source' means the set of all Source necessary to Make + a Product, in the preferred form for making modifications, + including necessary installation and interfacing information + both for the Product, and for any included Available Components. + If the format is proprietary, it must also be made available in + a format (if the proprietary tool can create it) which is + viewable with a tool available to potential licensees and + licensed under a licence approved by the Free Software + Foundation or the Open Source Initiative. Complete Source need + not include the Source of any Available Component, provided that + You include in the Complete Source sufficient information to + enable a recipient to Make or source and use the Available + Component to Make the Product. + + 1.9 'Source Location' means a location where a Licensor has placed + Covered Source, and which that Licensor reasonably believes will + remain easily accessible for at least three years for anyone to + obtain a digital copy. + + 1.10 'Notice' means copyright, acknowledgement and trademark notices, + Source Location references, modification notices (subsection + 3.3(b)) and all notices that refer to this Licence and to the + disclaimer of warranties that are included in the Covered + Source. + + 1.11 'Licensee' or 'You' means any person exercising rights under + this Licence. + + 1.12 'Licensor' means a natural or legal person who creates or + modifies Covered Source. A person may be a Licensee and a + Licensor at the same time. + + 1.13 'Convey' means to communicate to the public or distribute. + + +2 Applicability + + 2.1 This Licence governs the use, copying, modification, Conveying + of Covered Source and Products, and the Making of Products. By + exercising any right granted under this Licence, You irrevocably + accept these terms and conditions. + + 2.2 This Licence is granted by the Licensor directly to You, and + shall apply worldwide and without limitation in time. + + 2.3 You shall not attempt to restrict by contract or otherwise the + rights granted under this Licence to other Licensees. + + 2.4 This Licence is not intended to restrict fair use, fair dealing, + or any other similar right. + + +3 Copying, modifying and Conveying Covered Source + + 3.1 You may copy and Convey verbatim copies of Covered Source, in + any medium, provided You retain all Notices. + + 3.2 You may modify Covered Source, other than Notices, provided that + You irrevocably undertake to make that modified Covered Source + available from a Source Location should You Convey a Product in + circumstances where the recipient does not otherwise receive a + copy of the modified Covered Source. In each case subsection 3.3 + shall apply. + + You may only delete Notices if they are no longer applicable to + the corresponding Covered Source as modified by You and You may + add additional Notices applicable to Your modifications. + Including Covered Source in a larger work is modifying the + Covered Source, and the larger work becomes modified Covered + Source. + + 3.3 You may Convey modified Covered Source (with the effect that You + shall also become a Licensor) provided that You: + + a) retain Notices as required in subsection 3.2; + + b) add a Notice to the modified Covered Source stating that You + have modified it, with the date and brief description of how + You have modified it; + + c) add a Source Location Notice for the modified Covered Source + if You Convey in circumstances where the recipient does not + otherwise receive a copy of the modified Covered Source; and + + d) license the modified Covered Source under the terms and + conditions of this Licence (or, as set out in subsection + 8.3, a later version, if permitted by the licence of the + original Covered Source). Such modified Covered Source must + be licensed as a whole, but excluding Available Components + contained in it, which remain licensed under their own + applicable licences. + + +4 Making and Conveying Products + +You may Make Products, and/or Convey them, provided that You either +provide each recipient with a copy of the Complete Source or ensure +that each recipient is notified of the Source Location of the Complete +Source. That Complete Source is Covered Source, and You must +accordingly satisfy Your obligations set out in subsection 3.3. If +specified in a Notice, the Product must visibly and securely display +the Source Location on it or its packaging or documentation in the +manner specified in that Notice. + + +5 Research and Development + +You may Convey Covered Source, modified Covered Source or Products to +a legal entity carrying out development, testing or quality assurance +work on Your behalf provided that the work is performed on terms which +prevent the entity from both using the Source or Products for its own +internal purposes and Conveying the Source or Products or any +modifications to them to any person other than You. Any modifications +made by the entity shall be deemed to be made by You pursuant to +subsection 3.2. + + +6 DISCLAIMER AND LIABILITY + + 6.1 DISCLAIMER OF WARRANTY -- The Covered Source and any Products + are provided 'as is' and any express or implied warranties, + including, but not limited to, implied warranties of + merchantability, of satisfactory quality, non-infringement of + third party rights, and fitness for a particular purpose or use + are disclaimed in respect of any Source or Product to the + maximum extent permitted by law. The Licensor makes no + representation that any Source or Product does not or will not + infringe any patent, copyright, trade secret or other + proprietary right. The entire risk as to the use, quality, and + performance of any Source or Product shall be with You and not + the Licensor. This disclaimer of warranty is an essential part + of this Licence and a condition for the grant of any rights + granted under this Licence. + + 6.2 EXCLUSION AND LIMITATION OF LIABILITY -- The Licensor shall, to + the maximum extent permitted by law, have no liability for + direct, indirect, special, incidental, consequential, exemplary, + punitive or other damages of any character including, without + limitation, procurement of substitute goods or services, loss of + use, data or profits, or business interruption, however caused + and on any theory of contract, warranty, tort (including + negligence), product liability or otherwise, arising in any way + in relation to the Covered Source, modified Covered Source + and/or the Making or Conveyance of a Product, even if advised of + the possibility of such damages, and You shall hold the + Licensor(s) free and harmless from any liability, costs, + damages, fees and expenses, including claims by third parties, + in relation to such use. + + +7 Patents + + 7.1 Subject to the terms and conditions of this Licence, each + Licensor hereby grants to You a perpetual, worldwide, + non-exclusive, no-charge, royalty-free, irrevocable (except as + stated in subsections 7.2 and 8.4) patent license to Make, have + Made, use, offer to sell, sell, import, and otherwise transfer + the Covered Source and Products, where such licence applies only + to those patent claims licensable by such Licensor that are + necessarily infringed by exercising rights under the Covered + Source as Conveyed by that Licensor. + + 7.2 If You institute patent litigation against any entity (including + a cross-claim or counterclaim in a lawsuit) alleging that the + Covered Source or a Product constitutes direct or contributory + patent infringement, or You seek any declaration that a patent + licensed to You under this Licence is invalid or unenforceable + then any rights granted to You under this Licence shall + terminate as of the date such process is initiated. + + +8 General + + 8.1 If any provisions of this Licence are or subsequently become + invalid or unenforceable for any reason, the remaining + provisions shall remain effective. + + 8.2 You shall not use any of the name (including acronyms and + abbreviations), image, or logo by which the Licensor or CERN is + known, except where needed to comply with section 3, or where + the use is otherwise allowed by law. Any such permitted use + shall be factual and shall not be made so as to suggest any kind + of endorsement or implication of involvement by the Licensor or + its personnel. + + 8.3 CERN may publish updated versions and variants of this Licence + which it considers to be in the spirit of this version, but may + differ in detail to address new problems or concerns. New + versions will be published with a unique version number and a + variant identifier specifying the variant. If the Licensor has + specified that a given variant applies to the Covered Source + without specifying a version, You may treat that Covered Source + as being released under any version of the CERN-OHL with that + variant. If no variant is specified, the Covered Source shall be + treated as being released under CERN-OHL-S. The Licensor may + also specify that the Covered Source is subject to a specific + version of the CERN-OHL or any later version in which case You + may apply this or any later version of CERN-OHL with the same + variant identifier published by CERN. + + 8.4 This Licence shall terminate with immediate effect if You fail + to comply with any of its terms and conditions. + + 8.5 However, if You cease all breaches of this Licence, then Your + Licence from any Licensor is reinstated unless such Licensor has + terminated this Licence by giving You, while You remain in + breach, a notice specifying the breach and requiring You to cure + it within 30 days, and You have failed to come into compliance + in all material respects by the end of the 30 day period. Should + You repeat the breach after receipt of a cure notice and + subsequent reinstatement, this Licence will terminate + immediately and permanently. Section 6 shall continue to apply + after any termination. + + 8.6 This Licence shall not be enforceable except by a Licensor + acting as such, and third party beneficiary rights are + specifically excluded. From 4919aa3dfdc8a9c0ccd5881f2f0986c2aa4136b2 Mon Sep 17 00:00:00 2001 From: Ludo-lab Date: Fri, 19 Jun 2026 12:32:50 +0200 Subject: [PATCH 09/37] changed array name to be more transparent for user. Returns fluo = s_630/r_630 --- src/PAM.cpp | 46 +++++++++++++++++++++++++++++++++++------- src/frontend_cloud.cpp | 2 +- 2 files changed, 40 insertions(+), 8 deletions(-) diff --git a/src/PAM.cpp b/src/PAM.cpp index c94ccd1..43cb141 100644 --- a/src/PAM.cpp +++ b/src/PAM.cpp @@ -156,8 +156,8 @@ static void pam_send_results(dataclass* d_env, dataclass* d_fluor, dataclass* d_ bool has_730, bool allow_interrupt){ if (CONNECTION_TYPE == CONNECTION_TYPES::COMPUTER){ d_env->send_serial("env"); - d_fluor->send_serial("s_fluo"); - d_fluoRef->send_serial("r_fluo"); + d_fluor->send_serial("s_630"); + d_fluoRef->send_serial("r_630"); d_sun->send_serial("sun"); d_leaf->send_serial("leaf"); d_730->send_serial("s_730"); @@ -232,6 +232,27 @@ static void send_env_json(dataclass* d){ } Serial.print(']'); } + +// Cloud/openJII derived channel: fluo = s_630 / r_630 (signal / reference), one float +// per sample. Computed on-device only for the cloud build because the openJII sink +// consumes the JSON verbatim and does no math. MUST run BEFORE d_fluor / d_fluoRef are +// drained by send_json(): it reads arr[] directly and relies on read_ptr == 0 (nothing +// popped yet). den == 0 -> 0 (calc_signal floors the reference at 0 when dark dominates). +static void send_fluo_json(dataclass* num, dataclass* den){ + Serial.print("\"fluo\":["); + if (num->available && den->available){ + uint16_t n = num->get_length(); + uint16_t m = den->get_length(); + if (m < n) n = m; // defensive: emit only paired samples + for (uint16_t i = 0; i < n; i++){ + if (i > 0) Serial.print(','); + uint32_t d = den->arr[i]; + if (d == 0) Serial.print('0'); + else Serial.printf("%.5f", (double)num->arr[i] / (double)d); + } + } + Serial.print(']'); +} #endif int run_arr_type1(uint8_t length, uint8_t* arr, bool led_persist, bool allow_interrupt, bool json_output, bool retain){ @@ -313,7 +334,16 @@ int run_arr_type1(uint8_t length, uint8_t* arr, bool led_persist, bool allow_int adpd.run_freq(freq); adpd.clear_fifo(); light_sleep_time = (1000/freq); +#ifdef VARIANT_CLOUD + // Cloud/app path: exactly ONE env temperature per array, sampled once at the start + // (the unconditional d_env->put() before this loop). No in-run 2 s resampling, so + // env is a single {"temp_c":..} for every array — fast or slow. The ambyte binary + // path keeps the original cadence below: that env stream is part of the FROZEN wire + // contract with the datalogger, so its bytes must not change. + measure_temperature = false; +#else measure_temperature = (light_sleep_time > 20) && measure_temp && actinic < 50; +#endif if (_type == 1){ // use IR reflect @@ -441,11 +471,13 @@ int run_arr_type1(uint8_t length, uint8_t* arr, bool led_persist, bool allow_int #ifdef VARIANT_CLOUD - if (json_output) { // one JSON object: {"env":[..],"s_fluo":[..],...} + if (json_output) { // one JSON object: {"env":[..],"fluo":[..],"s_630":[..],...} Serial.print('{'); send_env_json(d_env); - Serial.print(','); d_fluor->send_json("s_fluo"); - Serial.print(','); d_fluoRef->send_json("r_fluo"); + // fluo first: it reads d_fluor/d_fluoRef before send_json() drains them. + Serial.print(','); send_fluo_json(d_fluor, d_fluoRef); + Serial.print(','); d_fluor->send_json("s_630"); + Serial.print(','); d_fluoRef->send_json("r_630"); if (d_sun->available) { Serial.print(','); d_sun->send_json("sun"); } if (d_leaf->available) { Serial.print(','); d_leaf->send_json("leaf"); } if (d_730->available) { Serial.print(','); d_730->send_json("s_730"); } @@ -1266,8 +1298,8 @@ int MPF(uint16_t mode, uint16_t current, uint16_t dc_current, uint8_t sign_gain, d_fluoRef->fsm_send_esp(1); } else{ - d_fluor->send_serial("s_fluo"); - d_fluoRef->send_serial("r_fluo"); + d_fluor->send_serial("s_630"); + d_fluoRef->send_serial("r_630"); Serial.println("Data sent"); } diff --git a/src/frontend_cloud.cpp b/src/frontend_cloud.cpp index 29c0e4a..3823ca6 100644 --- a/src/frontend_cloud.cpp +++ b/src/frontend_cloud.cpp @@ -88,7 +88,7 @@ static uint8_t arg_array8(const String& a, uint8_t from, uint8_t* arr, uint8_t m } // arrun,,,<8*len array bytes> — runs an array-mode measurement and -// emits one JSON object {"env":[..],"s_fluo":[..],...}. run_arr_type1's json_output +// emits one JSON object {"env":[..],"s_630":[..],...}. run_arr_type1's json_output // path writes it to Serial, which IS the openJII output stream in the cloud build. static void cmd_arrun(const String& args, Print& out) { uint8_t len = (uint8_t) arg_long(args, 0); From f4ffa07c1f6f5497090f187a524b607feb72fe8b Mon Sep 17 00:00:00 2001 From: dominikvrbic Date: Tue, 4 Aug 2026 12:35:02 +0200 Subject: [PATCH 10/37] docs: add AGENTS.md and CLAUDE.md agent guidance --- AGENTS.md | 88 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ CLAUDE.md | 7 +++++ 2 files changed, 95 insertions(+) create mode 100644 AGENTS.md create mode 100644 CLAUDE.md diff --git a/AGENTS.md b/AGENTS.md new file mode 100644 index 0000000..357ec3a --- /dev/null +++ b/AGENTS.md @@ -0,0 +1,88 @@ +--- +title: "AGENTS.md — ambit-iot firmware" +date: 2026-08-04 +generated_by: skills-for-architects +--- + +# AGENTS.md — ambit-iot firmware + +ESP32-C3 (Arduino framework via PlatformIO) firmware for the AMBIT leaf-sensor board: +ADPD6100 (fluorescence), AS7341 (spectral/PAR), MLX90632 (leaf temperature). An AMBIT is +either carried by an Ambyte datalogger (binary FSM over UART0/FFC) or driven directly by +the openJII app/host (text LINE + JSON over the same UART). One source tree builds both +product variants. + +## Commands + +- Build field variant: `pio run -e ambyte` — binary FSM protocol, light-sleep idle +- Build app variant: `pio run -e cloud` — openJII LINE/JSON protocol (default env) +- Flash: add `-t upload`; serial monitor: 115200 8N1 +- Linux/macOS quirk: `platformio.ini` sets `build_dir = ${sysenv.LOCALAPPDATA}/pio_build/…` + (Windows OneDrive/AV workaround). Off Windows, export something sane first, e.g. + `LOCALAPPDATA=$HOME/.cache pio run -e ambyte`. +- No automated test suite. The regression gate for anything touching `run_esp.cpp` or the + `data_utils.cpp` FSM is the hardware conformance procedure in `plans/HW_CONFORMANCE.md` + (byte-diff against a real Ambyte). + +## Architecture — one CORE + one CONFIG + thin transport adapters + +`plans/MERGE_PLAN.md` is the authoritative design doc (this tree is the merge of two +diverged forks); read it before structural changes. The spine: + +``` +wire bytes → [adapter: decode + undo wire conventions] → normalized args → core op → [sink] +``` + +- `src/core.{h,cpp}` — transport-agnostic command core. Takes normalized typed args + (gains 0-indexed, real widths), does **no** wire I/O: no Serial/printf/JSON. +- `src/config.h` + PAM globals — single config (`adpd_*_config`, `adpd_mode`) with + "set, then apply on run" semantics; setters mark it dirty, the run re-applies it. + `CONNECTION_TYPE` (PLOTTING / AMBYTE / COMPUTER) selects the output sink. +- Adapters: + - `src/run_esp.cpp` — binary/Ambyte adapter. **Frozen wire contract** (below). + - `src/do_command.h` — text/console verbs (`hash()` dispatch switch). + - `src/frontend_cloud.cpp` — openJII adapter (snapshot tree-builders + streamed + measurement values), gated on `VARIANT_CLOUD`. +- `lib/openjii_proto/` — device-agnostic openJII serial protocol module (first-byte + LINE-vs-JSON detect, envelope with flat `set`, dot-path queries, §9 error taxonomy). + Knows nothing about AMBIT; devices register snapshot/stream handlers. +- `src/PAM.cpp` — measurement engine (array runs, MPF, triggers, env logging); + `src/data_utils.cpp` — FSM data framing + checksums; `src/nvs1.*` — calibration, + metadata, and fw-info structs persisted in NVS; `src/src/` — sensor drivers. +- Variant gating: `-DVARIANT_AMBYTE` / `-DVARIANT_CLOUD` (see `platformio.ini`). The + ambyte image must link **no JSON** — ArduinoJson code exists only behind + `VARIANT_CLOUD` guards. + +## The frozen binary wire contract (do not break) + +The `ambyte` path is a wire contract with shipped Ambyte firmware. The source of truth is +the Ambyte repo (`ambyte-iot`): `components/uart_sensors/uart_sensors.c` and +`components/device_commands/include/ambit_protocol.h`. MERGE_PLAN §2 lists every frozen +element. Rules: + +- Refactor behind the wire freely; never change the bytes. Obscure-but-frozen encodings + stay: 1-indexed gains on the wire (stored −1), base-128 MPF length split + (`cmd[1]<<7 | cmd[2]`), byte-sum-mod-256 data checksum, struct sizes 136/48/248 with + `eof_mark==2025`. +- Wire conventions are decoded **in the adapter, never the core** — the core only ever + sees normalized values. +- Any change to the binary path re-runs `plans/HW_CONFORMANCE.md` before merge. +- UART0 doubles as the log console; the ambyte variant silences all ESP logging at boot + so ASCII can't interleave into the binary stream. + +## Version reporting (currently three divergent copies — keep in sync) + +- `src/nvs1.h` `MAJOR/MINOR/BATCH_VERSION` — the compiled fw version, reported over the + binary wire via info cmd 33 subtype 2; bump `BATCH_VERSION` every hosted build so a + post-OTA version read confirms the update landed. +- `src/frontend_cloud.cpp` `cmd_hello` hardcodes its own `"version"` string. +- The calibratron repo pins a minimum ambit fw version on its side. + +## Conventions + +- Heavy rationale comments are the house style — a constraint's *why* lives at its + definition (wire freezes, sleep thresholds, build-dir workaround). Keep it that way. +- Conventional Commits for commits and PR titles: `type(scope): description`. +- License: CERN-OHL-S-2.0 (hardware-adjacent open license — keep headers/attribution). +- Vendored driver libs under `src/src/` (as7341, adpd, mlx90632) are third-party + imports; don't reformat or "clean up" wholesale. diff --git a/CLAUDE.md b/CLAUDE.md new file mode 100644 index 0000000..1fb4cfd --- /dev/null +++ b/CLAUDE.md @@ -0,0 +1,7 @@ +# CLAUDE.md + +This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository. + +The canonical agent guidance lives in AGENTS.md (shared with Codex and other agents): + +@AGENTS.md From d5e9393b0ffac1c4e7a94107df473e1054d13861 Mon Sep 17 00:00:00 2001 From: dominikvrbic Date: Tue, 4 Aug 2026 12:40:32 +0200 Subject: [PATCH 11/37] feat(fw): single-image firmware with runtime host routing Merge the ambyte/cloud build variants into one image. First-byte router in loop(): >127 -> frozen binary FSM, '{'/'[' -> openJII JSON envelope, other printable -> legacy text console (what the openJII app driver and Calibratron parse). Sticky host latch keeps light sleep for the ambyte and disables it for non-retrying text/JSON hosts. Version is build-injected (tools/version.py) and now reported identically by cmd 33/2, hello (FW:), and the JSON identity; hw_rev claims a byte of the reserved cmd 33/2 slot. --- lib/openjii_proto/openjii_proto.cpp | 16 ++--- lib/openjii_proto/openjii_proto.h | 24 +++++-- platformio.ini | 35 ++++----- src/PAM.cpp | 32 ++++----- src/ambit-1.ino | 71 +++++++++++++------ src/do_command.h | 11 ++- src/{frontend_cloud.cpp => frontend_json.cpp} | 70 +++++------------- src/nvs1.cpp | 5 +- src/nvs1.h | 29 ++++++-- tools/version.py | 50 +++++++++++++ 10 files changed, 207 insertions(+), 136 deletions(-) rename src/{frontend_cloud.cpp => frontend_json.cpp} (72%) create mode 100644 tools/version.py diff --git a/lib/openjii_proto/openjii_proto.cpp b/lib/openjii_proto/openjii_proto.cpp index 94b9062..84b3150 100644 --- a/lib/openjii_proto/openjii_proto.cpp +++ b/lib/openjii_proto/openjii_proto.cpp @@ -1,7 +1,5 @@ // openjii_proto implementation — see openjii_proto.h and -// CommunicationProtocolOpenJIISerial.md. Gated on VARIANT_CLOUD. -#ifdef VARIANT_CLOUD - +// CommunicationProtocolOpenJIISerial.md. #include "openjii_proto.h" #include @@ -19,7 +17,7 @@ size_t s_ncmds = 0; struct SEntry { const char* name; StreamFn fn; }; SEntry s_streams[MAX_CMDS]; size_t s_nstreams = 0; -Identity s_id = { "device", "0", 0.0f }; +Identity s_id = { "device", "0", "0" }; // receiver state String s_rx; @@ -205,8 +203,8 @@ void handle_json(const String& doc_str, Print& out) { out.print("{\"device_name\":\""); out.print(s_id.device); out.print("\",\"device_version\":\""); out.print(s_id.version); - out.print("\",\"device_battery\":0,\"device_firmware\":"); out.print(s_id.firmware, 3); - out.print(",\"sample\":[{\"protocol_id\":\"NaN\",\"set\":["); + out.print("\",\"device_battery\":0,\"device_firmware\":\""); out.print(s_id.firmware); + out.print("\",\"sample\":[{\"protocol_id\":\"NaN\",\"set\":["); bool first = true; for (JsonObjectConst entry : list) { const char* label = entry["label"]; @@ -235,6 +233,10 @@ void on_stream(const char* name, StreamFn fn) { void identity(const Identity& id) { s_id = id; } +bool busy(void) { return s_mode != Mode::UNKNOWN || s_rx.length() > 0; } + +void reset(void) { reset_rx(); } + void poll(Stream& io) { while (io.available() > 0) { char c = (char)io.read(); @@ -288,5 +290,3 @@ void poll(Stream& io) { } } // namespace ojii - -#endif // VARIANT_CLOUD diff --git a/lib/openjii_proto/openjii_proto.h b/lib/openjii_proto/openjii_proto.h index 9cfeb80..65a08c9 100644 --- a/lib/openjii_proto/openjii_proto.h +++ b/lib/openjii_proto/openjii_proto.h @@ -9,9 +9,13 @@ // envelope writer, and the receiver. Measurement/STREAM commands (one streamed // JSON value per envelope position) are a separate API added once D6 is settled. // -// Whole module is gated on VARIANT_CLOUD so the ambyte image links no JSON. +// Single-image note: the module no longer owns the whole read loop. The device's +// main loop routes by first byte and feeds poll() only printable traffic (the +// binary FSM path must never reach it — poll() consumes bytes and silently drops +// >127 junk while unlocked). busy()/reset() exist for that router: busy() says an +// envelope is mid-frame and still owns the stream; reset() drops any stale +// partial input before the stream is handed to another protocol. #pragma once -#ifdef VARIANT_CLOUD #include #include @@ -31,8 +35,8 @@ using StreamFn = void (*)(const String& args, Print& out); struct Identity { const char* device; // e.g. "Ambit" -> hello.device, envelope device_name - const char* version; // e.g. "0.0.3" - float firmware; // e.g. 0.003f -> envelope device_firmware + const char* version; // e.g. "0.1.0" -> envelope device_version + const char* firmware; // e.g. "0.1.0" -> envelope device_firmware }; // Register a snapshot command (name is matched case-sensitively). @@ -48,6 +52,14 @@ void identity(const Identity& id); // is framed, dispatch it and write the response to `io`. Call every loop(). void poll(Stream& io); -} // namespace ojii +// True while a request is mid-frame (mode locked or bytes buffered). While busy, +// the receiver owns the stream: keep calling poll() (it also fires the JSON idle +// timeout) and do not route bytes elsewhere. +bool busy(void); + +// Drop any partial input and unlock the mode. Call before handing the stream to +// another protocol (e.g. the binary FSM path) so a stale fragment can't prepend +// to the next text command. +void reset(void); -#endif // VARIANT_CLOUD +} // namespace ojii diff --git a/platformio.ini b/platformio.ini index a5eb754..1ec6b17 100644 --- a/platformio.ini +++ b/platformio.ini @@ -6,10 +6,17 @@ ; which blocks fresh creation of .pio/build sub-dirs and makes the compiler fail with ; "opening dependency file <...>.cpp.d: No such file or directory" on a clean build. ; LOCALAPPDATA is local-only (and, unlike TEMP, not auto-cleaned). +; On Linux/macOS export it first, e.g.: LOCALAPPDATA=$HOME/.cache pio run build_dir = ${sysenv.LOCALAPPDATA}/pio_build/ambit_fw_new -default_envs = cloud +default_envs = ambit -; ── shared base ───────────────────────────────────────────────────────────── +; ── single image ───────────────────────────────────────────────────────────── +; One firmware serves every host at runtime by first-byte routing (ambit-1.ino +; loop()): binary FSM for the Ambyte over UART0/FFC (frozen wire, >127 framing +; bytes), the text console for the openJII app + Calibratron (bare printable +; lines), and the openJII JSON envelope ('{'/'[' first byte). Replaces the former +; ambyte/cloud build-variant pair: that split assumed the app variant would live +; on native USB-CDC, but all hosts ended up on the same UART0. [env] platform = espressif32 board = esp32-c3-devkitm-1 @@ -17,30 +24,18 @@ framework = arduino monitor_speed = 115200 ; Pin the dual-OTA partition layout explicitly. This is the Arduino-ESP32 4 MB ; default (otadata + ota_0/ota_1 1.25 MB each + spiffs) the board was already -; using implicitly — naming it guarantees a future build can't silently switch -; to a single-app scheme and break OTA. SAME layout = no NVS shift, so the +; using implicitly (naming it guarantees a future build can't silently switch +; to a single-app scheme and break OTA). SAME layout = no NVS shift, so the ; one-time bootstrap reflash preserves calibration. VERIFY a fielded unit's ; table matches before reflashing it (esptool read_flash 0x8000 0xc00). board_build.partitions = default.csv -; ArduinoJson is header-only: it is in the shared deps so the dependency finder -; resolves it across the #ifdef VARIANT_CLOUD guards, but it instantiates no code -; in the ambyte image (nothing there includes it). +; Version is injected at build time by tools/version.py (semantic-release tag +; in CI, git describe locally). It feeds cmd 33/2, `hello`, and the JSON identity. +extra_scripts = pre:tools/version.py lib_deps = adafruit/Adafruit BusIO bblanchon/ArduinoJson@^7 -; ── Field variant: binary FSM over UART0/FFC to the ambyte (HW-verified) ───── -[env:ambyte] -build_flags = - -DARDUINO_USB_CDC_ON_BOOT=0 ; Serial -> UART0 (GPIO20 RX / 21 TX), FFC to the ambyte - -DVARIANT_AMBYTE=1 - -; ── App variant: openJII LINE + JSON (CommunicationProtocolOpenJIISerial.md). -; This test HW has no native USB-C, so Serial is UART0 (GPIO20/21) — same wire as -; ambyte, just the LINE/JSON protocol. (For a future PCB with native USB, swap to -; ARDUINO_USB_MODE=1 / ARDUINO_USB_CDC_ON_BOOT=1 + USB_VID/PID/MANUFACTURER/PRODUCT.) -[env:cloud] +[env:ambit] build_flags = -DARDUINO_USB_CDC_ON_BOOT=0 ; Serial -> UART0 (GPIO20 RX / 21 TX) - -DVARIANT_CLOUD=1 - diff --git a/src/PAM.cpp b/src/PAM.cpp index 43cb141..07c40dd 100644 --- a/src/PAM.cpp +++ b/src/PAM.cpp @@ -217,8 +217,8 @@ void ambit_async_clear(void){ uint8_t ambit_async_get_state(void){ return g_async.state; } -#ifdef VARIANT_CLOUD -// Cloud/openJII env channel: fw_new stores leaf temp as centi-degC in the low 16 bits. +// openJII env channel: fw_new stores leaf temp as centi-degC in the low 16 bits. +// Used only on the json_output path (arrun via the JSON envelope). static void send_env_json(dataclass* d){ Serial.print("\"env\":["); if (d->available){ @@ -233,8 +233,8 @@ static void send_env_json(dataclass* d){ Serial.print(']'); } -// Cloud/openJII derived channel: fluo = s_630 / r_630 (signal / reference), one float -// per sample. Computed on-device only for the cloud build because the openJII sink +// openJII derived channel: fluo = s_630 / r_630 (signal / reference), one float +// per sample. Computed on-device only for the JSON path because the openJII sink // consumes the JSON verbatim and does no math. MUST run BEFORE d_fluor / d_fluoRef are // drained by send_json(): it reads arr[] directly and relies on read_ptr == 0 (nothing // popped yet). den == 0 -> 0 (calc_signal floors the reference at 0 when dark dominates). @@ -253,11 +253,8 @@ static void send_fluo_json(dataclass* num, dataclass* den){ } Serial.print(']'); } -#endif int run_arr_type1(uint8_t length, uint8_t* arr, bool led_persist, bool allow_interrupt, bool json_output, bool retain){ - (void) json_output; - if (adpd_mode != ADPD_CONFIG_MODE::ARRAY_MODE1){ conf_slow_FR_1(); ESP_LOGW(TAG, "Run array was not configured!"); @@ -334,16 +331,14 @@ int run_arr_type1(uint8_t length, uint8_t* arr, bool led_persist, bool allow_int adpd.run_freq(freq); adpd.clear_fifo(); light_sleep_time = (1000/freq); -#ifdef VARIANT_CLOUD - // Cloud/app path: exactly ONE env temperature per array, sampled once at the start + // JSON path: exactly ONE env temperature per array, sampled once at the start // (the unconditional d_env->put() before this loop). No in-run 2 s resampling, so - // env is a single {"temp_c":..} for every array — fast or slow. The ambyte binary - // path keeps the original cadence below: that env stream is part of the FROZEN wire - // contract with the datalogger, so its bytes must not change. - measure_temperature = false; -#else - measure_temperature = (light_sleep_time > 20) && measure_temp && actinic < 50; -#endif + // env is a single {"temp_c":..} for every array — fast or slow. All other paths + // keep the original cadence: that env stream is part of the FROZEN wire contract + // with the datalogger, so its bytes must not change. Runtime branch on + // json_output (was compile-time VARIANT_CLOUD) — same semantics per caller. + if (json_output) measure_temperature = false; + else measure_temperature = (light_sleep_time > 20) && measure_temp && actinic < 50; if (_type == 1){ // use IR reflect @@ -470,7 +465,6 @@ int run_arr_type1(uint8_t length, uint8_t* arr, bool led_persist, bool allow_int }; -#ifdef VARIANT_CLOUD if (json_output) { // one JSON object: {"env":[..],"fluo":[..],"s_630":[..],...} Serial.print('{'); send_env_json(d_env); @@ -483,9 +477,7 @@ int run_arr_type1(uint8_t length, uint8_t* arr, bool led_persist, bool allow_int if (d_730->available) { Serial.print(','); d_730->send_json("s_730"); } if (d_730Ref->available) { Serial.print(','); d_730Ref->send_json("r_730"); } Serial.print('}'); - } else -#endif - { + } else { d_timing->put((uint32_t) run_tick_begin); // Change 3: run start tick (us) d_timing->put((uint32_t) esp_timer_get_time()); // run end tick (us) if (retain){ diff --git a/src/ambit-1.ino b/src/ambit-1.ino index 7364882..1f3657a 100644 --- a/src/ambit-1.ino +++ b/src/ambit-1.ino @@ -11,6 +11,9 @@ #include #include "Esp.h" #include "nvs1.h" +#include "openjii_proto.h" + +void frontend_json_register(); // src/frontend_json.cpp static const char* TAG = "INO"; ADPD6 adpd; @@ -59,11 +62,6 @@ void ambit_light_sleep(){ int serial_read_until(uint8_t target1, uint8_t target2 = 0, uint8_t target3 = 0, uint16_t timeout = 20, bool remove = false); uint16_t flush_serial(uint8_t timeout); void setup(){ -#ifdef VARIANT_CLOUD - extern void cloud_setup(); - cloud_setup(); - return; -#endif esp_timer_early_init(); pinMode(STF_FLASH_PIN, OUTPUT); pinMode(BOOT_PIN, INPUT_PULLUP); @@ -108,7 +106,8 @@ void setup(){ load_info_from_nvs(true); - + frontend_json_register(); + Serial.write(AMBIT_BOOT_IDLE); esp_sleep_enable_timer_wakeup(10000000); @@ -123,16 +122,30 @@ int do_esp_cmd(); int c = -1; char choose[50]; +/* Sticky host latch: the first routed traffic decides the idle policy. + * BINARY/UNKNOWN keep the light-sleep idle (the ambyte re-sends its 0xAA wake + * until it gets the 0x80 ack, so bytes lost to sleep-wake are harmless). + * TEXT disables sleep entirely: the openJII app / Calibratron / a JSON host do + * NOT retry, and the UART sleep-wake (threshold 3 edges) eats the in-flight + * bytes, so a sleeping device would truncate `hello\n`. The latch releases + * after a long idle so a bench/phone device later installed on an ambyte + * regains light sleep without a reboot. */ +enum HostLatch : uint8_t { HOST_UNKNOWN = 0, HOST_BINARY, HOST_TEXT }; +static HostLatch host_latch = HOST_UNKNOWN; +static const unsigned int TEXT_LATCH_RELEASE_MS = 120000; + void loop(){ -#ifdef VARIANT_CLOUD - extern void cloud_loop(); - cloud_loop(); - return; -#endif + // An in-flight JSON envelope owns the stream until it completes or times + // out; poll() is what fires its 1 s idle timeout, so keep calling it. + if (ojii::busy()){ + ojii::poll(Serial); + if (ojii::busy()){ delay(1); return; } + } + c = -1; int b; unsigned int sleep_timer = millis(); - + for (;;) { c = Serial.available(); if (c > 0){ @@ -141,7 +154,12 @@ void loop(){ if (c == 255) Serial.read(); if (c < 255) break; }else{ - if (millis() - sleep_timer > sleep_threshod_ms){ + if (host_latch == HOST_TEXT){ + if (millis() - sleep_timer > TEXT_LATCH_RELEASE_MS){ + host_latch = HOST_UNKNOWN; + } + delay(10); + }else if (millis() - sleep_timer > sleep_threshod_ms){ Serial.flush(); @@ -153,8 +171,8 @@ void loop(){ sleep_threshod_ms = 1000; }else{ sleep_threshod_ms = 200; - } - + } + Serial.write(AMBIT_BOOT_IDLE); Serial.flush(); @@ -169,9 +187,16 @@ void loop(){ } } - + + /* First-byte router. Every frozen binary framing byte (0x80 0x85 0xA0 0xA1 + * 0xAA 0xB4 0xD2-0xD4 0xDE 0xF0) is >127; both text dialects are printable + * ASCII, and only the JSON envelope starts with '{' or '['. ojii::poll() + * must never see binary traffic (it consumes bytes and silently drops >127 + * junk while unlocked), hence peek-then-route. */ c = Serial.peek(); - if (c > 127) { // not from computer + if (c > 127) { // binary FSM to the ambyte (frozen wire) + host_latch = HOST_BINARY; + ojii::reset(); // a stale partial line must not prepend to later text while (Serial.available() > 0){ b = serial_read_until(170, 160, 222, 50, false); @@ -193,12 +218,18 @@ void loop(){ break; } } - + + }else if (c == '{' || c == '['){ // openJII JSON envelope + host_latch = HOST_TEXT; + ojii::poll(Serial); }else{ - sleep_threshod_ms = 30000; + // Text console: what the openJII app driver and the Calibratron speak. + // The old `sleep_threshod_ms = 30000` stay-awake heuristic is + // superseded by the TEXT latch. + host_latch = HOST_TEXT; Serial_Input_Chars(choose, ":,", 200, sizeof(choose) - 1); do_command(choose); - + } diff --git a/src/do_command.h b/src/do_command.h index 37ae9d6..950165c 100644 --- a/src/do_command.h +++ b/src/do_command.h @@ -58,9 +58,14 @@ void do_command(char *choose){ switch (val) { case hash("hello"): { - Serial.print("NEW Name Here"); - Serial.println(" Ready"); - } + // "NEW" and "Ready" are the sentinels the openJII app driver and the + // Calibratron match (substring / \bready\b); the name and FW: + // tokens are additive, both hosts tolerate them. + Serial.print("NEW "); + Serial.print(ambit_calibration_local.ambit_name); + Serial.print(" Ready FW:"); + Serial.println(AMBIT_FW_VERSION); + } break; int external_trigger_run(void); diff --git a/src/frontend_cloud.cpp b/src/frontend_json.cpp similarity index 72% rename from src/frontend_cloud.cpp rename to src/frontend_json.cpp index 3823ca6..3512036 100644 --- a/src/frontend_cloud.cpp +++ b/src/frontend_json.cpp @@ -1,12 +1,13 @@ -// frontend_cloud — cloud/app (USB-CDC) variant: wires the device's snapshot -// commands into the openJII protocol module and drives it. Gated on VARIANT_CLOUD -// so it is empty in the ambyte image. +// frontend_json — wires the device's snapshot commands into the openJII protocol +// module (was frontend_cloud, gated on the deleted VARIANT_CLOUD). In the single +// image the main loop routes only '{'/'[' envelope traffic here; bare printable +// lines keep their legacy do_command console replies (that text console is what +// the openJII app driver and the Calibratron actually parse), and openJII LINE +// mode is intentionally unreachable — it had no live consumer. // -// Increment 1: snapshot commands only (hello / temp / get_par / PAR). Measurement -// commands (arrun/q/mpf as one streamed JSON value per envelope position) are -// added once D6 — the app's exact in-envelope measurement shape — is settled. -#ifdef VARIANT_CLOUD - +// Measurement commands beyond arrun (q/mpf as one streamed JSON value per +// envelope position) are added once D6 — the app's exact in-envelope measurement +// shape — is settled. #include #include #include "openjii_proto.h" @@ -25,7 +26,7 @@ extern ADPD6 adpd; // defined in ambit-1.ino static void cmd_hello(const String& args, JsonVariant root) { root["device"] = "Ambit"; - root["version"] = "0.0.3"; + root["version"] = AMBIT_FW_VERSION; // build-injected, same source as cmd 33/2 and text hello root["name"] = ambit_calibration_local.ambit_name; } @@ -54,8 +55,6 @@ static void cmd_PAR(const String& args, JsonVariant root) { for (int i = 0; i < 10; i++) ch.add(spec[i]); } -// ── entry points called from ambit-1.ino under VARIANT_CLOUD ──────────────── - // ── measurement command (one streamed JSON value per envelope slot) ───────── // n-th comma token of `a` (token 0 is before the first comma). static long arg_long(const String& a, uint8_t n, long def = 0) { @@ -143,41 +142,12 @@ static void cmd_get_gains(const String& args, JsonVariant root) { root["Leaf"] = adpd_gains_config.Leaf; } -// printf reaches the ESP-IDF console (USB-Serial/JTAG) regardless of CDC DTR, so -// these per-step markers show exactly where init reaches / hangs. -#define INIT_STEP(label, expr) do { printf("[init] " label "...\n"); expr; printf("[init] " label " ok\n"); } while (0) - -void cloud_setup() { - // Pin setup + STF strobe pulse BEFORE device init — mirrors fork A's proven - // app-compatible startup; skipping the strobe can hang the detector init. - esp_timer_early_init(); - pinMode(STF_FLASH_PIN, OUTPUT); - digitalWrite(STF_FLASH_PIN, LOW); - pinMode(10, OUTPUT); - digitalWrite(10, LOW); - - Serial.begin(115200); - Serial.setTimeout(50); - printf("\n[init] boot (cloud)\n"); - esp_log_level_set("*", ESP_LOG_NONE); - - digitalWrite(STF_FLASH_PIN, HIGH); - delayMicroseconds(1); - digitalWrite(STF_FLASH_PIN, LOW); - - INIT_STEP("i2c_bus", init_i2c_bus()); - INIT_STEP("spi_bus", init_spi_bus()); - INIT_STEP("adpd", adpd.begin()); - INIT_STEP("as7341", as7341.begin()); - INIT_STEP("check_as", check_AS7341()); - INIT_STEP("led_off", AS_LED_OFF()); - INIT_STEP("mlx", mlx_init()); - INIT_STEP("nvs", load_info_from_nvs(false)); - - esp_log_level_set("*", ESP_LOG_NONE); // UART0 is also the protocol port — keep it clean - CONNECTION_TYPE = CONNECTION_TYPES::COMPUTER; - - ojii::identity({ "Ambit", "0.0.3", 0.003f }); +// Register the openJII envelope surface. Called once from setup() in +// ambit-1.ino; the device init itself lives there (single shared boot path). +// No printf/markers here: UART0 is the protocol port, and ASCII in front of a +// binary frame breaks the Ambyte session. +void frontend_json_register() { + ojii::identity({ "Ambit", AMBIT_FW_VERSION, AMBIT_FW_VERSION }); ojii::on("hello", cmd_hello); ojii::on("temp", cmd_temp); ojii::on("get_par", cmd_get_par); @@ -187,12 +157,4 @@ void cloud_setup() { ojii::on("get_currents", cmd_get_currents); ojii::on("get_gains", cmd_get_gains); ojii::on_stream("arrun", cmd_arrun); - - printf("[init] Ready (cloud)\n"); } - -void cloud_loop() { - ojii::poll(Serial); -} - -#endif // VARIANT_CLOUD diff --git a/src/nvs1.cpp b/src/nvs1.cpp index da1123d..72acb6b 100644 --- a/src/nvs1.cpp +++ b/src/nvs1.cpp @@ -13,8 +13,11 @@ static void get_FW_info(void){ ambit_FW_info.MAC = ESP.getEfuseMac(); ambit_FW_info.Size = ESP.getSketchSize(); strncpy(ambit_FW_info.FW_date, __DATE__, 12); + preferences.begin("config", true); + ambit_FW_info.hw_rev = preferences.getUChar("hw_rev", 0); + preferences.end(); ambit_FW_info.Checksum = 0xFF & ((MAJOR_VERSION << 4) | (MINOR_VERSION << 2) | (BATCH_VERSION << 0)); - + return; } diff --git a/src/nvs1.h b/src/nvs1.h index 57ee48b..ece10aa 100644 --- a/src/nvs1.h +++ b/src/nvs1.h @@ -3,9 +3,25 @@ #include #include "nvs_flash.h" -#define MAJOR_VERSION 0 -#define MINOR_VERSION 0 -#define BATCH_VERSION 6 // bump on every hosted build: a post-OTA cmd 33/2 version read confirms the update landed +// Version is build-injected by tools/version.py (semantic-release tag in CI, +// git describe locally). These fallbacks only apply if the pre-script did not +// run. A post-OTA cmd 33/2 version read confirms an update landed. +#ifndef AMBIT_FW_VERSION +#define AMBIT_FW_VERSION "0.0.0-dev" +#endif +#ifndef AMBIT_FW_MAJOR +#define AMBIT_FW_MAJOR 0 +#endif +#ifndef AMBIT_FW_MINOR +#define AMBIT_FW_MINOR 0 +#endif +#ifndef AMBIT_FW_BATCH +#define AMBIT_FW_BATCH 0 +#endif +// Legacy names, kept because the frozen cmd 33/2 wire struct fields use them. +#define MAJOR_VERSION AMBIT_FW_MAJOR +#define MINOR_VERSION AMBIT_FW_MINOR +#define BATCH_VERSION AMBIT_FW_BATCH struct ambit_calibration_info_t { @@ -36,7 +52,12 @@ struct ambit_FW_info_t uint32_t Size = 0; uint64_t MAC = 0; char FW_date[12]; - char reserved[12]; + // hw_rev occupies the first byte of what was reserved[12]: same offsets, same + // 48-byte total, so the frozen cmd 33/2 wire layout is unchanged (old readers + // never looked at these bytes). 0 = unknown; NVS "config"/"hw_rev" once boards + // start being programmed with a hardware revision. + uint8_t hw_rev = 0; + char reserved[11]; uint8_t Checksum = 0; }; diff --git a/tools/version.py b/tools/version.py new file mode 100644 index 0000000..4f0b50d --- /dev/null +++ b/tools/version.py @@ -0,0 +1,50 @@ +# version.py - PlatformIO pre-script: inject the firmware version at build time. +# +# The version has exactly one source, resolved in priority order: +# 1. $AMBIT_RELEASE_VERSION - set by CI from the semantic-release tag +# 2. git describe - dev builds ("v0.1.0-3-gabc123-dirty") +# 3. "0.0.0-dev" - no git / no tags +# +# It feeds every reporting surface: the cmd 33/2 binary struct (Major/Minor/Batch), +# the text `hello` reply, and the openJII envelope identity. Before this script the +# tree carried four hand-maintained copies (nvs1.h, two literals in the JSON +# frontend, plus the Calibratron's out-of-repo pin) that had already diverged +# (0.0.6 vs 0.0.3 vs 0.0.5). +Import("env") + +import os +import re +import subprocess + + +def _git_describe(): + try: + return ( + subprocess.check_output( + ["git", "describe", "--tags", "--always", "--dirty"], + cwd=env["PROJECT_DIR"], + stderr=subprocess.DEVNULL, + ) + .decode() + .strip() + ) + except Exception: + return "" + + +version = os.environ.get("AMBIT_RELEASE_VERSION", "").strip() or _git_describe() or "0.0.0-dev" +version = version.lstrip("vV") + +# Major/Minor/Batch feed the frozen 48-byte cmd 33/2 wire struct (uint8 each). +m = re.match(r"^(\d+)\.(\d+)\.(\d+)", version) +major, minor, batch = (int(g) for g in m.groups()) if m else (0, 0, 0) + +env.Append( + CPPDEFINES=[ + ("AMBIT_FW_VERSION", env.StringifyMacro(version)), + ("AMBIT_FW_MAJOR", major), + ("AMBIT_FW_MINOR", minor), + ("AMBIT_FW_BATCH", batch), + ] +) +print("ambit fw version: %s (%d.%d.%d)" % (version, major, minor, batch)) From 0972449eaab0466d11925f56c2b76dc15235a03b Mon Sep 17 00:00:00 2001 From: dominikvrbic Date: Tue, 4 Aug 2026 12:42:58 +0200 Subject: [PATCH 12/37] ci: add semantic-release versioning and release workflows PR titles (Conventional Commits, squash model) drive semantic-release. pr.yml validates the title, builds with the previewed version injected, verifies the version string is embedded, and uploads the artifact; release.yml publishes the same bits as a GitHub release with a flash manifest (names, offsets, sha256) so downstream flashers never hardcode the layout. --- .github/workflows/pr.yml | 172 ++++++++++++++++++++++++++++++++++ .github/workflows/release.yml | 111 ++++++++++++++++++++++ .gitignore | 4 +- .releaserc.json | 44 +++++++++ AGENTS.md | 90 +++++++++++------- package.json | 15 +++ 6 files changed, 400 insertions(+), 36 deletions(-) create mode 100644 .github/workflows/pr.yml create mode 100644 .github/workflows/release.yml create mode 100644 .releaserc.json create mode 100644 package.json diff --git a/.github/workflows/pr.yml b/.github/workflows/pr.yml new file mode 100644 index 0000000..dc9ba3f --- /dev/null +++ b/.github/workflows/pr.yml @@ -0,0 +1,172 @@ +name: Firmware PR + +on: + pull_request: + types: [opened, edited, synchronize, reopened] + +permissions: + contents: read + pull-requests: read + +jobs: + validate-pr: + name: Validate PR title + runs-on: ubuntu-latest + steps: + - uses: amannn/action-semantic-pull-request@v6 + env: + GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} + + build: + name: Build firmware + needs: validate-pr + runs-on: ubuntu-latest + permissions: + contents: write + pull-requests: read + steps: + - name: Checkout PR head + uses: actions/checkout@v6 + with: + ref: ${{ github.event.pull_request.head.sha }} + fetch-depth: 0 + + - name: Setup Node.js + uses: actions/setup-node@v6 + with: + node-version: "24" + + - name: Install release tooling + run: npm install --ignore-scripts --package-lock=false + + - name: Compute release preview + id: preview + env: + GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} + PR_NUMBER: ${{ github.event.pull_request.number }} + PR_TITLE: ${{ github.event.pull_request.title }} + PR_BASE_SHA: ${{ github.event.pull_request.base.sha }} + PR_HEAD_SHA: ${{ github.event.pull_request.head.sha }} + shell: bash + run: | + set -euo pipefail + # Present semantic-release with the PR tree as one squash commit whose + # message is the already validated PR title. + git config user.name "github-actions[bot]" + git config user.email "41898282+github-actions[bot]@users.noreply.github.com" + git checkout -B main "${PR_HEAD_SHA}" + git reset --soft "${PR_BASE_SHA}" + git commit --allow-empty -m "${PR_TITLE}" + + export GITHUB_REF="refs/heads/main" + export GITHUB_EVENT_NAME="push" + set +e + npx semantic-release --dry-run --no-ci 2>&1 | tee release-preview.log + RELEASE_STATUS=${PIPESTATUS[0]} + set -e + if [[ ${RELEASE_STATUS} -ne 0 ]]; then + exit "${RELEASE_STATUS}" + fi + + VERSION=$(grep -Eo 'The next release version is [0-9]+\.[0-9]+\.[0-9]+' release-preview.log | tail -n 1 | awk '{print $6}' || true) + if [[ -n "${VERSION}" ]]; then + BUILD_VERSION="${VERSION}" + WILL_RELEASE=true + else + BUILD_VERSION="pr-${PR_NUMBER}-${PR_HEAD_SHA:0:12}" + WILL_RELEASE=false + fi + + echo "version=${BUILD_VERSION}" >> "${GITHUB_OUTPUT}" + echo "will-release=${WILL_RELEASE}" >> "${GITHUB_OUTPUT}" + { + echo "## Firmware release preview" + echo + if [[ "${WILL_RELEASE}" == "true" ]]; then + echo "Merging this PR will publish **v${VERSION}**." + else + echo "Merging this PR will not create a firmware release." + fi + echo + echo "- Title: \`${PR_TITLE}\`" + echo "- Build version: \`${BUILD_VERSION}\`" + } | tee release-preview.md >> "${GITHUB_STEP_SUMMARY}" + + - name: Setup Python + uses: actions/setup-python@v6 + with: + python-version: "3.12" + + - name: Install PlatformIO + run: | + python -m venv "${RUNNER_TEMP}/platformio" + "${RUNNER_TEMP}/platformio/bin/pip" install --disable-pip-version-check platformio==6.1.19 + + - name: Build firmware + env: + AMBIT_RELEASE_VERSION: ${{ steps.preview.outputs.version }} + # platformio.ini redirects build_dir under LOCALAPPDATA (a Windows + # OneDrive workaround); give it a sane root on the runner. + LOCALAPPDATA: ${{ runner.temp }}/pio_build_root + run: "${RUNNER_TEMP}/platformio/bin/pio run -e ambit" + + - name: Verify version and assemble release assets + env: + FIRMWARE_VERSION: ${{ steps.preview.outputs.version }} + LOCALAPPDATA: ${{ runner.temp }}/pio_build_root + shell: bash + run: | + set -euo pipefail + BUILD_DIR="${LOCALAPPDATA}/pio_build/ambit_fw_new/ambit" + for FILE in firmware.bin bootloader.bin partitions.bin; do + test -f "${BUILD_DIR}/${FILE}" + done + + # The build-injected AMBIT_FW_VERSION must be embedded verbatim: it is + # what cmd 33/2, `hello` and the JSON identity report after flashing. + strings "${BUILD_DIR}/firmware.bin" | grep -qx "${FIRMWARE_VERSION}" + + # boot_app0.bin is not a build product: it ships with the Arduino-ESP32 + # core, but the Calibratron's 4-region flash layout needs it at 0xe000. + BOOT_APP0=$(find "${HOME}/.platformio/packages" -path "*framework-arduinoespressif32*" -name boot_app0.bin | head -n 1) + test -n "${BOOT_APP0}" + + mkdir -p dist + APP_NAME="ambit-fw-v${FIRMWARE_VERSION}.bin" + cp "${BUILD_DIR}/firmware.bin" "dist/${APP_NAME}" + cp "${BUILD_DIR}/bootloader.bin" dist/bootloader.bin + cp "${BUILD_DIR}/partitions.bin" dist/partitions.bin + cp "${BOOT_APP0}" dist/boot_app0.bin + cp release-preview.md dist/release-preview.md + + # Manifest: downstream flashers (Calibratron) read names, offsets and + # hashes from here instead of hardcoding them. + python3 - "$FIRMWARE_VERSION" "$APP_NAME" <<'EOF' + import hashlib, json, sys + version, app_name = sys.argv[1], sys.argv[2] + def entry(file, offset): + data = open(f"dist/{file}", "rb").read() + return {"file": file, "offset": offset, + "size": len(data), "sha256": hashlib.sha256(data).hexdigest()} + manifest = { + "name": "ambit-iot", + "version": version, + "chip": "esp32c3", + "flash": [ + entry("bootloader.bin", "0x0"), + entry("partitions.bin", "0x8000"), + entry("boot_app0.bin", "0xe000"), + entry(app_name, "0x10000"), + ], + "ota": {"file": app_name}, + } + json.dump(manifest, open("dist/manifest.json", "w"), indent=2) + EOF + + - name: Upload firmware candidate + uses: actions/upload-artifact@v6 + with: + name: firmware-${{ github.event.pull_request.head.sha }} + path: dist/ + if-no-files-found: error + retention-days: 30 diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml new file mode 100644 index 0000000..148fe66 --- /dev/null +++ b/.github/workflows/release.yml @@ -0,0 +1,111 @@ +name: Release firmware + +on: + push: + branches: [main] + workflow_dispatch: + +permissions: + contents: write + actions: read + pull-requests: read + +concurrency: + group: firmware-release + cancel-in-progress: false + +jobs: + release: + name: Release firmware + runs-on: ubuntu-latest + steps: + - name: Checkout main + uses: actions/checkout@v6 + with: + fetch-depth: 0 + persist-credentials: false + + - name: Setup Node.js + uses: actions/setup-node@v6 + with: + node-version: "24" + + - name: Install release tooling + run: npm install --ignore-scripts --package-lock=false + + - name: Determine next release + id: preview + env: + GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} + shell: bash + run: | + set -euo pipefail + npx semantic-release --dry-run --no-ci 2>&1 | tee release-preview.log + VERSION=$(grep -Eo 'The next release version is [0-9]+\.[0-9]+\.[0-9]+' release-preview.log | tail -n 1 | awk '{print $6}' || true) + if [[ -n "${VERSION}" ]]; then + echo "will-release=true" >> "${GITHUB_OUTPUT}" + echo "version=${VERSION}" >> "${GITHUB_OUTPUT}" + else + echo "will-release=false" >> "${GITHUB_OUTPUT}" + echo "No firmware release is required." >> "${GITHUB_STEP_SUMMARY}" + fi + + - name: Locate PR firmware artifact + id: artifact + if: steps.preview.outputs.will-release == 'true' + env: + GH_TOKEN: ${{ secrets.GITHUB_TOKEN }} + REPO: ${{ github.repository }} + shell: bash + run: | + set -euo pipefail + SUBJECT=$(git log -1 --pretty=%s) + PR_NUMBER=$(printf '%s' "${SUBJECT}" | sed -nE 's/.*\(#([0-9]+)\).*/\1/p') + if [[ -z "${PR_NUMBER}" ]]; then + echo "::error::Release commit subject has no squash PR number: ${SUBJECT}" + exit 1 + fi + HEAD_SHA=$(gh pr view "${PR_NUMBER}" --repo "${REPO}" --json headRefOid -q .headRefOid) + ARTIFACT_NAME="firmware-${HEAD_SHA}" + RUN_ID=$(gh api "repos/${REPO}/actions/artifacts?name=${ARTIFACT_NAME}&per_page=100" \ + --jq '[.artifacts[] | select(.expired == false)] | sort_by(.created_at) | last | .workflow_run.id // empty') + if [[ -z "${RUN_ID}" ]]; then + echo "::error::No live PR artifact named ${ARTIFACT_NAME}" + exit 1 + fi + echo "name=${ARTIFACT_NAME}" >> "${GITHUB_OUTPUT}" + echo "run-id=${RUN_ID}" >> "${GITHUB_OUTPUT}" + + - name: Download PR firmware artifact + if: steps.preview.outputs.will-release == 'true' + uses: actions/download-artifact@v6 + with: + name: ${{ steps.artifact.outputs.name }} + path: release-assets + github-token: ${{ secrets.GITHUB_TOKEN }} + repository: ${{ github.repository }} + run-id: ${{ steps.artifact.outputs.run-id }} + + - name: Verify release assets + if: steps.preview.outputs.will-release == 'true' + env: + VERSION: ${{ steps.preview.outputs.version }} + shell: bash + run: | + set -euo pipefail + test -f "release-assets/ambit-fw-v${VERSION}.bin" + test -f release-assets/bootloader.bin + test -f release-assets/partitions.bin + test -f release-assets/boot_app0.bin + test -f release-assets/manifest.json + python3 -c "import json,sys; m=json.load(open('release-assets/manifest.json')); sys.exit(0 if m['version']=='${VERSION}' else 1)" + + - name: Publish GitHub release + if: steps.preview.outputs.will-release == 'true' + env: + GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} + run: npx semantic-release + + - name: Release summary + if: steps.preview.outputs.will-release == 'true' + run: echo "Published firmware v${{ steps.preview.outputs.version }} from the PR-built artifact." >> "${GITHUB_STEP_SUMMARY}" diff --git a/.gitignore b/.gitignore index db04e5f..39f1b6a 100644 --- a/.gitignore +++ b/.gitignore @@ -1,6 +1,8 @@ .pio +node_modules/ +package-lock.json .vscode/.browse.c_cpp.db* .vscode/c_cpp_properties.json .vscode/launch.json .vscode/ipch -.plans/ \ No newline at end of file +.plans/ diff --git a/.releaserc.json b/.releaserc.json new file mode 100644 index 0000000..7467e37 --- /dev/null +++ b/.releaserc.json @@ -0,0 +1,44 @@ +{ + "branches": ["main"], + "plugins": [ + [ + "@semantic-release/commit-analyzer", + { + "preset": "conventionalcommits", + "releaseRules": [ + { "type": "feat", "release": "minor" }, + { "type": "fix", "release": "patch" }, + { "type": "perf", "release": "patch" }, + { "type": "revert", "release": "patch" }, + { "type": "docs", "release": false }, + { "type": "style", "release": false }, + { "type": "chore", "release": false }, + { "type": "refactor", "release": false }, + { "type": "test", "release": false }, + { "type": "build", "release": false }, + { "type": "ci", "release": false }, + { "breaking": true, "release": "major" } + ] + } + ], + [ + "@semantic-release/release-notes-generator", + { "preset": "conventionalcommits" } + ], + [ + "@semantic-release/github", + { + "assets": [ + { "path": "release-assets/manifest.json", "label": "Flash manifest (offsets + sha256)" }, + { "path": "release-assets/ambit-fw-v*.bin", "label": "Application image (OTA / 0x10000)" }, + { "path": "release-assets/bootloader.bin", "label": "Bootloader (0x0)" }, + { "path": "release-assets/partitions.bin", "label": "Partition table (0x8000)" }, + { "path": "release-assets/boot_app0.bin", "label": "OTA data init (0xe000)" } + ], + "successComment": false, + "failComment": false, + "releasedLabels": false + } + ] + ] +} diff --git a/AGENTS.md b/AGENTS.md index 357ec3a..f7ef046 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -7,82 +7,102 @@ generated_by: skills-for-architects # AGENTS.md — ambit-iot firmware ESP32-C3 (Arduino framework via PlatformIO) firmware for the AMBIT leaf-sensor board: -ADPD6100 (fluorescence), AS7341 (spectral/PAR), MLX90632 (leaf temperature). An AMBIT is -either carried by an Ambyte datalogger (binary FSM over UART0/FFC) or driven directly by -the openJII app/host (text LINE + JSON over the same UART). One source tree builds both -product variants. +ADPD6100 (fluorescence), AS7341 (spectral/PAR), MLX90632 (leaf temperature). One image +serves every host at runtime over UART0: an Ambyte datalogger (binary FSM over the FFC), +the openJII app and the Calibratron (text console), and the openJII JSON envelope. ## Commands -- Build field variant: `pio run -e ambyte` — binary FSM protocol, light-sleep idle -- Build app variant: `pio run -e cloud` — openJII LINE/JSON protocol (default env) +- Build: `pio run` (single env `ambit`) - Flash: add `-t upload`; serial monitor: 115200 8N1 - Linux/macOS quirk: `platformio.ini` sets `build_dir = ${sysenv.LOCALAPPDATA}/pio_build/…` (Windows OneDrive/AV workaround). Off Windows, export something sane first, e.g. - `LOCALAPPDATA=$HOME/.cache pio run -e ambyte`. -- No automated test suite. The regression gate for anything touching `run_esp.cpp` or the - `data_utils.cpp` FSM is the hardware conformance procedure in `plans/HW_CONFORMANCE.md` - (byte-diff against a real Ambyte). + `LOCALAPPDATA=$HOME/.cache pio run`. +- Version is build-injected by `tools/version.py`: `$AMBIT_RELEASE_VERSION` (CI) → + `git describe` (dev) → `0.0.0-dev`. Never hand-edit a version literal; everything + (cmd 33/2, `hello`, JSON identity) reports the same injected value. +- Releases: semantic-release keyed on Conventional-Commit PR titles (squash-merge). + `pr.yml` validates the title, builds, and uploads the artifact; `release.yml` reuses + that artifact bit-identically and publishes the GitHub release (app image, + bootloader, partitions, boot_app0, `manifest.json` with offsets + sha256). The + Calibratron flashes devices from these release assets. +- No automated test suite. The regression gate for anything touching `run_esp.cpp`, + the `data_utils.cpp` FSM, or the `loop()` router is the hardware conformance + procedure in `plans/HW_CONFORMANCE.md` (byte-diff against a real Ambyte). -## Architecture — one CORE + one CONFIG + thin transport adapters +## Architecture — one CORE + one CONFIG + thin transport adapters, routed at runtime -`plans/MERGE_PLAN.md` is the authoritative design doc (this tree is the merge of two -diverged forks); read it before structural changes. The spine: +`plans/MERGE_PLAN.md` is the historical design doc for the fork merge (its §10/§11 +build-variant split was superseded by the single image once every host landed on the +same UART0); read it before structural changes. The spine: ``` wire bytes → [adapter: decode + undo wire conventions] → normalized args → core op → [sink] ``` +- **First-byte router** (`ambit-1.ino` `loop()`): >127 → binary FSM branch (every + frozen framing byte is >127); `{`/`[` → openJII JSON envelope (`ojii::poll`); other + printable → legacy text console (`do_command`). `ojii::poll()` must never see binary + traffic (it consumes bytes and drops >127 junk silently) — peek, then route. While + `ojii::busy()` the envelope owns the stream. +- **Sticky host latch** (`HOST_UNKNOWN/BINARY/TEXT`): BINARY/UNKNOWN idle in light + sleep (the Ambyte re-sends its wake until acked, so sleep-lost bytes are safe); + TEXT never sleeps (text/JSON hosts don't retry; UART sleep-wake eats in-flight + bytes) and releases after 2 min idle. The latch also gates the 0x85 idle heartbeat. - `src/core.{h,cpp}` — transport-agnostic command core. Takes normalized typed args (gains 0-indexed, real widths), does **no** wire I/O: no Serial/printf/JSON. - `src/config.h` + PAM globals — single config (`adpd_*_config`, `adpd_mode`) with - "set, then apply on run" semantics; setters mark it dirty, the run re-applies it. - `CONNECTION_TYPE` (PLOTTING / AMBYTE / COMPUTER) selects the output sink. + "set, then apply on run" semantics. `CONNECTION_TYPE` (PLOTTING / AMBYTE / COMPUTER) + selects the measurement output sink; the JSON envelope path uses the `json_output` + flag through `run_arr_type1` instead. - Adapters: - `src/run_esp.cpp` — binary/Ambyte adapter. **Frozen wire contract** (below). - - `src/do_command.h` — text/console verbs (`hash()` dispatch switch). - - `src/frontend_cloud.cpp` — openJII adapter (snapshot tree-builders + streamed - measurement values), gated on `VARIANT_CLOUD`. -- `lib/openjii_proto/` — device-agnostic openJII serial protocol module (first-byte - LINE-vs-JSON detect, envelope with flat `set`, dot-path queries, §9 error taxonomy). - Knows nothing about AMBIT; devices register snapshot/stream handlers. + - `src/do_command.h` — text/console verbs (`hash()` dispatch switch). This is the + dialect the openJII platform's ambit driver and the Calibratron actually speak. + - `src/frontend_json.cpp` — openJII envelope handlers (snapshot tree-builders + + streamed `arrun`), registered from `setup()`. +- `lib/openjii_proto/` — device-agnostic openJII serial protocol module. Devices + register snapshot/stream handlers; `busy()`/`reset()` exist for router coexistence. + Bare-line LINE mode is intentionally unreachable in this firmware (no live consumer; + bare lines belong to the text console). - `src/PAM.cpp` — measurement engine (array runs, MPF, triggers, env logging); `src/data_utils.cpp` — FSM data framing + checksums; `src/nvs1.*` — calibration, metadata, and fw-info structs persisted in NVS; `src/src/` — sensor drivers. -- Variant gating: `-DVARIANT_AMBYTE` / `-DVARIANT_CLOUD` (see `platformio.ini`). The - ambyte image must link **no JSON** — ArduinoJson code exists only behind - `VARIANT_CLOUD` guards. ## The frozen binary wire contract (do not break) -The `ambyte` path is a wire contract with shipped Ambyte firmware. The source of truth is +The binary path is a wire contract with shipped Ambyte firmware. The source of truth is the Ambyte repo (`ambyte-iot`): `components/uart_sensors/uart_sensors.c` and `components/device_commands/include/ambit_protocol.h`. MERGE_PLAN §2 lists every frozen element. Rules: - Refactor behind the wire freely; never change the bytes. Obscure-but-frozen encodings stay: 1-indexed gains on the wire (stored −1), base-128 MPF length split - (`cmd[1]<<7 | cmd[2]`), byte-sum-mod-256 data checksum, struct sizes 136/48/248 with + (`cmd[1]<<7 | cmd[2]`), byte-sum-mod-256 data checksum, struct sizes 140/48/248 with `eof_mark==2025`. - Wire conventions are decoded **in the adapter, never the core** — the core only ever sees normalized values. -- Any change to the binary path re-runs `plans/HW_CONFORMANCE.md` before merge. -- UART0 doubles as the log console; the ambyte variant silences all ESP logging at boot - so ASCII can't interleave into the binary stream. +- The cmd 33/2 fw-info struct is 48 bytes with fixed offsets; `hw_rev` lives in the + first formerly-reserved byte (old readers never looked at it). Do not move fields. +- Any change to the binary path or the router re-runs `plans/HW_CONFORMANCE.md`. +- UART0 doubles as the log console; setup silences all ESP logging, and nothing may + `printf` outside explicit console replies — ASCII in front of a binary frame breaks + the Ambyte session. The boot banner + NVS dump predate the freeze and are tolerated; + do not add more. -## Version reporting (currently three divergent copies — keep in sync) +## Version reporting (single source) -- `src/nvs1.h` `MAJOR/MINOR/BATCH_VERSION` — the compiled fw version, reported over the - binary wire via info cmd 33 subtype 2; bump `BATCH_VERSION` every hosted build so a - post-OTA version read confirms the update landed. -- `src/frontend_cloud.cpp` `cmd_hello` hardcodes its own `"version"` string. -- The calibratron repo pins a minimum ambit fw version on its side. +`tools/version.py` injects `AMBIT_FW_VERSION` (string) + `AMBIT_FW_MAJOR/MINOR/BATCH` +(uint8 fields of the cmd 33/2 struct). Reported by: binary cmd 33/2, text `hello` +(`NEW Ready FW:` — "NEW"/"Ready" are matched by the app driver and +Calibratron, the FW token is additive), and the JSON `hello`/envelope identity. ## Conventions - Heavy rationale comments are the house style — a constraint's *why* lives at its definition (wire freezes, sleep thresholds, build-dir workaround). Keep it that way. - Conventional Commits for commits and PR titles: `type(scope): description`. + PR titles drive semantic-release (feat → minor, fix/perf → patch). - License: CERN-OHL-S-2.0 (hardware-adjacent open license — keep headers/attribution). - Vendored driver libs under `src/src/` (as7341, adpd, mlx90632) are third-party imports; don't reformat or "clean up" wholesale. diff --git a/package.json b/package.json new file mode 100644 index 0000000..cd6d4fb --- /dev/null +++ b/package.json @@ -0,0 +1,15 @@ +{ + "name": "ambit-release-automation", + "private": true, + "version": "1.0.0", + "description": "Minimal semantic-release tooling for Ambit firmware", + "repository": { + "type": "git", + "url": "https://github.com/Jan-IngenHousz-Institute/ambit-iot.git" + }, + "devDependencies": { + "@semantic-release/github": "11.0.6", + "conventional-changelog-conventionalcommits": "8.0.0", + "semantic-release": "25.0.5" + } +} From bba87254702e619df407f651fb0d5afb05e87225 Mon Sep 17 00:00:00 2001 From: dominikvrbic Date: Tue, 4 Aug 2026 15:07:06 +0200 Subject: [PATCH 13/37] ci(release): resolve the release PR via the API, not the commit subject The v1.1.0 release failed because the subject regex only matched a squash merge's "(#N)"; PR #1 landed as a merge commit ("Merge pull request #1"), so no artifact could be located. Ask the API which merged PR contains each of the last 20 commits instead, newest first, which also covers a direct push to main following a release. --- .github/workflows/release.yml | 19 ++++++++++++++++--- 1 file changed, 16 insertions(+), 3 deletions(-) diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml index 148fe66..1d4b9b6 100644 --- a/.github/workflows/release.yml +++ b/.github/workflows/release.yml @@ -59,10 +59,23 @@ jobs: shell: bash run: | set -euo pipefail - SUBJECT=$(git log -1 --pretty=%s) - PR_NUMBER=$(printf '%s' "${SUBJECT}" | sed -nE 's/.*\(#([0-9]+)\).*/\1/p') + # Find the PR whose build produced the artifact we republish. Parsing the + # commit subject is NOT reliable: a squash merge writes "(#N)", a merge + # commit writes "Merge pull request #N", and a direct push writes neither + # (v1.1.0's first attempt failed exactly here, on a merge commit). Ask the + # API which merged PR contains each recent commit instead, newest first, + # so a follow-up direct push to main still finds the last released PR. + PR_NUMBER="" + for SHA in $(git log -n 20 --pretty=%H); do + PR_NUMBER=$(gh api "repos/${REPO}/commits/${SHA}/pulls" \ + --jq '[.[] | select(.merged_at != null) | .number] | first // empty' 2>/dev/null || true) + if [[ -n "${PR_NUMBER}" ]]; then + echo "release commit traced to PR #${PR_NUMBER} (via ${SHA})" + break + fi + done if [[ -z "${PR_NUMBER}" ]]; then - echo "::error::Release commit subject has no squash PR number: ${SUBJECT}" + echo "::error::No merged PR found in the last 20 commits; cannot locate a reviewed firmware artifact" exit 1 fi HEAD_SHA=$(gh pr view "${PR_NUMBER}" --repo "${REPO}" --json headRefOid -q .headRefOid) From 1f7f0622a75ed2607797975cd21c4395b0c72386 Mon Sep 17 00:00:00 2001 From: dominikvrbic Date: Tue, 4 Aug 2026 15:32:24 +0200 Subject: [PATCH 14/37] fix(router): never let a finished envelope stall the first-byte router busy() treated any buffered byte as mid-frame. A client that terminates an envelope with a newline (the openJII driver probes with '{"command":"INFO"}\n') completes the JSON, resets, then has its trailing \n appended in UNKNOWN mode: whitespace locks no mode, so rx stayed non-empty with busy() true and the idle timeout - which only covered Mode::JSON - could never clear it. loop() then early-returned forever and the device answered neither dialect until power-cycled. - busy() now means "a mode is locked"; with no mode locked the buffer can only hold whitespace. - poll() no longer buffers a leading newline, and abandons a locked frame when a >0x7F byte arrives, so an ambyte wake burst is handed back to the binary router instead of being absorbed (each absorbed byte refreshed the idle timer, outliving the companion's ~1.25 s retry window). - the idle timeout now covers any locked mode; LINE had none. Also claim CONNECTION_TYPE=COMPUTER when routing to the text console: every binary command latches AMBYTE and nothing cleared it, so plain `arrun` from a text host ran with the ambyte sink still selected. --- lib/openjii_proto/openjii_proto.cpp | 31 +++++++++++++++++++++++------ src/ambit-1.ino | 7 +++++++ 2 files changed, 32 insertions(+), 6 deletions(-) diff --git a/lib/openjii_proto/openjii_proto.cpp b/lib/openjii_proto/openjii_proto.cpp index 84b3150..110dea5 100644 --- a/lib/openjii_proto/openjii_proto.cpp +++ b/lib/openjii_proto/openjii_proto.cpp @@ -233,7 +233,10 @@ void on_stream(const char* name, StreamFn fn) { void identity(const Identity& id) { s_id = id; } -bool busy(void) { return s_mode != Mode::UNKNOWN || s_rx.length() > 0; } +// Mid-frame == a mode is locked. Buffered bytes alone must NOT count: with no +// mode locked the buffer can only hold whitespace (anything else would have +// locked a mode), and treating that as busy stalled the caller's router forever. +bool busy(void) { return s_mode != Mode::UNKNOWN; } void reset(void) { reset_rx(); } @@ -243,10 +246,24 @@ void poll(Stream& io) { if (c == '\r') continue; // §4: CR ignored if (s_mode == Mode::UNKNOWN) { - // drop leading framing/boot junk before a mode is locked + // drop leading framing/boot junk before a mode is locked. A '\n' is only + // meaningful once a request has started: buffering a leading one selects + // no mode (it is whitespace) yet leaves rx non-empty, which used to make + // busy() true forever and stall the caller's router. Clients terminate + // envelopes with '\n' (the openJII driver probes with + // '{"command":"INFO"}\n'), so this is the common path, not an edge case. unsigned char uc = (unsigned char)c; bool printable = (uc >= 0x20 && uc < 0x7F); - if (!printable && c != '\n') continue; + if (!printable && !(c == '\n' && s_rx.length() > 0)) continue; + } else if ((unsigned char)c > 0x7F) { + // Both dialects are 7-bit, so a high byte mid-frame means the binary host + // has taken the wire (an ambyte wake burst). Abandon the partial frame and + // hand the stream back instead of absorbing the burst: every absorbed byte + // refreshed the idle timer, so the companion's ~1.25 s retry window + // expired before the timeout could fire. Dropping this one byte is safe - + // the wake is sent in triplicate and retried. + reset_rx(); + return; } s_rx += c; @@ -282,9 +299,11 @@ void poll(Stream& io) { if (s_rx.length() > RX_MAX) { io.print("{\"error\":\"rx_overflow\"}\n"); reset_rx(); } } - // §4: incomplete JSON idle > 1 s - if (s_mode == Mode::JSON && s_rx.length() > 0 && (millis() - s_last_byte_ms) > JSON_IDLE_MS) { - io.print("{\"error\":\"json_timeout\"}\n"); + // §4: incomplete request idle > 1 s. Applies to any locked mode, not just + // JSON: a stalled LINE frame would otherwise hold the stream indefinitely + // (there is no other LINE timeout). + if (s_mode != Mode::UNKNOWN && s_rx.length() > 0 && (millis() - s_last_byte_ms) > JSON_IDLE_MS) { + if (s_mode == Mode::JSON) io.print("{\"error\":\"json_timeout\"}\n"); reset_rx(); } } diff --git a/src/ambit-1.ino b/src/ambit-1.ino index 1f3657a..ef40e22 100644 --- a/src/ambit-1.ino +++ b/src/ambit-1.ino @@ -227,6 +227,13 @@ void loop(){ // The old `sleep_threshod_ms = 30000` stay-awake heuristic is // superseded by the TEXT latch. host_latch = HOST_TEXT; + /* Claim the sink for this host before dispatching. do_esp_cmd() latches + * CONNECTION_TYPE=AMBYTE on every binary command and nothing used to + * clear it, so a text command that does not set its own sink (plain + * `arrun`; arrun1/arrun2/q/r/w all do) would run with the ambyte sink + * still selected and emit FSM wake traffic at a text host. Verbs that + * set their own sink still override this. */ + CONNECTION_TYPE = CONNECTION_TYPES::COMPUTER; Serial_Input_Chars(choose, ":,", 200, sizeof(choose) - 1); do_command(choose); From 1218d74c9f65bd712ad648d8afea957b451dee08 Mon Sep 17 00:00:00 2001 From: dominikvrbic Date: Tue, 4 Aug 2026 15:41:36 +0200 Subject: [PATCH 15/37] fix(uart): stop ARDUHAL writing ASCII onto the protocol port setup()'s esp_log_level_set("*", ESP_LOG_NONE) only gags IDF logging; the Arduino ESP_LOGx macros compile to Serial.printf. Bench proof: a stray frame byte made the router answer a host with "[E][ambit-1.ino:215] loop(): [INO] Unknown cmd 171" instead of protocol bytes, which is exactly the ASCII-before-a-binary-frame hazard AGENTS.md forbids. CORE_DEBUG_LEVEL=0 removes the format strings entirely (verified absent from the image) and drops flash 418 KB -> 397 KB. --- platformio.ini | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/platformio.ini b/platformio.ini index 1ec6b17..af06cbe 100644 --- a/platformio.ini +++ b/platformio.ini @@ -39,3 +39,10 @@ lib_deps = [env:ambit] build_flags = -DARDUINO_USB_CDC_ON_BOOT=0 ; Serial -> UART0 (GPIO20 RX / 21 TX) + ; Gag ARDUHAL. setup()'s esp_log_level_set() silences IDF logging only; the + ; Arduino ESP_LOGx macros compile to Serial.printf and were writing ASCII + ; straight onto the protocol port. Observed on the bench: a stray frame byte + ; made the router answer a host with + ; "[E][ambit-1.ino:215] loop(): [INO] Unknown cmd 171" instead of protocol + ; bytes. Nothing may emit on UART0 except an explicit console reply. + -DCORE_DEBUG_LEVEL=0 From 27971fa0ef61d44eb13aacdad59995465bf26793 Mon Sep 17 00:00:00 2001 From: dominikvrbic Date: Tue, 4 Aug 2026 15:45:15 +0200 Subject: [PATCH 16/37] Revert "fix(uart): stop ARDUHAL writing ASCII onto the protocol port" This reverts commit fda6d46b3780392f13e9e9d2139405cc789be331. --- platformio.ini | 7 ------- 1 file changed, 7 deletions(-) diff --git a/platformio.ini b/platformio.ini index af06cbe..1ec6b17 100644 --- a/platformio.ini +++ b/platformio.ini @@ -39,10 +39,3 @@ lib_deps = [env:ambit] build_flags = -DARDUINO_USB_CDC_ON_BOOT=0 ; Serial -> UART0 (GPIO20 RX / 21 TX) - ; Gag ARDUHAL. setup()'s esp_log_level_set() silences IDF logging only; the - ; Arduino ESP_LOGx macros compile to Serial.printf and were writing ASCII - ; straight onto the protocol port. Observed on the bench: a stray frame byte - ; made the router answer a host with - ; "[E][ambit-1.ino:215] loop(): [INO] Unknown cmd 171" instead of protocol - ; bytes. Nothing may emit on UART0 except an explicit console reply. - -DCORE_DEBUG_LEVEL=0 From 65fd01ee25d170a0680da7ecec5af13899ec4a9e Mon Sep 17 00:00:00 2001 From: dominikvrbic Date: Tue, 4 Aug 2026 15:48:27 +0200 Subject: [PATCH 17/37] Reapply "fix(uart): stop ARDUHAL writing ASCII onto the protocol port" This reverts commit 4c9b90fce36a6a1ed786e5b8c7baa5bef18e1dbd. --- platformio.ini | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/platformio.ini b/platformio.ini index 1ec6b17..af06cbe 100644 --- a/platformio.ini +++ b/platformio.ini @@ -39,3 +39,10 @@ lib_deps = [env:ambit] build_flags = -DARDUINO_USB_CDC_ON_BOOT=0 ; Serial -> UART0 (GPIO20 RX / 21 TX) + ; Gag ARDUHAL. setup()'s esp_log_level_set() silences IDF logging only; the + ; Arduino ESP_LOGx macros compile to Serial.printf and were writing ASCII + ; straight onto the protocol port. Observed on the bench: a stray frame byte + ; made the router answer a host with + ; "[E][ambit-1.ino:215] loop(): [INO] Unknown cmd 171" instead of protocol + ; bytes. Nothing may emit on UART0 except an explicit console reply. + -DCORE_DEBUG_LEVEL=0 From 1be78f45d575cffb8b0f66904d21c5cc89b4008c Mon Sep 17 00:00:00 2001 From: dominikvrbic Date: Tue, 4 Aug 2026 17:09:30 +0200 Subject: [PATCH 18/37] fix(json): honor arrun request length --- src/frontend_json.cpp | 46 +++++++++++++++++++++++++++++++++++-------- 1 file changed, 38 insertions(+), 8 deletions(-) diff --git a/src/frontend_json.cpp b/src/frontend_json.cpp index 3512036..accc0a4 100644 --- a/src/frontend_json.cpp +++ b/src/frontend_json.cpp @@ -67,16 +67,19 @@ static long arg_long(const String& a, uint8_t n, long def = 0) { return a.substring(start).toInt(); } -// Parse comma-separated uint8 values from token index `from` into arr. -static uint8_t arg_array8(const String& a, uint8_t from, uint8_t* arr, uint8_t maxLen) { - uint8_t count = 0; +// Parse comma-separated uint8 values from token index `from` into arr. Return +// capacity + 1 as soon as an extra token is seen so callers can distinguish an +// overlong payload without writing past the destination. +static size_t arg_array8(const String& a, uint8_t from, uint8_t* arr, size_t capacity) { + size_t count = 0; int pos = 0; for (uint8_t i = 0; i < from; i++) { pos = a.indexOf(',', pos); if (pos < 0) return 0; pos++; } - while (pos >= 0 && pos < (int)a.length() && count < maxLen) { + while (pos >= 0 && pos < (int)a.length()) { + if (count >= capacity) return capacity + 1; int next = a.indexOf(',', pos); if (next < 0) next = a.length(); arr[count++] = (uint8_t) a.substring(pos, next).toInt(); @@ -86,15 +89,42 @@ static uint8_t arg_array8(const String& a, uint8_t from, uint8_t* arr, uint8_t m return count; } +static constexpr long ARRUN_MIN_LEN = 1; +static constexpr long ARRUN_MAX_LEN = 16; + +static constexpr bool valid_arrun_shape(long len, size_t parsed) { + // Validate before multiplying: `len` comes from the wire and must not be + // narrowed to uint8_t (or multiplied there) until its range is known. + return len >= ARRUN_MIN_LEN && len <= ARRUN_MAX_LEN && + parsed == static_cast(len) * 8U; +} + +// There is no host/unit harness in this firmware. Keep the boundary contract +// compiler-checked, including the one-point request that exposed the regression. +static_assert(valid_arrun_shape(1, 8), "one-point arrun must be accepted"); +static_assert(valid_arrun_shape(16, 128), "full arrun must be accepted"); +static_assert(!valid_arrun_shape(0, 0), "empty arrun must be rejected"); +static_assert(!valid_arrun_shape(17, 136), "oversized arrun must be rejected"); +static_assert(!valid_arrun_shape(1, 128), "arrun byte count must match len"); + // arrun,,,<8*len array bytes> — runs an array-mode measurement and // emits one JSON object {"env":[..],"s_630":[..],...}. run_arr_type1's json_output // path writes it to Serial, which IS the openJII output stream in the cloud build. static void cmd_arrun(const String& args, Print& out) { - uint8_t len = (uint8_t) arg_long(args, 0); + long requested_len = arg_long(args, 0); uint8_t persist = (uint8_t) arg_long(args, 1); uint8_t arr[128] = {0}; - uint8_t parsed = arg_array8(args, 2, arr, len * 8); - if (len == 0 || parsed == 0) { out.print("{\"error\":\"bad_arrun\"}"); return; } + if (requested_len < ARRUN_MIN_LEN || requested_len > ARRUN_MAX_LEN) { + out.print("{\"error\":\"bad_arrun\"}"); + return; + } + const uint8_t len = static_cast(requested_len); + const size_t expected = static_cast(len) * 8U; + const size_t parsed = arg_array8(args, 2, arr, expected); + if (!valid_arrun_shape(requested_len, parsed)) { + out.print("{\"error\":\"bad_arrun\"}"); + return; + } if (!adpd_gains_config.init) adpd_gains_config.init = true; if (!adpd_current_config.init) adpd_current_config.init = true; @@ -103,7 +133,7 @@ static void cmd_arrun(const String& args, Print& out) { adpd_mode = ADPD_CONFIG_MODE::ARRAY_MODE1; } CONNECTION_TYPE = CONNECTION_TYPES::COMPUTER; // no inline plotting; JSON emitted at the end - run_arr_type1(16, arr, persist, false, true); // json_output -> writes the JSON object to Serial + run_arr_type1(len, arr, persist, false, true); // json_output -> writes the JSON object to Serial } // ── config setters (snapshot: ack with the applied values; command-as-root) ── From 9732b2f288e57796d98d3862afc98c7f84b7f586 Mon Sep 17 00:00:00 2001 From: dominikvrbic Date: Wed, 5 Aug 2026 09:46:47 +0200 Subject: [PATCH 19/37] fix(router): keep unknown host discovery awake --- src/ambit-1.ino | 40 ++++++++++++++++++++++------------------ 1 file changed, 22 insertions(+), 18 deletions(-) diff --git a/src/ambit-1.ino b/src/ambit-1.ino index ef40e22..287ba39 100644 --- a/src/ambit-1.ino +++ b/src/ambit-1.ino @@ -108,8 +108,6 @@ void setup(){ frontend_json_register(); - Serial.write(AMBIT_BOOT_IDLE); - esp_sleep_enable_timer_wakeup(10000000); @@ -122,51 +120,54 @@ int do_esp_cmd(); int c = -1; char choose[50]; -/* Sticky host latch: the first routed traffic decides the idle policy. - * BINARY/UNKNOWN keep the light-sleep idle (the ambyte re-sends its 0xAA wake - * until it gets the 0x80 ack, so bytes lost to sleep-wake are harmless). - * TEXT disables sleep entirely: the openJII app / Calibratron / a JSON host do - * NOT retry, and the UART sleep-wake (threshold 3 edges) eats the in-flight - * bytes, so a sleeping device would truncate `hello\n`. The latch releases - * after a long idle so a bench/phone device later installed on an ambyte - * regains light sleep without a reboot. */ +/* Sticky host latch: UNKNOWN is the app-discovery default, so it stays awake + * and quiet until traffic identifies a host. Only the ambyte's 0xAA wake + * preamble positively latches BINARY and opts into the frozen light-sleep / + * 0x85 idle-heartbeat contract; an arbitrary high byte must not do that. + * TEXT also stays awake because the openJII app / Calibratron / a JSON host do + * not retry and UART sleep-wake (threshold 3 edges) eats in-flight bytes. Its + * persistent last-activity timestamp releases the latch after a long idle so + * a device can later be installed on an ambyte without a reboot. */ enum HostLatch : uint8_t { HOST_UNKNOWN = 0, HOST_BINARY, HOST_TEXT }; static HostLatch host_latch = HOST_UNKNOWN; -static const unsigned int TEXT_LATCH_RELEASE_MS = 120000; +static uint32_t host_last_activity_ms = 0; +static const uint32_t TEXT_LATCH_RELEASE_MS = 120000; void loop(){ // An in-flight JSON envelope owns the stream until it completes or times // out; poll() is what fires its 1 s idle timeout, so keep calling it. if (ojii::busy()){ + if (Serial.available() > 0) host_last_activity_ms = millis(); ojii::poll(Serial); if (ojii::busy()){ delay(1); return; } + host_last_activity_ms = millis(); } c = -1; int b; - unsigned int sleep_timer = millis(); for (;;) { c = Serial.available(); if (c > 0){ - sleep_timer = millis(); + host_last_activity_ms = millis(); c = Serial.peek(); if (c == 255) Serial.read(); if (c < 255) break; }else{ if (host_latch == HOST_TEXT){ - if (millis() - sleep_timer > TEXT_LATCH_RELEASE_MS){ + if (millis() - host_last_activity_ms > TEXT_LATCH_RELEASE_MS){ host_latch = HOST_UNKNOWN; } delay(10); - }else if (millis() - sleep_timer > sleep_threshod_ms){ + }else if (host_latch == HOST_BINARY && + millis() - host_last_activity_ms > sleep_threshod_ms){ Serial.flush(); flush_serial(20); ambit_light_sleep(); c = esp_sleep_get_wakeup_cause(); - sleep_timer = millis(); + host_last_activity_ms = millis(); if (c == 8){ sleep_threshod_ms = 1000; }else{ @@ -195,12 +196,12 @@ void loop(){ * junk while unlocked), hence peek-then-route. */ c = Serial.peek(); if (c > 127) { // binary FSM to the ambyte (frozen wire) - host_latch = HOST_BINARY; ojii::reset(); // a stale partial line must not prepend to later text while (Serial.available() > 0){ b = serial_read_until(170, 160, 222, 50, false); if (b == 1){ // wake up signal + host_latch = HOST_BINARY; flush_serial(5); Serial.write(128); sleep_threshod_ms = 500; @@ -218,10 +219,12 @@ void loop(){ break; } } + host_last_activity_ms = millis(); }else if (c == '{' || c == '['){ // openJII JSON envelope host_latch = HOST_TEXT; ojii::poll(Serial); + host_last_activity_ms = millis(); }else{ // Text console: what the openJII app driver and the Calibratron speak. // The old `sleep_threshod_ms = 30000` stay-awake heuristic is @@ -236,8 +239,9 @@ void loop(){ CONNECTION_TYPE = CONNECTION_TYPES::COMPUTER; Serial_Input_Chars(choose, ":,", 200, sizeof(choose) - 1); do_command(choose); + host_last_activity_ms = millis(); } -} \ No newline at end of file +} From 4ed94decbbd57157efd9a2e9e61768ae197e70e7 Mon Sep 17 00:00:00 2001 From: dominikvrbic Date: Wed, 5 Aug 2026 10:07:10 +0200 Subject: [PATCH 20/37] docs(hw): record rc4 conformance run --- plans/HW_CONFORMANCE.md | 1 + 1 file changed, 1 insertion(+) diff --git a/plans/HW_CONFORMANCE.md b/plans/HW_CONFORMANCE.md index 6496395..65bb137 100644 --- a/plans/HW_CONFORMANCE.md +++ b/plans/HW_CONFORMANCE.md @@ -148,6 +148,7 @@ touches `run_esp.cpp` or `data_utils.cpp`'s FSM (Step 5 onward). | 2026-06-05 | Sweep #4 inc 2 — routed `run_trigger_spacer` (the mpf / cmd-20 path) through `pam_send_results` (`subsampling=1, has_730=true` → unconditional 7 channels; AMBYTE branch identical to the former inline block, COMPUTER branch inert as this path is never COMPUTER). `MPF` (2-channel idx 0/1), `external_trigger_run`/`_Flash`/`fluor_offset` (no FSM send) don't share this block. | B — the `mpf(20)` row of the Lua | ✅ PASSED — mpf(20) = 7 arrays, no checksum errors | | 2026-06-05 | Cheap correctness sweep — **#10** init the comma-decl locals in `run_arr_type1`/`run_trigger_spacer`/`fluor_offset` (defensive; each was already assigned before use); **#8** `w`-length `uint8_t`→`uint16_t` + drop pointless `(uint16_t)` casts; **#9** delete 2 uncalled FSM fns (`fsm_wake_up_calls(void)`, `fsm_send_waitesp` — the latter had missing-return UB). | #10 → A+B (measurement path, behavior-neutral, very low risk). #8 text path (`w` over USB), #9 dead-code → no ambyte HW. | ☐ #10 prudent Lua re-run; #8/#9 done | | 2026-06-08 | **Wire v2 (ambyte variant)** — (1) self-describing length header: the 2 spare bytes now carry `elem_width` (2\|4) + `dtype` (0 unsigned\|1 signed); csum formula unchanged (sum of bytes [0..6], now covers the new bytes); host defaults 4/0 when a byte is 0, so v1 still decodes. (2) ADC channels (Fluo/Fluoref/Sun/Leaf/730/730ref) sent as **uint16** (elem_width 2, dtype 0, each clamped to 0xFFFF); ENV as **int16** centi-°C (elem_width 2, dtype 1). Data-trailer csum = byte-sum of exactly the bytes sent. (3) new **TIMING** block idx 7 = `uint32[tick_begin, tick_end]` (µs from `esp_timer_get_time()`), emitted in `pam_send_results`. (4) **one wake per run**: `data_utils.cpp` FSM split into free `ambyte_wake()` + `dataclass::fsm_send_array(idx,elem_width,dtype)`; `pam_send_results` wakes once then streams each array back-to-back; host loops on the 212 marker, stops at the run's trailing 240. `fsm_send_esp` kept as a legacy wake+one-array(4/0) wrapper (MPF path). Host (ambyte) side updated to match. Both `pio run -e ambyte` and `-e cloud` build clean. | A + B | ☐ pending HW — one wake yields ENV(int16×N), Fluo/Fluoref/Sun/Leaf/730/730ref(uint16×N), TIMING(uint32×2), then 240; every header csum + data byte-sum must verify and each block decodes per `elem_width`/`dtype` | +| 2026-08-05 | **v1.1.1-rc4 host-discovery latch** (`30aaf6f`): UNKNOWN/TEXT remain awake and quiet; only a matched `0xAA` wake latches BINARY and enables light sleep/`0x85`. Binary parser/FSM code was unchanged. Exact rc4 app image (427,264 B, SHA-256 `a3c5e3f6bc9f8b55422db7f618b45e3ae1cfcef14b9512144e30f495f7c51e04`) OTA-flashed to recovered AB48. | Weak A + non-destructive B | ✅ PASSED — cold legacy/JSON first contact 10/10; cold binary wake 5/5; wake after 1.2 s idle 5/5; cmd 33/2 identity, temp/spec/temp-raw, run(21), and mpf(20) length 200 all completed with no timeout/framing/checksum error. MPF returned ENV + six 200-element arrays + TIMING. JSON arrun and malformed-extra-token rejection also passed, as did binary→JSON→binary→text→binary switching on one boot. Mutating baseline/set-metadata tests were deliberately omitted to preserve NVS calibration; no logic analyzer was available, so the strict pre/post byte trace remains unrun. | **Focused check for sweep-#4 inc 1** (the send block is shared by both transports, so verify both halves): From 8fb51cbed3f653b2c3d8f3922cb90c796bacf41c Mon Sep 17 00:00:00 2001 From: dominikvrbic Date: Wed, 5 Aug 2026 21:56:50 +0200 Subject: [PATCH 21/37] chore(adpd): replace vendor SDK with JII clean-room driver --- .gitignore | 1 + src/src/adpd/ADPD_platform_ops.cpp | 109 ++--- src/src/adpd/ADPD_platform_ops.h | 14 + src/src/adpd/jii_adpd6000.cpp | 225 ++++++++++ src/src/adpd/jii_adpd6000.h | 136 ++++++ src/src/adpd/u_adpd6100.cpp | 683 +++++++---------------------- src/src/adpd/u_adpd6100.h | 23 +- src/src/adpd/u_adpd6100_typedef.h | 3 +- test/adpd6000/test_main.cpp | 302 +++++++++++++ 9 files changed, 877 insertions(+), 619 deletions(-) create mode 100644 src/src/adpd/ADPD_platform_ops.h create mode 100644 src/src/adpd/jii_adpd6000.cpp create mode 100644 src/src/adpd/jii_adpd6000.h create mode 100644 test/adpd6000/test_main.cpp diff --git a/.gitignore b/.gitignore index 39f1b6a..f6776ee 100644 --- a/.gitignore +++ b/.gitignore @@ -6,3 +6,4 @@ package-lock.json .vscode/launch.json .vscode/ipch .plans/ +graphify-out/ diff --git a/src/src/adpd/ADPD_platform_ops.cpp b/src/src/adpd/ADPD_platform_ops.cpp index 4b3bfaa..009cc54 100644 --- a/src/src/adpd/ADPD_platform_ops.cpp +++ b/src/src/adpd/ADPD_platform_ops.cpp @@ -1,82 +1,35 @@ -#include "driver/spi_common.h" -#include "driver/spi_master.h" -#include "../pin_config.h" - -#include "lib/ADPD6000/adi_adpd6000.h" - - - - - - -uint8_t check_adpd(spi_device_handle_t handle){ - /// @brief Check ADPD connected - /// @param ADPD number - /// @return - esp_err_t err = 1; - uint16_t ret = 1; - - spi_transaction_t check_adpd = { - .addr = 0x0010, - .length = 16, - .rxlength = 16, - .rx_buffer = &ret, - }; - - err = spi_device_polling_transmit(handle, &check_adpd); - - if (err != ESP_OK) {Serial.print("SPI communication failed: "); Serial.println(esp_err_to_name(err));return 1;} - ret = SPI_SWAP_DATA_RX(ret, 16); - Serial.println(ret); - - return 1; +// SPDX-License-Identifier: CERN-OHL-S-2.0 +// Copyright (c) 2026 Jan IngenHousz Institute -} - - -int32_t spi_read(void* user_data, uint8_t *rd_buf, uint32_t rd_len, uint8_t *wr_buf, uint32_t wr_len){ +#include "ADPD_platform_ops.h" - spi_device_handle_t handle = * ((spi_device_handle_t*) user_data); - - esp_err_t err; - uint16_t addr = 0x0000; - addr |= wr_buf[0] << 8; - addr |= wr_buf[1]; - - spi_transaction_t spi_read_and_write = { - .addr = addr, - .length = rd_len * 8, - .rxlength = rd_len * 8, - .rx_buffer = rd_buf - }; - err = spi_device_polling_transmit(handle, &spi_read_and_write); - if (err != ESP_OK) Serial.println(esp_err_to_name(err)); - return 0; - -} -int32_t spi_write(void* user_data, uint8_t *wr_buf, uint32_t len){ - - spi_device_handle_t handle = * ((spi_device_handle_t*) user_data); - - esp_err_t err; - uint16_t addr = 0x0000; - addr |= wr_buf[0] << 8; - addr |= wr_buf[1]; - - spi_transaction_t spi_read_and_write = { - .addr = addr, - .length = (len - 2)<<3, - .rxlength = (len - 2)<<3, - .tx_buffer = &wr_buf[2], - .rx_buffer = &wr_buf[2] - }; - err = spi_device_polling_transmit(handle, &spi_read_and_write); - if (err != ESP_OK) Serial.println(esp_err_to_name(err)); - return 0; -} +#include "driver/spi_master.h" -int32_t log_print(void* user_data, char *string){ - Serial.println(string); - return 0; +int32_t jii_adpd6000_spi_transact(void *context, uint16_t command, + const uint8_t *tx_data, uint8_t *rx_data, + size_t data_length) { + if (context == nullptr || data_length == 0) { + return ESP_ERR_INVALID_ARG; + } + + const spi_device_handle_t handle = + *static_cast(context); + if (handle == nullptr) { + return ESP_ERR_INVALID_STATE; + } + + spi_transaction_t transaction = {}; + transaction.addr = command; + transaction.length = data_length * 8; + transaction.tx_buffer = tx_data; + if (rx_data != nullptr) { + transaction.rxlength = data_length * 8; + transaction.rx_buffer = rx_data; + } + + // Return the ESP-IDF status unchanged. The clean-room driver deliberately + // propagates transport failures to its caller rather than turning them into + // successful register operations on a disconnected sensor. + return static_cast( + spi_device_polling_transmit(handle, &transaction)); } - diff --git a/src/src/adpd/ADPD_platform_ops.h b/src/src/adpd/ADPD_platform_ops.h new file mode 100644 index 0000000..3add7d8 --- /dev/null +++ b/src/src/adpd/ADPD_platform_ops.h @@ -0,0 +1,14 @@ +// SPDX-License-Identifier: CERN-OHL-S-2.0 +// Copyright (c) 2026 Jan IngenHousz Institute + +#ifndef JII_ADPD_PLATFORM_OPS_H +#define JII_ADPD_PLATFORM_OPS_H + +#include +#include + +int32_t jii_adpd6000_spi_transact(void *context, uint16_t command, + const uint8_t *tx_data, uint8_t *rx_data, + size_t data_length); + +#endif // JII_ADPD_PLATFORM_OPS_H diff --git a/src/src/adpd/jii_adpd6000.cpp b/src/src/adpd/jii_adpd6000.cpp new file mode 100644 index 0000000..02672a5 --- /dev/null +++ b/src/src/adpd/jii_adpd6000.cpp @@ -0,0 +1,225 @@ +// SPDX-License-Identifier: CERN-OHL-S-2.0 +// Copyright (c) 2026 Jan IngenHousz Institute + +#include "jii_adpd6000.h" + +#if defined(__has_include) +#if __has_include("esp_attr.h") +#include "esp_attr.h" +#endif +#endif + +// Host tests do not carry ESP-IDF's include path. Production builds use the +// exact WORD_ALIGNED_ATTR definition from esp_attr.h; this identical fallback +// keeps the transport-agnostic driver testable on the host. +#ifndef WORD_ALIGNED_ATTR +#define WORD_ALIGNED_ATTR __attribute__((aligned(4))) +#endif + +namespace jii { +namespace adpd6000 { + +namespace { + +constexpr uint16_t kReadCommandBit = 0; +constexpr uint16_t kWriteCommandBit = 1; +constexpr uint16_t kSoftwareReset = 0x8000; +constexpr uint16_t kOperatingModeMask = 0x0007; +constexpr uint16_t kOperatingModeRun = 0x0001; +constexpr uint16_t kOpticalSlotMask = 0x0F00; +constexpr uint16_t kClearFifo = 0x8000; +constexpr uint16_t kFifoByteCountMask = 0x07FF; + +} // namespace + +Driver::Driver() : transport_{nullptr, nullptr} {} + +Driver::Driver(Transport transport) : transport_(transport) {} + +void Driver::set_transport(Transport transport) { transport_ = transport; } + +int32_t Driver::encode_spi_command(uint16_t register_address, bool write, + uint8_t command_bytes[2]) { + if (command_bytes == nullptr || register_address > kMaxRegisterAddress) { + return kInvalidArgument; + } + + // Figures 38 and 39 of the Rev. 0 data sheet define a 15-bit address + // followed by R/W as the least-significant command bit: 0 reads, 1 writes. + const uint16_t command = static_cast( + (register_address << 1) | (write ? kWriteCommandBit : kReadCommandBit)); + command_bytes[0] = static_cast(command >> 8); + command_bytes[1] = static_cast(command & 0xFF); + return kOk; +} + +int32_t Driver::transact(uint16_t register_address, bool write, + const uint8_t *tx_data, uint8_t *rx_data, + size_t data_length) const { + if (transport_.transact == nullptr || register_address > kMaxRegisterAddress || + data_length == 0) { + return kInvalidArgument; + } + + uint8_t command_bytes[2]; + const int32_t encode_result = + encode_spi_command(register_address, write, command_bytes); + if (encode_result != kOk) { + return encode_result; + } + const uint16_t command = static_cast( + (static_cast(command_bytes[0]) << 8) | command_bytes[1]); + return transport_.transact(transport_.context, command, tx_data, rx_data, + data_length); +} + +int32_t Driver::read_register(uint16_t register_address, uint16_t *value) const { + if (value == nullptr) { + return kInvalidArgument; + } + + // ESP-IDF's SPI DMA engine writes RX data in four-byte units even though an + // ADPD register contributes only two bytes. Keep the on-wire length at two, + // but provide the explicitly aligned four-byte storage DMA requires. + WORD_ALIGNED_ATTR uint8_t bytes[4] = {0, 0, 0, 0}; + const int32_t result = transact(register_address, false, nullptr, bytes, 2); + if (result != kOk) { + return result; + } + *value = static_cast((static_cast(bytes[0]) << 8) | + bytes[1]); + return kOk; +} + +int32_t Driver::write_register(uint16_t register_address, uint16_t value) const { + const uint8_t bytes[2] = {static_cast(value >> 8), + static_cast(value & 0xFF)}; + return transact(register_address, true, bytes, nullptr, sizeof(bytes)); +} + +int32_t Driver::update_register(uint16_t register_address, uint16_t mask, + uint16_t value) const { + uint16_t current = 0; + int32_t result = read_register(register_address, ¤t); + if (result != kOk) { + return result; + } + const uint16_t updated = + static_cast((current & static_cast(~mask)) | + (value & mask)); + return write_register(register_address, updated); +} + +int32_t Driver::identify(uint8_t *chip_id, uint8_t *silicon_version) const { + if (chip_id == nullptr || silicon_version == nullptr) { + return kInvalidArgument; + } + uint16_t identity = 0; + const int32_t result = read_register(reg::kChipId, &identity); + if (result != kOk) { + return result; + } + *chip_id = static_cast(identity & 0xFF); + *silicon_version = static_cast(identity >> 8); + return kOk; +} + +int32_t Driver::software_reset() const { + return write_register(reg::kSystemControl, kSoftwareReset); +} + +int32_t Driver::set_running(bool running) const { + return update_register(reg::kOperatingMode, kOperatingModeMask, + running ? kOperatingModeRun : 0); +} + +int32_t Driver::set_slot_frequency(uint32_t timer_clock_hz, + uint32_t frequency_hz) const { + if (timer_clock_hz == 0 || frequency_hz == 0 || + frequency_hz > timer_clock_hz) { + return kOutOfRange; + } + const uint32_t period = timer_clock_hz / frequency_hz; + if (period == 0 || period > kMaxTimeslotPeriod) { + return kOutOfRange; + } + + int32_t result = write_register(reg::kTimeslotFrequencyLow, + static_cast(period & 0xFFFF)); + if (result != kOk) { + return result; + } + return write_register(reg::kTimeslotFrequencyHigh, + static_cast((period >> 16) & 0x7F)); +} + +int32_t Driver::set_optical_slot_count(uint8_t count) const { + if (count > 12) { + return kOutOfRange; + } + return update_register(reg::kOperatingMode, kOpticalSlotMask, + static_cast(count) << 8); +} + +int32_t Driver::clear_fifo() const { + int32_t result = write_register(reg::kFifoStatus, kClearFifo); + if (result != kOk) { + return result; + } + // CLEAR_FIFO is a command bit. The data sheet requires it to be returned to + // zero after the clear so the FIFO can resume operation. + return write_register(reg::kFifoStatus, 0); +} + +int32_t Driver::fifo_byte_count(uint16_t *count) const { + if (count == nullptr) { + return kInvalidArgument; + } + uint16_t status = 0; + const int32_t result = read_register(reg::kFifoStatus, &status); + if (result != kOk) { + return result; + } + *count = static_cast(status & kFifoByteCountMask); + return kOk; +} + +int32_t Driver::read_fifo(uint8_t *data, size_t length) const { + if (data == nullptr || length == 0 || length > kFifoCapacityBytes) { + return kInvalidArgument; + } + // The FIFO address does not auto-increment like normal registers. A single + // byte-granular transaction drains consecutive bytes while CS stays low. + return transact(reg::kFifoData, false, nullptr, data, length); +} + +int32_t Driver::read_fifo_samples(uint16_t num_samples, uint8_t width, + uint32_t *data) const { + uint8_t readout[4]; + if (data == nullptr || num_samples == 0 || width == 0 || + width > sizeof(readout)) { + return kInvalidArgument; + } + + for (uint16_t i = 0; i < num_samples; ++i) { + data[i] = 0; + const int32_t result = read_fifo(readout, width); + if (result != kOk) { + // Callers historically ignore readfifo's status. Clear the failed and + // unattempted samples so a transport fault cannot republish values left + // in the caller's reusable buffer by a prior measurement point. + for (uint16_t remaining = i; remaining < num_samples; ++remaining) { + data[remaining] = 0; + } + return result; + } + for (uint8_t byte = 0; byte < width; ++byte) { + data[i] |= static_cast(readout[byte]) + << ((width - byte - 1) * 8); + } + } + return kOk; +} + +} // namespace adpd6000 +} // namespace jii diff --git a/src/src/adpd/jii_adpd6000.h b/src/src/adpd/jii_adpd6000.h new file mode 100644 index 0000000..93ea305 --- /dev/null +++ b/src/src/adpd/jii_adpd6000.h @@ -0,0 +1,136 @@ +// SPDX-License-Identifier: CERN-OHL-S-2.0 +// Copyright (c) 2026 Jan IngenHousz Institute + +#ifndef JII_ADPD6000_H +#define JII_ADPD6000_H + +#include +#include + +namespace jii { +namespace adpd6000 { + +constexpr int32_t kOk = 0; +constexpr int32_t kInvalidArgument = -1; +constexpr int32_t kOutOfRange = -2; +constexpr uint16_t kMaxRegisterAddress = 0x7FFF; +constexpr uint16_t kFifoCapacityBytes = 640; +constexpr uint32_t kMaxTimeslotPeriod = 0x7FFFFF; + +enum class Slot : uint8_t { + A = 0, + B, + C, + D, + E, + F, + G, + H, + I, + J, + K, + L, +}; + +namespace reg { + +// ADPD6000 Rev. 0 data sheet, Table 20 and Table 21. Register names and +// numeric addresses are public hardware facts. AMBIT uses only the optical, +// GPIO, clock, and FIFO subset below. +constexpr uint16_t kFifoStatus = 0x0000; +constexpr uint16_t kChipId = 0x0008; +constexpr uint16_t kTimeslotFrequencyLow = 0x000D; +constexpr uint16_t kTimeslotFrequencyHigh = 0x000E; +constexpr uint16_t kSystemControl = 0x000F; +constexpr uint16_t kOperatingMode = 0x0010; +constexpr uint16_t kInputSleep = 0x0020; +constexpr uint16_t kInputConfig = 0x0021; +constexpr uint16_t kGpioConfig = 0x0022; +constexpr uint16_t kGpio01 = 0x0023; +constexpr uint16_t kGpio23 = 0x0024; +constexpr uint16_t kGpioExternal = 0x0026; +constexpr uint16_t kFifoData = 0x002F; +constexpr uint16_t kAdcControl = 0x0046; +constexpr uint16_t kGlobalBiasControl = 0x004C; +constexpr uint16_t kIoAdjust = 0x0057; + +constexpr uint16_t kSlotStride = 0x0020; +constexpr uint16_t kTimeslotControlA = 0x0120; +constexpr uint16_t kTimeslotPathA = 0x0121; +constexpr uint16_t kInputsA = 0x0122; +constexpr uint16_t kCathodeA = 0x0123; +constexpr uint16_t kAfeTrim1A = 0x0124; +constexpr uint16_t kAfeTrim2A = 0x0125; +constexpr uint16_t kAfeDac1A = 0x0126; +constexpr uint16_t kAfeDac2A = 0x0127; +constexpr uint16_t kLedPower12A = 0x0128; +constexpr uint16_t kLedModeA = 0x0129; +constexpr uint16_t kCountsA = 0x012A; +constexpr uint16_t kPeriodA = 0x012B; +constexpr uint16_t kLedPulse1A = 0x012C; +constexpr uint16_t kLedPulse2A = 0x012D; +constexpr uint16_t kIntegratorWidthA = 0x012E; +constexpr uint16_t kIntegratorOffsetA = 0x012F; +constexpr uint16_t kModulationPulseA = 0x0130; +constexpr uint16_t kPattern1A = 0x0131; +constexpr uint16_t kData1A = 0x0135; +constexpr uint16_t kData2A = 0x0136; +constexpr uint16_t kDigitalIntegrationLitA = 0x0138; +constexpr uint16_t kDigitalIntegrationDarkA = 0x0139; + +constexpr uint16_t for_slot(uint16_t slot_a_register, Slot slot) { + return static_cast(slot_a_register + + static_cast(slot) * kSlotStride); +} + +} // namespace reg + +struct Transport { + void *context; + // The 16-bit command is shifted MSB first while CS is asserted, followed by + // data_length bytes. Reads leave tx_data null; writes leave rx_data null. + int32_t (*transact)(void *context, uint16_t command, + const uint8_t *tx_data, uint8_t *rx_data, + size_t data_length); +}; + +class Driver { + public: + Driver(); + explicit Driver(Transport transport); + + void set_transport(Transport transport); + + static int32_t encode_spi_command(uint16_t register_address, bool write, + uint8_t command_bytes[2]); + + int32_t read_register(uint16_t register_address, uint16_t *value) const; + int32_t write_register(uint16_t register_address, uint16_t value) const; + int32_t update_register(uint16_t register_address, uint16_t mask, + uint16_t value) const; + + int32_t identify(uint8_t *chip_id, uint8_t *silicon_version) const; + int32_t software_reset() const; + int32_t set_running(bool running) const; + int32_t set_slot_frequency(uint32_t timer_clock_hz, + uint32_t frequency_hz) const; + int32_t set_optical_slot_count(uint8_t count) const; + + int32_t clear_fifo() const; + int32_t fifo_byte_count(uint16_t *count) const; + int32_t read_fifo(uint8_t *data, size_t length) const; + int32_t read_fifo_samples(uint16_t num_samples, uint8_t width, + uint32_t *data) const; + + private: + int32_t transact(uint16_t register_address, bool write, + const uint8_t *tx_data, uint8_t *rx_data, + size_t data_length) const; + + Transport transport_; +}; + +} // namespace adpd6000 +} // namespace jii + +#endif // JII_ADPD6000_H diff --git a/src/src/adpd/u_adpd6100.cpp b/src/src/adpd/u_adpd6100.cpp index fc71c0e..bd22b86 100644 --- a/src/src/adpd/u_adpd6100.cpp +++ b/src/src/adpd/u_adpd6100.cpp @@ -1,7 +1,4 @@ #include "u_adpd6100.h" -int32_t spi_read(void* user_data, uint8_t *rd_buf, uint32_t rd_len, uint8_t *wr_buf, uint32_t wr_len); -int32_t spi_write(void* user_data, uint8_t *wr_buf, uint32_t len); -int32_t log_print(void* user_data, char *string); static const char* TAG = "ADPD"; @@ -18,13 +15,8 @@ ADPD6::ADPD6(void){ .spics_io_num = ADPD1_CS, .queue_size=1 }; - // handle for spi IO - ADPD6::handle = { - .user_data = &adpd1_spi_handle, - .read = *spi_read, - .write = *spi_write, - .log_write = *log_print - }; + ADPD6::driver.set_transport({&adpd1_spi_handle, + jii_adpd6000_spi_transact}); ADPD6::load_default(&(ADPD6::sys_config)); ADPD6::load_default(&(ADPD6::led_config)); @@ -60,15 +52,27 @@ bool ADPD6::begin(void){ ADPD6::_spi_device_attached = true; uint8_t ret1 = 0; uint8_t ret2 = 0; - adi_adpd6000_device_get_id(&(ADPD6::handle), &ret1, &ret2); + err = static_cast(ADPD6::driver.identify(&ret1, &ret2)); + if (err != ESP_OK) { + ADPD6::chip_check = false; + ESP_LOGE(TAG, "ADPD identity read failed: %s", esp_err_to_name(err)); + return false; + } - if (ret1 == 196) { + if (ret1 == 0xC4) { ADPD6::chip_check = true; Serial.printf("ADPD Found, chip version: %d\n", ret2); - err = adi_adpd6000_device_sw_reset(&(ADPD6::handle)); - ADPD6000_ERROR_RETURN(err); + err = static_cast(ADPD6::driver.software_reset()); + if (err != ESP_OK) { + ADPD6::chip_check = false; + return false; + } + delay(1); ADPD6::load_default(&(ADPD6::sys_config)); - ADPD6::global_setup(&(ADPD6::sys_config)); + if (ADPD6::global_setup(&(ADPD6::sys_config)) != jii::adpd6000::kOk) { + ADPD6::chip_check = false; + return false; + } return true; }else{ ADPD6::chip_check = false; @@ -80,54 +84,51 @@ bool ADPD6::begin(void){ } int32_t ADPD6::clear_fifo(void){ - return adi_adpd6000_device_clr_fifo(&(ADPD6::handle)); + return ADPD6::driver.clear_fifo(); } int32_t ADPD6::run_freq(uint32_t freq){ - return adi_adpd6000_device_set_slot_freq(&(ADPD6::handle), 960000, freq); + return ADPD6::driver.set_slot_frequency(960000, freq); } int32_t ADPD6::RUN(){ - return adi_adpd6000_device_enable_slot_operation_mode_go(&(ADPD6::handle), true); + return ADPD6::driver.set_running(true); } int32_t ADPD6::STOP(){ - return adi_adpd6000_device_enable_slot_operation_mode_go(&(ADPD6::handle), false); + return ADPD6::driver.set_running(false); } uint16_t ADPD6::fifo_count(){ uint16_t ret = 0; - adi_adpd6000_device_get_fifo_count(&(ADPD6::handle), &ret); - if (ret < 641) return ret; + if (ADPD6::driver.fifo_byte_count(&ret) != jii::adpd6000::kOk) return 0; + if (ret <= jii::adpd6000::kFifoCapacityBytes) return ret; return 0; } - int32_t ADPD6::readfifo(uint16_t num_samples, uint8_t width, uint32_t* data){ - uint16_t i, j; - uint8_t readout[width]; - for (i = 0; i < num_samples; i++){ - data[i] = 0; - adi_adpd6000_device_fifo_read_bytes(&(ADPD6::handle), readout, width); - for (j = 0; j < width; j++){ - data[i] += readout[j] << ((width - j - 1) * 8); - } - } - return 0; + return ADPD6::driver.read_fifo_samples(num_samples, width, data); } int32_t ADPD6::write_reg(uint32_t reg_addr, uint16_t *reg_data){ - return adi_adpd6000_hal_reg_write(&(ADPD6::handle), reg_addr, *reg_data); + if (reg_data == nullptr || reg_addr > jii::adpd6000::kMaxRegisterAddress) { + return jii::adpd6000::kInvalidArgument; + } + return ADPD6::driver.write_register(static_cast(reg_addr), + *reg_data); } int32_t ADPD6::read_reg(uint32_t reg_addr){ uint16_t reg_data = 0; - adi_adpd6000_hal_reg_read(&(ADPD6::handle), reg_addr, ®_data); + if (reg_addr > jii::adpd6000::kMaxRegisterAddress) { + return jii::adpd6000::kInvalidArgument; + } + const int32_t result = ADPD6::driver.read_register( + static_cast(reg_addr), ®_data); + if (result != jii::adpd6000::kOk) return result; return reg_data; } - - int32_t ADPD6::num_ts(uint8_t mode){ - return adi_adpd6000_ppg_set_slot_mode(&(ADPD6::handle), (adi_adpd6000_ppg_slot_mode_e)mode); + return ADPD6::driver.set_optical_slot_count(mode); } @@ -140,7 +141,7 @@ void ADPD6::load_default(struct ts_led *ts){ ts->led2_mode = 0; } -int32_t ADPD6::ts_setup(adi_adpd6000_slot_e timeslot_no, struct ts_led *init) +int32_t ADPD6::ts_setup(jii::adpd6000::Slot timeslot_no, struct ts_led *init) { int32_t ret; uint16_t data = 0; @@ -151,18 +152,18 @@ int32_t ADPD6::ts_setup(adi_adpd6000_slot_e timeslot_no, struct ts_led *init) init->led1_channel << 7| init->driver1_current << 0; - ret = ADPD6::write_reg(REG_LED_POW12_A_ADDR + (timeslot_no) * 0x20, &data); - if(ret != API_ADPD6000_ERROR_OK) + ret = ADPD6::write_reg(jii::adpd6000::reg::for_slot(jii::adpd6000::reg::kLedPower12A, timeslot_no), &data); + if(ret != jii::adpd6000::kOk) return ret; /* Set LED power and A/B channels*/ data = init->led2_mode << 1| init->led1_mode << 0; - ret = ADPD6::write_reg(REG_LED_MODE_A_ADDR + (timeslot_no) * 0x20, &data); - if(ret != API_ADPD6000_ERROR_OK) + ret = ADPD6::write_reg(jii::adpd6000::reg::for_slot(jii::adpd6000::reg::kLedModeA, timeslot_no), &data); + if(ret != jii::adpd6000::kOk) return ret; - return API_ADPD6000_ERROR_OK; + return jii::adpd6000::kOk; } @@ -184,7 +185,7 @@ void ADPD6::load_default(struct ts_SNR *ts){ } -int32_t ADPD6::ts_setup(adi_adpd6000_slot_e timeslot_no, struct ts_SNR *init) +int32_t ADPD6::ts_setup(jii::adpd6000::Slot timeslot_no, struct ts_SNR *init) { int32_t ret; uint16_t data = 0; @@ -193,16 +194,16 @@ int32_t ADPD6::ts_setup(adi_adpd6000_slot_e timeslot_no, struct ts_SNR *init) data = init->ch1_dac << 7| init->ch1_led_offset << 0; - ret = ADPD6::write_reg(REG_AFE_DAC1_A_ADDR + (timeslot_no) * 0x20, &data); - if(ret != API_ADPD6000_ERROR_OK) + ret = ADPD6::write_reg(jii::adpd6000::reg::for_slot(jii::adpd6000::reg::kAfeDac1A, timeslot_no), &data); + if(ret != jii::adpd6000::kOk) return ret; /* Set TIA AC Dac for channel 1*/ data = init->ch2_dac << 7| init->ch2_led_offset << 0; - ret = ADPD6::write_reg(REG_AFE_DAC2_A_ADDR + (timeslot_no) * 0x20, &data); - if(ret != API_ADPD6000_ERROR_OK) + ret = ADPD6::write_reg(jii::adpd6000::reg::for_slot(jii::adpd6000::reg::kAfeDac2A, timeslot_no), &data); + if(ret != jii::adpd6000::kOk) return ret; @@ -215,18 +216,18 @@ int32_t ADPD6::ts_setup(adi_adpd6000_slot_e timeslot_no, struct ts_SNR *init) init->TIA_gain_CH2 << 3| init->TIA_gain_CH1 << 0; - ret = ADPD6::write_reg(REG_AFE_TRIM1_A_ADDR + (timeslot_no) * 0x20, &data); - if(ret != API_ADPD6000_ERROR_OK) + ret = ADPD6::write_reg(jii::adpd6000::reg::for_slot(jii::adpd6000::reg::kAfeTrim1A, timeslot_no), &data); + if(ret != jii::adpd6000::kOk) return ret; data = 0; data = init->C_int_CH2 << 13| init->C_int_CH1 << 12; - ret = ADPD6::write_reg(REG_AFE_TRIM2_A_ADDR + (timeslot_no) * 0x20, &data); - if(ret != API_ADPD6000_ERROR_OK) + ret = ADPD6::write_reg(jii::adpd6000::reg::for_slot(jii::adpd6000::reg::kAfeTrim2A, timeslot_no), &data); + if(ret != jii::adpd6000::kOk) return ret; - return API_ADPD6000_ERROR_OK; + return jii::adpd6000::kOk; } void ADPD6::load_default(struct ts_signal *ts){ @@ -247,7 +248,7 @@ void ADPD6::load_default(struct ts_signal *ts){ } -int32_t ADPD6::ts_setup(adi_adpd6000_slot_e timeslot_no, struct ts_signal *init) +int32_t ADPD6::ts_setup(jii::adpd6000::Slot timeslot_no, struct ts_signal *init) { int32_t ret; uint16_t data = 0; @@ -259,16 +260,16 @@ int32_t ADPD6::ts_setup(adi_adpd6000_slot_e timeslot_no, struct ts_signal *init) init->INT2BUT << 8| init->AFE_PATh << 0; - ret = ADPD6::write_reg(REG_TS_PATH_A_ADDR + (timeslot_no) * 0x20, &data); - if(ret != API_ADPD6000_ERROR_OK) + ret = ADPD6::write_reg(jii::adpd6000::reg::for_slot(jii::adpd6000::reg::kTimeslotPathA, timeslot_no), &data); + if(ret != jii::adpd6000::kOk) return ret; /* Set TIA AC Dac for channel 1*/ data = init->IN34 << 4| init->IN12 << 0; - ret = ADPD6::write_reg(REG_INPUTS_A_ADDR + (timeslot_no) * 0x20, &data); - if(ret != API_ADPD6000_ERROR_OK) + ret = ADPD6::write_reg(jii::adpd6000::reg::for_slot(jii::adpd6000::reg::kInputsA, timeslot_no), &data); + if(ret != jii::adpd6000::kOk) return ret; @@ -280,10 +281,10 @@ int32_t ADPD6::ts_setup(adi_adpd6000_slot_e timeslot_no, struct ts_signal *init) init->VC1_pulse_to << 2| init->VC1_active << 0; - ret = ADPD6::write_reg(REG_CATHODE_A_ADDR + (timeslot_no) * 0x20, &data); - if(ret != API_ADPD6000_ERROR_OK) + ret = ADPD6::write_reg(jii::adpd6000::reg::for_slot(jii::adpd6000::reg::kCathodeA, timeslot_no), &data); + if(ret != jii::adpd6000::kOk) return ret; - return API_ADPD6000_ERROR_OK; + return jii::adpd6000::kOk; } void ADPD6::load_default(struct ts_DI_timing *ts){ @@ -310,46 +311,46 @@ void ADPD6::load_default(struct ts_DI_timing *ts){ } -int32_t ADPD6::ts_setup(adi_adpd6000_slot_e timeslot_no, struct ts_DI_timing *init){ +int32_t ADPD6::ts_setup(jii::adpd6000::Slot timeslot_no, struct ts_DI_timing *init){ int32_t ret; uint16_t data = 0; data = init->num_integration << 8| init->num_repeats << 0; - ret = ADPD6::write_reg(REG_COUNTS_A_ADDR + (timeslot_no) * 0x20, &data); - if(ret != API_ADPD6000_ERROR_OK) + ret = ADPD6::write_reg(jii::adpd6000::reg::for_slot(jii::adpd6000::reg::kCountsA, timeslot_no), &data); + if(ret != jii::adpd6000::kOk) return ret; data = init->Modulation_type << 12| init->period_min << 0; - ret = ADPD6::write_reg(REG_PERIOD_A_ADDR + (timeslot_no) * 0x20, &data); - if(ret != API_ADPD6000_ERROR_OK) + ret = ADPD6::write_reg(jii::adpd6000::reg::for_slot(jii::adpd6000::reg::kPeriodA, timeslot_no), &data); + if(ret != jii::adpd6000::kOk) return ret; data = 0; data = init->LED_pulse_width << 8| init->LED_pulse_offset << 0; - ret = ADPD6::write_reg(REG_LED_PULSE1_A_ADDR + (timeslot_no) * 0x20, &data); - if(ret != API_ADPD6000_ERROR_OK) + ret = ADPD6::write_reg(jii::adpd6000::reg::for_slot(jii::adpd6000::reg::kLedPulse1A, timeslot_no), &data); + if(ret != jii::adpd6000::kOk) return ret; data = 0; data = init->LED_pulse2_offset << 0; - ret = ADPD6::write_reg(REG_LED_PULSE2_A_ADDR + (timeslot_no) * 0x20, &data); - if(ret != API_ADPD6000_ERROR_OK) + ret = ADPD6::write_reg(jii::adpd6000::reg::for_slot(jii::adpd6000::reg::kLedPulse2A, timeslot_no), &data); + if(ret != jii::adpd6000::kOk) return ret; data = 0; data = init->LIT_OFFSET << 0; - ret = ADPD6::write_reg(REG_DIGINT_LIT_A_ADDR + (timeslot_no) * 0x20, &data); - if(ret != API_ADPD6000_ERROR_OK) + ret = ADPD6::write_reg(jii::adpd6000::reg::for_slot(jii::adpd6000::reg::kDigitalIntegrationLitA, timeslot_no), &data); + if(ret != jii::adpd6000::kOk) return ret; data = 0; data = init->DARK_OFFSET2 << 7| init->DARK_OFFSET1 << 0; - ret = ADPD6::write_reg(REG_DIGINT_DARK_A_ADDR + (timeslot_no) * 0x20, &data); - if(ret != API_ADPD6000_ERROR_OK) + ret = ADPD6::write_reg(jii::adpd6000::reg::for_slot(jii::adpd6000::reg::kDigitalIntegrationDarkA, timeslot_no), &data); + if(ret != jii::adpd6000::kOk) return ret; data = 0; @@ -357,8 +358,8 @@ int32_t ADPD6::ts_setup(adi_adpd6000_slot_e timeslot_no, struct ts_DI_timing *in init->ch2_en << 14| init->sample_type << 11| init->ts_offset << 0; - ret = ADPD6::write_reg(REG_TS_CTRL_A_ADDR + (timeslot_no) * 0x20, &data); - if(ret != API_ADPD6000_ERROR_OK) + ret = ADPD6::write_reg(jii::adpd6000::reg::for_slot(jii::adpd6000::reg::kTimeslotControlA, timeslot_no), &data); + if(ret != jii::adpd6000::kOk) return ret; data = 0; @@ -366,16 +367,17 @@ int32_t ADPD6::ts_setup(adi_adpd6000_slot_e timeslot_no, struct ts_DI_timing *in init->dark_size << 8| init->signal_shift << 3| init->signal_size << 0; - ret = ADPD6::write_reg(REG_DATA1_A_ADDR + (timeslot_no) * 0x20, &data); - if(ret != API_ADPD6000_ERROR_OK) + ret = ADPD6::write_reg(jii::adpd6000::reg::for_slot(jii::adpd6000::reg::kData1A, timeslot_no), &data); + if(ret != jii::adpd6000::kOk) return ret; data = 0; data = init->lit_shift << 3| init->lit_size << 0; - ret = ADPD6::write_reg(REG_DATA2_A_ADDR + (timeslot_no) * 0x20, &data); - if(ret != API_ADPD6000_ERROR_OK) - return ret; + ret = ADPD6::write_reg(jii::adpd6000::reg::for_slot(jii::adpd6000::reg::kData2A, timeslot_no), &data); + if(ret != jii::adpd6000::kOk) + return ret; + return jii::adpd6000::kOk; } void ADPD6::load_default(struct ts_AI_timing *ts){ @@ -404,26 +406,26 @@ void ADPD6::load_default(struct ts_AI_timing *ts){ } -int32_t ADPD6::ts_setup(adi_adpd6000_slot_e timeslot_no, struct ts_AI_timing *init){ +int32_t ADPD6::ts_setup(jii::adpd6000::Slot timeslot_no, struct ts_AI_timing *init){ int32_t ret; uint16_t data = 0; data = init->Modulation_type << 12| init->period_min << 0; - ret = ADPD6::write_reg(REG_PERIOD_A_ADDR + (timeslot_no) * 0x20, &data); - if(ret != API_ADPD6000_ERROR_OK) + ret = ADPD6::write_reg(jii::adpd6000::reg::for_slot(jii::adpd6000::reg::kPeriodA, timeslot_no), &data); + if(ret != jii::adpd6000::kOk) return ret; data = 0; data = init->LED_pulse_width << 8| init->LED_pulse_offset << 0; - ret = ADPD6::write_reg(REG_LED_PULSE1_A_ADDR + (timeslot_no) * 0x20, &data); - if(ret != API_ADPD6000_ERROR_OK) + ret = ADPD6::write_reg(jii::adpd6000::reg::for_slot(jii::adpd6000::reg::kLedPulse1A, timeslot_no), &data); + if(ret != jii::adpd6000::kOk) return ret; data = 0; data = init->LED_pulse2_offset << 0; - ret = ADPD6::write_reg(REG_LED_PULSE2_A_ADDR + (timeslot_no) * 0x20, &data); - if(ret != API_ADPD6000_ERROR_OK) + ret = ADPD6::write_reg(jii::adpd6000::reg::for_slot(jii::adpd6000::reg::kLedPulse2A, timeslot_no), &data); + if(ret != jii::adpd6000::kOk) return ret; //0x012E INTEG_WIDTH_A @@ -433,24 +435,24 @@ int32_t ADPD6::ts_setup(adi_adpd6000_slot_e timeslot_no, struct ts_AI_timing *in init->CH1_DIS_AMP << 7| init->ADC_count << 5| init->integration_width << 0; - ret = ADPD6::write_reg(REG_INTEG_WIDTH_A_ADDR + (timeslot_no) * 0x20, &data); - if(ret != API_ADPD6000_ERROR_OK) + ret = ADPD6::write_reg(jii::adpd6000::reg::for_slot(jii::adpd6000::reg::kIntegratorWidthA, timeslot_no), &data); + if(ret != jii::adpd6000::kOk) return ret; //0x012F INTEG_OFFSET_A data = 0; data = init->offset_us << 5| init->offset_ns << 0; - ret = ADPD6::write_reg(REG_INTEG_OFFSET_A_ADDR + (timeslot_no) * 0x20, &data); - if(ret != API_ADPD6000_ERROR_OK) + ret = ADPD6::write_reg(jii::adpd6000::reg::for_slot(jii::adpd6000::reg::kIntegratorOffsetA, timeslot_no), &data); + if(ret != jii::adpd6000::kOk) return ret; //0x130 MOD_PULSE_A data = 0; data = init->modulation_width << 8| init->modulation_offset << 0; - ret = ADPD6::write_reg(REG_MOD_PULSE_A_ADDR + (timeslot_no) * 0x20, &data); - if(ret != API_ADPD6000_ERROR_OK) + ret = ADPD6::write_reg(jii::adpd6000::reg::for_slot(jii::adpd6000::reg::kModulationPulseA, timeslot_no), &data); + if(ret != jii::adpd6000::kOk) return ret; //0x0131 PATTERN1_A @@ -459,8 +461,8 @@ int32_t ADPD6::ts_setup(adi_adpd6000_slot_e timeslot_no, struct ts_AI_timing *in init->pattern_MOD_disable << 8| init->pattern_subtract << 4| init->pattern_reverse_int << 0; - ret = ADPD6::write_reg(REG_PATTERN1_A_ADDR + (timeslot_no) * 0x20, &data); - if(ret != API_ADPD6000_ERROR_OK) + ret = ADPD6::write_reg(jii::adpd6000::reg::for_slot(jii::adpd6000::reg::kPattern1A, timeslot_no), &data); + if(ret != jii::adpd6000::kOk) return ret; @@ -470,9 +472,10 @@ int32_t ADPD6::ts_setup(adi_adpd6000_slot_e timeslot_no, struct ts_AI_timing *in init->ch2_en << 14| init->sample_type << 11| init->ts_offset << 0; - ret = ADPD6::write_reg(REG_TS_CTRL_A_ADDR + (timeslot_no) * 0x20, &data); - if(ret != API_ADPD6000_ERROR_OK) - return ret; + ret = ADPD6::write_reg(jii::adpd6000::reg::for_slot(jii::adpd6000::reg::kTimeslotControlA, timeslot_no), &data); + if(ret != jii::adpd6000::kOk) + return ret; + return jii::adpd6000::kOk; } void ADPD6::load_default(struct system_config *ts){ @@ -505,20 +508,20 @@ int32_t ADPD6::global_setup(struct system_config *init){ uint16_t data = 0; data = 0x2004; - ret = ADPD6::write_reg(0x0046, &data); - if(ret != API_ADPD6000_ERROR_OK) + ret = ADPD6::write_reg(jii::adpd6000::reg::kAdcControl, &data); + if(ret != jii::adpd6000::kOk) return ret; data = 0x400b; - ret = ADPD6::write_reg(0x004c, &data); - if(ret != API_ADPD6000_ERROR_OK) + ret = ADPD6::write_reg(jii::adpd6000::reg::kGlobalBiasControl, &data); + if(ret != jii::adpd6000::kOk) return ret; data = 0; data = init->IN34_sleep << 4| init->IN12_sleep << 0; - ret = ADPD6::write_reg(REG_INPUT_SLEEP_ADDR, &data); - if(ret != API_ADPD6000_ERROR_OK) + ret = ADPD6::write_reg(jii::adpd6000::reg::kInputSleep, &data); + if(ret != jii::adpd6000::kOk) return ret; @@ -527,8 +530,8 @@ int32_t ADPD6::global_setup(struct system_config *init){ init->VC1_sleep << 4| init->PAIR34 << 1| init->PAIR12 << 0; - ret = ADPD6::write_reg(REG_INPUT_CFG_ADDR, &data); - if(ret != API_ADPD6000_ERROR_OK) + ret = ADPD6::write_reg(jii::adpd6000::reg::kInputConfig, &data); + if(ret != jii::adpd6000::kOk) return ret; data = 0; @@ -537,22 +540,22 @@ int32_t ADPD6::global_setup(struct system_config *init){ init->GPIO2_cfg << 6| init->GPIO1_cfg << 3| init->GPIO0_cfg << 0; - ret = ADPD6::write_reg(REG_GPIO_CFG_ADDR, &data); - if(ret != API_ADPD6000_ERROR_OK) + ret = ADPD6::write_reg(jii::adpd6000::reg::kGpioConfig, &data); + if(ret != jii::adpd6000::kOk) return ret; data = 0; data = init->GPIO1_output << 8| init->GPIO0_output << 0; - ret = ADPD6::write_reg(REG_GPIO01_ADDR, &data); - if(ret != API_ADPD6000_ERROR_OK) + ret = ADPD6::write_reg(jii::adpd6000::reg::kGpio01, &data); + if(ret != jii::adpd6000::kOk) return ret; data = 0; data = init->GPIO2_output << 0; - ret = ADPD6::write_reg(REG_GPIO23_ADDR, &data); - if(ret != API_ADPD6000_ERROR_OK) + ret = ADPD6::write_reg(jii::adpd6000::reg::kGpio23, &data); + if(ret != jii::adpd6000::kOk) return ret; data = 0; @@ -560,8 +563,8 @@ int32_t ADPD6::global_setup(struct system_config *init){ 1 << 4| init->SPI_slew << 2| init->SPI_drv << 0; - ret = ADPD6::write_reg(REG_IO_ADJUST_ADDR, &data); - if(ret != API_ADPD6000_ERROR_OK) + ret = ADPD6::write_reg(jii::adpd6000::reg::kIoAdjust, &data); + if(ret != jii::adpd6000::kOk) return ret; data = 0; @@ -569,9 +572,10 @@ int32_t ADPD6::global_setup(struct system_config *init){ init->alt_clock_gpio << 6| init->ext_clock_freq << 2| init->internal_clock_en << 1; - ret = ADPD6::write_reg(REG_SYS_CTL_ADDR, &data); - if(ret != API_ADPD6000_ERROR_OK) - return ret; + ret = ADPD6::write_reg(jii::adpd6000::reg::kSystemControl, &data); + if(ret != jii::adpd6000::kOk) + return ret; + return jii::adpd6000::kOk; } void ADPD6::load_default(struct GPIO0_config *ts){ @@ -586,27 +590,21 @@ int32_t ADPD6::gpio_setup(struct GPIO0_config *init){ uint16_t data = 0; data = init->EXT_SYNC_EN << 2| init->SYNC_GPIO << 0; - ret = ADPD6::write_reg(REG_GPIO_EXT_ADDR, &data); - if(ret != API_ADPD6000_ERROR_OK) return ret; + ret = ADPD6::write_reg(jii::adpd6000::reg::kGpioExternal, &data); + if(ret != jii::adpd6000::kOk) return ret; data = 0; data = init->GPIO0_output << 0; - ret = ADPD6::write_reg(REG_GPIO01_ADDR, &data); - if(ret != API_ADPD6000_ERROR_OK) return ret; + ret = ADPD6::write_reg(jii::adpd6000::reg::kGpio01, &data); + if(ret != jii::adpd6000::kOk) return ret; data = 0; data = init->GPIO0_cfg; - ret = ADPD6::write_reg(REG_GPIO_CFG_ADDR, &data); - if(ret != API_ADPD6000_ERROR_OK) return ret; + ret = ADPD6::write_reg(jii::adpd6000::reg::kGpioConfig, &data); + if(ret != jii::adpd6000::kOk) return ret; return 0; } - - - - - - int32_t ADPD6::preset_config_1(uint8_t ts, uint8_t num_integ){ if (!(ADPD6::chip_check)){ ESP_LOGE(TAG, "ADPD Not init in preset1"); @@ -644,10 +642,10 @@ int32_t ADPD6::preset_config_1(uint8_t ts, uint8_t num_integ){ ADPD6::num_ts(ts + 1); - ADPD6::ts_setup((adi_adpd6000_slot_e)ts, &(ADPD6::DI_config)); - ADPD6::ts_setup((adi_adpd6000_slot_e)ts, &(ADPD6::signal_config)); - ADPD6::ts_setup((adi_adpd6000_slot_e)ts, &(ADPD6::SNR_config)); - ADPD6::ts_setup((adi_adpd6000_slot_e)ts, &(ADPD6::led_config)); + ADPD6::ts_setup(static_cast(ts), &(ADPD6::DI_config)); + ADPD6::ts_setup(static_cast(ts), &(ADPD6::signal_config)); + ADPD6::ts_setup(static_cast(ts), &(ADPD6::SNR_config)); + ADPD6::ts_setup(static_cast(ts), &(ADPD6::led_config)); return 0; @@ -694,10 +692,10 @@ int32_t ADPD6::preset_config_2(uint8_t ts, uint8_t num_integ){ ADPD6::num_ts(ts + 1); - ADPD6::ts_setup((adi_adpd6000_slot_e)ts, &(ADPD6::DI_config)); - ADPD6::ts_setup((adi_adpd6000_slot_e)ts, &(ADPD6::signal_config)); - ADPD6::ts_setup((adi_adpd6000_slot_e)ts, &(ADPD6::SNR_config)); - ADPD6::ts_setup((adi_adpd6000_slot_e)ts, &(ADPD6::led_config)); + ADPD6::ts_setup(static_cast(ts), &(ADPD6::DI_config)); + ADPD6::ts_setup(static_cast(ts), &(ADPD6::signal_config)); + ADPD6::ts_setup(static_cast(ts), &(ADPD6::SNR_config)); + ADPD6::ts_setup(static_cast(ts), &(ADPD6::led_config)); return 0; } @@ -741,10 +739,10 @@ int32_t ADPD6::preset_config_2x(uint8_t ts, uint8_t num_integ, uint8_t lit_offse ADPD6::num_ts(ts + 1); - ADPD6::ts_setup((adi_adpd6000_slot_e)ts, &(ADPD6::DI_config)); - ADPD6::ts_setup((adi_adpd6000_slot_e)ts, &(ADPD6::signal_config)); - ADPD6::ts_setup((adi_adpd6000_slot_e)ts, &(ADPD6::SNR_config)); - ADPD6::ts_setup((adi_adpd6000_slot_e)ts, &(ADPD6::led_config)); + ADPD6::ts_setup(static_cast(ts), &(ADPD6::DI_config)); + ADPD6::ts_setup(static_cast(ts), &(ADPD6::signal_config)); + ADPD6::ts_setup(static_cast(ts), &(ADPD6::SNR_config)); + ADPD6::ts_setup(static_cast(ts), &(ADPD6::led_config)); return 0; } @@ -788,10 +786,10 @@ int32_t ADPD6::preset_config_3(uint8_t ts, uint8_t num_integ){ ADPD6::num_ts(ts + 1); - ADPD6::ts_setup((adi_adpd6000_slot_e)ts, &(ADPD6::DI_config)); - ADPD6::ts_setup((adi_adpd6000_slot_e)ts, &(ADPD6::signal_config)); - ADPD6::ts_setup((adi_adpd6000_slot_e)ts, &(ADPD6::SNR_config)); - ADPD6::ts_setup((adi_adpd6000_slot_e)ts, &(ADPD6::led_config)); + ADPD6::ts_setup(static_cast(ts), &(ADPD6::DI_config)); + ADPD6::ts_setup(static_cast(ts), &(ADPD6::signal_config)); + ADPD6::ts_setup(static_cast(ts), &(ADPD6::SNR_config)); + ADPD6::ts_setup(static_cast(ts), &(ADPD6::led_config)); return 0; } @@ -838,10 +836,10 @@ int32_t ADPD6::preset_config_4(uint8_t ts){ ADPD6::num_ts(ts + 1); - ADPD6::ts_setup((adi_adpd6000_slot_e)ts, &(ADPD6::DI_config)); - ADPD6::ts_setup((adi_adpd6000_slot_e)ts, &(ADPD6::signal_config)); - ADPD6::ts_setup((adi_adpd6000_slot_e)ts, &(ADPD6::SNR_config)); - ADPD6::ts_setup((adi_adpd6000_slot_e)ts, &(ADPD6::led_config)); + ADPD6::ts_setup(static_cast(ts), &(ADPD6::DI_config)); + ADPD6::ts_setup(static_cast(ts), &(ADPD6::signal_config)); + ADPD6::ts_setup(static_cast(ts), &(ADPD6::SNR_config)); + ADPD6::ts_setup(static_cast(ts), &(ADPD6::led_config)); return 0; } @@ -851,9 +849,10 @@ int32_t ADPD6::repeats_only(uint8_t ts, uint16_t num_integration, uint8_t num_re int32_t ret; data = num_integration << 8| num_repeats << 0; - ret = ADPD6::write_reg(REG_COUNTS_A_ADDR + (ts) * 0x20, &data); - if(ret != API_ADPD6000_ERROR_OK) + ret = ADPD6::write_reg(jii::adpd6000::reg::for_slot(jii::adpd6000::reg::kCountsA, static_cast(ts)), &data); + if(ret != jii::adpd6000::kOk) return ret; + return jii::adpd6000::kOk; } // external trigger @@ -900,382 +899,10 @@ int32_t ADPD6::preset_config_ext_fast(uint8_t ts, uint8_t integ){ ADPD6::num_ts(ts + 1); - ADPD6::ts_setup((adi_adpd6000_slot_e)ts, &(ADPD6::DI_config)); - ADPD6::ts_setup((adi_adpd6000_slot_e)ts, &(ADPD6::signal_config)); - ADPD6::ts_setup((adi_adpd6000_slot_e)ts, &(ADPD6::SNR_config)); - ADPD6::ts_setup((adi_adpd6000_slot_e)ts, &(ADPD6::led_config)); + ADPD6::ts_setup(static_cast(ts), &(ADPD6::DI_config)); + ADPD6::ts_setup(static_cast(ts), &(ADPD6::signal_config)); + ADPD6::ts_setup(static_cast(ts), &(ADPD6::SNR_config)); + ADPD6::ts_setup(static_cast(ts), &(ADPD6::led_config)); return 0; } - - - - - -// int32_t ADPD6::current_sweep(uint8_t led, uint8_t PD_IN, uint8_t gain, uint32_t *data){ -// if (!(ADPD6::chip_check)){ -// Serial.println("adpd not init1"); -// return -2; -// } - -// if (data == NULL) return -1; -// for (uint8_t i = 0; i < 60; i++) data[i] = 0; - -// ADPD6::STOP(); -// ADPD6::DI_config.period_min = 58; -// ADPD6::DI_config.LIT_OFFSET = 64; -// ADPD6::DI_config.DARK_OFFSET1 = 48; -// ADPD6::DI_config.DARK_OFFSET2 = 90; -// ADPD6::DI_config.LED_pulse_offset = 60; -// ADPD6::DI_config.LED_pulse_width = 19; -// ADPD6::DI_config.sample_type = 3; -// ADPD6::DI_config.num_integration = 1; - -// if ((led == 1)|(led == 3)){ -// ADPD6::led_config.led1_channel = LED_A; -// ADPD6::led_config.led2_channel = LED_A; -// } -// if ((led == 2)|(led == 4)){ -// ADPD6::led_config.led1_channel = LED_B; -// ADPD6::led_config.led2_channel = LED_B; -// } - -// ADPD6::signal_config.IN12 = 0; -// ADPD6::signal_config.IN34 = 0; -// switch (PD_IN) -// { -// case 1: -// ADPD6::signal_config.IN12 = 1; -// break; -// case 2: -// ADPD6::signal_config.IN12 = 3; -// break; -// case 3: -// ADPD6::signal_config.IN34 = 1; -// break; -// case 4: -// ADPD6::signal_config.IN34 = 3; -// break; -// default: -// break; -// } - -// ADPD6::signal_config.pre_condition_type = 5; -// ADPD6::SNR_config.Ch1_R_int = 3; -// ADPD6::SNR_config.C_int_CH1 = 1; -// ADPD6::signal_config.INT2BUT = 1; -// ADPD6::signal_config.ac_type = 2; - -// ADPD6::SNR_config.TIA_gain_CH1 = gain; -// ADPD6::led_config.driver1_current = 0; -// ADPD6::led_config.driver2_current = 0; - - -// uint8_t* p_I_led_driver = &(ADPD6::led_config.driver1_current); -// *p_I_led_driver = 0; -// if (led > 2) p_I_led_driver = &(ADPD6::led_config.driver2_current); -// ADPD6::num_ts(12); - -// for (uint8_t i = 0; i < 12; i++){ -// ADPD6::ts_setup((adi_adpd6000_slot_e)i, &(ADPD6::DI_config)); -// ADPD6::ts_setup((adi_adpd6000_slot_e)i, &(ADPD6::signal_config)); -// ADPD6::ts_setup((adi_adpd6000_slot_e)i, &(ADPD6::SNR_config)); -// } - -// ADPD6::run_freq(500); -// uint32_t ret[12]; -// uint8_t cycle_counter = 0; - -// for (uint8_t c = 0; c < 5; c++){ - -// for (uint8_t i = 0; i < 12; i++){ -// *p_I_led_driver = i * 10 + c * 2; -// ADPD6::ts_setup((adi_adpd6000_slot_e)i, &(ADPD6::led_config)); -// } - -// ADPD6::clear_fifo(); -// ADPD6::RUN(); -// while (ADPD6::fifo_count() < 12 * 3 * 4){ -// delay(10); -// } -// ADPD6::STOP(); - - -// for (uint8_t n = 0; n < 4; n++){ -// ADPD6::readfifo(12, 3, ret); -// for (uint8_t i = 0; i < 12; i++){ -// data[i * 5 + c] += ret[i]; -// } -// } -// } - -// for (uint8_t i = 0; i < 60; i++){ -// data[i] = (data[i] >> 2); -// } -// return 0; -// } - - -// int32_t ADPD6::augogain(uint8_t led, uint8_t PD_IN, uint8_t mode, struct light_gain_setting * output){ -// uint32_t trace[60]; -// uint8_t idx = 0; - -// for (int8_t g = 5; g > -1; g--){ -// ADPD6::current_sweep(led, PD_IN, g, trace); -// idx = 59; -// for (uint8_t i = 0; i < 60; i++){ -// //Serial.println(trace[i]); -// if (trace[i] > 8000){ -// idx = i; -// break; -// } -// } -// if (idx < 10) break; - -// if ( (idx < 30) || ((idx < 59) && (mode == 0)) ){ // Led saturated with half the current or low gain high current mode -// // Serial.print(g); -// // Serial.print(idx); - -// output->current = idx * 2; -// output->gain = g; -// return 0 ; -// } -// output->gain = g; -// } -// output->current = idx * 2; -// return 0; -// } - -// int32_t ADPD6::augogain(uint8_t led, uint8_t PD_IN, uint8_t mode){ -// struct light_gain_setting output; -// ADPD6::augogain(led, PD_IN, mode, &output); -// Serial.println(output.current); -// Serial.println(output.gain); -// return 0; -// } - -// int32_t ADPD6::led_input_preset(struct light_gain_setting* output){ -// if (output == NULL) return -1; -// if (!(ADPD6::chip_check)){ -// Serial.println("adpd not init2"); -// return -2; -// } -// ADPD6::STOP(); - -// ADPD6::led_config.led1_channel = (driverside) output->led_side; -// ADPD6::led_config.led2_channel = (driverside)output->led_side; - -// ADPD6::led_config.driver1_current = 0; -// ADPD6::led_config.driver2_current = 0; -// if (output->led_driver == 1) ADPD6::led_config.driver1_current = output->current; -// if (output->led_driver == 2) ADPD6::led_config.driver2_current = output->current; - -// ADPD6::signal_config.IN12 = 0; -// ADPD6::signal_config.IN34 = 0; - -// if (output->PD == 1) ADPD6::signal_config.IN12 = 1; -// if (output->PD == 2) ADPD6::signal_config.IN12 = 3; -// if (output->PD == 3) ADPD6::signal_config.IN34 = 1; -// if (output->PD == 4) ADPD6::signal_config.IN34 = 3; - -// ADPD6::SNR_config.TIA_gain_CH1 = output->gain; -// return 0; -// } - -// int32_t ADPD6::DI_FluoRef(uint8_t ts, uint8_t num_integ){ -// if (!(ADPD6::chip_check)){ -// Serial.println("adpd not init3"); -// return -2; -// } - -// ADPD6::STOP(); -// ADPD6::DI_config.period_min = 58; -// ADPD6::DI_config.LIT_OFFSET = 64; -// ADPD6::DI_config.DARK_OFFSET1 = 48; -// ADPD6::DI_config.DARK_OFFSET2 = 90; -// ADPD6::DI_config.LED_pulse_offset = 60; -// ADPD6::DI_config.LED_pulse_width = 19; -// ADPD6::DI_config.sample_type = 3; -// ADPD6::DI_config.signal_size = 3; -// ADPD6::DI_config.num_integration = num_integ; -// ADPD6::DI_config.lit_size = 0; -// ADPD6::DI_config.dark_size = 0; - -// ADPD6::signal_config.pre_condition_type = 5; -// ADPD6::SNR_config.Ch1_R_int = 3; -// ADPD6::SNR_config.C_int_CH1 = 1; -// ADPD6::SNR_config.Ch2_R_int = 3; -// ADPD6::SNR_config.C_int_CH2 = 1; -// ADPD6::signal_config.INT2BUT = 1; -// ADPD6::signal_config.ac_type = 2; - -// ADPD6::DI_config.ch2_en = true; -// ADPD6::signal_config.IN12 = 0B0011; -// ADPD6::signal_config.IN34 = 0B0100; - -// ADPD6::num_ts(ts + 1); - -// ADPD6::ts_setup((adi_adpd6000_slot_e)ts, &(ADPD6::DI_config)); -// ADPD6::ts_setup((adi_adpd6000_slot_e)ts, &(ADPD6::signal_config)); -// ADPD6::ts_setup((adi_adpd6000_slot_e)ts, &(ADPD6::SNR_config)); -// ADPD6::ts_setup((adi_adpd6000_slot_e)ts, &(ADPD6::led_config)); - -// return 0; - -// } - -// int32_t ADPD6::DI_ambient(uint8_t ts, uint8_t num_integ){ -// if (!(ADPD6::chip_check)){ -// Serial.println("adpd not init3"); -// return -2; -// } - -// ADPD6::STOP(); -// ADPD6::DI_config.period_min = 58; -// ADPD6::DI_config.LIT_OFFSET = 64; -// ADPD6::DI_config.DARK_OFFSET1 = 48; -// ADPD6::DI_config.DARK_OFFSET2 = 90; -// ADPD6::DI_config.LED_pulse_offset = 60; -// ADPD6::DI_config.LED_pulse_width = 19; -// ADPD6::DI_config.sample_type = 3; -// ADPD6::DI_config.num_integration = num_integ; -// ADPD6::DI_config.dark_size = 3; -// ADPD6::DI_config.lit_size = 0; -// ADPD6::DI_config.signal_size = 0; - -// ADPD6::signal_config.pre_condition_type = 5; -// ADPD6::SNR_config.Ch1_R_int = 3; -// ADPD6::SNR_config.C_int_CH1 = 1; -// ADPD6::SNR_config.Ch2_R_int = 3; -// ADPD6::SNR_config.C_int_CH2 = 1; -// ADPD6::signal_config.INT2BUT = 1; -// ADPD6::signal_config.ac_type = 0; - -// ADPD6::DI_config.ch2_en = false; -// ADPD6::signal_config.IN12 = 0B0001; -// ADPD6::signal_config.IN34 = 0B0000; - -// ADPD6::num_ts(ts + 1); - -// ADPD6::ts_setup((adi_adpd6000_slot_e)ts, &(ADPD6::DI_config)); -// ADPD6::ts_setup((adi_adpd6000_slot_e)ts, &(ADPD6::signal_config)); -// ADPD6::ts_setup((adi_adpd6000_slot_e)ts, &(ADPD6::SNR_config)); -// ADPD6::ts_setup((adi_adpd6000_slot_e)ts, &(ADPD6::led_config)); - -// return 0; - -// } - - - - - -// int32_t ADPD6::current_sweep2(uint8_t led, uint8_t PD_IN, uint8_t gain, uint8_t ac, uint32_t *data){ -// if (!(ADPD6::chip_check)){ -// Serial.println("adpd not init1"); -// return -2; -// } - -// if (data == NULL) return -1; -// for (uint8_t i = 0; i < 60; i++) data[i] = 0; - -// ADPD6::STOP(); -// ADPD6::DI_config.period_min = 58; -// ADPD6::DI_config.LIT_OFFSET = 64; -// ADPD6::DI_config.DARK_OFFSET1 = 48; -// ADPD6::DI_config.DARK_OFFSET2 = 90; -// ADPD6::DI_config.LED_pulse_offset = 60; -// ADPD6::DI_config.LED_pulse_width = 19; -// ADPD6::DI_config.sample_type = 3; -// ADPD6::DI_config.num_integration = 1; - -// if ((led == 1)|(led == 3)){ -// ADPD6::led_config.led1_channel = LED_A; -// ADPD6::led_config.led2_channel = LED_A; -// } -// if ((led == 2)|(led == 4)){ -// ADPD6::led_config.led1_channel = LED_B; -// ADPD6::led_config.led2_channel = LED_B; -// } - -// ADPD6::signal_config.IN12 = 0; -// ADPD6::signal_config.IN34 = 0; -// switch (PD_IN) -// { -// case 1: -// ADPD6::signal_config.IN12 = 1; -// break; -// case 2: -// ADPD6::signal_config.IN12 = 3; -// break; -// case 3: -// ADPD6::signal_config.IN34 = 1; -// break; -// case 4: -// ADPD6::signal_config.IN34 = 3; -// break; -// default: -// break; -// } - -// ADPD6::signal_config.pre_condition_type = 5; -// ADPD6::SNR_config.Ch1_R_int = 3; -// ADPD6::SNR_config.C_int_CH1 = 1; -// ADPD6::signal_config.INT2BUT = 1; -// if (ac < 3) ADPD6::signal_config.ac_type = ac; -// if (ac > 3){ -// ADPD6::signal_config.ac_type = 3; -// ADPD6::SNR_config.ch1_dac = ac * 10; -// } - - -// ADPD6::SNR_config.TIA_gain_CH1 = gain; -// ADPD6::led_config.driver1_current = 0; -// ADPD6::led_config.driver2_current = 0; - - -// uint8_t* p_I_led_driver = &(ADPD6::led_config.driver1_current); -// *p_I_led_driver = 0; -// if (led > 2) p_I_led_driver = &(ADPD6::led_config.driver2_current); -// ADPD6::num_ts(12); - -// for (uint8_t i = 0; i < 12; i++){ -// ADPD6::ts_setup((adi_adpd6000_slot_e)i, &(ADPD6::DI_config)); -// ADPD6::ts_setup((adi_adpd6000_slot_e)i, &(ADPD6::signal_config)); -// ADPD6::ts_setup((adi_adpd6000_slot_e)i, &(ADPD6::SNR_config)); -// } - -// ADPD6::run_freq(500); -// uint32_t ret[12]; -// uint8_t cycle_counter = 0; - -// for (uint8_t c = 0; c < 5; c++){ - -// for (uint8_t i = 0; i < 12; i++){ -// *p_I_led_driver = i * 10 + c * 2; -// ADPD6::ts_setup((adi_adpd6000_slot_e)i, &(ADPD6::led_config)); -// } - -// ADPD6::clear_fifo(); -// ADPD6::RUN(); -// while (ADPD6::fifo_count() < 12 * 3 * 4){ -// delay(10); -// } -// ADPD6::STOP(); -// //Serial.println(ADPD6::read_reg(REG_AFE_DAC1_A_ADDR)); - - - -// for (uint8_t n = 0; n < 4; n++){ -// ADPD6::readfifo(12, 3, ret); -// for (uint8_t i = 0; i < 12; i++){ -// data[i * 5 + c] += ret[i]; -// } -// } -// } - -// for (uint8_t i = 0; i < 60; i++){ -// data[i] = (data[i] >> 2); -// } -// return 0; -// } \ No newline at end of file diff --git a/src/src/adpd/u_adpd6100.h b/src/src/adpd/u_adpd6100.h index f946204..3e53273 100644 --- a/src/src/adpd/u_adpd6100.h +++ b/src/src/adpd/u_adpd6100.h @@ -1,25 +1,25 @@ /*! - * @brief ADPD6000 configuration header + * @brief AMBIT ADPD6000/6100 optical configuration wrapper * @copyright MSU-PRL Kramer Lab - * @author Jingcheng Huang - * @date 20230224 + * @author Jingcheng Huang; Jan IngenHousz Institute + * @date 20230224; clean-room driver migration 20260805 */ #ifndef __U_ADPD6000_H__ #define __U_ADPD6000_H__ #include -#include "lib/ADPD6000/adi_adpd6000.h" #include "driver/spi_common.h" #include "driver/spi_master.h" #include "../pin_config.h" +#include "ADPD_platform_ops.h" +#include "jii_adpd6000.h" #include "u_adpd6100_typedef.h" class ADPD6; class ADPD6{ public: - adi_adpd6000_device_t handle; ADPD6(); ~ADPD6(); bool begin(); @@ -42,11 +42,11 @@ class ADPD6{ struct GPIO0_config gpio_config; - int32_t ts_setup(adi_adpd6000_slot_e timeslot_no,struct ts_led *init); - int32_t ts_setup(adi_adpd6000_slot_e timeslot_no, struct ts_SNR *init); - int32_t ts_setup(adi_adpd6000_slot_e timeslot_no, struct ts_signal *init); - int32_t ts_setup(adi_adpd6000_slot_e timeslot_no, struct ts_DI_timing *init); - int32_t ts_setup(adi_adpd6000_slot_e timeslot_no, struct ts_AI_timing *init); + int32_t ts_setup(jii::adpd6000::Slot timeslot_no, struct ts_led *init); + int32_t ts_setup(jii::adpd6000::Slot timeslot_no, struct ts_SNR *init); + int32_t ts_setup(jii::adpd6000::Slot timeslot_no, struct ts_signal *init); + int32_t ts_setup(jii::adpd6000::Slot timeslot_no, struct ts_DI_timing *init); + int32_t ts_setup(jii::adpd6000::Slot timeslot_no, struct ts_AI_timing *init); int32_t gpio_setup(struct GPIO0_config *init); int32_t global_setup(struct system_config *init); @@ -82,6 +82,7 @@ class ADPD6{ bool _spi_device_attached = false; spi_device_interface_config_t adpd_spi_dev; spi_device_handle_t adpd1_spi_handle = NULL; + jii::adpd6000::Driver driver; void load_default(struct ts_led *ts); @@ -94,4 +95,4 @@ class ADPD6{ }; -#endif \ No newline at end of file +#endif diff --git a/src/src/adpd/u_adpd6100_typedef.h b/src/src/adpd/u_adpd6100_typedef.h index d05e977..73cc740 100644 --- a/src/src/adpd/u_adpd6100_typedef.h +++ b/src/src/adpd/u_adpd6100_typedef.h @@ -126,7 +126,7 @@ struct ts_SNR{ struct ts_signal{ - // 0x0121 REG_TS_PATH_A_ADDR + // Time Slot A path register (0x0121). /** Precondition duration for this time slot. This value is in 2 μs * increments. A value of 0 skips the precondition state. 4 = 8us @@ -607,4 +607,3 @@ struct GPIO0_config{ }; - diff --git a/test/adpd6000/test_main.cpp b/test/adpd6000/test_main.cpp new file mode 100644 index 0000000..0585aef --- /dev/null +++ b/test/adpd6000/test_main.cpp @@ -0,0 +1,302 @@ +// SPDX-License-Identifier: CERN-OHL-S-2.0 +// Copyright (c) 2026 Jan IngenHousz Institute + +#include + +#include +#include +#include +#include +#include + +#include "../../src/src/adpd/jii_adpd6000.h" + +namespace { + +using jii::adpd6000::Driver; +using jii::adpd6000::Transport; + +struct Operation { + uint16_t command; + std::vector transmitted; + size_t received_length; + bool receive_buffer_word_aligned; +}; + +struct FakeTransport { + std::map registers; + std::deque fifo; + std::vector operations; + size_t fail_on_call = 0; + int32_t failure = -77; + bool emulate_dma_word_write = false; + + static int32_t transact(void *context, uint16_t command, + const uint8_t *tx_data, uint8_t *rx_data, + size_t data_length) { + FakeTransport &self = *static_cast(context); + Operation operation = { + command, + {}, + rx_data == nullptr ? 0 : data_length, + rx_data == nullptr || + (reinterpret_cast(rx_data) % sizeof(uint32_t)) == 0}; + if (tx_data != nullptr) { + operation.transmitted.assign(tx_data, tx_data + data_length); + } + self.operations.push_back(operation); + if (self.fail_on_call != 0 && self.operations.size() == self.fail_on_call) { + return self.failure; + } + + const bool write = (command & 1U) != 0; + const uint16_t address = command >> 1; + if (write) { + if (tx_data == nullptr || data_length != 2) { + return -88; + } + const uint16_t value = static_cast( + (static_cast(tx_data[0]) << 8) | tx_data[1]); + self.registers[address] = value; + if (address == jii::adpd6000::reg::kFifoStatus && + (value & 0x8000U) != 0) { + self.fifo.clear(); + } + return 0; + } + + if (rx_data == nullptr) { + return -89; + } + if (address == jii::adpd6000::reg::kFifoData) { + if (self.fifo.size() < data_length) { + return -90; + } + for (size_t i = 0; i < data_length; ++i) { + rx_data[i] = self.fifo.front(); + self.fifo.pop_front(); + } + return 0; + } + if (data_length != 2) { + return -91; + } + uint16_t value = self.registers[address]; + if (address == jii::adpd6000::reg::kFifoStatus) { + value = static_cast((value & 0xF800U) | self.fifo.size()); + } + rx_data[0] = static_cast(value >> 8); + rx_data[1] = static_cast(value & 0xFF); + if (self.emulate_dma_word_write) { + // ESP-IDF documents that SPI DMA writes RX buffers in four-byte units, + // even when the requested transfer length is only two bytes. + rx_data[2] = 0xA5; + rx_data[3] = 0x5A; + } + return 0; + } + + Driver driver() { + return Driver(Transport{this, &FakeTransport::transact}); + } +}; + +int failures = 0; + +void check(bool condition, const std::string &message) { + if (!condition) { + ++failures; + std::cerr << "FAIL: " << message << '\n'; + } +} + +void test_spi_framing_and_register_byte_order() { + uint8_t bytes[2] = {0xFF, 0xFF}; + check(Driver::encode_spi_command(jii::adpd6000::reg::kChipId, false, + bytes) == 0, + "read command encodes"); + check(bytes[0] == 0x00 && bytes[1] == 0x10, + "CHIP_ID read is address<<1 with R/W=0"); + check(Driver::encode_spi_command(jii::adpd6000::reg::kSystemControl, + true, bytes) == 0, + "write command encodes"); + check(bytes[0] == 0x00 && bytes[1] == 0x1F, + "SYS_CTL write is address<<1 with R/W=1"); + check(Driver::encode_spi_command(jii::adpd6000::kMaxRegisterAddress, + true, bytes) == 0 && + bytes[0] == 0xFF && bytes[1] == 0xFF, + "maximum 15-bit register address is accepted"); + check(Driver::encode_spi_command( + static_cast(jii::adpd6000::kMaxRegisterAddress + 1U), + false, bytes) == jii::adpd6000::kInvalidArgument, + "register address above 15 bits is rejected"); + + FakeTransport fake; + Driver driver = fake.driver(); + check(driver.write_register(0x0128, 0xBEEF) == 0, + "register write succeeds"); + check(fake.operations.back().command == 0x0251, + "write command reaches transport unchanged"); + check(fake.operations.back().transmitted == std::vector({0xBE, 0xEF}), + "register value is transmitted MSB first"); + + fake.registers[0x0128] = 0xCAFE; + fake.emulate_dma_word_write = true; + uint16_t value = 0; + check(driver.read_register(0x0128, &value) == 0 && value == 0xCAFE, + "register read reconstructs MSB-first value"); + check(fake.operations.back().received_length == 2, + "register read keeps the wire receive length at two bytes"); + check(fake.operations.back().receive_buffer_word_aligned, + "register read provides a four-byte-aligned DMA receive buffer"); +} + +void test_masking_reset_and_run_transitions() { + FakeTransport fake; + Driver driver = fake.driver(); + fake.registers[jii::adpd6000::reg::kOperatingMode] = 0xA5F8; + + check(driver.set_running(true) == 0, "run transition succeeds"); + check(fake.registers[jii::adpd6000::reg::kOperatingMode] == 0xA5F9, + "run changes only OP_MODE bits"); + check(driver.set_running(false) == 0, "stop transition succeeds"); + check(fake.registers[jii::adpd6000::reg::kOperatingMode] == 0xA5F8, + "stop preserves enabled-slot and unrelated bits"); + check(driver.set_optical_slot_count(3) == 0, + "optical slot count accepts three slots"); + check(fake.registers[jii::adpd6000::reg::kOperatingMode] == 0xA3F8, + "slot count changes only PPG_TIMESLOT_EN"); + check(driver.set_optical_slot_count(12) == 0, + "optical slot count accepts the twelve-slot boundary"); + check(fake.registers[jii::adpd6000::reg::kOperatingMode] == 0xACF8, + "twelve-slot boundary preserves unrelated OPMODE bits"); + check(driver.set_optical_slot_count(13) == jii::adpd6000::kOutOfRange, + "optical slot count rejects values above twelve"); + + check(driver.software_reset() == 0, "software reset write succeeds"); + check(fake.registers[jii::adpd6000::reg::kSystemControl] == 0x8000, + "software reset asserts SYS_CTL.SW_RESET"); +} + +void test_fifo_operations() { + FakeTransport fake; + Driver driver = fake.driver(); + fake.fifo = {0x01, 0x23, 0x45, 0x67, 0x89}; + + uint16_t count = 0; + check(driver.fifo_byte_count(&count) == 0 && count == 5, + "FIFO byte count is read from FIFO_STATUS"); + uint8_t data[3] = {}; + check(driver.read_fifo(data, sizeof(data)) == 0, + "byte-granular FIFO read succeeds"); + check(data[0] == 0x01 && data[1] == 0x23 && data[2] == 0x45, + "FIFO preserves byte stream order"); + check(fake.operations.back().command == 0x005E, + "FIFO read uses the fixed FIFO_DATA read command"); + + uint8_t over_capacity = 0; + const size_t before_invalid_read = fake.operations.size(); + check(driver.read_fifo(&over_capacity, + jii::adpd6000::kFifoCapacityBytes + 1U) == + jii::adpd6000::kInvalidArgument, + "FIFO read rejects lengths past the hardware capacity"); + check(fake.operations.size() == before_invalid_read, + "invalid FIFO length does not reach the transport"); + + const size_t before_clear = fake.operations.size(); + check(driver.clear_fifo() == 0, "FIFO clear succeeds"); + check(fake.fifo.empty(), "FIFO clear empties fake FIFO"); + check(fake.operations.size() == before_clear + 2, + "FIFO clear asserts then deasserts CLEAR_FIFO"); + check(fake.operations[before_clear].transmitted == + std::vector({0x80, 0x00}) && + fake.operations[before_clear + 1].transmitted == + std::vector({0x00, 0x00}), + "FIFO clear transition writes the specified command values"); +} + +void test_fifo_sample_failure_clears_stale_outputs() { + FakeTransport fake; + Driver driver = fake.driver(); + fake.fifo = {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB}; + fake.fail_on_call = 2; + uint32_t samples[3] = {0xAAAAAAAAU, 0xBBBBBBBBU, 0xCCCCCCCCU}; + + check(driver.read_fifo_samples(3, 3, samples) == fake.failure, + "sample FIFO read propagates a mid-run transport failure"); + check(samples[0] == 0x012345U, + "samples completed before the failure remain available"); + check(samples[1] == 0 && samples[2] == 0, + "failed and remaining samples are cleared instead of staying stale"); + check(fake.operations.size() == 2, + "sample FIFO read stops transport work at the first failure"); +} + +void test_frequency_bounds_and_identity() { + FakeTransport fake; + Driver driver = fake.driver(); + + check(driver.set_slot_frequency(960000, 100) == 0, + "100 Hz slot frequency succeeds"); + check(fake.registers[jii::adpd6000::reg::kTimeslotFrequencyLow] == 0x2580 && + fake.registers[jii::adpd6000::reg::kTimeslotFrequencyHigh] == 0, + "slot period is split across low and high registers"); + check(driver.set_slot_frequency(960000, 0) == jii::adpd6000::kOutOfRange, + "zero frequency is rejected"); + check(driver.set_slot_frequency(960000, 960001) == + jii::adpd6000::kOutOfRange, + "frequency above timer clock is rejected"); + check(driver.set_slot_frequency(0xFFFFFFFFU, 1) == + jii::adpd6000::kOutOfRange, + "period wider than 23 bits is rejected"); + + fake.registers[jii::adpd6000::reg::kChipId] = 0x02C4; + uint8_t chip = 0; + uint8_t version = 0; + check(driver.identify(&chip, &version) == 0 && chip == 0xC4 && version == 2, + "identity separates chip ID and silicon version bytes"); +} + +void test_transport_error_propagation() { + FakeTransport fake; + Driver driver = fake.driver(); + fake.fail_on_call = 1; + + uint16_t value = 0; + check(driver.read_register(0x0008, &value) == fake.failure, + "register read propagates transport error"); + check(fake.operations.size() == 1, "failed read performs one transaction"); + + fake.operations.clear(); + fake.fail_on_call = 2; + fake.registers[jii::adpd6000::reg::kOperatingMode] = 0x1200; + check(driver.set_running(true) == fake.failure, + "read-modify-write propagates write error"); + check(fake.operations.size() == 2, + "read-modify-write stops after failed write"); + + fake.operations.clear(); + fake.fail_on_call = 1; + check(driver.clear_fifo() == fake.failure, + "FIFO clear propagates first transport error"); + check(fake.operations.size() == 1, + "FIFO clear does not deassert after failed assertion"); +} + +} // namespace + +int main() { + test_spi_framing_and_register_byte_order(); + test_masking_reset_and_run_transitions(); + test_fifo_operations(); + test_fifo_sample_failure_clears_stale_outputs(); + test_frequency_bounds_and_identity(); + test_transport_error_propagation(); + + if (failures != 0) { + std::cerr << failures << " test(s) failed\n"; + return 1; + } + std::cout << "ADPD6000 fake-transport tests passed\n"; + return 0; +} From ec99a27e6b331f089cadb3bd31890e841ae103eb Mon Sep 17 00:00:00 2001 From: dominikvrbic Date: Wed, 5 Aug 2026 22:01:27 +0200 Subject: [PATCH 22/37] chore(migration): import JII AMBIT continuation --- .github/workflows/pr.yml | 172 + .github/workflows/release.yml | 124 + .gitignore | 16 +- .releaserc.json | 44 + .vscode/arduino.json | 23 - .vscode/c_cpp_properties.json | 86 - .vscode/examples/FSM_combined.excalidraw | 12570 ----------- .vscode/examples/Untitled-1.ipynb | 925 - .vscode/examples/Untitled-1_temp.ipynb | 685 - .vscode/examples/Untitled-2.ipynb | 277 - .vscode/examples/ambit_fsm.excalidraw | 5170 ----- .vscode/examples/demo.ipynb | 296 - .vscode/examples/includes.txt | 69 - .vscode/examples/includes_MAC.txt | 69 - .vscode/examples/phi2_01.png | Bin 20089 -> 0 bytes .vscode/examples/phi2_02.png | Bin 20169 -> 0 bytes .vscode/examples/phi2_03.png | Bin 19650 -> 0 bytes .vscode/examples/pm25.ipynb | 473 - .vscode/examples/pm25.txt | 24 - .vscode/examples/pyAMBYTE.ipynb | 679 - .vscode/examples/sender.ipynb | 1893 -- .vscode/examples/traces_loads.ipynb | 463 - .../examples/traces_loads_qProtocols.ipynb | 550 - .vscode/examples/uploader_v2.ipynb | 278 - .vscode/extensions.json | 10 + .vscode/settings.json | 14 - 260605_amBIT_DEMO.ipynb | 508 + AGENTS.md | 108 + CLAUDE.md | 7 + LICENSE.txt | 289 + ORIGIN.md | 18 + README.md | 27 + adpd6000.pdf | Bin 2012199 -> 0 bytes ambit-1.code-workspace | 19 - ambyte.ipynb | 574 - data_utils.cpp | 718 - do_c.cpp | 229 - dual_ambit_v2.ipynb | 428 - include/README | 37 + lib/README | 46 + lib/openjii_proto/openjii_proto.cpp | 311 + lib/openjii_proto/openjii_proto.h | 65 + old/do_E.cpp | 210 - old/mlx90632.c | 710 - old/mlx90632.h | 465 - old/mlx90632_depends.h | 87 - old/mlx90632_extended_meas.c | 366 - old/mlx90632_extended_meas.h | 156 - package.json | 15 + par_calibrator.py | 122 - plans/HW_CONFORMANCE.md | 165 + plans/MERGE_PLAN.md | 615 + platformio.ini | 48 + run_esp.cpp | 372 - run_output.txt | 51 - self_test.cpp | 309 - sketch.yaml | 17 - src/.gitignore | 2 + PAM.cpp => src/PAM.cpp | 3497 ++-- PAM.h => src/PAM.h | 15 +- src/adpd/ADPD_platform_ops.cpp | 82 - src/adpd/lib/ADPD6000/adi_adpd6000.h | 1983 -- src/adpd/lib/ADPD6000/adi_adpd6000_bf_reg.h | 2353 --- src/adpd/lib/ADPD6000/adi_adpd6000_bioz.c_bak | 591 - src/adpd/lib/ADPD6000/adi_adpd6000_config.h | 36 - src/adpd/lib/ADPD6000/adi_adpd6000_device.c | 360 - src/adpd/lib/ADPD6000/adi_adpd6000_ecg.c | 261 - src/adpd/lib/ADPD6000/adi_adpd6000_gpio.c | 68 - src/adpd/lib/ADPD6000/adi_adpd6000_hal.c | 203 - src/adpd/lib/ADPD6000/adi_adpd6000_ppg.c | 892 - src/adpd/u_adpd6100.cpp | 1281 -- ambit-1.ino => src/ambit-1.ino | 88 +- config.h => src/config.h | 0 src/core.cpp | 43 + src/core.h | 42 + src/data_utils.cpp | 497 + data_utils.h => src/data_utils.h | 35 +- do_command.h => src/do_command.h | 880 +- src/frontend_json.cpp | 190 + nvs1.cpp => src/nvs1.cpp | 7 +- nvs1.h => src/nvs1.h | 36 +- src/run_esp.cpp | 489 + src/self_test.cpp | 169 + serial.cpp => src/serial.cpp | 232 +- serial.h => src/serial.h | 14 +- src/src/adpd/ADPD_platform_ops.cpp | 35 + src/src/adpd/ADPD_platform_ops.h | 14 + src/src/adpd/jii_adpd6000.cpp | 225 + src/src/adpd/jii_adpd6000.h | 136 + src/src/adpd/u_adpd6100.cpp | 908 + src/{ => src}/adpd/u_adpd6100.h | 23 +- src/{ => src}/adpd/u_adpd6100_typedef.h | 3 +- src/{ => src}/as7341/Adafruit_AS7341.cpp | 0 src/{ => src}/as7341/Adafruit_AS7341.h | 0 src/{ => src}/as7341/README.md | 0 src/{ => src}/as7341/code-of-conduct.md | 0 src/{ => src}/as7341/library.properties | 0 src/{ => src}/as7341/license.txt | 0 src/{ => src}/as7341/spec_meas.cpp | 26 +- src/{ => src}/as7341/spec_meas.h | 0 src/{ => src}/devices_init.cpp | 0 src/{ => src}/devices_init.h | 0 src/{ => src}/mlx90632/mlx_dev.cpp | 25 - src/{ => src}/mlx90632/mlx_dev.h | 1 - src/{ => src}/mlx90632/u_mlx.cpp | 4 +- src/{ => src}/mlx90632/u_mlx.h | 0 src/{ => src}/pin_config.h | 0 upload.bat => src/upload.bat | 3 +- uploader.py => src/uploader.py | 0 src/wrench.cpp | 17420 ---------------- src/wrench.h | 972 - test/README | 11 + test/adpd6000/test_main.cpp | 302 + tools/version.py | 50 + 114 files changed, 8013 insertions(+), 58493 deletions(-) create mode 100644 .github/workflows/pr.yml create mode 100644 .github/workflows/release.yml create mode 100644 .releaserc.json delete mode 100644 .vscode/arduino.json delete mode 100644 .vscode/c_cpp_properties.json delete mode 100644 .vscode/examples/FSM_combined.excalidraw delete mode 100644 .vscode/examples/Untitled-1.ipynb delete mode 100644 .vscode/examples/Untitled-1_temp.ipynb delete mode 100644 .vscode/examples/Untitled-2.ipynb delete mode 100644 .vscode/examples/ambit_fsm.excalidraw delete mode 100644 .vscode/examples/demo.ipynb delete mode 100644 .vscode/examples/includes.txt delete mode 100644 .vscode/examples/includes_MAC.txt delete mode 100644 .vscode/examples/phi2_01.png delete mode 100644 .vscode/examples/phi2_02.png delete mode 100644 .vscode/examples/phi2_03.png delete mode 100644 .vscode/examples/pm25.ipynb delete mode 100644 .vscode/examples/pm25.txt delete mode 100644 .vscode/examples/pyAMBYTE.ipynb delete mode 100644 .vscode/examples/sender.ipynb delete mode 100644 .vscode/examples/traces_loads.ipynb delete mode 100644 .vscode/examples/traces_loads_qProtocols.ipynb delete mode 100644 .vscode/examples/uploader_v2.ipynb create mode 100644 .vscode/extensions.json delete mode 100644 .vscode/settings.json create mode 100644 260605_amBIT_DEMO.ipynb create mode 100644 AGENTS.md create mode 100644 CLAUDE.md create mode 100644 LICENSE.txt create mode 100644 ORIGIN.md create mode 100644 README.md delete mode 100644 adpd6000.pdf delete mode 100644 ambit-1.code-workspace delete mode 100644 ambyte.ipynb delete mode 100644 data_utils.cpp delete mode 100644 do_c.cpp delete mode 100644 dual_ambit_v2.ipynb create mode 100644 include/README create mode 100644 lib/README create mode 100644 lib/openjii_proto/openjii_proto.cpp create mode 100644 lib/openjii_proto/openjii_proto.h delete mode 100644 old/do_E.cpp delete mode 100644 old/mlx90632.c delete mode 100644 old/mlx90632.h delete mode 100644 old/mlx90632_depends.h delete mode 100644 old/mlx90632_extended_meas.c delete mode 100644 old/mlx90632_extended_meas.h create mode 100644 package.json delete mode 100644 par_calibrator.py create mode 100644 plans/HW_CONFORMANCE.md create mode 100644 plans/MERGE_PLAN.md create mode 100644 platformio.ini delete mode 100644 run_esp.cpp delete mode 100644 run_output.txt delete mode 100644 self_test.cpp delete mode 100644 sketch.yaml create mode 100644 src/.gitignore rename PAM.cpp => src/PAM.cpp (69%) rename PAM.h => src/PAM.h (61%) delete mode 100644 src/adpd/ADPD_platform_ops.cpp delete mode 100644 src/adpd/lib/ADPD6000/adi_adpd6000.h delete mode 100644 src/adpd/lib/ADPD6000/adi_adpd6000_bf_reg.h delete mode 100644 src/adpd/lib/ADPD6000/adi_adpd6000_bioz.c_bak delete mode 100644 src/adpd/lib/ADPD6000/adi_adpd6000_config.h delete mode 100644 src/adpd/lib/ADPD6000/adi_adpd6000_device.c delete mode 100644 src/adpd/lib/ADPD6000/adi_adpd6000_ecg.c delete mode 100644 src/adpd/lib/ADPD6000/adi_adpd6000_gpio.c delete mode 100644 src/adpd/lib/ADPD6000/adi_adpd6000_hal.c delete mode 100644 src/adpd/lib/ADPD6000/adi_adpd6000_ppg.c delete mode 100644 src/adpd/u_adpd6100.cpp rename ambit-1.ino => src/ambit-1.ino (54%) rename config.h => src/config.h (100%) create mode 100644 src/core.cpp create mode 100644 src/core.h create mode 100644 src/data_utils.cpp rename data_utils.h => src/data_utils.h (62%) rename do_command.h => src/do_command.h (80%) create mode 100644 src/frontend_json.cpp rename nvs1.cpp => src/nvs1.cpp (96%) rename nvs1.h => src/nvs1.h (51%) create mode 100644 src/run_esp.cpp create mode 100644 src/self_test.cpp rename serial.cpp => src/serial.cpp (96%) rename serial.h => src/serial.h (97%) create mode 100644 src/src/adpd/ADPD_platform_ops.cpp create mode 100644 src/src/adpd/ADPD_platform_ops.h create mode 100644 src/src/adpd/jii_adpd6000.cpp create mode 100644 src/src/adpd/jii_adpd6000.h create mode 100644 src/src/adpd/u_adpd6100.cpp rename src/{ => src}/adpd/u_adpd6100.h (81%) rename src/{ => src}/adpd/u_adpd6100_typedef.h (99%) rename src/{ => src}/as7341/Adafruit_AS7341.cpp (100%) rename src/{ => src}/as7341/Adafruit_AS7341.h (100%) rename src/{ => src}/as7341/README.md (100%) rename src/{ => src}/as7341/code-of-conduct.md (100%) rename src/{ => src}/as7341/library.properties (100%) rename src/{ => src}/as7341/license.txt (100%) rename src/{ => src}/as7341/spec_meas.cpp (93%) rename src/{ => src}/as7341/spec_meas.h (100%) rename src/{ => src}/devices_init.cpp (100%) rename src/{ => src}/devices_init.h (100%) rename src/{ => src}/mlx90632/mlx_dev.cpp (96%) rename src/{ => src}/mlx90632/mlx_dev.h (99%) rename src/{ => src}/mlx90632/u_mlx.cpp (98%) rename src/{ => src}/mlx90632/u_mlx.h (100%) rename src/{ => src}/pin_config.h (100%) rename upload.bat => src/upload.bat (97%) rename uploader.py => src/uploader.py (100%) delete mode 100644 src/wrench.cpp delete mode 100644 src/wrench.h create mode 100644 test/README create mode 100644 test/adpd6000/test_main.cpp create mode 100644 tools/version.py diff --git a/.github/workflows/pr.yml b/.github/workflows/pr.yml new file mode 100644 index 0000000..dc9ba3f --- /dev/null +++ b/.github/workflows/pr.yml @@ -0,0 +1,172 @@ +name: Firmware PR + +on: + pull_request: + types: [opened, edited, synchronize, reopened] + +permissions: + contents: read + pull-requests: read + +jobs: + validate-pr: + name: Validate PR title + runs-on: ubuntu-latest + steps: + - uses: amannn/action-semantic-pull-request@v6 + env: + GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} + + build: + name: Build firmware + needs: validate-pr + runs-on: ubuntu-latest + permissions: + contents: write + pull-requests: read + steps: + - name: Checkout PR head + uses: actions/checkout@v6 + with: + ref: ${{ github.event.pull_request.head.sha }} + fetch-depth: 0 + + - name: Setup Node.js + uses: actions/setup-node@v6 + with: + node-version: "24" + + - name: Install release tooling + run: npm install --ignore-scripts --package-lock=false + + - name: Compute release preview + id: preview + env: + GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} + PR_NUMBER: ${{ github.event.pull_request.number }} + PR_TITLE: ${{ github.event.pull_request.title }} + PR_BASE_SHA: ${{ github.event.pull_request.base.sha }} + PR_HEAD_SHA: ${{ github.event.pull_request.head.sha }} + shell: bash + run: | + set -euo pipefail + # Present semantic-release with the PR tree as one squash commit whose + # message is the already validated PR title. + git config user.name "github-actions[bot]" + git config user.email "41898282+github-actions[bot]@users.noreply.github.com" + git checkout -B main "${PR_HEAD_SHA}" + git reset --soft "${PR_BASE_SHA}" + git commit --allow-empty -m "${PR_TITLE}" + + export GITHUB_REF="refs/heads/main" + export GITHUB_EVENT_NAME="push" + set +e + npx semantic-release --dry-run --no-ci 2>&1 | tee release-preview.log + RELEASE_STATUS=${PIPESTATUS[0]} + set -e + if [[ ${RELEASE_STATUS} -ne 0 ]]; then + exit "${RELEASE_STATUS}" + fi + + VERSION=$(grep -Eo 'The next release version is [0-9]+\.[0-9]+\.[0-9]+' release-preview.log | tail -n 1 | awk '{print $6}' || true) + if [[ -n "${VERSION}" ]]; then + BUILD_VERSION="${VERSION}" + WILL_RELEASE=true + else + BUILD_VERSION="pr-${PR_NUMBER}-${PR_HEAD_SHA:0:12}" + WILL_RELEASE=false + fi + + echo "version=${BUILD_VERSION}" >> "${GITHUB_OUTPUT}" + echo "will-release=${WILL_RELEASE}" >> "${GITHUB_OUTPUT}" + { + echo "## Firmware release preview" + echo + if [[ "${WILL_RELEASE}" == "true" ]]; then + echo "Merging this PR will publish **v${VERSION}**." + else + echo "Merging this PR will not create a firmware release." + fi + echo + echo "- Title: \`${PR_TITLE}\`" + echo "- Build version: \`${BUILD_VERSION}\`" + } | tee release-preview.md >> "${GITHUB_STEP_SUMMARY}" + + - name: Setup Python + uses: actions/setup-python@v6 + with: + python-version: "3.12" + + - name: Install PlatformIO + run: | + python -m venv "${RUNNER_TEMP}/platformio" + "${RUNNER_TEMP}/platformio/bin/pip" install --disable-pip-version-check platformio==6.1.19 + + - name: Build firmware + env: + AMBIT_RELEASE_VERSION: ${{ steps.preview.outputs.version }} + # platformio.ini redirects build_dir under LOCALAPPDATA (a Windows + # OneDrive workaround); give it a sane root on the runner. + LOCALAPPDATA: ${{ runner.temp }}/pio_build_root + run: "${RUNNER_TEMP}/platformio/bin/pio run -e ambit" + + - name: Verify version and assemble release assets + env: + FIRMWARE_VERSION: ${{ steps.preview.outputs.version }} + LOCALAPPDATA: ${{ runner.temp }}/pio_build_root + shell: bash + run: | + set -euo pipefail + BUILD_DIR="${LOCALAPPDATA}/pio_build/ambit_fw_new/ambit" + for FILE in firmware.bin bootloader.bin partitions.bin; do + test -f "${BUILD_DIR}/${FILE}" + done + + # The build-injected AMBIT_FW_VERSION must be embedded verbatim: it is + # what cmd 33/2, `hello` and the JSON identity report after flashing. + strings "${BUILD_DIR}/firmware.bin" | grep -qx "${FIRMWARE_VERSION}" + + # boot_app0.bin is not a build product: it ships with the Arduino-ESP32 + # core, but the Calibratron's 4-region flash layout needs it at 0xe000. + BOOT_APP0=$(find "${HOME}/.platformio/packages" -path "*framework-arduinoespressif32*" -name boot_app0.bin | head -n 1) + test -n "${BOOT_APP0}" + + mkdir -p dist + APP_NAME="ambit-fw-v${FIRMWARE_VERSION}.bin" + cp "${BUILD_DIR}/firmware.bin" "dist/${APP_NAME}" + cp "${BUILD_DIR}/bootloader.bin" dist/bootloader.bin + cp "${BUILD_DIR}/partitions.bin" dist/partitions.bin + cp "${BOOT_APP0}" dist/boot_app0.bin + cp release-preview.md dist/release-preview.md + + # Manifest: downstream flashers (Calibratron) read names, offsets and + # hashes from here instead of hardcoding them. + python3 - "$FIRMWARE_VERSION" "$APP_NAME" <<'EOF' + import hashlib, json, sys + version, app_name = sys.argv[1], sys.argv[2] + def entry(file, offset): + data = open(f"dist/{file}", "rb").read() + return {"file": file, "offset": offset, + "size": len(data), "sha256": hashlib.sha256(data).hexdigest()} + manifest = { + "name": "ambit-iot", + "version": version, + "chip": "esp32c3", + "flash": [ + entry("bootloader.bin", "0x0"), + entry("partitions.bin", "0x8000"), + entry("boot_app0.bin", "0xe000"), + entry(app_name, "0x10000"), + ], + "ota": {"file": app_name}, + } + json.dump(manifest, open("dist/manifest.json", "w"), indent=2) + EOF + + - name: Upload firmware candidate + uses: actions/upload-artifact@v6 + with: + name: firmware-${{ github.event.pull_request.head.sha }} + path: dist/ + if-no-files-found: error + retention-days: 30 diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml new file mode 100644 index 0000000..1d4b9b6 --- /dev/null +++ b/.github/workflows/release.yml @@ -0,0 +1,124 @@ +name: Release firmware + +on: + push: + branches: [main] + workflow_dispatch: + +permissions: + contents: write + actions: read + pull-requests: read + +concurrency: + group: firmware-release + cancel-in-progress: false + +jobs: + release: + name: Release firmware + runs-on: ubuntu-latest + steps: + - name: Checkout main + uses: actions/checkout@v6 + with: + fetch-depth: 0 + persist-credentials: false + + - name: Setup Node.js + uses: actions/setup-node@v6 + with: + node-version: "24" + + - name: Install release tooling + run: npm install --ignore-scripts --package-lock=false + + - name: Determine next release + id: preview + env: + GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} + shell: bash + run: | + set -euo pipefail + npx semantic-release --dry-run --no-ci 2>&1 | tee release-preview.log + VERSION=$(grep -Eo 'The next release version is [0-9]+\.[0-9]+\.[0-9]+' release-preview.log | tail -n 1 | awk '{print $6}' || true) + if [[ -n "${VERSION}" ]]; then + echo "will-release=true" >> "${GITHUB_OUTPUT}" + echo "version=${VERSION}" >> "${GITHUB_OUTPUT}" + else + echo "will-release=false" >> "${GITHUB_OUTPUT}" + echo "No firmware release is required." >> "${GITHUB_STEP_SUMMARY}" + fi + + - name: Locate PR firmware artifact + id: artifact + if: steps.preview.outputs.will-release == 'true' + env: + GH_TOKEN: ${{ secrets.GITHUB_TOKEN }} + REPO: ${{ github.repository }} + shell: bash + run: | + set -euo pipefail + # Find the PR whose build produced the artifact we republish. Parsing the + # commit subject is NOT reliable: a squash merge writes "(#N)", a merge + # commit writes "Merge pull request #N", and a direct push writes neither + # (v1.1.0's first attempt failed exactly here, on a merge commit). Ask the + # API which merged PR contains each recent commit instead, newest first, + # so a follow-up direct push to main still finds the last released PR. + PR_NUMBER="" + for SHA in $(git log -n 20 --pretty=%H); do + PR_NUMBER=$(gh api "repos/${REPO}/commits/${SHA}/pulls" \ + --jq '[.[] | select(.merged_at != null) | .number] | first // empty' 2>/dev/null || true) + if [[ -n "${PR_NUMBER}" ]]; then + echo "release commit traced to PR #${PR_NUMBER} (via ${SHA})" + break + fi + done + if [[ -z "${PR_NUMBER}" ]]; then + echo "::error::No merged PR found in the last 20 commits; cannot locate a reviewed firmware artifact" + exit 1 + fi + HEAD_SHA=$(gh pr view "${PR_NUMBER}" --repo "${REPO}" --json headRefOid -q .headRefOid) + ARTIFACT_NAME="firmware-${HEAD_SHA}" + RUN_ID=$(gh api "repos/${REPO}/actions/artifacts?name=${ARTIFACT_NAME}&per_page=100" \ + --jq '[.artifacts[] | select(.expired == false)] | sort_by(.created_at) | last | .workflow_run.id // empty') + if [[ -z "${RUN_ID}" ]]; then + echo "::error::No live PR artifact named ${ARTIFACT_NAME}" + exit 1 + fi + echo "name=${ARTIFACT_NAME}" >> "${GITHUB_OUTPUT}" + echo "run-id=${RUN_ID}" >> "${GITHUB_OUTPUT}" + + - name: Download PR firmware artifact + if: steps.preview.outputs.will-release == 'true' + uses: actions/download-artifact@v6 + with: + name: ${{ steps.artifact.outputs.name }} + path: release-assets + github-token: ${{ secrets.GITHUB_TOKEN }} + repository: ${{ github.repository }} + run-id: ${{ steps.artifact.outputs.run-id }} + + - name: Verify release assets + if: steps.preview.outputs.will-release == 'true' + env: + VERSION: ${{ steps.preview.outputs.version }} + shell: bash + run: | + set -euo pipefail + test -f "release-assets/ambit-fw-v${VERSION}.bin" + test -f release-assets/bootloader.bin + test -f release-assets/partitions.bin + test -f release-assets/boot_app0.bin + test -f release-assets/manifest.json + python3 -c "import json,sys; m=json.load(open('release-assets/manifest.json')); sys.exit(0 if m['version']=='${VERSION}' else 1)" + + - name: Publish GitHub release + if: steps.preview.outputs.will-release == 'true' + env: + GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} + run: npx semantic-release + + - name: Release summary + if: steps.preview.outputs.will-release == 'true' + run: echo "Published firmware v${{ steps.preview.outputs.version }} from the PR-built artifact." >> "${GITHUB_STEP_SUMMARY}" diff --git a/.gitignore b/.gitignore index 947bc14..f6776ee 100644 --- a/.gitignore +++ b/.gitignore @@ -1,7 +1,9 @@ -.vscode -.upload.bat -old -*.ipynb -*.py -*.pdf -*.code-workspace \ No newline at end of file +.pio +node_modules/ +package-lock.json +.vscode/.browse.c_cpp.db* +.vscode/c_cpp_properties.json +.vscode/launch.json +.vscode/ipch +.plans/ +graphify-out/ diff --git a/.releaserc.json b/.releaserc.json new file mode 100644 index 0000000..7467e37 --- /dev/null +++ b/.releaserc.json @@ -0,0 +1,44 @@ +{ + "branches": ["main"], + "plugins": [ + [ + "@semantic-release/commit-analyzer", + { + "preset": "conventionalcommits", + "releaseRules": [ + { "type": "feat", "release": "minor" }, + { "type": "fix", "release": "patch" }, + { "type": "perf", "release": "patch" }, + { "type": "revert", "release": "patch" }, + { "type": "docs", "release": false }, + { "type": "style", "release": false }, + { "type": "chore", "release": false }, + { "type": "refactor", "release": false }, + { "type": "test", "release": false }, + { "type": "build", "release": false }, + { "type": "ci", "release": false }, + { "breaking": true, "release": "major" } + ] + } + ], + [ + "@semantic-release/release-notes-generator", + { "preset": "conventionalcommits" } + ], + [ + "@semantic-release/github", + { + "assets": [ + { "path": "release-assets/manifest.json", "label": "Flash manifest (offsets + sha256)" }, + { "path": "release-assets/ambit-fw-v*.bin", "label": "Application image (OTA / 0x10000)" }, + { "path": "release-assets/bootloader.bin", "label": "Bootloader (0x0)" }, + { "path": "release-assets/partitions.bin", "label": "Partition table (0x8000)" }, + { "path": "release-assets/boot_app0.bin", "label": "OTA data init (0xe000)" } + ], + "successComment": false, + "failComment": false, + "releasedLabels": false + } + ] + ] +} diff --git a/.vscode/arduino.json b/.vscode/arduino.json deleted file mode 100644 index b21aeb8..0000000 --- a/.vscode/arduino.json +++ /dev/null @@ -1,23 +0,0 @@ -{ - "configuration": "UploadSpeed=921600,CDCOnBoot=default,CPUFreq=160,FlashFreq=80,FlashMode=qio,FlashSize=2M,PartitionScheme=minimal,DebugLevel=none,EraseFlash=none,JTAGAdapter=default,ZigbeeMode=default", - "board": "esp32:esp32:esp32c3", - "sketch": "ambit-1.ino", - "port": "COM13", - "output": "../tmp", - "programmer": "esptool", - "monitorPortSettings": { - "settings": { - "port": "COM13", - "baudRate": 115200, - "lineEnding": "\r\n", - "dataBits": 8, - "parity": "none", - "stopBits": "one" - }, - "profile_name": "" - }, - "configurationRequired": true, - "optimize_for_debug": false, - "compile_profile": "ambit", - "useProgrammer": true -} \ No newline at end of file diff --git a/.vscode/c_cpp_properties.json b/.vscode/c_cpp_properties.json deleted file mode 100644 index 887fc99..0000000 --- a/.vscode/c_cpp_properties.json +++ /dev/null @@ -1,86 +0,0 @@ -{ - "configurations": [ - { - "name": "Arduino", - "includePath": [ - "C:\\Users\\huangj27\\Documents\\Arduino\\libraries/**", - "D:\\AA_Folder\\FW\\ESP32\\Ambit_series\\ambit_1\\ambit-1/**", - "C:\\Users\\huangj27\\AppData\\Local\\Arduino15\\internal\\esp32_esp32-arduino-libs_idf-release_v5.3-083aad99-v2_e953d9a84a\\esp32c3\\include/**", - "C:\\Users\\huangj27\\AppData\\Local\\Arduino15\\internal\\esp32_esp32-arduino-libs_idf-release_v5.3-083aad99-v2_e953d9a84a\\esp32c3\\qio_qspi\\include/**", - "C:\\Users\\huangj27\\AppData\\Local\\Arduino15\\internal\\esp32_esp32_3.1.0_c0417d578482f9af\\cores\\esp32/**", - "C:\\Users\\huangj27\\AppData\\Local\\Arduino15\\internal\\esp32_esp32_3.1.0_c0417d578482f9af\\variants\\esp32c3/**", - "C:\\Users\\huangj27\\AppData\\Local\\Arduino15\\internal\\Adafruit_BusIO_1.17.4_7b46ea3f5fdb9ecd\\Adafruit BusIO/**", - "C:\\Users\\huangj27\\AppData\\Local\\Arduino15\\internal\\esp32_esp32_3.1.0_c0417d578482f9af\\libraries\\Wire\\src/**", - "C:\\Users\\huangj27\\AppData\\Local\\Arduino15\\internal\\esp32_esp32_3.1.0_c0417d578482f9af\\libraries\\SPI\\src/**", - "C:\\Users\\huangj27\\AppData\\Local\\Arduino15\\internal\\esp32_esp32_3.1.0_c0417d578482f9af\\libraries\\Preferences\\src/**" - ], - "forcedInclude": [ - "C:\\Users\\huangj27\\AppData\\Local\\Arduino15\\internal\\esp32_esp32_3.1.0_c0417d578482f9af\\cores\\esp32\\Arduino.h" - ], - "compilerPath": "C:\\Users\\huangj27\\AppData\\Local\\Arduino15\\internal\\esp32_esp-rv32_2405_ee89291512ffd117/bin/riscv32-esp-elf-g++", - "compilerArgs": [ - "C:\\Users\\huangj27\\AppData\\Local\\Arduino15\\internal\\esp32_esp-rv32_2405_ee89291512ffd117/bin/riscv32-esp-elf-g++", - "-MMD", - "-c", - "@C:\\Users\\huangj27\\AppData\\Local\\Arduino15\\internal\\esp32_esp32-arduino-libs_idf-release_v5.3-083aad99-v2_e953d9a84a\\esp32c3/flags/cpp_flags", - "-w", - "-Os", - "-Werror=return-type", - "-DF_CPU=160000000L", - "-DARDUINO=10607", - "-DARDUINO_ESP32C3_DEV", - "-DARDUINO_ARCH_ESP32", - "-DARDUINO_BOARD=\"ESP32C3_DEV\"", - "-DARDUINO_VARIANT=\"esp32c3\"", - "-DARDUINO_PARTITION_minimal", - "-DARDUINO_HOST_OS=\"windows\"", - "-DARDUINO_FQBN=\"esp32:esp32:esp32c3:UploadSpeed=921600,CDCOnBoot=default,CPUFreq=160,FlashFreq=80,FlashMode=qio,FlashSize=4M,PartitionScheme=minimal,DebugLevel=none,EraseFlash=all,JTAGAdapter=default,ZigbeeMode=default\"", - "-DESP32=ESP32", - "-DCORE_DEBUG_LEVEL=0", - "-DARDUINO_USB_MODE=1", - "-DARDUINO_USB_CDC_ON_BOOT=0", - "@C:\\Users\\huangj27\\AppData\\Local\\Arduino15\\internal\\esp32_esp32-arduino-libs_idf-release_v5.3-083aad99-v2_e953d9a84a\\esp32c3/flags/defines", - "-ID:\\AA_Folder\\FW\\ESP32\\Ambit_series\\ambit_1\\ambit-1", - "-iprefix", - "C:\\Users\\huangj27\\AppData\\Local\\Arduino15\\internal\\esp32_esp32-arduino-libs_idf-release_v5.3-083aad99-v2_e953d9a84a\\esp32c3/include/", - "@C:\\Users\\huangj27\\AppData\\Local\\Arduino15\\internal\\esp32_esp32-arduino-libs_idf-release_v5.3-083aad99-v2_e953d9a84a\\esp32c3/flags/includes", - "-IC:\\Users\\huangj27\\AppData\\Local\\Arduino15\\internal\\esp32_esp32-arduino-libs_idf-release_v5.3-083aad99-v2_e953d9a84a\\esp32c3/qio_qspi/include", - "-IC:\\Users\\huangj27\\AppData\\Local\\Arduino15\\internal\\esp32_esp32_3.1.0_c0417d578482f9af\\cores\\esp32", - "-IC:\\Users\\huangj27\\AppData\\Local\\Arduino15\\internal\\esp32_esp32_3.1.0_c0417d578482f9af\\variants\\esp32c3", - "-IC:\\Users\\huangj27\\AppData\\Local\\Arduino15\\internal\\Adafruit_BusIO_1.17.4_7b46ea3f5fdb9ecd\\Adafruit BusIO", - "-IC:\\Users\\huangj27\\AppData\\Local\\Arduino15\\internal\\esp32_esp32_3.1.0_c0417d578482f9af\\libraries\\Wire\\src", - "-IC:\\Users\\huangj27\\AppData\\Local\\Arduino15\\internal\\esp32_esp32_3.1.0_c0417d578482f9af\\libraries\\SPI\\src", - "-IC:\\Users\\huangj27\\AppData\\Local\\Arduino15\\internal\\esp32_esp32_3.1.0_c0417d578482f9af\\libraries\\Preferences\\src", - "@D:\\AA_Folder\\FW\\ESP32\\Ambit_series\\ambit_1\\tmp\\build_ambit/build_opt.h", - "@D:\\AA_Folder\\FW\\ESP32\\Ambit_series\\ambit_1\\tmp\\build_ambit/file_opts", - "D:\\AA_Folder\\FW\\ESP32\\Ambit_series\\ambit_1\\tmp\\build_ambit\\sketch\\PAM.cpp", - "-o", - "D:\\AA_Folder\\FW\\ESP32\\Ambit_series\\ambit_1\\tmp\\build_ambit\\sketch\\PAM.cpp.o" - ], - "defines": [ - "F_CPU=160000000L", - "ARDUINO=10607", - "ARDUINO_ESP32C3_DEV", - "ARDUINO_ARCH_ESP32", - "ARDUINO_BOARD=\"ESP32C3_DEV\"", - "ARDUINO_VARIANT=\"esp32c3\"", - "ARDUINO_PARTITION_minimal", - "ARDUINO_HOST_OS=\"windows\"", - "ARDUINO_FQBN=\"esp32:esp32:esp32c3:UploadSpeed=921600,CDCOnBoot=default,CPUFreq=160,FlashFreq=80,FlashMode=qio,FlashSize=4M,PartitionScheme=minimal,DebugLevel=none,EraseFlash=all,JTAGAdapter=default,ZigbeeMode=default\"", - "ESP32=ESP32", - "CORE_DEBUG_LEVEL=0", - "ARDUINO_USB_MODE=1", - "ARDUINO_USB_CDC_ON_BOOT=0", - "ARDUINO_BOARD=\\\"ESP32C3_DEV\\\"\"", - "ARDUINO_VARIANT=\\\"esp32c3\\\"\"", - "ARDUINO_HOST_OS=\\\"windows\\\"\"", - "ARDUINO_FQBN=\\\"esp32:esp32:esp32c3:UploadSpeed=921600,CDCOnBoot=default,CPUFreq=160,FlashFreq=80,FlashMode=qio,FlashSize=4M,PartitionScheme=minimal,DebugLevel=none,EraseFlash=all,JTAGAdapter=default,ZigbeeMode=default\\\"\"", - "ARDUINO_CORE_BUILD", - "USBCON" - ], - "cStandard": "c17", - "cppStandard": "c++17" - } - ], - "version": 4 -} \ No newline at end of file diff --git a/.vscode/examples/FSM_combined.excalidraw b/.vscode/examples/FSM_combined.excalidraw deleted file mode 100644 index afd4aed..0000000 --- a/.vscode/examples/FSM_combined.excalidraw +++ /dev/null @@ -1,12570 +0,0 @@ -{ - "type": "excalidraw", - "version": 2, - "source": "https://marketplace.visualstudio.com/items?itemName=pomdtr.excalidraw-editor", - "elements": [ - { - "type": "rectangle", - "version": 1092, - "versionNonce": 1353254064, - "isDeleted": false, - "id": "pt-9mP3SKkXwwMIxu9wrD", - "fillStyle": "cross-hatch", - "strokeWidth": 2, - "strokeStyle": "dotted", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 2271.2276545457325, - "y": 3177.5945953942132, - "strokeColor": "#e03131", - "backgroundColor": "#ffec99", - "width": 1683.3331298828116, - "height": 1121.666755676269, - "seed": 994387473, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 3 - }, - "boundElements": [], - "updated": 1714744053936, - "link": null, - "locked": false - }, - { - "type": "rectangle", - "version": 543, - "versionNonce": 769318480, - "isDeleted": false, - "id": "aaz6cNCI_j8N6G1raymwv", - "fillStyle": "cross-hatch", - "strokeWidth": 2, - "strokeStyle": "dotted", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 1061.227654545733, - "y": 3157.5945953942132, - "strokeColor": "#e03131", - "backgroundColor": "#ffec99", - "width": 1175.8331298828118, - "height": 1166.666755676269, - "seed": 1024409525, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 3 - }, - "boundElements": [], - "updated": 1714744053936, - "link": null, - "locked": false - }, - { - "type": "rectangle", - "version": 169, - "versionNonce": 1485106864, - "isDeleted": false, - "id": "MirtgVDjs3MKh0_VZszei", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": -323.8951139904175, - "y": 3657.7246207585376, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 282.3999938964844, - "height": 145.76242065429682, - "seed": 1223074271, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 3 - }, - "boundElements": [ - { - "type": "text", - "id": "lwZzuQ1tXelScna8pNPTa" - }, - { - "id": "928BTNxR2z6vRYef32noK", - "type": "arrow" - }, - { - "id": "-WiN9iXrynz3M1JX3xK7v", - "type": "arrow" - }, - { - "id": "2jA6V3d4c1VkKuvHPMw1b", - "type": "arrow" - } - ], - "updated": 1714744053936, - "link": null, - "locked": false - }, - { - "type": "text", - "version": 123, - "versionNonce": 294294608, - "isDeleted": false, - "id": "lwZzuQ1tXelScna8pNPTa", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": -240.58310227166749, - "y": 3708.105831085686, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 115.77597045898438, - "height": 45, - "seed": 823532575, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053936, - "link": null, - "locked": false, - "fontSize": 36, - "fontFamily": 1, - "text": "SLEEP", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "MirtgVDjs3MKh0_VZszei", - "originalText": "SLEEP", - "lineHeight": 1.25, - "baseline": 38 - }, - { - "type": "diamond", - "version": 273, - "versionNonce": 290691248, - "isDeleted": false, - "id": "L-iASTWFuRMdMSTyvh7t4", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 36.90490432012939, - "y": 3646.6872367253345, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 184.79998779296875, - "height": 184.79998779296875, - "seed": 452865983, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 2 - }, - "boundElements": [ - { - "type": "text", - "id": "aNfbUypu6HzNoJJLtdZDd" - }, - { - "id": "928BTNxR2z6vRYef32noK", - "type": "arrow" - }, - { - "id": "-WiN9iXrynz3M1JX3xK7v", - "type": "arrow" - }, - { - "id": "OvEZk-8scrlXLuGmE7FPb", - "type": "arrow" - } - ], - "updated": 1714744053936, - "link": null, - "locked": false - }, - { - "type": "text", - "version": 218, - "versionNonce": 299076176, - "isDeleted": false, - "id": "aNfbUypu6HzNoJJLtdZDd", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 100.5849122546997, - "y": 3713.8872336735767, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 57.03997802734375, - "height": 50, - "seed": 639092927, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053936, - "link": null, - "locked": false, - "fontSize": 20, - "fontFamily": 1, - "text": "UART\ninput", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "L-iASTWFuRMdMSTyvh7t4", - "originalText": "UART\ninput", - "lineHeight": 1.25, - "baseline": 46 - }, - { - "type": "arrow", - "version": 317, - "versionNonce": 1321009840, - "isDeleted": false, - "id": "928BTNxR2z6vRYef32noK", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": -25.65747360955808, - "y": 3735.462389115326, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 50.90109560222547, - "height": 1.4532686988250134, - "seed": 494747313, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053936, - "link": null, - "locked": false, - "startBinding": { - "elementId": "MirtgVDjs3MKh0_VZszei", - "focus": -0.003106909499580352, - "gap": 15.837646484375 - }, - "endBinding": { - "elementId": "L-iASTWFuRMdMSTyvh7t4", - "focus": -0.008652201328443859, - "gap": 11.861755096939916 - }, - "lastCommittedPoint": null, - "startArrowhead": null, - "endArrowhead": "arrow", - "points": [ - [ - 0, - 0 - ], - [ - 50.90109560222547, - 1.4532686988250134 - ] - ] - }, - { - "type": "rectangle", - "version": 390, - "versionNonce": 1234026576, - "isDeleted": false, - "id": "ViWZZy9Q7c0UYyERaQ5M0", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 376.50489516485595, - "y": 3665.5310019841236, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 282.3999938964844, - "height": 145.76242065429682, - "seed": 347662161, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 3 - }, - "boundElements": [ - { - "type": "text", - "id": "qK6m5n9Nbto6yahbct-jf" - }, - { - "id": "OvEZk-8scrlXLuGmE7FPb", - "type": "arrow" - }, - { - "id": "3TDl2MJg2FQvz-gbZsQQP", - "type": "arrow" - }, - { - "id": "B0Fc9vslccT_uvolbahsS", - "type": "arrow" - }, - { - "id": "G5nVT5VA8UUPppUVgsIHm", - "type": "arrow" - }, - { - "id": "iXpExTgBKgqPR5laoFls7", - "type": "arrow" - }, - { - "id": "QHTBVNXQrucCR_A6H0uaZ", - "type": "arrow" - }, - { - "id": "1pwwcSYOnzOIeKOG9nO85", - "type": "arrow" - } - ], - "updated": 1714744053936, - "link": null, - "locked": false - }, - { - "type": "text", - "version": 345, - "versionNonce": 795421872, - "isDeleted": false, - "id": "qK6m5n9Nbto6yahbct-jf", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 470.94090743292236, - "y": 3715.912212311272, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 93.52796936035156, - "height": 45, - "seed": 1822545201, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053936, - "link": null, - "locked": false, - "fontSize": 36, - "fontFamily": 1, - "text": "IDLE", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "ViWZZy9Q7c0UYyERaQ5M0", - "originalText": "IDLE", - "lineHeight": 1.25, - "baseline": 38 - }, - { - "type": "arrow", - "version": 233, - "versionNonce": 949040720, - "isDeleted": false, - "id": "-WiN9iXrynz3M1JX3xK7v", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 135.30450148809814, - "y": 3848.124614655022, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 330.4000244140625, - "height": 115.99996948242188, - "seed": 1609308639, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [ - { - "type": "text", - "id": "I3ao2m-5w5FzW_XrAW_Eo" - } - ], - "updated": 1714744053936, - "link": null, - "locked": false, - "startBinding": { - "elementId": "L-iASTWFuRMdMSTyvh7t4", - "focus": -0.07519278226210531, - "gap": 16.006771544615603 - }, - "endBinding": { - "elementId": "MirtgVDjs3MKh0_VZszei", - "focus": 0.09224382420379566, - "gap": 20.6375732421875 - }, - "lastCommittedPoint": null, - "startArrowhead": null, - "endArrowhead": "arrow", - "points": [ - [ - 0, - 0 - ], - [ - -0.800048828125, - 91.99996948242188 - ], - [ - -329.60003662109375, - 87.19998168945312 - ], - [ - -330.4000244140625, - -24 - ] - ] - }, - { - "type": "text", - "version": 28, - "versionNonce": 1023415984, - "isDeleted": false, - "id": "I3ao2m-5w5FzW_XrAW_Eo", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": -54.55552963983155, - "y": 3915.2245902409595, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 49.319976806640625, - "height": 45, - "seed": 979230431, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053936, - "link": null, - "locked": false, - "fontSize": 36, - "fontFamily": 1, - "text": "NO", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "-WiN9iXrynz3M1JX3xK7v", - "originalText": "NO", - "lineHeight": 1.25, - "baseline": 38 - }, - { - "type": "arrow", - "version": 114, - "versionNonce": 599125072, - "isDeleted": false, - "id": "OvEZk-8scrlXLuGmE7FPb", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 235.7833449662752, - "y": 3741.649261986373, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 117.12113210776045, - "height": 1.4778070768534235, - "seed": 2083668433, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053936, - "link": null, - "locked": false, - "startBinding": { - "elementId": "L-iASTWFuRMdMSTyvh7t4", - "focus": 0.037201062302432523, - "gap": 14.30967642723229 - }, - "endBinding": { - "elementId": "ViWZZy9Q7c0UYyERaQ5M0", - "focus": 0.004288217994394458, - "gap": 23.600418090820312 - }, - "lastCommittedPoint": null, - "startArrowhead": null, - "endArrowhead": "arrow", - "points": [ - [ - 0, - 0 - ], - [ - 117.12113210776045, - -1.4778070768534235 - ] - ] - }, - { - "type": "diamond", - "version": 463, - "versionNonce": 204062896, - "isDeleted": false, - "id": "jj_yHGzqEfb3EVrV7IAkE", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 2, - "opacity": 100, - "angle": 0, - "x": 765.1044587634888, - "y": 3647.674632965569, - "strokeColor": "#1971c2", - "backgroundColor": "#ffc9c9", - "width": 184.79998779296875, - "height": 184.79998779296875, - "seed": 1264239377, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 2 - }, - "boundElements": [ - { - "type": "text", - "id": "divVu8Qqns3cT8RUrS4w7" - }, - { - "id": "3TDl2MJg2FQvz-gbZsQQP", - "type": "arrow" - }, - { - "id": "1K2QjfeA0GWeHrjWOTtMK", - "type": "arrow" - }, - { - "id": "zKHIolzbkZXnArU9Xcx6Q", - "type": "arrow" - }, - { - "id": "L50BGCy0awqTIQHghyt9z", - "type": "arrow" - } - ], - "updated": 1714744053936, - "link": null, - "locked": false - }, - { - "type": "text", - "version": 407, - "versionNonce": 1960043088, - "isDeleted": false, - "id": "divVu8Qqns3cT8RUrS4w7", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 832.8344697498169, - "y": 3714.874629913811, - "strokeColor": "#1971c2", - "backgroundColor": "transparent", - "width": 48.939971923828125, - "height": 50, - "seed": 1804666641, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053936, - "link": null, - "locked": false, - "fontSize": 20, - "fontFamily": 1, - "text": "Wake\n(211)", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "jj_yHGzqEfb3EVrV7IAkE", - "originalText": "Wake\n(211)", - "lineHeight": 1.25, - "baseline": 46 - }, - { - "type": "diamond", - "version": 610, - "versionNonce": 1552820912, - "isDeleted": false, - "id": "3nOMpYEVbfxy5YlUz3RSc", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 768.3044099353638, - "y": 3878.449581085686, - "strokeColor": "#1971c2", - "backgroundColor": "transparent", - "width": 184.79998779296875, - "height": 184.79998779296875, - "seed": 721195647, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 2 - }, - "boundElements": [ - { - "type": "text", - "id": "w3PJaAR1UFs4J9cI-jX-i" - }, - { - "id": "1K2QjfeA0GWeHrjWOTtMK", - "type": "arrow" - }, - { - "id": "2jA6V3d4c1VkKuvHPMw1b", - "type": "arrow" - }, - { - "id": "3qj6dE7YV5VkyyM-orVEg", - "type": "arrow" - } - ], - "updated": 1714744053936, - "link": null, - "locked": false - }, - { - "type": "text", - "version": 576, - "versionNonce": 448993360, - "isDeleted": false, - "id": "w3PJaAR1UFs4J9cI-jX-i", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 823.5144471668091, - "y": 3933.1495780339283, - "strokeColor": "#1971c2", - "backgroundColor": "transparent", - "width": 73.97991943359375, - "height": 75, - "seed": 1742989983, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053936, - "link": null, - "locked": false, - "fontSize": 20, - "fontFamily": 1, - "text": "Complet\ne\n240", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "3nOMpYEVbfxy5YlUz3RSc", - "originalText": "Complete\n240", - "lineHeight": 1.25, - "baseline": 71 - }, - { - "type": "arrow", - "version": 93, - "versionNonce": 953504944, - "isDeleted": false, - "id": "3TDl2MJg2FQvz-gbZsQQP", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 669.7044038318481, - "y": 3737.208992925008, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 89.00246009566376, - "height": 2.7166506316098094, - "seed": 1534593407, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [ - { - "type": "text", - "id": "yMC16ViMT7oPtxH6R0Uqb" - } - ], - "updated": 1714744053936, - "link": null, - "locked": false, - "startBinding": { - "elementId": "ViWZZy9Q7c0UYyERaQ5M0", - "focus": -0.07710905772468238, - "gap": 10.799514770507812 - }, - "endBinding": { - "elementId": "jj_yHGzqEfb3EVrV7IAkE", - "focus": -0.031024322165604547, - "gap": 6.399329317250107 - }, - "lastCommittedPoint": null, - "startArrowhead": null, - "endArrowhead": "arrow", - "points": [ - [ - 0, - 0 - ], - [ - 89.00246009566376, - 2.7166506316098094 - ] - ] - }, - { - "type": "text", - "version": 30, - "versionNonce": 1767607888, - "isDeleted": false, - "id": "yMC16ViMT7oPtxH6R0Uqb", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 690.3204316638794, - "y": 3728.92461770678, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 45.16796875, - "height": 20, - "seed": 323450367, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053936, - "link": null, - "locked": false, - "fontSize": 16, - "fontFamily": 1, - "text": "100ms", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "3TDl2MJg2FQvz-gbZsQQP", - "originalText": "100ms", - "lineHeight": 1.25, - "baseline": 17 - }, - { - "type": "arrow", - "version": 196, - "versionNonce": 380059312, - "isDeleted": false, - "id": "1K2QjfeA0GWeHrjWOTtMK", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 922.9216007221565, - "y": 3790.907295694401, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 3.011202334860741, - "height": 123.63337077368078, - "seed": 1051573759, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053936, - "link": null, - "locked": false, - "startBinding": { - "elementId": "jj_yHGzqEfb3EVrV7IAkE", - "focus": -0.6948033911504963, - "gap": 16.864371572017816 - }, - "endBinding": { - "elementId": "3nOMpYEVbfxy5YlUz3RSc", - "focus": 0.7207776830617192, - "gap": 20.603192203785753 - }, - "lastCommittedPoint": null, - "startArrowhead": null, - "endArrowhead": "arrow", - "points": [ - [ - 0, - 0 - ], - [ - 3.011202334860741, - 123.63337077368078 - ] - ] - }, - { - "type": "arrow", - "version": 226, - "versionNonce": 2037728336, - "isDeleted": false, - "id": "2jA6V3d4c1VkKuvHPMw1b", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 807.3043794177856, - "y": 4030.5246085515064, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 1068.0000610351562, - "height": 212, - "seed": 510787793, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [ - { - "type": "text", - "id": "o9VTEhz_yQ6WEf6Z2pU_w" - } - ], - "updated": 1714744053937, - "link": null, - "locked": false, - "startBinding": { - "elementId": "3nOMpYEVbfxy5YlUz3RSc", - "focus": -0.6419376269810059, - "gap": 14.619478017323388 - }, - "endBinding": { - "elementId": "MirtgVDjs3MKh0_VZszei", - "focus": 0.5155642464843946, - "gap": 22.237579345703125 - }, - "lastCommittedPoint": null, - "startArrowhead": null, - "endArrowhead": "arrow", - "points": [ - [ - 0, - 0 - ], - [ - -1068.0000610351562, - 7.20001220703125 - ], - [ - -1064.8000793457031, - -204.79998779296875 - ] - ] - }, - { - "type": "text", - "version": 33, - "versionNonce": 1990977712, - "isDeleted": false, - "id": "o9VTEhz_yQ6WEf6Z2pU_w", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": -295.55965714227295, - "y": 4027.7246207585376, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 69.72795104980469, - "height": 20, - "seed": 938218833, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053937, - "link": null, - "locked": false, - "fontSize": 16, - "fontFamily": 1, - "text": "No signal", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "2jA6V3d4c1VkKuvHPMw1b", - "originalText": "No signal", - "lineHeight": 1.25, - "baseline": 17 - }, - { - "type": "rectangle", - "version": 399, - "versionNonce": 149437008, - "isDeleted": false, - "id": "fi4W3ItbbvRhqtjyzb4Dx", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 725.304211571106, - "y": 4158.218410431389, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 282.3999938964844, - "height": 145.76242065429682, - "seed": 1867227313, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 3 - }, - "boundElements": [ - { - "type": "text", - "id": "xDQjHsUQjsjhRddDXUFxw" - }, - { - "id": "3qj6dE7YV5VkyyM-orVEg", - "type": "arrow" - } - ], - "updated": 1714744053937, - "link": null, - "locked": false - }, - { - "type": "text", - "version": 372, - "versionNonce": 76239536, - "isDeleted": false, - "id": "xDQjHsUQjsjhRddDXUFxw", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 779.8342484973755, - "y": 4208.599620758538, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 173.3399200439453, - "height": 45, - "seed": 1263952529, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053937, - "link": null, - "locked": false, - "fontSize": 36, - "fontFamily": 1, - "text": "Completed", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "fi4W3ItbbvRhqtjyzb4Dx", - "originalText": "Completed", - "lineHeight": 1.25, - "baseline": 38 - }, - { - "type": "arrow", - "version": 74, - "versionNonce": 1519153232, - "isDeleted": false, - "id": "3qj6dE7YV5VkyyM-orVEg", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 860.1044282459106, - "y": 4074.5246085515064, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 3.199951171875, - "height": 68, - "seed": 220484799, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053937, - "link": null, - "locked": false, - "startBinding": { - "elementId": "3nOMpYEVbfxy5YlUz3RSc", - "focus": 0.05929357805215138, - "gap": 8.396903816183467 - }, - "endBinding": { - "elementId": "fi4W3ItbbvRhqtjyzb4Dx", - "focus": 0.0066953295810437225, - "gap": 15.693801879882812 - }, - "lastCommittedPoint": null, - "startArrowhead": null, - "endArrowhead": "arrow", - "points": [ - [ - 0, - 0 - ], - [ - 3.199951171875, - 68 - ] - ] - }, - { - "type": "rectangle", - "version": 640, - "versionNonce": 921533616, - "isDeleted": false, - "id": "KfH21YEUEsYkyEZLKCAZB", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 1132.5045289539185, - "y": 3711.393398224358, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 282.3999938964844, - "height": 64.74990844726557, - "seed": 2060753777, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 3 - }, - "boundElements": [ - { - "type": "text", - "id": "_zExFCe3_MOPeE1yrVxbX" - }, - { - "id": "zKHIolzbkZXnArU9Xcx6Q", - "type": "arrow" - }, - { - "id": "-QGeO6hJY6qLAm44eYDdi", - "type": "arrow" - } - ], - "updated": 1714744053937, - "link": null, - "locked": false - }, - { - "type": "text", - "version": 625, - "versionNonce": 372893264, - "isDeleted": false, - "id": "_zExFCe3_MOPeE1yrVxbX", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 1159.6565598987427, - "y": 3721.2683524479908, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 228.09593200683594, - "height": 45, - "seed": 1500644689, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053937, - "link": null, - "locked": false, - "fontSize": 36, - "fontFamily": 1, - "text": "Length array", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "KfH21YEUEsYkyEZLKCAZB", - "originalText": "Length array", - "lineHeight": 1.25, - "baseline": 38 - }, - { - "type": "arrow", - "version": 366, - "versionNonce": 1870292656, - "isDeleted": false, - "id": "zKHIolzbkZXnArU9Xcx6Q", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 960.6335237489178, - "y": 3746.168708669787, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 155.68352809318424, - "height": 0.9221920678483002, - "seed": 1167207999, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053937, - "link": null, - "locked": false, - "startBinding": { - "elementId": "jj_yHGzqEfb3EVrV7IAkE", - "gap": 12.339000384193383, - "focus": 0.07253845745618966 - }, - "endBinding": { - "elementId": "KfH21YEUEsYkyEZLKCAZB", - "gap": 16.187477111816392, - "focus": -0.016436510554634826 - }, - "lastCommittedPoint": null, - "startArrowhead": null, - "endArrowhead": "arrow", - "points": [ - [ - 0, - 0 - ], - [ - 155.68352809318424, - -0.9221920678483002 - ] - ] - }, - { - "type": "ellipse", - "version": 228, - "versionNonce": 684235856, - "isDeleted": false, - "id": "aIvbGx1MfjAb_6oY4CqMb", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 2, - "opacity": 100, - "angle": 0, - "x": 1145.704342796692, - "y": 3792.237163483147, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 115.2000732421875, - "height": 115.2000732421875, - "seed": 249772767, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [ - { - "type": "text", - "id": "NMcqlJsEyYXR0Zs5kRI9l" - }, - { - "id": "QHTBVNXQrucCR_A6H0uaZ", - "type": "arrow" - } - ], - "updated": 1714744053937, - "link": null, - "locked": false - }, - { - "type": "text", - "version": 179, - "versionNonce": 450498736, - "isDeleted": false, - "id": "NMcqlJsEyYXR0Zs5kRI9l", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 2, - "opacity": 100, - "angle": 0, - "x": 1184.2430250821785, - "y": 3839.607823612872, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 37.66395568847656, - "height": 20, - "seed": 2107016959, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053937, - "link": null, - "locked": false, - "fontSize": 16, - "fontFamily": 1, - "text": "flush", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "aIvbGx1MfjAb_6oY4CqMb", - "originalText": "flush", - "lineHeight": 1.25, - "baseline": 17 - }, - { - "type": "ellipse", - "version": 307, - "versionNonce": 605065808, - "isDeleted": false, - "id": "4uG_zS5TMGWF1M74StXiw", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 2, - "opacity": 100, - "angle": 0, - "x": 1272.9043550037231, - "y": 3792.237194000725, - "strokeColor": "#1971c2", - "backgroundColor": "#b2f2bb", - "width": 115.2000732421875, - "height": 115.2000732421875, - "seed": 249869343, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [ - { - "type": "text", - "id": "8r-DwMJpdfHD8ndMm-YNi" - }, - { - "id": "O4MRTCghp9QBztgDBgQdC", - "type": "arrow" - } - ], - "updated": 1714744053937, - "link": null, - "locked": false - }, - { - "type": "text", - "version": 265, - "versionNonce": 1354005168, - "isDeleted": false, - "id": "8r-DwMJpdfHD8ndMm-YNi", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 2, - "opacity": 100, - "angle": 0, - "x": 1306.5470335660652, - "y": 3829.60785413045, - "strokeColor": "#1971c2", - "backgroundColor": "transparent", - "width": 47.455963134765625, - "height": 40, - "seed": 492402399, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053937, - "link": null, - "locked": false, - "fontSize": 16, - "fontFamily": 1, - "text": "Awake\n210", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "4uG_zS5TMGWF1M74StXiw", - "originalText": "Awake\n210", - "lineHeight": 1.25, - "baseline": 37 - }, - { - "type": "diamond", - "version": 524, - "versionNonce": 518637648, - "isDeleted": false, - "id": "RJxANj4RhJ_aciZMjF5IY", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 2, - "opacity": 100, - "angle": 0, - "x": 1524.7046784900513, - "y": 3655.8872184147876, - "strokeColor": "#1971c2", - "backgroundColor": "#ffc9c9", - "width": 184.79998779296875, - "height": 184.79998779296875, - "seed": 1837615697, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 2 - }, - "boundElements": [ - { - "type": "text", - "id": "SnK8aSJAtTHmCgIHKqEq4" - }, - { - "id": "-QGeO6hJY6qLAm44eYDdi", - "type": "arrow" - }, - { - "id": "QHTBVNXQrucCR_A6H0uaZ", - "type": "arrow" - }, - { - "id": "NGBHlZ4_l_GHyKePYfaeX", - "type": "arrow" - }, - { - "id": "ObbXkkUi4RX8Luqzn8JMg", - "type": "arrow" - }, - { - "id": "SPFSlS5fEkc_qQBkM9eLq", - "type": "arrow" - } - ], - "updated": 1714744053937, - "link": null, - "locked": false - }, - { - "type": "text", - "version": 484, - "versionNonce": 1941021872, - "isDeleted": false, - "id": "SnK8aSJAtTHmCgIHKqEq4", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 1580.174702598938, - "y": 3710.58721536303, - "strokeColor": "#1971c2", - "backgroundColor": "transparent", - "width": 73.45994567871094, - "height": 75, - "seed": 798775345, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053937, - "link": null, - "locked": false, - "fontSize": 20, - "fontFamily": 1, - "text": "Length \narray\n(212)", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "RJxANj4RhJ_aciZMjF5IY", - "originalText": "Length array\n(212)", - "lineHeight": 1.25, - "baseline": 71 - }, - { - "type": "arrow", - "version": 86, - "versionNonce": 355221072, - "isDeleted": false, - "id": "-QGeO6hJY6qLAm44eYDdi", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 1425.7045259021606, - "y": 3746.9389775637524, - "strokeColor": "#1e1e1e", - "backgroundColor": "#b2f2bb", - "width": 90.5076695043881, - "height": 1.519763803449223, - "seed": 242224927, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [ - { - "type": "text", - "id": "PaRBQL0YM0cBiapoHkwYC" - } - ], - "updated": 1714744053937, - "link": null, - "locked": false, - "startBinding": { - "elementId": "KfH21YEUEsYkyEZLKCAZB", - "focus": 0.020934024143426978, - "gap": 10.800003051757812 - }, - "endBinding": { - "elementId": "RJxANj4RhJ_aciZMjF5IY", - "focus": -0.020191233413333516, - "gap": 8.494215157423724 - }, - "lastCommittedPoint": null, - "startArrowhead": null, - "endArrowhead": "arrow", - "points": [ - [ - 0, - 0 - ], - [ - 90.5076695043881, - 1.519763803449223 - ] - ] - }, - { - "type": "text", - "version": 27, - "versionNonce": 1366920880, - "isDeleted": false, - "id": "PaRBQL0YM0cBiapoHkwYC", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 1439.2805223010864, - "y": 3736.018428741936, - "strokeColor": "#1e1e1e", - "backgroundColor": "#b2f2bb", - "width": 44.04795837402344, - "height": 20, - "seed": 227682673, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053937, - "link": null, - "locked": false, - "fontSize": 16, - "fontFamily": 1, - "text": "150ms", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "-QGeO6hJY6qLAm44eYDdi", - "originalText": "150ms", - "lineHeight": 1.25, - "baseline": 17 - }, - { - "type": "ellipse", - "version": 303, - "versionNonce": 1202713680, - "isDeleted": false, - "id": "qD194lAbU6OCv9YNsEdgc", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 2, - "opacity": 100, - "angle": 0, - "x": 1791.7044648670044, - "y": 3688.6621207585376, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 115.2000732421875, - "height": 115.2000732421875, - "seed": 685827615, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [ - { - "type": "text", - "id": "67h2ln-uEeQlwJso1_aJE" - }, - { - "id": "NGBHlZ4_l_GHyKePYfaeX", - "type": "arrow" - }, - { - "id": "bHaGLZ3mcvx3uoIcm7J3S", - "type": "arrow" - }, - { - "id": "SPFSlS5fEkc_qQBkM9eLq", - "type": "arrow" - } - ], - "updated": 1714744053937, - "link": null, - "locked": false - }, - { - "type": "text", - "version": 278, - "versionNonce": 1119107248, - "isDeleted": false, - "id": "67h2ln-uEeQlwJso1_aJE", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 2, - "opacity": 100, - "angle": 0, - "x": 1826.3791411100106, - "y": 3726.0327808882626, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 45.3919677734375, - "height": 40, - "seed": 960285247, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053937, - "link": null, - "locked": false, - "fontSize": 16, - "fontFamily": 1, - "text": "get \nlength", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "qD194lAbU6OCv9YNsEdgc", - "originalText": "get length", - "lineHeight": 1.25, - "baseline": 37 - }, - { - "type": "arrow", - "version": 592, - "versionNonce": 474802768, - "isDeleted": false, - "id": "QHTBVNXQrucCR_A6H0uaZ", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 1615.2045259021606, - "y": 3655.212230621819, - "strokeColor": "#1e1e1e", - "backgroundColor": "#b2f2bb", - "width": 1025.9715140206472, - "height": 72.95533970424094, - "seed": 1445721521, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [ - { - "type": "text", - "id": "Q3sy61C7uU4rY6u7Sca8j" - } - ], - "updated": 1714744053937, - "link": null, - "locked": false, - "startBinding": { - "elementId": "RJxANj4RhJ_aciZMjF5IY", - "focus": 0.02841037195942465, - "gap": 1.820894909975678 - }, - "endBinding": { - "elementId": "ViWZZy9Q7c0UYyERaQ5M0", - "focus": 0.45298152656145046, - "gap": 9.350919451032496 - }, - "lastCommittedPoint": null, - "startArrowhead": null, - "endArrowhead": "arrow", - "points": [ - [ - 0, - 0 - ], - [ - -3.5, - -71.98748779296875 - ], - [ - -1021.8714773995533, - -61.47494070870562 - ], - [ - -1025.9715140206472, - 0.9678519112721915 - ] - ] - }, - { - "type": "text", - "version": 34, - "versionNonce": 1258922672, - "isDeleted": false, - "id": "Q3sy61C7uU4rY6u7Sca8j", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 1356.144528343567, - "y": 3958.9247245183033, - "strokeColor": "#1e1e1e", - "backgroundColor": "#b2f2bb", - "width": 90.3199462890625, - "height": 20, - "seed": 1409966257, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053937, - "link": null, - "locked": false, - "fontSize": 16, - "fontFamily": 1, - "text": "no response", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "QHTBVNXQrucCR_A6H0uaZ", - "originalText": "no response", - "lineHeight": 1.25, - "baseline": 17 - }, - { - "type": "arrow", - "version": 78, - "versionNonce": 2111512656, - "isDeleted": false, - "id": "NGBHlZ4_l_GHyKePYfaeX", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 1723.4362670438531, - "y": 3750.8672188472137, - "strokeColor": "#1e1e1e", - "backgroundColor": "#b2f2bb", - "width": 57.44773159596252, - "height": 1.8192351632887949, - "seed": 1295562431, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053937, - "link": null, - "locked": false, - "startBinding": { - "elementId": "RJxANj4RhJ_aciZMjF5IY", - "focus": 0.061761125756669914, - "gap": 14.168483810371228 - }, - "endBinding": { - "elementId": "qD194lAbU6OCv9YNsEdgc", - "focus": -0.010743030743175907, - "gap": 10.877156941504424 - }, - "lastCommittedPoint": null, - "startArrowhead": null, - "endArrowhead": "arrow", - "points": [ - [ - 0, - 0 - ], - [ - 57.44773159596252, - -1.8192351632887949 - ] - ] - }, - { - "type": "diamond", - "version": 107, - "versionNonce": 958516400, - "isDeleted": false, - "id": "dwSyGncFb0E5Cqk0pkmyg", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 2, - "opacity": 100, - "angle": 0, - "x": 1985.7042817615356, - "y": 3645.2997855534595, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 205.38748168945312, - "height": 205.38748168945312, - "seed": 396803697, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 2 - }, - "boundElements": [ - { - "type": "text", - "id": "OxXFhnNB5cEBfpuzdFUWe" - }, - { - "id": "bHaGLZ3mcvx3uoIcm7J3S", - "type": "arrow" - }, - { - "id": "ePBq6IfgOVxC4L3VUSArw", - "type": "arrow" - }, - { - "id": "siYv23QE5fZuK8S_aLGSW", - "type": "arrow" - }, - { - "id": "VwKQnf_zVtP_2qxBcKzUw", - "type": "arrow" - } - ], - "updated": 1714744053937, - "link": null, - "locked": false - }, - { - "type": "text", - "version": 54, - "versionNonce": 1009948240, - "isDeleted": false, - "id": "OxXFhnNB5cEBfpuzdFUWe", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 2, - "opacity": 100, - "angle": 0, - "x": 2042.9751710437622, - "y": 3725.646655975823, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 91.15196228027344, - "height": 45, - "seed": 727800511, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053937, - "link": null, - "locked": false, - "fontSize": 36, - "fontFamily": 1, - "text": "check", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "dwSyGncFb0E5Cqk0pkmyg", - "originalText": "check", - "lineHeight": 1.25, - "baseline": 38 - }, - { - "type": "ellipse", - "version": 429, - "versionNonce": 1185199792, - "isDeleted": false, - "id": "0XOIdMglnzJdbVbiI4UlR", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 2, - "opacity": 100, - "angle": 0, - "x": 1796.082075815355, - "y": 3451.263554406541, - "strokeColor": "#1971c2", - "backgroundColor": "#b2f2bb", - "width": 115.2000732421875, - "height": 115.2000732421875, - "seed": 1088946879, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [ - { - "type": "text", - "id": "fNg-UCz9figTJYVT-DfOl" - }, - { - "id": "OBwdSuILKZp4xw1epS01V", - "type": "arrow" - }, - { - "id": "fNlhld2BS4snfpZ0Sn2La", - "type": "arrow" - } - ], - "updated": 1714744053938, - "link": null, - "locked": false - }, - { - "type": "text", - "version": 399, - "versionNonce": 1814776912, - "isDeleted": false, - "id": "fNg-UCz9figTJYVT-DfOl", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 2, - "opacity": 100, - "angle": 0, - "x": 1832.3967514480096, - "y": 3488.634214536266, - "strokeColor": "#1971c2", - "backgroundColor": "transparent", - "width": 42.111968994140625, - "height": 40, - "seed": 1199002335, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053938, - "link": null, - "locked": false, - "fontSize": 16, - "fontFamily": 1, - "text": "reset\n222", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "0XOIdMglnzJdbVbiI4UlR", - "originalText": "reset\n222", - "lineHeight": 1.25, - "baseline": 37 - }, - { - "type": "arrow", - "version": 65, - "versionNonce": 943349936, - "isDeleted": false, - "id": "bHaGLZ3mcvx3uoIcm7J3S", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 1921.637767004591, - "y": 3747.4149894108814, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 48.888888888888914, - "height": 1.7777845594619066, - "seed": 1709095825, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053938, - "link": null, - "locked": false, - "startBinding": { - "elementId": "qD194lAbU6OCv9YNsEdgc", - "focus": -0.02563371081574025, - "gap": 14.742415106586463 - }, - "endBinding": { - "elementId": "dwSyGncFb0E5Cqk0pkmyg", - "focus": -0.05341606406134963, - "gap": 11.580198264208377 - }, - "lastCommittedPoint": null, - "startArrowhead": null, - "endArrowhead": "arrow", - "points": [ - [ - 0, - 0 - ], - [ - 48.888888888888914, - 1.7777845594619066 - ] - ] - }, - { - "type": "ellipse", - "version": 382, - "versionNonce": 1201488464, - "isDeleted": false, - "id": "RLGE222iSRNZwVPwD-ZOS", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 2, - "opacity": 100, - "angle": 0, - "x": 1934.4820663209973, - "y": 3453.551135108581, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 115.2000732421875, - "height": 115.2000732421875, - "seed": 406583551, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [ - { - "type": "text", - "id": "RPfqH37NtfweHtDKqAEwS" - }, - { - "id": "ePBq6IfgOVxC4L3VUSArw", - "type": "arrow" - } - ], - "updated": 1714744053938, - "link": null, - "locked": false - }, - { - "type": "text", - "version": 333, - "versionNonce": 2106247856, - "isDeleted": false, - "id": "RPfqH37NtfweHtDKqAEwS", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 2, - "opacity": 100, - "angle": 0, - "x": 1973.020748606484, - "y": 3500.921795238306, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 37.66395568847656, - "height": 20, - "seed": 1970438431, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053938, - "link": null, - "locked": false, - "fontSize": 16, - "fontFamily": 1, - "text": "flush", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "RLGE222iSRNZwVPwD-ZOS", - "originalText": "flush", - "lineHeight": 1.25, - "baseline": 17 - }, - { - "type": "arrow", - "version": 98, - "versionNonce": 224426064, - "isDeleted": false, - "id": "ePBq6IfgOVxC4L3VUSArw", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 2088.7489052424385, - "y": 3638.970572093173, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 23.111165364583485, - "height": 126.22224595811622, - "seed": 757944017, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053938, - "link": null, - "locked": false, - "startBinding": { - "elementId": "dwSyGncFb0E5Cqk0pkmyg", - "focus": -0.026487875877383715, - "gap": 4.723541248786674 - }, - "endBinding": { - "elementId": "RLGE222iSRNZwVPwD-ZOS", - "focus": 0.09458042699230661, - "gap": 19.55116601669355 - }, - "lastCommittedPoint": null, - "startArrowhead": null, - "endArrowhead": "arrow", - "points": [ - [ - 0, - 0 - ], - [ - 3.555501302083485, - -126.22224595811622 - ], - [ - -19.5556640625, - -125.33335367838527 - ] - ] - }, - { - "type": "arrow", - "version": 166, - "versionNonce": 1898188880, - "isDeleted": false, - "id": "OBwdSuILKZp4xw1epS01V", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 1781.1932954334106, - "y": 3508.303864736403, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 275.76749030962856, - "height": 8.203961378917938, - "seed": 1538388625, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714746086744, - "link": null, - "locked": false, - "startBinding": { - "elementId": "0XOIdMglnzJdbVbiI4UlR", - "focus": -0.027709669026886503, - "gap": 14.890941328034792 - }, - "endBinding": null, - "lastCommittedPoint": null, - "startArrowhead": null, - "endArrowhead": "arrow", - "points": [ - [ - 0, - 0 - ], - [ - -275.76749030962856, - -8.203961378917938 - ] - ] - }, - { - "type": "arrow", - "version": 216, - "versionNonce": 1367873616, - "isDeleted": false, - "id": "B0Fc9vslccT_uvolbahsS", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 1466.8035830201425, - "y": 3496.9651357132116, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 937.1658024521832, - "height": 150.00538212648962, - "seed": 2098559761, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714746088585, - "link": null, - "locked": false, - "startBinding": null, - "endBinding": { - "elementId": "ViWZZy9Q7c0UYyERaQ5M0", - "focus": 0.08451054329154957, - "gap": 18.56048414442239 - }, - "lastCommittedPoint": null, - "startArrowhead": null, - "endArrowhead": "arrow", - "points": [ - [ - 0, - 0 - ], - [ - -937.1658024521832, - 7.78315990426745 - ], - [ - -937.1658024521832, - 150.00538212648962 - ] - ] - }, - { - "type": "arrow", - "version": 299, - "versionNonce": 1010103376, - "isDeleted": false, - "id": "AIfWh0zeQmsdxyozN0htX", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 1484.7773382782707, - "y": 3483.2459822560527, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 2.536415323688516, - "height": 232.25600776487545, - "seed": 909467103, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714746090050, - "link": null, - "locked": false, - "startBinding": null, - "endBinding": { - "elementId": "nv-KG2JPAMopF0URTfGuD", - "focus": 0.0006375270414996052, - "gap": 12.155510796441149 - }, - "lastCommittedPoint": null, - "startArrowhead": null, - "endArrowhead": "arrow", - "points": [ - [ - 0, - 0 - ], - [ - -2.536415323688516, - -232.25600776487545 - ] - ] - }, - { - "type": "rectangle", - "version": 251, - "versionNonce": 2080479824, - "isDeleted": false, - "id": "nv-KG2JPAMopF0URTfGuD", - "fillStyle": "cross-hatch", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 1438.5711844308066, - "y": 3155.7511371430874, - "strokeColor": "#e03131", - "backgroundColor": "#ffc9c9", - "width": 86.2221950954861, - "height": 83.08332655164895, - "seed": 1872529695, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [ - { - "type": "text", - "id": "fWh8fw65I9uHbHGXLcsa8" - }, - { - "id": "AIfWh0zeQmsdxyozN0htX", - "type": "arrow" - } - ], - "updated": 1714744053938, - "link": null, - "locked": false - }, - { - "type": "text", - "version": 215, - "versionNonce": 1916269232, - "isDeleted": false, - "id": "fWh8fw65I9uHbHGXLcsa8", - "fillStyle": "cross-hatch", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 1463.1602940635107, - "y": 3174.792800418912, - "strokeColor": "#1e1e1e", - "backgroundColor": "#ffc9c9", - "width": 37.043975830078125, - "height": 45, - "seed": 1210514975, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053938, - "link": null, - "locked": false, - "fontSize": 36, - "fontFamily": 1, - "text": "-5", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "nv-KG2JPAMopF0URTfGuD", - "originalText": "-5", - "lineHeight": 1.25, - "baseline": 38 - }, - { - "type": "rectangle", - "version": 777, - "versionNonce": 1668927568, - "isDeleted": false, - "id": "yNZIuCW9fYJaiSxldyEzO", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 2353.9857146248014, - "y": 3717.151095920136, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 282.3999938964844, - "height": 64.74990844726557, - "seed": 2027580849, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 3 - }, - "boundElements": [ - { - "type": "text", - "id": "N1vwXFEt4e3ZP3rjJ-f2E" - }, - { - "id": "siYv23QE5fZuK8S_aLGSW", - "type": "arrow" - }, - { - "id": "h0EYmx16SKh0tRtXR5XhJ", - "type": "arrow" - }, - { - "id": "R_t8UO3YLfP0qZT237eff", - "type": "arrow" - }, - { - "id": "ObbXkkUi4RX8Luqzn8JMg", - "type": "arrow" - } - ], - "updated": 1714744053938, - "link": null, - "locked": false - }, - { - "type": "text", - "version": 764, - "versionNonce": 101063856, - "isDeleted": false, - "id": "N1vwXFEt4e3ZP3rjJ-f2E", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 2407.5437361702116, - "y": 3727.0260501437688, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 175.28395080566406, - "height": 45, - "seed": 864259985, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053938, - "link": null, - "locked": false, - "fontSize": 36, - "fontFamily": 1, - "text": "Get data", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "yNZIuCW9fYJaiSxldyEzO", - "originalText": "Get data", - "lineHeight": 1.25, - "baseline": 38 - }, - { - "type": "ellipse", - "version": 258, - "versionNonce": 1518028368, - "isDeleted": false, - "id": "VQlEEltnpBfObZWSn_WBA", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 2, - "opacity": 100, - "angle": 0, - "x": 2378.84284658281, - "y": 3806.49748787047, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 115.2000732421875, - "height": 115.2000732421875, - "seed": 1345305663, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [ - { - "type": "text", - "id": "uu50DfbD7jrKocfnBIPZy" - } - ], - "updated": 1714744053938, - "link": null, - "locked": false - }, - { - "type": "text", - "version": 210, - "versionNonce": 310314672, - "isDeleted": false, - "id": "uu50DfbD7jrKocfnBIPZy", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 2, - "opacity": 100, - "angle": 0, - "x": 2417.3815288682968, - "y": 3853.868148000195, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 37.66395568847656, - "height": 20, - "seed": 1485560927, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053938, - "link": null, - "locked": false, - "fontSize": 16, - "fontFamily": 1, - "text": "flush", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "VQlEEltnpBfObZWSn_WBA", - "originalText": "flush", - "lineHeight": 1.25, - "baseline": 17 - }, - { - "type": "ellipse", - "version": 333, - "versionNonce": 501087312, - "isDeleted": false, - "id": "Mdil-sv7Ec0Ncq-XpaH48", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 2, - "opacity": 100, - "angle": 0, - "x": 2506.0428587898414, - "y": 3806.4975183880483, - "strokeColor": "#1971c2", - "backgroundColor": "#b2f2bb", - "width": 115.2000732421875, - "height": 115.2000732421875, - "seed": 481228927, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [ - { - "type": "text", - "id": "VDtyhPE1d6rpvutGa5x_e" - }, - { - "id": "U2EvPXeHbkdhv1IajJrxn", - "type": "arrow" - } - ], - "updated": 1714744053938, - "link": null, - "locked": false - }, - { - "type": "text", - "version": 305, - "versionNonce": 877310128, - "isDeleted": false, - "id": "VDtyhPE1d6rpvutGa5x_e", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 2, - "opacity": 100, - "angle": 0, - "x": 2539.973531736949, - "y": 3843.8681785177732, - "strokeColor": "#1971c2", - "backgroundColor": "transparent", - "width": 46.879974365234375, - "height": 40, - "seed": 39424159, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053938, - "link": null, - "locked": false, - "fontSize": 16, - "fontFamily": 1, - "text": "Ready\n200", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "Mdil-sv7Ec0Ncq-XpaH48", - "originalText": "Ready\n200", - "lineHeight": 1.25, - "baseline": 37 - }, - { - "type": "arrow", - "version": 52, - "versionNonce": 259650128, - "isDeleted": false, - "id": "siYv23QE5fZuK8S_aLGSW", - "fillStyle": "cross-hatch", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 2207.7572098989367, - "y": 3745.276085021001, - "strokeColor": "#1e1e1e", - "backgroundColor": "#ffc9c9", - "width": 134.857177734375, - "height": 0, - "seed": 1103405215, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053938, - "link": null, - "locked": false, - "startBinding": { - "elementId": "dwSyGncFb0E5Cqk0pkmyg", - "focus": -0.026461606664945167, - "gap": 13.70577142012965 - }, - "endBinding": { - "elementId": "yNZIuCW9fYJaiSxldyEzO", - "focus": 0.13127323959782808, - "gap": 11.371326991489696 - }, - "lastCommittedPoint": null, - "startArrowhead": null, - "endArrowhead": "arrow", - "points": [ - [ - 0, - 0 - ], - [ - 134.857177734375, - 0 - ] - ] - }, - { - "type": "ellipse", - "version": 308, - "versionNonce": 856758960, - "isDeleted": false, - "id": "NYb28wO65_lvUaT1Cockk", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 2, - "opacity": 100, - "angle": 0, - "x": 2719.300065297932, - "y": 3698.479576231939, - "strokeColor": "#1971c2", - "backgroundColor": "#ffc9c9", - "width": 115.2000732421875, - "height": 115.2000732421875, - "seed": 1502846335, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [ - { - "type": "text", - "id": "LjxP0wGHK-eX-3WNTP8ZD" - }, - { - "id": "h0EYmx16SKh0tRtXR5XhJ", - "type": "arrow" - }, - { - "id": "IHs7M-PwfAD5r15fGjb9t", - "type": "arrow" - }, - { - "id": "bLoyDI7x4qG_GKX6CeMT3", - "type": "arrow" - } - ], - "updated": 1714744053938, - "link": null, - "locked": false - }, - { - "type": "text", - "version": 272, - "versionNonce": 371664976, - "isDeleted": false, - "id": "LjxP0wGHK-eX-3WNTP8ZD", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 2, - "opacity": 100, - "angle": 0, - "x": 2742.118738733321, - "y": 3720.850236361664, - "strokeColor": "#1971c2", - "backgroundColor": "transparent", - "width": 69.10397338867188, - "height": 70, - "seed": 1700894111, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053938, - "link": null, - "locked": false, - "fontSize": 28, - "fontFamily": 1, - "text": "Get \ndata", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "NYb28wO65_lvUaT1Cockk", - "originalText": "Get data", - "lineHeight": 1.25, - "baseline": 64 - }, - { - "type": "ellipse", - "version": 533, - "versionNonce": 561661104, - "isDeleted": false, - "id": "iBZRtI2xGc5MgU0R2emqB", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 2, - "opacity": 100, - "angle": 0, - "x": 3218.72842746311, - "y": 3687.5153951493503, - "strokeColor": "#1971c2", - "backgroundColor": "#ffc9c9", - "width": 140.3428955078125, - "height": 144.8393031529018, - "seed": 66654737, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [ - { - "type": "text", - "id": "0ONVDP4A5ZJaTQOKliW_p" - }, - { - "id": "CqJZf-4HS85UA4KXz_pP_", - "type": "arrow" - }, - { - "id": "UCWmZfJ31JSBJj1P0S_KC", - "type": "arrow" - }, - { - "id": "ObbXkkUi4RX8Luqzn8JMg", - "type": "arrow" - } - ], - "updated": 1714744053938, - "link": null, - "locked": false - }, - { - "type": "text", - "version": 549, - "versionNonce": 2109578832, - "isDeleted": false, - "id": "0ONVDP4A5ZJaTQOKliW_p", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 2, - "opacity": 100, - "angle": 0, - "x": 3246.0212123046886, - "y": 3734.7266200049257, - "strokeColor": "#1971c2", - "backgroundColor": "transparent", - "width": 85.51991271972656, - "height": 50, - "seed": 1074702321, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053939, - "link": null, - "locked": false, - "fontSize": 20, - "fontFamily": 1, - "text": "Get \nchecksum", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "iBZRtI2xGc5MgU0R2emqB", - "originalText": "Get checksum", - "lineHeight": 1.25, - "baseline": 46 - }, - { - "type": "arrow", - "version": 114, - "versionNonce": 2100178608, - "isDeleted": false, - "id": "h0EYmx16SKh0tRtXR5XhJ", - "fillStyle": "cross-hatch", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 2644.328603593133, - "y": 3751.881046146817, - "strokeColor": "#1e1e1e", - "backgroundColor": "#ffc9c9", - "width": 69.710065902123, - "height": 2.3767629593407946, - "seed": 1105780465, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053939, - "link": null, - "locked": false, - "startBinding": { - "elementId": "yNZIuCW9fYJaiSxldyEzO", - "focus": -0.07508062880961323, - "gap": 7.942895071847033 - }, - "endBinding": { - "elementId": "NYb28wO65_lvUaT1Cockk", - "focus": -0.005577575392632, - "gap": 5.287789349123756 - }, - "lastCommittedPoint": null, - "startArrowhead": null, - "endArrowhead": "arrow", - "points": [ - [ - 0, - 0 - ], - [ - 69.710065902123, - 2.3767629593407946 - ] - ] - }, - { - "type": "diamond", - "version": 164, - "versionNonce": 1461015632, - "isDeleted": false, - "id": "xcVSmTB-gt0cN1YieTegp", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 2, - "opacity": 100, - "angle": 0, - "x": 2910.7777547684964, - "y": 3656.2608894469226, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 205.38748168945312, - "height": 205.38748168945312, - "seed": 2087491999, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 2 - }, - "boundElements": [ - { - "type": "text", - "id": "wFtq9-bbenLPBluVjdBTQ" - }, - { - "id": "IHs7M-PwfAD5r15fGjb9t", - "type": "arrow" - }, - { - "id": "CqJZf-4HS85UA4KXz_pP_", - "type": "arrow" - }, - { - "id": "ObbXkkUi4RX8Luqzn8JMg", - "type": "arrow" - }, - { - "id": "gyPcyFeW-J2407VPWQOUM", - "type": "arrow" - }, - { - "id": "1pwwcSYOnzOIeKOG9nO85", - "type": "arrow" - } - ], - "updated": 1714744053939, - "link": null, - "locked": false - }, - { - "type": "text", - "version": 114, - "versionNonce": 1322571952, - "isDeleted": false, - "id": "wFtq9-bbenLPBluVjdBTQ", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 2, - "opacity": 100, - "angle": 0, - "x": 2969.2006368485745, - "y": 3714.107759869286, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 88.84797668457031, - "height": 90, - "seed": 403049919, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053939, - "link": null, - "locked": false, - "fontSize": 36, - "fontFamily": 1, - "text": "data\nsize", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "xcVSmTB-gt0cN1YieTegp", - "originalText": "data size", - "lineHeight": 1.25, - "baseline": 83 - }, - { - "type": "diamond", - "version": 183, - "versionNonce": 1476807248, - "isDeleted": false, - "id": "MeyabU_KuxgmXdgvyrffK", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 2, - "opacity": 100, - "angle": 0, - "x": 3493.0634341769783, - "y": 3654.2609417627714, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 205.38748168945312, - "height": 205.38748168945312, - "seed": 1145797361, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 2 - }, - "boundElements": [ - { - "type": "text", - "id": "qXPQBk0vCTDesZ3ehy1sN" - }, - { - "id": "UCWmZfJ31JSBJj1P0S_KC", - "type": "arrow" - }, - { - "id": "FNpbosK2lphWsC9POj79B", - "type": "arrow" - }, - { - "id": "R_t8UO3YLfP0qZT237eff", - "type": "arrow" - }, - { - "id": "gyPcyFeW-J2407VPWQOUM", - "type": "arrow" - } - ], - "updated": 1714744053939, - "link": null, - "locked": false - }, - { - "type": "text", - "version": 146, - "versionNonce": 1242972848, - "isDeleted": false, - "id": "qXPQBk0vCTDesZ3ehy1sN", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 2, - "opacity": 100, - "angle": 0, - "x": 3550.334323459205, - "y": 3712.1078121851347, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 91.15196228027344, - "height": 90, - "seed": 534836433, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053939, - "link": null, - "locked": false, - "fontSize": 36, - "fontFamily": 1, - "text": "check\nsum", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "MeyabU_KuxgmXdgvyrffK", - "originalText": "checksum", - "lineHeight": 1.25, - "baseline": 83 - }, - { - "type": "ellipse", - "version": 394, - "versionNonce": 996704336, - "isDeleted": false, - "id": "I1nmKrm-fWZatTXwyA29D", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 2, - "opacity": 100, - "angle": 0, - "x": 3817.5856749519503, - "y": 3701.908356923905, - "strokeColor": "#1971c2", - "backgroundColor": "#b2f2bb", - "width": 115.2000732421875, - "height": 115.2000732421875, - "seed": 1475797983, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [ - { - "type": "text", - "id": "vr3UtOfRy6FMkQnzXawBx" - }, - { - "id": "FNpbosK2lphWsC9POj79B", - "type": "arrow" - }, - { - "id": "G5nVT5VA8UUPppUVgsIHm", - "type": "arrow" - }, - { - "id": "-3xsQ8CUpzKqR3rQuEvHY", - "type": "arrow" - } - ], - "updated": 1714744053939, - "link": null, - "locked": false - }, - { - "type": "text", - "version": 378, - "versionNonce": 1838836912, - "isDeleted": false, - "id": "vr3UtOfRy6FMkQnzXawBx", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 2, - "opacity": 100, - "angle": 0, - "x": 3845.9003582139994, - "y": 3739.27901705363, - "strokeColor": "#1971c2", - "backgroundColor": "transparent", - "width": 58.11195373535156, - "height": 40, - "seed": 407703551, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053939, - "link": null, - "locked": false, - "fontSize": 16, - "fontFamily": 1, - "text": "Finished\n180", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "I1nmKrm-fWZatTXwyA29D", - "originalText": "Finished\n180", - "lineHeight": 1.25, - "baseline": 37 - }, - { - "type": "arrow", - "version": 86, - "versionNonce": 554956368, - "isDeleted": false, - "id": "IHs7M-PwfAD5r15fGjb9t", - "fillStyle": "cross-hatch", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 2853.4715828063026, - "y": 3758.990466647677, - "strokeColor": "#1e1e1e", - "backgroundColor": "#ffc9c9", - "width": 41.14283970424094, - "height": 1.14288330078125, - "seed": 1733680337, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053939, - "link": null, - "locked": false, - "startBinding": { - "elementId": "NYb28wO65_lvUaT1Cockk", - "focus": 0.08742956876768007, - "gap": 19.0267521350872 - }, - "endBinding": { - "elementId": "xcVSmTB-gt0cN1YieTegp", - "focus": 0.04293065224006023, - "gap": 12.212002247896805 - }, - "lastCommittedPoint": null, - "startArrowhead": null, - "endArrowhead": "arrow", - "points": [ - [ - 0, - 0 - ], - [ - 41.14283970424094, - -1.14288330078125 - ] - ] - }, - { - "type": "arrow", - "version": 53, - "versionNonce": 587814576, - "isDeleted": false, - "id": "CqJZf-4HS85UA4KXz_pP_", - "fillStyle": "cross-hatch", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 3138.043028816347, - "y": 3757.8475833468956, - "strokeColor": "#1e1e1e", - "backgroundColor": "#ffc9c9", - "width": 59.428536551339675, - "height": 0, - "seed": 1485765023, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053939, - "link": null, - "locked": false, - "startBinding": { - "elementId": "xcVSmTB-gt0cN1YieTegp", - "focus": -0.010780081976247025, - "gap": 16.25273573574124 - }, - "endBinding": { - "elementId": "iBZRtI2xGc5MgU0R2emqB", - "focus": 0.02882454324848109, - "gap": 21.2795556480239 - }, - "lastCommittedPoint": null, - "startArrowhead": null, - "endArrowhead": "arrow", - "points": [ - [ - 0, - 0 - ], - [ - 59.428536551339675, - 0 - ] - ] - }, - { - "type": "arrow", - "version": 63, - "versionNonce": 1843440720, - "isDeleted": false, - "id": "UCWmZfJ31JSBJj1P0S_KC", - "fillStyle": "cross-hatch", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 3366.6144573877755, - "y": 3756.704743642654, - "strokeColor": "#1e1e1e", - "backgroundColor": "#ffc9c9", - "width": 110.85710797991123, - "height": 0, - "seed": 1479588447, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053939, - "link": null, - "locked": false, - "startBinding": { - "elementId": "iBZRtI2xGc5MgU0R2emqB", - "focus": -0.044605338645362265, - "gap": 7.606519777442898 - }, - "endBinding": { - "elementId": "MeyabU_KuxgmXdgvyrffK", - "focus": 0.002433828612998517, - "gap": 11.201849703344834 - }, - "lastCommittedPoint": null, - "startArrowhead": null, - "endArrowhead": "arrow", - "points": [ - [ - 0, - 0 - ], - [ - 110.85710797991123, - 0 - ] - ] - }, - { - "type": "arrow", - "version": 53, - "versionNonce": 1594556592, - "isDeleted": false, - "id": "FNpbosK2lphWsC9POj79B", - "fillStyle": "cross-hatch", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 3711.757279653401, - "y": 3754.419020637632, - "strokeColor": "#1e1e1e", - "backgroundColor": "#ffc9c9", - "width": 89.14289202008922, - "height": 1.14288330078125, - "seed": 30695519, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053939, - "link": null, - "locked": false, - "startBinding": { - "elementId": "MeyabU_KuxgmXdgvyrffK", - "focus": -0.03917352919837444, - "gap": 11.202003840390304 - }, - "endBinding": { - "elementId": "I1nmKrm-fWZatTXwyA29D", - "focus": 0.05197641523578342, - "gap": 16.790259912682096 - }, - "lastCommittedPoint": null, - "startArrowhead": null, - "endArrowhead": "arrow", - "points": [ - [ - 0, - 0 - ], - [ - 89.14289202008922, - 1.14288330078125 - ] - ] - }, - { - "type": "arrow", - "version": 306, - "versionNonce": 732340816, - "isDeleted": false, - "id": "R_t8UO3YLfP0qZT237eff", - "fillStyle": "cross-hatch", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 3598.614492265008, - "y": 3883.561912657721, - "strokeColor": "#1e1e1e", - "backgroundColor": "#ffc9c9", - "width": 1259.4285365513392, - "height": 180.26785714285688, - "seed": 2105252219, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053939, - "link": null, - "locked": false, - "startBinding": { - "focus": 0.02373368924095548, - "gap": 18.929818777778806, - "elementId": "MeyabU_KuxgmXdgvyrffK" - }, - "endBinding": { - "focus": 1.080670393703399, - "gap": 11.371326991489696, - "elementId": "yNZIuCW9fYJaiSxldyEzO" - }, - "lastCommittedPoint": null, - "startArrowhead": null, - "endArrowhead": "arrow", - "points": [ - [ - 0, - 0 - ], - [ - 3.428431919643117, - 81.98216029575906 - ], - [ - -1254.8571777343745, - 84.26783970424094 - ], - [ - -1256.000104631696, - -96.00001743861594 - ] - ] - }, - { - "type": "arrow", - "version": 490, - "versionNonce": 1095199408, - "isDeleted": false, - "id": "G5nVT5VA8UUPppUVgsIHm", - "fillStyle": "cross-hatch", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 3878.490602523564, - "y": 3683.0739046127064, - "strokeColor": "#1e1e1e", - "backgroundColor": "#ffc9c9", - "width": 3389.866658528645, - "height": 374.6416727701826, - "seed": 1176066097, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053939, - "link": null, - "locked": false, - "startBinding": { - "elementId": "I1nmKrm-fWZatTXwyA29D", - "focus": 0.06304296269521902, - "gap": 18.905867742788914 - }, - "endBinding": { - "elementId": "ViWZZy9Q7c0UYyERaQ5M0", - "focus": -0.18141147608207922, - "gap": 12.857091267901524 - }, - "lastCommittedPoint": null, - "startArrowhead": null, - "endArrowhead": "arrow", - "points": [ - [ - 0, - 0 - ], - [ - -1.5999348958330302, - -374.6416727701826 - ], - [ - -3389.866658528645, - -360.7082824707031 - ], - [ - -3387.199951171874, - -30.399993896484375 - ] - ] - }, - { - "type": "rectangle", - "version": 504, - "versionNonce": 1765660752, - "isDeleted": false, - "id": "LUIcjOG-pExPEpZZJQzlm", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": -1795.3821297297375, - "y": 3326.836719573486, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 948.685961042132, - "height": 145.76242065429682, - "seed": 1996228065, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 3 - }, - "boundElements": [ - { - "type": "text", - "id": "m3Xa6yXTyfn-0cNoEqvXL" - }, - { - "id": "1PypevWTBXChXql2NBnfV", - "type": "arrow" - }, - { - "id": "iXpExTgBKgqPR5laoFls7", - "type": "arrow" - } - ], - "updated": 1714744053939, - "link": null, - "locked": false - }, - { - "type": "text", - "version": 506, - "versionNonce": 879137968, - "isDeleted": false, - "id": "m3Xa6yXTyfn-0cNoEqvXL", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": -1408.5731152731246, - "y": 3354.7179299006343, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 175.06793212890625, - "height": 90, - "seed": 874684865, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053939, - "link": null, - "locked": false, - "fontSize": 36, - "fontFamily": 1, - "text": "RUN_MPF\n2", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "LUIcjOG-pExPEpZZJQzlm", - "originalText": "RUN_MPF\n2", - "lineHeight": 1.25, - "baseline": 83 - }, - { - "type": "text", - "version": 114, - "versionNonce": 245087984, - "isDeleted": false, - "id": "zuvqv-bFqKG3ZoKU-hDV9", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": -2131.0392582000222, - "y": 3374.325037880546, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 147.65625, - "height": 43.199999999999996, - "seed": 1806435311, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1717506989674, - "link": null, - "locked": false, - "fontSize": 36, - "fontFamily": 3, - "text": "run_MPF", - "textAlign": "left", - "verticalAlign": "top", - "containerId": null, - "originalText": "run_MPF", - "lineHeight": 1.2, - "baseline": 34 - }, - { - "type": "arrow", - "version": 526, - "versionNonce": 235962032, - "isDeleted": false, - "id": "1PypevWTBXChXql2NBnfV", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": -1967.8963763524587, - "y": 3395.035870481208, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 145.71427844819596, - "height": 0.8547003201483676, - "seed": 474179585, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 2 - }, - "boundElements": [], - "updated": 1714744053939, - "link": null, - "locked": false, - "startBinding": { - "focus": 0.17249076682334344, - "gap": 11.486642020089903, - "elementId": "zuvqv-bFqKG3ZoKU-hDV9" - }, - "endBinding": { - "focus": 0.011734317410885505, - "gap": 26.799968174525247, - "elementId": "LUIcjOG-pExPEpZZJQzlm" - }, - "lastCommittedPoint": null, - "startArrowhead": null, - "endArrowhead": "arrow", - "points": [ - [ - 0, - 0 - ], - [ - 145.71427844819596, - 0.8547003201483676 - ] - ] - }, - { - "type": "ellipse", - "version": 453, - "versionNonce": 1172142256, - "isDeleted": false, - "id": "uYwEC6UHGHtBawFQ1yRXK", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 2, - "opacity": 100, - "angle": 0, - "x": -1854.1151692223898, - "y": 3517.3203846764904, - "strokeColor": "#1971c2", - "backgroundColor": "#b2f2bb", - "width": 151.19998168945312, - "height": 151.19998168945312, - "seed": 1261839745, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [ - { - "id": "v8Qr4f-p1eNaONyU3HxYm", - "type": "arrow" - }, - { - "type": "text", - "id": "cQbHPbTLQ-p6eVbLGwIJB" - }, - { - "id": "xIDgdoUwo4XtG0resbUs1", - "type": "arrow" - } - ], - "updated": 1714744077470, - "link": null, - "locked": false - }, - { - "type": "text", - "version": 442, - "versionNonce": 386589360, - "isDeleted": false, - "id": "cQbHPbTLQ-p6eVbLGwIJB", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 2, - "opacity": 100, - "angle": 0, - "x": -1814.981676128993, - "y": 3555.6554170295776, - "strokeColor": "#1971c2", - "backgroundColor": "transparent", - "width": 73.01846313476562, - "height": 74.61538461538461, - "seed": 657968481, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744077470, - "link": null, - "locked": false, - "fontSize": 29.846153846153843, - "fontFamily": 1, - "text": "Wake\n170", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "uYwEC6UHGHtBawFQ1yRXK", - "originalText": "Wake\n170", - "lineHeight": 1.25, - "baseline": 68 - }, - { - "type": "diamond", - "version": 479, - "versionNonce": 20110512, - "isDeleted": false, - "id": "nTdCg9YES9bcUbYEdQyta", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": -1600.5819711836525, - "y": 3482.1245126875583, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 220.13316345214852, - "height": 230, - "seed": 142178625, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 2 - }, - "boundElements": [ - { - "id": "v8Qr4f-p1eNaONyU3HxYm", - "type": "arrow" - }, - { - "id": "xX9zNOd036gOt9NBE8Rvi", - "type": "arrow" - }, - { - "id": "JgAs79Mhh9PankgSUE3N-", - "type": "arrow" - }, - { - "type": "text", - "id": "Zh3fcBVd8hpkdWFRpjVw5" - }, - { - "id": "9kzbQWa7MJj_5DR5ThIqF", - "type": "arrow" - } - ], - "updated": 1714744073401, - "link": null, - "locked": false - }, - { - "type": "text", - "version": 402, - "versionNonce": 169068208, - "isDeleted": false, - "id": "Zh3fcBVd8hpkdWFRpjVw5", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": -1532.0726595076271, - "y": 3562.1245126875583, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 83.04795837402344, - "height": 70, - "seed": 1348118817, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744073401, - "link": null, - "locked": false, - "fontSize": 28, - "fontFamily": 1, - "text": "Awake\n128", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "nTdCg9YES9bcUbYEdQyta", - "originalText": "Awake\n128", - "lineHeight": 1.25, - "baseline": 64 - }, - { - "type": "ellipse", - "version": 470, - "versionNonce": 445490864, - "isDeleted": false, - "id": "IyEMitLQCn9ktYumohw1w", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 2, - "opacity": 100, - "angle": 0, - "x": -1278.448690747455, - "y": 3506.9661264570896, - "strokeColor": "#1971c2", - "backgroundColor": "#b2f2bb", - "width": 158.20010375976562, - "height": 163, - "seed": 139123969, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [ - { - "id": "xX9zNOd036gOt9NBE8Rvi", - "type": "arrow" - }, - { - "id": "UvCZgYnpIziv3kllJrXSu", - "type": "arrow" - }, - { - "type": "text", - "id": "zZOZtekgqGD5GVTzmQp37" - }, - { - "id": "t2mJ36gZcTfYuLR0nvMGj", - "type": "arrow" - } - ], - "updated": 1714744061491, - "link": null, - "locked": false - }, - { - "type": "text", - "version": 487, - "versionNonce": 1336254640, - "isDeleted": false, - "id": "zZOZtekgqGD5GVTzmQp37", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 2, - "opacity": 100, - "angle": 0, - "x": -1236.56280436592, - "y": 3553.3369237903858, - "strokeColor": "#1971c2", - "backgroundColor": "transparent", - "width": 74.56396484375, - "height": 70, - "seed": 1607046369, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744061492, - "link": null, - "locked": false, - "fontSize": 28, - "fontFamily": 1, - "text": "array\n160", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "IyEMitLQCn9ktYumohw1w", - "originalText": "array\n160", - "lineHeight": 1.25, - "baseline": 64 - }, - { - "type": "diamond", - "version": 484, - "versionNonce": 1005657680, - "isDeleted": false, - "id": "uobFuAsT0NWnRMntfj5nA", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": -1039.5818592858661, - "y": 3491.4578561934177, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 206.13360595703108, - "height": 230, - "seed": 450433295, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 2 - }, - "boundElements": [ - { - "type": "text", - "id": "Qhq4_JM-nSBfudx4KwI3w" - }, - { - "id": "UvCZgYnpIziv3kllJrXSu", - "type": "arrow" - }, - { - "id": "dWqgALvF9Tt7Y7xljGzgz", - "type": "arrow" - }, - { - "id": "0ov9dJFlVufiTGN_Batn_", - "type": "arrow" - } - ], - "updated": 1714744082328, - "link": null, - "locked": false - }, - { - "type": "text", - "version": 485, - "versionNonce": 1281448016, - "isDeleted": false, - "id": "Qhq4_JM-nSBfudx4KwI3w", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": -975.3284413171161, - "y": 3571.4578561934177, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 77.55996704101562, - "height": 70, - "seed": 47322927, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744082329, - "link": null, - "locked": false, - "fontSize": 28, - "fontFamily": 1, - "text": "start\n161", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "uobFuAsT0NWnRMntfj5nA", - "originalText": "start\n161", - "lineHeight": 1.25, - "baseline": 64 - }, - { - "type": "arrow", - "version": 302, - "versionNonce": 1935013552, - "isDeleted": false, - "id": "v8Qr4f-p1eNaONyU3HxYm", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": -1696.5029965461563, - "y": 3593.6014571092824, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 86.1103623030699, - "height": 0.9750729043958017, - "seed": 1785090241, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 2 - }, - "boundElements": [], - "updated": 1714744077471, - "link": null, - "locked": false, - "startBinding": { - "elementId": "uYwEC6UHGHtBawFQ1yRXK", - "gap": 6.415019006481387, - "focus": 0.010680436385080695 - }, - "endBinding": { - "elementId": "nTdCg9YES9bcUbYEdQyta", - "gap": 10.792695192228948, - "focus": 0.0509179265231678 - }, - "lastCommittedPoint": null, - "startArrowhead": null, - "endArrowhead": "arrow", - "points": [ - [ - 0, - 0 - ], - [ - 86.1103623030699, - -0.9750729043958017 - ] - ] - }, - { - "type": "arrow", - "version": 192, - "versionNonce": 610463408, - "isDeleted": false, - "id": "xX9zNOd036gOt9NBE8Rvi", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": -1366.6940117176691, - "y": 3599.8292813762528, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 68.68906999390629, - "height": 4.53107866674145, - "seed": 499159201, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 2 - }, - "boundElements": [], - "updated": 1714744073402, - "link": null, - "locked": false, - "startBinding": { - "elementId": "nTdCg9YES9bcUbYEdQyta", - "gap": 14.018209123905663, - "focus": 0.08586378806646597 - }, - "endBinding": { - "elementId": "IyEMitLQCn9ktYumohw1w", - "gap": 19.781480549311887, - "focus": -0.003969875383615567 - }, - "lastCommittedPoint": null, - "startArrowhead": null, - "endArrowhead": "arrow", - "points": [ - [ - 0, - 0 - ], - [ - 68.68906999390629, - -4.53107866674145 - ] - ] - }, - { - "type": "arrow", - "version": 153, - "versionNonce": 1062849104, - "isDeleted": false, - "id": "UvCZgYnpIziv3kllJrXSu", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": -1107.4111953175195, - "y": 3595.148697392535, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 64.52409946038006, - "height": 4.936904705241432, - "seed": 260560001, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 2 - }, - "boundElements": [], - "updated": 1714744082328, - "link": null, - "locked": false, - "startBinding": { - "elementId": "IyEMitLQCn9ktYumohw1w", - "gap": 13.067797381304693, - "focus": -0.005107202519207527 - }, - "endBinding": { - "elementId": "uobFuAsT0NWnRMntfj5nA", - "gap": 6.714296040635084, - "focus": -0.015361252813825369 - }, - "lastCommittedPoint": null, - "startArrowhead": null, - "endArrowhead": "arrow", - "points": [ - [ - 0, - 0 - ], - [ - 64.52409946038006, - 4.936904705241432 - ] - ] - }, - { - "type": "arrow", - "version": 153, - "versionNonce": 2016262832, - "isDeleted": false, - "id": "iXpExTgBKgqPR5laoFls7", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": -823.1819772871686, - "y": 3403.649465893939, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 1256.0001627604165, - "height": 250.66665649414062, - "seed": 200897505, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053940, - "link": null, - "locked": false, - "startBinding": { - "elementId": "LUIcjOG-pExPEpZZJQzlm", - "focus": 0.03348251315767217, - "gap": 23.514191400436857 - }, - "endBinding": { - "elementId": "ViWZZy9Q7c0UYyERaQ5M0", - "focus": -0.6121335146544702, - "gap": 11.21487959604383 - }, - "lastCommittedPoint": null, - "startArrowhead": null, - "endArrowhead": "arrow", - "points": [ - [ - 0, - 0 - ], - [ - 1256.0001627604165, - 3.6459350585932953 - ], - [ - 1254.666748046875, - 250.66665649414062 - ] - ] - }, - { - "type": "arrow", - "version": 220, - "versionNonce": 829528240, - "isDeleted": false, - "id": "JgAs79Mhh9PankgSUE3N-", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": -1477.5786765478156, - "y": 3727.9894984688544, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 274.6666463216145, - "height": 101.33341471354152, - "seed": 1937480801, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [ - { - "type": "text", - "id": "78O2q2PxtGz1Gg4RXJBpS" - } - ], - "updated": 1714744073402, - "link": null, - "locked": false, - "startBinding": { - "elementId": "nTdCg9YES9bcUbYEdQyta", - "gap": 20.47086502203458, - "focus": -0.05271894646311373 - }, - "endBinding": null, - "lastCommittedPoint": null, - "startArrowhead": null, - "endArrowhead": "arrow", - "points": [ - [ - 0, - 0 - ], - [ - 5.396633139228015, - 98.99335162104808 - ], - [ - -269.2700131823865, - 98.99335162104808 - ], - [ - -265.27007421754274, - -2.3400630924934376 - ] - ] - }, - { - "type": "text", - "version": 35, - "versionNonce": 472808016, - "isDeleted": false, - "id": "78O2q2PxtGz1Gg4RXJBpS", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": -1673.9684915693947, - "y": 3814.9828500899025, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 128.90625, - "height": 24, - "seed": 1500211265, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744085177, - "link": null, - "locked": false, - "fontSize": 20, - "fontFamily": 3, - "text": "10 x re-try", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "JgAs79Mhh9PankgSUE3N-", - "originalText": "10 x re-try", - "lineHeight": 1.2, - "baseline": 20 - }, - { - "type": "arrow", - "version": 167, - "versionNonce": 1770485328, - "isDeleted": false, - "id": "dWqgALvF9Tt7Y7xljGzgz", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": -931.749744704638, - "y": 3732.369685731488, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 3.9029481307186416, - "height": 87.90479033497695, - "seed": 211599620, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744082328, - "link": null, - "locked": false, - "startBinding": { - "elementId": "uobFuAsT0NWnRMntfj5nA", - "gap": 11.906981924016634, - "focus": 0.005182860059776323 - }, - "endBinding": { - "elementId": "4Kr7ILxxgOKk4cL8Frdqj", - "gap": 14.791649712458138, - "focus": 0.03343417125319411 - }, - "lastCommittedPoint": null, - "startArrowhead": null, - "endArrowhead": "arrow", - "points": [ - [ - 0, - 0 - ], - [ - 3.9029481307186416, - 87.90479033497695 - ] - ] - }, - { - "type": "rectangle", - "version": 250, - "versionNonce": 1537396400, - "isDeleted": false, - "id": "4Kr7ILxxgOKk4cL8Frdqj", - "fillStyle": "cross-hatch", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": -969.9597618466297, - "y": 3835.0661257789234, - "strokeColor": "#e03131", - "backgroundColor": "#ffc9c9", - "width": 86.2221950954861, - "height": 83.08332655164895, - "seed": 1759903876, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [ - { - "id": "dWqgALvF9Tt7Y7xljGzgz", - "type": "arrow" - }, - { - "type": "text", - "id": "nCDFFqPz2NaPevY59Q_sK" - } - ], - "updated": 1714744053940, - "link": null, - "locked": false - }, - { - "type": "text", - "version": 214, - "versionNonce": 1069200464, - "isDeleted": false, - "id": "nCDFFqPz2NaPevY59Q_sK", - "fillStyle": "cross-hatch", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": -939.1246576460546, - "y": 3854.1077890547476, - "strokeColor": "#1e1e1e", - "backgroundColor": "#ffc9c9", - "width": 24.551986694335938, - "height": 45, - "seed": 2027638788, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053940, - "link": null, - "locked": false, - "fontSize": 36, - "fontFamily": 1, - "text": "-1", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "4Kr7ILxxgOKk4cL8Frdqj", - "originalText": "-1", - "lineHeight": 1.25, - "baseline": 38 - }, - { - "type": "rectangle", - "version": 553, - "versionNonce": 901085360, - "isDeleted": false, - "id": "fsf5g_MH6n-Xe8361Ds-Y", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": -1795.1915837847953, - "y": 3165.3932962568956, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 948.685961042132, - "height": 145.76242065429682, - "seed": 790388271, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 3 - }, - "boundElements": [ - { - "id": "cP4_-wTdxlg1lANFXh59e", - "type": "arrow" - }, - { - "type": "text", - "id": "rIrygkewhTvE4fK0UIFY-" - } - ], - "updated": 1714744053940, - "link": null, - "locked": false - }, - { - "type": "text", - "version": 560, - "versionNonce": 1157605968, - "isDeleted": false, - "id": "rIrygkewhTvE4fK0UIFY-", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": -1429.6765680464441, - "y": 3193.274506584044, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 217.6559295654297, - "height": 90, - "seed": 124698703, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053940, - "link": null, - "locked": false, - "fontSize": 36, - "fontFamily": 1, - "text": "RUN_ARRAY\n1", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "fsf5g_MH6n-Xe8361Ds-Y", - "originalText": "RUN_ARRAY\n1", - "lineHeight": 1.25, - "baseline": 83 - }, - { - "type": "text", - "version": 153, - "versionNonce": 154658832, - "isDeleted": false, - "id": "bTp-8luSuqfkr5dZXRzbu", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": -2131.0392582000222, - "y": 3211.3042045472125, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 189.84375, - "height": 43.199999999999996, - "seed": 124771951, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1717506989675, - "link": null, - "locked": false, - "fontSize": 36, - "fontFamily": 3, - "text": "run_array", - "textAlign": "left", - "verticalAlign": "top", - "containerId": null, - "originalText": "run_array", - "lineHeight": 1.2, - "baseline": 34 - }, - { - "type": "arrow", - "version": 44, - "versionNonce": 37085264, - "isDeleted": false, - "id": "cP4_-wTdxlg1lANFXh59e", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": -1929.848542228573, - "y": 3228.9828195723258, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 121.33331298828102, - "height": 0.354156494140625, - "seed": 1105737871, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053940, - "link": null, - "locked": false, - "startBinding": { - "focus": -0.16506783603693345, - "gap": 11.346965971449208, - "elementId": "bTp-8luSuqfkr5dZXRzbu" - }, - "endBinding": { - "focus": 0.1490495853850813, - "gap": 13.323645455496717, - "elementId": "fsf5g_MH6n-Xe8361Ds-Y" - }, - "lastCommittedPoint": null, - "startArrowhead": null, - "endArrowhead": "arrow", - "points": [ - [ - 0, - 0 - ], - [ - 121.33331298828102, - -0.354156494140625 - ] - ] - }, - { - "type": "rectangle", - "version": 592, - "versionNonce": 1288899760, - "isDeleted": false, - "id": "Pr4PBT6gtyxcUP4k4uCsX", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": -1795.1915837847953, - "y": 4097.039109245177, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 948.685961042132, - "height": 145.76242065429682, - "seed": 610179599, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 3 - }, - "boundElements": [ - { - "type": "text", - "id": "5c9x3dweo76bhGW5AV51w" - }, - { - "id": "fsL0FB0S9Y5X_0v2NpbrG", - "type": "arrow" - } - ], - "updated": 1714744053940, - "link": null, - "locked": false - }, - { - "type": "text", - "version": 618, - "versionNonce": 1731548752, - "isDeleted": false, - "id": "5c9x3dweo76bhGW5AV51w", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": -1394.1805811079676, - "y": 4124.920319572326, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 146.66395568847656, - "height": 90, - "seed": 884899887, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053940, - "link": null, - "locked": false, - "fontSize": 36, - "fontFamily": 1, - "text": "Set gain\nnot FSM", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "Pr4PBT6gtyxcUP4k4uCsX", - "originalText": "Set gain\nnot FSM", - "lineHeight": 1.25, - "baseline": 83 - }, - { - "type": "text", - "version": 203, - "versionNonce": 883319024, - "isDeleted": false, - "id": "WoDN3x20JgQV_4M3zgm2E", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": -2131.0392582000222, - "y": 4142.950017535494, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 189.84375, - "height": 43.199999999999996, - "seed": 1683577121, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [ - { - "id": "1PypevWTBXChXql2NBnfV", - "type": "arrow" - }, - { - "id": "fsL0FB0S9Y5X_0v2NpbrG", - "type": "arrow" - } - ], - "updated": 1717506989677, - "link": null, - "locked": false, - "fontSize": 36, - "fontFamily": 3, - "text": "set gains", - "textAlign": "left", - "verticalAlign": "top", - "containerId": null, - "originalText": "set gains", - "lineHeight": 1.2, - "baseline": 34 - }, - { - "type": "arrow", - "version": 188, - "versionNonce": 685116496, - "isDeleted": false, - "id": "fsL0FB0S9Y5X_0v2NpbrG", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": -1929.848542228573, - "y": 4160.6172362743755, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 121.33331298828102, - "height": 0.3515877575155173, - "seed": 1982559553, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053941, - "link": null, - "locked": false, - "startBinding": { - "elementId": "WoDN3x20JgQV_4M3zgm2E", - "focus": -0.16506783603693345, - "gap": 11.346965971449208 - }, - "endBinding": { - "elementId": "Pr4PBT6gtyxcUP4k4uCsX", - "focus": 0.1490495853850874, - "gap": 13.323645455496717 - }, - "lastCommittedPoint": null, - "startArrowhead": null, - "endArrowhead": "arrow", - "points": [ - [ - 0, - 0 - ], - [ - 121.33331298828102, - -0.3515877575155173 - ] - ] - }, - { - "type": "ellipse", - "version": 453, - "versionNonce": 10199216, - "isDeleted": false, - "id": "D6RCrZZfUskxRWf_dQGQy", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 2, - "opacity": 100, - "angle": 0, - "x": -1794.115245516335, - "y": 4286.966228182349, - "strokeColor": "#1971c2", - "backgroundColor": "#b2f2bb", - "width": 115.2000732421875, - "height": 115.2000732421875, - "seed": 1508824801, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [ - { - "type": "text", - "id": "rGXtYr1wg85vT4cKNEyTV" - }, - { - "id": "Gce5Uag0FalsnQV4V5iGy", - "type": "arrow" - }, - { - "id": "1DsZ45isiDwiBY2WN00mP", - "type": "arrow" - } - ], - "updated": 1714744053941, - "link": null, - "locked": false - }, - { - "type": "text", - "version": 425, - "versionNonce": 552600144, - "isDeleted": false, - "id": "rGXtYr1wg85vT4cKNEyTV", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 2, - "opacity": 100, - "angle": 0, - "x": -1756.3205741561414, - "y": 4324.336888312075, - "strokeColor": "#1971c2", - "backgroundColor": "transparent", - "width": 39.1519775390625, - "height": 40, - "seed": 848515777, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053941, - "link": null, - "locked": false, - "fontSize": 16, - "fontFamily": 1, - "text": "Wake\n170", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "D6RCrZZfUskxRWf_dQGQy", - "originalText": "Wake\n170", - "lineHeight": 1.25, - "baseline": 37 - }, - { - "type": "diamond", - "version": 460, - "versionNonce": 667159216, - "isDeleted": false, - "id": "U9zJlCi1cx3t3KTdW_MOO", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": -1552.582093253965, - "y": 4279.770386710996, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 146.13330078124994, - "height": 144.44578043619777, - "seed": 352820577, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 2 - }, - "boundElements": [ - { - "type": "text", - "id": "F1qzQG_LJqW8QZc9pHFKr" - }, - { - "id": "Gce5Uag0FalsnQV4V5iGy", - "type": "arrow" - }, - { - "id": "mgTwcu3_Vl7Te2jdNRQfS", - "type": "arrow" - }, - { - "id": "1DsZ45isiDwiBY2WN00mP", - "type": "arrow" - } - ], - "updated": 1714744053941, - "link": null, - "locked": false - }, - { - "type": "text", - "version": 422, - "versionNonce": 777730128, - "isDeleted": false, - "id": "F1qzQG_LJqW8QZc9pHFKr", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": -1503.2767496260353, - "y": 4331.881831820045, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 47.455963134765625, - "height": 40, - "seed": 1271875905, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053941, - "link": null, - "locked": false, - "fontSize": 16, - "fontFamily": 1, - "text": "Awake\n128", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "U9zJlCi1cx3t3KTdW_MOO", - "originalText": "Awake\n128", - "lineHeight": 1.25, - "baseline": 37 - }, - { - "type": "rectangle", - "version": 230, - "versionNonce": 1649358000, - "isDeleted": false, - "id": "5ZUJfQAvOLg0_P7upig6F", - "fillStyle": "cross-hatch", - "strokeWidth": 2, - "strokeStyle": "dotted", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 1036.227654545733, - "y": 1485.0945953942132, - "strokeColor": "#e03131", - "backgroundColor": "#ffec99", - "width": 863.333129882812, - "height": 1246.666755676269, - "seed": 1238532844, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 3 - }, - "boundElements": [], - "updated": 1714744053941, - "link": null, - "locked": false - }, - { - "type": "ellipse", - "version": 505, - "versionNonce": 351252048, - "isDeleted": false, - "id": "Onjg_i4-ah2ZiKQ2dExDG", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 2, - "opacity": 100, - "angle": 0, - "x": -1235.4486602298769, - "y": 4290.612061515683, - "strokeColor": "#1971c2", - "backgroundColor": "#b2f2bb", - "width": 115.2000732421875, - "height": 115.2000732421875, - "seed": 1575725263, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [ - { - "type": "text", - "id": "M7tosNMgSJnNzEvXvHCjs" - }, - { - "id": "mgTwcu3_Vl7Te2jdNRQfS", - "type": "arrow" - }, - { - "id": "h08UrC6DZ5KTYrflQ6eMN", - "type": "arrow" - } - ], - "updated": 1714744053941, - "link": null, - "locked": false - }, - { - "type": "text", - "version": 499, - "versionNonce": 904208048, - "isDeleted": false, - "id": "M7tosNMgSJnNzEvXvHCjs", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 2, - "opacity": 100, - "angle": 0, - "x": -1197.2539873438043, - "y": 4327.982721645408, - "strokeColor": "#1971c2", - "backgroundColor": "transparent", - "width": 38.35197448730469, - "height": 40, - "seed": 1060878063, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053941, - "link": null, - "locked": false, - "fontSize": 16, - "fontFamily": 1, - "text": "gains\n160-1", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "Onjg_i4-ah2ZiKQ2dExDG", - "originalText": "gains\n160-1", - "lineHeight": 1.25, - "baseline": 37 - }, - { - "type": "arrow", - "version": 278, - "versionNonce": 1569023056, - "isDeleted": false, - "id": "Gce5Uag0FalsnQV4V5iGy", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": -1672.5153716556579, - "y": 4345.962037101621, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 109.33339436848951, - "height": 1.333414713541515, - "seed": 319409487, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 2 - }, - "boundElements": [], - "updated": 1714744053941, - "link": null, - "locked": false, - "startBinding": { - "elementId": "D6RCrZZfUskxRWf_dQGQy", - "focus": 0.010680436385085314, - "gap": 6.415019006481387 - }, - "endBinding": { - "elementId": "U9zJlCi1cx3t3KTdW_MOO", - "focus": 0.05091792652318522, - "gap": 10.792695192229587 - }, - "lastCommittedPoint": null, - "startArrowhead": null, - "endArrowhead": "arrow", - "points": [ - [ - 0, - 0 - ], - [ - 109.33339436848951, - 1.333414713541515 - ] - ] - }, - { - "type": "arrow", - "version": 232, - "versionNonce": 858638512, - "isDeleted": false, - "id": "mgTwcu3_Vl7Te2jdNRQfS", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": -1389.848643953835, - "y": 4355.295431470111, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 134.66664632161473, - "height": 4.354146321614735, - "seed": 1327861647, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 2 - }, - "boundElements": [], - "updated": 1714744053941, - "link": null, - "locked": false, - "startBinding": { - "elementId": "U9zJlCi1cx3t3KTdW_MOO", - "focus": 0.08586378806647016, - "gap": 14.018209123905656 - }, - "endBinding": { - "elementId": "Onjg_i4-ah2ZiKQ2dExDG", - "focus": -0.0039698753836031435, - "gap": 19.781480549311844 - }, - "lastCommittedPoint": null, - "startArrowhead": null, - "endArrowhead": "arrow", - "points": [ - [ - 0, - 0 - ], - [ - 134.66664632161473, - -4.354146321614735 - ] - ] - }, - { - "type": "rectangle", - "version": 631, - "versionNonce": 905206352, - "isDeleted": false, - "id": "13A-cIBI0hFl0Kou3xlia", - "fillStyle": "cross-hatch", - "strokeWidth": 2, - "strokeStyle": "dotted", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 1967.8942194871388, - "y": 1493.0945953942132, - "strokeColor": "#e03131", - "backgroundColor": "#ffec99", - "width": 770, - "height": 1246.666755676269, - "seed": 869527039, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 3 - }, - "boundElements": [], - "updated": 1714744053941, - "link": null, - "locked": false - }, - { - "type": "arrow", - "version": 158, - "versionNonce": 366031536, - "isDeleted": false, - "id": "h08UrC6DZ5KTYrflQ6eMN", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": -1107.1820179772726, - "y": 4348.628764803444, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 97.3333740234375, - "height": 0.9791056315107198, - "seed": 1782263937, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 2 - }, - "boundElements": [], - "updated": 1714744053941, - "link": null, - "locked": false, - "startBinding": { - "elementId": "Onjg_i4-ah2ZiKQ2dExDG", - "focus": -0.005107202519207527, - "gap": 13.067797381304693 - }, - "endBinding": { - "elementId": "N0cX1tGro7njXrsAOLgdr", - "focus": 0.030303133580792906, - "gap": 7.4763777515814525 - }, - "lastCommittedPoint": null, - "startArrowhead": null, - "endArrowhead": "arrow", - "points": [ - [ - 0, - 0 - ], - [ - 97.3333740234375, - 0.9791056315107198 - ] - ] - }, - { - "type": "arrow", - "version": 309, - "versionNonce": 1360302160, - "isDeleted": false, - "id": "1DsZ45isiDwiBY2WN00mP", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": -1476.5153106205016, - "y": 4433.96211848183, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 274.6666463216145, - "height": 101.33341471354152, - "seed": 1189902927, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [ - { - "type": "text", - "id": "D5gdBq6jF-zLZy7WfzaTh" - } - ], - "updated": 1714744053941, - "link": null, - "locked": false, - "startBinding": { - "elementId": "U9zJlCi1cx3t3KTdW_MOO", - "focus": -0.023801452166815396, - "gap": 9.040391251510648 - }, - "endBinding": { - "elementId": "D6RCrZZfUskxRWf_dQGQy", - "focus": 0.11074199316822089, - "gap": 17.70967973621081 - }, - "lastCommittedPoint": null, - "startArrowhead": null, - "endArrowhead": "arrow", - "points": [ - [ - 0, - 0 - ], - [ - 1.33331298828125, - 86.66666666666652 - ], - [ - -273.33333333333326, - 86.66666666666652 - ], - [ - -269.3333943684895, - -14.666748046875 - ] - ] - }, - { - "type": "text", - "version": 31, - "versionNonce": 1685544112, - "isDeleted": false, - "id": "D5gdBq6jF-zLZy7WfzaTh", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": -1664.0778207930275, - "y": 3727.3828500899026, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 103.125, - "height": 19.2, - "seed": 453937231, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053941, - "link": null, - "locked": false, - "fontSize": 16, - "fontFamily": 3, - "text": "10 x re-try", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "1DsZ45isiDwiBY2WN00mP", - "originalText": "10 x re-try", - "lineHeight": 1.2, - "baseline": 16 - }, - { - "type": "arrow", - "version": 202, - "versionNonce": 1186858576, - "isDeleted": false, - "id": "bC8G2hYSNIFc2_Me7VqsJ", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": -927.1820179772726, - "y": 4437.9620574466735, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 1.33331298828125, - "height": 165.95835367838527, - "seed": 1191860399, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053941, - "link": null, - "locked": false, - "startBinding": { - "elementId": "N0cX1tGro7njXrsAOLgdr", - "focus": -0.017986064516638294, - "gap": 10.744892908205493 - }, - "endBinding": { - "elementId": "uCNGKGtZaXicEtZGcUrvR", - "focus": 0.03343417125319422, - "gap": 14.79164971245882 - }, - "lastCommittedPoint": null, - "startArrowhead": null, - "endArrowhead": "arrow", - "points": [ - [ - 0, - 0 - ], - [ - 1.33331298828125, - 165.95835367838527 - ] - ] - }, - { - "type": "rectangle", - "version": 297, - "versionNonce": 281560752, - "isDeleted": false, - "id": "uCNGKGtZaXicEtZGcUrvR", - "fillStyle": "cross-hatch", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": -969.9597618466297, - "y": 4618.712060837517, - "strokeColor": "#e03131", - "backgroundColor": "#ffc9c9", - "width": 86.2221950954861, - "height": 83.08332655164895, - "seed": 992918767, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [ - { - "type": "text", - "id": "bhGbuqXzpmUaQXBBQbWk3" - }, - { - "id": "bC8G2hYSNIFc2_Me7VqsJ", - "type": "arrow" - } - ], - "updated": 1714744053941, - "link": null, - "locked": false - }, - { - "type": "text", - "version": 263, - "versionNonce": 1942535248, - "isDeleted": false, - "id": "bhGbuqXzpmUaQXBBQbWk3", - "fillStyle": "cross-hatch", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": -939.1246576460546, - "y": 4637.753724113341, - "strokeColor": "#1e1e1e", - "backgroundColor": "#ffc9c9", - "width": 24.551986694335938, - "height": 45, - "seed": 122111759, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053941, - "link": null, - "locked": false, - "fontSize": 36, - "fontFamily": 1, - "text": "-1", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "uCNGKGtZaXicEtZGcUrvR", - "originalText": "-1", - "lineHeight": 1.25, - "baseline": 38 - }, - { - "type": "diamond", - "version": 484, - "versionNonce": 392949936, - "isDeleted": false, - "id": "N0cX1tGro7njXrsAOLgdr", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": -1002.2485869876848, - "y": 4280.385010734436, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 146.13330078124994, - "height": 144.44578043619777, - "seed": 474451023, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 2 - }, - "boundElements": [ - { - "type": "text", - "id": "lxahC8Py7GJOXqxS0jtRJ" - }, - { - "id": "h08UrC6DZ5KTYrflQ6eMN", - "type": "arrow" - }, - { - "id": "bC8G2hYSNIFc2_Me7VqsJ", - "type": "arrow" - } - ], - "updated": 1714744053941, - "link": null, - "locked": false - }, - { - "type": "text", - "version": 464, - "versionNonce": 1510781520, - "isDeleted": false, - "id": "lxahC8Py7GJOXqxS0jtRJ", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": -951.3752425662981, - "y": 4332.496455843486, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 44.31996154785156, - "height": 40, - "seed": 525281903, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053941, - "link": null, - "locked": false, - "fontSize": 16, - "fontFamily": 1, - "text": "start\n161", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "N0cX1tGro7njXrsAOLgdr", - "originalText": "start\n161", - "lineHeight": 1.25, - "baseline": 37 - }, - { - "type": "rectangle", - "version": 258, - "versionNonce": 537549488, - "isDeleted": false, - "id": "949o_Sk--Ld6wo2FKS2fL", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": -2718.0883511511747, - "y": 2144.6222031974667, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 268.50899366592813, - "height": 120.34072952849813, - "seed": 1290344508, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 3 - }, - "boundElements": [ - { - "type": "text", - "id": "Ku5jwN-ehg_ppOzAQcOz5" - }, - { - "id": "5e8pE6-Q5WVxBCsQPlJL-", - "type": "arrow" - }, - { - "id": "Aujbd37Vz68tzdcf0qX0K", - "type": "arrow" - }, - { - "id": "7p9T0a-IxPmDdjBqC-0im", - "type": "arrow" - } - ], - "updated": 1714744053941, - "link": null, - "locked": false - }, - { - "type": "text", - "version": 298, - "versionNonce": 6416464, - "isDeleted": false, - "id": "Ku5jwN-ehg_ppOzAQcOz5", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": -2618.465835214207, - "y": 2182.2925679617156, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 69.26396179199219, - "height": 45, - "seed": 219328700, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053942, - "link": null, - "locked": false, - "fontSize": 36, - "fontFamily": 1, - "text": "Idle", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "949o_Sk--Ld6wo2FKS2fL", - "originalText": "Idle", - "lineHeight": 1.25, - "baseline": 38 - }, - { - "type": "rectangle", - "version": 306, - "versionNonce": 491488432, - "isDeleted": false, - "id": "QljoeT8sSPtX_l3e_a3My", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": -2015.3499767931817, - "y": 2144.6222031974667, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 268.50899366592813, - "height": 120.34072952849813, - "seed": 896874812, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 3 - }, - "boundElements": [ - { - "type": "text", - "id": "qX54YZHFaLlmhuYfJptkK" - }, - { - "id": "ORyDG0-MmRvrIZpmyRPlC", - "type": "arrow" - }, - { - "id": "ZTgJCi82oC_3iuspj4sVs", - "type": "arrow" - } - ], - "updated": 1714744053942, - "link": null, - "locked": false - }, - { - "type": "text", - "version": 344, - "versionNonce": 1386241616, - "isDeleted": false, - "id": "qX54YZHFaLlmhuYfJptkK", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": -1924.169446940198, - "y": 2182.2925679617156, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 86.14793395996094, - "height": 45, - "seed": 829600188, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053942, - "link": null, - "locked": false, - "fontSize": 36, - "fontFamily": 1, - "text": "sleep", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "QljoeT8sSPtX_l3e_a3My", - "originalText": "sleep", - "lineHeight": 1.25, - "baseline": 38 - }, - { - "type": "diamond", - "version": 302, - "versionNonce": 1826057904, - "isDeleted": false, - "id": "oojvRHlnGhZu1D9CQPzga", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": -2338.399894807081, - "y": 2098.1937387087164, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 234.94540946863557, - "height": 219.45825162823473, - "seed": 808262204, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 2 - }, - "boundElements": [ - { - "type": "text", - "id": "VEK9mOzvCT7cIABUKVdF1" - }, - { - "id": "7p9T0a-IxPmDdjBqC-0im", - "type": "arrow" - }, - { - "id": "ORyDG0-MmRvrIZpmyRPlC", - "type": "arrow" - } - ], - "updated": 1714744053942, - "link": null, - "locked": false - }, - { - "type": "text", - "version": 309, - "versionNonce": 27268176, - "isDeleted": false, - "id": "VEK9mOzvCT7cIABUKVdF1", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": -2260.6855303549614, - "y": 2173.0583016157752, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 79.04397583007812, - "height": 70, - "seed": 747008700, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053942, - "link": null, - "locked": false, - "fontSize": 28, - "fontFamily": 1, - "text": "idle\n100ms", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "oojvRHlnGhZu1D9CQPzga", - "originalText": "idle\n100ms", - "lineHeight": 1.25, - "baseline": 64 - }, - { - "type": "diamond", - "version": 595, - "versionNonce": 2002131120, - "isDeleted": false, - "id": "4HG3lkfSICKQoMrMvMSOL", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": -773.0239289434176, - "y": 2111.0701354668563, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 234.94540946863557, - "height": 219.45825162823473, - "seed": 1965079356, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 2 - }, - "boundElements": [ - { - "type": "text", - "id": "-1QesW8sjDIOBHp0WoVlf" - }, - { - "id": "XOgSlXTT9UnidMDOPb8Og", - "type": "arrow" - }, - { - "id": "z8rBoA7QcvEpK40GcZt3l", - "type": "arrow" - }, - { - "id": "t2mJ36gZcTfYuLR0nvMGj", - "type": "arrow" - }, - { - "id": "ek9xtHVfDe-Hf4jNvTJNN", - "type": "arrow" - } - ], - "updated": 1714744053942, - "link": null, - "locked": false - }, - { - "type": "text", - "version": 605, - "versionNonce": 1664682576, - "isDeleted": false, - "id": "-1QesW8sjDIOBHp0WoVlf", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": -688.7155627212783, - "y": 2185.934698373915, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 65.85597229003906, - "height": 70, - "seed": 878572476, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053942, - "link": null, - "locked": false, - "fontSize": 28, - "fontFamily": 1, - "text": "CMD\n(160)", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "4HG3lkfSICKQoMrMvMSOL", - "originalText": "CMD\n(160)", - "lineHeight": 1.25, - "baseline": 64 - }, - { - "type": "diamond", - "version": 338, - "versionNonce": 1349485232, - "isDeleted": false, - "id": "ZVlRo5ABA2pBBSuDikef_", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": -1674.4696597442662, - "y": 2098.1937387087164, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 234.94540946863557, - "height": 219.45825162823473, - "seed": 2019564604, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 2 - }, - "boundElements": [ - { - "type": "text", - "id": "tl-Ch-qaGtP3U275BDcYl" - }, - { - "id": "ZTgJCi82oC_3iuspj4sVs", - "type": "arrow" - }, - { - "id": "glCxPNKW4x-VKTsz6vtbT", - "type": "arrow" - }, - { - "id": "gyPcyFeW-J2407VPWQOUM", - "type": "arrow" - }, - { - "id": "GkT7kVIBQeOtiyApJWoB5", - "type": "arrow" - } - ], - "updated": 1714744053942, - "link": null, - "locked": false - }, - { - "type": "text", - "version": 353, - "versionNonce": 1380139088, - "isDeleted": false, - "id": "tl-Ch-qaGtP3U275BDcYl", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": -1595.4532933390215, - "y": 2173.0583016157752, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 76.43997192382812, - "height": 70, - "seed": 990459068, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053942, - "link": null, - "locked": false, - "fontSize": 28, - "fontFamily": 1, - "text": "uart \ninput", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "ZVlRo5ABA2pBBSuDikef_", - "originalText": "uart input", - "lineHeight": 1.25, - "baseline": 64 - }, - { - "type": "rectangle", - "version": 303, - "versionNonce": 1456188592, - "isDeleted": false, - "id": "hCliSU94s9BGXBwt9V9Cz", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": -465.0767722216874, - "y": 2146.622248973834, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 268.50899366592813, - "height": 120.34072952849813, - "seed": 1778072892, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 3 - }, - "boundElements": [ - { - "type": "text", - "id": "XxYAkqaHV42o7VvCwwdhJ" - }, - { - "id": "jYKNwDNwCT9HqtyU1cb6j", - "type": "arrow" - }, - { - "id": "ek9xtHVfDe-Hf4jNvTJNN", - "type": "arrow" - } - ], - "updated": 1714744053942, - "link": null, - "locked": false - }, - { - "type": "text", - "version": 351, - "versionNonce": 244758096, - "isDeleted": false, - "id": "XxYAkqaHV42o7VvCwwdhJ", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": -410.32824920464134, - "y": 2184.2926137380828, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 159.01194763183594, - "height": 45, - "seed": 1855468988, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053942, - "link": null, - "locked": false, - "fontSize": 36, - "fontFamily": 1, - "text": "read cmd", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "hCliSU94s9BGXBwt9V9Cz", - "originalText": "read cmd", - "lineHeight": 1.25, - "baseline": 38 - }, - { - "type": "rectangle", - "version": 330, - "versionNonce": 1410504368, - "isDeleted": false, - "id": "zkcdoo4IxMpf3Io6otHZq", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 32.08426882387903, - "y": 1672.2575258163251, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 268.50899366592813, - "height": 120.34072952849813, - "seed": 906108476, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 3 - }, - "boundElements": [ - { - "type": "text", - "id": "c6kmxmWIl4-5yo2Pi83fh" - }, - { - "id": "OSsAiS2MCRmxV-q2MalgZ", - "type": "arrow" - } - ], - "updated": 1714744053942, - "link": null, - "locked": false - }, - { - "type": "text", - "version": 400, - "versionNonce": 487287888, - "isDeleted": false, - "id": "c6kmxmWIl4-5yo2Pi83fh", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 76.10439065684307, - "y": 1715.627890580574, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 180.46875, - "height": 33.6, - "seed": 958068412, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053942, - "link": null, - "locked": false, - "fontSize": 28, - "fontFamily": 3, - "text": "1:set gains", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "zkcdoo4IxMpf3Io6otHZq", - "originalText": "1:set gains", - "lineHeight": 1.2, - "baseline": 28 - }, - { - "type": "rectangle", - "version": 378, - "versionNonce": 485245104, - "isDeleted": false, - "id": "6IK43Bfug0fISgEXMfPcp", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 32.08426882387903, - "y": 1832.4549615654232, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 268.50899366592813, - "height": 120.34072952849813, - "seed": 75808572, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 3 - }, - "boundElements": [ - { - "type": "text", - "id": "UPwfygmX8bemeNlVw1EeP" - }, - { - "id": "7CmBjWZiaxLIltxekbWVi", - "type": "arrow" - } - ], - "updated": 1714744053942, - "link": null, - "locked": false - }, - { - "type": "text", - "version": 469, - "versionNonce": 662266448, - "isDeleted": false, - "id": "UPwfygmX8bemeNlVw1EeP", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 59.698140656843066, - "y": 1875.8253263296724, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 213.28125, - "height": 33.6, - "seed": 1084323772, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053942, - "link": null, - "locked": false, - "fontSize": 28, - "fontFamily": 3, - "text": "2.set current", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "6IK43Bfug0fISgEXMfPcp", - "originalText": "2.set current", - "lineHeight": 1.2, - "baseline": 28 - }, - { - "type": "rectangle", - "version": 418, - "versionNonce": 822127280, - "isDeleted": false, - "id": "bdtDFfCqknXWzFkbBWzlY", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 33.13311582593906, - "y": 1987.1296460922222, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 268.50899366592813, - "height": 120.34072952849813, - "seed": 965943356, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 3 - }, - "boundElements": [ - { - "type": "text", - "id": "Ij_bOM4RLwQ1FQsCPmfeb" - }, - { - "id": "mQQVZWFCaZll-lGe9sJFL", - "type": "arrow" - } - ], - "updated": 1714744053942, - "link": null, - "locked": false - }, - { - "type": "text", - "version": 535, - "versionNonce": 1555601488, - "isDeleted": false, - "id": "Ij_bOM4RLwQ1FQsCPmfeb", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 68.9501126589031, - "y": 2013.7000108564712, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 196.875, - "height": 67.2, - "seed": 1731967164, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053942, - "link": null, - "locked": false, - "fontSize": 28, - "fontFamily": 3, - "text": "10.run array\nconfig", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "bdtDFfCqknXWzFkbBWzlY", - "originalText": "10.run array\nconfig", - "lineHeight": 1.2, - "baseline": 62 - }, - { - "type": "rectangle", - "version": 458, - "versionNonce": 1526191280, - "isDeleted": false, - "id": "NbYnTiIlKnGn-vT1BgUXG", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 33.13311582593906, - "y": 2141.525494319436, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 268.50899366592813, - "height": 120.34072952849813, - "seed": 1966948668, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 3 - }, - "boundElements": [ - { - "type": "text", - "id": "f3gVRuvhdURfRJvpSdgQ3" - }, - { - "id": "s1oV_1bxxeApejlYxosK_", - "type": "arrow" - }, - { - "id": "jYKNwDNwCT9HqtyU1cb6j", - "type": "arrow" - } - ], - "updated": 1714744053942, - "link": null, - "locked": false - }, - { - "type": "text", - "version": 571, - "versionNonce": 1352732240, - "isDeleted": false, - "id": "f3gVRuvhdURfRJvpSdgQ3", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 85.3563626589031, - "y": 2184.895859083685, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 164.0625, - "height": 33.6, - "seed": 1257879996, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053942, - "link": null, - "locked": false, - "fontSize": 28, - "fontFamily": 3, - "text": "20.run MPF", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "NbYnTiIlKnGn-vT1BgUXG", - "originalText": "20.run MPF", - "lineHeight": 1.2, - "baseline": 28 - }, - { - "type": "rectangle", - "version": 491, - "versionNonce": 1350155952, - "isDeleted": false, - "id": "yi8YUhr6OLbLopAi9MGHa", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 33.13311582593906, - "y": 2295.429768034279, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 268.50899366592813, - "height": 120.34072952849813, - "seed": 328409660, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 3 - }, - "boundElements": [ - { - "type": "text", - "id": "EV2Vp2bvAYI5ZOmPQuYNE" - }, - { - "id": "EWVImJd5PN_hqIZKeyIS9", - "type": "arrow" - } - ], - "updated": 1714744053942, - "link": null, - "locked": false - }, - { - "type": "text", - "version": 614, - "versionNonce": 1544209488, - "isDeleted": false, - "id": "EV2Vp2bvAYI5ZOmPQuYNE", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 68.9501126589031, - "y": 2338.800132798528, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 196.875, - "height": 33.6, - "seed": 1173060284, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053942, - "link": null, - "locked": false, - "fontSize": 28, - "fontFamily": 3, - "text": "21.run array", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "yi8YUhr6OLbLopAi9MGHa", - "originalText": "21.run array", - "lineHeight": 1.2, - "baseline": 28 - }, - { - "type": "rectangle", - "version": 533, - "versionNonce": 1378773168, - "isDeleted": false, - "id": "Ur3AZBQlRtcWGMQc7cqJZ", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 33.13311582593906, - "y": 2431.5034026484154, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 268.50899366592813, - "height": 120.34072952849813, - "seed": 748995388, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 3 - }, - "boundElements": [ - { - "type": "text", - "id": "-9GR8zduWrQC-XQutHFrt" - }, - { - "id": "7mtOYU4QDRX4K4NLvqMk3", - "type": "arrow" - } - ], - "updated": 1714744053942, - "link": null, - "locked": false - }, - { - "type": "text", - "version": 680, - "versionNonce": 2093857360, - "isDeleted": false, - "id": "-9GR8zduWrQC-XQutHFrt", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 68.9501126589031, - "y": 2474.8737674126646, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 196.875, - "height": 33.6, - "seed": 1847655356, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053943, - "link": null, - "locked": false, - "fontSize": 28, - "fontFamily": 3, - "text": "31. get spec", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "Ur3AZBQlRtcWGMQc7cqJZ", - "originalText": "31. get spec", - "lineHeight": 1.2, - "baseline": 28 - }, - { - "type": "rectangle", - "version": 551, - "versionNonce": 1270731440, - "isDeleted": false, - "id": "w8M4H0JRvxO08MbJjpNhG", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 33.13311582593906, - "y": 2573.0999085176936, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 268.50899366592813, - "height": 120.34072952849813, - "seed": 344073276, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 3 - }, - "boundElements": [ - { - "type": "text", - "id": "ZvZCZgvqRaDJEJlbn82VF" - }, - { - "id": "C9zNCvnFdLQJDCrQGY8nP", - "type": "arrow" - } - ], - "updated": 1714744053943, - "link": null, - "locked": false - }, - { - "type": "text", - "version": 711, - "versionNonce": 901902416, - "isDeleted": false, - "id": "ZvZCZgvqRaDJEJlbn82VF", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 68.9501126589031, - "y": 2616.470273281943, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 196.875, - "height": 33.6, - "seed": 363478204, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053943, - "link": null, - "locked": false, - "fontSize": 28, - "fontFamily": 3, - "text": "32. get temp", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "w8M4H0JRvxO08MbJjpNhG", - "originalText": "32. get temp", - "lineHeight": 1.2, - "baseline": 28 - }, - { - "type": "rectangle", - "version": 321, - "versionNonce": 1943010480, - "isDeleted": false, - "id": "NDEGY3EfBEYzOwrS2OYXC", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 483.79423282886455, - "y": 1907.2027352302175, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 233.89656246657583, - "height": 121.11090027476531, - "seed": 1530611004, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 3 - }, - "boundElements": [ - { - "type": "text", - "id": "VYBcw0ZEu1x5FhGAVUwuV" - }, - { - "id": "OSsAiS2MCRmxV-q2MalgZ", - "type": "arrow" - }, - { - "id": "7CmBjWZiaxLIltxekbWVi", - "type": "arrow" - }, - { - "id": "mQQVZWFCaZll-lGe9sJFL", - "type": "arrow" - }, - { - "id": "5e8pE6-Q5WVxBCsQPlJL-", - "type": "arrow" - } - ], - "updated": 1714744053943, - "link": null, - "locked": false - }, - { - "type": "text", - "version": 329, - "versionNonce": 1858037328, - "isDeleted": false, - "id": "VYBcw0ZEu1x5FhGAVUwuV", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 534.6943573238713, - "y": 1934.9812164163782, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 132.0963134765625, - "height": 65.553937902444, - "seed": 1251425724, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053943, - "link": null, - "locked": false, - "fontSize": 26.221575160977604, - "fontFamily": 1, - "text": "CMD Done\n(161)", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "NDEGY3EfBEYzOwrS2OYXC", - "originalText": "CMD Done\n(161)", - "lineHeight": 1.25, - "baseline": 59 - }, - { - "type": "arrow", - "version": 414, - "versionNonce": 1812784816, - "isDeleted": false, - "id": "OSsAiS2MCRmxV-q2MalgZ", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 315.27700048579845, - "y": 1730.502083610896, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 160.72423860764746, - "height": 164.9177156199111, - "seed": 1289758268, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 2 - }, - "boundElements": [], - "updated": 1714744053943, - "link": null, - "locked": false, - "startBinding": { - "elementId": "zkcdoo4IxMpf3Io6otHZq", - "focus": -0.7818511425353244, - "gap": 14.683737995991294 - }, - "endBinding": { - "elementId": "NDEGY3EfBEYzOwrS2OYXC", - "focus": -0.3082579603972137, - "gap": 11.782935999410256 - }, - "lastCommittedPoint": null, - "startArrowhead": null, - "endArrowhead": "arrow", - "points": [ - [ - 0, - 0 - ], - [ - 160.72423860764746, - 164.9177156199111 - ] - ] - }, - { - "type": "arrow", - "version": 392, - "versionNonce": 1419648080, - "isDeleted": false, - "id": "7CmBjWZiaxLIltxekbWVi", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 322.61900952211363, - "y": 1897.2712976336188, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 145.44235823206162, - "height": 45.06178574940823, - "seed": 1459093180, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 2 - }, - "boundElements": [], - "updated": 1714744053943, - "link": null, - "locked": false, - "startBinding": { - "elementId": "6IK43Bfug0fISgEXMfPcp", - "focus": -0.43014100212738277, - "gap": 22.02574703230647 - }, - "endBinding": { - "elementId": "NDEGY3EfBEYzOwrS2OYXC", - "focus": -0.16203210909219073, - "gap": 15.732865074689244 - }, - "lastCommittedPoint": null, - "startArrowhead": null, - "endArrowhead": "arrow", - "points": [ - [ - 0, - 0 - ], - [ - 145.44235823206162, - 45.06178574940823 - ] - ] - }, - { - "type": "arrow", - "version": 404, - "versionNonce": 1629262000, - "isDeleted": false, - "id": "mQQVZWFCaZll-lGe9sJFL", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 317.37469448991806, - "y": 2046.2098525501606, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 149.63782626219742, - "height": 71.88620736856174, - "seed": 1904265020, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 2 - }, - "boundElements": [], - "updated": 1714744053943, - "link": null, - "locked": false, - "startBinding": { - "elementId": "bdtDFfCqknXWzFkbBWzlY", - "focus": 0.569229813113076, - "gap": 15.732584998050868 - }, - "endBinding": { - "elementId": "NDEGY3EfBEYzOwrS2OYXC", - "focus": 0.494087807924145, - "gap": 16.78171207674899 - }, - "lastCommittedPoint": null, - "startArrowhead": null, - "endArrowhead": "arrow", - "points": [ - [ - 0, - 0 - ], - [ - 149.63782626219742, - -71.88620736856174 - ] - ] - }, - { - "type": "arrow", - "version": 728, - "versionNonce": 959844944, - "isDeleted": false, - "id": "5e8pE6-Q5WVxBCsQPlJL-", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 603.6512416399964, - "y": 1889.340799946709, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 3090.989014818514, - "height": 688.0832522879243, - "seed": 1088192444, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053943, - "link": null, - "locked": false, - "startBinding": { - "elementId": "NDEGY3EfBEYzOwrS2OYXC", - "focus": 0.012193318881083352, - "gap": 17.8619352835085 - }, - "endBinding": { - "elementId": "949o_Sk--Ld6wo2FKS2fL", - "focus": 0.7775389777746909, - "gap": 15.116554543785924 - }, - "lastCommittedPoint": null, - "startArrowhead": null, - "endArrowhead": "arrow", - "points": [ - [ - 0, - 0 - ], - [ - 5.608157783207142, - -299.390323902586 - ], - [ - -3085.380857035307, - -447.9184035809528 - ], - [ - -3083.187832256145, - 240.1648487069715 - ] - ] - }, - { - "type": "rectangle", - "version": 376, - "versionNonce": 715586224, - "isDeleted": false, - "id": "R0nMXwKFeadrft0ZosQ-f", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 448.9193431448157, - "y": 2231.6415856866715, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 233.89656246657583, - "height": 121.11090027476531, - "seed": 221063228, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 3 - }, - "boundElements": [ - { - "id": "s1oV_1bxxeApejlYxosK_", - "type": "arrow" - }, - { - "id": "EWVImJd5PN_hqIZKeyIS9", - "type": "arrow" - }, - { - "type": "text", - "id": "zVF10-saLAt7kjq1aldcL" - }, - { - "id": "BTXvg-RCegp3WrYRd1Fx_", - "type": "arrow" - }, - { - "id": "0ov9dJFlVufiTGN_Batn_", - "type": "arrow" - } - ], - "updated": 1714744053943, - "link": null, - "locked": false - }, - { - "type": "text", - "version": 377, - "versionNonce": 1935624272, - "isDeleted": false, - "id": "zVF10-saLAt7kjq1aldcL", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 504.4144993781036, - "y": 2260.731145630881, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 122.90625, - "height": 62.93178038634625, - "seed": 1247068348, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053943, - "link": null, - "locked": false, - "fontSize": 26.221575160977604, - "fontFamily": 3, - "text": "CMD Done\n(161)", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "R0nMXwKFeadrft0ZosQ-f", - "originalText": "CMD Done\n(161)", - "lineHeight": 1.2, - "baseline": 58 - }, - { - "type": "arrow", - "version": 385, - "versionNonce": 1800676528, - "isDeleted": false, - "id": "s1oV_1bxxeApejlYxosK_", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 318.0739524985911, - "y": 2240.4604561540273, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 113.62682569757001, - "height": 28.09206390009679, - "seed": 536168764, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053943, - "link": null, - "locked": false, - "startBinding": { - "elementId": "NbYnTiIlKnGn-vT1BgUXG", - "focus": 0.016176516931354017, - "gap": 16.43184300672391 - }, - "endBinding": { - "elementId": "R0nMXwKFeadrft0ZosQ-f", - "focus": -0.10646939352813495, - "gap": 17.218564948654546 - }, - "lastCommittedPoint": null, - "startArrowhead": null, - "endArrowhead": "arrow", - "points": [ - [ - 0, - 0 - ], - [ - 113.62682569757001, - 28.09206390009679 - ] - ] - }, - { - "type": "arrow", - "version": 380, - "versionNonce": 1056030288, - "isDeleted": false, - "id": "EWVImJd5PN_hqIZKeyIS9", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 316.32600753165207, - "y": 2384.1056235194374, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 106.63424561084935, - "height": 51.38105636489672, - "seed": 1903215036, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053943, - "link": null, - "locked": false, - "startBinding": { - "elementId": "yi8YUhr6OLbLopAi9MGHa", - "focus": 0.8030633168768259, - "gap": 14.683898039784879 - }, - "endBinding": { - "elementId": "R0nMXwKFeadrft0ZosQ-f", - "focus": 0.24234380222657106, - "gap": 25.959090002314213 - }, - "lastCommittedPoint": null, - "startArrowhead": null, - "endArrowhead": "arrow", - "points": [ - [ - 0, - 0 - ], - [ - 106.63424561084935, - -51.38105636489672 - ] - ] - }, - { - "type": "rectangle", - "version": 405, - "versionNonce": 818679472, - "isDeleted": false, - "id": "TAfAwbMTEgK3giBptpu7a", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 854.4796522866723, - "y": 2232.925270282032, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 233.89656246657583, - "height": 121.11090027476531, - "seed": 1709779516, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 3 - }, - "boundElements": [ - { - "id": "s1oV_1bxxeApejlYxosK_", - "type": "arrow" - }, - { - "id": "EWVImJd5PN_hqIZKeyIS9", - "type": "arrow" - }, - { - "id": "BTXvg-RCegp3WrYRd1Fx_", - "type": "arrow" - }, - { - "type": "text", - "id": "yc1kY6T5k1WDP2E5hMY5_" - }, - { - "id": "5HnIVT4wdBSYi6xZCQtv4", - "type": "arrow" - } - ], - "updated": 1714744053943, - "link": null, - "locked": false - }, - { - "type": "text", - "version": 422, - "versionNonce": 482702416, - "isDeleted": false, - "id": "yc1kY6T5k1WDP2E5hMY5_", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 884.2719581781632, - "y": 2270.980720419415, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 174.31195068359375, - "height": 45, - "seed": 1883275964, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053943, - "link": null, - "locked": false, - "fontSize": 36, - "fontFamily": 1, - "text": "ADPD run", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "TAfAwbMTEgK3giBptpu7a", - "originalText": "ADPD run", - "lineHeight": 1.25, - "baseline": 38 - }, - { - "type": "arrow", - "version": 358, - "versionNonce": 330741936, - "isDeleted": false, - "id": "BTXvg-RCegp3WrYRd1Fx_", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 695.664608142702, - "y": 2293.1530307517987, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 153.8331609225059, - "height": 0.9358156326924376, - "seed": 1461242684, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053943, - "link": null, - "locked": false, - "startBinding": { - "elementId": "R0nMXwKFeadrft0ZosQ-f", - "focus": 0.028491589862995152, - "gap": 12.848702531310607 - }, - "endBinding": { - "elementId": "TAfAwbMTEgK3giBptpu7a", - "focus": 0.03272967111097992, - "gap": 4.981883221464386 - }, - "lastCommittedPoint": null, - "startArrowhead": null, - "endArrowhead": "arrow", - "points": [ - [ - 0, - 0 - ], - [ - 153.8331609225059, - -0.9358156326924376 - ] - ] - }, - { - "type": "rectangle", - "version": 521, - "versionNonce": 850553424, - "isDeleted": false, - "id": "SHT8Z3GcYk1eYuTfyw4Wt", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 575.2203036057099, - "y": 2514.8072032625405, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 233.89656246657583, - "height": 121.11090027476531, - "seed": 1020527548, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 3 - }, - "boundElements": [ - { - "type": "text", - "id": "iAJdqxhOI0k_feq8Uwxtj" - }, - { - "id": "7mtOYU4QDRX4K4NLvqMk3", - "type": "arrow" - }, - { - "id": "C9zNCvnFdLQJDCrQGY8nP", - "type": "arrow" - }, - { - "id": "Jy7jiHD5Z1gj-YInr76xP", - "type": "arrow" - } - ], - "updated": 1714744053943, - "link": null, - "locked": false - }, - { - "type": "text", - "version": 523, - "versionNonce": 1471947440, - "isDeleted": false, - "id": "iAJdqxhOI0k_feq8Uwxtj", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 626.1204281007166, - "y": 2542.585684448701, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 132.0963134765625, - "height": 65.553937902444, - "seed": 664022076, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053943, - "link": null, - "locked": false, - "fontSize": 26.221575160977604, - "fontFamily": 1, - "text": "CMD Done\n(161)", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "SHT8Z3GcYk1eYuTfyw4Wt", - "originalText": "CMD Done\n(161)", - "lineHeight": 1.25, - "baseline": 59 - }, - { - "type": "arrow", - "version": 411, - "versionNonce": 730898512, - "isDeleted": false, - "id": "7mtOYU4QDRX4K4NLvqMk3", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 318.0742192382472, - "y": 2478.832353262067, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 237.74212141573616, - "height": 112, - "seed": 154879164, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [ - { - "type": "text", - "id": "kCQCzgIGfsxrXb1SZe3jH" - } - ], - "updated": 1714744053943, - "link": null, - "locked": false, - "startBinding": { - "elementId": "Ur3AZBQlRtcWGMQc7cqJZ", - "focus": -0.5535205562715501, - "gap": 16.432109746380036 - }, - "endBinding": { - "elementId": "SHT8Z3GcYk1eYuTfyw4Wt", - "focus": -0.040339719106359855, - "gap": 19.40396295172644 - }, - "lastCommittedPoint": null, - "startArrowhead": null, - "endArrowhead": "arrow", - "points": [ - [ - 0, - 0 - ], - [ - 237.74212141573616, - 63.70210159886882 - ] - ] - }, - { - "type": "text", - "version": 93, - "versionNonce": 193219760, - "isDeleted": false, - "id": "kCQCzgIGfsxrXb1SZe3jH", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": -164.44798991065522, - "y": 2774.9504589649146, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 61.453125, - "height": 31.465890193173124, - "seed": 1198214460, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053943, - "link": null, - "locked": false, - "fontSize": 26.221575160977604, - "fontFamily": 3, - "text": "meas", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "7mtOYU4QDRX4K4NLvqMk3", - "originalText": "meas", - "lineHeight": 1.2, - "baseline": 26 - }, - { - "type": "arrow", - "version": 383, - "versionNonce": 389551696, - "isDeleted": false, - "id": "C9zNCvnFdLQJDCrQGY8nP", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 316.326007531653, - "y": 2618.3005360739553, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 241.238544828925, - "height": 112, - "seed": 1132873148, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [ - { - "type": "text", - "id": "eFSZKVRSOkEGvhMKxDmAh" - } - ], - "updated": 1714744053943, - "link": null, - "locked": false, - "startBinding": { - "elementId": "w8M4H0JRvxO08MbJjpNhG", - "focus": 0.11936697090636625, - "gap": 14.683898039785788 - }, - "endBinding": { - "elementId": "SHT8Z3GcYk1eYuTfyw4Wt", - "focus": 0.24613615402321784, - "gap": 17.655751245131853 - }, - "lastCommittedPoint": null, - "startArrowhead": null, - "endArrowhead": "arrow", - "points": [ - [ - 0, - 0 - ], - [ - 241.238544828925, - -40.20633522493557 - ] - ] - }, - { - "type": "text", - "version": 93, - "versionNonce": 683095728, - "isDeleted": false, - "id": "eFSZKVRSOkEGvhMKxDmAh", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": -164.44798991065505, - "y": 2862.464423364901, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 61.453125, - "height": 31.465890193173124, - "seed": 1655582268, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053943, - "link": null, - "locked": false, - "fontSize": 26.221575160977604, - "fontFamily": 3, - "text": "meas", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "C9zNCvnFdLQJDCrQGY8nP", - "originalText": "meas", - "lineHeight": 1.2, - "baseline": 26 - }, - { - "type": "arrow", - "version": 439, - "versionNonce": 1249954896, - "isDeleted": false, - "id": "Jy7jiHD5Z1gj-YInr76xP", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 737.6194218138885, - "y": 2491.972768277614, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 111.87888073063108, - "height": 902.0221588636638, - "seed": 365233852, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053943, - "link": null, - "locked": false, - "startBinding": { - "elementId": "SHT8Z3GcYk1eYuTfyw4Wt", - "focus": 0.37982535473551726, - "gap": 22.834434984926702 - }, - "endBinding": null, - "lastCommittedPoint": null, - "startArrowhead": null, - "endArrowhead": "arrow", - "points": [ - [ - 0, - 0 - ], - [ - 8.740525053659002, - -902.0221588636638 - ], - [ - -103.13835567697207, - -902.0221588636638 - ] - ] - }, - { - "type": "rectangle", - "version": 618, - "versionNonce": 872210608, - "isDeleted": false, - "id": "qSLZScUOArZiVJFz_NsGj", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 1263.5362514718886, - "y": 2242.020959187892, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 312.5615546891644, - "height": 121.11090027476531, - "seed": 1634520892, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 3 - }, - "boundElements": [ - { - "id": "s1oV_1bxxeApejlYxosK_", - "type": "arrow" - }, - { - "id": "EWVImJd5PN_hqIZKeyIS9", - "type": "arrow" - }, - { - "id": "BTXvg-RCegp3WrYRd1Fx_", - "type": "arrow" - }, - { - "type": "text", - "id": "gAXVS9hXxi3dcVkSgbUn8" - }, - { - "id": "5HnIVT4wdBSYi6xZCQtv4", - "type": "arrow" - }, - { - "id": "6BugvbGckeMPIHactOOZE", - "type": "arrow" - } - ], - "updated": 1714744053943, - "link": null, - "locked": false - }, - { - "type": "text", - "version": 659, - "versionNonce": 1061339728, - "isDeleted": false, - "id": "gAXVS9hXxi3dcVkSgbUn8", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 1350.1390503008458, - "y": 2257.5764093252747, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 139.35595703125, - "height": 90, - "seed": 1711769532, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053943, - "link": null, - "locked": false, - "fontSize": 36, - "fontFamily": 1, - "text": "wake up\ncalls 0", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "qSLZScUOArZiVJFz_NsGj", - "originalText": "wake up\ncalls 0", - "lineHeight": 1.25, - "baseline": 83 - }, - { - "type": "ellipse", - "version": 157, - "versionNonce": 1560103600, - "isDeleted": false, - "id": "y2e4ni4LWBSfKtYa3s8nT", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 1263.799136740035, - "y": 2394.0787142958543, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 139.3841404869686, - "height": 139.3841404869686, - "seed": 1740058684, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [ - { - "type": "text", - "id": "lBtEZLY2LoTkLrZHlaEBE" - } - ], - "updated": 1714744053943, - "link": null, - "locked": false - }, - { - "type": "text", - "version": 213, - "versionNonce": 1951791184, - "isDeleted": false, - "id": "lBtEZLY2LoTkLrZHlaEBE", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 1302.1294936751842, - "y": 2431.21408012402, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 63.16395568847656, - "height": 65.553937902444, - "seed": 1448986812, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053943, - "link": null, - "locked": false, - "fontSize": 26.221575160977604, - "fontFamily": 1, - "text": "buf\nclear", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "y2e4ni4LWBSfKtYa3s8nT", - "originalText": "buf\nclear", - "lineHeight": 1.25, - "baseline": 59 - }, - { - "type": "ellipse", - "version": 180, - "versionNonce": 509637808, - "isDeleted": false, - "id": "gKny8cgFf1eK8KNEfsu1X", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 1429.8691127595603, - "y": 2394.0787142958543, - "strokeColor": "#2f9e44", - "backgroundColor": "#a5d8ff", - "width": 139.3841404869686, - "height": 139.3841404869686, - "seed": 1436373308, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [ - { - "type": "text", - "id": "P5_Yz5mVJDY9sXWVbzD_n" - }, - { - "id": "L50BGCy0awqTIQHghyt9z", - "type": "arrow" - } - ], - "updated": 1714744053943, - "link": null, - "locked": false - }, - { - "type": "text", - "version": 243, - "versionNonce": 1301442128, - "isDeleted": false, - "id": "P5_Yz5mVJDY9sXWVbzD_n", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 1469.4973594041821, - "y": 2431.21408012402, - "strokeColor": "#2f9e44", - "backgroundColor": "transparent", - "width": 60.56817626953125, - "height": 65.553937902444, - "seed": 1154992572, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053943, - "link": null, - "locked": false, - "fontSize": 26.221575160977604, - "fontFamily": 1, - "text": "wake\n211", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "gKny8cgFf1eK8KNEfsu1X", - "originalText": "wake\n211", - "lineHeight": 1.25, - "baseline": 59 - }, - { - "type": "diamond", - "version": 479, - "versionNonce": 1573805744, - "isDeleted": false, - "id": "Vswn_gFvxMoxlj_jej-d8", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 1687.802065775767, - "y": 2189.0505779300256, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 234.94540946863557, - "height": 219.45825162823473, - "seed": 1194275388, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 2 - }, - "boundElements": [ - { - "id": "6BugvbGckeMPIHactOOZE", - "type": "arrow" - }, - { - "id": "qhDyQfFkqHq0kXOVvxY_b", - "type": "arrow" - }, - { - "id": "4_WZn9xeDSBDx7Mkg_hO0", - "type": "arrow" - }, - { - "type": "text", - "id": "lq7O7hIUiNEJnNgmn2SjF" - }, - { - "id": "lkSF2Cz3w84tbQRvuXG1P", - "type": "arrow" - } - ], - "updated": 1714744053943, - "link": null, - "locked": false - }, - { - "type": "text", - "version": 516, - "versionNonce": 1943020624, - "isDeleted": false, - "id": "lq7O7hIUiNEJnNgmn2SjF", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 1766.154171316754, - "y": 2266.1381718858624, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 77.76849365234375, - "height": 65.553937902444, - "seed": 1267043004, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053943, - "link": null, - "locked": false, - "fontSize": 26.221575160977604, - "fontFamily": 1, - "text": "Awake\n(210)", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "Vswn_gFvxMoxlj_jej-d8", - "originalText": "Awake\n(210)", - "lineHeight": 1.25, - "baseline": 59 - }, - { - "type": "diamond", - "version": 575, - "versionNonce": 200214704, - "isDeleted": false, - "id": "A6XONEaAFuF1YW-ZTzIXs", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 1687.802065775767, - "y": 1913.6692904253305, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 234.94540946863557, - "height": 222.88338886830962, - "seed": 343724860, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 2 - }, - "boundElements": [ - { - "type": "text", - "id": "zTmzZBLGTl-LJ9j4ea9lU" - }, - { - "id": "4_WZn9xeDSBDx7Mkg_hO0", - "type": "arrow" - }, - { - "id": "w48z_r3CFcohLuEU1P684", - "type": "arrow" - } - ], - "updated": 1714744053943, - "link": null, - "locked": false - }, - { - "type": "text", - "version": 632, - "versionNonce": 887560784, - "isDeleted": false, - "id": "zTmzZBLGTl-LJ9j4ea9lU", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 1771.2015269686094, - "y": 1975.7246842155746, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 67.67378234863281, - "height": 98.33090685366601, - "seed": 1081543612, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053943, - "link": null, - "locked": false, - "fontSize": 26.221575160977604, - "fontFamily": 1, - "text": "Ambit\nwake\n170", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "A6XONEaAFuF1YW-ZTzIXs", - "originalText": "Ambit\nwake\n170", - "lineHeight": 1.25, - "baseline": 92 - }, - { - "type": "diamond", - "version": 620, - "versionNonce": 1147826864, - "isDeleted": false, - "id": "Dy1HFFDMmS5fyBx8k3h7k", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 1694.7949126021458, - "y": 1654.8404989423398, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 234.94540946863557, - "height": 219.45825162823473, - "seed": 1368798268, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 2 - }, - "boundElements": [ - { - "type": "text", - "id": "cMv-xGTbgpxOxQUClVR73" - }, - { - "id": "Lbhp_UFrpA9qz0Sjh3F_X", - "type": "arrow" - }, - { - "id": "OVXw14xqvamX9AQXfYgcc", - "type": "arrow" - }, - { - "id": "fNlhld2BS4snfpZ0Sn2La", - "type": "arrow" - } - ], - "updated": 1714744053943, - "link": null, - "locked": false - }, - { - "type": "text", - "version": 676, - "versionNonce": 1672433744, - "isDeleted": false, - "id": "cMv-xGTbgpxOxQUClVR73", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 1774.1565091099296, - "y": 1731.9280928981764, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 75.74951171875, - "height": 65.553937902444, - "seed": 901532860, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053943, - "link": null, - "locked": false, - "fontSize": 26.221575160977604, - "fontFamily": 1, - "text": "Reset\n(222)", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "Dy1HFFDMmS5fyBx8k3h7k", - "originalText": "Reset\n(222)", - "lineHeight": 1.25, - "baseline": 59 - }, - { - "type": "rectangle", - "version": 697, - "versionNonce": 1843961008, - "isDeleted": false, - "id": "kcrgX4XIE6URlJf9Ew8_e", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 2037.9465578343684, - "y": 2242.020959187892, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 312.5615546891644, - "height": 121.11090027476531, - "seed": 1317754172, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 3 - }, - "boundElements": [ - { - "id": "s1oV_1bxxeApejlYxosK_", - "type": "arrow" - }, - { - "id": "EWVImJd5PN_hqIZKeyIS9", - "type": "arrow" - }, - { - "id": "BTXvg-RCegp3WrYRd1Fx_", - "type": "arrow" - }, - { - "id": "qhDyQfFkqHq0kXOVvxY_b", - "type": "arrow" - }, - { - "type": "text", - "id": "ue0buZG8YRti9qmUTlH-R" - }, - { - "id": "rva0j4f5-xA3KLWub0fg7", - "type": "arrow" - } - ], - "updated": 1714744053943, - "link": null, - "locked": false - }, - { - "type": "text", - "version": 762, - "versionNonce": 939574864, - "isDeleted": false, - "id": "ue0buZG8YRti9qmUTlH-R", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 2055.8253881574665, - "y": 2257.5764093252747, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 276.80389404296875, - "height": 90, - "seed": 2036682172, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053943, - "link": null, - "locked": false, - "fontSize": 36, - "fontFamily": 1, - "text": "send length info\n1", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "kcrgX4XIE6URlJf9Ew8_e", - "originalText": "send length info\n1", - "lineHeight": 1.25, - "baseline": 83 - }, - { - "type": "rectangle", - "version": 765, - "versionNonce": 1511098032, - "isDeleted": false, - "id": "gAmwiSt1Yl0N5qJUv0p_Z", - "fillStyle": "cross-hatch", - "strokeWidth": 2, - "strokeStyle": "dotted", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 2824.561089604326, - "y": 1493.0945953942132, - "strokeColor": "#e03131", - "backgroundColor": "#ffec99", - "width": 1350.0003051757808, - "height": 1246.666755676269, - "seed": 466529531, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 3 - }, - "boundElements": [], - "updated": 1714744053943, - "link": null, - "locked": false - }, - { - "type": "arrow", - "version": 346, - "versionNonce": 783514704, - "isDeleted": false, - "id": "5HnIVT4wdBSYi6xZCQtv4", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 1113.4619991212344, - "y": 2296.6491874253315, - "strokeColor": "#1e1e1e", - "backgroundColor": "#a5d8ff", - "width": 138.1004558916087, - "height": 1.2838179651874806, - "seed": 392967740, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 2 - }, - "boundElements": [], - "updated": 1714744053943, - "link": null, - "locked": false, - "startBinding": { - "elementId": "TAfAwbMTEgK3giBptpu7a", - "focus": 0.029980568922257398, - "gap": 25.085784367986207 - }, - "endBinding": { - "elementId": "qSLZScUOArZiVJFz_NsGj", - "focus": 0.049658941415414874, - "gap": 11.973796459045388 - }, - "lastCommittedPoint": null, - "startArrowhead": null, - "endArrowhead": "arrow", - "points": [ - [ - 0, - 0 - ], - [ - 138.1004558916087, - 1.2838179651874806 - ] - ] - }, - { - "type": "arrow", - "version": 344, - "versionNonce": 1703751856, - "isDeleted": false, - "id": "6BugvbGckeMPIHactOOZE", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 1599.4352454526174, - "y": 2314.037565768769, - "strokeColor": "#1e1e1e", - "backgroundColor": "#a5d8ff", - "width": 80.35548509632035, - "height": 3.9215436107445356, - "seed": 360844988, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 2 - }, - "boundElements": [], - "updated": 1714744053943, - "link": null, - "locked": false, - "startBinding": { - "elementId": "qSLZScUOArZiVJFz_NsGj", - "focus": 0.2966598891762295, - "gap": 23.33743929156435 - }, - "endBinding": { - "elementId": "Vswn_gFvxMoxlj_jej-d8", - "focus": -0.04750234949950599, - "gap": 13.753003304900218 - }, - "lastCommittedPoint": null, - "startArrowhead": null, - "endArrowhead": "arrow", - "points": [ - [ - 0, - 0 - ], - [ - 80.35548509632035, - -3.9215436107445356 - ] - ] - }, - { - "type": "arrow", - "version": 354, - "versionNonce": 1772057168, - "isDeleted": false, - "id": "qhDyQfFkqHq0kXOVvxY_b", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 1933.015906326351, - "y": 2301.744795169394, - "strokeColor": "#1e1e1e", - "backgroundColor": "#a5d8ff", - "width": 91.20891008203469, - "height": 1.3562021069867687, - "seed": 1950930748, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 2 - }, - "boundElements": [], - "updated": 1714744053944, - "link": null, - "locked": false, - "startBinding": { - "elementId": "Vswn_gFvxMoxlj_jej-d8", - "focus": 0.009711960318178375, - "gap": 9.176175869011061 - }, - "endBinding": { - "elementId": "kcrgX4XIE6URlJf9Ew8_e", - "focus": -0.04854365024789139, - "gap": 13.721741425983055 - }, - "lastCommittedPoint": null, - "startArrowhead": null, - "endArrowhead": "arrow", - "points": [ - [ - 0, - 0 - ], - [ - 91.20891008203469, - 1.3562021069867687 - ] - ] - }, - { - "type": "arrow", - "version": 362, - "versionNonce": 402889392, - "isDeleted": false, - "id": "4_WZn9xeDSBDx7Mkg_hO0", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 1802.470830749241, - "y": 2189.3116969104212, - "strokeColor": "#1e1e1e", - "backgroundColor": "#a5d8ff", - "width": 3.541252778497889, - "height": 46.76052119185137, - "seed": 1344442300, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 2 - }, - "boundElements": [], - "updated": 1714744053944, - "link": null, - "locked": false, - "startBinding": { - "elementId": "Vswn_gFvxMoxlj_jej-d8", - "focus": 0.046702390998293965, - "gap": 1.7231777265871244 - }, - "endBinding": { - "elementId": "A6XONEaAFuF1YW-ZTzIXs", - "focus": 0.12972490421438407, - "gap": 8.718821959924895 - }, - "lastCommittedPoint": null, - "startArrowhead": null, - "endArrowhead": "arrow", - "points": [ - [ - 0, - 0 - ], - [ - -3.541252778497889, - -46.76052119185137 - ] - ] - }, - { - "type": "arrow", - "version": 576, - "versionNonce": 261924944, - "isDeleted": false, - "id": "w48z_r3CFcohLuEU1P684", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 1678.210617877989, - "y": 2026.024876345019, - "strokeColor": "#1e1e1e", - "backgroundColor": "#a5d8ff", - "width": 183.66140632962447, - "height": 2.5164180489332466, - "seed": 1764833340, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 2 - }, - "boundElements": [], - "updated": 1714744053944, - "link": null, - "locked": false, - "startBinding": { - "elementId": "A6XONEaAFuF1YW-ZTzIXs", - "focus": -0.023822753611799197, - "gap": 9.634888189445448 - }, - "endBinding": { - "elementId": "_xAS16LWhNy5Gw6c3Abgu", - "focus": -0.48212803665819465, - "gap": 26.571011077067737 - }, - "lastCommittedPoint": null, - "startArrowhead": null, - "endArrowhead": "arrow", - "points": [ - [ - 0, - 0 - ], - [ - -183.66140632962447, - -2.5164180489332466 - ] - ] - }, - { - "type": "arrow", - "version": 229, - "versionNonce": 1142736048, - "isDeleted": false, - "id": "Lbhp_UFrpA9qz0Sjh3F_X", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 1803.9634783603115, - "y": 1919.0585317812183, - "strokeColor": "#1e1e1e", - "backgroundColor": "#a5d8ff", - "width": 5.103656499848702, - "height": 40.81884762541737, - "seed": 727109820, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 2 - }, - "boundElements": [], - "updated": 1714744053944, - "link": null, - "locked": false, - "startBinding": null, - "endBinding": { - "elementId": "Dy1HFFDMmS5fyBx8k3h7k", - "focus": -0.09374004509086609, - "gap": 5.064647792888465 - }, - "lastCommittedPoint": null, - "startArrowhead": null, - "endArrowhead": "arrow", - "points": [ - [ - 0, - 0 - ], - [ - 5.103656499848702, - -40.81884762541737 - ] - ] - }, - { - "type": "arrow", - "version": 397, - "versionNonce": 746790480, - "isDeleted": false, - "id": "ksZH5o4yNx8HLY0yxGFbD", - "fillStyle": "hachure", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 1265.9543940254225, - "y": 1982.755085231943, - "strokeColor": "#1e1e1e", - "backgroundColor": "#ffc9c9", - "width": 514.3500787777475, - "height": 387.56034083506404, - "seed": 1466251836, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 2 - }, - "boundElements": [], - "updated": 1714744053944, - "link": null, - "locked": false, - "startBinding": { - "elementId": "r8QgYWHtt1ERGS9dITEB-", - "focus": -1.1187841319912741, - "gap": 17.702114966580893 - }, - "endBinding": null, - "lastCommittedPoint": null, - "startArrowhead": null, - "endArrowhead": "arrow", - "points": [ - [ - 0, - 0 - ], - [ - -514.3500787777475, - -387.56034083506404 - ] - ] - }, - { - "type": "arrow", - "version": 387, - "versionNonce": 662744752, - "isDeleted": false, - "id": "OVXw14xqvamX9AQXfYgcc", - "fillStyle": "hachure", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 1691.2884221676595, - "y": 1764.9041793277192, - "strokeColor": "#1e1e1e", - "backgroundColor": "#ffc9c9", - "width": 518.3906926377496, - "height": 518.7228077829324, - "seed": 2008715964, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053944, - "link": null, - "locked": false, - "startBinding": { - "elementId": "Dy1HFFDMmS5fyBx8k3h7k", - "focus": -0.01723764136291547, - "gap": 2.638053944030233 - }, - "endBinding": null, - "lastCommittedPoint": null, - "startArrowhead": null, - "endArrowhead": "arrow", - "points": [ - [ - 0, - 0 - ], - [ - -518.3906926377496, - -6.671321870813335 - ], - [ - -514.8942692245607, - 512.051485912119 - ] - ] - }, - { - "type": "diamond", - "version": 679, - "versionNonce": 288019536, - "isDeleted": false, - "id": "N_kTAn2ip0eQE6iXbIrQv", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 1982.3577334101178, - "y": 2377.354304565746, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 156.28081735553135, - "height": 157.34578876980638, - "seed": 80796476, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 2 - }, - "boundElements": [ - { - "type": "text", - "id": "Kc42nuulcX904ruXDYBVk" - }, - { - "id": "meH7fxdoDWONFZedxAMC9", - "type": "arrow" - } - ], - "updated": 1714744053944, - "link": null, - "locked": false - }, - { - "type": "text", - "version": 776, - "versionNonce": 181885104, - "isDeleted": false, - "id": "Kc42nuulcX904ruXDYBVk", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 2029.3294422656022, - "y": 2429.96917659722, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 62.196990966796875, - "height": 52.443150321955216, - "seed": 420090812, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053944, - "link": null, - "locked": false, - "fontSize": 20.977260128782085, - "fontFamily": 1, - "text": "Awake\n(210)", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "N_kTAn2ip0eQE6iXbIrQv", - "originalText": "Awake\n(210)", - "lineHeight": 1.25, - "baseline": 47 - }, - { - "type": "ellipse", - "version": 278, - "versionNonce": 862702160, - "isDeleted": false, - "id": "3ZsaM9HAI9xyZdhjU5G6O", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 2289.6289107200214, - "y": 2387.4120984918172, - "strokeColor": "#2f9e44", - "backgroundColor": "#a5d8ff", - "width": 139.3841404869686, - "height": 139.3841404869686, - "seed": 847789116, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [ - { - "type": "text", - "id": "MzwMYkNhdgHEUHpWZZ5zF" - }, - { - "id": "SPFSlS5fEkc_qQBkM9eLq", - "type": "arrow" - } - ], - "updated": 1714744053944, - "link": null, - "locked": false - }, - { - "type": "text", - "version": 373, - "versionNonce": 1640546992, - "isDeleted": false, - "id": "MzwMYkNhdgHEUHpWZZ5zF", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 2322.348198929584, - "y": 2424.5474643199827, - "strokeColor": "#2f9e44", - "backgroundColor": "transparent", - "width": 74.38609313964844, - "height": 65.553937902444, - "seed": 992826556, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053944, - "link": null, - "locked": false, - "fontSize": 26.221575160977604, - "fontFamily": 1, - "text": "length\n212", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "3ZsaM9HAI9xyZdhjU5G6O", - "originalText": "length\n212", - "lineHeight": 1.25, - "baseline": 59 - }, - { - "type": "diamond", - "version": 508, - "versionNonce": 236847184, - "isDeleted": false, - "id": "k4wYSdGSsCo2g1t0Te4BW", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 2462.2125055080755, - "y": 2189.0505779300256, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 234.94540946863557, - "height": 222.88338886830962, - "seed": 278617404, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 2 - }, - "boundElements": [ - { - "id": "6BugvbGckeMPIHactOOZE", - "type": "arrow" - }, - { - "id": "qhDyQfFkqHq0kXOVvxY_b", - "type": "arrow" - }, - { - "id": "4_WZn9xeDSBDx7Mkg_hO0", - "type": "arrow" - }, - { - "type": "text", - "id": "tNGUuAf_S3eZboOy3I-iT" - }, - { - "id": "CMoLNeKsWZqOByiv7kqiN", - "type": "arrow" - }, - { - "id": "rva0j4f5-xA3KLWub0fg7", - "type": "arrow" - }, - { - "id": "KgnwsuNsjv2jMGhxXrA0g", - "type": "arrow" - }, - { - "id": "U2EvPXeHbkdhv1IajJrxn", - "type": "arrow" - } - ], - "updated": 1714744053944, - "link": null, - "locked": false - }, - { - "type": "text", - "version": 555, - "versionNonce": 1794960560, - "isDeleted": false, - "id": "tNGUuAf_S3eZboOy3I-iT", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 2544.2878547624414, - "y": 2251.1059717202697, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 70.32200622558594, - "height": 98.33090685366601, - "seed": 204756412, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053944, - "link": null, - "locked": false, - "fontSize": 26.221575160977604, - "fontFamily": 1, - "text": "Data\nready\n200", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "k4wYSdGSsCo2g1t0Te4BW", - "originalText": "Data\nready\n200", - "lineHeight": 1.25, - "baseline": 92 - }, - { - "type": "diamond", - "version": 538, - "versionNonce": 18445904, - "isDeleted": false, - "id": "34chdPI9dxnIxbtR92YBx", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 2462.2125055080755, - "y": 1914.1337508516517, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 234.94540946863557, - "height": 222.88338886830962, - "seed": 186269244, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 2 - }, - "boundElements": [ - { - "id": "6BugvbGckeMPIHactOOZE", - "type": "arrow" - }, - { - "id": "qhDyQfFkqHq0kXOVvxY_b", - "type": "arrow" - }, - { - "id": "4_WZn9xeDSBDx7Mkg_hO0", - "type": "arrow" - }, - { - "type": "text", - "id": "C4ffhyqmxNXcwVJ9Fa1SE" - }, - { - "id": "lkSF2Cz3w84tbQRvuXG1P", - "type": "arrow" - }, - { - "id": "KgnwsuNsjv2jMGhxXrA0g", - "type": "arrow" - } - ], - "updated": 1714744053944, - "link": null, - "locked": false - }, - { - "type": "text", - "version": 592, - "versionNonce": 1344001712, - "isDeleted": false, - "id": "C4ffhyqmxNXcwVJ9Fa1SE", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 2540.5646110490625, - "y": 1992.577629117507, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 77.76849365234375, - "height": 65.553937902444, - "seed": 1982797500, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053944, - "link": null, - "locked": false, - "fontSize": 26.221575160977604, - "fontFamily": 1, - "text": "Awake\n(210)", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "34chdPI9dxnIxbtR92YBx", - "originalText": "Awake\n(210)", - "lineHeight": 1.25, - "baseline": 59 - }, - { - "type": "diamond", - "version": 659, - "versionNonce": 825633872, - "isDeleted": false, - "id": "WE37nkuHKBGUDppwGsS5u", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 2465.708395441952, - "y": 1650.5250180723979, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 234.94540946863557, - "height": 202.31586085689204, - "seed": 1242881852, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 2 - }, - "boundElements": [ - { - "type": "text", - "id": "b1SGoGCgXHnm0iAPk63bd" - }, - { - "id": "6BugvbGckeMPIHactOOZE", - "type": "arrow" - }, - { - "id": "qhDyQfFkqHq0kXOVvxY_b", - "type": "arrow" - }, - { - "id": "4_WZn9xeDSBDx7Mkg_hO0", - "type": "arrow" - }, - { - "id": "yU4-Ia2xMJoY7ELd6lx_h", - "type": "arrow" - }, - { - "id": "RUnPrOD-VXiYiCxnrfXqG", - "type": "arrow" - } - ], - "updated": 1714744053944, - "link": null, - "locked": false - }, - { - "type": "text", - "version": 716, - "versionNonce": 1171095728, - "isDeleted": false, - "id": "b1SGoGCgXHnm0iAPk63bd", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 2545.0699919497356, - "y": 1718.8270143353989, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 75.74951171875, - "height": 65.553937902444, - "seed": 523081660, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053944, - "link": null, - "locked": false, - "fontSize": 26.221575160977604, - "fontFamily": 1, - "text": "Reset\n(222)", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "WE37nkuHKBGUDppwGsS5u", - "originalText": "Reset\n(222)", - "lineHeight": 1.25, - "baseline": 59 - }, - { - "type": "arrow", - "version": 740, - "versionNonce": 1749819984, - "isDeleted": false, - "id": "lkSF2Cz3w84tbQRvuXG1P", - "fillStyle": "hachure", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 2454.258889114109, - "y": 2026.9767287270824, - "strokeColor": "#1e1e1e", - "backgroundColor": "#ffc9c9", - "width": 557.9883641971126, - "height": 228.53008413746977, - "seed": 832258108, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053944, - "link": null, - "locked": false, - "startBinding": { - "elementId": "34chdPI9dxnIxbtR92YBx", - "focus": -0.01777290911946115, - "gap": 6.490593978475275 - }, - "endBinding": { - "elementId": "Vswn_gFvxMoxlj_jej-d8", - "focus": 0.6407492940644685, - "gap": 15.166454499261874 - }, - "lastCommittedPoint": null, - "startArrowhead": null, - "endArrowhead": "arrow", - "points": [ - [ - 0, - 0 - ], - [ - -478.9809329843176, - -2.212472078173153 - ], - [ - -557.9883641971126, - 226.3176120592966 - ] - ] - }, - { - "type": "arrow", - "version": 362, - "versionNonce": 733604528, - "isDeleted": false, - "id": "rva0j4f5-xA3KLWub0fg7", - "fillStyle": "hachure", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 2368.601716914283, - "y": 2301.8935558054563, - "strokeColor": "#1e1e1e", - "backgroundColor": "#ffc9c9", - "width": 76.91651377633869, - "height": 1.7480783367662225, - "seed": 1765791932, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053944, - "link": null, - "locked": false, - "startBinding": { - "elementId": "kcrgX4XIE6URlJf9Ew8_e", - "focus": 0.051166542257359934, - "gap": 18.09360439074976 - }, - "endBinding": { - "elementId": "k4wYSdGSsCo2g1t0Te4BW", - "focus": 0.030473353352103227, - "gap": 11.741235840797415 - }, - "lastCommittedPoint": null, - "startArrowhead": null, - "endArrowhead": "arrow", - "points": [ - [ - 0, - 0 - ], - [ - 76.91651377633869, - -1.7480783367662225 - ] - ] - }, - { - "type": "arrow", - "version": 288, - "versionNonce": 1966299216, - "isDeleted": false, - "id": "KgnwsuNsjv2jMGhxXrA0g", - "fillStyle": "hachure", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 2585.3666315491687, - "y": 2179.526205054228, - "strokeColor": "#1e1e1e", - "backgroundColor": "#ffc9c9", - "width": 0, - "height": 41.95448024661574, - "seed": 1639801148, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053944, - "link": null, - "locked": false, - "startBinding": { - "elementId": "k4wYSdGSsCo2g1t0Te4BW", - "focus": 0.04836375666691641, - "gap": 10.819958053979562 - }, - "endBinding": { - "elementId": "34chdPI9dxnIxbtR92YBx", - "focus": -0.04836375666691641, - "gap": 4.312515406365563 - }, - "lastCommittedPoint": null, - "startArrowhead": null, - "endArrowhead": "arrow", - "points": [ - [ - 0, - 0 - ], - [ - 0, - -41.95448024661574 - ] - ] - }, - { - "type": "arrow", - "version": 235, - "versionNonce": 747181232, - "isDeleted": false, - "id": "yU4-Ia2xMJoY7ELd6lx_h", - "fillStyle": "hachure", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 2578.374318202105, - "y": 1915.5623751076855, - "strokeColor": "#1e1e1e", - "backgroundColor": "#ffc9c9", - "width": 1.7479449669377358, - "height": 54.655622400128294, - "seed": 1920326076, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053944, - "link": null, - "locked": false, - "startBinding": null, - "endBinding": { - "elementId": "WE37nkuHKBGUDppwGsS5u", - "focus": -0.003696658593138085, - "gap": 8.108016770816732 - }, - "lastCommittedPoint": null, - "startArrowhead": null, - "endArrowhead": "arrow", - "points": [ - [ - 0, - 0 - ], - [ - 1.7479449669377358, - -54.655622400128294 - ] - ] - }, - { - "type": "arrow", - "version": 649, - "versionNonce": 197381712, - "isDeleted": false, - "id": "RUnPrOD-VXiYiCxnrfXqG", - "fillStyle": "hachure", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 2452.5108107773426, - "y": 1759.9810024785875, - "strokeColor": "#1e1e1e", - "backgroundColor": "#ffc9c9", - "width": 1272.2421494841942, - "height": 164.32186434030154, - "seed": 915096124, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053944, - "link": null, - "locked": false, - "startBinding": { - "elementId": "WE37nkuHKBGUDppwGsS5u", - "focus": -0.05142061028716597, - "gap": 14.899755456221797 - }, - "endBinding": null, - "lastCommittedPoint": null, - "startArrowhead": null, - "endArrowhead": "arrow", - "points": [ - [ - 0, - 0 - ], - [ - -368.8502639602806, - 8.740525053659152 - ], - [ - -360.1097389066216, - -152.0851159281959 - ], - [ - -854.8235102916636, - -155.5813392866424 - ], - [ - -1272.2421494841942, - -8.352795886928106 - ] - ] - }, - { - "type": "rectangle", - "version": 821, - "versionNonce": 1575157424, - "isDeleted": false, - "id": "wd7YXgtyvh01iiFDbjeH9", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 2838.5784393578283, - "y": 2246.336606770119, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 510.09747424979207, - "height": 121.11090027476531, - "seed": 350198460, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 3 - }, - "boundElements": [ - { - "type": "text", - "id": "kgw0XxlnSkZpNb_p7KodU" - }, - { - "id": "s1oV_1bxxeApejlYxosK_", - "type": "arrow" - }, - { - "id": "EWVImJd5PN_hqIZKeyIS9", - "type": "arrow" - }, - { - "id": "BTXvg-RCegp3WrYRd1Fx_", - "type": "arrow" - }, - { - "id": "qhDyQfFkqHq0kXOVvxY_b", - "type": "arrow" - }, - { - "id": "lkSF2Cz3w84tbQRvuXG1P", - "type": "arrow" - }, - { - "id": "CFu19CmnN1JxOHt6ZiolU", - "type": "arrow" - }, - { - "id": "CMoLNeKsWZqOByiv7kqiN", - "type": "arrow" - } - ], - "updated": 1714744053944, - "link": null, - "locked": false - }, - { - "type": "text", - "version": 901, - "versionNonce": 617972816, - "isDeleted": false, - "id": "kgw0XxlnSkZpNb_p7KodU", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 2966.565218169736, - "y": 2284.3920569075017, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 254.12391662597656, - "height": 45, - "seed": 1209328444, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053944, - "link": null, - "locked": false, - "fontSize": 36, - "fontFamily": 1, - "text": "send data (2)", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "wd7YXgtyvh01iiFDbjeH9", - "originalText": "send data (2)", - "lineHeight": 1.25, - "baseline": 38 - }, - { - "type": "diamond", - "version": 703, - "versionNonce": 1617930416, - "isDeleted": false, - "id": "CJVOPFdInQ7GHYiRl2bPN", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 2817.514862276306, - "y": 2397.9764808642212, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 156.28081735553135, - "height": 157.34578876980638, - "seed": 1720523708, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 2 - }, - "boundElements": [ - { - "type": "text", - "id": "SihYnjDpcrRVcWISADJ71" - }, - { - "id": "38p8yj5Uhz8GhXiRADMtD", - "type": "arrow" - } - ], - "updated": 1714744053944, - "link": null, - "locked": false - }, - { - "type": "text", - "version": 812, - "versionNonce": 1581283920, - "isDeleted": false, - "id": "SihYnjDpcrRVcWISADJ71", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 2864.8640430556184, - "y": 2450.5913528956953, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 61.442047119140625, - "height": 52.443150321955216, - "seed": 1785349180, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053944, - "link": null, - "locked": false, - "fontSize": 20.977260128782085, - "fontFamily": 1, - "text": "Ready\n200", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "CJVOPFdInQ7GHYiRl2bPN", - "originalText": "Ready\n200", - "lineHeight": 1.25, - "baseline": 47 - }, - { - "type": "arrow", - "version": 350, - "versionNonce": 2144801456, - "isDeleted": false, - "id": "meH7fxdoDWONFZedxAMC9", - "fillStyle": "hachure", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 2067.92757504651, - "y": 2548.3763356446816, - "strokeColor": "#1e1e1e", - "backgroundColor": "#ffc9c9", - "width": 886.2893204629399, - "height": 304.1702985413057, - "seed": 965631164, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053944, - "link": null, - "locked": false, - "startBinding": { - "elementId": "N_kTAn2ip0eQE6iXbIrQv", - "focus": 0.00550407107670552, - "gap": 14.90888094252869 - }, - "endBinding": null, - "lastCommittedPoint": null, - "startArrowhead": null, - "endArrowhead": "arrow", - "points": [ - [ - 0, - 0 - ], - [ - 6.992446716893377, - 82.16101552629344 - ], - [ - -879.2968737460466, - 78.66472548293281 - ], - [ - -877.5486620394524, - -222.00928301501224 - ] - ] - }, - { - "type": "arrow", - "version": 361, - "versionNonce": 1524412496, - "isDeleted": false, - "id": "38p8yj5Uhz8GhXiRADMtD", - "fillStyle": "hachure", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 2814.3684946509034, - "y": 2490.22455657102, - "strokeColor": "#1e1e1e", - "backgroundColor": "#ffc9c9", - "width": 725.4637128235424, - "height": 139.38400711714024, - "seed": 765158716, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053944, - "link": null, - "locked": false, - "startBinding": { - "elementId": "CJVOPFdInQ7GHYiRl2bPN", - "focus": 0.025962199840136233, - "gap": 11.798812015943149 - }, - "endBinding": null, - "lastCommittedPoint": null, - "startArrowhead": null, - "endArrowhead": "arrow", - "points": [ - [ - 0, - 0 - ], - [ - -725.4637128235424, - 139.38400711714024 - ] - ] - }, - { - "type": "ellipse", - "version": 242, - "versionNonce": 1388395696, - "isDeleted": false, - "id": "OkLwDHyZTul2qE2aBhHEy", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 2989.411125909877, - "y": 2409.142436269056, - "strokeColor": "#2f9e44", - "backgroundColor": "#a5d8ff", - "width": 139.3841404869686, - "height": 139.3841404869686, - "seed": 468934076, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [ - { - "type": "text", - "id": "-Pw65CXy3gpCSlR4FtT51" - }, - { - "id": "gyPcyFeW-J2407VPWQOUM", - "type": "arrow" - }, - { - "id": "bLoyDI7x4qG_GKX6CeMT3", - "type": "arrow" - } - ], - "updated": 1714744053944, - "link": null, - "locked": false - }, - { - "type": "text", - "version": 341, - "versionNonce": 578954832, - "isDeleted": false, - "id": "-Pw65CXy3gpCSlR4FtT51", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 3026.9679919392643, - "y": 2462.666286572832, - "strokeColor": "#2f9e44", - "backgroundColor": "transparent", - "width": 64.7109375, - "height": 32.776968951222, - "seed": 1572357692, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053944, - "link": null, - "locked": false, - "fontSize": 26.221575160977604, - "fontFamily": 1, - "text": "data", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "OkLwDHyZTul2qE2aBhHEy", - "originalText": "data", - "lineHeight": 1.25, - "baseline": 26 - }, - { - "type": "ellipse", - "version": 297, - "versionNonce": 1523984048, - "isDeleted": false, - "id": "ZIqLdTRRThlw8lHcE4onP", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 3141.4962084956146, - "y": 2402.9694137759416, - "strokeColor": "#2f9e44", - "backgroundColor": "#a5d8ff", - "width": 177.84266411479416, - "height": 157.32945096586562, - "seed": 1472995004, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [ - { - "type": "text", - "id": "Deda_sUeSYuIMRJ5U1KIy" - }, - { - "id": "ObbXkkUi4RX8Luqzn8JMg", - "type": "arrow" - } - ], - "updated": 1714744053944, - "link": null, - "locked": false - }, - { - "type": "text", - "version": 438, - "versionNonce": 34135120, - "isDeleted": false, - "id": "Deda_sUeSYuIMRJ5U1KIy", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 3174.4823293124996, - "y": 2448.7328094784925, - "strokeColor": "#2f9e44", - "backgroundColor": "transparent", - "width": 112.11666870117188, - "height": 65.553937902444, - "seed": 47245116, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053944, - "link": null, - "locked": false, - "fontSize": 26.221575160977604, - "fontFamily": 1, - "text": "checksum\n212", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "ZIqLdTRRThlw8lHcE4onP", - "originalText": "checksum\n212", - "lineHeight": 1.25, - "baseline": 59 - }, - { - "type": "diamond", - "version": 547, - "versionNonce": 616419504, - "isDeleted": false, - "id": "8rA9xpm9xmRmEM21VM0lU", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 3446.395679898031, - "y": 2200.8229992856377, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 234.94540946863557, - "height": 222.88338886830962, - "seed": 1932042172, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 2 - }, - "boundElements": [ - { - "id": "6BugvbGckeMPIHactOOZE", - "type": "arrow" - }, - { - "id": "qhDyQfFkqHq0kXOVvxY_b", - "type": "arrow" - }, - { - "id": "4_WZn9xeDSBDx7Mkg_hO0", - "type": "arrow" - }, - { - "type": "text", - "id": "QNsPWLwVwhzn49ygKxv5a" - }, - { - "id": "CFu19CmnN1JxOHt6ZiolU", - "type": "arrow" - }, - { - "id": "8CEtBqAZieSjbWOmO_PSg", - "type": "arrow" - }, - { - "id": "DB3e9gtzmMSohg8hJcoZI", - "type": "arrow" - }, - { - "id": "-3xsQ8CUpzKqR3rQuEvHY", - "type": "arrow" - } - ], - "updated": 1714744053944, - "link": null, - "locked": false - }, - { - "type": "text", - "version": 611, - "versionNonce": 1799934544, - "isDeleted": false, - "id": "QNsPWLwVwhzn49ygKxv5a", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 3531.984502663139, - "y": 2279.266877551493, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 63.29505920410156, - "height": 65.553937902444, - "seed": 1626687548, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053944, - "link": null, - "locked": false, - "fontSize": 26.221575160977604, - "fontFamily": 1, - "text": "Pass\n180", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "8rA9xpm9xmRmEM21VM0lU", - "originalText": "Pass\n180", - "lineHeight": 1.25, - "baseline": 59 - }, - { - "type": "diamond", - "version": 539, - "versionNonce": 1746942640, - "isDeleted": false, - "id": "fLrsRoZN3z9h4LDm0lB1t", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 3447.2696523815025, - "y": 1914.633654309786, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 234.94540946863557, - "height": 222.88338886830962, - "seed": 806936764, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 2 - }, - "boundElements": [ - { - "type": "text", - "id": "2W0bhnszToQz3HNbeD6Q5" - }, - { - "id": "DB3e9gtzmMSohg8hJcoZI", - "type": "arrow" - }, - { - "id": "dmIr2dlTpFl6-BrVArGX1", - "type": "arrow" - } - ], - "updated": 1714744053944, - "link": null, - "locked": false - }, - { - "type": "text", - "version": 587, - "versionNonce": 1427769424, - "isDeleted": false, - "id": "2W0bhnszToQz3HNbeD6Q5", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 3529.3450016358684, - "y": 1976.68904810003, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 70.32200622558594, - "height": 98.33090685366601, - "seed": 2016766268, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053944, - "link": null, - "locked": false, - "fontSize": 26.221575160977604, - "fontFamily": 1, - "text": "Data\nready\n200", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "fLrsRoZN3z9h4LDm0lB1t", - "originalText": "Data\nready\n200", - "lineHeight": 1.25, - "baseline": 92 - }, - { - "type": "diamond", - "version": 717, - "versionNonce": 665150640, - "isDeleted": false, - "id": "LdRxYtp-vyX2QeDnxXSrS", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 3449.017864088097, - "y": 1639.5392953189967, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 234.94540946863557, - "height": 202.31586085689204, - "seed": 212656572, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 2 - }, - "boundElements": [ - { - "type": "text", - "id": "ooWWRl3O0f9_XGRFNJqxD" - }, - { - "id": "P7nbNgM-TYS29fTy3DVih", - "type": "arrow" - }, - { - "id": "mazLiIjyU9ysfCDKZcVgX", - "type": "arrow" - }, - { - "id": "gyPcyFeW-J2407VPWQOUM", - "type": "arrow" - } - ], - "updated": 1714744053944, - "link": null, - "locked": false - }, - { - "type": "text", - "version": 765, - "versionNonce": 458522192, - "isDeleted": false, - "id": "ooWWRl3O0f9_XGRFNJqxD", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 3528.379460595881, - "y": 1707.8412915819977, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 75.74951171875, - "height": 65.553937902444, - "seed": 77679164, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053944, - "link": null, - "locked": false, - "fontSize": 26.221575160977604, - "fontFamily": 1, - "text": "Reset\n(222)", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "LdRxYtp-vyX2QeDnxXSrS", - "originalText": "Reset\n(222)", - "lineHeight": 1.25, - "baseline": 59 - }, - { - "type": "arrow", - "version": 335, - "versionNonce": 1358253744, - "isDeleted": false, - "id": "CFu19CmnN1JxOHt6ZiolU", - "fillStyle": "hachure", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 3365.0215730314326, - "y": 2315.8783825543287, - "strokeColor": "#1e1e1e", - "backgroundColor": "#ffc9c9", - "width": 73.42035710280446, - "height": 5.708495381877409, - "seed": 1123328700, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053944, - "link": null, - "locked": false, - "startBinding": { - "elementId": "wd7YXgtyvh01iiFDbjeH9", - "focus": 0.3742888204104405, - "gap": 16.34565942381232 - }, - "endBinding": { - "elementId": "8rA9xpm9xmRmEM21VM0lU", - "focus": 0.106305098963807, - "gap": 6.993826081966404 - }, - "lastCommittedPoint": null, - "startArrowhead": null, - "endArrowhead": "arrow", - "points": [ - [ - 0, - 0 - ], - [ - 73.42035710280446, - -5.708495381877409 - ] - ] - }, - { - "type": "arrow", - "version": 342, - "versionNonce": 1590703184, - "isDeleted": false, - "id": "CMoLNeKsWZqOByiv7kqiN", - "fillStyle": "hachure", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 2704.2378256268644, - "y": 2301.8935558054563, - "strokeColor": "#1e1e1e", - "backgroundColor": "#ffc9c9", - "width": 111.87861399097531, - "height": 1.2837512802733864, - "seed": 2118708028, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053945, - "link": null, - "locked": false, - "startBinding": { - "elementId": "k4wYSdGSsCo2g1t0Te4BW", - "focus": -0.00025031638454271223, - "gap": 5.889276108841742 - }, - "endBinding": { - "elementId": "wd7YXgtyvh01iiFDbjeH9", - "focus": 0.008355951359017745, - "gap": 22.46199973998864 - }, - "lastCommittedPoint": null, - "startArrowhead": null, - "endArrowhead": "arrow", - "points": [ - [ - 0, - 0 - ], - [ - 111.87861399097531, - 1.2837512802733864 - ] - ] - }, - { - "type": "rectangle", - "version": 714, - "versionNonce": 1555560624, - "isDeleted": false, - "id": "fLK6ZVR8UYtruAYgkEaKw", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 3806.1554697127326, - "y": 2258.327487904142, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 312.5615546891644, - "height": 121.11090027476531, - "seed": 1224745916, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 3 - }, - "boundElements": [ - { - "type": "text", - "id": "VdrP7iaNj0HsSEIJBGrhq" - }, - { - "id": "8CEtBqAZieSjbWOmO_PSg", - "type": "arrow" - }, - { - "id": "Aujbd37Vz68tzdcf0qX0K", - "type": "arrow" - } - ], - "updated": 1714744053945, - "link": null, - "locked": false - }, - { - "type": "text", - "version": 800, - "versionNonce": 1701128784, - "isDeleted": false, - "id": "VdrP7iaNj0HsSEIJBGrhq", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 3886.0082838004787, - "y": 2296.3829380415245, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 152.85592651367188, - "height": 45, - "seed": 423382076, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053945, - "link": null, - "locked": false, - "fontSize": 36, - "fontFamily": 1, - "text": "Complete", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "fLK6ZVR8UYtruAYgkEaKw", - "originalText": "Complete", - "lineHeight": 1.25, - "baseline": 38 - }, - { - "type": "arrow", - "version": 338, - "versionNonce": 1855283888, - "isDeleted": false, - "id": "8CEtBqAZieSjbWOmO_PSg", - "fillStyle": "hachure", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 3697.1615250704804, - "y": 2310.634080859116, - "strokeColor": "#1e1e1e", - "backgroundColor": "#ffc9c9", - "width": 87.4052505365936, - "height": 1.2837512802733864, - "seed": 1356817596, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053945, - "link": null, - "locked": false, - "startBinding": { - "elementId": "8rA9xpm9xmRmEM21VM0lU", - "focus": -0.032199218974212185, - "gap": 12.071216306949111 - }, - "endBinding": { - "elementId": "fLK6ZVR8UYtruAYgkEaKw", - "focus": 0.06925409328961642, - "gap": 21.588694105658988 - }, - "lastCommittedPoint": null, - "startArrowhead": null, - "endArrowhead": "arrow", - "points": [ - [ - 0, - 0 - ], - [ - 87.4052505365936, - 1.2837512802733864 - ] - ] - }, - { - "type": "arrow", - "version": 258, - "versionNonce": 2045468752, - "isDeleted": false, - "id": "DB3e9gtzmMSohg8hJcoZI", - "fillStyle": "hachure", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 3564.3054375589986, - "y": 2181.274350075908, - "strokeColor": "#1e1e1e", - "backgroundColor": "#ffc9c9", - "width": 0, - "height": 40.670795651256455, - "seed": 1166765372, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053945, - "link": null, - "locked": false, - "startBinding": { - "elementId": "8rA9xpm9xmRmEM21VM0lU", - "focus": 0.0037204636399393283, - "gap": 14.483040010456321 - }, - "endBinding": { - "elementId": "fLrsRoZN3z9h4LDm0lB1t", - "focus": 0.0037193283138422326, - "gap": 2.539921118278727 - }, - "lastCommittedPoint": null, - "startArrowhead": null, - "endArrowhead": "arrow", - "points": [ - [ - 0, - 0 - ], - [ - 0, - -40.670795651256455 - ] - ] - }, - { - "type": "arrow", - "version": 482, - "versionNonce": 1966443696, - "isDeleted": false, - "id": "dmIr2dlTpFl6-BrVArGX1", - "fillStyle": "hachure", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 3436.6937184276444, - "y": 2037.929725858914, - "strokeColor": "#1e1e1e", - "backgroundColor": "#ffc9c9", - "width": 654.8500208638843, - "height": 256.88986983428936, - "seed": 1218602428, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053945, - "link": null, - "locked": false, - "startBinding": { - "elementId": "fLrsRoZN3z9h4LDm0lB1t", - "focus": -0.11557471422657803, - "gap": 15.87893188155762 - }, - "endBinding": null, - "lastCommittedPoint": null, - "startArrowhead": null, - "endArrowhead": "arrow", - "points": [ - [ - 0, - 0 - ], - [ - -654.8500208638843, - -5.244301695212698 - ], - [ - -649.5240057185702, - 251.64556813907666 - ] - ] - }, - { - "type": "arrow", - "version": 282, - "versionNonce": 1278924368, - "isDeleted": false, - "id": "P7nbNgM-TYS29fTy3DVih", - "fillStyle": "hachure", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 3562.5574925920614, - "y": 1919.0585984661338, - "strokeColor": "#1e1e1e", - "backgroundColor": "#ffc9c9", - "width": 1.7479449669389282, - "height": 62.93182039729468, - "seed": 793136700, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053945, - "link": null, - "locked": false, - "startBinding": null, - "endBinding": { - "elementId": "LdRxYtp-vyX2QeDnxXSrS", - "focus": -0.008690951667154442, - "gap": 12.24040562982438 - }, - "lastCommittedPoint": null, - "startArrowhead": null, - "endArrowhead": "arrow", - "points": [ - [ - 0, - 0 - ], - [ - 1.7479449669389282, - -62.93182039729468 - ] - ] - }, - { - "type": "arrow", - "version": 319, - "versionNonce": 1245738672, - "isDeleted": false, - "id": "mazLiIjyU9ysfCDKZcVgX", - "fillStyle": "hachure", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 3431.4496167871725, - "y": 1740.7518406920462, - "strokeColor": "#1e1e1e", - "backgroundColor": "#ffc9c9", - "width": 1337.3004665796852, - "height": 129.35976412566478, - "seed": 1934121892, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053945, - "link": null, - "locked": false, - "startBinding": { - "focus": -0.12967246181941028, - "gap": 11.505130366976317, - "elementId": "LdRxYtp-vyX2QeDnxXSrS" - }, - "endBinding": null, - "lastCommittedPoint": null, - "startArrowhead": null, - "endArrowhead": "arrow", - "points": [ - [ - 0, - 0 - ], - [ - -1337.3004665796852, - -129.35976412566478 - ] - ] - }, - { - "type": "arrow", - "version": 678, - "versionNonce": 1361808464, - "isDeleted": false, - "id": "Aujbd37Vz68tzdcf0qX0K", - "fillStyle": "hachure", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 3968.117855081848, - "y": 2235.916248720727, - "strokeColor": "#1e1e1e", - "backgroundColor": "#ffc9c9", - "width": 6519.118763895883, - "height": 840.6017236318519, - "seed": 1048375100, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053945, - "link": null, - "locked": false, - "startBinding": { - "elementId": "fLK6ZVR8UYtruAYgkEaKw", - "focus": 0.03291444940185092, - "gap": 22.41123918341509 - }, - "endBinding": { - "elementId": "949o_Sk--Ld6wo2FKS2fL", - "focus": 0.3424424357386611, - "gap": 18.21441840216653 - }, - "lastCommittedPoint": null, - "startArrowhead": null, - "endArrowhead": "arrow", - "points": [ - [ - 0, - 0 - ], - [ - 5.244235010298666, - -828.6017850896292 - ], - [ - -6513.874528885584, - -840.6017236318519 - ], - [ - -6506.555695853329, - -109.5084639254269 - ] - ] - }, - { - "type": "arrow", - "version": 536, - "versionNonce": 1381900464, - "isDeleted": false, - "id": "7p9T0a-IxPmDdjBqC-0im", - "fillStyle": "hachure", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": -2431.0494403703915, - "y": 2212.9390628484234, - "strokeColor": "#1e1e1e", - "backgroundColor": "#ffc9c9", - "width": 65.55393790244402, - "height": 2.6221175051493337, - "seed": 1813227452, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053945, - "link": null, - "locked": false, - "startBinding": { - "elementId": "949o_Sk--Ld6wo2FKS2fL", - "focus": 0.03105274966501898, - "gap": 18.529917114855152 - }, - "endBinding": { - "elementId": "oojvRHlnGhZu1D9CQPzga", - "focus": -0.12230991534358376, - "gap": 24.077694044019935 - }, - "lastCommittedPoint": null, - "startArrowhead": null, - "endArrowhead": "arrow", - "points": [ - [ - 0, - 0 - ], - [ - 65.55393790244402, - 2.6221175051493337 - ] - ] - }, - { - "type": "arrow", - "version": 513, - "versionNonce": 580223568, - "isDeleted": false, - "id": "ORyDG0-MmRvrIZpmyRPlC", - "fillStyle": "hachure", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": -2087.6406571569705, - "y": 2212.6715715579994, - "strokeColor": "#1e1e1e", - "backgroundColor": "#ffc9c9", - "width": 50.944797461869896, - "height": 1.8962903214384983, - "seed": 390025276, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053945, - "link": null, - "locked": false, - "startBinding": { - "elementId": "oojvRHlnGhZu1D9CQPzga", - "focus": 0.0884902586256845, - "gap": 14.264957239387115 - }, - "endBinding": { - "elementId": "QljoeT8sSPtX_l3e_a3My", - "focus": -0.002929144863462674, - "gap": 21.3458829019188 - }, - "lastCommittedPoint": null, - "startArrowhead": null, - "endArrowhead": "arrow", - "points": [ - [ - 0, - 0 - ], - [ - 50.944797461869896, - -1.8962903214384983 - ] - ] - }, - { - "type": "arrow", - "version": 496, - "versionNonce": 490113712, - "isDeleted": false, - "id": "ZTgJCi82oC_3iuspj4sVs", - "fillStyle": "hachure", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": -1734.0238949610475, - "y": 2211.1732186979134, - "strokeColor": "#1e1e1e", - "backgroundColor": "#ffc9c9", - "width": 44.95127170453295, - "height": 0.39793746135318603, - "seed": 534898876, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053945, - "link": null, - "locked": false, - "startBinding": { - "elementId": "QljoeT8sSPtX_l3e_a3My", - "focus": 0.12520801716349567, - "gap": 12.81708816620619 - }, - "endBinding": { - "elementId": "ZVlRo5ABA2pBBSuDikef_", - "focus": -0.015339576009995734, - "gap": 12.052632752984309 - }, - "lastCommittedPoint": null, - "startArrowhead": null, - "endArrowhead": "arrow", - "points": [ - [ - 0, - 0 - ], - [ - 44.95127170453295, - -0.39793746135318603 - ] - ] - }, - { - "type": "arrow", - "version": 474, - "versionNonce": 1599125584, - "isDeleted": false, - "id": "glCxPNKW4x-VKTsz6vtbT", - "fillStyle": "hachure", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": -1554.218808142915, - "y": 2346.0270338115133, - "strokeColor": "#1e1e1e", - "backgroundColor": "#ffc9c9", - "width": 966.4523988059578, - "height": 182.80190685529828, - "seed": 1406396860, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053945, - "link": null, - "locked": false, - "startBinding": { - "elementId": "ZVlRo5ABA2pBBSuDikef_", - "focus": -0.07708710629889753, - "gap": 22.632373153893866 - }, - "endBinding": null, - "lastCommittedPoint": null, - "startArrowhead": null, - "endArrowhead": "arrow", - "points": [ - [ - 0, - 0 - ], - [ - -5.993525757336797, - 131.85710939342837 - ], - [ - -958.9605201885356, - 127.3619364961769 - ], - [ - -966.4523988059578, - -50.944797461869896 - ] - ] - }, - { - "type": "arrow", - "version": 654, - "versionNonce": 91337904, - "isDeleted": false, - "id": "XOgSlXTT9UnidMDOPb8Og", - "fillStyle": "hachure", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": -1214.3809191534424, - "y": 2330.8770033653723, - "strokeColor": "#1e1e1e", - "backgroundColor": "#ffc9c9", - "width": 321.8378584718955, - "height": 158.4926510258515, - "seed": 1638355516, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053945, - "link": null, - "locked": false, - "startBinding": { - "elementId": "5EIpXEGwnVHQ2AJv0uPo3", - "focus": 0.013419094194996711, - "gap": 11.296368033082274 - }, - "endBinding": null, - "lastCommittedPoint": null, - "startArrowhead": null, - "endArrowhead": "arrow", - "points": [ - [ - 0, - 0 - ], - [ - -3.169157500093206, - 158.4926510258515 - ], - [ - -321.8378584718955, - 152.50550795844356 - ] - ] - }, - { - "type": "arrow", - "version": 362, - "versionNonce": 188034640, - "isDeleted": false, - "id": "jYKNwDNwCT9HqtyU1cb6j", - "fillStyle": "hachure", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": -189.5943008389845, - "y": 2213.1732644742806, - "strokeColor": "#1e1e1e", - "backgroundColor": "#ffc9c9", - "width": 200.78225549331788, - "height": 2.996705720170625, - "seed": 1198322492, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053945, - "link": null, - "locked": false, - "startBinding": { - "elementId": "hCliSU94s9BGXBwt9V9Cz", - "focus": 0.13652783341717944, - "gap": 6.973477716774795 - }, - "endBinding": { - "elementId": "NbYnTiIlKnGn-vT1BgUXG", - "focus": -0.09890601847601484, - "gap": 21.94516117160569 - }, - "lastCommittedPoint": null, - "startArrowhead": null, - "endArrowhead": "arrow", - "points": [ - [ - 0, - 0 - ], - [ - 200.78225549331788, - -2.996705720170625 - ] - ] - }, - { - "type": "arrow", - "version": 355, - "versionNonce": 1527571024, - "isDeleted": false, - "id": "xIDgdoUwo4XtG0resbUs1", - "fillStyle": "solid", - "strokeWidth": 1, - "strokeStyle": "solid", - "roughness": 0, - "opacity": 100, - "angle": 0, - "x": -1764.6144487827762, - "y": 3511.2971303887534, - "strokeColor": "#e03131", - "backgroundColor": "transparent", - "width": 489.2747061718467, - "height": 1227.3857010239385, - "seed": 322643716, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 2 - }, - "boundElements": [ - { - "type": "text", - "id": "gtybl0KFWshqe39VLmwt0" - } - ], - "updated": 1714744133371, - "link": null, - "locked": false, - "startBinding": { - "elementId": "uYwEC6UHGHtBawFQ1yRXK", - "gap": 7.198465839105609, - "focus": -0.22902796241089074 - }, - "endBinding": { - "elementId": "5EIpXEGwnVHQ2AJv0uPo3", - "gap": 18.585891880479323, - "focus": 0.30026755265226734 - }, - "lastCommittedPoint": null, - "startArrowhead": null, - "endArrowhead": "triangle", - "points": [ - [ - 0, - 0 - ], - [ - 489.2747061718467, - -1227.3857010239385 - ] - ] - }, - { - "type": "text", - "version": 6, - "versionNonce": 1608092752, - "isDeleted": false, - "id": "gtybl0KFWshqe39VLmwt0", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": -1546.923087212966, - "y": 2875.104279876784, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 53.89198303222656, - "height": 45, - "seed": 508037200, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744119006, - "link": null, - "locked": false, - "fontSize": 36, - "fontFamily": 1, - "text": "170", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "xIDgdoUwo4XtG0resbUs1", - "originalText": "170", - "lineHeight": 1.25, - "baseline": 38 - }, - { - "type": "diamond", - "version": 632, - "versionNonce": 1864033360, - "isDeleted": false, - "id": "5EIpXEGwnVHQ2AJv0uPo3", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": -1327.8488544719605, - "y": 2099.7016238671436, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 234.94540946863557, - "height": 219.45825162823473, - "seed": 1739695364, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 2 - }, - "boundElements": [ - { - "type": "text", - "id": "_S8sOHWq8blm1h1sEx5FL" - }, - { - "id": "GkT7kVIBQeOtiyApJWoB5", - "type": "arrow" - }, - { - "id": "XOgSlXTT9UnidMDOPb8Og", - "type": "arrow" - }, - { - "id": "loqm_U-HBXuGevymOPovB", - "type": "arrow" - }, - { - "id": "xIDgdoUwo4XtG0resbUs1", - "type": "arrow" - } - ], - "updated": 1714744053945, - "link": null, - "locked": false - }, - { - "type": "text", - "version": 643, - "versionNonce": 1336953008, - "isDeleted": false, - "id": "_S8sOHWq8blm1h1sEx5FL", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": -1242.1124868460126, - "y": 2174.5661867742024, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 62.999969482421875, - "height": 70, - "seed": 1472095364, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053945, - "link": null, - "locked": false, - "fontSize": 28, - "fontFamily": 1, - "text": "CMD\n(170)", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "5EIpXEGwnVHQ2AJv0uPo3", - "originalText": "CMD\n(170)", - "lineHeight": 1.25, - "baseline": 64 - }, - { - "type": "arrow", - "version": 612, - "versionNonce": 2027543120, - "isDeleted": false, - "id": "GkT7kVIBQeOtiyApJWoB5", - "fillStyle": "hachure", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": -1426.2952407614466, - "y": 2218.0916328676894, - "strokeColor": "#1e1e1e", - "backgroundColor": "#ffc9c9", - "width": 81.63091741904873, - "height": 0.31509507133432635, - "seed": 673838852, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053945, - "link": null, - "locked": false, - "startBinding": { - "elementId": "ZVlRo5ABA2pBBSuDikef_", - "focus": 0.09756821397048676, - "gap": 16.685638806401826 - }, - "endBinding": { - "elementId": "5EIpXEGwnVHQ2AJv0uPo3", - "focus": -0.08652515996484812, - "gap": 19.061169403173878 - }, - "lastCommittedPoint": null, - "startArrowhead": null, - "endArrowhead": "arrow", - "points": [ - [ - 0, - 0 - ], - [ - 81.63091741904873, - 0.31509507133432635 - ] - ] - }, - { - "type": "ellipse", - "version": 274, - "versionNonce": 2114171568, - "isDeleted": false, - "id": "tJ7jGw7ATFSp-lsgemQ-N", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": -996.0676706647207, - "y": 2141.7387252141434, - "strokeColor": "#2f9e44", - "backgroundColor": "#a5d8ff", - "width": 160.38420152212487, - "height": 162.24351160477877, - "seed": 138158980, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [ - { - "type": "text", - "id": "q1oh912rgTL2L9sgr4Mf1" - }, - { - "id": "loqm_U-HBXuGevymOPovB", - "type": "arrow" - }, - { - "id": "z8rBoA7QcvEpK40GcZt3l", - "type": "arrow" - }, - { - "id": "9kzbQWa7MJj_5DR5ThIqF", - "type": "arrow" - } - ], - "updated": 1714744053945, - "link": null, - "locked": false - }, - { - "type": "text", - "version": 362, - "versionNonce": 457838672, - "isDeleted": false, - "id": "q1oh912rgTL2L9sgr4Mf1", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": -958.479987822252, - "y": 2177.107648277993, - "strokeColor": "#2f9e44", - "backgroundColor": "transparent", - "width": 84.80007934570312, - "height": 91.78217821782177, - "seed": 796201732, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053945, - "link": null, - "locked": false, - "fontSize": 36.712871287128706, - "fontFamily": 1, - "text": "wake\n128", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "tJ7jGw7ATFSp-lsgemQ-N", - "originalText": "wake\n128", - "lineHeight": 1.25, - "baseline": 83 - }, - { - "type": "arrow", - "version": 689, - "versionNonce": 576314544, - "isDeleted": false, - "id": "loqm_U-HBXuGevymOPovB", - "fillStyle": "hachure", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": -1101.1914558592762, - "y": 2222.5701808265217, - "strokeColor": "#1e1e1e", - "backgroundColor": "#ffc9c9", - "width": 81.63091741904873, - "height": 0.31509507133432635, - "seed": 1469898372, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053945, - "link": null, - "locked": false, - "startBinding": { - "elementId": "5EIpXEGwnVHQ2AJv0uPo3", - "focus": 0.11590339842350911, - "gap": 3.944580631035052 - }, - "endBinding": { - "elementId": "tJ7jGw7ATFSp-lsgemQ-N", - "focus": -0.005239228598300345, - "gap": 23.492870687665373 - }, - "lastCommittedPoint": null, - "startArrowhead": null, - "endArrowhead": "arrow", - "points": [ - [ - 0, - 0 - ], - [ - 81.63091741904873, - 0.31509507133432635 - ] - ] - }, - { - "type": "arrow", - "version": 749, - "versionNonce": 776177232, - "isDeleted": false, - "id": "z8rBoA7QcvEpK40GcZt3l", - "fillStyle": "hachure", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": -837.1915168944327, - "y": 2182.769452133614, - "strokeColor": "#1e1e1e", - "backgroundColor": "#ffc9c9", - "width": 81.63091741904873, - "height": 0.31509507133432635, - "seed": 1080590084, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053945, - "link": null, - "locked": false, - "startBinding": { - "focus": -0.49794847999276115, - "gap": 7.927550336249354, - "elementId": "tJ7jGw7ATFSp-lsgemQ-N" - }, - "endBinding": { - "focus": 0.34018933388207834, - "gap": 15.640594201247026, - "elementId": "4HG3lkfSICKQoMrMvMSOL" - }, - "lastCommittedPoint": null, - "startArrowhead": null, - "endArrowhead": "arrow", - "points": [ - [ - 0, - 0 - ], - [ - 81.63091741904873, - 0.31509507133432635 - ] - ] - }, - { - "type": "arrow", - "version": 239, - "versionNonce": 1821841072, - "isDeleted": false, - "id": "9kzbQWa7MJj_5DR5ThIqF", - "fillStyle": "solid", - "strokeWidth": 1, - "strokeStyle": "solid", - "roughness": 0, - "opacity": 100, - "angle": 0, - "x": -937.4520888181194, - "y": 2324.1819359493093, - "strokeColor": "#2f9e44", - "backgroundColor": "transparent", - "width": 552.7872994620591, - "height": 1145.3787284288592, - "seed": 1197231108, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 2 - }, - "boundElements": [ - { - "type": "text", - "id": "5goX2SHWrF5szxWrULsTJ" - } - ], - "updated": 1714744131315, - "link": null, - "locked": false, - "startBinding": { - "elementId": "tJ7jGw7ATFSp-lsgemQ-N", - "focus": -0.3061850989969431, - "gap": 22.51240484911591 - }, - "endBinding": { - "elementId": "nTdCg9YES9bcUbYEdQyta", - "focus": -0.5568391113905278, - "gap": 8.886552655038898 - }, - "lastCommittedPoint": null, - "startArrowhead": null, - "endArrowhead": "triangle", - "points": [ - [ - 0, - 0 - ], - [ - -552.7872994620591, - 1145.3787284288592 - ] - ] - }, - { - "type": "text", - "version": 4, - "versionNonce": 354861136, - "isDeleted": false, - "id": "5goX2SHWrF5szxWrULsTJ", - "fillStyle": "solid", - "strokeWidth": 1, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": -1245.3097278069613, - "y": 2874.371300163739, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 62.927978515625, - "height": 45, - "seed": 1307499184, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744129957, - "link": null, - "locked": false, - "fontSize": 36, - "fontFamily": 1, - "text": "128", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "9kzbQWa7MJj_5DR5ThIqF", - "originalText": "128", - "lineHeight": 1.25, - "baseline": 38 - }, - { - "type": "arrow", - "version": 354, - "versionNonce": 125855408, - "isDeleted": false, - "id": "t2mJ36gZcTfYuLR0nvMGj", - "fillStyle": "solid", - "strokeWidth": 1, - "strokeStyle": "solid", - "roughness": 0, - "opacity": 100, - "angle": 0, - "x": -1164.5690481075685, - "y": 3492.775508481896, - "strokeColor": "#e03131", - "backgroundColor": "transparent", - "width": 455.9462874412552, - "height": 1178.1947013396725, - "seed": 473248038, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 2 - }, - "boundElements": [ - { - "type": "text", - "id": "XiVZdOHhCQ3Yu2DPnpc4P" - } - ], - "updated": 1714744269767, - "link": null, - "locked": false, - "startBinding": { - "elementId": "IyEMitLQCn9ktYumohw1w", - "gap": 20.604103413635933, - "focus": -0.02650605165516595 - }, - "endBinding": { - "elementId": "4HG3lkfSICKQoMrMvMSOL", - "gap": 24.57298092007626, - "focus": 0.14283553907316254 - }, - "lastCommittedPoint": null, - "startArrowhead": null, - "endArrowhead": "triangle", - "points": [ - [ - 0, - 0 - ], - [ - 455.9462874412552, - -1178.1947013396725 - ] - ] - }, - { - "type": "text", - "version": 7, - "versionNonce": 1550217296, - "isDeleted": false, - "id": "XiVZdOHhCQ3Yu2DPnpc4P", - "fillStyle": "solid", - "strokeWidth": 1, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": -990.4698820480737, - "y": 2881.17815781206, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 107.74795532226562, - "height": 45, - "seed": 1982803120, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744269144, - "link": null, - "locked": false, - "fontSize": 36, - "fontFamily": 1, - "text": "160-21", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "t2mJ36gZcTfYuLR0nvMGj", - "originalText": "160-21", - "lineHeight": 1.25, - "baseline": 38 - }, - { - "type": "arrow", - "version": 808, - "versionNonce": 514748592, - "isDeleted": false, - "id": "ek9xtHVfDe-Hf4jNvTJNN", - "fillStyle": "hachure", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": -560.1913948241202, - "y": 2166.7695436863482, - "strokeColor": "#1e1e1e", - "backgroundColor": "#ffc9c9", - "width": 81.63091741904873, - "height": 0.31509507133432635, - "seed": 1832311428, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053945, - "link": null, - "locked": false, - "startBinding": { - "elementId": "4HG3lkfSICKQoMrMvMSOL", - "focus": -0.49574628264975046, - "gap": 24.389481639407776 - }, - "endBinding": { - "elementId": "hCliSU94s9BGXBwt9V9Cz", - "focus": 0.6448940097529402, - "gap": 13.48370518338399 - }, - "lastCommittedPoint": null, - "startArrowhead": null, - "endArrowhead": "arrow", - "points": [ - [ - 0, - 0 - ], - [ - 81.63091741904873, - 0.31509507133432635 - ] - ] - }, - { - "type": "arrow", - "version": 317, - "versionNonce": 1088876112, - "isDeleted": false, - "id": "0ov9dJFlVufiTGN_Batn_", - "fillStyle": "solid", - "strokeWidth": 1, - "strokeStyle": "solid", - "roughness": 0, - "opacity": 100, - "angle": 0, - "x": 473.3990782659803, - "y": 2372.4307801988393, - "strokeColor": "#2f9e44", - "backgroundColor": "transparent", - "width": 1326.5799781303176, - "height": 1179.563456471902, - "seed": 1631563558, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 2 - }, - "boundElements": [ - { - "type": "text", - "id": "T80QU0AXIqb-YK4ex70mT" - } - ], - "updated": 1714744366477, - "link": null, - "locked": false, - "startBinding": { - "elementId": "R0nMXwKFeadrft0ZosQ-f", - "gap": 19.678294237402497, - "focus": 0.011726209379353184 - }, - "endBinding": { - "elementId": "uobFuAsT0NWnRMntfj5nA", - "gap": 21.65509953072869, - "focus": 0.17074031393058853 - }, - "lastCommittedPoint": null, - "startArrowhead": null, - "endArrowhead": "triangle", - "points": [ - [ - 0, - 0 - ], - [ - -1326.5799781303176, - 1179.563456471902 - ] - ] - }, - { - "type": "text", - "version": 4, - "versionNonce": 1712376496, - "isDeleted": false, - "id": "T80QU0AXIqb-YK4ex70mT", - "fillStyle": "solid", - "strokeWidth": 1, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": -211.1669041463465, - "y": 2939.7125084347904, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 42.55198669433594, - "height": 45, - "seed": 392620624, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744364801, - "link": null, - "locked": false, - "fontSize": 36, - "fontFamily": 1, - "text": "161", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "0ov9dJFlVufiTGN_Batn_", - "originalText": "161", - "lineHeight": 1.25, - "baseline": 38 - }, - { - "type": "arrow", - "version": 563, - "versionNonce": 404904016, - "isDeleted": false, - "id": "IjtzlmGeUZNzHhtL5Sx4-", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": -1755.218199559816, - "y": 3739.806878950265, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 193.7277174788685, - "height": 2.793981468968923, - "seed": 1401878607, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744201193, - "link": null, - "locked": false, - "startBinding": null, - "endBinding": { - "elementId": "hxutjfIhgXhW_6SJNpt1Z", - "gap": 14.791649712458025, - "focus": 0.06393838495605775 - }, - "lastCommittedPoint": null, - "startArrowhead": null, - "endArrowhead": "arrow", - "points": [ - [ - 0, - 0 - ], - [ - -193.7277174788685, - 2.793981468968923 - ] - ] - }, - { - "type": "rectangle", - "version": 548, - "versionNonce": 1944398928, - "isDeleted": false, - "id": "hxutjfIhgXhW_6SJNpt1Z", - "fillStyle": "cross-hatch", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": -2210.9596321469216, - "y": 3621.0661105201343, - "strokeColor": "#e03131", - "backgroundColor": "#ffc9c9", - "width": 247.2220653957791, - "height": 231.99996948242196, - "seed": 1388910191, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [ - { - "id": "IjtzlmGeUZNzHhtL5Sx4-", - "type": "arrow" - }, - { - "type": "text", - "id": "pmGje4fSxRgG95Nu-6IzQ" - } - ], - "updated": 1714744201192, - "link": null, - "locked": false - }, - { - "type": "text", - "version": 599, - "versionNonce": 1442918992, - "isDeleted": false, - "id": "pmGje4fSxRgG95Nu-6IzQ", - "fillStyle": "cross-hatch", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": -2188.958561912411, - "y": 3647.0660952613453, - "strokeColor": "#1e1e1e", - "backgroundColor": "#ffc9c9", - "width": 203.2199249267578, - "height": 180, - "seed": 1029337231, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744213336, - "link": null, - "locked": false, - "fontSize": 36, - "fontFamily": 1, - "text": "no response\n-21\nlost syn\n-22", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "hxutjfIhgXhW_6SJNpt1Z", - "originalText": "no response\n-21\nlost syn\n-22", - "lineHeight": 1.25, - "baseline": 173 - }, - { - "type": "rectangle", - "version": 287, - "versionNonce": 191225424, - "isDeleted": false, - "id": "_xAS16LWhNy5Gw6c3Abgu", - "fillStyle": "cross-hatch", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 1310.0891352586232, - "y": 1973.3864053239558, - "strokeColor": "#e03131", - "backgroundColor": "#ffc9c9", - "width": 157.88906521267364, - "height": 190, - "seed": 828001200, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [ - { - "type": "text", - "id": "LhTNzIQ3McbWToRZS31Wk" - }, - { - "id": "w48z_r3CFcohLuEU1P684", - "type": "arrow" - } - ], - "updated": 1714744053945, - "link": null, - "locked": false - }, - { - "type": "text", - "version": 279, - "versionNonce": 757722800, - "isDeleted": false, - "id": "LhTNzIQ3McbWToRZS31Wk", - "fillStyle": "cross-hatch", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 1339.3356774474796, - "y": 2000.8864053239558, - "strokeColor": "#1e1e1e", - "backgroundColor": "#ffc9c9", - "width": 99.39598083496094, - "height": 135, - "seed": 1098208688, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053945, - "link": null, - "locked": false, - "fontSize": 36, - "fontFamily": 1, - "text": "Lost \nSync\n-2", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "_xAS16LWhNy5Gw6c3Abgu", - "originalText": "Lost Sync\n-2", - "lineHeight": 1.25, - "baseline": 128 - }, - { - "type": "rectangle", - "version": 355, - "versionNonce": 95786064, - "isDeleted": false, - "id": "r8QgYWHtt1ERGS9dITEB-", - "fillStyle": "cross-hatch", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 1272.5891352586236, - "y": 1775.8863290300105, - "strokeColor": "#e03131", - "backgroundColor": "#ffc9c9", - "width": 256.22219509548574, - "height": 189.16664123535156, - "seed": 322910640, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [ - { - "type": "text", - "id": "DTpFAXniLPN2v6ENsjj-p" - }, - { - "id": "ksZH5o4yNx8HLY0yxGFbD", - "type": "arrow" - } - ], - "updated": 1714744053945, - "link": null, - "locked": false - }, - { - "type": "text", - "version": 398, - "versionNonce": 156801200, - "isDeleted": false, - "id": "DTpFAXniLPN2v6ENsjj-p", - "fillStyle": "cross-hatch", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 1283.052260699433, - "y": 1802.9696496476863, - "strokeColor": "#1e1e1e", - "backgroundColor": "#ffc9c9", - "width": 235.2959442138672, - "height": 135, - "seed": 881623984, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053945, - "link": null, - "locked": false, - "fontSize": 36, - "fontFamily": 1, - "text": "Too many re-\ntry\n-4/-9", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "r8QgYWHtt1ERGS9dITEB-", - "originalText": "Too many re-try\n-4/-9", - "lineHeight": 1.25, - "baseline": 128 - }, - { - "type": "arrow", - "version": 403, - "versionNonce": 1218349648, - "isDeleted": false, - "id": "L50BGCy0awqTIQHghyt9z", - "fillStyle": "solid", - "strokeWidth": 4, - "strokeStyle": "solid", - "roughness": 2, - "opacity": 100, - "angle": 0, - "x": 1472.29062882681, - "y": 2534.0973451402456, - "strokeColor": "#2f9e44", - "backgroundColor": "transparent", - "width": 607.666625976562, - "height": 1110.3332519531245, - "seed": 1534128676, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 2 - }, - "boundElements": [ - { - "type": "text", - "id": "lMCaitAoU9MIWzybhfH--" - } - ], - "updated": 1714744053945, - "link": null, - "locked": false, - "startBinding": { - "focus": -0.14120177941968304, - "gap": 5.736758801065733, - "elementId": "gKny8cgFf1eK8KNEfsu1X" - }, - "endBinding": { - "focus": -0.4894460396284771, - "gap": 7.328161982185463, - "elementId": "jj_yHGzqEfb3EVrV7IAkE" - }, - "lastCommittedPoint": null, - "startArrowhead": null, - "endArrowhead": "triangle", - "points": [ - [ - 0, - 0 - ], - [ - -607.666625976562, - 1110.3332519531245 - ] - ] - }, - { - "type": "text", - "version": 17, - "versionNonce": 2116158128, - "isDeleted": false, - "id": "lMCaitAoU9MIWzybhfH--", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 1145.885324871732, - "y": 3066.7639711168076, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 45.14398193359375, - "height": 45, - "seed": 1650371559, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053945, - "link": null, - "locked": false, - "fontSize": 36, - "fontFamily": 1, - "text": "211", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "L50BGCy0awqTIQHghyt9z", - "originalText": "211", - "lineHeight": 1.25, - "baseline": 38 - }, - { - "type": "arrow", - "version": 818, - "versionNonce": 1861795920, - "isDeleted": false, - "id": "SPFSlS5fEkc_qQBkM9eLq", - "fillStyle": "solid", - "strokeWidth": 1, - "strokeStyle": "solid", - "roughness": 0, - "opacity": 100, - "angle": 0, - "x": 2334.3758187878966, - "y": 2535.584703759284, - "strokeColor": "#2f9e44", - "backgroundColor": "transparent", - "width": 702.2942235865171, - "height": 1100.4878762984686, - "seed": 688223260, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 2 - }, - "boundElements": [ - { - "type": "text", - "id": "-h8D-LdmAqoy7Z6XE0ewo" - } - ], - "updated": 1714744053945, - "link": null, - "locked": false, - "startBinding": { - "elementId": "3ZsaM9HAI9xyZdhjU5G6O", - "focus": -0.3040666851117252, - "gap": 12.657522916518118 - }, - "endBinding": { - "elementId": "RJxANj4RhJ_aciZMjF5IY", - "focus": -0.6129293531506963, - "gap": 24.601348832702257 - }, - "lastCommittedPoint": null, - "startArrowhead": null, - "endArrowhead": "triangle", - "points": [ - [ - 0, - 0 - ], - [ - -702.2942235865171, - 1100.4878762984686 - ] - ] - }, - { - "type": "text", - "version": 20, - "versionNonce": 707669168, - "isDeleted": false, - "id": "-h8D-LdmAqoy7Z6XE0ewo", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 2017.9474306863476, - "y": 3090.0973044501416, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 61.01997375488281, - "height": 45, - "seed": 16289948, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053945, - "link": null, - "locked": false, - "fontSize": 36, - "fontFamily": 1, - "text": "212", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "SPFSlS5fEkc_qQBkM9eLq", - "originalText": "212", - "lineHeight": 1.25, - "baseline": 38 - }, - { - "type": "arrow", - "version": 537, - "versionNonce": 2023503440, - "isDeleted": false, - "id": "U2EvPXeHbkdhv1IajJrxn", - "fillStyle": "solid", - "strokeWidth": 1, - "strokeStyle": "solid", - "roughness": 0, - "opacity": 100, - "angle": 0, - "x": 2577.2203239280425, - "y": 3793.0965001415034, - "strokeColor": "#e03131", - "backgroundColor": "transparent", - "width": 9.821008887962762, - "height": 1378.4508223351522, - "seed": 504576292, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 2 - }, - "boundElements": [ - { - "type": "text", - "id": "cS0N1k5dk3sOmQa2I3DTC" - } - ], - "updated": 1714744053945, - "link": null, - "locked": false, - "startBinding": { - "focus": 0.22693106397956136, - "gap": 14.687558147681067, - "elementId": "Mdil-sv7Ec0Ncq-XpaH48" - }, - "endBinding": { - "focus": -0.06954320217056414, - "gap": 7.030070750862535, - "elementId": "k4wYSdGSsCo2g1t0Te4BW" - }, - "lastCommittedPoint": null, - "startArrowhead": null, - "endArrowhead": "triangle", - "points": [ - [ - 0, - 0 - ], - [ - 9.821008887962762, - -1378.4508223351522 - ] - ] - }, - { - "type": "text", - "version": 17, - "versionNonce": 388306608, - "isDeleted": false, - "id": "cS0N1k5dk3sOmQa2I3DTC", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 2544.5468439970236, - "y": 3081.3710889739273, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 75.16796875, - "height": 45, - "seed": 1360557220, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053945, - "link": null, - "locked": false, - "fontSize": 36, - "fontFamily": 1, - "text": "200", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "U2EvPXeHbkdhv1IajJrxn", - "originalText": "200", - "lineHeight": 1.25, - "baseline": 38 - }, - { - "type": "arrow", - "version": 506, - "versionNonce": 710995024, - "isDeleted": false, - "id": "O4MRTCghp9QBztgDBgQdC", - "fillStyle": "solid", - "strokeWidth": 1, - "strokeStyle": "solid", - "roughness": 0, - "opacity": 100, - "angle": 0, - "x": 1360.5536572613762, - "y": 3775.318688455305, - "strokeColor": "#e03131", - "backgroundColor": "transparent", - "width": 379.82100888796276, - "height": 1372.8951481001259, - "seed": 1621826028, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 2 - }, - "boundElements": [ - { - "type": "text", - "id": "V-QvlDWfBZWDgmbPNv7tC" - } - ], - "updated": 1714744053945, - "link": null, - "locked": false, - "startBinding": { - "focus": 0.15784142807548998, - "gap": 22.74902368404603, - "elementId": "4uG_zS5TMGWF1M74StXiw" - }, - "endBinding": null, - "lastCommittedPoint": null, - "startArrowhead": null, - "endArrowhead": "triangle", - "points": [ - [ - 0, - 0 - ], - [ - 379.82100888796276, - -1372.8951481001259 - ] - ] - }, - { - "type": "text", - "version": 22, - "versionNonce": 1504624816, - "isDeleted": false, - "id": "V-QvlDWfBZWDgmbPNv7tC", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 1495.3861740344591, - "y": 3064.7044477385757, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 60.155975341796875, - "height": 45, - "seed": 914947180, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053946, - "link": null, - "locked": false, - "fontSize": 36, - "fontFamily": 1, - "text": "210", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "O4MRTCghp9QBztgDBgQdC", - "originalText": "210", - "lineHeight": 1.25, - "baseline": 38 - }, - { - "type": "ellipse", - "version": 291, - "versionNonce": 1847517776, - "isDeleted": false, - "id": "drdcmV3L0ddqrWjMto2HA", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 2140.646627596518, - "y": 2384.9118050376096, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 139.3841404869686, - "height": 139.3841404869686, - "seed": 1147122921, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [ - { - "type": "text", - "id": "skRaGtOsOJag3_-_vAeWM" - } - ], - "updated": 1714744053946, - "link": null, - "locked": false - }, - { - "type": "text", - "version": 348, - "versionNonce": 829631152, - "isDeleted": false, - "id": "skRaGtOsOJag3_-_vAeWM", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 2178.9769845316673, - "y": 2422.047170865775, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 63.16395568847656, - "height": 65.553937902444, - "seed": 1850421193, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053946, - "link": null, - "locked": false, - "fontSize": 26.221575160977604, - "fontFamily": 1, - "text": "buf\nclear", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "drdcmV3L0ddqrWjMto2HA", - "originalText": "buf\nclear", - "lineHeight": 1.25, - "baseline": 59 - }, - { - "type": "arrow", - "version": 812, - "versionNonce": 850270288, - "isDeleted": false, - "id": "bLoyDI7x4qG_GKX6CeMT3", - "fillStyle": "solid", - "strokeWidth": 1, - "strokeStyle": "solid", - "roughness": 0, - "opacity": 100, - "angle": 0, - "x": 3050.3758187878966, - "y": 2567.584703759284, - "strokeColor": "#2f9e44", - "backgroundColor": "transparent", - "width": 278.29422358651755, - "height": 1123.1546243453436, - "seed": 855051044, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 2 - }, - "boundElements": [], - "updated": 1714744053946, - "link": null, - "locked": false, - "startBinding": { - "focus": -0.18472349081490505, - "gap": 19.486204168028564, - "elementId": "OkLwDHyZTul2qE2aBhHEy" - }, - "endBinding": { - "focus": -0.3540243231205051, - "gap": 7.917677151524252, - "elementId": "NYb28wO65_lvUaT1Cockk" - }, - "lastCommittedPoint": null, - "startArrowhead": null, - "endArrowhead": "triangle", - "points": [ - [ - 0, - 0 - ], - [ - -278.29422358651755, - 1123.1546243453436 - ] - ] - }, - { - "type": "arrow", - "version": 867, - "versionNonce": 689591472, - "isDeleted": false, - "id": "ObbXkkUi4RX8Luqzn8JMg", - "fillStyle": "solid", - "strokeWidth": 1, - "strokeStyle": "solid", - "roughness": 0, - "opacity": 100, - "angle": 0, - "x": 3230.3758187878966, - "y": 2579.584703759284, - "strokeColor": "#2f9e44", - "backgroundColor": "transparent", - "width": 37.705776413482454, - "height": 1089.8211282515936, - "seed": 2041902628, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 2 - }, - "boundElements": [], - "updated": 1714744053946, - "link": null, - "locked": false, - "startBinding": { - "elementId": "ZIqLdTRRThlw8lHcE4onP", - "focus": 0.03856242982066085, - "gap": 19.285846282459815 - }, - "endBinding": { - "elementId": "iBZRtI2xGc5MgU0R2emqB", - "focus": -0.25188128440851404, - "gap": 20.588958897294617 - }, - "lastCommittedPoint": null, - "startArrowhead": null, - "endArrowhead": "triangle", - "points": [ - [ - 0, - 0 - ], - [ - 37.705776413482454, - 1089.8211282515936 - ] - ] - }, - { - "type": "arrow", - "version": 647, - "versionNonce": 1273400912, - "isDeleted": false, - "id": "-3xsQ8CUpzKqR3rQuEvHY", - "fillStyle": "solid", - "strokeWidth": 1, - "strokeStyle": "solid", - "roughness": 0, - "opacity": 100, - "angle": 0, - "x": 3869.220323928042, - "y": 3689.0965001415034, - "strokeColor": "#e03131", - "backgroundColor": "transparent", - "width": 314.17899111203724, - "height": 1250.4508223351522, - "seed": 1943232309, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 2 - }, - "boundElements": [ - { - "type": "text", - "id": "2IXeqGDbLQ3GdBBwzZ2ga" - } - ], - "updated": 1714744053946, - "link": null, - "locked": false, - "startBinding": { - "focus": 0.19743598335435658, - "gap": 13.064102674735437, - "elementId": "I1nmKrm-fWZatTXwyA29D" - }, - "endBinding": { - "focus": 0.34544705344176796, - "gap": 16.91334043405756, - "elementId": "8rA9xpm9xmRmEM21VM0lU" - }, - "lastCommittedPoint": null, - "startArrowhead": null, - "endArrowhead": "triangle", - "points": [ - [ - 0, - 0 - ], - [ - -314.17899111203724, - -1250.4508223351522 - ] - ] - }, - { - "type": "text", - "version": 22, - "versionNonce": 910966448, - "isDeleted": false, - "id": "2IXeqGDbLQ3GdBBwzZ2ga", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 3681.098838320754, - "y": 3041.3710889739273, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 62.06398010253906, - "height": 45, - "seed": 1089187989, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053946, - "link": null, - "locked": false, - "fontSize": 36, - "fontFamily": 1, - "text": "180", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "-3xsQ8CUpzKqR3rQuEvHY", - "originalText": "180", - "lineHeight": 1.25, - "baseline": 38 - }, - { - "type": "rectangle", - "version": 311, - "versionNonce": 1386234960, - "isDeleted": false, - "id": "idBlXd68348ilwf1GeNIr", - "fillStyle": "cross-hatch", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 3728.338880945471, - "y": 1929.5667387793594, - "strokeColor": "#e03131", - "backgroundColor": "#ffc9c9", - "width": 157.88906521267364, - "height": 190, - "seed": 2000803100, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [ - { - "type": "text", - "id": "YJUsRewdxJ1m5V334YrRQ" - } - ], - "updated": 1714744053946, - "link": null, - "locked": false - }, - { - "type": "text", - "version": 319, - "versionNonce": 1504766128, - "isDeleted": false, - "id": "YJUsRewdxJ1m5V334YrRQ", - "fillStyle": "cross-hatch", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 3739.1534391865735, - "y": 1979.5667387793594, - "strokeColor": "#1e1e1e", - "backgroundColor": "#ffc9c9", - "width": 136.25994873046875, - "height": 90, - "seed": 1795215772, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053946, - "link": null, - "locked": false, - "fontSize": 36, - "fontFamily": 1, - "text": "Checksu\nm -10", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "idBlXd68348ilwf1GeNIr", - "originalText": "Checksum -10", - "lineHeight": 1.25, - "baseline": 83 - }, - { - "type": "rectangle", - "version": 265, - "versionNonce": 78854736, - "isDeleted": false, - "id": "Pw8tqcnRVRBvkr7aqbhd8", - "fillStyle": "cross-hatch", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 1985.860989235402, - "y": 3990.173510581504, - "strokeColor": "#e03131", - "backgroundColor": "#ffc9c9", - "width": 211.22219509548637, - "height": 280, - "seed": 782587884, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [ - { - "type": "text", - "id": "uFsm7wNyZQ8nqtC5IPOp_" - }, - { - "id": "VwKQnf_zVtP_2qxBcKzUw", - "type": "arrow" - } - ], - "updated": 1714744053946, - "link": null, - "locked": false - }, - { - "type": "text", - "version": 316, - "versionNonce": 1055937200, - "isDeleted": false, - "id": "uFsm7wNyZQ8nqtC5IPOp_", - "fillStyle": "cross-hatch", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 2006.4941204745514, - "y": 4062.673510581504, - "strokeColor": "#1e1e1e", - "backgroundColor": "#ffc9c9", - "width": 169.9559326171875, - "height": 135, - "seed": 109804140, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053946, - "link": null, - "locked": false, - "fontSize": 36, - "fontFamily": 1, - "text": "Memory \nallocation\n-6", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "Pw8tqcnRVRBvkr7aqbhd8", - "originalText": "Memory allocation\n-6", - "lineHeight": 1.25, - "baseline": 128 - }, - { - "type": "arrow", - "version": 118, - "versionNonce": 620195920, - "isDeleted": false, - "id": "VwKQnf_zVtP_2qxBcKzUw", - "fillStyle": "solid", - "strokeWidth": 1, - "strokeStyle": "solid", - "roughness": 0, - "opacity": 100, - "angle": 0, - "x": 2105.799847513522, - "y": 3852.3874131269513, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 5.154140784180072, - "height": 124.32776073037712, - "seed": 624914284, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 2 - }, - "boundElements": [], - "updated": 1714744053946, - "link": null, - "locked": false, - "startBinding": { - "elementId": "dwSyGncFb0E5Cqk0pkmyg", - "gap": 13.50713308055471, - "focus": -0.12731120776534016 - }, - "endBinding": { - "elementId": "Pw8tqcnRVRBvkr7aqbhd8", - "gap": 13.458336724175524, - "focus": 0.2319588358641433 - }, - "lastCommittedPoint": null, - "startArrowhead": null, - "endArrowhead": "arrow", - "points": [ - [ - 0, - 0 - ], - [ - 5.154140784180072, - 124.32776073037712 - ] - ] - }, - { - "type": "arrow", - "version": 565, - "versionNonce": 1555201200, - "isDeleted": false, - "id": "fNlhld2BS4snfpZ0Sn2La", - "fillStyle": "solid", - "strokeWidth": 1, - "strokeStyle": "solid", - "roughness": 0, - "opacity": 100, - "angle": 0, - "x": 1833.0536572613762, - "y": 3452.818688455305, - "strokeColor": "#e03131", - "backgroundColor": "transparent", - "width": 10.178991112037465, - "height": 1582.8951481001259, - "seed": 418498516, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 2 - }, - "boundElements": [ - { - "type": "text", - "id": "aa-hRQKnGiw7dxWn3bQd8" - } - ], - "updated": 1714744053946, - "link": null, - "locked": false, - "startBinding": { - "elementId": "0XOIdMglnzJdbVbiI4UlR", - "focus": -0.3518684023567377, - "gap": 2.120682289950004 - }, - "endBinding": { - "elementId": "Dy1HFFDMmS5fyBx8k3h7k", - "focus": -0.08452651399850455, - "gap": 4.043157064792169 - }, - "lastCommittedPoint": null, - "startArrowhead": null, - "endArrowhead": "triangle", - "points": [ - [ - 0, - 0 - ], - [ - -10.178991112037465, - -1582.8951481001259 - ] - ] - }, - { - "type": "text", - "version": 27, - "versionNonce": 1531242064, - "isDeleted": false, - "id": "aa-hRQKnGiw7dxWn3bQd8", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 1789.5161789172716, - "y": 2638.871114405242, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 76.89596557617188, - "height": 45, - "seed": 688587561, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053946, - "link": null, - "locked": false, - "fontSize": 36, - "fontFamily": 1, - "text": "222", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "fNlhld2BS4snfpZ0Sn2La", - "originalText": "222", - "lineHeight": 1.25, - "baseline": 38 - }, - { - "type": "rectangle", - "version": 364, - "versionNonce": 345990832, - "isDeleted": false, - "id": "yveyjSE9qA0izb8K6Q7fq", - "fillStyle": "cross-hatch", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 648.360989235402, - "y": 3897.673510581504, - "strokeColor": "#e03131", - "backgroundColor": "#ffc9c9", - "width": 86.2221950954861, - "height": 83.08332655164895, - "seed": 125543276, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [ - { - "type": "text", - "id": "fnXvu4aURmwd_clUbqKTb" - } - ], - "updated": 1714744053946, - "link": null, - "locked": false - }, - { - "type": "text", - "version": 331, - "versionNonce": 343120976, - "isDeleted": false, - "id": "fnXvu4aURmwd_clUbqKTb", - "fillStyle": "cross-hatch", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 673.112093802188, - "y": 3916.7151738573284, - "strokeColor": "#1e1e1e", - "backgroundColor": "#ffc9c9", - "width": 36.71998596191406, - "height": 45, - "seed": 361518572, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053946, - "link": null, - "locked": false, - "fontSize": 36, - "fontFamily": 1, - "text": "-9", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "yveyjSE9qA0izb8K6Q7fq", - "originalText": "-9", - "lineHeight": 1.25, - "baseline": 38 - }, - { - "type": "arrow", - "version": 948, - "versionNonce": 1398739120, - "isDeleted": false, - "id": "gyPcyFeW-J2407VPWQOUM", - "fillStyle": "solid", - "strokeWidth": 1, - "strokeStyle": "solid", - "roughness": 0, - "opacity": 100, - "angle": 0, - "x": 3024.220323928042, - "y": 3631.5965001415034, - "strokeColor": "#e03131", - "backgroundColor": "transparent", - "width": 468.32100888796276, - "height": 1817.9508223351518, - "seed": 643667460, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 2 - }, - "boundElements": [ - { - "type": "text", - "id": "y1KCIJ3BwpKUJUiddHDVo" - } - ], - "updated": 1714744053946, - "link": null, - "locked": false, - "startBinding": { - "elementId": "xcVSmTB-gt0cN1YieTegp", - "focus": -0.21481161526658266, - "gap": 25.040926322905463 - }, - "endBinding": { - "elementId": "LdRxYtp-vyX2QeDnxXSrS", - "focus": 0.46953066807727273, - "gap": 26.877644598323087 - }, - "lastCommittedPoint": null, - "startArrowhead": null, - "endArrowhead": "triangle", - "points": [ - [ - 0, - 0 - ], - [ - 468.32100888796276, - -1817.9508223351518 - ] - ] - }, - { - "type": "text", - "version": 26, - "versionNonce": 1650168400, - "isDeleted": false, - "id": "y1KCIJ3BwpKUJUiddHDVo", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 3219.9328455839377, - "y": 2700.1210889739277, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 76.89596557617188, - "height": 45, - "seed": 1362489830, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053946, - "link": null, - "locked": false, - "fontSize": 36, - "fontFamily": 1, - "text": "222", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "gyPcyFeW-J2407VPWQOUM", - "originalText": "222", - "lineHeight": 1.25, - "baseline": 38 - }, - { - "type": "arrow", - "version": 628, - "versionNonce": 815364784, - "isDeleted": false, - "id": "1pwwcSYOnzOIeKOG9nO85", - "fillStyle": "cross-hatch", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 3016.1144922650083, - "y": 3893.561912657721, - "strokeColor": "#1e1e1e", - "backgroundColor": "#ffc9c9", - "width": 2472.357177734374, - "height": 607.982177734375, - "seed": 1567446097, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714744053946, - "link": null, - "locked": false, - "startBinding": { - "elementId": "xcVSmTB-gt0cN1YieTegp", - "focus": -0.05915173079298335, - "gap": 24.43516247655255 - }, - "endBinding": { - "elementId": "ViWZZy9Q7c0UYyERaQ5M0", - "focus": -0.2156363294749259, - "gap": 26.26847258068483 - }, - "lastCommittedPoint": null, - "startArrowhead": null, - "endArrowhead": "arrow", - "points": [ - [ - 0, - 0 - ], - [ - -14.071568080356883, - 551.9821602957591 - ], - [ - -2472.357177734374, - 541.7678397042409 - ], - [ - -2468.5001046316956, - -56.00001743861594 - ] - ] - } - ], - "appState": { - "gridSize": null, - "viewBackgroundColor": "#ffffff" - }, - "files": {} -} \ No newline at end of file diff --git a/.vscode/examples/Untitled-1.ipynb b/.vscode/examples/Untitled-1.ipynb deleted file mode 100644 index 2c311a1..0000000 --- a/.vscode/examples/Untitled-1.ipynb +++ /dev/null @@ -1,925 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "import serial\n", - "import serial.tools.list_ports\n", - "import numpy as np\n", - "import time\n", - "import matplotlib.pyplot as plt\n", - "from IPython.display import clear_output, display\n", - "import pandas as pd\n", - "plt.style.use('dark_background')" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Found USB devices:\tUSB VID:PID=303A:1001 SER=34:85:18:8E:88:FC LOCATION=1-4.2:x.0\n", - "Pulser Likely at:\tCOM14\n", - "Found USB devices:\tUSB VID:PID=1A86:55D4 SER=554C028876 LOCATION=1-4.1:x.0\n", - "Ambit Likely at:\tCOM23\n" - ] - } - ], - "source": [ - "Ambit_Port = \"\"\n", - "Pulser_Port = \"\"\n", - "ports = serial.tools.list_ports.comports()\n", - "for port, desc, hwid in sorted(ports):\n", - " if hwid[:4] == \"USB \":\n", - " print(f'Found USB devices:\\t{hwid}')\n", - " devices = hwid[4:].split(\" \")\n", - " if len(devices) > 1 and len(devices[0]) > 9:\n", - " if devices[0][-9:] == \"1A86:55D4\":\n", - " print(f'Ambit Likely at:\\t{port}')\n", - " Ambit_Port = port\n", - " if devices[0][-9:] == \"303A:1001\":\n", - " print(f'Pulser Likely at:\\t{port}')\n", - " Pulser_Port = port\n", - "\n", - "if Ambit_Port == \"\": print(f'Ambit not Found')\n", - "\n", - "if Pulser_Port == \"\": print(f'Pulser not Found')" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "def _readline(ser: serial.Serial, timeout: int):\n", - " _t0 = time.time()\n", - " s = \"\"\n", - " while (time.time() - _t0 < timeout):\n", - " if ser.in_waiting > 0:\n", - " c = ser.read()\n", - " if (c > bytes([0])) and (c < bytes([128])):\n", - " if (c == b'\\n') or (c == b'\\r'):\n", - " if s == \"\":\n", - " pass\n", - " elif len(s) > 2:\n", - " return s\n", - " else:\n", - " s += c.decode()\n", - " \n", - " return s\n", - "\n", - "def _wait_for_line(ser: serial.Serial, target: str, input: str = \"\", timeout: float = 1.0, print_out = False):\n", - " if input != \"\":\n", - " ser.write((input + \"\\n\").encode())\n", - " t0 = time.time()\n", - " timeout_t = t0 + timeout\n", - " condition = False\n", - " while (condition == False):\n", - " _l = _readline(ser, 0.25)\n", - " if target in _l:\n", - " condition = True\n", - " if print_out:\n", - " if _l != \"\": print(_l)\n", - " if time.time() > timeout_t:\n", - " break\n", - "\n", - " return condition\n", - "\n", - " \n", - "def _parse_data_line(l:str)->dict:\n", - " ret = {}\n", - " if len(l) > 5:\n", - " if (l[:2] == \"T:\") and (\",\" in l) and (\":\" in l):\n", - " items = [n.split(':') for n in l.split(',') if \":\" in n]\n", - " for i in items:\n", - " k = i[0]\n", - " v = i[1]\n", - " if len(k) > 0:\n", - " if v.isdecimal():\n", - " ret.update({k: int(v)})\n", - " if (v.count(\".\") == 1) and v.replace(\".\", \"0\").isdecimal():\n", - " ret.update({k: float(v)})\n", - "\n", - " return ret \n", - "\n", - "\n", - "def Trigger(ser: serial.Serial) -> dict:\n", - " ser.write(b\"G\")\n", - " ser.flush()\n", - " _ret = _parse_data_line(_readline(ser, .5))\n", - " return _ret\n", - "\n", - "def Ambit_actinic(ser: serial.Serial, v:int)->int:\n", - " if (v > 255): return -1\n", - " ser.write(bytes([65, v]))\n", - " ser.flush()\n", - " return v\n", - " \n", - "\n", - "def DAC_set(ser: serial.Serial, ch:int, v:int):\n", - " ret = False\n", - " if (ch == 2) or (ch == 4):\n", - " if (v > -1) and (v < 4095):\n", - " ret = _wait_for_line(ser, target = \"Done\", input = f'DAC,{ch},{v},\\n', print_out=False)\n", - " if ret == False: \n", - " print(\"DAC_set error\", ch, v)\n", - " return -1\n", - " return v\n", - "\n", - "def DAC_ONOFF(ser: serial.Serial, ch:int, onoff:bool):\n", - " if onoff:\n", - " if (ch == 2) or (ch == 4):\n", - " _wait_for_line(ser, target = \"Done\", input = f'LED_ON,{ch},\\n', print_out=False)\n", - " else:\n", - " if (ch == 2) or (ch == 4):\n", - " _wait_for_line(ser, target = \"Done\", input = f'LED_OFF,{ch},\\n', print_out=False)\n", - " else:\n", - " _wait_for_line(ser, target = \"Done\", input = f'LED_OFF,0,\\n', print_out=False)\n", - "\n", - "# plot autoscale\n", - "def autoscale(data: list, axis:plt.Axes):\n", - " if len(data) == 0: return\n", - " if len(data) == 1: \n", - " axis.set_ylim([data[0]-1, data[0]+1])\n", - " return \n", - " l, h = axis.get_ylim()\n", - " x, d = np.min(data), np.max(data)\n", - " r = d - x\n", - "\n", - " _l, _h, a = l, h, False\n", - " if (x < l) or (l < x - r):\n", - " _l = x - 0.05 * r\n", - " a = True\n", - " if (d > h) or (h > l + r):\n", - " _h = d + 0.05 * r\n", - " a = True\n", - " if a and _l != _h:\n", - " axis.set_ylim([_l, _h])\n", - "\n", - "def print_protocol(protocol:list)->None:\n", - " _act_ambit, _act_blue, _act_red, act_blue, act_red = -1, -1, -1, 0, 0\n", - " _timer = 0\n", - " _blue_on_time, _red_on_time = 0, 0\n", - " for _l in protocol:\n", - " if _l[0] == 'M' and len(_l) == 4: # Run measurement \n", - " if (_act_ambit != _l[3]): # Set ambit actinic\n", - " if _l[3] > 4 and _l[3] < 255: \n", - " _act_ambit = _l[3]\n", - " else:\n", - " _act_ambit = 0\n", - " #print(f'{_timer:<12.3f}Set Ambit Actinic to {_act_ambit}')\n", - " if (_l[1] < 1): continue # no data\n", - " for _ in range(_l[1]):\n", - " _timer += _l[2]\n", - " print(f'{_timer:<12.3f}Meas {_l[1]}\\t Interval: {_l[2]:.3f} sec \\t Take {_l[1] * _l[2]:.2f} seconds\\tAct:{_act_ambit:>3d}\\tRed:{act_red:>3d}\\tBlue:{act_blue:>3d}\\t')\n", - "\n", - " if _l[0] == 'A' and len(_l) == 3: # Change Actinic\n", - " if _l[1] == \"B\":\n", - " if _l[2] > 0:\n", - " if _act_blue != _l[2]: \n", - " _act_blue = _l[2]\n", - " if (_act_blue > 200 and act_blue < 200): _blue_on_time = _timer\n", - " print(f'{_timer:<12.3f}Set Blue Actinic: {_act_blue}')\n", - "\n", - " print(f'{_timer:<12.3f}Blue Actinic ON')\n", - " act_blue = _act_blue\n", - " else: \n", - " print(f'{_timer:<12.3f}Blue Actinic OFF')\n", - " act_blue = 0\n", - "\n", - " \n", - " if _l[1] == \"R\":\n", - " if _l[2] > 0:\n", - " if _act_red != _l[2]: \n", - " _act_red= _l[2]\n", - " if (_act_red > 200): _red_on_time = _timer\n", - " print(f'{_timer:<12.3f}Set Red Actinic: {_act_red}')\n", - " print(f'{_timer:<12.3f}Red Actinic ON')\n", - " act_red = _act_red\n", - " else: \n", - " print(f'{_timer:<12.3f}Red Actinic OFF')\n", - " act_red = 0\n", - "\n", - " if _l[0] == 'W' and len(_l) == 2:\n", - " print(f'{_timer:<12.3f}Sleep for: {_l[1]} sec with \\tAct:{_act_ambit:>3d}\\tRed:{act_red:>3d}\\tBlue:{act_blue:>3d}\\t')\n", - " _timer += _l[1]\n", - " if _l[0] == 'P':\n", - " print(f'{_timer:<12.3f}Update plot')\n", - "\n", - "\n", - "\n", - "\n", - " if (act_blue > 200) and (_timer - _blue_on_time > 5): print(f'\\t\\t-------Blue Actinic @ {act_blue} for too long-------')\n", - " if (act_red > 200) and (_timer - _red_on_time > 5): print(f'\\t\\t-------Red Actinic @ {act_red} for too long-------')\n", - " return" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Protocol is a list of Lines\n", - "#### Each Line is a command to run, also a list [\"Keyword\", augments,,,,]\n" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "1.000 Meas 10\t Interval: 0.100 sec \t Take 1.00 seconds\tAct: 0\tRed: 0\tBlue: 0\t\n", - "2.250 Meas 250\t Interval: 0.005 sec \t Take 1.25 seconds\tAct:254\tRed: 0\tBlue: 0\t\n", - "2.450 Meas 20\t Interval: 0.010 sec \t Take 0.20 seconds\tAct: 0\tRed: 0\tBlue: 0\t\n" - ] - } - ], - "source": [ - "## \"M\": Measurement:\n", - "# [\"M\", Number of points, Interval in second, Ambit actinic 0-255]\n", - "# NOTE there are 3 Actinic light, one from Ambit and two from external controller (Blue)\n", - "# This command controls Actinic on Ambit, ideally for Saturation Flash. Intensity is ~ 3000uE @ 254. Depends on real working distance. \n", - "\n", - "Example_protocol = [\n", - " ['M', 10, 0.1, 0],\n", - " ['M', 250, 0.005, 254],\n", - " ['M', 20, 0.01, 0]\n", - " ]\n", - "print_protocol(Example_protocol)" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "1.000 Meas 10\t Interval: 0.100 sec \t Take 1.00 seconds\tAct: 0\tRed: 0\tBlue: 0\t\n", - "1.000 Set Red Actinic: 50\n", - "1.000 Red Actinic ON\n", - "21.000 Meas 20\t Interval: 1.000 sec \t Take 20.00 seconds\tAct: 0\tRed: 50\tBlue: 0\t\n", - "21.000 Set Blue Actinic: 50\n", - "21.000 Blue Actinic ON\n", - "41.000 Meas 20\t Interval: 1.000 sec \t Take 20.00 seconds\tAct:200\tRed: 50\tBlue: 50\t\n", - "41.000 Blue Actinic OFF\n", - "42.000 Meas 10\t Interval: 0.100 sec \t Take 1.00 seconds\tAct: 0\tRed: 50\tBlue: 0\t\n", - "42.000 Red Actinic OFF\n", - "43.000 Meas 10\t Interval: 0.100 sec \t Take 1.00 seconds\tAct: 0\tRed: 0\tBlue: 0\t\n" - ] - } - ], - "source": [ - "## \"A\": External Actinic light:\n", - "# [\"A\", \"B\" or \"R\", Intensity (0 - 1000)]\n", - "# \"B\" = Blue LED\n", - "# \"R\" = Red LED\n", - "# The PAR is ~ Intensity x 10, you need to measure it in your setup\n", - "# !!!!NOTE: Due to hardware limitation, All LED should no be on for long time. \n", - "# For Red and Blue External, Suggested limitations are:\n", - "# Intensity | Duration (s)\n", - "# <50 | No limit\n", - "# 50 - 100 | <2min\n", - "# 100-200 | <10s\n", - "# 200-500 | < 2s\n", - "# 500+ | <0.5s\n", - "\n", - "\n", - "Example_protocol = [\n", - " ['M', 10, 0.1, 0],\n", - " ['A', \"R\", 50],\n", - " ['M', 20, 1, 0],\n", - " ['A', \"B\", 50],\n", - " ['M', 20, 1, 200],\n", - " ['A', \"B\", 0],\n", - " ['M', 10, 0.1, 0],\n", - " ['A', \"R\", 0],\n", - " ['M', 10, 0.1, 0]\n", - " ]\n", - "print_protocol(Example_protocol)" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "1.000 Meas 10\t Interval: 0.100 sec \t Take 1.00 seconds\tAct: 0\tRed: 0\tBlue: 0\t\n", - "1.000 Set Red Actinic: 50\n", - "1.000 Red Actinic ON\n", - "21.000 Meas 20\t Interval: 1.000 sec \t Take 20.00 seconds\tAct: 0\tRed: 50\tBlue: 0\t\n", - "21.000 Set Blue Actinic: 50\n", - "21.000 Blue Actinic ON\n", - "41.000 Meas 20\t Interval: 1.000 sec \t Take 20.00 seconds\tAct:200\tRed: 50\tBlue: 50\t\n", - "41.000 Update plot\n", - "41.000 Sleep for: 10 sec with \tAct:200\tRed: 50\tBlue: 50\t\n", - "51.000 Red Actinic OFF\n", - "52.000 Meas 10\t Interval: 0.100 sec \t Take 1.00 seconds\tAct: 0\tRed: 0\tBlue: 50\t\n" - ] - } - ], - "source": [ - "## \"W\": Wait:\n", - "# [\"W\", Wait (seconds)] \n", - "## \"P\": Update ploat:\n", - "# [\"P\"] \n", - "# Update plot will take an unknown amount of time (100ms to 1s?), and protocol will pause during updating. Only update figure at non-timing-critical step. \n", - "\n", - "Example_protocol = [\n", - " ['M', 10, 0.1, 0],\n", - " ['A', \"R\", 50],\n", - " ['M', 20, 1, 0],\n", - " ['A', \"B\", 50],\n", - " ['M', 20, 1, 200],\n", - " ['P'],\n", - " ['W', 10],\n", - " ['A', \"R\", 0],\n", - " ['M', 10, 0.1, 0]\n", - " ]\n", - "print_protocol(Example_protocol)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [], - "source": [ - "# Here are some simple protocols for calibration and testing:\n", - "\n", - "ambit_actinic_test = [['M', 5, 1, 250]] # Calibrate the real PAR using ambit actinic: 250 = 2400uE\n", - "Blue_actinic_test = [['A', \"B\", 250], [\"W\", 5]] # Calibrate the real PAR using Blue LED: 250 = 2800uE\n", - "Red_actinic_test = [['A', \"R\", 250], [\"W\", 2]] # Calibrate the real PAR using Red LED: 250 = 3200uE\n", - "signal_offset_protocol = [['M', 50, .1, 0]] # Get_offset. Put no chlorophyll, measure the baseline, and substract if from latter measurements\n" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "10.000 Meas 100\t Interval: 0.100 sec \t Take 10.00 seconds\tAct: 0\tRed: 0\tBlue: 0\t\n", - "11.000 Meas 10\t Interval: 0.100 sec \t Take 1.00 seconds\tAct: 0\tRed: 0\tBlue: 0\t\n", - "12.250 Meas 250\t Interval: 0.005 sec \t Take 1.25 seconds\tAct:254\tRed: 0\tBlue: 0\t\n", - "12.450 Meas 20\t Interval: 0.010 sec \t Take 0.20 seconds\tAct: 0\tRed: 0\tBlue: 0\t\n", - "14.450 Meas 20\t Interval: 0.100 sec \t Take 2.00 seconds\tAct: 0\tRed: 0\tBlue: 0\t\n", - "24.450 Meas 100\t Interval: 0.100 sec \t Take 10.00 seconds\tAct: 0\tRed: 0\tBlue: 0\t\n" - ] - } - ], - "source": [ - "## protocol blocks\n", - "# It might be easier to write protocols with small blocks\n", - "# Each block can be tested seperatedly and merge together\n", - "\n", - "# e.g. Here's a saturation flash block\n", - "Sat_Flash = [ \n", - " ['M', 10, 0.1, 0],\n", - " ['M', 250, 0.005, 254],\n", - " ['M', 20, 0.01, 0],\n", - " ['M', 20, 0.1, 0]\n", - " ]\n", - "\n", - "# To merge it in a large protocol, use Python list append:\n", - "Protocol_Eg1 = [\n", - " ['M', 100, .1, 0],\n", - " *Sat_Flash,\n", - " ['M', 100, .1, 0]\n", - " ]\n", - "\n", - "print_protocol(Protocol_Eg1)" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "60.000 Meas 60\t Interval: 1.000 sec \t Take 60.00 seconds\tAct: 0\tRed: 0\tBlue: 0\t\n", - "61.000 Meas 10\t Interval: 0.100 sec \t Take 1.00 seconds\tAct: 0\tRed: 0\tBlue: 0\t\n", - "62.250 Meas 250\t Interval: 0.005 sec \t Take 1.25 seconds\tAct:254\tRed: 0\tBlue: 0\t\n", - "62.450 Meas 20\t Interval: 0.010 sec \t Take 0.20 seconds\tAct: 0\tRed: 0\tBlue: 0\t\n", - "64.450 Meas 20\t Interval: 0.100 sec \t Take 2.00 seconds\tAct: 0\tRed: 0\tBlue: 0\t\n", - "65.450 Meas 10\t Interval: 0.100 sec \t Take 1.00 seconds\tAct: 0\tRed: 0\tBlue: 0\t\n", - "65.450 Set Blue Actinic: 10\n", - "65.450 Blue Actinic ON\n", - "69.450 Meas 20\t Interval: 0.200 sec \t Take 4.00 seconds\tAct: 0\tRed: 0\tBlue: 10\t\n", - "69.450 Update plot\n", - "129.450 Meas 60\t Interval: 1.000 sec \t Take 60.00 seconds\tAct: 0\tRed: 0\tBlue: 10\t\n", - "130.450 Meas 10\t Interval: 0.100 sec \t Take 1.00 seconds\tAct: 0\tRed: 0\tBlue: 10\t\n", - "131.700 Meas 250\t Interval: 0.005 sec \t Take 1.25 seconds\tAct:254\tRed: 0\tBlue: 10\t\n", - "131.900 Meas 20\t Interval: 0.010 sec \t Take 0.20 seconds\tAct: 0\tRed: 0\tBlue: 10\t\n", - "133.900 Meas 20\t Interval: 0.100 sec \t Take 2.00 seconds\tAct: 0\tRed: 0\tBlue: 10\t\n", - "135.900 Meas 10\t Interval: 0.200 sec \t Take 2.00 seconds\tAct: 0\tRed: 0\tBlue: 10\t\n", - "135.900 Update plot\n", - "136.900 Meas 10\t Interval: 0.100 sec \t Take 1.00 seconds\tAct: 0\tRed: 0\tBlue: 10\t\n", - "138.150 Meas 250\t Interval: 0.005 sec \t Take 1.25 seconds\tAct:254\tRed: 0\tBlue: 10\t\n", - "138.350 Meas 20\t Interval: 0.010 sec \t Take 0.20 seconds\tAct: 0\tRed: 0\tBlue: 10\t\n", - "140.350 Meas 20\t Interval: 0.100 sec \t Take 2.00 seconds\tAct: 0\tRed: 0\tBlue: 10\t\n", - "142.350 Meas 10\t Interval: 0.200 sec \t Take 2.00 seconds\tAct: 0\tRed: 0\tBlue: 10\t\n", - "142.350 Update plot\n", - "143.350 Meas 10\t Interval: 0.100 sec \t Take 1.00 seconds\tAct: 0\tRed: 0\tBlue: 10\t\n", - "144.600 Meas 250\t Interval: 0.005 sec \t Take 1.25 seconds\tAct:254\tRed: 0\tBlue: 10\t\n", - "144.800 Meas 20\t Interval: 0.010 sec \t Take 0.20 seconds\tAct: 0\tRed: 0\tBlue: 10\t\n", - "146.800 Meas 20\t Interval: 0.100 sec \t Take 2.00 seconds\tAct: 0\tRed: 0\tBlue: 10\t\n", - "148.800 Meas 10\t Interval: 0.200 sec \t Take 2.00 seconds\tAct: 0\tRed: 0\tBlue: 10\t\n", - "148.800 Update plot\n", - "148.800 Blue Actinic OFF\n", - "158.800 Meas 50\t Interval: 0.200 sec \t Take 10.00 seconds\tAct: 0\tRed: 0\tBlue: 0\t\n", - "159.800 Meas 10\t Interval: 0.100 sec \t Take 1.00 seconds\tAct: 0\tRed: 0\tBlue: 0\t\n", - "161.050 Meas 250\t Interval: 0.005 sec \t Take 1.25 seconds\tAct:254\tRed: 0\tBlue: 0\t\n", - "161.250 Meas 20\t Interval: 0.010 sec \t Take 0.20 seconds\tAct: 0\tRed: 0\tBlue: 0\t\n", - "163.250 Meas 20\t Interval: 0.100 sec \t Take 2.00 seconds\tAct: 0\tRed: 0\tBlue: 0\t\n", - "173.250 Meas 50\t Interval: 0.200 sec \t Take 10.00 seconds\tAct: 0\tRed: 0\tBlue: 0\t\n", - "173.250 Update plot\n", - "174.250 Meas 10\t Interval: 0.100 sec \t Take 1.00 seconds\tAct: 0\tRed: 0\tBlue: 0\t\n", - "175.500 Meas 250\t Interval: 0.005 sec \t Take 1.25 seconds\tAct:254\tRed: 0\tBlue: 0\t\n", - "175.700 Meas 20\t Interval: 0.010 sec \t Take 0.20 seconds\tAct: 0\tRed: 0\tBlue: 0\t\n", - "177.700 Meas 20\t Interval: 0.100 sec \t Take 2.00 seconds\tAct: 0\tRed: 0\tBlue: 0\t\n", - "202.700 Meas 50\t Interval: 0.500 sec \t Take 25.00 seconds\tAct: 0\tRed: 0\tBlue: 0\t\n", - "202.700 Update plot\n", - "203.700 Meas 10\t Interval: 0.100 sec \t Take 1.00 seconds\tAct: 0\tRed: 0\tBlue: 0\t\n", - "204.950 Meas 250\t Interval: 0.005 sec \t Take 1.25 seconds\tAct:254\tRed: 0\tBlue: 0\t\n", - "205.150 Meas 20\t Interval: 0.010 sec \t Take 0.20 seconds\tAct: 0\tRed: 0\tBlue: 0\t\n", - "207.150 Meas 20\t Interval: 0.100 sec \t Take 2.00 seconds\tAct: 0\tRed: 0\tBlue: 0\t\n", - "257.150 Meas 50\t Interval: 1.000 sec \t Take 50.00 seconds\tAct: 0\tRed: 0\tBlue: 0\t\n", - "257.150 Update plot\n" - ] - } - ], - "source": [ - "Sat_Flash = [ \n", - " ['M', 10, 0.1, 0],\n", - " ['M', 250, 0.005, 254],\n", - " ['M', 20, 0.01, 0],\n", - " ['M', 20, 0.1, 0]\n", - " ]\n", - "\n", - "Protocol_1 = [\n", - " ['M', 60, 1, 0],\n", - " *Sat_Flash,\n", - " ['M', 10, 0.1, 0],\n", - " ['A', \"B\", 10],\n", - " ['M', 20, 0.2, 0],\n", - " ['P'],\n", - "\n", - " ['M', 60, 1, 0],\n", - "\n", - " *Sat_Flash,\n", - " ['M', 10, 0.2, 0],\n", - " ['P'],\n", - "\n", - " *Sat_Flash,\n", - " ['M', 10, 0.2, 0],\n", - " ['P'],\n", - "\n", - " *Sat_Flash,\n", - " ['M', 10, 0.2, 0],\n", - " ['P'],\n", - "\n", - " ['A', \"B\", 0],\n", - " ['M', 50, 0.2, 0],\n", - "\n", - " *Sat_Flash,\n", - " ['M', 50, 0.2, 0],\n", - " ['P'],\n", - "\n", - " *Sat_Flash,\n", - " ['M', 50, 0.5, 0],\n", - " ['P'],\n", - "\n", - " *Sat_Flash,\n", - " ['M', 50, 1, 0],\n", - " ['P'],\n", - " \n", - " \n", - "]\n", - "\n", - "print_protocol(Protocol_1)" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "NEW Name Here Ready\n", - "Start\n", - "Run\n", - "Stop\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "## This block run the protocol\n", - "# Change the protocol want to run:\n", - "run_protocol = Protocol_Eg1\n", - "# Signal offset when no exist\n", - "OFFSET = 4000\n", - "# Set the Serial ports for devices:\n", - "# If auto port detection doesn't work, put in Serial ports manually.\n", - "\n", - "ser = serial.Serial(Ambit_Port, 115200, rtscts=False) # This is Ambit\n", - "try:\n", - " ser_pulser = serial.Serial(Pulser_Port, 115200, dsrdtr= True, rtscts=False) # This is external LED\n", - "except:\n", - " ser.close()\n", - " raise ConnectionRefusedError\n", - " \n", - "\n", - "\n", - "\n", - "\n", - "\n", - "#\n", - "fig, axis = plt.subplots(1,1,figsize = (12,6))\n", - "START_TIME = time.time()\n", - "try:\n", - " _wait_for_line(ser, target = \"NEW Name\", input = \"hello\", print_out=True)\n", - " if not _wait_for_line(ser, target = \"Start\", input = \"ww\", print_out=True):\n", - " ser.write(b'E\\n')\n", - " raise NameError(\"Function not started\")\n", - " \n", - " if not _wait_for_line(ser, target = \"Run\", input = \"\", print_out=True):\n", - " ser.write(b'E\\n')\n", - " raise NameError(\"Run not started\") \n", - "\n", - "\n", - " _act_ambit, _act_blue, _act_red, act_blue, act_red = -1, -1, -1, 0, 0\n", - " _data = []\n", - " for _l in run_protocol:\n", - "\n", - " if _l[0] == 'M' and len(_l) == 4: # Run measurement\n", - " \n", - " if (_act_ambit != _l[3]): # Set ambit actinic\n", - " _act_ambit = Ambit_actinic(ser, _l[3])\n", - " if (_l[1] < 1): continue # no data\n", - " for _ in range(_l[1]):\n", - " _ts = time.perf_counter()\n", - " _ret = Trigger(ser)\n", - " if _ret != {}: \n", - " _ret.update({\"ACT\":_act_ambit,\"Blue\":act_blue,\"Red\":act_red}.copy())\n", - " _data.append(_ret)\n", - " _elapsed = time.perf_counter() - _ts\n", - " if _elapsed < _l[2]: time.sleep(_l[2] - _elapsed)\n", - "\n", - " if _l[0] == 'A' and len(_l) == 3: # Change Actinic\n", - " if _l[1] == \"B\":\n", - " if _l[2] > 0:\n", - " if _act_blue != _l[2]: _act_blue = DAC_set(ser_pulser, 2, _l[2])\n", - " DAC_ONOFF(ser_pulser, 2, True)\n", - " act_blue = _act_blue\n", - " else: \n", - " DAC_ONOFF(ser_pulser, 2, False)\n", - " act_blue = 0\n", - " \n", - " if _l[1] == \"R\":\n", - " if _l[2] > 0:\n", - " if _act_red != _l[2]: _act_red= DAC_set(ser_pulser, 4, _l[2])\n", - " DAC_ONOFF(ser_pulser, 4, True)\n", - " act_red = _act_red\n", - " else: \n", - " DAC_ONOFF(ser_pulser, 4, False)\n", - " act_red = 0\n", - " \n", - "\n", - " if _l[0] == 'W' and len(_l) == 2:\n", - " time.sleep(_l[1])\n", - "\n", - " if _l[0] == 'P':\n", - " _plot_data = pd.DataFrame(_data)\n", - " axis.clear()\n", - " axis.plot(_plot_data['T']/1000, (_plot_data['S'] - OFFSET) / _plot_data['R'])\n", - " display(fig)\n", - " clear_output(True)\n", - " \n", - "\n", - "\n", - " \n", - "\n", - " DAC_ONOFF(ser_pulser, 0, False)\n", - " Ambit_actinic(ser, 0)\n", - "\n", - " if not _wait_for_line(ser, target = \"Stop\", input = \"E\", print_out=True):\n", - " ser.write(b'E\\n')\n", - " raise NameError(\"Run not Stopped\")\n", - " \n", - "finally:\n", - " ser.close()\n", - " ser_pulser.close()\n", - "\n", - "\n", - "data = pd.DataFrame(_data)\n", - "data.attrs['OFFSET'] = OFFSET\n", - "data.attrs['START_TIME'] = START_TIME\n", - "data.attrs['protocol'] = run_protocol" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{'OFFSET': 4000,\n", - " 'START_TIME': 1738691730.8549724,\n", - " 'protocol': [['M', 100, 0.1, 0],\n", - " ['M', 10, 0.1, 0],\n", - " ['M', 250, 0.005, 254],\n", - " ['M', 20, 0.01, 0],\n", - " ['M', 20, 0.1, 0],\n", - " ['M', 100, 0.1, 0]]}" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "data.attrs" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
TSRFBACTBlueRed
0579251553929561549000
11038160183951185888000
22038189194461043868000
33048192185951066851000
44048205182491081842000
...........................
492242978479182371523836000
493243988489182411444836000
494244988466182411365832000
495245988486182431373840000
496246988468182421331833000
\n", - "

497 rows × 8 columns

\n", - "
" - ], - "text/plain": [ - " T S R F B ACT Blue Red\n", - "0 5 7925 15539 2956 1549 0 0 0\n", - "1 103 8160 18395 1185 888 0 0 0\n", - "2 203 8189 19446 1043 868 0 0 0\n", - "3 304 8192 18595 1066 851 0 0 0\n", - "4 404 8205 18249 1081 842 0 0 0\n", - ".. ... ... ... ... ... ... ... ...\n", - "492 24297 8479 18237 1523 836 0 0 0\n", - "493 24398 8489 18241 1444 836 0 0 0\n", - "494 24498 8466 18241 1365 832 0 0 0\n", - "495 24598 8486 18243 1373 840 0 0 0\n", - "496 24698 8468 18242 1331 833 0 0 0\n", - "\n", - "[497 rows x 8 columns]" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "data" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 15, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.plot(data['T'], data['S']/data['R'])" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "base", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.12.3" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/.vscode/examples/Untitled-1_temp.ipynb b/.vscode/examples/Untitled-1_temp.ipynb deleted file mode 100644 index 082b984..0000000 --- a/.vscode/examples/Untitled-1_temp.ipynb +++ /dev/null @@ -1,685 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "import serial\n", - "import serial.tools.list_ports\n", - "import numpy as np\n", - "import time\n", - "import matplotlib.pyplot as plt\n", - "from IPython.display import clear_output, display\n", - "import pandas as pd\n", - "plt.style.use('dark_background')" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Found USB devices:\tUSB VID:PID=1A86:55D4 SER=554C028532 LOCATION=1-4.2\n", - "Ambit Likely at:\tCOM10\n", - "Pulser not Found\n" - ] - } - ], - "source": [ - "Ambit_Port = \"\"\n", - "Pulser_Port = \"\"\n", - "ports = serial.tools.list_ports.comports()\n", - "for port, desc, hwid in sorted(ports):\n", - " if hwid[:4] == \"USB \":\n", - " print(f'Found USB devices:\\t{hwid}')\n", - " devices = hwid[4:].split(\" \")\n", - " if len(devices) > 1 and len(devices[0]) > 9:\n", - " if devices[0][-9:] == \"1A86:55D4\":\n", - " print(f'Ambit Likely at:\\t{port}')\n", - " Ambit_Port = port\n", - " if devices[0][-9:] == \"303A:1001\":\n", - " print(f'Pulser Likely at:\\t{port}')\n", - " Pulser_Port = port\n", - "\n", - "if Ambit_Port == \"\": print(f'Ambit not Found')\n", - "\n", - "if Pulser_Port == \"\": print(f'Pulser not Found')" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [], - "source": [ - "def _readline(ser: serial.Serial, timeout: int):\n", - " _t0 = time.time()\n", - " s = \"\"\n", - " while (time.time() - _t0 < timeout):\n", - " if ser.in_waiting > 0:\n", - " c = ser.read()\n", - " if (c > bytes([0])) and (c < bytes([128])):\n", - " if (c == b'\\n') or (c == b'\\r'):\n", - " if s == \"\":\n", - " pass\n", - " elif len(s) > 2:\n", - " return s\n", - " else:\n", - " s += c.decode()\n", - " \n", - " return s\n", - "\n", - "def _wait_for_line(ser: serial.Serial, target: str, input: str = \"\", timeout: float = 1.0, print_out = False):\n", - " if input != \"\":\n", - " ser.write((input + \"\\n\").encode())\n", - " t0 = time.time()\n", - " timeout_t = t0 + timeout\n", - " condition = False\n", - " while (condition == False):\n", - " _l = _readline(ser, 0.25)\n", - " if target in _l:\n", - " condition = True\n", - " if print_out:\n", - " if _l != \"\": print(_l)\n", - " if time.time() > timeout_t:\n", - " break\n", - "\n", - " return condition\n", - "\n", - " \n", - "def _parse_data_line(l:str)->dict:\n", - " ret = {}\n", - " if len(l) > 5:\n", - " if (l[:2] == \"T:\") and (\",\" in l) and (\":\" in l):\n", - " items = [n.split(':') for n in l.split(',') if \":\" in n]\n", - " for i in items:\n", - " k = i[0]\n", - " v = i[1]\n", - " if len(k) > 0:\n", - " if v.isdecimal():\n", - " ret.update({k: int(v)})\n", - " if (v.count(\".\") == 1) and v.replace(\".\", \"0\").isdecimal():\n", - " ret.update({k: float(v)})\n", - "\n", - " return ret \n", - "\n", - "\n", - "def Trigger(ser: serial.Serial) -> dict:\n", - " ser.write(b\"G\")\n", - " ser.flush()\n", - " _ret = _parse_data_line(_readline(ser, .5))\n", - " return _ret\n", - "\n", - "def Ambit_actinic(ser: serial.Serial, v:int)->int:\n", - " if (v > 255): return -1\n", - " ser.write(bytes([65, v]))\n", - " ser.flush()\n", - " return v\n", - " \n", - "\n", - "def DAC_set(ser: serial.Serial, ch:int, v:int):\n", - " ret = False\n", - " if (ch == 2) or (ch == 4):\n", - " if (v > -1) and (v < 4095):\n", - " ret = _wait_for_line(ser, target = \"Done\", input = f'DAC,{ch},{v},\\n', print_out=False)\n", - " if ret == False: \n", - " print(\"DAC_set error\", ch, v)\n", - " return -1\n", - " return v\n", - "\n", - "def DAC_ONOFF(ser: serial.Serial, ch:int, onoff:bool):\n", - " if onoff:\n", - " if (ch == 2) or (ch == 4):\n", - " _wait_for_line(ser, target = \"Done\", input = f'LED_ON,{ch},\\n', print_out=False)\n", - " else:\n", - " if (ch == 2) or (ch == 4):\n", - " _wait_for_line(ser, target = \"Done\", input = f'LED_OFF,{ch},\\n', print_out=False)\n", - " else:\n", - " _wait_for_line(ser, target = \"Done\", input = f'LED_OFF,0,\\n', print_out=False)\n", - "\n", - "# plot autoscale\n", - "def autoscale(data: list, axis:plt.Axes):\n", - " if len(data) == 0: return\n", - " if len(data) == 1: \n", - " axis.set_ylim([data[0]-1, data[0]+1])\n", - " return \n", - " l, h = axis.get_ylim()\n", - " x, d = np.min(data), np.max(data)\n", - " r = d - x\n", - "\n", - " _l, _h, a = l, h, False\n", - " if (x < l) or (l < x - r):\n", - " _l = x - 0.05 * r\n", - " a = True\n", - " if (d > h) or (h > l + r):\n", - " _h = d + 0.05 * r\n", - " a = True\n", - " if a and _l != _h:\n", - " axis.set_ylim([_l, _h])\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "metadata": {}, - "outputs": [], - "source": [ - "ser.close()" - ] - }, - { - "cell_type": "code", - "execution_count": 31, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "fig, axis = plt.subplots(1,1,figsize = (12,6))\n", - "ser = serial.Serial(Ambit_Port, 115200, rtscts=False) # This is Ambit\n", - "\n", - "l1 = axis.plot([0], 'g')\n", - "l2 = axis.plot([0], 'g--')\n", - "ax = axis.twinx()\n", - "l3 = ax.plot([0], 'r')\n", - "\n", - "START_TIME = time.time()\n", - "T1, S, R, F, B = [], [], [], [], []\n", - "T2, Temp1, Temp2 = [], [], []\n", - "try:\n", - " _wait_for_line(ser, target = \"NEW Name\", input = \"hello\", print_out=True)\n", - " if not _wait_for_line(ser, target = \"Start\", input = \"ww\", print_out=True):\n", - " ser.write(b'E\\n')\n", - " raise NameError(\"Function not started\")\n", - " \n", - " if not _wait_for_line(ser, target = \"Run\", input = \"\", print_out=True):\n", - " ser.write(b'E\\n')\n", - " raise NameError(\"Run not started\") \n", - " plot_timer = 0\n", - " while True:\n", - " try:\n", - " _ret = Trigger(ser)\n", - " if _ret != {}: \n", - " T1.append(_ret['T']/1000)\n", - " S.append(_ret['S']/_ret['R'])\n", - " # R.append(_ret['R'])\n", - " # F.append(_ret['F'])\n", - " # B.append(_ret['B'])\n", - " l3[0].set_xdata(T1)\n", - " l3[0].set_ydata(S)\n", - " \n", - "\n", - " ser.write(b\"T\")\n", - " ser.flush()\n", - " _ret = _parse_data_line(_readline(ser, .5))\n", - " if _ret != {}: \n", - " T2.append(_ret['T']/1000)\n", - " Temp1.append(_ret['o'])\n", - " Temp2.append(_ret['a'])\n", - " l1[0].set_xdata(T2)\n", - " l2[0].set_xdata(T2)\n", - " l1[0].set_ydata(Temp1)\n", - " l2[0].set_ydata(Temp2)\n", - "\n", - " if time.perf_counter() - plot_timer > 1: \n", - " autoscale(S, ax) \n", - " autoscale(Temp1, axis)\n", - "\n", - " axis.set_xlim([-1, max(T1[-1], T2[-1]) + 1])\n", - " display(fig)\n", - " clear_output(True)\n", - " plot_timer = time.perf_counter()\n", - "\n", - " except KeyboardInterrupt:\n", - " break\n", - " \n", - " \n", - "\n", - "finally:\n", - " ser.write(b'E\\n')\n", - " ser.close()" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[23]" - ] - }, - "execution_count": 19, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "T2" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "NEW Name Here Ready\n", - "Start\n", - "Run\n", - "Stop\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "## This block run the protocol\n", - "# Change the protocol want to run:\n", - "run_protocol = Protocol_Eg1\n", - "# Signal offset when no exist\n", - "OFFSET = 4000\n", - "# Set the Serial ports for devices:\n", - "# If auto port detection doesn't work, put in Serial ports manually.\n", - "\n", - "ser = serial.Serial(Ambit_Port, 115200, rtscts=False) # This is Ambit\n", - "try:\n", - " ser_pulser = serial.Serial(Pulser_Port, 115200, dsrdtr= True, rtscts=False) # This is external LED\n", - "except:\n", - " ser.close()\n", - " raise ConnectionRefusedError\n", - " \n", - "\n", - "\n", - "\n", - "\n", - "\n", - "#\n", - "fig, axis = plt.subplots(1,1,figsize = (12,6))\n", - "START_TIME = time.time()\n", - "try:\n", - " _wait_for_line(ser, target = \"NEW Name\", input = \"hello\", print_out=True)\n", - " if not _wait_for_line(ser, target = \"Start\", input = \"ww\", print_out=True):\n", - " ser.write(b'E\\n')\n", - " raise NameError(\"Function not started\")\n", - " \n", - " if not _wait_for_line(ser, target = \"Run\", input = \"\", print_out=True):\n", - " ser.write(b'E\\n')\n", - " raise NameError(\"Run not started\") \n", - "\n", - "\n", - " _act_ambit, _act_blue, _act_red, act_blue, act_red = -1, -1, -1, 0, 0\n", - " _data = []\n", - " for _l in run_protocol:\n", - "\n", - " if _l[0] == 'M' and len(_l) == 4: # Run measurement\n", - " \n", - " if (_act_ambit != _l[3]): # Set ambit actinic\n", - " _act_ambit = Ambit_actinic(ser, _l[3])\n", - " if (_l[1] < 1): continue # no data\n", - " for _ in range(_l[1]):\n", - " _ts = time.perf_counter()\n", - " _ret = Trigger(ser)\n", - " if _ret != {}: \n", - " _ret.update({\"ACT\":_act_ambit,\"Blue\":act_blue,\"Red\":act_red}.copy())\n", - " _data.append(_ret)\n", - " _elapsed = time.perf_counter() - _ts\n", - " if _elapsed < _l[2]: time.sleep(_l[2] - _elapsed)\n", - "\n", - " if _l[0] == 'A' and len(_l) == 3: # Change Actinic\n", - " if _l[1] == \"B\":\n", - " if _l[2] > 0:\n", - " if _act_blue != _l[2]: _act_blue = DAC_set(ser_pulser, 2, _l[2])\n", - " DAC_ONOFF(ser_pulser, 2, True)\n", - " act_blue = _act_blue\n", - " else: \n", - " DAC_ONOFF(ser_pulser, 2, False)\n", - " act_blue = 0\n", - " \n", - " if _l[1] == \"R\":\n", - " if _l[2] > 0:\n", - " if _act_red != _l[2]: _act_red= DAC_set(ser_pulser, 4, _l[2])\n", - " DAC_ONOFF(ser_pulser, 4, True)\n", - " act_red = _act_red\n", - " else: \n", - " DAC_ONOFF(ser_pulser, 4, False)\n", - " act_red = 0\n", - " \n", - "\n", - " if _l[0] == 'W' and len(_l) == 2:\n", - " time.sleep(_l[1])\n", - "\n", - " if _l[0] == 'P':\n", - " _plot_data = pd.DataFrame(_data)\n", - " axis.clear()\n", - " axis.plot(_plot_data['T']/1000, (_plot_data['S'] - OFFSET) / _plot_data['R'])\n", - " display(fig)\n", - " clear_output(True)\n", - " \n", - "\n", - "\n", - " \n", - "\n", - " DAC_ONOFF(ser_pulser, 0, False)\n", - " Ambit_actinic(ser, 0)\n", - "\n", - " if not _wait_for_line(ser, target = \"Stop\", input = \"E\", print_out=True):\n", - " ser.write(b'E\\n')\n", - " raise NameError(\"Run not Stopped\")\n", - " \n", - "finally:\n", - " ser.close()\n", - " ser_pulser.close()\n", - "\n", - "\n", - "data = pd.DataFrame(_data)\n", - "data.attrs['OFFSET'] = OFFSET\n", - "data.attrs['START_TIME'] = START_TIME\n", - "data.attrs['protocol'] = run_protocol" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{'OFFSET': 4000,\n", - " 'START_TIME': 1738691730.8549724,\n", - " 'protocol': [['M', 100, 0.1, 0],\n", - " ['M', 10, 0.1, 0],\n", - " ['M', 250, 0.005, 254],\n", - " ['M', 20, 0.01, 0],\n", - " ['M', 20, 0.1, 0],\n", - " ['M', 100, 0.1, 0]]}" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "data.attrs" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
TSRFBACTBlueRed
0579251553929561549000
11038160183951185888000
22038189194461043868000
33048192185951066851000
44048205182491081842000
...........................
492242978479182371523836000
493243988489182411444836000
494244988466182411365832000
495245988486182431373840000
496246988468182421331833000
\n", - "

497 rows × 8 columns

\n", - "
" - ], - "text/plain": [ - " T S R F B ACT Blue Red\n", - "0 5 7925 15539 2956 1549 0 0 0\n", - "1 103 8160 18395 1185 888 0 0 0\n", - "2 203 8189 19446 1043 868 0 0 0\n", - "3 304 8192 18595 1066 851 0 0 0\n", - "4 404 8205 18249 1081 842 0 0 0\n", - ".. ... ... ... ... ... ... ... ...\n", - "492 24297 8479 18237 1523 836 0 0 0\n", - "493 24398 8489 18241 1444 836 0 0 0\n", - "494 24498 8466 18241 1365 832 0 0 0\n", - "495 24598 8486 18243 1373 840 0 0 0\n", - "496 24698 8468 18242 1331 833 0 0 0\n", - "\n", - "[497 rows x 8 columns]" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "data" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 15, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.plot(data['T'], data['S']/data['R'])" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "base", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.12.3" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/.vscode/examples/Untitled-2.ipynb b/.vscode/examples/Untitled-2.ipynb deleted file mode 100644 index 42833ec..0000000 --- a/.vscode/examples/Untitled-2.ipynb +++ /dev/null @@ -1,277 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "import serial\n", - "import numpy as np\n", - "import time\n", - "import matplotlib.pyplot as plt\n", - "from IPython.display import clear_output, display\n", - "import pandas as pd\n", - "from collections import namedtuple\n", - "plt.style.use('dark_background')" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "def _readline(ser: serial.Serial, timeout: int):\n", - " _t0 = time.time()\n", - " s = \"\"\n", - " while (time.time() - _t0 < timeout):\n", - " if ser.in_waiting > 0:\n", - " c = ser.read()\n", - " if (c > bytes([0])) and (c < bytes([128])):\n", - " if (c == b'\\n') or (c == b'\\r'):\n", - " if s == \"\":\n", - " pass\n", - " elif len(s) > 2:\n", - " return s\n", - " else:\n", - " s += c.decode()\n", - " \n", - " return s\n", - "\n", - "def _wait_for_line(ser: serial.Serial, target: str, input: str = \"\", timeout: float = 1.0, print_out = False):\n", - " if input != \"\":\n", - " ser.write((input + \"\\n\").encode())\n", - " t0 = time.time()\n", - " timeout_t = t0 + timeout\n", - " condition = False\n", - " while (condition == False):\n", - " _l = _readline(ser, 0.25)\n", - " if target in _l:\n", - " condition = True\n", - " if print_out:\n", - " if _l != \"\": print(_l)\n", - " if time.time() > timeout_t:\n", - " break\n", - "\n", - " return condition\n", - "\n", - " \n", - "def _parse_data_line(l:str)->dict:\n", - " ret = {}\n", - " if len(l) > 5:\n", - " if (l[:2] == \"T:\") and (\",\" in l) and (\":\" in l):\n", - " items = [n.split(':') for n in l.split(',') if \":\" in n]\n", - " for i in items:\n", - " k = i[0]\n", - " v = i[1]\n", - " if len(k) > 0:\n", - " if v.isdecimal():\n", - " ret.update({k: int(v)})\n", - " if (v.count(\".\") == 1) and v.replace(\".\", \"0\").isdecimal():\n", - " ret.update({k: float(v)})\n", - "\n", - " return ret \n", - "\n", - "\n", - "def Trigger(ser: serial.Serial) -> dict:\n", - " ser.write(b\"G\")\n", - " ser.flush()\n", - " _ret = _parse_data_line(_readline(ser, .5))\n", - " return _ret\n", - "\n", - "def Ambit_actinic(ser: serial.Serial, v:int)->int:\n", - " if (v > 255): return -1\n", - " ser.write(bytes([65, v]))\n", - " ser.flush()\n", - " return v\n", - " \n", - "\n", - "def DAC_set(ser: serial.Serial, ch:int, v:int):\n", - " ret = False\n", - " if (ch == 2) or (ch == 4):\n", - " if (v > -1) and (v < 4095):\n", - " ret = _wait_for_line(ser, target = \"Done\", input = f'DAC,{ch},{v},\\n', print_out=False)\n", - " if ret == False: \n", - " print(\"DAC_set error\", ch, v)\n", - " return -1\n", - " return v\n", - "\n", - "def DAC_ONOFF(ser: serial.Serial, ch:int, onoff:bool):\n", - " if onoff:\n", - " if (ch == 2) or (ch == 4):\n", - " _wait_for_line(ser, target = \"Done\", input = f'LED_ON,{ch},\\n', print_out=False)\n", - " else:\n", - " if (ch == 2) or (ch == 4):\n", - " _wait_for_line(ser, target = \"Done\", input = f'LED_OFF,{ch},\\n', print_out=False)\n", - " else:\n", - " _wait_for_line(ser, target = \"Done\", input = f'LED_OFF,0,\\n', print_out=False)\n", - "\n", - "# plot autoscale\n", - "def autoscale(data: list, axis:plt.Axes):\n", - " if len(data) == 0: return\n", - " if len(data) == 1: \n", - " axis.set_ylim([data[0]-1, data[0]+1])\n", - " return \n", - " l, h = axis.get_ylim()\n", - " x, d = np.min(data), np.max(data)\n", - " r = d - x\n", - "\n", - " _l, _h, a = l, h, False\n", - " if (x < l) or (l < x - r):\n", - " _l = x - 0.05 * r\n", - " a = True\n", - " if (d > h) or (h > l + r):\n", - " _h = d + 0.05 * r\n", - " a = True\n", - " if a and _l != _h:\n", - " axis.set_ylim([_l, _h])" - ] - }, - { - "cell_type": "code", - "execution_count": 48, - "metadata": {}, - "outputs": [], - "source": [ - "protocol = [['M', 100, 0.001, 0]]" - ] - }, - { - "cell_type": "code", - "execution_count": 49, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "NEW Name Here Ready\n", - "Start\n", - "Run\n", - "Stop\n" - ] - } - ], - "source": [ - "ser = serial.Serial(\"COM9\", 115200, rtscts=False)\n", - "START_TIME = time.time()\n", - "try:\n", - " _wait_for_line(ser, target = \"NEW Name\", input = \"hello\", print_out=True)\n", - " if not _wait_for_line(ser, target = \"Start\", input = \"ff,190\", print_out=True):\n", - " ser.write(b'E\\n')\n", - " raise NameError(\"Function not started\")\n", - " \n", - " if not _wait_for_line(ser, target = \"Run\", input = \"\", print_out=True):\n", - " ser.write(b'E\\n')\n", - " raise NameError(\"Run not started\") \n", - "\n", - "\n", - " _act_ambit, _act_blue, _act_red, act_blue, act_red = -1, -1, -1, 0, 0\n", - " _data = []\n", - " for _l in protocol:\n", - "\n", - " if _l[0] == 'M' and len(_l) == 4: # Run measurement\n", - " \n", - " if (_act_ambit != _l[3]): # Set ambit actinic\n", - " _act_ambit = Ambit_actinic(ser, _l[3])\n", - " if (_l[1] < 1): continue # no data\n", - " for _ in range(_l[1]):\n", - " _ts = time.perf_counter()\n", - " _ret = Trigger(ser)\n", - " if _ret != {}: \n", - " _ret.update({\"ACT\":_act_ambit,\"Blue\":act_blue,\"Red\":act_red}.copy())\n", - " _data.append(_ret)\n", - " _elapsed = time.perf_counter() - _ts\n", - " if _elapsed < _l[2]: time.sleep(_l[2] - _elapsed)\n", - " \n", - "\n", - " if _l[0] == 'W' and len(_l) == 2:\n", - " time.sleep(_l[1])\n", - "\n", - " if not _wait_for_line(ser, target = \"Stop\", input = \"E\", print_out=True):\n", - " ser.write(b'E\\n')\n", - " raise NameError(\"Run not Stopped\")\n", - "\n", - "finally:\n", - " ser.close()\n" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [], - "source": [ - "data = pd.DataFrame(_data)" - ] - }, - { - "cell_type": "code", - "execution_count": 124, - "metadata": {}, - "outputs": [], - "source": [ - "data.attrs['OFFSET'] = 1" - ] - }, - { - "cell_type": "code", - "execution_count": 118, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 118, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.plot(data['T'], data['B'])" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "base", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.11.9" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/.vscode/examples/ambit_fsm.excalidraw b/.vscode/examples/ambit_fsm.excalidraw deleted file mode 100644 index b3888ce..0000000 --- a/.vscode/examples/ambit_fsm.excalidraw +++ /dev/null @@ -1,5170 +0,0 @@ -{ - "type": "excalidraw", - "version": 2, - "source": "https://marketplace.visualstudio.com/items?itemName=pomdtr.excalidraw-editor", - "elements": [ - { - "id": "1AceduuKyjAEicwMtKieL", - "type": "rectangle", - "x": 540.7999877929688, - "y": 378.3999938964844, - "width": 204.800048828125, - "height": 91.78756713867188, - "angle": 0, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 3 - }, - "seed": 1585265939, - "version": 93, - "versionNonce": 1972389053, - "isDeleted": false, - "boundElements": [ - { - "type": "text", - "id": "swGNJJTp38JRogcSElTHZ" - }, - { - "id": "gG53V94Hs4M8Od4h0p5Rv", - "type": "arrow" - }, - { - "id": "68P5vEf1kj79sIFqAd-rT", - "type": "arrow" - }, - { - "id": "SQeHgmklU1eLjMjKYB3QA", - "type": "arrow" - } - ], - "updated": 1714402299521, - "link": null, - "locked": false - }, - { - "id": "swGNJJTp38JRogcSElTHZ", - "type": "text", - "x": 608.5680313110352, - "y": 401.7937774658203, - "width": 69.26396179199219, - "height": 45, - "angle": 0, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "groupIds": [], - "frameId": null, - "roundness": null, - "seed": 1150952115, - "version": 65, - "versionNonce": 1684263411, - "isDeleted": false, - "boundElements": null, - "updated": 1714402202186, - "link": null, - "locked": false, - "text": "Idle", - "fontSize": 36, - "fontFamily": 1, - "textAlign": "center", - "verticalAlign": "middle", - "baseline": 31, - "containerId": "1AceduuKyjAEicwMtKieL", - "originalText": "Idle", - "lineHeight": 1.25 - }, - { - "id": "JZ0K6tXACCW2EGqwMGHf3", - "type": "rectangle", - "x": 1076.8001098632812, - "y": 378.3999938964844, - "width": 204.800048828125, - "height": 91.78756713867188, - "angle": 0, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 3 - }, - "seed": 485474813, - "version": 142, - "versionNonce": 1395914749, - "isDeleted": false, - "boundElements": [ - { - "type": "text", - "id": "nUPfwkOIRuggiid05Iipr" - }, - { - "id": "7gp1qzUOY0czzGF-6vJCI", - "type": "arrow" - }, - { - "id": "p0lrF4zO3SgeKn0sD5HfT", - "type": "arrow" - } - ], - "updated": 1714402312013, - "link": null, - "locked": false - }, - { - "id": "nUPfwkOIRuggiid05Iipr", - "type": "text", - "x": 1136.1261672973633, - "y": 401.7937774658203, - "width": 86.14793395996094, - "height": 45, - "angle": 0, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "groupIds": [], - "frameId": null, - "roundness": null, - "seed": 218135133, - "version": 111, - "versionNonce": 2124094355, - "isDeleted": false, - "boundElements": null, - "updated": 1714402202186, - "link": null, - "locked": false, - "text": "sleep", - "fontSize": 36, - "fontFamily": 1, - "textAlign": "center", - "verticalAlign": "middle", - "baseline": 31, - "containerId": "JZ0K6tXACCW2EGqwMGHf3", - "originalText": "sleep", - "lineHeight": 1.25 - }, - { - "id": "9swZXvIOWgkhnpW8_AAOL", - "type": "diamond", - "x": 830.4000244140625, - "y": 342.9875793457031, - "width": 179.2000732421875, - "height": 167.38754272460938, - "angle": 0, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 2 - }, - "seed": 1501065341, - "version": 138, - "versionNonce": 1413620371, - "isDeleted": false, - "boundElements": [ - { - "type": "text", - "id": "gO1S5UgQIOOBUtdpjJwD7" - }, - { - "id": "SQeHgmklU1eLjMjKYB3QA", - "type": "arrow" - }, - { - "id": "7gp1qzUOY0czzGF-6vJCI", - "type": "arrow" - } - ], - "updated": 1714402308643, - "link": null, - "locked": false - }, - { - "id": "gO1S5UgQIOOBUtdpjJwD7", - "type": "text", - "x": 891.9700622558594, - "y": 401.83446502685547, - "width": 56.4599609375, - "height": 50, - "angle": 0, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "groupIds": [], - "frameId": null, - "roundness": null, - "seed": 1097816285, - "version": 78, - "versionNonce": 309866803, - "isDeleted": false, - "boundElements": null, - "updated": 1714402202186, - "link": null, - "locked": false, - "text": "idle\n100ms", - "fontSize": 20, - "fontFamily": 1, - "textAlign": "center", - "verticalAlign": "middle", - "baseline": 43, - "containerId": "9swZXvIOWgkhnpW8_AAOL", - "originalText": "idle\n100ms", - "lineHeight": 1.25 - }, - { - "type": "diamond", - "version": 299, - "versionNonce": 214574077, - "isDeleted": false, - "id": "91QgijPwAjHPsQPXDhXJd", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 1577.3999633789062, - "y": 343.6561737060547, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 179.2000732421875, - "height": 167.38754272460938, - "seed": 1237483901, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 2 - }, - "boundElements": [ - { - "type": "text", - "id": "kWt_smhnWOhoCebqGmlmz" - }, - { - "id": "sY2dxYIT00ouAkmYO_J5N", - "type": "arrow" - }, - { - "id": "auFN6X7BnJ9hTAiNS4d53", - "type": "arrow" - }, - { - "id": "QvahvFaqmITq3A9lK6PSc", - "type": "arrow" - } - ], - "updated": 1714402341096, - "link": null, - "locked": false - }, - { - "type": "text", - "version": 250, - "versionNonce": 23171795, - "isDeleted": false, - "id": "kWt_smhnWOhoCebqGmlmz", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 1643.6800003051758, - "y": 402.50305938720703, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 47.03996276855469, - "height": 50, - "seed": 542067165, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714402202186, - "link": null, - "locked": false, - "fontSize": 20, - "fontFamily": 1, - "text": "CMD\n(160)", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "91QgijPwAjHPsQPXDhXJd", - "originalText": "CMD\n(160)", - "lineHeight": 1.25, - "baseline": 43 - }, - { - "id": "DhXnx6-g9HjL7buARwkue", - "type": "diamond", - "x": 1336.7999877929688, - "y": 342.9875793457031, - "width": 179.2000732421875, - "height": 167.38754272460938, - "angle": 0, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 2 - }, - "seed": 46510131, - "version": 170, - "versionNonce": 1799972605, - "isDeleted": false, - "boundElements": [ - { - "type": "text", - "id": "g3I7LaKIacgaO1VTygMM2" - }, - { - "id": "p0lrF4zO3SgeKn0sD5HfT", - "type": "arrow" - }, - { - "id": "sY2dxYIT00ouAkmYO_J5N", - "type": "arrow" - }, - { - "id": "5_6i8jy9BLi4Raoq7wu8Y", - "type": "arrow" - } - ], - "updated": 1714402322456, - "link": null, - "locked": false - }, - { - "id": "g3I7LaKIacgaO1VTygMM2", - "type": "text", - "x": 1399.3000259399414, - "y": 401.83446502685547, - "width": 54.59996032714844, - "height": 50, - "angle": 0, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "groupIds": [], - "frameId": null, - "roundness": null, - "seed": 1242289875, - "version": 122, - "versionNonce": 1541618195, - "isDeleted": false, - "boundElements": null, - "updated": 1714402202186, - "link": null, - "locked": false, - "text": "uart \ninput", - "fontSize": 20, - "fontFamily": 1, - "textAlign": "center", - "verticalAlign": "middle", - "baseline": 43, - "containerId": "DhXnx6-g9HjL7buARwkue", - "originalText": "uart input", - "lineHeight": 1.25 - }, - { - "id": "4WQmrGNtNOnpuJTz3oKzu", - "type": "rectangle", - "x": 1834.4000854492188, - "y": 378.3999938964844, - "width": 204.800048828125, - "height": 91.78756713867188, - "angle": 0, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 3 - }, - "seed": 829237821, - "version": 191, - "versionNonce": 595488637, - "isDeleted": false, - "boundElements": [ - { - "type": "text", - "id": "bBNsM6KfWxTxNUYwaDBZj" - }, - { - "id": "QvahvFaqmITq3A9lK6PSc", - "type": "arrow" - }, - { - "id": "pU5xOgFud-RCppGcjI_Fe", - "type": "arrow" - } - ], - "updated": 1714402344324, - "link": null, - "locked": false - }, - { - "id": "bBNsM6KfWxTxNUYwaDBZj", - "type": "text", - "x": 1857.2941360473633, - "y": 401.7937774658203, - "width": 159.01194763183594, - "height": 45, - "angle": 0, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "groupIds": [], - "frameId": null, - "roundness": null, - "seed": 908515997, - "version": 172, - "versionNonce": 2117631923, - "isDeleted": false, - "boundElements": null, - "updated": 1714402202186, - "link": null, - "locked": false, - "text": "read cmd", - "fontSize": 36, - "fontFamily": 1, - "textAlign": "center", - "verticalAlign": "middle", - "baseline": 31, - "containerId": "4WQmrGNtNOnpuJTz3oKzu", - "originalText": "read cmd", - "lineHeight": 1.25 - }, - { - "id": "tkgLkECrwUk37XbPVZcBR", - "type": "rectangle", - "x": 2213.600067138672, - "y": 16.58746337890625, - "width": 204.800048828125, - "height": 91.78756713867188, - "angle": 0, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 3 - }, - "seed": 1914675645, - "version": 220, - "versionNonce": 2136393981, - "isDeleted": false, - "boundElements": [ - { - "type": "text", - "id": "iOBFR3zHQhAJXHC0Ma41J" - }, - { - "id": "YAVECsQH4pzpzN2EWIZ6P", - "type": "arrow" - } - ], - "updated": 1714402202186, - "link": null, - "locked": false - }, - { - "id": "iOBFR3zHQhAJXHC0Ma41J", - "type": "text", - "x": 2251.5469665527344, - "y": 50.48124694824219, - "width": 128.90625, - "height": 24, - "angle": 0, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "groupIds": [], - "frameId": null, - "roundness": null, - "seed": 949903901, - "version": 219, - "versionNonce": 1561596243, - "isDeleted": false, - "boundElements": null, - "updated": 1714402202186, - "link": null, - "locked": false, - "text": "1:set gains", - "fontSize": 20, - "fontFamily": 3, - "textAlign": "center", - "verticalAlign": "middle", - "baseline": 19, - "containerId": "tkgLkECrwUk37XbPVZcBR", - "originalText": "1:set gains", - "lineHeight": 1.2 - }, - { - "id": "N5fVsn-fstc9TLBsEkuE2", - "type": "rectangle", - "x": 2213.600067138672, - "y": 138.77496337890625, - "width": 204.800048828125, - "height": 91.78756713867188, - "angle": 0, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 3 - }, - "seed": 23270931, - "version": 268, - "versionNonce": 988717405, - "isDeleted": false, - "boundElements": [ - { - "type": "text", - "id": "r8GQuIt-8LdhpQRwzZbvL" - }, - { - "id": "rWiNBdY_GSQ3jUZJh9j9e", - "type": "arrow" - } - ], - "updated": 1714402202186, - "link": null, - "locked": false - }, - { - "id": "r8GQuIt-8LdhpQRwzZbvL", - "type": "text", - "x": 2239.8282165527344, - "y": 172.6687469482422, - "width": 152.34375, - "height": 24, - "angle": 0, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "groupIds": [], - "frameId": null, - "roundness": null, - "seed": 526179251, - "version": 288, - "versionNonce": 701263603, - "isDeleted": false, - "boundElements": null, - "updated": 1714402202186, - "link": null, - "locked": false, - "text": "2.set current", - "fontSize": 20, - "fontFamily": 3, - "textAlign": "center", - "verticalAlign": "middle", - "baseline": 19, - "containerId": "N5fVsn-fstc9TLBsEkuE2", - "originalText": "2.set current", - "lineHeight": 1.2 - }, - { - "id": "npCnZj0g3qwogXzMuDCWW", - "type": "rectangle", - "x": 2214.4000549316406, - "y": 256.7500915527344, - "width": 204.800048828125, - "height": 91.78756713867188, - "angle": 0, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 3 - }, - "seed": 309671357, - "version": 308, - "versionNonce": 2058120637, - "isDeleted": false, - "boundElements": [ - { - "type": "text", - "id": "lreK3yTBCi8zT9og-VQ7h" - }, - { - "id": "IDqXx46-nFH73EVmhokvk", - "type": "arrow" - } - ], - "updated": 1714402202186, - "link": null, - "locked": false - }, - { - "id": "lreK3yTBCi8zT9og-VQ7h", - "type": "text", - "x": 2246.487579345703, - "y": 278.6438751220703, - "width": 140.625, - "height": 48, - "angle": 0, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "groupIds": [], - "frameId": null, - "roundness": null, - "seed": 1629582877, - "version": 354, - "versionNonce": 652744851, - "isDeleted": false, - "boundElements": null, - "updated": 1714402202186, - "link": null, - "locked": false, - "text": "10.run array\nconfig", - "fontSize": 20, - "fontFamily": 3, - "textAlign": "center", - "verticalAlign": "middle", - "baseline": 43, - "containerId": "npCnZj0g3qwogXzMuDCWW", - "originalText": "10.run array\nconfig", - "lineHeight": 1.2 - }, - { - "id": "X9ZeCduHYuJ72eB5ZETh8", - "type": "rectangle", - "x": 2214.4000549316406, - "y": 374.5125427246094, - "width": 204.800048828125, - "height": 91.78756713867188, - "angle": 0, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 3 - }, - "seed": 2093722835, - "version": 348, - "versionNonce": 16544829, - "isDeleted": false, - "boundElements": [ - { - "type": "text", - "id": "3-UYk_M99rmw3uhZQ_Kdf" - }, - { - "id": "JNhkwkzBMK3KtrBKhdLjN", - "type": "arrow" - }, - { - "id": "pU5xOgFud-RCppGcjI_Fe", - "type": "arrow" - } - ], - "updated": 1714402344324, - "link": null, - "locked": false - }, - { - "id": "3-UYk_M99rmw3uhZQ_Kdf", - "type": "text", - "x": 2258.206329345703, - "y": 408.4063262939453, - "width": 117.1875, - "height": 24, - "angle": 0, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "groupIds": [], - "frameId": null, - "roundness": null, - "seed": 923048563, - "version": 390, - "versionNonce": 35491379, - "isDeleted": false, - "boundElements": null, - "updated": 1714402202186, - "link": null, - "locked": false, - "text": "20.run MPF", - "fontSize": 20, - "fontFamily": 3, - "textAlign": "center", - "verticalAlign": "middle", - "baseline": 19, - "containerId": "X9ZeCduHYuJ72eB5ZETh8", - "originalText": "20.run MPF", - "lineHeight": 1.2 - }, - { - "id": "drMFFK8UmzfslilfaWI7i", - "type": "rectangle", - "x": 2214.4000549316406, - "y": 491.9000549316406, - "width": 204.800048828125, - "height": 91.78756713867188, - "angle": 0, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 3 - }, - "seed": 924430931, - "version": 381, - "versionNonce": 1659888253, - "isDeleted": false, - "boundElements": [ - { - "type": "text", - "id": "RtKSJBt7mKeApqNBdQlH3" - }, - { - "id": "QOwONcVPbJwb_R67i2dvy", - "type": "arrow" - } - ], - "updated": 1714402202186, - "link": null, - "locked": false - }, - { - "id": "RtKSJBt7mKeApqNBdQlH3", - "type": "text", - "x": 2246.487579345703, - "y": 525.7938385009766, - "width": 140.625, - "height": 24, - "angle": 0, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "groupIds": [], - "frameId": null, - "roundness": null, - "seed": 642748509, - "version": 433, - "versionNonce": 1850953683, - "isDeleted": false, - "boundElements": null, - "updated": 1714402202186, - "link": null, - "locked": false, - "text": "21.run array", - "fontSize": 20, - "fontFamily": 3, - "textAlign": "center", - "verticalAlign": "middle", - "baseline": 19, - "containerId": "drMFFK8UmzfslilfaWI7i", - "originalText": "21.run array", - "lineHeight": 1.2 - }, - { - "id": "0i4g4WbpQrjegeyvuCkEz", - "type": "rectangle", - "x": 2214.4000549316406, - "y": 595.6875915527344, - "width": 204.800048828125, - "height": 91.78756713867188, - "angle": 0, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 3 - }, - "seed": 1047136339, - "version": 423, - "versionNonce": 1328057053, - "isDeleted": false, - "boundElements": [ - { - "type": "text", - "id": "k6N1tS0Jh_HeUJc5zOTbe" - }, - { - "id": "xiW2VrAyc1GUP03CYemni", - "type": "arrow" - } - ], - "updated": 1714402202186, - "link": null, - "locked": false - }, - { - "id": "k6N1tS0Jh_HeUJc5zOTbe", - "type": "text", - "x": 2246.487579345703, - "y": 629.5813751220703, - "width": 140.625, - "height": 24, - "angle": 0, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "groupIds": [], - "frameId": null, - "roundness": null, - "seed": 2068547059, - "version": 499, - "versionNonce": 2107628915, - "isDeleted": false, - "boundElements": null, - "updated": 1714402202186, - "link": null, - "locked": false, - "text": "31. get spec", - "fontSize": 20, - "fontFamily": 3, - "textAlign": "center", - "verticalAlign": "middle", - "baseline": 19, - "containerId": "0i4g4WbpQrjegeyvuCkEz", - "originalText": "31. get spec", - "lineHeight": 1.2 - }, - { - "id": "-GJ8y9iJ6Jofh4-J-28zz", - "type": "rectangle", - "x": 2214.4000549316406, - "y": 703.6875915527344, - "width": 204.800048828125, - "height": 91.78756713867188, - "angle": 0, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 3 - }, - "seed": 166368157, - "version": 441, - "versionNonce": 317531965, - "isDeleted": false, - "boundElements": [ - { - "type": "text", - "id": "7XdYRR3YYeAVurTr14aKG" - }, - { - "id": "BKH0AcpQRoBtXWmQMIv38", - "type": "arrow" - } - ], - "updated": 1714402202186, - "link": null, - "locked": false - }, - { - "id": "7XdYRR3YYeAVurTr14aKG", - "type": "text", - "x": 2246.487579345703, - "y": 737.5813751220703, - "width": 140.625, - "height": 24, - "angle": 0, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "groupIds": [], - "frameId": null, - "roundness": null, - "seed": 1643124733, - "version": 530, - "versionNonce": 994686739, - "isDeleted": false, - "boundElements": null, - "updated": 1714402202186, - "link": null, - "locked": false, - "text": "32. get temp", - "fontSize": 20, - "fontFamily": 3, - "textAlign": "center", - "verticalAlign": "middle", - "baseline": 19, - "containerId": "-GJ8y9iJ6Jofh4-J-28zz", - "originalText": "32. get temp", - "lineHeight": 1.2 - }, - { - "id": "ajWzG2mD9MR1R84IFg5Fh", - "type": "rectangle", - "x": 2558.1331176757812, - "y": 195.78738403320312, - "width": 178.40008544921875, - "height": 92.375, - "angle": 0, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 3 - }, - "seed": 1398620019, - "version": 209, - "versionNonce": 1084176285, - "isDeleted": false, - "boundElements": [ - { - "type": "text", - "id": "YMqKF0ru8vtrSPERrGvsK" - }, - { - "id": "YAVECsQH4pzpzN2EWIZ6P", - "type": "arrow" - }, - { - "id": "rWiNBdY_GSQ3jUZJh9j9e", - "type": "arrow" - }, - { - "id": "IDqXx46-nFH73EVmhokvk", - "type": "arrow" - }, - { - "id": "gG53V94Hs4M8Od4h0p5Rv", - "type": "arrow" - } - ], - "updated": 1714402202186, - "link": null, - "locked": false - }, - { - "id": "YMqKF0ru8vtrSPERrGvsK", - "type": "text", - "x": 2596.953193664551, - "y": 216.97488403320312, - "width": 100.75993347167969, - "height": 50, - "angle": 0, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "groupIds": [], - "frameId": null, - "roundness": null, - "seed": 814366227, - "version": 153, - "versionNonce": 96951475, - "isDeleted": false, - "boundElements": null, - "updated": 1714402202186, - "link": null, - "locked": false, - "text": "CMD Done\n(161)", - "fontSize": 20, - "fontFamily": 1, - "textAlign": "center", - "verticalAlign": "middle", - "baseline": 43, - "containerId": "ajWzG2mD9MR1R84IFg5Fh", - "originalText": "CMD Done\n(161)", - "lineHeight": 1.25 - }, - { - "id": "YAVECsQH4pzpzN2EWIZ6P", - "type": "arrow", - "x": 2429.599853515625, - "y": 61.012374877929524, - "width": 122.58930870547692, - "height": 125.7878023020815, - "angle": 0, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 2 - }, - "seed": 1724666141, - "version": 100, - "versionNonce": 577780733, - "isDeleted": false, - "boundElements": [], - "updated": 1714402202186, - "link": null, - "locked": false, - "points": [ - [ - 0, - 0 - ], - [ - 122.58930870547692, - 125.7878023020815 - ] - ], - "lastCommittedPoint": null, - "startBinding": { - "elementId": "tkgLkECrwUk37XbPVZcBR", - "focus": -0.7834522181347663, - "gap": 11.199737548828125 - }, - "endBinding": { - "elementId": "ajWzG2mD9MR1R84IFg5Fh", - "focus": -0.3082579603972113, - "gap": 10.774993896484375 - }, - "startArrowhead": null, - "endArrowhead": "arrow" - }, - { - "id": "rWiNBdY_GSQ3jUZJh9j9e", - "type": "arrow", - "x": 2435.1998291015625, - "y": 188.21237182617193, - "width": 110.933349609375, - "height": 34.370006738930186, - "angle": 0, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 2 - }, - "seed": 408227645, - "version": 78, - "versionNonce": 1080144989, - "isDeleted": false, - "boundElements": null, - "updated": 1714402202186, - "link": null, - "locked": false, - "points": [ - [ - 0, - 0 - ], - [ - 110.933349609375, - 34.370006738930186 - ] - ], - "lastCommittedPoint": null, - "startBinding": { - "elementId": "N5fVsn-fstc9TLBsEkuE2", - "focus": -0.432172408415282, - "gap": 16.799713134765625 - }, - "endBinding": { - "elementId": "ajWzG2mD9MR1R84IFg5Fh", - "focus": -0.16203210909218146, - "gap": 11.99993896484375 - }, - "startArrowhead": null, - "endArrowhead": "arrow" - }, - { - "id": "IDqXx46-nFH73EVmhokvk", - "type": "arrow", - "x": 2431.1998291015625, - "y": 301.81237792968756, - "width": 114.13336181640625, - "height": 54.82981623128521, - "angle": 0, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 2 - }, - "seed": 1270376627, - "version": 90, - "versionNonce": 923274227, - "isDeleted": false, - "boundElements": null, - "updated": 1714402202186, - "link": null, - "locked": false, - "points": [ - [ - 0, - 0 - ], - [ - 114.13336181640625, - -54.82981623128521 - ] - ], - "lastCommittedPoint": null, - "startBinding": { - "elementId": "npCnZj0g3qwogXzMuDCWW", - "focus": 0.5714348015148849, - "gap": 11.999725341796875 - }, - "endBinding": { - "elementId": "ajWzG2mD9MR1R84IFg5Fh", - "focus": 0.4940878079241482, - "gap": 12.7999267578125 - }, - "startArrowhead": null, - "endArrowhead": "arrow" - }, - { - "id": "gG53V94Hs4M8Od4h0p5Rv", - "type": "arrow", - "x": 2648.7890753245397, - "y": 182.16353788829963, - "width": 1949.333419799804, - "height": 417.3333740234374, - "angle": 0, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "groupIds": [], - "frameId": null, - "roundness": null, - "seed": 984256243, - "version": 264, - "versionNonce": 614995347, - "isDeleted": false, - "boundElements": null, - "updated": 1714402202186, - "link": null, - "locked": false, - "points": [ - [ - 0, - 0 - ], - [ - 4.277514030929069, - -228.35418701171875 - ], - [ - -1938.3892391022082, - -233.33333333333326 - ], - [ - -1945.055905768875, - 184.00004069010413 - ] - ], - "lastCommittedPoint": null, - "startBinding": { - "elementId": "ajWzG2mD9MR1R84IFg5Fh", - "focus": 0.0037254461007783244, - "gap": 13.623846144903496 - }, - "endBinding": { - "elementId": "1AceduuKyjAEicwMtKieL", - "focus": 0.5779379271248143, - "gap": 12.236415318080617 - }, - "startArrowhead": null, - "endArrowhead": "arrow" - }, - { - "type": "rectangle", - "version": 264, - "versionNonce": 1773928733, - "isDeleted": false, - "id": "Nf_D1fgEk2tNU8K5b0R9U", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 2531.5329691569013, - "y": 443.24685087658077, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 178.40008544921875, - "height": 92.375, - "seed": 1582259869, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 3 - }, - "boundElements": [ - { - "id": "JNhkwkzBMK3KtrBKhdLjN", - "type": "arrow" - }, - { - "id": "QOwONcVPbJwb_R67i2dvy", - "type": "arrow" - }, - { - "type": "text", - "id": "BO2Djliz0u5vf5dgpSgQL" - }, - { - "id": "Diu-lUS065dRmY2yluVCr", - "type": "arrow" - } - ], - "updated": 1714402202186, - "link": null, - "locked": false - }, - { - "type": "text", - "version": 202, - "versionNonce": 550890291, - "isDeleted": false, - "id": "BO2Djliz0u5vf5dgpSgQL", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 2573.8580118815107, - "y": 465.43435087658077, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 93.75, - "height": 48, - "seed": 2010195379, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": null, - "updated": 1714402202186, - "link": null, - "locked": false, - "fontSize": 20, - "fontFamily": 3, - "text": "CMD Done\n(161)", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "Nf_D1fgEk2tNU8K5b0R9U", - "originalText": "CMD Done\n(161)", - "lineHeight": 1.2, - "baseline": 43 - }, - { - "id": "JNhkwkzBMK3KtrBKhdLjN", - "type": "arrow", - "x": 2431.7331746419277, - "y": 449.97327399434914, - "width": 86.66666666666697, - "height": 21.42667915839229, - "angle": 0, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "groupIds": [], - "frameId": null, - "roundness": null, - "seed": 800783933, - "version": 73, - "versionNonce": 1882707325, - "isDeleted": false, - "boundElements": null, - "updated": 1714402202186, - "link": null, - "locked": false, - "points": [ - [ - 0, - 0 - ], - [ - 86.66666666666697, - 21.42667915839229 - ] - ], - "lastCommittedPoint": null, - "startBinding": { - "focus": 0.014320796960052715, - "gap": 12.533070882162065, - "elementId": "X9ZeCduHYuJ72eB5ZETh8" - }, - "endBinding": { - "focus": -0.10646939352812587, - "gap": 13.133127848306685, - "elementId": "Nf_D1fgEk2tNU8K5b0R9U" - }, - "startArrowhead": null, - "endArrowhead": "arrow" - }, - { - "id": "QOwONcVPbJwb_R67i2dvy", - "type": "arrow", - "x": 2430.3999633789062, - "y": 559.5358509818523, - "width": 81.33321126302144, - "height": 39.189908347962955, - "angle": 0, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "groupIds": [], - "frameId": null, - "roundness": null, - "seed": 753319197, - "version": 68, - "versionNonce": 804785363, - "isDeleted": false, - "boundElements": null, - "updated": 1714402202187, - "link": null, - "locked": false, - "points": [ - [ - 0, - 0 - ], - [ - 81.33321126302144, - -39.189908347962955 - ] - ], - "lastCommittedPoint": null, - "startBinding": { - "focus": 0.8031449635118987, - "gap": 11.199859619140625, - "elementId": "drMFFK8UmzfslilfaWI7i" - }, - "endBinding": { - "focus": 0.24234380222657526, - "gap": 19.799794514973655, - "elementId": "Nf_D1fgEk2tNU8K5b0R9U" - }, - "startArrowhead": null, - "endArrowhead": "arrow" - }, - { - "type": "rectangle", - "version": 295, - "versionNonce": 1962548701, - "isDeleted": false, - "id": "6yDCAunbFVaU8UTDj400L", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 2840.866261800131, - "y": 444.22595650809126, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 178.40008544921875, - "height": 92.375, - "seed": 2012827197, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 3 - }, - "boundElements": [ - { - "id": "JNhkwkzBMK3KtrBKhdLjN", - "type": "arrow" - }, - { - "id": "QOwONcVPbJwb_R67i2dvy", - "type": "arrow" - }, - { - "id": "Diu-lUS065dRmY2yluVCr", - "type": "arrow" - }, - { - "type": "text", - "id": "Qn7oeiXCDM0ejNltLwKq6" - }, - { - "id": "eh9FNlMPUSqysroVgLFbc", - "type": "arrow" - } - ], - "updated": 1714402202187, - "link": null, - "locked": false - }, - { - "type": "text", - "version": 243, - "versionNonce": 94698099, - "isDeleted": false, - "id": "Qn7oeiXCDM0ejNltLwKq6", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 2881.646336873373, - "y": 477.91345650809126, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 96.83993530273438, - "height": 25, - "seed": 529432221, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": null, - "updated": 1714402202187, - "link": null, - "locked": false, - "fontSize": 20, - "fontFamily": 1, - "text": "ADPD run", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "6yDCAunbFVaU8UTDj400L", - "originalText": "ADPD run", - "lineHeight": 1.25, - "baseline": 18 - }, - { - "id": "Diu-lUS065dRmY2yluVCr", - "type": "arrow", - "x": 2719.733154296875, - "y": 490.1635175432475, - "width": 117.33327229817769, - "height": 0.7137752991171169, - "angle": 0, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "groupIds": [], - "frameId": null, - "roundness": null, - "seed": 839986237, - "version": 46, - "versionNonce": 1326733885, - "isDeleted": false, - "boundElements": [], - "updated": 1714402202187, - "link": null, - "locked": false, - "points": [ - [ - 0, - 0 - ], - [ - 117.33327229817769, - -0.7137752991171169 - ] - ], - "lastCommittedPoint": null, - "startBinding": { - "focus": 0.028491589862986146, - "gap": 9.800099690754905, - "elementId": "Nf_D1fgEk2tNU8K5b0R9U" - }, - "endBinding": { - "focus": 0.03272967111096435, - "gap": 3.799835205078125, - "elementId": "6yDCAunbFVaU8UTDj400L" - }, - "startArrowhead": null, - "endArrowhead": "arrow" - }, - { - "type": "rectangle", - "version": 411, - "versionNonce": 2003307165, - "isDeleted": false, - "id": "xKBQWxStslhW-hmFaps0M", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 2627.866587320964, - "y": 659.225956508091, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 178.40008544921875, - "height": 92.375, - "seed": 814975955, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 3 - }, - "boundElements": [ - { - "type": "text", - "id": "hw1DwXjkzXpuGxFn0xMm7" - }, - { - "id": "xiW2VrAyc1GUP03CYemni", - "type": "arrow" - }, - { - "id": "BKH0AcpQRoBtXWmQMIv38", - "type": "arrow" - }, - { - "id": "OPC0mc4nR5Cnsyyo1SHwQ", - "type": "arrow" - } - ], - "updated": 1714402202187, - "link": null, - "locked": false - }, - { - "type": "text", - "version": 348, - "versionNonce": 451492275, - "isDeleted": false, - "id": "hw1DwXjkzXpuGxFn0xMm7", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 2666.6866633097334, - "y": 680.413456508091, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 100.75993347167969, - "height": 50, - "seed": 75012467, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714402202187, - "link": null, - "locked": false, - "fontSize": 20, - "fontFamily": 1, - "text": "CMD Done\n(161)", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "xKBQWxStslhW-hmFaps0M", - "originalText": "CMD Done\n(161)", - "lineHeight": 1.25, - "baseline": 43 - }, - { - "id": "xiW2VrAyc1GUP03CYemni", - "type": "arrow", - "x": 2431.7333780924487, - "y": 631.7868345029348, - "width": 181.33321126302053, - "height": 48.58754762655826, - "angle": 0, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "groupIds": [], - "frameId": null, - "roundness": null, - "seed": 154310067, - "version": 74, - "versionNonce": 1319546621, - "isDeleted": false, - "boundElements": [ - { - "type": "text", - "id": "vFM13GwzZDJORtJ4nVx9g" - } - ], - "updated": 1714402202187, - "link": null, - "locked": false, - "points": [ - [ - 0, - 0 - ], - [ - 181.33321126302053, - 48.58754762655826 - ] - ], - "lastCommittedPoint": null, - "startBinding": { - "elementId": "0i4g4WbpQrjegeyvuCkEz", - "focus": -0.5547579509721468, - "gap": 12.53327433268305 - }, - "endBinding": { - "elementId": "xKBQWxStslhW-hmFaps0M", - "focus": -0.0403397191063741, - "gap": 14.79999796549464 - }, - "startArrowhead": null, - "endArrowhead": "arrow" - }, - { - "id": "vFM13GwzZDJORtJ4nVx9g", - "type": "text", - "x": 2458.2958780924487, - "y": 640.1635124569842, - "width": 46.875, - "height": 24, - "angle": 0, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "groupIds": [], - "frameId": null, - "roundness": null, - "seed": 140821427, - "version": 9, - "versionNonce": 1469942611, - "isDeleted": false, - "boundElements": null, - "updated": 1714402202187, - "link": null, - "locked": false, - "text": "meas", - "fontSize": 20, - "fontFamily": 3, - "textAlign": "center", - "verticalAlign": "middle", - "baseline": 19, - "containerId": "xiW2VrAyc1GUP03CYemni", - "originalText": "meas", - "lineHeight": 1.2 - }, - { - "id": "BKH0AcpQRoBtXWmQMIv38", - "type": "arrow", - "x": 2430.399963378907, - "y": 738.1634971981952, - "width": 184.00004069010402, - "height": 30.666605631510492, - "angle": 0, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "groupIds": [], - "frameId": null, - "roundness": null, - "seed": 1301709267, - "version": 46, - "versionNonce": 592562013, - "isDeleted": false, - "boundElements": [ - { - "type": "text", - "id": "SOSg6UcQz_zAoc5RXbHCv" - } - ], - "updated": 1714402202187, - "link": null, - "locked": false, - "points": [ - [ - 0, - 0 - ], - [ - 184.00004069010402, - -30.666605631510492 - ] - ], - "lastCommittedPoint": null, - "startBinding": { - "elementId": "-GJ8y9iJ6Jofh4-J-28zz", - "focus": 0.11936697090635726, - "gap": 11.199859619141534 - }, - "endBinding": { - "elementId": "xKBQWxStslhW-hmFaps0M", - "focus": 0.24613615402321876, - "gap": 13.46658325195267 - }, - "startArrowhead": null, - "endArrowhead": "arrow" - }, - { - "id": "SOSg6UcQz_zAoc5RXbHCv", - "type": "text", - "x": 2498.962483723959, - "y": 710.8301943824399, - "width": 46.875, - "height": 24, - "angle": 0, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "groupIds": [], - "frameId": null, - "roundness": null, - "seed": 1753995795, - "version": 9, - "versionNonce": 1226221811, - "isDeleted": false, - "boundElements": null, - "updated": 1714402202187, - "link": null, - "locked": false, - "text": "meas", - "fontSize": 20, - "fontFamily": 3, - "textAlign": "center", - "verticalAlign": "middle", - "baseline": 19, - "containerId": "BKH0AcpQRoBtXWmQMIv38", - "originalText": "meas", - "lineHeight": 1.2 - }, - { - "id": "OPC0mc4nR5Cnsyyo1SHwQ", - "type": "arrow", - "x": 2751.7333780924487, - "y": 641.8094322567889, - "width": 85.33345540364553, - "height": 687.9999796549478, - "angle": 0, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "groupIds": [], - "frameId": null, - "roundness": null, - "seed": 491935507, - "version": 228, - "versionNonce": 2008732605, - "isDeleted": false, - "boundElements": null, - "updated": 1714402202187, - "link": null, - "locked": false, - "points": [ - [ - 0, - 0 - ], - [ - 6.666666666666515, - -687.9999796549478 - ], - [ - -78.66678873697902, - -687.9999796549478 - ] - ], - "lastCommittedPoint": null, - "startBinding": { - "elementId": "xKBQWxStslhW-hmFaps0M", - "focus": 0.37982535473551865, - "gap": 17.41652425130212 - }, - "endBinding": null, - "startArrowhead": null, - "endArrowhead": "arrow" - }, - { - "type": "rectangle", - "version": 508, - "versionNonce": 349901459, - "isDeleted": false, - "id": "_bTuWLWVkJ15NJTNaFe4L", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 3152.866282145183, - "y": 451.1635175432474, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 238.40028889973928, - "height": 92.375, - "seed": 1255899773, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 3 - }, - "boundElements": [ - { - "id": "JNhkwkzBMK3KtrBKhdLjN", - "type": "arrow" - }, - { - "id": "QOwONcVPbJwb_R67i2dvy", - "type": "arrow" - }, - { - "id": "Diu-lUS065dRmY2yluVCr", - "type": "arrow" - }, - { - "type": "text", - "id": "rNAWILXrKvXx6oj9pisdd" - }, - { - "id": "eh9FNlMPUSqysroVgLFbc", - "type": "arrow" - }, - { - "id": "6nOlra-spVR8nmex7M75z", - "type": "arrow" - } - ], - "updated": 1714402202187, - "link": null, - "locked": false - }, - { - "type": "text", - "version": 481, - "versionNonce": 134435869, - "isDeleted": false, - "id": "rNAWILXrKvXx6oj9pisdd", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 3233.356458028158, - "y": 472.3510175432474, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 77.41993713378906, - "height": 50, - "seed": 2023762653, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": null, - "updated": 1714402202187, - "link": null, - "locked": false, - "fontSize": 20, - "fontFamily": 1, - "text": "wake up\ncalls 0", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "_bTuWLWVkJ15NJTNaFe4L", - "originalText": "wake up\ncalls 0", - "lineHeight": 1.25, - "baseline": 43 - }, - { - "id": "WaD6ueKE4XNUlEMy2tooF", - "type": "ellipse", - "x": 3153.06679280599, - "y": 567.1426333472837, - "width": 106.31256103515636, - "height": 106.31256103515636, - "angle": 0, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "groupIds": [], - "frameId": null, - "roundness": null, - "seed": 558097565, - "version": 47, - "versionNonce": 1805731891, - "isDeleted": false, - "boundElements": [ - { - "type": "text", - "id": "foRYdI8Q8Mvg2O3W-IHBc" - } - ], - "updated": 1714402202187, - "link": null, - "locked": false - }, - { - "id": "foRYdI8Q8Mvg2O3W-IHBc", - "type": "text", - "x": 3182.1330922444668, - "y": 595.2117474482279, - "width": 48.179962158203125, - "height": 50, - "angle": 0, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "groupIds": [], - "frameId": null, - "roundness": null, - "seed": 1140279549, - "version": 37, - "versionNonce": 270321789, - "isDeleted": false, - "boundElements": null, - "updated": 1714402202187, - "link": null, - "locked": false, - "text": "buf\nclear", - "fontSize": 20, - "fontFamily": 1, - "textAlign": "center", - "verticalAlign": "middle", - "baseline": 43, - "containerId": "WaD6ueKE4XNUlEMy2tooF", - "originalText": "buf\nclear", - "lineHeight": 1.25 - }, - { - "id": "aX0CI4fhYtd5N6BntWaC5", - "type": "ellipse", - "x": 3279.733459472657, - "y": 567.1426333472837, - "width": 106.31256103515636, - "height": 106.31256103515636, - "angle": 0, - "strokeColor": "#2f9e44", - "backgroundColor": "#a5d8ff", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "groupIds": [], - "frameId": null, - "roundness": null, - "seed": 1977976787, - "version": 68, - "versionNonce": 592431571, - "isDeleted": false, - "boundElements": [ - { - "type": "text", - "id": "5XsOdC4iGhG75C7EPM5g_" - } - ], - "updated": 1714402202187, - "link": null, - "locked": false - }, - { - "id": "5XsOdC4iGhG75C7EPM5g_", - "type": "text", - "x": 3309.7025903582694, - "y": 595.2117474482279, - "width": 46.19996643066406, - "height": 50, - "angle": 0, - "strokeColor": "#2f9e44", - "backgroundColor": "transparent", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "groupIds": [], - "frameId": null, - "roundness": null, - "seed": 1177228659, - "version": 68, - "versionNonce": 1372106973, - "isDeleted": false, - "boundElements": null, - "updated": 1714402202187, - "link": null, - "locked": false, - "text": "wake\n211", - "fontSize": 20, - "fontFamily": 1, - "textAlign": "center", - "verticalAlign": "middle", - "baseline": 43, - "containerId": "aX0CI4fhYtd5N6BntWaC5", - "originalText": "wake\n211", - "lineHeight": 1.25 - }, - { - "type": "diamond", - "version": 363, - "versionNonce": 285022067, - "isDeleted": false, - "id": "HzL0GsyPyI1MtIzoZB3FN", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 3476.4668375651045, - "y": 410.7613823300311, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 179.2000732421875, - "height": 167.38754272460938, - "seed": 325170173, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 2 - }, - "boundElements": [ - { - "id": "6nOlra-spVR8nmex7M75z", - "type": "arrow" - }, - { - "id": "m7Efs73wnsp9FlzEweaij", - "type": "arrow" - }, - { - "id": "mw0EQBA_FTBKqMGDbdbhG", - "type": "arrow" - }, - { - "type": "text", - "id": "m7kQqvsPf6ost906icOfz" - } - ], - "updated": 1714402202187, - "link": null, - "locked": false - }, - { - "type": "text", - "version": 341, - "versionNonce": 1519947069, - "isDeleted": false, - "id": "m7kQqvsPf6ost906icOfz", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 3536.6068751017256, - "y": 469.60826801118344, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 59.31996154785156, - "height": 50, - "seed": 73673821, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": null, - "updated": 1714402202187, - "link": null, - "locked": false, - "fontSize": 20, - "fontFamily": 1, - "text": "Awake\n(210)", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "HzL0GsyPyI1MtIzoZB3FN", - "originalText": "Awake\n(210)", - "lineHeight": 1.25, - "baseline": 43 - }, - { - "type": "diamond", - "version": 464, - "versionNonce": 586133779, - "isDeleted": false, - "id": "TVTFFITN1cOHhjT4e_4Au", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 3476.4668375651045, - "y": 200.7196241106302, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 179.2000732421875, - "height": 170, - "seed": 357724701, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 2 - }, - "boundElements": [ - { - "type": "text", - "id": "PbL1dTGTSU5GSDsZywmDz" - }, - { - "id": "mw0EQBA_FTBKqMGDbdbhG", - "type": "arrow" - }, - { - "id": "KfTYmWxD3C4PPayb6eSZ9", - "type": "arrow" - } - ], - "updated": 1714402202187, - "link": null, - "locked": false - }, - { - "type": "text", - "version": 458, - "versionNonce": 166583709, - "isDeleted": false, - "id": "PbL1dTGTSU5GSDsZywmDz", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 3540.456881205241, - "y": 248.2196241106302, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 51.61994934082031, - "height": 75, - "seed": 567813757, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": null, - "updated": 1714402202187, - "link": null, - "locked": false, - "fontSize": 20, - "fontFamily": 1, - "text": "Ambit\nwake\n170", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "TVTFFITN1cOHhjT4e_4Au", - "originalText": "Ambit\nwake\n170", - "lineHeight": 1.25, - "baseline": 68 - }, - { - "type": "diamond", - "version": 509, - "versionNonce": 983439027, - "isDeleted": false, - "id": "YAw3xjrLKFSEYmcYEJp5k", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 3481.8004964192723, - "y": 3.30296253022658, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 179.2000732421875, - "height": 167.38754272460938, - "seed": 1941604883, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 2 - }, - "boundElements": [ - { - "type": "text", - "id": "nGndLxfX4jQqMZVJfPtXM" - }, - { - "id": "siLekLf7ndrtOq37og-1E", - "type": "arrow" - }, - { - "id": "3SONNUcem5JBsIe0DEqmL", - "type": "arrow" - } - ], - "updated": 1714402202187, - "link": null, - "locked": false - }, - { - "type": "text", - "version": 501, - "versionNonce": 1459233277, - "isDeleted": false, - "id": "nGndLxfX4jQqMZVJfPtXM", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 3542.7105382283544, - "y": 62.149848211378924, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 57.77995300292969, - "height": 50, - "seed": 1051054003, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714402202187, - "link": null, - "locked": false, - "fontSize": 20, - "fontFamily": 1, - "text": "Reset\n(222)", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "YAw3xjrLKFSEYmcYEJp5k", - "originalText": "Reset\n(222)", - "lineHeight": 1.25, - "baseline": 43 - }, - { - "type": "rectangle", - "version": 587, - "versionNonce": 1185859667, - "isDeleted": false, - "id": "Hg85iUuDbtM_3FFIdLgHk", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 3743.532786051433, - "y": 451.1635175432474, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 238.40028889973928, - "height": 92.375, - "seed": 479013075, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 3 - }, - "boundElements": [ - { - "id": "JNhkwkzBMK3KtrBKhdLjN", - "type": "arrow" - }, - { - "id": "QOwONcVPbJwb_R67i2dvy", - "type": "arrow" - }, - { - "id": "Diu-lUS065dRmY2yluVCr", - "type": "arrow" - }, - { - "id": "m7Efs73wnsp9FlzEweaij", - "type": "arrow" - }, - { - "type": "text", - "id": "hR5cai5mR4utKVi3xTwPJ" - }, - { - "id": "BTbmeY-DZvSeRXSUnxmaR", - "type": "arrow" - } - ], - "updated": 1714402202187, - "link": null, - "locked": false - }, - { - "type": "text", - "version": 583, - "versionNonce": 1455348317, - "isDeleted": false, - "id": "hR5cai5mR4utKVi3xTwPJ", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 3785.842999776205, - "y": 472.3510175432474, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 153.7798614501953, - "height": 50, - "seed": 1496749683, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": null, - "updated": 1714402202187, - "link": null, - "locked": false, - "fontSize": 20, - "fontFamily": 1, - "text": "send length info\n1", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "Hg85iUuDbtM_3FFIdLgHk", - "originalText": "send length info\n1", - "lineHeight": 1.25, - "baseline": 43 - }, - { - "id": "eh9FNlMPUSqysroVgLFbc", - "type": "arrow", - "x": 3038.400044759115, - "y": 492.8301435198098, - "width": 105.33345540364553, - "height": 0.9792073567708712, - "angle": 0, - "strokeColor": "#1e1e1e", - "backgroundColor": "#a5d8ff", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 2 - }, - "seed": 1780988755, - "version": 34, - "versionNonce": 486032883, - "isDeleted": false, - "boundElements": null, - "updated": 1714402202187, - "link": null, - "locked": false, - "points": [ - [ - 0, - 0 - ], - [ - 105.33345540364553, - 0.9792073567708712 - ] - ], - "lastCommittedPoint": null, - "startBinding": { - "elementId": "6yDCAunbFVaU8UTDj400L", - "focus": 0.02998056892226112, - "gap": 19.133697509765625 - }, - "endBinding": { - "elementId": "_bTuWLWVkJ15NJTNaFe4L", - "focus": 0.049658941415434484, - "gap": 9.13278198242233 - }, - "startArrowhead": null, - "endArrowhead": "arrow" - }, - { - "id": "6nOlra-spVR8nmex7M75z", - "type": "arrow", - "x": 3409.066752115886, - "y": 506.09279325514274, - "width": 61.28959423910101, - "height": 2.991081646826842, - "angle": 0, - "strokeColor": "#1e1e1e", - "backgroundColor": "#a5d8ff", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 2 - }, - "seed": 1318666899, - "version": 32, - "versionNonce": 34440893, - "isDeleted": false, - "boundElements": null, - "updated": 1714402202187, - "link": null, - "locked": false, - "points": [ - [ - 0, - 0 - ], - [ - 61.28959423910101, - -2.991081646826842 - ] - ], - "lastCommittedPoint": null, - "startBinding": { - "focus": 0.29889665695649315, - "gap": 17.80018107096339, - "elementId": "_bTuWLWVkJ15NJTNaFe4L" - }, - "endBinding": { - "focus": -0.047502349499503424, - "gap": 10.489837639782309, - "elementId": "HzL0GsyPyI1MtIzoZB3FN" - }, - "startArrowhead": null, - "endArrowhead": "arrow" - }, - { - "id": "m7Efs73wnsp9FlzEweaij", - "type": "arrow", - "x": 3663.4989582864455, - "y": 496.7167199079794, - "width": 69.5678345195447, - "height": 1.0344169628718873, - "angle": 0, - "strokeColor": "#1e1e1e", - "backgroundColor": "#a5d8ff", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 2 - }, - "seed": 1947258973, - "version": 42, - "versionNonce": 344002451, - "isDeleted": false, - "boundElements": null, - "updated": 1714402202187, - "link": null, - "locked": false, - "points": [ - [ - 0, - 0 - ], - [ - 69.5678345195447, - 1.0344169628718873 - ] - ], - "lastCommittedPoint": null, - "startBinding": { - "focus": 0.01134490525654605, - "gap": 8.15203345573704, - "elementId": "HzL0GsyPyI1MtIzoZB3FN" - }, - "endBinding": { - "focus": -0.048543650247888336, - "gap": 10.46599324544286, - "elementId": "Hg85iUuDbtM_3FFIdLgHk" - }, - "startArrowhead": null, - "endArrowhead": "arrow" - }, - { - "id": "mw0EQBA_FTBKqMGDbdbhG", - "type": "arrow", - "x": 3563.9282232900337, - "y": 410.96054578897116, - "width": 2.7010221596206065, - "height": 35.66568438759498, - "angle": 0, - "strokeColor": "#1e1e1e", - "backgroundColor": "#a5d8ff", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 2 - }, - "seed": 1735141715, - "version": 50, - "versionNonce": 998745885, - "isDeleted": false, - "boundElements": null, - "updated": 1714402202187, - "link": null, - "locked": false, - "points": [ - [ - 0, - 0 - ], - [ - -2.7010221596206065, - -35.66568438759498 - ] - ], - "lastCommittedPoint": null, - "startBinding": { - "focus": 0.04282565766436311, - "gap": 1.3143205288072934, - "elementId": "HzL0GsyPyI1MtIzoZB3FN" - }, - "endBinding": { - "focus": 0.12972490421438299, - "gap": 6.650113051103283, - "elementId": "TVTFFITN1cOHhjT4e_4Au" - }, - "startArrowhead": null, - "endArrowhead": "arrow" - }, - { - "id": "KfTYmWxD3C4PPayb6eSZ9", - "type": "arrow", - "x": 3466.485381393517, - "y": 286.380152488667, - "width": 137.41842582710888, - "height": 1.882824562427004, - "angle": 0, - "strokeColor": "#1e1e1e", - "backgroundColor": "#a5d8ff", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 2 - }, - "seed": 1600135571, - "version": 260, - "versionNonce": 1602200883, - "isDeleted": false, - "boundElements": null, - "updated": 1714402202187, - "link": null, - "locked": false, - "points": [ - [ - 0, - 0 - ], - [ - -137.41842582710888, - -1.882824562427004 - ] - ], - "lastCommittedPoint": null, - "startBinding": { - "elementId": "TVTFFITN1cOHhjT4e_4Au", - "gap": 10.003287711723438, - "focus": -0.02353075099318264 - }, - "endBinding": { - "elementId": "Oz9-wpfUp_7qVhfZq_XSv", - "gap": 20.000000000000455, - "focus": 0.1172219957782847 - }, - "startArrowhead": null, - "endArrowhead": "arrow" - }, - { - "id": "siLekLf7ndrtOq37og-1E", - "type": "arrow", - "x": 3565.066711425782, - "y": 204.8301638648619, - "width": 3.8927154211878587, - "height": 31.133787634667442, - "angle": 0, - "strokeColor": "#1e1e1e", - "backgroundColor": "#a5d8ff", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 2 - }, - "seed": 2102729971, - "version": 17, - "versionNonce": 362724221, - "isDeleted": false, - "boundElements": null, - "updated": 1714402202187, - "link": null, - "locked": false, - "points": [ - [ - 0, - 0 - ], - [ - 3.8927154211878587, - -31.133787634667442 - ] - ], - "lastCommittedPoint": null, - "startBinding": null, - "endBinding": { - "elementId": "YAw3xjrLKFSEYmcYEJp5k", - "focus": -0.09374004509087391, - "gap": 3.8722422145236237 - }, - "startArrowhead": null, - "endArrowhead": "arrow" - }, - { - "id": "Oz9-wpfUp_7qVhfZq_XSv", - "type": "rectangle", - "x": 3215.733622233074, - "y": 231.76762317475766, - "width": 93.33333333333303, - "height": 92.6249694824219, - "angle": 0, - "strokeColor": "#1e1e1e", - "backgroundColor": "#ffc9c9", - "fillStyle": "hachure", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 3 - }, - "seed": 369954205, - "version": 129, - "versionNonce": 626689747, - "isDeleted": false, - "boundElements": [ - { - "type": "text", - "id": "dw9OZGLlCKPeTyXYRqtAy" - }, - { - "id": "KfTYmWxD3C4PPayb6eSZ9", - "type": "arrow" - }, - { - "id": "_scyjoLEs9u8kB235TtQ5", - "type": "arrow" - } - ], - "updated": 1714402202187, - "link": null, - "locked": false - }, - { - "id": "dw9OZGLlCKPeTyXYRqtAy", - "type": "text", - "x": 3241.3065388997406, - "y": 256.48010791596863, - "width": 42.1875, - "height": 43.199999999999996, - "angle": 0, - "strokeColor": "#1e1e1e", - "backgroundColor": "#a5d8ff", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "groupIds": [], - "frameId": null, - "roundness": null, - "seed": 1558345843, - "version": 97, - "versionNonce": 1486111709, - "isDeleted": false, - "boundElements": null, - "updated": 1714402202187, - "link": null, - "locked": false, - "text": "-2", - "fontSize": 36, - "fontFamily": 3, - "textAlign": "center", - "verticalAlign": "middle", - "baseline": 34, - "containerId": "Oz9-wpfUp_7qVhfZq_XSv", - "originalText": "-2", - "lineHeight": 1.2 - }, - { - "id": "_scyjoLEs9u8kB235TtQ5", - "type": "arrow", - "x": 3199.7334594726567, - "y": 280.8301740373879, - "width": 437.33337402343705, - "height": 323.0208587646484, - "angle": 0, - "strokeColor": "#1e1e1e", - "backgroundColor": "#ffc9c9", - "fillStyle": "hachure", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 2 - }, - "seed": 2094383027, - "version": 52, - "versionNonce": 1554527347, - "isDeleted": false, - "boundElements": null, - "updated": 1714402202187, - "link": null, - "locked": false, - "points": [ - [ - 0, - 0 - ], - [ - -437.33337402343705, - -323.0208587646484 - ] - ], - "lastCommittedPoint": null, - "startBinding": { - "elementId": "Oz9-wpfUp_7qVhfZq_XSv", - "focus": -0.6070314044928766, - "gap": 16.000162760417425 - }, - "endBinding": null, - "startArrowhead": null, - "endArrowhead": "arrow" - }, - { - "id": "3SONNUcem5JBsIe0DEqmL", - "type": "arrow", - "x": 3479.125988566133, - "y": 87.25190893004165, - "width": 395.3924884033722, - "height": 395.64580281575513, - "angle": 0, - "strokeColor": "#1e1e1e", - "backgroundColor": "#ffc9c9", - "fillStyle": "hachure", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "groupIds": [], - "frameId": null, - "roundness": null, - "seed": 567959485, - "version": 176, - "versionNonce": 1215938621, - "isDeleted": false, - "boundElements": null, - "updated": 1714402202187, - "link": null, - "locked": false, - "points": [ - [ - 0, - 0 - ], - [ - -395.3924884033722, - -5.088421904372439 - ], - [ - -392.72565897628874, - 390.55738091138267 - ] - ], - "lastCommittedPoint": null, - "startBinding": { - "elementId": "YAw3xjrLKFSEYmcYEJp5k", - "focus": -0.01723764136293494, - "gap": 2.6866534120111183 - }, - "endBinding": null, - "startArrowhead": null, - "endArrowhead": "arrow" - }, - { - "type": "diamond", - "version": 569, - "versionNonce": 1697590803, - "isDeleted": false, - "id": "S3_ciCfD6SYPS-EYJaV4_", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 3701.13348388672, - "y": 554.3864128476093, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 119.20017496744829, - "height": 120.01246134440089, - "seed": 1801127059, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 2 - }, - "boundElements": [ - { - "type": "text", - "id": "9KjD-G5e8Y37-OJ2ltPsB" - }, - { - "id": "7R5AB9CyKO18BnxhCHdhk", - "type": "arrow" - } - ], - "updated": 1714402202187, - "link": null, - "locked": false - }, - { - "type": "text", - "version": 599, - "versionNonce": 724611229, - "isDeleted": false, - "id": "9KjD-G5e8Y37-OJ2ltPsB", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 3737.2055460611996, - "y": 594.3895281837096, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 47.455963134765625, - "height": 40, - "seed": 290650675, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714402202187, - "link": null, - "locked": false, - "fontSize": 16, - "fontFamily": 1, - "text": "Awake\n(211)", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "S3_ciCfD6SYPS-EYJaV4_", - "originalText": "Awake\n(211)", - "lineHeight": 1.25, - "baseline": 34 - }, - { - "id": "oftnwFxFjOUyzkU8S7icv", - "type": "ellipse", - "x": 3839.733357747397, - "y": 567.1426333472837, - "width": 106.31256103515636, - "height": 106.31256103515636, - "angle": 0, - "strokeColor": "#2f9e44", - "backgroundColor": "#a5d8ff", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "groupIds": [], - "frameId": null, - "roundness": null, - "seed": 754283955, - "version": 107, - "versionNonce": 1642460083, - "isDeleted": false, - "boundElements": [ - { - "type": "text", - "id": "jNTIw0mf1j0FAAEOXLIKB" - } - ], - "updated": 1714402202187, - "link": null, - "locked": false - }, - { - "id": "jNTIw0mf1j0FAAEOXLIKB", - "type": "text", - "x": 3864.4324996193372, - "y": 595.2117474482279, - "width": 56.73994445800781, - "height": 50, - "angle": 0, - "strokeColor": "#2f9e44", - "backgroundColor": "transparent", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "groupIds": [], - "frameId": null, - "roundness": null, - "seed": 393036019, - "version": 140, - "versionNonce": 241865981, - "isDeleted": false, - "boundElements": null, - "updated": 1714402202187, - "link": null, - "locked": false, - "text": "length\n212", - "fontSize": 20, - "fontFamily": 1, - "textAlign": "center", - "verticalAlign": "middle", - "baseline": 43, - "containerId": "oftnwFxFjOUyzkU8S7icv", - "originalText": "length\n212", - "lineHeight": 1.25 - }, - { - "type": "diamond", - "version": 393, - "versionNonce": 1391658323, - "isDeleted": false, - "id": "pInF-NX9Wlny_wLJB_Olk", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 4067.1334431966147, - "y": 410.7613823300311, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 179.2000732421875, - "height": 170, - "seed": 1866376349, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 2 - }, - "boundElements": [ - { - "id": "6nOlra-spVR8nmex7M75z", - "type": "arrow" - }, - { - "id": "m7Efs73wnsp9FlzEweaij", - "type": "arrow" - }, - { - "id": "mw0EQBA_FTBKqMGDbdbhG", - "type": "arrow" - }, - { - "type": "text", - "id": "5mEDN53hcN7KdA3b94n0o" - }, - { - "id": "ehMKCfJF_oyC83sa07rsd", - "type": "arrow" - } - ], - "updated": 1714402202187, - "link": null, - "locked": false - }, - { - "type": "text", - "version": 380, - "versionNonce": 1302916445, - "isDeleted": false, - "id": "5mEDN53hcN7KdA3b94n0o", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 4130.113484700521, - "y": 458.2613823300311, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 53.63995361328125, - "height": 75, - "seed": 77203709, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": null, - "updated": 1714402202187, - "link": null, - "locked": false, - "fontSize": 20, - "fontFamily": 1, - "text": "Data\nready\n200", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "pInF-NX9Wlny_wLJB_Olk", - "originalText": "Data\nready\n200", - "lineHeight": 1.25, - "baseline": 68 - }, - { - "type": "diamond", - "version": 428, - "versionNonce": 1873601267, - "isDeleted": false, - "id": "hXmuLQ7QlCPx-ZZRQZztB", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 4067.1334431966147, - "y": 201.0738823300312, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 179.2000732421875, - "height": 170, - "seed": 766647251, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 2 - }, - "boundElements": [ - { - "id": "6nOlra-spVR8nmex7M75z", - "type": "arrow" - }, - { - "id": "m7Efs73wnsp9FlzEweaij", - "type": "arrow" - }, - { - "id": "mw0EQBA_FTBKqMGDbdbhG", - "type": "arrow" - }, - { - "type": "text", - "id": "QJFtxfzgrxBna2fmVnfjR" - }, - { - "id": "1zSOF8pPIkVBMsOaLs13r", - "type": "arrow" - }, - { - "id": "kINfovyMzyKOApwv8qrMF", - "type": "arrow" - } - ], - "updated": 1714402202187, - "link": null, - "locked": false - }, - { - "type": "text", - "version": 416, - "versionNonce": 1480407485, - "isDeleted": false, - "id": "QJFtxfzgrxBna2fmVnfjR", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 4127.273480733236, - "y": 261.0738823300312, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 59.31996154785156, - "height": 50, - "seed": 2135239027, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": null, - "updated": 1714402202187, - "link": null, - "locked": false, - "fontSize": 20, - "fontFamily": 1, - "text": "Awake\n(210)", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "hXmuLQ7QlCPx-ZZRQZztB", - "originalText": "Awake\n(210)", - "lineHeight": 1.25, - "baseline": 43 - }, - { - "type": "diamond", - "version": 549, - "versionNonce": 1083837587, - "isDeleted": false, - "id": "arV-pBSIgBpdJNr-qVS9S", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 4069.7998657226567, - "y": 0.01141284760939243, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 179.2000732421875, - "height": 154.31251525878906, - "seed": 1155970429, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 2 - }, - "boundElements": [ - { - "type": "text", - "id": "7ZTJ9EuV747mt0glQQ213" - }, - { - "id": "6nOlra-spVR8nmex7M75z", - "type": "arrow" - }, - { - "id": "m7Efs73wnsp9FlzEweaij", - "type": "arrow" - }, - { - "id": "mw0EQBA_FTBKqMGDbdbhG", - "type": "arrow" - }, - { - "id": "W7sho896R5OQE8GjmjKz6", - "type": "arrow" - }, - { - "id": "OhdW0e5A8-zTkTy3_X5Ty", - "type": "arrow" - } - ], - "updated": 1714402202187, - "link": null, - "locked": false - }, - { - "type": "text", - "version": 540, - "versionNonce": 927529501, - "isDeleted": false, - "id": "7ZTJ9EuV747mt0glQQ213", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 4130.709907531738, - "y": 52.08954166230666, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 57.77995300292969, - "height": 50, - "seed": 281869789, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": null, - "updated": 1714402202187, - "link": null, - "locked": false, - "fontSize": 20, - "fontFamily": 1, - "text": "Reset\n(222)", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "arV-pBSIgBpdJNr-qVS9S", - "originalText": "Reset\n(222)", - "lineHeight": 1.25, - "baseline": 43 - }, - { - "id": "1zSOF8pPIkVBMsOaLs13r", - "type": "arrow", - "x": 4061.066975911459, - "y": 287.14268420991397, - "width": 365.33345540364553, - "height": 209.74340021103552, - "angle": 0, - "strokeColor": "#1e1e1e", - "backgroundColor": "#ffc9c9", - "fillStyle": "hachure", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "groupIds": [], - "frameId": null, - "roundness": null, - "seed": 980812979, - "version": 259, - "versionNonce": 2037449267, - "isDeleted": false, - "boundElements": null, - "updated": 1714402202187, - "link": null, - "locked": false, - "points": [ - [ - 0, - 0 - ], - [ - -365.33345540364553, - -1.6875203450521212 - ], - [ - -360.0001017252607, - 208.0558798659834 - ] - ], - "lastCommittedPoint": null, - "startBinding": { - "elementId": "hXmuLQ7QlCPx-ZZRQZztB", - "focus": -0.01777290911947176, - "gap": 4.950575195143216 - }, - "endBinding": null, - "startArrowhead": null, - "endArrowhead": "arrow" - }, - { - "id": "BTbmeY-DZvSeRXSUnxmaR", - "type": "arrow", - "x": 3995.7336222330737, - "y": 496.83018420991397, - "width": 58.666585286458485, - "height": 1.33331298828125, - "angle": 0, - "strokeColor": "#1e1e1e", - "backgroundColor": "#ffc9c9", - "fillStyle": "hachure", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "groupIds": [], - "frameId": null, - "roundness": null, - "seed": 1756035645, - "version": 84, - "versionNonce": 1404939901, - "isDeleted": false, - "boundElements": null, - "updated": 1714402202187, - "link": null, - "locked": false, - "points": [ - [ - 0, - 0 - ], - [ - 58.666585286458485, - -1.33331298828125 - ] - ], - "lastCommittedPoint": null, - "startBinding": { - "elementId": "Hg85iUuDbtM_3FFIdLgHk", - "focus": 0.05116654225737033, - "gap": 13.800547281901345 - }, - "endBinding": null, - "startArrowhead": null, - "endArrowhead": "arrow" - }, - { - "id": "kINfovyMzyKOApwv8qrMF", - "type": "arrow", - "x": 4161.066874186199, - "y": 403.4968508765806, - "width": 0, - "height": 31.999969482421875, - "angle": 0, - "strokeColor": "#1e1e1e", - "backgroundColor": "#ffc9c9", - "fillStyle": "hachure", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "groupIds": [], - "frameId": null, - "roundness": null, - "seed": 190266579, - "version": 50, - "versionNonce": 320357331, - "isDeleted": false, - "boundElements": null, - "updated": 1714402202187, - "link": null, - "locked": false, - "points": [ - [ - 0, - 0 - ], - [ - 0, - -31.999969482421875 - ] - ], - "lastCommittedPoint": null, - "startBinding": { - "elementId": "hXmuLQ7QlCPx-ZZRQZztB", - "focus": 0.04836375666692547, - "gap": 26.504771972258368 - }, - "endBinding": null, - "startArrowhead": null, - "endArrowhead": "arrow" - }, - { - "id": "W7sho896R5OQE8GjmjKz6", - "type": "arrow", - "x": 4155.733622233074, - "y": 202.1635378882994, - "width": 1.3332112630205302, - "height": 41.687520345052064, - "angle": 0, - "strokeColor": "#1e1e1e", - "backgroundColor": "#ffc9c9", - "fillStyle": "hachure", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "groupIds": [], - "frameId": null, - "roundness": null, - "seed": 1392308659, - "version": 24, - "versionNonce": 733475645, - "isDeleted": false, - "boundElements": null, - "updated": 1714402202187, - "link": null, - "locked": false, - "points": [ - [ - 0, - 0 - ], - [ - 1.3332112630205302, - -41.687520345052064 - ] - ], - "lastCommittedPoint": null, - "startBinding": null, - "endBinding": { - "elementId": "arV-pBSIgBpdJNr-qVS9S", - "focus": -0.003696658593147046, - "gap": 6.184233190448403 - }, - "startArrowhead": null, - "endArrowhead": "arrow" - }, - { - "id": "OhdW0e5A8-zTkTy3_X5Ty", - "type": "arrow", - "x": 4059.7336629231777, - "y": 83.49685087658071, - "width": 652.0001220703125, - "height": 125.33332824707028, - "angle": 0, - "strokeColor": "#1e1e1e", - "backgroundColor": "#ffc9c9", - "fillStyle": "hachure", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "groupIds": [], - "frameId": null, - "roundness": null, - "seed": 1440070461, - "version": 242, - "versionNonce": 39955219, - "isDeleted": false, - "boundElements": null, - "updated": 1714402202187, - "link": null, - "locked": false, - "points": [ - [ - 0, - 0 - ], - [ - -281.3334147135415, - 6.666666666666629 - ], - [ - -274.666748046875, - -115.99998474121094 - ], - [ - -652.0001220703125, - -118.66666158040366 - ], - [ - -650.6668090820312, - 0 - ] - ], - "lastCommittedPoint": null, - "startBinding": { - "elementId": "arV-pBSIgBpdJNr-qVS9S", - "focus": -0.05142061028717455, - "gap": 11.364500694371351 - }, - "endBinding": null, - "startArrowhead": null, - "endArrowhead": "arrow" - }, - { - "type": "rectangle", - "version": 709, - "versionNonce": 1207437309, - "isDeleted": false, - "id": "FtpcpLBg7XTyN8Q-iuuhN", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 4354.1992899576835, - "y": 454.45519438244, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 389.06699625650896, - "height": 92.375, - "seed": 920608957, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 3 - }, - "boundElements": [ - { - "type": "text", - "id": "mRGCQ2R3y_I5P3iHWd2ae" - }, - { - "id": "JNhkwkzBMK3KtrBKhdLjN", - "type": "arrow" - }, - { - "id": "QOwONcVPbJwb_R67i2dvy", - "type": "arrow" - }, - { - "id": "Diu-lUS065dRmY2yluVCr", - "type": "arrow" - }, - { - "id": "m7Efs73wnsp9FlzEweaij", - "type": "arrow" - }, - { - "id": "1zSOF8pPIkVBMsOaLs13r", - "type": "arrow" - }, - { - "id": "9CJJ1LycDQEREP5vkV0cB", - "type": "arrow" - }, - { - "id": "ehMKCfJF_oyC83sa07rsd", - "type": "arrow" - } - ], - "updated": 1714402202188, - "link": null, - "locked": false - }, - { - "type": "text", - "version": 722, - "versionNonce": 1500136019, - "isDeleted": false, - "id": "mRGCQ2R3y_I5P3iHWd2ae", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 4478.142837524415, - "y": 488.14269438244, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 141.17990112304688, - "height": 25, - "seed": 1829650717, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714402202188, - "link": null, - "locked": false, - "fontSize": 20, - "fontFamily": 1, - "text": "send data (2)", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "FtpcpLBg7XTyN8Q-iuuhN", - "originalText": "send data (2)", - "lineHeight": 1.25, - "baseline": 18 - }, - { - "type": "diamond", - "version": 593, - "versionNonce": 2064646237, - "isDeleted": false, - "id": "m2D24vjPA_gORtFep5SPy", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 4338.1334533691415, - "y": 570.1155795142761, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 119.20017496744829, - "height": 120.01246134440089, - "seed": 1292620723, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 2 - }, - "boundElements": [ - { - "type": "text", - "id": "OOC9aSSv1jP2NyT4crZBP" - }, - { - "id": "sPKerDNeKg2PLeAGbriiV", - "type": "arrow" - } - ], - "updated": 1714402202188, - "link": null, - "locked": false - }, - { - "type": "text", - "version": 637, - "versionNonce": 2117369843, - "isDeleted": false, - "id": "OOC9aSSv1jP2NyT4crZBP", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 4374.493509928387, - "y": 610.1186948503763, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 46.879974365234375, - "height": 40, - "seed": 509404499, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714402202188, - "link": null, - "locked": false, - "fontSize": 16, - "fontFamily": 1, - "text": "Ready\n200", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "m2D24vjPA_gORtFep5SPy", - "originalText": "Ready\n200", - "lineHeight": 1.25, - "baseline": 34 - }, - { - "id": "7R5AB9CyKO18BnxhCHdhk", - "type": "arrow", - "x": 3766.400227864584, - "y": 684.8301638648618, - "width": 676.0000610351562, - "height": 232.000020345052, - "angle": 0, - "strokeColor": "#1e1e1e", - "backgroundColor": "#ffc9c9", - "fillStyle": "hachure", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "groupIds": [], - "frameId": null, - "roundness": null, - "seed": 1358347187, - "version": 139, - "versionNonce": 222948541, - "isDeleted": false, - "boundElements": null, - "updated": 1714402202188, - "link": null, - "locked": false, - "points": [ - [ - 0, - 0 - ], - [ - 5.33335367838572, - 62.66672770182299 - ], - [ - -670.6667073567705, - 60 - ], - [ - -669.333292643229, - -169.33329264322902 - ] - ], - "lastCommittedPoint": null, - "startBinding": { - "elementId": "S3_ciCfD6SYPS-EYJaV4_", - "focus": 0.005504071076706266, - "gap": 11.37146098279895 - }, - "endBinding": null, - "startArrowhead": null, - "endArrowhead": "arrow" - }, - { - "id": "sPKerDNeKg2PLeAGbriiV", - "type": "arrow", - "x": 4335.733622233074, - "y": 640.4760175432473, - "width": 553.3334350585942, - "height": 106.31245930989576, - "angle": 0, - "strokeColor": "#1e1e1e", - "backgroundColor": "#ffc9c9", - "fillStyle": "hachure", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "groupIds": [], - "frameId": null, - "roundness": null, - "seed": 829945651, - "version": 150, - "versionNonce": 908462483, - "isDeleted": false, - "boundElements": [], - "updated": 1714402202188, - "link": null, - "locked": false, - "points": [ - [ - 0, - 0 - ], - [ - -553.3334350585942, - 106.31245930989576 - ] - ], - "lastCommittedPoint": null, - "startBinding": { - "elementId": "m2D24vjPA_gORtFep5SPy", - "focus": 0.02596219984013676, - "gap": 8.999315978165313 - }, - "endBinding": null, - "startArrowhead": null, - "endArrowhead": "arrow" - }, - { - "type": "ellipse", - "version": 129, - "versionNonce": 913661747, - "isDeleted": false, - "id": "Qg70WrqvJvAZqUQdsaJW2", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 4469.244008382162, - "y": 578.6321963355649, - "strokeColor": "#2f9e44", - "backgroundColor": "#a5d8ff", - "width": 106.31256103515636, - "height": 106.31256103515636, - "seed": 867311827, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [ - { - "type": "text", - "id": "5irT9X_2vVwnIi9aIebbv" - } - ], - "updated": 1714402202188, - "link": null, - "locked": false - }, - { - "type": "text", - "version": 166, - "versionNonce": 494510461, - "isDeleted": false, - "id": "5irT9X_2vVwnIi9aIebbv", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 4497.63313743672, - "y": 619.2013104365092, - "strokeColor": "#2f9e44", - "backgroundColor": "transparent", - "width": 49.35997009277344, - "height": 25, - "seed": 821857907, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": null, - "updated": 1714402202188, - "link": null, - "locked": false, - "fontSize": 20, - "fontFamily": 1, - "text": "data", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "Qg70WrqvJvAZqUQdsaJW2", - "originalText": "data", - "lineHeight": 1.25, - "baseline": 18 - }, - { - "type": "ellipse", - "version": 186, - "versionNonce": 1233715411, - "isDeleted": false, - "id": "Hj8Y-N9g-vkVLjheEqryL", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 4585.243967692058, - "y": 573.9238426571794, - "strokeColor": "#2f9e44", - "backgroundColor": "#a5d8ff", - "width": 135.64605712890648, - "height": 120, - "seed": 70032979, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [ - { - "type": "text", - "id": "9jgGwnDb83wjrii2byeKD" - } - ], - "updated": 1714402202188, - "link": null, - "locked": false - }, - { - "type": "text", - "version": 262, - "versionNonce": 807561693, - "isDeleted": false, - "id": "9jgGwnDb83wjrii2byeKD", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 4610.348916478114, - "y": 608.9974357859866, - "strokeColor": "#2f9e44", - "backgroundColor": "transparent", - "width": 85.51991271972656, - "height": 50, - "seed": 1481333747, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714402202188, - "link": null, - "locked": false, - "fontSize": 20, - "fontFamily": 1, - "text": "checksum\n212", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "Hj8Y-N9g-vkVLjheEqryL", - "originalText": "checksum\n212", - "lineHeight": 1.25, - "baseline": 43 - }, - { - "type": "diamond", - "version": 433, - "versionNonce": 687304307, - "isDeleted": false, - "id": "V-1etljVxtQwcu221FZSg", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 4817.800150553385, - "y": 419.74056934174985, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 179.2000732421875, - "height": 170, - "seed": 334955155, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 2 - }, - "boundElements": [ - { - "id": "6nOlra-spVR8nmex7M75z", - "type": "arrow" - }, - { - "id": "m7Efs73wnsp9FlzEweaij", - "type": "arrow" - }, - { - "id": "mw0EQBA_FTBKqMGDbdbhG", - "type": "arrow" - }, - { - "type": "text", - "id": "45G3D4MCqIc1cPv4vD3f0" - }, - { - "id": "9CJJ1LycDQEREP5vkV0cB", - "type": "arrow" - }, - { - "id": "4lod7oOAXX-jO_Hv7jZKL", - "type": "arrow" - } - ], - "updated": 1714402202188, - "link": null, - "locked": false - }, - { - "type": "text", - "version": 436, - "versionNonce": 391325245, - "isDeleted": false, - "id": "45G3D4MCqIc1cPv4vD3f0", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 4883.460192362467, - "y": 479.74056934174985, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 48.27995300292969, - "height": 50, - "seed": 29308979, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": null, - "updated": 1714402202188, - "link": null, - "locked": false, - "fontSize": 20, - "fontFamily": 1, - "text": "Pass\n180", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "V-1etljVxtQwcu221FZSg", - "originalText": "Pass\n180", - "lineHeight": 1.25, - "baseline": 43 - }, - { - "type": "diamond", - "version": 428, - "versionNonce": 1388939027, - "isDeleted": false, - "id": "ZkVhJwzREaCp7dn6TmykB", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 4818.466756184896, - "y": 201.45517403738802, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 179.2000732421875, - "height": 170, - "seed": 1996567411, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 2 - }, - "boundElements": [ - { - "type": "text", - "id": "4_qirs90h6wIvspTeT81U" - }, - { - "id": "AMA5cBcDp3AGK_DAtKN6X", - "type": "arrow" - }, - { - "id": "JK9kK6IN5MgtGzFGm928P", - "type": "arrow" - } - ], - "updated": 1714402207146, - "link": null, - "locked": false - }, - { - "type": "text", - "version": 412, - "versionNonce": 1710053021, - "isDeleted": false, - "id": "4_qirs90h6wIvspTeT81U", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 4881.446797688803, - "y": 248.95517403738802, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 53.63995361328125, - "height": 75, - "seed": 1779453203, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714402202188, - "link": null, - "locked": false, - "fontSize": 20, - "fontFamily": 1, - "text": "Data\nready\n200", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "ZkVhJwzREaCp7dn6TmykB", - "originalText": "Data\nready\n200", - "lineHeight": 1.25, - "baseline": 68 - }, - { - "type": "diamond", - "version": 601, - "versionNonce": 1785825693, - "isDeleted": false, - "id": "Tl-ydMOspxNXtENv4jiYa", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 4819.800170898439, - "y": -8.367734999884135, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 179.2000732421875, - "height": 154.31251525878906, - "seed": 1733794205, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 2 - }, - "boundElements": [ - { - "type": "text", - "id": "CXRF6zGubqqXg0gdFl9lE" - }, - { - "id": "Ff0iSsU3vymIPvV0oTBVy", - "type": "arrow" - }, - { - "id": "YaEtw2Rso7AeO2nXSnljt", - "type": "arrow" - } - ], - "updated": 1714402223042, - "link": null, - "locked": false - }, - { - "type": "text", - "version": 590, - "versionNonce": 1453488893, - "isDeleted": false, - "id": "CXRF6zGubqqXg0gdFl9lE", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 4880.710212707521, - "y": 43.71039381481313, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 57.77995300292969, - "height": 50, - "seed": 1473011197, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714402202188, - "link": null, - "locked": false, - "fontSize": 20, - "fontFamily": 1, - "text": "Reset\n(222)", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "Tl-ydMOspxNXtENv4jiYa", - "originalText": "Reset\n(222)", - "lineHeight": 1.25, - "baseline": 43 - }, - { - "id": "9CJJ1LycDQEREP5vkV0cB", - "type": "arrow", - "x": 4755.733622233074, - "y": 507.4968407040546, - "width": 55.99995930989462, - "height": 4.354044596354129, - "angle": 0, - "strokeColor": "#1e1e1e", - "backgroundColor": "#ffc9c9", - "fillStyle": "hachure", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "groupIds": [], - "frameId": null, - "roundness": null, - "seed": 411305267, - "version": 23, - "versionNonce": 924090195, - "isDeleted": false, - "boundElements": null, - "updated": 1714402202188, - "link": null, - "locked": false, - "points": [ - [ - 0, - 0 - ], - [ - 55.99995930989462, - -4.354044596354129 - ] - ], - "lastCommittedPoint": null, - "startBinding": { - "elementId": "FtpcpLBg7XTyN8Q-iuuhN", - "focus": 0.37428882041044537, - "gap": 12.467336018882179 - }, - "endBinding": { - "elementId": "V-1etljVxtQwcu221FZSg", - "focus": 0.10630509896380333, - "gap": 5.3344057624532795 - }, - "startArrowhead": null, - "endArrowhead": "arrow" - }, - { - "id": "ehMKCfJF_oyC83sa07rsd", - "type": "arrow", - "x": 4251.73358154297, - "y": 496.83018420991397, - "width": 85.333251953125, - "height": 0.979156494140625, - "angle": 0, - "strokeColor": "#1e1e1e", - "backgroundColor": "#ffc9c9", - "fillStyle": "hachure", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "groupIds": [], - "frameId": null, - "roundness": null, - "seed": 575160349, - "version": 30, - "versionNonce": 1374950237, - "isDeleted": false, - "boundElements": null, - "updated": 1714402202188, - "link": null, - "locked": false, - "points": [ - [ - 0, - 0 - ], - [ - 85.333251953125, - 0.979156494140625 - ] - ], - "lastCommittedPoint": null, - "startBinding": { - "elementId": "pInF-NX9Wlny_wLJB_Olk", - "focus": -0.00025031638453241643, - "gap": 4.491931604175804 - }, - "endBinding": { - "elementId": "FtpcpLBg7XTyN8Q-iuuhN", - "focus": 0.008355951359004408, - "gap": 17.13245646158839 - }, - "startArrowhead": null, - "endArrowhead": "arrow" - }, - { - "type": "rectangle", - "version": 604, - "versionNonce": 2105281821, - "isDeleted": false, - "id": "ot3I2R6hxCeL2d-X5XmXe", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 5092.199981689455, - "y": 463.60100737072116, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 238.40028889973928, - "height": 92.375, - "seed": 323555933, - "groupIds": [], - "frameId": null, - "roundness": { - "type": 3 - }, - "boundElements": [ - { - "type": "text", - "id": "GPevYv6fJ04dMT57Er6Il" - }, - { - "id": "4lod7oOAXX-jO_Hv7jZKL", - "type": "arrow" - }, - { - "id": "68P5vEf1kj79sIFqAd-rT", - "type": "arrow" - } - ], - "updated": 1714402292436, - "link": null, - "locked": false - }, - { - "type": "text", - "version": 621, - "versionNonce": 875798461, - "isDeleted": false, - "id": "GPevYv6fJ04dMT57Er6Il", - "fillStyle": "solid", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "angle": 0, - "x": 5168.940172831219, - "y": 497.28850737072116, - "strokeColor": "#1e1e1e", - "backgroundColor": "transparent", - "width": 84.91990661621094, - "height": 25, - "seed": 546356925, - "groupIds": [], - "frameId": null, - "roundness": null, - "boundElements": [], - "updated": 1714402202188, - "link": null, - "locked": false, - "fontSize": 20, - "fontFamily": 1, - "text": "Complete", - "textAlign": "center", - "verticalAlign": "middle", - "containerId": "ot3I2R6hxCeL2d-X5XmXe", - "originalText": "Complete", - "lineHeight": 1.25, - "baseline": 18 - }, - { - "id": "4lod7oOAXX-jO_Hv7jZKL", - "type": "arrow", - "x": 5009.066955566406, - "y": 503.4968508765806, - "width": 66.66666666666788, - "height": 0.979156494140625, - "angle": 0, - "strokeColor": "#1e1e1e", - "backgroundColor": "#ffc9c9", - "fillStyle": "hachure", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "groupIds": [], - "frameId": null, - "roundness": null, - "seed": 486237437, - "version": 26, - "versionNonce": 304416403, - "isDeleted": false, - "boundElements": null, - "updated": 1714402202188, - "link": null, - "locked": false, - "points": [ - [ - 0, - 0 - ], - [ - 66.66666666666788, - 0.979156494140625 - ] - ], - "lastCommittedPoint": null, - "startBinding": { - "elementId": "V-1etljVxtQwcu221FZSg", - "focus": -0.032199218974210915, - "gap": 9.207087089805093 - }, - "endBinding": { - "elementId": "ot3I2R6hxCeL2d-X5XmXe", - "focus": 0.06925409328960842, - "gap": 16.46635945638036 - }, - "startArrowhead": null, - "endArrowhead": "arrow" - }, - { - "id": "AMA5cBcDp3AGK_DAtKN6X", - "type": "arrow", - "x": 4907.733540852865, - "y": 404.8302147274921, - "width": 0, - "height": 31.020863850911496, - "angle": 0, - "strokeColor": "#1e1e1e", - "backgroundColor": "#ffc9c9", - "fillStyle": "hachure", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "groupIds": [], - "frameId": null, - "roundness": null, - "seed": 105078749, - "version": 20, - "versionNonce": 1401069597, - "isDeleted": false, - "boundElements": null, - "updated": 1714402202188, - "link": null, - "locked": false, - "points": [ - [ - 0, - 0 - ], - [ - 0, - -31.020863850911496 - ] - ], - "lastCommittedPoint": null, - "startBinding": { - "elementId": "ZkVhJwzREaCp7dn6TmykB", - "focus": -0.003719328313829567, - "gap": 24.44243388633941 - }, - "endBinding": null, - "startArrowhead": null, - "endArrowhead": "arrow" - }, - { - "id": "JK9kK6IN5MgtGzFGm928P", - "type": "arrow", - "x": 4810.400166829428, - "y": 295.4968712216327, - "width": 515.9999593098955, - "height": 194.6666463216145, - "angle": 0, - "strokeColor": "#1e1e1e", - "backgroundColor": "#ffc9c9", - "fillStyle": "hachure", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "groupIds": [], - "frameId": null, - "roundness": null, - "seed": 1726282973, - "version": 82, - "versionNonce": 2094640499, - "isDeleted": false, - "boundElements": null, - "updated": 1714402207146, - "link": null, - "locked": false, - "points": [ - [ - 0, - 0 - ], - [ - -515.9999593098955, - -3.9999898274738825 - ], - [ - -510.66650390625, - 190.66665649414062 - ] - ], - "lastCommittedPoint": null, - "startBinding": { - "elementId": "ZkVhJwzREaCp7dn6TmykB", - "focus": -0.11528001113239493, - "gap": 12.111348600589459 - }, - "endBinding": null, - "startArrowhead": null, - "endArrowhead": "arrow" - }, - { - "id": "Ff0iSsU3vymIPvV0oTBVy", - "type": "arrow", - "x": 4906.400329589844, - "y": 204.83021472749215, - "width": 1.3332112630214397, - "height": 48.000030517578125, - "angle": 0, - "strokeColor": "#1e1e1e", - "backgroundColor": "#ffc9c9", - "fillStyle": "hachure", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "groupIds": [], - "frameId": null, - "roundness": null, - "seed": 512433747, - "version": 71, - "versionNonce": 106557875, - "isDeleted": false, - "boundElements": null, - "updated": 1714402215746, - "link": null, - "locked": false, - "points": [ - [ - 0, - 0 - ], - [ - 1.3332112630214397, - -48.000030517578125 - ] - ], - "lastCommittedPoint": null, - "startBinding": null, - "endBinding": { - "elementId": "Tl-ydMOspxNXtENv4jiYa", - "focus": -0.008690951667139494, - "gap": 9.336132978037355 - }, - "startArrowhead": null, - "endArrowhead": "arrow" - }, - { - "id": "YaEtw2Rso7AeO2nXSnljt", - "type": "arrow", - "x": 4806.400329589844, - "y": 68.83017912365102, - "width": 1020.0001017252598, - "height": 98.66666158040366, - "angle": 0, - "strokeColor": "#1e1e1e", - "backgroundColor": "#ffc9c9", - "fillStyle": "hachure", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "groupIds": [], - "frameId": null, - "roundness": null, - "seed": 70730579, - "version": 103, - "versionNonce": 220313917, - "isDeleted": false, - "boundElements": null, - "updated": 1714402223042, - "link": null, - "locked": false, - "points": [ - [ - 0, - 0 - ], - [ - -1020.0001017252598, - -98.66666158040366 - ] - ], - "lastCommittedPoint": null, - "startBinding": { - "elementId": "Tl-ydMOspxNXtENv4jiYa", - "focus": -0.12967246181940068, - "gap": 8.775315972701492 - }, - "endBinding": null, - "startArrowhead": null, - "endArrowhead": "arrow" - }, - { - "id": "68P5vEf1kj79sIFqAd-rT", - "type": "arrow", - "x": 5215.733662923178, - "y": 446.5072675432473, - "width": 4582.000122070312, - "height": 632.0000076293943, - "angle": 0, - "strokeColor": "#1e1e1e", - "backgroundColor": "#ffc9c9", - "fillStyle": "hachure", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "groupIds": [], - "frameId": null, - "roundness": null, - "seed": 1560716179, - "version": 243, - "versionNonce": 927361043, - "isDeleted": false, - "boundElements": null, - "updated": 1714402292447, - "link": null, - "locked": false, - "points": [ - [ - 0, - 0 - ], - [ - 3.99993896484375, - -632.0000076293943 - ], - [ - -4574.000244140624, - -631.9999694824216 - ], - [ - -4578.000183105468, - -81.99996948242188 - ] - ], - "lastCommittedPoint": null, - "startBinding": { - "elementId": "ot3I2R6hxCeL2d-X5XmXe", - "focus": 0.0329144494018595, - "gap": 17.093739827473883 - }, - "endBinding": { - "elementId": "1AceduuKyjAEicwMtKieL", - "focus": -0.057442993023585305, - "gap": 13.89269583565897 - }, - "startArrowhead": null, - "endArrowhead": "arrow" - }, - { - "id": "SQeHgmklU1eLjMjKYB3QA", - "type": "arrow", - "x": 759.7333730061866, - "y": 430.50735909598166, - "width": 50, - "height": 1.999969482421875, - "angle": 0, - "strokeColor": "#1e1e1e", - "backgroundColor": "#ffc9c9", - "fillStyle": "hachure", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "groupIds": [], - "frameId": null, - "roundness": null, - "seed": 1610858323, - "version": 60, - "versionNonce": 735286899, - "isDeleted": false, - "boundElements": null, - "updated": 1714402299526, - "link": null, - "locked": false, - "points": [ - [ - 0, - 0 - ], - [ - 50, - 1.999969482421875 - ] - ], - "lastCommittedPoint": null, - "startBinding": { - "elementId": "1AceduuKyjAEicwMtKieL", - "focus": 0.031052749665004417, - "gap": 14.133336385092889 - }, - "endBinding": { - "elementId": "9swZXvIOWgkhnpW8_AAOL", - "focus": -0.12230991534358891, - "gap": 18.364796085822178 - }, - "startArrowhead": null, - "endArrowhead": "arrow" - }, - { - "id": "7gp1qzUOY0czzGF-6vJCI", - "type": "arrow", - "x": 1021.6617896670404, - "y": 430.3033352806451, - "width": 38.857160295758945, - "height": 1.4463588169642208, - "angle": 0, - "strokeColor": "#1e1e1e", - "backgroundColor": "#ffc9c9", - "fillStyle": "hachure", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "groupIds": [], - "frameId": null, - "roundness": null, - "seed": 524070557, - "version": 37, - "versionNonce": 1269192755, - "isDeleted": false, - "boundElements": null, - "updated": 1714402308643, - "link": null, - "locked": false, - "points": [ - [ - 0, - 0 - ], - [ - 38.857160295758945, - -1.4463588169642208 - ] - ], - "lastCommittedPoint": null, - "startBinding": { - "elementId": "9swZXvIOWgkhnpW8_AAOL", - "focus": 0.08849025862569071, - "gap": 10.880320615228342 - }, - "endBinding": { - "elementId": "JZ0K6tXACCW2EGqwMGHf3", - "focus": -0.0029291448634439937, - "gap": 16.281159900481953 - }, - "startArrowhead": null, - "endArrowhead": "arrow" - }, - { - "id": "p0lrF4zO3SgeKn0sD5HfT", - "type": "arrow", - "x": 1291.3761451357902, - "y": 429.16049557640406, - "width": 34.28571428571422, - "height": 0.30351911272316556, - "angle": 0, - "strokeColor": "#1e1e1e", - "backgroundColor": "#ffc9c9", - "fillStyle": "hachure", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "groupIds": [], - "frameId": null, - "roundness": null, - "seed": 1593714547, - "version": 20, - "versionNonce": 424538205, - "isDeleted": false, - "boundElements": null, - "updated": 1714402312014, - "link": null, - "locked": false, - "points": [ - [ - 0, - 0 - ], - [ - 34.28571428571422, - -0.30351911272316556 - ] - ], - "lastCommittedPoint": null, - "startBinding": { - "elementId": "JZ0K6tXACCW2EGqwMGHf3", - "focus": 0.12520801716350022, - "gap": 9.775986444383989 - }, - "endBinding": { - "elementId": "DhXnx6-g9HjL7buARwkue", - "focus": -0.015339576010003958, - "gap": 9.1929128429489 - }, - "startArrowhead": null, - "endArrowhead": "arrow" - }, - { - "id": "sY2dxYIT00ouAkmYO_J5N", - "type": "arrow", - "x": 1538.233270554317, - "y": 426.87481616792195, - "width": 27.4285888671875, - "height": 2.5892857142857792, - "angle": 0, - "strokeColor": "#1e1e1e", - "backgroundColor": "#ffc9c9", - "fillStyle": "hachure", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "groupIds": [], - "frameId": null, - "roundness": null, - "seed": 1774796061, - "version": 10, - "versionNonce": 1112526291, - "isDeleted": false, - "boundElements": null, - "updated": 1714402315057, - "link": null, - "locked": false, - "points": [ - [ - 0, - 0 - ], - [ - 27.4285888671875, - -2.5892857142857792 - ] - ], - "lastCommittedPoint": null, - "startBinding": { - "elementId": "DhXnx6-g9HjL7buARwkue", - "focus": 0.1284520162189083, - "gap": 15.318004559229735 - }, - "endBinding": { - "elementId": "91QgijPwAjHPsQPXDhXJd", - "focus": 0.1509172589325972, - "gap": 10.251973714646624 - }, - "startArrowhead": null, - "endArrowhead": "arrow" - }, - { - "id": "5_6i8jy9BLi4Raoq7wu8Y", - "type": "arrow", - "x": 1428.5190022786473, - "y": 532.017638433547, - "width": 737.1429007393972, - "height": 139.4286237444196, - "angle": 0, - "strokeColor": "#1e1e1e", - "backgroundColor": "#ffc9c9", - "fillStyle": "hachure", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "groupIds": [], - "frameId": null, - "roundness": null, - "seed": 1019131155, - "version": 154, - "versionNonce": 1610728093, - "isDeleted": false, - "boundElements": null, - "updated": 1714402322456, - "link": null, - "locked": false, - "points": [ - [ - 0, - 0 - ], - [ - -4.57144601004461, - 100.57146344866067 - ], - [ - -731.4286150251114, - 97.14285714285711 - ], - [ - -737.1429007393972, - -38.857160295758945 - ] - ], - "lastCommittedPoint": null, - "startBinding": { - "elementId": "DhXnx6-g9HjL7buARwkue", - "focus": -0.07708710629889162, - "gap": 17.262405492385923 - }, - "endBinding": null, - "startArrowhead": null, - "endArrowhead": "arrow" - }, - { - "id": "auFN6X7BnJ9hTAiNS4d53", - "type": "arrow", - "x": 1669.6618419828885, - "y": 534.3034050351094, - "width": 241.14283970424117, - "height": 108.57142857142856, - "angle": 0, - "strokeColor": "#1e1e1e", - "backgroundColor": "#ffc9c9", - "fillStyle": "hachure", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "groupIds": [], - "frameId": null, - "roundness": null, - "seed": 1695517629, - "version": 69, - "versionNonce": 1127335795, - "isDeleted": false, - "boundElements": null, - "updated": 1714402335445, - "link": null, - "locked": false, - "points": [ - [ - 0, - 0 - ], - [ - -7.99996512276789, - 108.57142857142856 - ], - [ - -241.14283970424117, - 99.42853655133922 - ] - ], - "lastCommittedPoint": null, - "startBinding": { - "elementId": "91QgijPwAjHPsQPXDhXJd", - "focus": -0.11766277429885352, - "gap": 18.81477118916989 - }, - "endBinding": null, - "startArrowhead": null, - "endArrowhead": "arrow" - }, - { - "id": "QvahvFaqmITq3A9lK6PSc", - "type": "arrow", - "x": 1771.3760579427098, - "y": 429.16049557640406, - "width": 42.28585379464289, - "height": 0, - "angle": 0, - "strokeColor": "#1e1e1e", - "backgroundColor": "#ffc9c9", - "fillStyle": "hachure", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "groupIds": [], - "frameId": null, - "roundness": null, - "seed": 1524725843, - "version": 50, - "versionNonce": 773161779, - "isDeleted": false, - "boundElements": null, - "updated": 1714402341100, - "link": null, - "locked": false, - "points": [ - [ - 0, - 0 - ], - [ - 42.28585379464289, - 0 - ] - ], - "lastCommittedPoint": null, - "startBinding": { - "elementId": "91QgijPwAjHPsQPXDhXJd", - "focus": 0.021633037663064965, - "gap": 11.409386411551353 - }, - "endBinding": { - "elementId": "4WQmrGNtNOnpuJTz3oKzu", - "focus": -0.10604307886777632, - "gap": 20.73817371186601 - }, - "startArrowhead": null, - "endArrowhead": "arrow" - }, - { - "id": "pU5xOgFud-RCppGcjI_Fe", - "type": "arrow", - "x": 2044.5190197172635, - "y": 429.16049557640406, - "width": 153.1427873883929, - "height": 2.2856794084821104, - "angle": 0, - "strokeColor": "#1e1e1e", - "backgroundColor": "#ffc9c9", - "fillStyle": "hachure", - "strokeWidth": 2, - "strokeStyle": "solid", - "roughness": 1, - "opacity": 100, - "groupIds": [], - "frameId": null, - "roundness": null, - "seed": 562341075, - "version": 50, - "versionNonce": 1088880563, - "isDeleted": false, - "boundElements": null, - "updated": 1714402344330, - "link": null, - "locked": false, - "points": [ - [ - 0, - 0 - ], - [ - 153.1427873883929, - -2.2856794084821104 - ] - ], - "lastCommittedPoint": null, - "startBinding": { - "elementId": "4WQmrGNtNOnpuJTz3oKzu", - "focus": 0.1365278334171839, - "gap": 5.318885439919768 - }, - "endBinding": { - "elementId": "X9ZeCduHYuJ72eB5ZETh8", - "focus": -0.09890601847601437, - "gap": 16.738247825984217 - }, - "startArrowhead": null, - "endArrowhead": "arrow" - } - ], - "appState": { - "gridSize": null, - "viewBackgroundColor": "#ffffff" - }, - "files": {} -} \ No newline at end of file diff --git a/.vscode/examples/demo.ipynb b/.vscode/examples/demo.ipynb deleted file mode 100644 index f8cdb42..0000000 --- a/.vscode/examples/demo.ipynb +++ /dev/null @@ -1,296 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "import numpy as np\n", - "import serial\n", - "import time\n", - "import matplotlib.pyplot as plt\n", - "from IPython import display\n", - "plt.style.use(\"dark_background\")" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "#helper functions\n", - "# plot autoscale\n", - "def autoscale(data: list, axis:plt.Axes):\n", - " if len(data) == 0: return\n", - " if len(data) == 1: \n", - " axis.set_ylim([data[0]-1, data[0]+1])\n", - " return \n", - " l, h = axis.get_ylim()\n", - " x, d = np.min(data), np.max(data)\n", - " r = d - x\n", - "\n", - " _l, _h, a = l, h, False\n", - " if (x < l) or (l < x - r):\n", - " _l = x - 0.05 * r\n", - " a = True\n", - " if (d > h) or (h > l + r):\n", - " _h = d + 0.05 * r\n", - " a = True\n", - " if a and _l != _h:\n", - " axis.set_ylim([_l, _h])\n", - "\n", - "# convert protocol to ambit array\n", - "def gen_cmd_arr_line(num:int, freq:int, actinic:int)->list:\n", - " return [2, 0, num//256, num%256, freq//256, freq%256, actinic, 1]\n", - "\n", - "\n", - "# flatten ambit array, calc time, actinic array\n", - "def calc_arr_param(cmd: list, persist:bool = False):\n", - " cmd_arr = np.reshape(cmd, (-1, 8))\n", - " arr_length = cmd_arr.shape[0]\n", - " cmd_str = \"arrun1,\" + str(arr_length) + \",\" + str(persist) + \",\"+ str(cmd)[1:-1] + \",\\n\"\n", - " cmd_str = cmd_str.replace(\" \", \"\")\n", - "\n", - " num_pts = cmd_arr[:, 2] * 256 + cmd_arr[:, 3]\n", - " act_arr = cmd_arr[:, 6]\n", - " mea_feq = 1 / (cmd_arr[:, 4] * 256 + cmd_arr[:, 5])\n", - " _t, mea_tml, mea_act = 0, [], []\n", - " for _n, _f, _a in zip(num_pts, mea_feq, act_arr):\n", - " mea_tml += (np.arange(_n) * _f + _t).tolist()\n", - " mea_act += [_a] * _n\n", - " _t = mea_tml[-1]\n", - " mea_tml = np.array(mea_tml) * 0.854\n", - " return cmd_str, mea_tml, mea_act\n" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "cmd: hello\n", - "\n", - "NEW Name Here Ready\n", - "\n", - "cmd: set_gains\n", - "\n", - "Gains set to 0, 5, 5, 1, 5, 5\n", - "\n" - ] - } - ], - "source": [ - "with serial.Serial(\"COM10\", baudrate=115200) as ser:\n", - " ser.write(\"hello\\n\\r\".encode())\n", - " ser.flush()\n", - " time.sleep(.5)\n", - " ser.write(\"set_gains,0,5,5,1,5,5\\n\".encode())\n", - "\n", - " l = ser.readline()\n", - " print(l.decode())\n", - " l = ser.readline()\n", - " print(l.decode())\n", - " l = ser.readline()\n", - " print(l.decode())\n", - " l = ser.readline()\n", - " print(l.decode())" - ] - }, - { - "cell_type": "code", - "execution_count": 201, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0.5, 1.0, 'Protocol preview')" - ] - }, - "execution_count": 201, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# create a trace with 3 different setups:\n", - "# 1. 50 points, 10Hz, no actinic\n", - "# 2. 50 points, 50Hz, 240/255(max) actinic\n", - "# 3. 50 points, 10Hz, no actinic\n", - "# number of lines (1 - 8) points(10 - 2000), freq (1 - 200), actinic 0 - 255\n", - "\n", - "\n", - "\n", - "cmd = []\n", - "cmd += gen_cmd_arr_line(num = 50, freq = 10, actinic = 0)\n", - "cmd += gen_cmd_arr_line(num = 50, freq = 50, actinic = 240)\n", - "cmd += gen_cmd_arr_line(num = 50, freq = 10, actinic = 0)\n", - "\n", - "\n", - "# convert to command for ambit, also pre-calculate the time and actinic of each point\n", - "cmd_str, timeline, act_arr = calc_arr_param(cmd, 0)\n", - "plt.plot(timeline, act_arr, 'w,')\n", - "plt.xlabel(\"Time (s)\")\n", - "plt.ylabel(\"Actinic (AU)\")\n", - "plt.title(\"Protocol preview\")" - ] - }, - { - "cell_type": "code", - "execution_count": 220, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "TIMEOUT = 2\n", - "ambit_port = \"COM9\" #<----change to ambit port\n", - "\n", - "\n", - "fig, axes = plt.subplots(1, 3, sharex = True, figsize = (16, 4))\n", - "x = [] # x axis\n", - "d_temp, d_fluo, d_ambient = [], [], []\n", - "axes[0].set_title(\"Temperature\")\n", - "axes[1].set_title(\"Fluorescence\")\n", - "axes[2].set_title(\"Ambient\")\n", - "axes[1].set_xlabel('Time (s)')\n", - "\n", - "l_temp = axes[0].plot(0)\n", - "l_fluo = axes[1].plot(0)\n", - "l_ambient = axes[2].plot(0)\n", - "\n", - "\n", - "ax_spec = axes[2].inset_axes([0.8, 0.1, 0.15, 0.15])\n", - "ax_spec.set_xticks([])\n", - "ax_spec.set_yticks([])\n", - "\n", - "\n", - "\n", - "\n", - "# get spectrometer data\n", - "with serial.Serial(ambit_port, baudrate=115200, timeout = 1) as ser:\n", - " ser.write(\"get_par\".encode())\n", - " _ = ser.readline()\n", - " par = ser.readline().decode()\n", - " spec = ser.readline().decode()\n", - "if len(spec) > 10 and str.count(spec, ',') == 9:\n", - " spec = np.fromstring(spec, sep = ',', dtype= int)\n", - " ax_spec.bar([415, 445, 480,515, 555, 590, 630, 680, 850], spec[:9] + [spec[-1]], width = [30, 30, 30, 40, 40, 40, 60, 60, 100], color = ['indigo','blue','royalblue','c','lime','gold','orange','red','darkred'])\n", - "\n", - "\n", - "# run PAM\n", - "with serial.Serial(ambit_port, baudrate=115200) as ser:\n", - " watchdog_timer_t = time.time()\n", - " ser.write(cmd_str.encode())\n", - " _str = ''\n", - " data_counter = 0\n", - " _line = ''\n", - " run_msg = ''\n", - " new_data = []\n", - " last_plot = time.time()\n", - " pre_act = -1\n", - " while time.time() < watchdog_timer_t + TIMEOUT:\n", - " # readlines from serial\n", - " if ser.in_waiting > 0:\n", - " c = ser.read()\n", - " if (c > bytes([0])) and (c < bytes([128])):\n", - " watchdog_timer_t = time.time()\n", - " _str += c.decode()\n", - " if (c == b\"\\n\") or (c == b\"\\r\"):\n", - " _line = _str\n", - " _str = ''\n", - " if (\"T:\" in _line) and (\",L:\" in _line): # line contains data\n", - " new_data = [float(n.split(':')[1]) for n in _line.strip('\\n').split(',')]\n", - " data_counter += 1\n", - " elif (\"Done\") in _line:\n", - " TIMEOUT = 0\n", - " else:\n", - " run_msg += _line # error msg if any\n", - "\n", - " if len(new_data) == 6: # add data to lists\n", - " x.append(timeline[data_counter - 1])\n", - " d_temp.append(new_data[0])\n", - " d_fluo.append(new_data[1])\n", - " d_ambient.append(new_data[4] - 500) # this offset can be different for different ambits\n", - " # if actinic intensity changed, plot it on middle figure\n", - " if pre_act != act_arr[data_counter - 1]: \n", - " axes[1].text(x[-1], d_fluo[-1], str(act_arr[data_counter - 1]))\n", - " pre_act = act_arr[data_counter - 1]\n", - " new_data = []\n", - "\n", - "\n", - " # update the figure, plotting takes time, so lower the plotting frequency when data are coming in high rate\n", - " if (ser.in_waiting > 50 and time.time() - last_plot > .5) or (ser.in_waiting < 50 and time.time() - last_plot > .2):\n", - " if data_counter < 2: continue\n", - "\n", - " last_plot = time.time()\n", - " _xlim_left, _xlim_right = axes[0].get_xlim() \n", - " if x[-1] >= _xlim_right - 2: axes[0].set_xlim([_xlim_left, x[-1] + 2])\n", - " autoscale(d_temp, axes[0])\n", - " autoscale(d_fluo, axes[1])\n", - " autoscale(d_ambient[1:], axes[2])\n", - " l_temp[0].set_xdata(x)\n", - " l_temp[0].set_ydata(d_temp)\n", - " l_fluo[0].set_xdata(x)\n", - " l_fluo[0].set_ydata(d_fluo)\n", - "\n", - " # ambient data #1 is also off...\n", - " l_ambient[0].set_xdata(x[1:])\n", - " l_ambient[0].set_ydata(d_ambient[1:])\n", - "\n", - "\n", - " display.display(fig)\n", - " display.clear_output(True)\n", - " \n", - "\n", - "plt.show()" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "base", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.13.5" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/.vscode/examples/includes.txt b/.vscode/examples/includes.txt deleted file mode 100644 index 030ea49..0000000 --- a/.vscode/examples/includes.txt +++ /dev/null @@ -1,69 +0,0 @@ -. -C:\Users\hjcbj\AppData\Local\Arduino15\packages\esp32\tools\esp32-arduino-libs\idf-release_v5.3-cfea4f7c-v1\esp32c3\qio_qspi\include -C:\Users\hjcbj\AppData\Local\Arduino15\packages\esp32\hardware\esp32\3.1.1\cores\esp32 -C:\Users\hjcbj\AppData\Local\Arduino15\packages\esp32\hardware\esp32\3.1.1\variants\esp32c3 -C:\Users\hjcbj\AppData\Local\Arduino15\packages\esp32\hardware\esp32\3.1.1\libraries\Wire\src -C:\Users\hjcbj\Documents\Arduino\libraries\Adafruit_BusIO -C:\Users\hjcbj\AppData\Local\Arduino15\packages\esp32\hardware\esp32\3.1.1\libraries\SPI\src -c:\users\hjcbj\appdata\local\arduino15\packages\esp32\tools\esp-rv32\2405\riscv32-esp-elf\include\c++\13.2.0 -c:\users\hjcbj\appdata\local\arduino15\packages\esp32\tools\esp-rv32\2405\riscv32-esp-elf\include\c++\13.2.0\riscv32-esp-elf -c:\users\hjcbj\appdata\local\arduino15\packages\esp32\tools\esp-rv32\2405\riscv32-esp-elf\include\c++\13.2.0\backward -c:\users\hjcbj\appdata\local\arduino15\packages\esp32\tools\esp-rv32\2405\lib\gcc\riscv32-esp-elf\13.2.0\include -c:\users\hjcbj\appdata\local\arduino15\packages\esp32\tools\esp-rv32\2405\lib\gcc\riscv32-esp-elf\13.2.0\include-fixed -C:\Users\hjcbj\AppData\Local\Arduino15\packages\esp32\tools\esp-rv32\2405\riscv32-esp-elf\include\sys -C:\users\hjcbj\appdata\local\arduino15\packages\esp32\tools\esp-rv32\2405\riscv32-esp-elf\include - - - -C:\Users\hjcbj\AppData\Local\Arduino15\packages\esp32\tools\esp32-arduino-libs\idf-release_v5.3-cfea4f7c-v1\esp32c3\qio_qspi\include -C:\Users\hjcbj\AppData\Local\Arduino15\packages\esp32\tools\esp32-arduino-libs\idf-release_v5.3-cfea4f7c-v1\esp32c3\include\freertos\FreeRTOS-Kernel\include -C:\Users\hjcbj\AppData\Local\Arduino15\packages\esp32\tools\esp32-arduino-libs\idf-release_v5.3-cfea4f7c-v1\esp32c3\include\freertos\esp_additions\include\freertos -C:\Users\hjcbj\AppData\Local\Arduino15\packages\esp32\tools\esp32-arduino-libs\idf-release_v5.3-cfea4f7c-v1\esp32c3\include\freertos\FreeRTOS-Kernel\include\freertos -C:\Users\hjcbj\AppData\Local\Arduino15\packages\esp32\tools\esp32-arduino-libs\idf-release_v5.3-cfea4f7c-v1\esp32c3\include\esp_hw_support\include -C:\Users\hjcbj\AppData\Local\Arduino15\packages\esp32\tools\esp32-arduino-libs\idf-release_v5.3-cfea4f7c-v1\esp32c3\include\soc\esp32c3\include -C:\Users\hjcbj\AppData\Local\Arduino15\packages\esp32\tools\esp32-arduino-libs\idf-release_v5.3-cfea4f7c-v1\esp32c3\include\esp_common\include -C:\Users\hjcbj\AppData\Local\Arduino15\packages\esp32\tools\esp32-arduino-libs\idf-release_v5.3-cfea4f7c-v1\esp32c3\include\esp_system\include -C:\Users\hjcbj\AppData\Local\Arduino15\packages\esp32\tools\esp32-arduino-libs\idf-release_v5.3-cfea4f7c-v1\esp32c3\include\newlib\platform_include -C:\Users\hjcbj\AppData\Local\Arduino15\packages\esp32\tools\esp32-arduino-libs\idf-release_v5.3-cfea4f7c-v1\esp32c3\include\heap\include -C:\Users\hjcbj\AppData\Local\Arduino15\packages\esp32\tools\esp32-arduino-libs\idf-release_v5.3-cfea4f7c-v1\esp32c3\include\esp_rom\include -C:\Users\hjcbj\AppData\Local\Arduino15\packages\esp32\tools\esp32-arduino-libs\idf-release_v5.3-cfea4f7c-v1\esp32c3\include\hal\include -C:\Users\hjcbj\AppData\Local\Arduino15\packages\esp32\tools\esp32-arduino-libs\idf-release_v5.3-cfea4f7c-v1\esp32c3\include\esp_timer\include -C:\Users\hjcbj\AppData\Local\Arduino15\packages\esp32\tools\esp32-arduino-libs\idf-release_v5.3-cfea4f7c-v1\esp32c3\include\log\include -C:\Users\hjcbj\AppData\Local\Arduino15\packages\esp32\tools\esp32-arduino-libs\idf-release_v5.3-cfea4f7c-v1\esp32c3\include\esp_driver_gptimer\include\driver -C:\Users\hjcbj\AppData\Local\Arduino15\packages\esp32\tools\esp32-arduino-libs\idf-release_v5.3-cfea4f7c-v1\esp32c3\include\esp_driver_gptimer\include - -C:\Users\hjcbj\AppData\Local\Arduino15\packages\esp32\tools\esp32-arduino-libs\idf-release_v5.3-cfea4f7c-v1\esp32c3\include\lwip\lwip\src\include -C:\Users\hjcbj\AppData\Local\Arduino15\packages\esp32\tools\esp32-arduino-libs\idf-release_v5.3-cfea4f7c-v1\esp32c3\include\lwip\port\esp32xx\include -C:\Users\hjcbj\AppData\Local\Arduino15\packages\esp32\tools\esp32-arduino-libs\idf-release_v5.3-cfea4f7c-v1\esp32c3\include\lwip\port\freertos\include -C:\Users\hjcbj\AppData\Local\Arduino15\packages\esp32\tools\esp32-arduino-libs\idf-release_v5.3-cfea4f7c-v1\esp32c3\include\lwip\port\include -C:\Users\hjcbj\AppData\Local\Arduino15\packages\esp32\tools\esp32-arduino-libs\idf-release_v5.3-cfea4f7c-v1\esp32c3\include\freertos\esp_additions\include -C:\Users\hjcbj\AppData\Local\Arduino15\packages\esp32\tools\esp32-arduino-libs\idf-release_v5.3-cfea4f7c-v1\esp32c3\include\esp_netif\include -C:\Users\hjcbj\AppData\Local\Arduino15\packages\esp32\tools\esp32-arduino-libs\idf-release_v5.3-cfea4f7c-v1\esp32c3\include\esp_event\include -C:\Users\hjcbj\AppData\Local\Arduino15\packages\esp32\tools\esp32-arduino-libs\idf-release_v5.3-cfea4f7c-v1\esp32c3\include\esp_driver_usb_serial_jtag\include\driver -C:\Users\hjcbj\AppData\Local\Arduino15\packages\esp32\tools\esp32-arduino-libs\idf-release_v5.3-cfea4f7c-v1\esp32c3\include\esp_driver_usb_serial_jtag\include - -C:\Users\hjcbj\AppData\Local\Arduino15\packages\esp32\tools\esp32-arduino-libs\idf-release_v5.3-cfea4f7c-v1\esp32c3\include\esp_partition\include -C:\Users\hjcbj\AppData\Local\Arduino15\packages\esp32\tools\esp32-arduino-libs\idf-release_v5.3-cfea4f7c-v1\esp32c3\include\fatfs\vfs -C:\Users\hjcbj\AppData\Local\Arduino15\packages\esp32\tools\esp32-arduino-libs\idf-release_v5.3-cfea4f7c-v1\esp32c3\include\esp_driver_gpio\include\driver -C:\Users\hjcbj\AppData\Local\Arduino15\packages\esp32\tools\esp32-arduino-libs\idf-release_v5.3-cfea4f7c-v1\esp32c3\include\esp_driver_gpio\include -C:\Users\hjcbj\AppData\Local\Arduino15\packages\esp32\tools\esp32-arduino-libs\idf-release_v5.3-cfea4f7c-v1\esp32c3\include\esp_driver_sdmmc\include\driver -C:\Users\hjcbj\AppData\Local\Arduino15\packages\esp32\tools\esp32-arduino-libs\idf-release_v5.3-cfea4f7c-v1\esp32c3\include\esp_driver_spi\include -C:\Users\hjcbj\AppData\Local\Arduino15\packages\esp32\tools\esp32-arduino-libs\idf-release_v5.3-cfea4f7c-v1\esp32c3\include\fatfs\src -C:\Users\hjcbj\AppData\Local\Arduino15\packages\esp32\tools\esp32-arduino-libs\idf-release_v5.3-cfea4f7c-v1\esp32c3\include\wear_levelling\include -C:\Users\hjcbj\AppData\Local\Arduino15\packages\esp32\tools\esp32-arduino-libs\idf-release_v5.3-cfea4f7c-v1\esp32c3\include\esp_driver_sdmmc\include -C:\Users\hjcbj\AppData\Local\Arduino15\packages\esp32\tools\esp32-arduino-libs\idf-release_v5.3-cfea4f7c-v1\esp32c3\include\esp_driver_uart\include -C:\Users\hjcbj\AppData\Local\Arduino15\packages\esp32\tools\esp32-arduino-libs\idf-release_v5.3-cfea4f7c-v1\esp32c3\include\esp_ringbuf\include -C:\Users\hjcbj\AppData\Local\Arduino15\packages\esp32\tools\esp32-arduino-libs\idf-release_v5.3-cfea4f7c-v1\esp32c3\include\esp_wifi\include -C:\Users\hjcbj\AppData\Local\Arduino15\packages\esp32\tools\esp32-arduino-libs\idf-release_v5.3-cfea4f7c-v1\esp32c3\include\esp_eth\include -C:\Users\hjcbj\AppData\Local\Arduino15\packages\esp32\tools\esp32-arduino-libs\idf-release_v5.3-cfea4f7c-v1\esp32c3\include\wifi_provisioning\include -C:\Users\hjcbj\AppData\Local\Arduino15\packages\esp32\tools\esp32-arduino-libs\idf-release_v5.3-cfea4f7c-v1\esp32c3\include\protocomm\include\common -C:\Users\hjcbj\AppData\Local\Arduino15\packages\esp32\tools\esp32-arduino-libs\idf-release_v5.3-cfea4f7c-v1\esp32c3\include\protocomm\include\security -C:\Users\hjcbj\AppData\Local\Arduino15\packages\esp32\tools\esp32-arduino-libs\idf-release_v5.3-cfea4f7c-v1\esp32c3\include\freertos\esp_additions\include\freertos -C:\Users\hjcbj\AppData\Local\Arduino15\packages\esp32\tools\esp32-arduino-libs\idf-release_v5.3-cfea4f7c-v1\esp32c3\include\freertos\FreeRTOS-Kernel\portable\riscv\include -C:\Users\hjcbj\AppData\Local\Arduino15\packages\esp32\tools\esp32-arduino-libs\idf-release_v5.3-cfea4f7c-v1\esp32c3\include\riscv\include -C:\Users\hjcbj\AppData\Local\Arduino15\packages\esp32\tools\esp32-arduino-libs\idf-release_v5.3-cfea4f7c-v1\esp32c3\include\esp_rom\include\esp32c3 -C:\Users\hjcbj\AppData\Local\Arduino15\packages\esp32\hardware\esp32\3.1.1\libraries\Preferences\src -C:\Users\hjcbj\AppData\Local\Arduino15\packages\esp32\tools\esp32-arduino-libs\idf-release_v5.3-cfea4f7c-v1\esp32c3\include\freertos\FreeRTOS-Kernel\portable\riscv\include\freertos -C:\Users\hjcbj\AppData\Local\Arduino15\packages\esp32\tools\esp32-arduino-libs\idf-release_v5.3-cfea4f7c-v1\esp32c3\include\freertos\config\include -C:\Users\hjcbj\AppData\Local\Arduino15\packages\esp32\tools\esp32-arduino-libs\idf-release_v5.3-cfea4f7c-v1\esp32c3\include\freertos\config\include\freertos -C:\Users\hjcbj\AppData\Local\Arduino15\packages\esp32\tools\esp32-arduino-libs\idf-release_v5.3-cfea4f7c-v1\esp32c3\include\freertos\config\riscv\include \ No newline at end of file diff --git a/.vscode/examples/includes_MAC.txt b/.vscode/examples/includes_MAC.txt deleted file mode 100644 index a08a27e..0000000 --- a/.vscode/examples/includes_MAC.txt +++ /dev/null @@ -1,69 +0,0 @@ -. -/Users/hjc/Library/Arduino15/packages/esp32/tools/esp32-arduino-libs/idf-release_v5.3-cfea4f7c-v1/esp32c3/qio_qspi/include -/Users/hjc/Library/Arduino15/packages/esp32/hardware/esp32/3.1.1/cores/esp32 -/Users/hjc/Library/Arduino15/packages/esp32/hardware/esp32/3.1.1/variants/esp32c3 -/Users/hjc/Library/Arduino15/packages/esp32/hardware/esp32/3.1.1/libraries/Wire/src -/Users/hjc/Documents/Arduino/libraries/Adafruit_BusIO -/Users/hjc/Library/Arduino15/packages/esp32/hardware/esp32/3.1.1/libraries/SPI/src -/Users/hjc/Library/Arduino15/packages/esp32/tools/esp-rv32/2405/riscv32-esp-elf/include/c++/13.2.0 -/Users/hjc/Library/Arduino15/packages/esp32/tools/esp-rv32/2405/riscv32-esp-elf/include/c++/13.2.0/riscv32-esp-elf -/Users/hjc/Library/Arduino15/packages/esp32/tools/esp-rv32/2405/riscv32-esp-elf/include/c++/13.2.0/backward -/Users/hjc/Library/Arduino15/packages/esp32/tools/esp-rv32/2405/lib/gcc/riscv32-esp-elf/13.2.0/include -/Users/hjc/Library/Arduino15/packages/esp32/tools/esp-rv32/2405/lib/gcc/riscv32-esp-elf/13.2.0/include-fixed -/Users/hjc/Library/Arduino15/packages/esp32/tools/esp-rv32/2405/riscv32-esp-elf/include/sys -/Users/hjc/Library/Arduino15/packages/esp32/tools/esp-rv32/2405/riscv32-esp-elf/include - - - -/Users/hjc/Library/Arduino15/packages/esp32/tools/esp32-arduino-libs/idf-release_v5.3-cfea4f7c-v1/esp32c3/qio_qspi/include -/Users/hjc/Library/Arduino15/packages/esp32/tools/esp32-arduino-libs/idf-release_v5.3-cfea4f7c-v1/esp32c3/include/freertos/FreeRTOS-Kernel/include -/Users/hjc/Library/Arduino15/packages/esp32/tools/esp32-arduino-libs/idf-release_v5.3-cfea4f7c-v1/esp32c3/include/freertos/esp_additions/include/freertos -/Users/hjc/Library/Arduino15/packages/esp32/tools/esp32-arduino-libs/idf-release_v5.3-cfea4f7c-v1/esp32c3/include/freertos/FreeRTOS-Kernel/include/freertos -/Users/hjc/Library/Arduino15/packages/esp32/tools/esp32-arduino-libs/idf-release_v5.3-cfea4f7c-v1/esp32c3/include/esp_hw_support/include -/Users/hjc/Library/Arduino15/packages/esp32/tools/esp32-arduino-libs/idf-release_v5.3-cfea4f7c-v1/esp32c3/include/soc/esp32c3/include -/Users/hjc/Library/Arduino15/packages/esp32/tools/esp32-arduino-libs/idf-release_v5.3-cfea4f7c-v1/esp32c3/include/esp_common/include -/Users/hjc/Library/Arduino15/packages/esp32/tools/esp32-arduino-libs/idf-release_v5.3-cfea4f7c-v1/esp32c3/include/esp_system/include -/Users/hjc/Library/Arduino15/packages/esp32/tools/esp32-arduino-libs/idf-release_v5.3-cfea4f7c-v1/esp32c3/include/newlib/platform_include -/Users/hjc/Library/Arduino15/packages/esp32/tools/esp32-arduino-libs/idf-release_v5.3-cfea4f7c-v1/esp32c3/include/heap/include -/Users/hjc/Library/Arduino15/packages/esp32/tools/esp32-arduino-libs/idf-release_v5.3-cfea4f7c-v1/esp32c3/include/esp_rom/include -/Users/hjc/Library/Arduino15/packages/esp32/tools/esp32-arduino-libs/idf-release_v5.3-cfea4f7c-v1/esp32c3/include/hal/include -/Users/hjc/Library/Arduino15/packages/esp32/tools/esp32-arduino-libs/idf-release_v5.3-cfea4f7c-v1/esp32c3/include/esp_timer/include -/Users/hjc/Library/Arduino15/packages/esp32/tools/esp32-arduino-libs/idf-release_v5.3-cfea4f7c-v1/esp32c3/include/log/include -/Users/hjc/Library/Arduino15/packages/esp32/tools/esp32-arduino-libs/idf-release_v5.3-cfea4f7c-v1/esp32c3/include/esp_driver_gptimer/include/driver -/Users/hjc/Library/Arduino15/packages/esp32/tools/esp32-arduino-libs/idf-release_v5.3-cfea4f7c-v1/esp32c3/include/esp_driver_gptimer/include - -/Users/hjc/Library/Arduino15/packages/esp32/tools/esp32-arduino-libs/idf-release_v5.3-cfea4f7c-v1/esp32c3/include/lwip/lwip/src/include -/Users/hjc/Library/Arduino15/packages/esp32/tools/esp32-arduino-libs/idf-release_v5.3-cfea4f7c-v1/esp32c3/include/lwip/port/esp32xx/include -/Users/hjc/Library/Arduino15/packages/esp32/tools/esp32-arduino-libs/idf-release_v5.3-cfea4f7c-v1/esp32c3/include/lwip/port/freertos/include -/Users/hjc/Library/Arduino15/packages/esp32/tools/esp32-arduino-libs/idf-release_v5.3-cfea4f7c-v1/esp32c3/include/lwip/port/include -/Users/hjc/Library/Arduino15/packages/esp32/tools/esp32-arduino-libs/idf-release_v5.3-cfea4f7c-v1/esp32c3/include/freertos/esp_additions/include -/Users/hjc/Library/Arduino15/packages/esp32/tools/esp32-arduino-libs/idf-release_v5.3-cfea4f7c-v1/esp32c3/include/esp_netif/include -/Users/hjc/Library/Arduino15/packages/esp32/tools/esp32-arduino-libs/idf-release_v5.3-cfea4f7c-v1/esp32c3/include/esp_event/include -/Users/hjc/Library/Arduino15/packages/esp32/tools/esp32-arduino-libs/idf-release_v5.3-cfea4f7c-v1/esp32c3/include/esp_driver_usb_serial_jtag/include/driver -/Users/hjc/Library/Arduino15/packages/esp32/tools/esp32-arduino-libs/idf-release_v5.3-cfea4f7c-v1/esp32c3/include/esp_driver_usb_serial_jtag/include - -/Users/hjc/Library/Arduino15/packages/esp32/tools/esp32-arduino-libs/idf-release_v5.3-cfea4f7c-v1/esp32c3/include/esp_partition/include -/Users/hjc/Library/Arduino15/packages/esp32/tools/esp32-arduino-libs/idf-release_v5.3-cfea4f7c-v1/esp32c3/include/fatfs/vfs -/Users/hjc/Library/Arduino15/packages/esp32/tools/esp32-arduino-libs/idf-release_v5.3-cfea4f7c-v1/esp32c3/include/esp_driver_gpio/include/driver -/Users/hjc/Library/Arduino15/packages/esp32/tools/esp32-arduino-libs/idf-release_v5.3-cfea4f7c-v1/esp32c3/include/esp_driver_gpio/include -/Users/hjc/Library/Arduino15/packages/esp32/tools/esp32-arduino-libs/idf-release_v5.3-cfea4f7c-v1/esp32c3/include/esp_driver_sdmmc/include/driver -/Users/hjc/Library/Arduino15/packages/esp32/tools/esp32-arduino-libs/idf-release_v5.3-cfea4f7c-v1/esp32c3/include/esp_driver_spi/include -/Users/hjc/Library/Arduino15/packages/esp32/tools/esp32-arduino-libs/idf-release_v5.3-cfea4f7c-v1/esp32c3/include/fatfs/src -/Users/hjc/Library/Arduino15/packages/esp32/tools/esp32-arduino-libs/idf-release_v5.3-cfea4f7c-v1/esp32c3/include/wear_levelling/include -/Users/hjc/Library/Arduino15/packages/esp32/tools/esp32-arduino-libs/idf-release_v5.3-cfea4f7c-v1/esp32c3/include/esp_driver_sdmmc/include -/Users/hjc/Library/Arduino15/packages/esp32/tools/esp32-arduino-libs/idf-release_v5.3-cfea4f7c-v1/esp32c3/include/esp_driver_uart/include -/Users/hjc/Library/Arduino15/packages/esp32/tools/esp32-arduino-libs/idf-release_v5.3-cfea4f7c-v1/esp32c3/include/esp_ringbuf/include -/Users/hjc/Library/Arduino15/packages/esp32/tools/esp32-arduino-libs/idf-release_v5.3-cfea4f7c-v1/esp32c3/include/esp_wifi/include -/Users/hjc/Library/Arduino15/packages/esp32/tools/esp32-arduino-libs/idf-release_v5.3-cfea4f7c-v1/esp32c3/include/esp_eth/include -/Users/hjc/Library/Arduino15/packages/esp32/tools/esp32-arduino-libs/idf-release_v5.3-cfea4f7c-v1/esp32c3/include/wifi_provisioning/include -/Users/hjc/Library/Arduino15/packages/esp32/tools/esp32-arduino-libs/idf-release_v5.3-cfea4f7c-v1/esp32c3/include/protocomm/include/common -/Users/hjc/Library/Arduino15/packages/esp32/tools/esp32-arduino-libs/idf-release_v5.3-cfea4f7c-v1/esp32c3/include/protocomm/include/security -/Users/hjc/Library/Arduino15/packages/esp32/tools/esp32-arduino-libs/idf-release_v5.3-cfea4f7c-v1/esp32c3/include/freertos/esp_additions/include/freertos -/Users/hjc/Library/Arduino15/packages/esp32/tools/esp32-arduino-libs/idf-release_v5.3-cfea4f7c-v1/esp32c3/include/freertos/FreeRTOS-Kernel/portable/riscv/include -/Users/hjc/Library/Arduino15/packages/esp32/tools/esp32-arduino-libs/idf-release_v5.3-cfea4f7c-v1/esp32c3/include/riscv/include -/Users/hjc/Library/Arduino15/packages/esp32/tools/esp32-arduino-libs/idf-release_v5.3-cfea4f7c-v1/esp32c3/include/esp_rom/include/esp32c3 -/Users/hjc/Library/Arduino15/packages/esp32/hardware/esp32/3.1.1/libraries/Preferences/src -/Users/hjc/Library/Arduino15/packages/esp32/tools/esp32-arduino-libs/idf-release_v5.3-cfea4f7c-v1/esp32c3/include/freertos/FreeRTOS-Kernel/portable/riscv/include/freertos -/Users/hjc/Library/Arduino15/packages/esp32/tools/esp32-arduino-libs/idf-release_v5.3-cfea4f7c-v1/esp32c3/include/freertos/config/include -/Users/hjc/Library/Arduino15/packages/esp32/tools/esp32-arduino-libs/idf-release_v5.3-cfea4f7c-v1/esp32c3/include/freertos/config/include/freertos -/Users/hjc/Library/Arduino15/packages/esp32/tools/esp32-arduino-libs/idf-release_v5.3-cfea4f7c-v1/esp32c3/include/freertos/config/riscv/include \ No newline at end of file diff --git a/.vscode/examples/phi2_01.png b/.vscode/examples/phi2_01.png deleted file mode 100644 index cb0ecbacc4bdeeb5e56021b2bfd52eaba8691129..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 20089 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 PIMj7THHAF62haW=)f+NX diff --git a/.vscode/examples/phi2_02.png b/.vscode/examples/phi2_02.png deleted file mode 100644 index 692fa89de12b6e06a0dd9dfbc3d656fee72e6eb5..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 20169 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 diff --git a/.vscode/examples/phi2_03.png b/.vscode/examples/phi2_03.png deleted file mode 100644 index 40716e4821589d8906419b4cab78fe7324077c92..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 19650 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 F{}1u)jy3=Q diff --git a/.vscode/examples/pm25.ipynb b/.vscode/examples/pm25.ipynb deleted file mode 100644 index b615b72..0000000 --- a/.vscode/examples/pm25.ipynb +++ /dev/null @@ -1,473 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": null, - "id": "8cf90bfa", - "metadata": {}, - "outputs": [], - "source": [ - "import serial" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "3fa0f942", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "225\t184\t50\t2\t0\t0\t\n", - "233\t186\t49\t2\t0\t0\t\n", - "245\t202\t49\t2\t0\t0\t\n", - "247\t201\t48\t2\t0\t0\t\n", - "230\t190\t41\t1\t0\t0\t\n", - "223\t183\t35\t2\t0\t0\t\n", - "216\t174\t34\t3\t0\t0\t\n", - "224\t177\t30\t2\t0\t0\t\n", - "221\t171\t28\t2\t0\t0\t\n", - "219\t169\t27\t2\t0\t0\t\n", - "224\t172\t26\t2\t0\t0\t\n", - "207\t159\t24\t2\t0\t0\t\n", - "214\t159\t26\t2\t0\t0\t\n", - "212\t157\t24\t2\t0\t0\t\n", - "211\t156\t23\t2\t0\t0\t\n", - "207\t154\t20\t1\t0\t0\t\n", - "209\t152\t20\t0\t0\t0\t\n", - "206\t154\t32\t0\t0\t0\t\n", - "192\t147\t31\t0\t0\t0\t\n", - "208\t165\t33\t1\t0\t0\t\n", - "212\t171\t35\t1\t0\t0\t\n", - "226\t183\t35\t1\t0\t0\t\n", - "216\t174\t35\t1\t0\t0\t\n", - "214\t172\t36\t2\t0\t0\t\n", - "225\t183\t39\t2\t0\t0\t\n", - "223\t183\t41\t2\t0\t0\t\n", - "235\t201\t43\t3\t0\t0\t\n", - "228\t198\t29\t3\t0\t0\t\n", - "253\t221\t32\t3\t0\t0\t\n", - "231\t204\t29\t2\t0\t0\t\n", - "222\t193\t27\t2\t0\t0\t\n", - "211\t186\t32\t3\t0\t0\t\n", - "218\t192\t32\t3\t0\t0\t\n", - "221\t191\t31\t2\t0\t0\t\n", - "218\t188\t29\t2\t0\t0\t\n", - "221\t187\t26\t2\t0\t0\t\n", - "220\t184\t24\t1\t0\t0\t\n", - "213\t180\t27\t1\t0\t0\t\n", - "193\t156\t21\t1\t0\t0\t\n", - "210\t168\t24\t1\t0\t0\t\n", - "208\t170\t24\t1\t0\t0\t\n", - "202\t164\t19\t0\t0\t0\t\n", - "195\t164\t23\t0\t0\t0\t\n", - "194\t165\t28\t0\t0\t0\t\n", - "186\t158\t28\t0\t0\t0\t\n", - "188\t160\t30\t0\t0\t0\t\n", - "181\t153\t27\t0\t0\t0\t\n", - "195\t166\t26\t0\t0\t0\t\n", - "200\t170\t27\t0\t0\t0\t\n", - "188\t158\t21\t0\t0\t0\t\n", - "199\t169\t22\t0\t0\t0\t\n", - "204\t170\t22\t0\t0\t0\t\n", - "197\t159\t18\t0\t0\t0\t\n", - "198\t160\t14\t0\t0\t0\t\n", - "201\t162\t14\t0\t0\t0\t\n", - "208\t166\t17\t0\t0\t0\t\n", - "210\t171\t22\t0\t0\t0\t\n", - "192\t154\t22\t0\t0\t0\t\n", - "197\t164\t25\t0\t0\t0\t\n", - "201\t172\t30\t1\t0\t0\t\n", - "209\t178\t35\t1\t0\t0\t\n", - "207\t171\t36\t1\t0\t0\t\n", - "205\t173\t37\t1\t0\t0\t\n", - "203\t171\t36\t1\t0\t0\t\n", - "212\t176\t39\t1\t0\t0\t\n", - "192\t164\t35\t1\t0\t0\t\n", - "170\t142\t31\t1\t0\t0\t\n", - "170\t141\t30\t1\t0\t0\t\n", - "147\t121\t26\t1\t0\t0\t\n", - "131\t106\t21\t0\t0\t0\t\n", - "98\t76\t14\t0\t0\t0\t\n", - "86\t74\t13\t0\t0\t0\t\n", - "72\t61\t10\t0\t0\t0\t\n", - "60\t51\t11\t0\t0\t0\t\n", - "52\t45\t11\t0\t0\t0\t\n", - "63\t56\t11\t0\t0\t0\t\n", - "75\t63\t13\t0\t0\t0\t\n", - "75\t64\t13\t0\t0\t0\t\n", - "92\t78\t14\t0\t0\t0\t\n", - "101\t87\t18\t0\t0\t0\t\n", - "121\t106\t19\t0\t0\t0\t\n", - "130\t114\t23\t0\t0\t0\t\n", - "146\t129\t22\t0\t0\t0\t\n", - "180\t159\t22\t1\t0\t0\t\n", - "188\t160\t19\t1\t0\t0\t\n", - "192\t161\t19\t1\t0\t0\t\n", - "209\t182\t17\t1\t0\t0\t\n", - "215\t187\t16\t1\t0\t0\t\n", - "211\t185\t16\t1\t0\t0\t\n", - "222\t191\t16\t2\t0\t0\t\n", - "225\t187\t18\t2\t0\t0\t\n", - "254\t207\t20\t3\t0\t0\t\n", - "275\t224\t29\t3\t0\t0\t\n", - "264\t215\t35\t2\t0\t0\t\n", - "272\t228\t35\t2\t0\t0\t\n", - "285\t237\t44\t5\t0\t0\t\n", - "283\t231\t47\t7\t1\t1\t\n", - "285\t233\t53\t7\t1\t1\t\n", - "317\t261\t54\t7\t1\t1\t\n", - "331\t273\t54\t6\t1\t1\t\n", - "340\t285\t53\t6\t1\t1\t\n", - "325\t275\t53\t5\t1\t1\t\n", - "303\t253\t46\t5\t1\t1\t\n", - "304\t252\t40\t6\t1\t1\t\n", - "301\t251\t49\t10\t1\t1\t\n", - "293\t247\t41\t8\t1\t1\t\n", - "302\t251\t41\t6\t0\t0\t\n", - "303\t250\t41\t6\t0\t0\t\n", - "262\t213\t40\t6\t0\t0\t\n", - "240\t197\t37\t6\t0\t0\t\n", - "225\t187\t36\t6\t0\t0\t\n", - "215\t177\t31\t6\t0\t0\t\n", - "209\t175\t30\t6\t0\t0\t\n", - "196\t168\t34\t5\t0\t0\t\n", - "188\t158\t23\t1\t0\t0\t\n", - "198\t161\t21\t0\t0\t0\t\n", - "182\t154\t20\t1\t0\t0\t\n", - "172\t144\t15\t2\t0\t0\t\n", - "187\t157\t18\t3\t0\t0\t\n", - "192\t156\t19\t3\t0\t0\t\n", - "188\t149\t19\t3\t0\t0\t\n", - "196\t161\t20\t3\t0\t0\t\n", - "203\t169\t21\t3\t0\t0\t\n", - "207\t167\t18\t3\t0\t0\t\n", - "216\t181\t23\t3\t0\t0\t\n", - "202\t177\t24\t3\t0\t0\t\n", - "204\t179\t22\t2\t0\t0\t\n", - "216\t189\t23\t1\t0\t0\t\n", - "215\t184\t21\t1\t0\t0\t\n", - "219\t192\t23\t1\t0\t0\t\n", - "211\t186\t22\t1\t0\t0\t\n", - "196\t172\t21\t1\t0\t0\t\n", - "205\t176\t26\t2\t0\t0\t\n", - "202\t175\t25\t2\t0\t0\t\n", - "195\t160\t20\t2\t0\t0\t\n", - "202\t162\t20\t2\t0\t0\t\n", - "194\t154\t28\t2\t0\t0\t\n", - "194\t158\t32\t2\t0\t0\t\n", - "206\t172\t32\t1\t0\t0\t\n", - "222\t186\t41\t2\t0\t0\t\n", - "241\t199\t42\t2\t0\t0\t\n", - "251\t208\t45\t2\t0\t0\t\n", - "247\t208\t41\t1\t0\t0\t\n", - "263\t228\t47\t1\t0\t0\t\n", - "256\t226\t51\t1\t0\t0\t\n", - "257\t232\t55\t1\t0\t0\t\n", - "263\t232\t50\t1\t0\t0\t\n", - "255\t222\t48\t4\t0\t0\t\n", - "255\t222\t52\t4\t0\t0\t\n", - "227\t198\t41\t3\t0\t0\t\n", - "220\t197\t42\t3\t0\t0\t\n", - "228\t196\t40\t3\t0\t0\t\n", - "233\t197\t38\t3\t0\t0\t\n", - "211\t176\t34\t3\t0\t0\t\n", - "215\t182\t33\t3\t0\t0\t\n", - "205\t171\t30\t3\t0\t0\t\n", - "200\t168\t28\t3\t0\t0\t\n", - "205\t169\t24\t0\t0\t0\t\n", - "196\t162\t19\t0\t0\t0\t\n", - "205\t167\t18\t0\t0\t0\t\n", - "211\t171\t18\t0\t0\t0\t\n", - "199\t166\t18\t0\t0\t0\t\n", - "180\t152\t23\t0\t0\t0\t\n", - "188\t155\t26\t0\t0\t0\t\n", - "191\t158\t23\t0\t0\t0\t\n", - "214\t177\t25\t0\t0\t0\t\n", - "219\t182\t24\t0\t0\t0\t\n", - "211\t176\t25\t0\t0\t0\t\n", - "202\t169\t25\t0\t0\t0\t\n", - "207\t176\t28\t0\t0\t0\t\n", - "200\t169\t27\t0\t0\t0\t\n", - "213\t185\t26\t1\t0\t0\t\n", - "212\t179\t22\t1\t0\t0\t\n", - "205\t174\t16\t1\t0\t0\t\n", - "202\t169\t16\t1\t0\t0\t\n", - "181\t152\t13\t1\t0\t0\t\n", - "185\t158\t12\t1\t0\t0\t\n", - "205\t175\t16\t1\t0\t0\t\n", - "204\t174\t16\t1\t0\t0\t\n", - "188\t158\t13\t1\t0\t0\t\n", - "193\t163\t13\t1\t0\t0\t\n", - "177\t146\t16\t0\t0\t0\t\n", - "187\t160\t17\t0\t0\t0\t\n", - "193\t168\t20\t0\t0\t0\t\n", - "188\t165\t21\t0\t0\t0\t\n", - "180\t155\t20\t0\t0\t0\t\n", - "167\t145\t20\t0\t0\t0\t\n", - "147\t130\t16\t0\t0\t0\t\n", - "153\t132\t16\t0\t0\t0\t\n", - "160\t142\t21\t0\t0\t0\t\n", - "153\t137\t21\t0\t0\t0\t\n", - "157\t139\t18\t0\t0\t0\t\n", - "151\t133\t16\t0\t0\t0\t\n", - "154\t134\t13\t0\t0\t0\t\n", - "153\t129\t16\t1\t0\t0\t\n", - "173\t147\t17\t1\t0\t0\t\n", - "175\t149\t22\t1\t0\t0\t\n", - "179\t149\t25\t1\t0\t0\t\n", - "174\t148\t25\t1\t0\t0\t\n", - "178\t149\t22\t1\t0\t0\t\n", - "183\t154\t22\t1\t0\t0\t\n", - "193\t166\t22\t1\t0\t0\t\n", - "190\t163\t22\t1\t0\t0\t\n", - "183\t159\t23\t2\t0\t0\t\n", - "188\t169\t21\t2\t0\t0\t\n", - "170\t155\t22\t2\t0\t0\t\n", - "177\t155\t18\t2\t0\t0\t\n", - "166\t150\t15\t2\t0\t0\t\n", - "168\t152\t16\t3\t0\t0\t\n", - "155\t139\t14\t3\t0\t0\t\n", - "160\t142\t18\t3\t0\t0\t\n", - "158\t133\t21\t3\t0\t0\t\n", - "169\t144\t21\t3\t0\t0\t\n", - "167\t137\t21\t2\t0\t0\t\n", - "148\t118\t19\t1\t0\t0\t\n", - "136\t107\t17\t1\t0\t0\t\n", - "115\t93\t16\t1\t0\t0\t\n", - "116\t90\t15\t1\t0\t0\t\n", - "100\t75\t14\t1\t0\t0\t\n", - "91\t69\t14\t1\t0\t0\t\n", - "71\t51\t9\t1\t0\t0\t\n", - "50\t37\t8\t1\t0\t0\t\n", - "31\t19\t7\t1\t0\t0\t\n", - "18\t11\t5\t1\t0\t0\t\n", - "18\t11\t5\t1\t0\t0\t\n", - "18\t11\t5\t1\t0\t0\t\n", - "18\t11\t5\t1\t0\t0\t\n", - "11\t9\t5\t1\t0\t0\t\n", - "12\t9\t4\t0\t0\t0\t\n", - "13\t9\t3\t0\t0\t0\t\n", - "10\t7\t3\t0\t0\t0\t\n", - "20\t13\t2\t0\t0\t0\t\n", - "37\t27\t5\t0\t0\t0\t\n", - "59\t44\t6\t0\t0\t0\t\n", - "81\t63\t9\t0\t0\t0\t\n", - "105\t80\t14\t0\t0\t0\t\n", - "110\t85\t15\t0\t0\t0\t\n", - "127\t97\t16\t0\t0\t0\t\n", - "141\t112\t23\t0\t0\t0\t\n", - "160\t125\t28\t1\t0\t0\t\n", - "173\t137\t29\t1\t0\t0\t\n", - "182\t148\t31\t2\t0\t0\t\n", - "177\t146\t30\t2\t0\t0\t\n", - "169\t143\t30\t2\t0\t0\t\n", - "163\t137\t28\t2\t0\t0\t\n", - "147\t123\t25\t2\t0\t0\t\n", - "166\t141\t26\t2\t0\t0\t\n", - "170\t150\t25\t2\t0\t0\t\n", - "180\t159\t21\t2\t0\t0\t\n", - "176\t159\t18\t1\t0\t0\t\n", - "189\t170\t21\t1\t0\t0\t\n", - "186\t163\t19\t0\t0\t0\t\n", - "193\t165\t19\t0\t0\t0\t\n", - "202\t173\t20\t1\t0\t0\t\n", - "208\t177\t21\t1\t0\t0\t\n", - "211\t182\t20\t1\t0\t0\t\n", - "202\t167\t25\t1\t0\t0\t\n", - "201\t161\t30\t1\t0\t0\t\n", - "195\t151\t30\t1\t0\t0\t\n", - "196\t152\t29\t1\t0\t0\t\n", - "185\t143\t26\t1\t0\t0\t\n", - "181\t143\t25\t1\t0\t0\t\n", - "176\t142\t28\t1\t0\t0\t\n", - "178\t137\t33\t0\t0\t0\t\n", - "178\t139\t34\t0\t0\t0\t\n", - "178\t137\t35\t0\t0\t0\t\n", - "171\t136\t30\t0\t0\t0\t\n", - "186\t148\t28\t1\t0\t0\t\n", - "178\t145\t27\t1\t0\t0\t\n", - "187\t154\t28\t2\t0\t0\t\n", - "196\t157\t30\t3\t1\t0\t\n", - "203\t166\t31\t3\t1\t0\t\n", - "201\t165\t28\t4\t1\t0\t\n", - "191\t163\t25\t4\t1\t0\t\n", - "185\t159\t23\t4\t1\t0\t\n", - "194\t168\t23\t4\t1\t0\t\n", - "201\t171\t25\t4\t1\t0\t\n", - "188\t163\t26\t3\t1\t0\t\n", - "204\t171\t25\t3\t1\t0\t\n", - "192\t162\t24\t2\t1\t0\t\n", - "178\t154\t22\t1\t0\t0\t\n", - "178\t152\t23\t1\t0\t0\t\n", - "189\t160\t24\t0\t0\t0\t\n", - "195\t163\t21\t0\t0\t0\t\n", - "204\t172\t20\t0\t0\t0\t\n", - "203\t168\t18\t0\t0\t0\t\n", - "209\t176\t16\t0\t0\t0\t\n", - "199\t164\t13\t0\t0\t0\t\n", - "194\t167\t18\t1\t0\t0\t\n", - "204\t177\t19\t1\t0\t0\t\n", - "211\t182\t22\t1\t0\t0\t\n", - "201\t175\t21\t1\t0\t0\t\n", - "200\t172\t19\t1\t0\t0\t\n", - "196\t168\t21\t1\t0\t0\t\n", - "185\t157\t22\t1\t0\t0\t\n", - "175\t154\t25\t2\t0\t0\t\n", - "173\t155\t25\t2\t0\t0\t\n", - "183\t167\t26\t2\t0\t0\t\n", - "176\t155\t22\t2\t0\t0\t\n", - "168\t137\t21\t2\t0\t0\t\n", - "167\t136\t20\t2\t0\t0\t\n", - "169\t137\t18\t2\t0\t0\t\n", - "162\t134\t22\t2\t0\t0\t\n", - "154\t128\t21\t2\t0\t0\t\n", - "169\t137\t21\t2\t0\t0\t\n", - "179\t141\t20\t1\t0\t0\t\n", - "178\t140\t19\t1\t0\t0\t\n", - "171\t133\t19\t2\t0\t0\t\n", - "185\t144\t22\t2\t0\t0\t\n", - "179\t147\t25\t2\t0\t0\t\n", - "175\t139\t22\t2\t0\t0\t\n", - "172\t134\t24\t2\t0\t0\t\n", - "184\t140\t21\t2\t0\t0\t\n", - "193\t149\t20\t2\t0\t0\t\n", - "179\t139\t19\t2\t0\t0\t\n", - "176\t142\t17\t2\t0\t0\t\n", - "168\t131\t17\t2\t0\t0\t\n", - "173\t138\t15\t1\t0\t0\t\n", - "152\t122\t11\t0\t0\t0\t\n", - "160\t124\t9\t0\t0\t0\t\n", - "161\t129\t13\t0\t0\t0\t\n", - "171\t134\t12\t0\t0\t0\t\n", - "163\t130\t14\t0\t0\t0\t\n", - "166\t131\t17\t0\t0\t0\t\n", - "166\t133\t21\t0\t0\t0\t\n", - "164\t129\t22\t0\t0\t0\t\n", - "170\t138\t22\t0\t0\t0\t\n", - "164\t132\t24\t0\t0\t0\t\n", - "175\t141\t27\t0\t0\t0\t\n", - "172\t144\t32\t0\t0\t0\t\n", - "182\t152\t32\t1\t0\t0\t\n", - "177\t154\t32\t1\t0\t0\t\n", - "169\t148\t30\t1\t0\t0\t\n", - "171\t150\t28\t1\t0\t0\t\n", - "172\t147\t26\t1\t0\t0\t\n", - "179\t150\t26\t1\t0\t0\t\n", - "174\t145\t25\t1\t0\t0\t\n", - "178\t150\t28\t1\t0\t0\t\n", - "174\t150\t28\t1\t0\t0\t\n", - "174\t146\t21\t1\t0\t0\t\n", - "179\t148\t24\t0\t0\t0\t\n", - "183\t148\t24\t1\t0\t0\t\n", - "182\t147\t23\t1\t0\t0\t\n", - "182\t145\t25\t1\t0\t0\t\n", - "189\t154\t28\t2\t0\t0\t\n", - "190\t155\t28\t2\t0\t0\t\n", - "200\t162\t29\t2\t0\t0\t\n", - "195\t156\t28\t2\t0\t0\t\n", - "201\t158\t29\t2\t0\t0\t\n", - "198\t159\t33\t2\t0\t0\t\n", - "176\t144\t28\t2\t0\t0\t\n", - "183\t156\t27\t1\t0\t0\t\n", - "191\t162\t27\t1\t0\t0\t\n", - "189\t162\t25\t1\t0\t0\t\n", - "179\t154\t24\t0\t0\t0\t\n" - ] - } - ], - "source": [ - "with serial.Serial(\"COM10\", baudrate=9600) as ser:\n", - " _line = bytearray([])\n", - " _line_counter = 0\n", - " _line_start = False\n", - " while True:\n", - " if ser.in_waiting > 0:\n", - " c = ser.read()\n", - " if c == bytes([0x42]):\n", - " _line_start = True\n", - " _line = bytearray([0x42])\n", - " _line_counter += 1\n", - " else:\n", - " if _line_start:\n", - " _line.append(c[0])\n", - " _line_counter += 1\n", - " \n", - " if _line_counter == 32:\n", - " _line_counter = 0\n", - " _line_start = False\n", - " for n in range(6):\n", - " print(_line[16 + n * 2] * 256 + _line[17 + n * 2], end = '\\t')\n", - " print()\n", - " " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "f17821b6", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "230\n", - "185\n", - "34\n", - "1\n", - "0\n", - "0\n" - ] - } - ], - "source": [ - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "id": "2bfa83eb", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "'M'" - ] - }, - "execution_count": 28, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "c.decode()" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "base", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.12.3" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/.vscode/examples/pm25.txt b/.vscode/examples/pm25.txt deleted file mode 100644 index 48b8d20..0000000 --- a/.vscode/examples/pm25.txt +++ /dev/null @@ -1,24 +0,0 @@ -import serial - -with serial.Serial("COM15", baudrate=9600) as ser: - _line = bytearray([]) - _line_counter = 0 - _line_start = False - while True: - if ser.in_waiting > 0: - c = ser.read() - if c == bytes([0x42]): - _line_start = True - _line = bytearray([0x42]) - _line_counter = 1 - else: - if _line_start: - _line.append(c[0]) - _line_counter += 1 - - if _line_counter == 32: - _line_counter = 0 - _line_start = False - for n in range(6): - print(_line[16 + n * 2] * 256 + _line[17 + n * 2], end = '\t') - print() \ No newline at end of file diff --git a/.vscode/examples/pyAMBYTE.ipynb b/.vscode/examples/pyAMBYTE.ipynb deleted file mode 100644 index a3ede11..0000000 --- a/.vscode/examples/pyAMBYTE.ipynb +++ /dev/null @@ -1,679 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "import serial\n", - "import numpy as np\n", - "import time\n", - "import matplotlib.pyplot as plt\n", - "from IPython.display import clear_output, display\n", - "\n", - "plt.style.use('dark_background')\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "with serial.Serial(\"COM6\", 115200, rtscts=False) as ser:\n", - " ser.write(b'hello\\n')\n", - " l = ser.readline().decode()\n", - " print(l)\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "def wait_for_control(ser, n, timeout = .1):\n", - " start_timer = time.time()\n", - " while (time.time() - start_timer < timeout):\n", - " if ser.in_waiting > 0:\n", - " b = ser.read()\n", - " if b[0] < 127:\n", - " print(b.decode(), end = \"\")\n", - " if n < 256:\n", - " if b == bytes([n]):\n", - " return 1\n", - " else:\n", - " print(int.from_bytes(b))\n", - " if n < 256:\n", - " if b == bytes([n]):\n", - " return 1\n", - " return -1\n", - "\n", - "def data_length_capture(ser, timeout = 1):\n", - " start_timer = time.time()\n", - " while (time.time() - start_timer < timeout):\n", - " if ser.in_waiting > 0:\n", - " b = ser.read()\n", - " if b[0] < 127:\n", - " print(b.decode(), end = \"\")\n", - " else:\n", - " if b == bytes([150]):\n", - " t = int.from_bytes(ser.read())\n", - " l1 = int.from_bytes(ser.read())\n", - " l2 = int.from_bytes(ser.read())\n", - " ser.read()\n", - " ser.read()\n", - " return l1 * 256 + l2\n", - " return 0\n", - "\n", - "\n", - "def data_capture(ser, len, timeout = 2):\n", - " start_timer = time.time()\n", - " counter = 0\n", - " while (time.time() - start_timer < timeout):\n", - " if ser.in_waiting > 0:\n", - " b = ser.read()\n", - " if b == bytes([151]):\n", - " b = ser.read(3) \n", - " break\n", - " else:\n", - " if b[0] < 127:\n", - " print(b.decode(), end = \"\")\n", - " \n", - " while (time.time() - start_timer < timeout):\n", - " b = ser.read(4)\n", - " print(int.from_bytes(b, \"little\"))\n", - " counter += 1 \n", - " if counter == len: break\n", - "\n", - " \n", - " return 0" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "info_outputs = \"\"\n", - "other_outputs = \"\"\n", - "with serial.Serial(\"COM6\", 115200) as ser:\n", - " start_timer = time.time()\n", - " ser.write(\"S,\".encode())\n", - "\n", - " print(wait_for_control(ser, 212))\n", - " ser.write(bytes([202]))\n", - " data_size = data_length_capture(ser)\n", - " print(\"data size:\", data_size)\n", - " \n", - " ser.write(bytes([200]))\n", - " data_capture(ser, data_size)\n", - "\n", - " print(wait_for_control(ser, 212))\n", - " ser.write(bytes([202]))\n", - " data_size = data_length_capture(ser)\n", - " print(\"data size:\", data_size)\n", - " \n", - " ser.write(bytes([200]))\n", - " data_capture(ser, data_size)\n", - "\n", - " print(wait_for_control(ser, 212))\n", - " ser.write(bytes([202]))\n", - " data_size = data_length_capture(ser)\n", - " print(\"data size:\", data_size)\n", - " \n", - " ser.write(bytes([200]))\n", - " data_capture(ser, data_size)\n", - "\n", - "\n", - "\n", - " wait_for_control(ser, 999, 2)\n", - "\n", - " " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "1000*4*8/115200" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "info_outputs = \"\"\n", - "other_outputs = \"\"\n", - "with serial.Serial(\"COM6\", 115200) as ser:\n", - " start_timer = time.time()\n", - "\n", - " ser.write(\"S,\".encode())\n", - " \n", - " while (time.time() - start_timer < 1):\n", - " if ser.in_waiting > 1:\n", - " start_timer = time.time()\n", - " l = ser.readline().decode().strip()\n", - " if l[0] == '[':\n", - " info_outputs += l + \"\\n\"\n", - " elif l[:6] == \"Binary\":\n", - " while ser.in_waiting > 0:\n", - " l = ser.read(4)\n", - " print(int.from_bytes(l, 'little'))\n", - "\n", - " else:\n", - " other_outputs += l + \"\\n\"\n", - " else:\n", - " time.sleep(.5)\n", - " \n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "int.from_bytes(l, 'little')" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "cmd = '''\n", - "set_currents(60, 30, 50);\n", - "set_gains(2, 5, 5, 1, 5, 5);\n", - "config();\n", - "\n", - "\n", - "actinic = 100;\n", - "\n", - "\n", - "set_arr(1,1,0,1,50,50,0,2);\n", - "\n", - "set_arr(1,2,0,1,250,100,actinic,2);\n", - "set_arr(2,1,0,1,450,100,actinic,2);\n", - "set_arr(3,1,0,1,50,10,actinic,2);\n", - "set_arr(3,2,0,1,450,100,0,2);\n", - "set_arr(4,1,0,1,50,10,0,2);\n", - "\n", - "\n", - "run_mpf(0, 0);\n", - "run(1,1);\n", - "run_mpf(1, actinic);\n", - "for(i=0;i<4;i++){\n", - "run(2, 1);\n", - "run_mpf(1, actinic);\n", - "}\n", - "\n", - "run(3,0);\n", - "run_mpf(1,0);\n", - "for(i=0;i<4;i++){ \n", - "set_arr(4,1,0,1,50+i*10,5,0,2);\n", - "run(4,0);\n", - "run_mpf(1,0);\n", - "}\n", - "\n", - "\n", - "'''\n", - "cmd_str = \"C:\" + cmd + \"?\"\n", - "cmd_str" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "cmd = '''\n", - "set_currents(110, 30, 50);\n", - "set_gains(1, 5, 5, 1, 5, 5);\n", - "config();\n", - "\n", - "\n", - "actinic = 0;\n", - "\n", - "\n", - "set_arr(1,1,0,1,50,25,0,2);\n", - "set_arr(1,2,0,1,50,25,0,2);\n", - "\n", - "run_mpf(0, 0);\n", - "run(1,0);\n", - "\n", - "'''\n", - "\n", - "cmd_str = \"C:\" + cmd + \"?\"\n", - "cmd_str" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "info_outputs = \"\"\n", - "other_outputs = \"\"\n", - "with serial.Serial(\"COM31\", 115200) as ser:\n", - " start_timer = time.time()\n", - " #ser.write(\"mpf, 0, 100, 100\".encode())\n", - " #ser.write(\"arrun, 500, 500, 0, 0, 0\".encode())\n", - " ser.write(cmd_str.encode())\n", - " \n", - " data = {}\n", - "\n", - " while (time.time() - start_timer < 3000):\n", - " if ser.in_waiting > 2:\n", - " start_timer = time.time()\n", - " l = ser.readline().decode().strip()\n", - " if l[0] == '[':\n", - " info_outputs += l + \"\\n\"\n", - "\n", - "\n", - " elif l[:5] == 'Data:':\n", - " _datainfo = l.split(\"\\t\")[0]\n", - " _datatype, _datalength = _datainfo.split(\",\")\n", - " datatype = _datatype.split(\":\")[1]\n", - " datalength = int(_datalength.split(\":\")[1])\n", - "\n", - " if datalength > 0:\n", - " _data = l.split(\"\\t\")[1]\n", - " if datatype in data:\n", - " data[datatype] += np.fromstring(_data, sep = ',', dtype=int).tolist()\n", - " else:\n", - " data.update({datatype: np.fromstring(_data, sep = ',', dtype=int).tolist()})\n", - " \n", - "\n", - " elif l == \"Cmd Done!\":\n", - " break\n", - " else:\n", - " other_outputs += l + \"\\n\"\n", - " else:\n", - " time.sleep(.5)\n", - " \n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "print(info_outputs, other_outputs)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "x, y = np.array(data['Fluo']), np.array(data['Fluoref'])\n", - "plt.plot(x/y)\n", - "\n", - "# if \"730\" in data:\n", - "# plt.twinx()\n", - "# plt.plot(data['730'] / data['730ref'], 'm')\n", - "# plt.twinx()\n", - "# plt.plot(data['SUN'], 'y')\n", - "# plt.twinx()\n", - "# plt.plot(data['leaf'], 'r')\n", - "\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "sig = arr[1:, 1] - 16384\n", - "ref = arr[1:, 0] - 16384\n", - "plt.plot(ref, sig-ref - ref * 0.01)\n", - "plt.plot(ref, sig-ref - ref * 0.01 - 5 * np.sin(ref/3.14/26))\n", - "plt.grid(c = [.2, .2, .2, .2])\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "y[3000]" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "info_outputs = \"\"\n", - "other_outputs = \"\"\n", - "with serial.Serial(\"COM31\", 115200) as ser:\n", - " start_timer = time.time()\n", - " #ser.write(\"mpf, 0, 100, 100\".encode())\n", - " #ser.write(\"arrun, 500, 500, 0, 0, 0\".encode())\n", - " ser.write(\"sd\\n\".encode())\n", - " \n", - " data = []\n", - "\n", - " while (time.time() - start_timer < 40):\n", - " if ser.in_waiting > 2:\n", - " start_timer = time.time()\n", - " l = ser.readline().decode().strip()\n", - " if l[0] == '[':\n", - " info_outputs += l + \"\\n\"\n", - "\n", - "\n", - " elif l[:5] == 'Data:':\n", - " data.append(np.fromstring(l[5:], sep = ',', dtype=int))\n", - " \n", - " \n", - "\n", - " elif l == \"Cmd Done!\":\n", - " break\n", - " else:\n", - " other_outputs += l + \"\\n\"\n", - " else:\n", - " time.sleep(.5)\n", - " \n", - "arr = np.array(data)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "n = 1.006\n", - "sig1 = arr[1:, 1] - arr[1:, 0] - (arr[1:, 0] - 16384) * 0.006\n", - "ref1= arr[1:, 3] - arr[1:, 2] - (arr[1:, 2] - 16384) * 0.006\n", - "\n", - "sig2 = arr[1:, 5] - arr[1:, 4] - (arr[1:, 4] - 16384 * 2) * 0.003\n", - "ref2= arr[1:, 7] - arr[1:, 6] - (arr[1:, 6] - 16384 * 2) * 0.003\n", - "\n", - "\n", - "sig3 = arr[1:, 9] - arr[1:, 8] - (arr[1:, 8] - 16384 * 3) * 0.0015\n", - "ref3= arr[1:, 11] - arr[1:, 10] - (arr[1:, 10] - 16384 * 3) * 0.0015\n", - "\n", - "sig4 = arr[1:, 13] - arr[1:, 12] - (arr[1:, 12] - 16384 * 4) * 0.0008\n", - "ref4= arr[1:, 15] - arr[1:, 14] - (arr[1:, 14] - 16384 * 4) * 0.0008\n", - "\n", - "plt.plot(sig1 / ref1 * 1.025 + .1)\n", - "plt.plot(sig2 / ref2)\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "plt.plot((sig1 * 1) / ref1 , ((sig4 * 1) / ref4) - 1.05* (sig1 * 1) / ref1 - .2)\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "(sig2.mean() - 60) / sig1.mean()/2, (sig3.mean() - 120) / sig1.mean()/3, (sig4.mean() - 120) / sig1.mean()/4, " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "x = sig1 / ref1\n", - "y = (sig2 - 50) / (ref2)\n", - "\n", - "y2 = (sig4 - 240) / (ref4)\n", - "plt.plot(x, y - 1.0 * x)\n", - "plt.plot(x, y2 - 1.0 * x)\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "np.polyfit(sig1, sig2, deg = 1)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "plt.plot(sig1, sig2)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "(sig2/sig1).mean(), (ref2/ref1).mean()\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "tl = []\n", - "\n", - "for x in range(20):\n", - " tl += [x * 500000]\n", - " \n", - "_z = tl[-1] + 1500\n", - "for x in range(4):\n", - " tl += (np.arange(12) * 120 + x * 1500 + _z).tolist()\n", - "\n", - "_z = tl[-1] + 1500\n", - "for x in range(200):\n", - " tl += [x * 1500 + _z]\n", - "\n", - "\n", - "_z = tl[-1] + 1500\n", - "for _ in range(8):\n", - " _z = tl[-1] + 1500\n", - " for x in range(20):\n", - " tl += [x * 1200 + _z]\n", - "\n", - "_z = tl[-1] + 1500\n", - "for x in range(50):\n", - " tl += [x * 1500 * 4 + _z]\n", - "\n", - "\n", - "_z = tl[-1] + 1500\n", - "inv = 1000\n", - "for x in range(40):\n", - " tl += [x * 1500 * 4 + x * inv + _z]\n", - " inv += 5000" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "plt.plot(tl[:], plot_arr[:, 0] / plot_arr[:, 1], '-')\n", - "#plt.xscale('log')" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "plt.plot((np.array(tl[-50:]) - tl[-50])/1e6, plot_arr[-50:, 0] / plot_arr[-50:, 1], '.-')\n", - "#plt.xscale('log')" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "print(outputs)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "\n", - "def line_parse(l:str)->str:\n", - " l = l.strip()\n", - " if len(l) < 1:return \"\"\n", - " if l[0] == '[':\n", - " print(l)\n", - " return \"\"\n", - " else:\n", - " return l.strip()\n", - "\n", - "with serial.Serial(\"COM4\", 115200, timeout = 5) as ser:\n", - "\n", - "\n", - " ser.write(cmd_str.encode())\n", - " data_ready = False\n", - " checked = False\n", - " ts = time.time()\n", - " while time.time() - ts < 1:\n", - " if ser.in_waiting > 0:\n", - " l = line_parse(ser.readline().decode())\n", - " if l == \"Wake!\":\n", - " ser.write(\"Ready\".encode())\n", - " data_ready = True\n", - " elif data_ready and l.isdigit():\n", - " ts = time.time()\n", - " data_len = int(l)\n", - " ser.write(\"GO\".encode())\n", - " a1 = ser.read(4 * (data_len + 1))\n", - " _a = np.frombuffer(a1, dtype=\">i4\")\n", - " if (_a[:-1].sum() == _a[-1]):\n", - " checked = True\n", - " elif l == \"DONE\":\n", - " ser.write(\"Check\".encode())\n", - " data_ready = False\n", - " print(_a)\n", - "\n", - " elif l == \"Finish\":\n", - " print(l)\n", - " break\n", - " else:\n", - " print(l)\n", - "\n", - " " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "_a[:-1].sum()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "_a" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "l" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "base", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.11.7" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/.vscode/examples/sender.ipynb b/.vscode/examples/sender.ipynb deleted file mode 100644 index eb11bab..0000000 --- a/.vscode/examples/sender.ipynb +++ /dev/null @@ -1,1893 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "import serial\n", - "import numpy as np\n", - "import time\n", - "import matplotlib.pyplot as plt\n", - "from IPython.display import clear_output, display\n", - "\n", - "plt.style.use('dark_background')\n" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "NEW Name Here Ready\n", - "\n" - ] - } - ], - "source": [ - "with serial.Serial(\"COM31\", 115200, rtscts=False) as ser:\n", - " ser.write(b'hello\\n')\n", - " l = ser.readline().decode()\n", - " print(l)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 408, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "'C:\\nset_currents(60, 30, 50);\\nset_gains(2, 5, 5, 1, 5, 5);\\nconfig();\\n\\n\\nactinic = 100;\\n\\n\\nset_arr(1,1,0,1,50,50,0,2);\\n\\nset_arr(1,2,0,1,250,100,actinic,2);\\nset_arr(2,1,0,1,450,100,actinic,2);\\nset_arr(3,1,0,1,50,10,actinic,2);\\nset_arr(3,2,0,1,450,100,0,2);\\nset_arr(4,1,0,1,50,10,0,2);\\n\\n\\nrun_mpf(0, 0);\\nrun(1,1);\\nrun_mpf(1, actinic);\\nfor(i=0;i<4;i++){\\nrun(2, 1);\\nrun_mpf(1, actinic);\\n}\\n\\nrun(3,0);\\nrun_mpf(1,0);\\nfor(i=0;i<4;i++){ \\nset_arr(4,1,0,1,50+i*10,5,0,2);\\nrun(4,0);\\nrun_mpf(1,0);\\n}\\n\\n\\n?'" - ] - }, - "execution_count": 408, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "cmd = '''\n", - "set_currents(60, 30, 50);\n", - "set_gains(2, 5, 5, 1, 5, 5);\n", - "config();\n", - "\n", - "\n", - "actinic = 100;\n", - "\n", - "\n", - "set_arr(1,1,0,1,50,50,0,2);\n", - "\n", - "set_arr(1,2,0,1,250,100,actinic,2);\n", - "set_arr(2,1,0,1,450,100,actinic,2);\n", - "set_arr(3,1,0,1,50,10,actinic,2);\n", - "set_arr(3,2,0,1,450,100,0,2);\n", - "set_arr(4,1,0,1,50,10,0,2);\n", - "\n", - "\n", - "run_mpf(0, 0);\n", - "run(1,1);\n", - "run_mpf(1, actinic);\n", - "for(i=0;i<4;i++){\n", - "run(2, 1);\n", - "run_mpf(1, actinic);\n", - "}\n", - "\n", - "run(3,0);\n", - "run_mpf(1,0);\n", - "for(i=0;i<4;i++){ \n", - "set_arr(4,1,0,1,50+i*10,5,0,2);\n", - "run(4,0);\n", - "run_mpf(1,0);\n", - "}\n", - "\n", - "\n", - "'''\n", - "cmd_str = \"C:\" + cmd + \"?\"\n", - "cmd_str" - ] - }, - { - "cell_type": "code", - "execution_count": 386, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "'C:\\nset_currents(110, 30, 50);\\nset_gains(1, 5, 5, 1, 5, 5);\\nconfig();\\n\\n\\nactinic = 0;\\n\\n\\nset_arr(1,1,0,1,50,25,0,2);\\nset_arr(1,2,0,1,50,25,0,2);\\n\\nrun_mpf(0, 0);\\nrun(1,0);\\n\\n?'" - ] - }, - "execution_count": 386, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "cmd = '''\n", - "set_currents(110, 30, 50);\n", - "set_gains(1, 5, 5, 1, 5, 5);\n", - "config();\n", - "\n", - "\n", - "actinic = 0;\n", - "\n", - "\n", - "set_arr(1,1,0,1,50,25,0,2);\n", - "set_arr(1,2,0,1,50,25,0,2);\n", - "\n", - "run_mpf(0, 0);\n", - "run(1,0);\n", - "\n", - "'''\n", - "\n", - "cmd_str = \"C:\" + cmd + \"?\"\n", - "cmd_str" - ] - }, - { - "cell_type": "code", - "execution_count": 409, - "metadata": {}, - "outputs": [], - "source": [ - "info_outputs = \"\"\n", - "other_outputs = \"\"\n", - "with serial.Serial(\"COM31\", 115200) as ser:\n", - " start_timer = time.time()\n", - " #ser.write(\"mpf, 0, 100, 100\".encode())\n", - " #ser.write(\"arrun, 500, 500, 0, 0, 0\".encode())\n", - " ser.write(cmd_str.encode())\n", - " \n", - " data = {}\n", - "\n", - " while (time.time() - start_timer < 3000):\n", - " if ser.in_waiting > 2:\n", - " start_timer = time.time()\n", - " l = ser.readline().decode().strip()\n", - " if l[0] == '[':\n", - " info_outputs += l + \"\\n\"\n", - "\n", - "\n", - " elif l[:5] == 'Data:':\n", - " _datainfo = l.split(\"\\t\")[0]\n", - " _datatype, _datalength = _datainfo.split(\",\")\n", - " datatype = _datatype.split(\":\")[1]\n", - " datalength = int(_datalength.split(\":\")[1])\n", - "\n", - " if datalength > 0:\n", - " _data = l.split(\"\\t\")[1]\n", - " if datatype in data:\n", - " data[datatype] += np.fromstring(_data, sep = ',', dtype=int).tolist()\n", - " else:\n", - " data.update({datatype: np.fromstring(_data, sep = ',', dtype=int).tolist()})\n", - " \n", - "\n", - " elif l == \"Cmd Done!\":\n", - " break\n", - " else:\n", - " other_outputs += l + \"\\n\"\n", - " else:\n", - " time.sleep(.5)\n", - " \n" - ] - }, - { - "cell_type": "code", - "execution_count": 410, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[234683][V][do_c.cpp:160] set_currents(): [DO_C] set pulsed-620 to: 60, set pulsed-720 to: 30, set far_red to: 50\n", - "[234693][V][do_c.cpp:172] set_gains(): [DO_C] Fluor Gain:2, Fluo ref Gain:5, 730 Gain:5, 730ref Gain:1, Sun Gain:5, Leaf Gain:5\n", - "[234705][V][u_adpd6100.cpp:618] preset_config_1(): [ADPD] Preset_config 1 set for timeslot:0. Two ambient channels. Total 2 x 3 bytes\n", - "[234717][V][u_adpd6100.cpp:666] preset_config_2(): [ADPD] Preset_config 2 set for timeslot:1. Total 2 x 2 x 3 bytes\n", - "[234728][V][u_adpd6100.cpp:714] preset_config_3(): [ADPD] Preset_config 3 set for timeslot:2. Total 2 x 3 bytes\n", - "[234739][V][u_adpd6100.cpp:763] preset_config_4(): [ADPD] Preset_config 4 set for timeslot:3. Total 0 bytes\n", - "[234749][V][u_adpd6100.cpp:763] preset_config_4(): [ADPD] Preset_config 4 set for timeslot:4. Total 0 bytes\n", - "[234759][V][u_adpd6100.cpp:763] preset_config_4(): [ADPD] Preset_config 4 set for timeslot:5. Total 0 bytes\n", - "[234769][V][u_adpd6100.cpp:763] preset_config_4(): [ADPD] Preset_config 4 set for timeslot:6. Total 0 bytes\n", - "[234780][V][u_adpd6100.cpp:763] preset_config_4(): [ADPD] Preset_config 4 set for timeslot:7. Total 0 bytes\n", - "[234790][V][u_adpd6100.cpp:763] preset_config_4(): [ADPD] Preset_config 4 set for timeslot:8. Total 0 bytes\n", - "[234800][V][do_c.cpp:147] detector_preset(): [DO_C] ADPD detector preset with stored values\n", - "[234808][V][do_c.cpp:47] arr_set(): [DO_C] Set arr0, line 0 to type 1 with 50 x 50Hz samples, actinic:0, sub:2, IR:0\n", - "[234819][V][do_c.cpp:47] arr_set(): [DO_C] Set arr0, line 1 to type 1 with 250 x 100Hz samples, actinic:100, sub:2, IR:0\n", - "[234829][V][do_c.cpp:47] arr_set(): [DO_C] Set arr1, line 0 to type 1 with 450 x 100Hz samples, actinic:100, sub:2, IR:0\n", - "[234840][V][do_c.cpp:47] arr_set(): [DO_C] Set arr2, line 0 to type 1 with 50 x 10Hz samples, actinic:100, sub:2, IR:0\n", - "[234851][V][do_c.cpp:47] arr_set(): [DO_C] Set arr2, line 1 to type 1 with 450 x 100Hz samples, actinic:0, sub:2, IR:0\n", - "[234861][V][do_c.cpp:47] arr_set(): [DO_C] Set arr3, line 0 to type 1 with 50 x 10Hz samples, actinic:0, sub:2, IR:0\n", - "[234872][V][PAM.cpp:298] MPF(): [PAM] RUN MPF with mode:0, pulse current:60, DC current 0\n", - "[234880][V][data_utils.cpp:10] dataclass(): [DATA_UTIL] DATACLASS Created\n", - "[234886][V][data_utils.cpp:10] dataclass(): [DATA_UTIL] DATACLASS Created\n", - "[234893][V][data_utils.cpp:32] init(): [DATA_UTIL] Allocation 4320 bytes\n", - "[234900][V][data_utils.cpp:61] clear(): [DATA_UTIL] ARR reset to 0\n", - "[234906][V][data_utils.cpp:32] init(): [DATA_UTIL] Allocation 4320 bytes\n", - "[234912][V][data_utils.cpp:61] clear(): [DATA_UTIL] ARR reset to 0\n", - "[234918][V][PAM.cpp:303] MPF(): [PAM] Memory allocation completed\n", - "[234927][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 0\n", - "[234938][V][PAM.cpp:341] MPF(): [PAM] Phase-0 Started\n", - "[244943][V][PAM.cpp:352] MPF(): [PAM] Phase-0 Completed\n", - "[244948][V][PAM.cpp:359] MPF(): [PAM] Phase-1 Config\n", - "[244953][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 0\n", - "[244961][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 1\n", - "[244970][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 2\n", - "[244978][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 3\n", - "[244987][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 4\n", - "[244996][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 5\n", - "[245004][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 6\n", - "[245013][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 7\n", - "[245022][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 8\n", - "[245030][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 9\n", - "[245039][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 10\n", - "[245048][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 11\n", - "[245061][V][PAM.cpp:369] MPF(): [PAM] Phase-1 LED ON\n", - "[245075][V][PAM.cpp:386] MPF(): [PAM] Phase-1 Completed; Phase-2 start\n", - "[245384][V][PAM.cpp:414] MPF(): [PAM] Phase-2 Completed; Phase-3 Start\n", - "[245391][V][PAM.cpp:421] MPF(): [PAM] LED set to 220\n", - "[245457][V][PAM.cpp:421] MPF(): [PAM] LED set to 190\n", - "[245523][V][PAM.cpp:421] MPF(): [PAM] LED set to 160\n", - "[245589][V][PAM.cpp:421] MPF(): [PAM] LED set to 130\n", - "[245655][V][PAM.cpp:421] MPF(): [PAM] LED set to 100\n", - "[245722][V][PAM.cpp:421] MPF(): [PAM] LED set to 70\n", - "[245788][V][PAM.cpp:421] MPF(): [PAM] LED set to 40\n", - "[245853][V][PAM.cpp:421] MPF(): [PAM] LED set to 10\n", - "[245919][V][PAM.cpp:444] MPF(): [PAM] Phase-3 Completed; Phase-4 Start\n", - "[245926][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 0\n", - "[246236][V][PAM.cpp:484] MPF(): [PAM] Phase-4 Completed\n", - "[246241][V][PAM.cpp:488] MPF(): [PAM] Phase-minus1 Started\n", - "[262367][V][PAM.cpp:507] MPF(): [PAM] Measurement Completed\n", - "[262733][V][PAM.cpp:526] MPF(): [PAM] All Completed\n", - "[262742][V][data_utils.cpp:15] ~dataclass(): [DATA_UTIL] DATACLASS destroied\n", - "[262749][V][data_utils.cpp:22] clean(): [DATA_UTIL] Memory freed\n", - "[262754][V][data_utils.cpp:15] ~dataclass(): [DATA_UTIL] DATACLASS destroied\n", - "[262761][V][data_utils.cpp:22] clean(): [DATA_UTIL] Memory freed\n", - "[262767][V][u_adpd6100.cpp:618] preset_config_1(): [ADPD] Preset_config 1 set for timeslot:0. Two ambient channels. Total 2 x 3 bytes\n", - "[262780][V][u_adpd6100.cpp:666] preset_config_2(): [ADPD] Preset_config 2 set for timeslot:1. Total 2 x 2 x 3 bytes\n", - "[262791][V][u_adpd6100.cpp:714] preset_config_3(): [ADPD] Preset_config 3 set for timeslot:2. Total 2 x 3 bytes\n", - "[262801][V][u_adpd6100.cpp:763] preset_config_4(): [ADPD] Preset_config 4 set for timeslot:3. Total 0 bytes\n", - "[262811][V][u_adpd6100.cpp:763] preset_config_4(): [ADPD] Preset_config 4 set for timeslot:4. Total 0 bytes\n", - "[262822][V][u_adpd6100.cpp:763] preset_config_4(): [ADPD] Preset_config 4 set for timeslot:5. Total 0 bytes\n", - "[262832][V][u_adpd6100.cpp:763] preset_config_4(): [ADPD] Preset_config 4 set for timeslot:6. Total 0 bytes\n", - "[262842][V][u_adpd6100.cpp:763] preset_config_4(): [ADPD] Preset_config 4 set for timeslot:7. Total 0 bytes\n", - "[262852][V][u_adpd6100.cpp:763] preset_config_4(): [ADPD] Preset_config 4 set for timeslot:8. Total 0 bytes\n", - "[262862][V][PAM.cpp:116] run_preprocess_type1(): [PAM] Run type:1, number:50, freq: 50, actinic: 0, subfactor 2\n", - "[262872][V][PAM.cpp:116] run_preprocess_type1(): [PAM] Run type:1, number:250, freq: 100, actinic: 100, subfactor 2\n", - "[262883][V][PAM.cpp:134] run_arr_type1(): [PAM] Sample & Ref: 300, optionals: 37\n", - "[262890][V][data_utils.cpp:10] dataclass(): [DATA_UTIL] DATACLASS Created\n", - "[262897][V][data_utils.cpp:10] dataclass(): [DATA_UTIL] DATACLASS Created\n", - "[262903][V][data_utils.cpp:10] dataclass(): [DATA_UTIL] DATACLASS Created\n", - "[262910][V][data_utils.cpp:10] dataclass(): [DATA_UTIL] DATACLASS Created\n", - "[262916][V][data_utils.cpp:10] dataclass(): [DATA_UTIL] DATACLASS Created\n", - "[262923][V][data_utils.cpp:10] dataclass(): [DATA_UTIL] DATACLASS Created\n", - "[262930][V][data_utils.cpp:32] init(): [DATA_UTIL] Allocation 1200 bytes\n", - "[262936][V][data_utils.cpp:61] clear(): [DATA_UTIL] ARR reset to 0\n", - "[262942][V][data_utils.cpp:32] init(): [DATA_UTIL] Allocation 1200 bytes\n", - "[262949][V][data_utils.cpp:61] clear(): [DATA_UTIL] ARR reset to 0\n", - "[262955][V][data_utils.cpp:32] init(): [DATA_UTIL] Allocation 148 bytes\n", - "[262961][V][data_utils.cpp:61] clear(): [DATA_UTIL] ARR reset to 0\n", - "[262967][V][data_utils.cpp:32] init(): [DATA_UTIL] Allocation 148 bytes\n", - "[262974][V][data_utils.cpp:61] clear(): [DATA_UTIL] ARR reset to 0\n", - "[262980][V][data_utils.cpp:32] init(): [DATA_UTIL] Allocation 148 bytes\n", - "[262986][V][data_utils.cpp:61] clear(): [DATA_UTIL] ARR reset to 0\n", - "[262992][V][data_utils.cpp:32] init(): [DATA_UTIL] Allocation 148 bytes\n", - "[262998][V][data_utils.cpp:61] clear(): [DATA_UTIL] ARR reset to 0\n", - "[263004][V][PAM.cpp:150] run_arr_type1(): [PAM] Memory allocation completed\n", - "[266279][V][data_utils.cpp:15] ~dataclass(): [DATA_UTIL] DATACLASS destroied\n", - "[266291][V][data_utils.cpp:22] clean(): [DATA_UTIL] Memory freed\n", - "[266297][V][data_utils.cpp:15] ~dataclass(): [DATA_UTIL] DATACLASS destroied\n", - "[266303][V][data_utils.cpp:22] clean(): [DATA_UTIL] Memory freed\n", - "[266309][V][data_utils.cpp:15] ~dataclass(): [DATA_UTIL] DATACLASS destroied\n", - "[266316][V][data_utils.cpp:22] clean(): [DATA_UTIL] Memory freed\n", - "[266322][V][data_utils.cpp:15] ~dataclass(): [DATA_UTIL] DATACLASS destroied\n", - "[266329][V][data_utils.cpp:22] clean(): [DATA_UTIL] Memory freed\n", - "[266335][V][data_utils.cpp:15] ~dataclass(): [DATA_UTIL] DATACLASS destroied\n", - "[266341][V][data_utils.cpp:22] clean(): [DATA_UTIL] Memory freed\n", - "[266347][V][data_utils.cpp:15] ~dataclass(): [DATA_UTIL] DATACLASS destroied\n", - "[266354][V][data_utils.cpp:22] clean(): [DATA_UTIL] Memory freed\n", - "[266360][V][PAM.cpp:298] MPF(): [PAM] RUN MPF with mode:1, pulse current:60, DC current 100\n", - "[266368][V][data_utils.cpp:10] dataclass(): [DATA_UTIL] DATACLASS Created\n", - "[266375][V][data_utils.cpp:10] dataclass(): [DATA_UTIL] DATACLASS Created\n", - "[266381][V][data_utils.cpp:32] init(): [DATA_UTIL] Allocation 4320 bytes\n", - "[266388][V][data_utils.cpp:61] clear(): [DATA_UTIL] ARR reset to 0\n", - "[266394][V][data_utils.cpp:32] init(): [DATA_UTIL] Allocation 4320 bytes\n", - "[266401][V][data_utils.cpp:61] clear(): [DATA_UTIL] ARR reset to 0\n", - "[266407][V][PAM.cpp:303] MPF(): [PAM] Memory allocation completed\n", - "[266413][V][PAM.cpp:359] MPF(): [PAM] Phase-1 Config\n", - "[266418][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 0\n", - "[266426][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 1\n", - "[266435][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 2\n", - "[266444][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 3\n", - "[266452][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 4\n", - "[266461][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 5\n", - "[266470][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 6\n", - "[266478][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 7\n", - "[266487][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 8\n", - "[266496][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 9\n", - "[266504][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 10\n", - "[266513][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 11\n", - "[266527][V][PAM.cpp:369] MPF(): [PAM] Phase-1 LED ON\n", - "[266541][V][PAM.cpp:386] MPF(): [PAM] Phase-1 Completed; Phase-2 start\n", - "[266850][V][PAM.cpp:414] MPF(): [PAM] Phase-2 Completed; Phase-3 Start\n", - "[266857][V][PAM.cpp:421] MPF(): [PAM] LED set to 220\n", - "[266923][V][PAM.cpp:421] MPF(): [PAM] LED set to 190\n", - "[266990][V][PAM.cpp:421] MPF(): [PAM] LED set to 160\n", - "[267056][V][PAM.cpp:421] MPF(): [PAM] LED set to 130\n", - "[267122][V][PAM.cpp:421] MPF(): [PAM] LED set to 100\n", - "[267188][V][PAM.cpp:421] MPF(): [PAM] LED set to 70\n", - "[267254][V][PAM.cpp:421] MPF(): [PAM] LED set to 40\n", - "[267319][V][PAM.cpp:421] MPF(): [PAM] LED set to 10\n", - "[267385][V][PAM.cpp:444] MPF(): [PAM] Phase-3 Completed; Phase-4 Start\n", - "[267392][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 0\n", - "[267701][V][PAM.cpp:484] MPF(): [PAM] Phase-4 Completed\n", - "[267706][V][PAM.cpp:507] MPF(): [PAM] Measurement Completed\n", - "[268029][V][PAM.cpp:526] MPF(): [PAM] All Completed\n", - "[268040][V][data_utils.cpp:15] ~dataclass(): [DATA_UTIL] DATACLASS destroied\n", - "[268047][V][data_utils.cpp:22] clean(): [DATA_UTIL] Memory freed\n", - "[268052][V][data_utils.cpp:15] ~dataclass(): [DATA_UTIL] DATACLASS destroied\n", - "[268059][V][data_utils.cpp:22] clean(): [DATA_UTIL] Memory freed\n", - "[268065][V][u_adpd6100.cpp:618] preset_config_1(): [ADPD] Preset_config 1 set for timeslot:0. Two ambient channels. Total 2 x 3 bytes\n", - "[268078][V][u_adpd6100.cpp:666] preset_config_2(): [ADPD] Preset_config 2 set for timeslot:1. Total 2 x 2 x 3 bytes\n", - "[268089][V][u_adpd6100.cpp:714] preset_config_3(): [ADPD] Preset_config 3 set for timeslot:2. Total 2 x 3 bytes\n", - "[268099][V][u_adpd6100.cpp:763] preset_config_4(): [ADPD] Preset_config 4 set for timeslot:3. Total 0 bytes\n", - "[268109][V][u_adpd6100.cpp:763] preset_config_4(): [ADPD] Preset_config 4 set for timeslot:4. Total 0 bytes\n", - "[268120][V][u_adpd6100.cpp:763] preset_config_4(): [ADPD] Preset_config 4 set for timeslot:5. Total 0 bytes\n", - "[268130][V][u_adpd6100.cpp:763] preset_config_4(): [ADPD] Preset_config 4 set for timeslot:6. Total 0 bytes\n", - "[268140][V][u_adpd6100.cpp:763] preset_config_4(): [ADPD] Preset_config 4 set for timeslot:7. Total 0 bytes\n", - "[268150][V][u_adpd6100.cpp:763] preset_config_4(): [ADPD] Preset_config 4 set for timeslot:8. Total 0 bytes\n", - "[268160][V][PAM.cpp:116] run_preprocess_type1(): [PAM] Run type:1, number:450, freq: 100, actinic: 100, subfactor 2\n", - "[268171][V][PAM.cpp:134] run_arr_type1(): [PAM] Sample & Ref: 450, optionals: 56\n", - "[268178][V][data_utils.cpp:10] dataclass(): [DATA_UTIL] DATACLASS Created\n", - "[268185][V][data_utils.cpp:10] dataclass(): [DATA_UTIL] DATACLASS Created\n", - "[268191][V][data_utils.cpp:10] dataclass(): [DATA_UTIL] DATACLASS Created\n", - "[268198][V][data_utils.cpp:10] dataclass(): [DATA_UTIL] DATACLASS Created\n", - "[268204][V][data_utils.cpp:10] dataclass(): [DATA_UTIL] DATACLASS Created\n", - "[268211][V][data_utils.cpp:10] dataclass(): [DATA_UTIL] DATACLASS Created\n", - "[268218][V][data_utils.cpp:32] init(): [DATA_UTIL] Allocation 1800 bytes\n", - "[268224][V][data_utils.cpp:61] clear(): [DATA_UTIL] ARR reset to 0\n", - "[268230][V][data_utils.cpp:32] init(): [DATA_UTIL] Allocation 1800 bytes\n", - "[268237][V][data_utils.cpp:61] clear(): [DATA_UTIL] ARR reset to 0\n", - "[268243][V][data_utils.cpp:32] init(): [DATA_UTIL] Allocation 224 bytes\n", - "[268249][V][data_utils.cpp:61] clear(): [DATA_UTIL] ARR reset to 0\n", - "[268255][V][data_utils.cpp:32] init(): [DATA_UTIL] Allocation 224 bytes\n", - "[268262][V][data_utils.cpp:61] clear(): [DATA_UTIL] ARR reset to 0\n", - "[268268][V][data_utils.cpp:32] init(): [DATA_UTIL] Allocation 224 bytes\n", - "[268274][V][data_utils.cpp:61] clear(): [DATA_UTIL] ARR reset to 0\n", - "[268280][V][data_utils.cpp:32] init(): [DATA_UTIL] Allocation 224 bytes\n", - "[268287][V][data_utils.cpp:61] clear(): [DATA_UTIL] ARR reset to 0\n", - "[268293][V][PAM.cpp:150] run_arr_type1(): [PAM] Memory allocation completed\n", - "[272581][V][data_utils.cpp:15] ~dataclass(): [DATA_UTIL] DATACLASS destroied\n", - "[272590][V][data_utils.cpp:22] clean(): [DATA_UTIL] Memory freed\n", - "[272595][V][data_utils.cpp:15] ~dataclass(): [DATA_UTIL] DATACLASS destroied\n", - "[272602][V][data_utils.cpp:22] clean(): [DATA_UTIL] Memory freed\n", - "[272608][V][data_utils.cpp:15] ~dataclass(): [DATA_UTIL] DATACLASS destroied\n", - "[272615][V][data_utils.cpp:22] clean(): [DATA_UTIL] Memory freed\n", - "[272621][V][data_utils.cpp:15] ~dataclass(): [DATA_UTIL] DATACLASS destroied\n", - "[272628][V][data_utils.cpp:22] clean(): [DATA_UTIL] Memory freed\n", - "[272633][V][data_utils.cpp:15] ~dataclass(): [DATA_UTIL] DATACLASS destroied\n", - "[272640][V][data_utils.cpp:22] clean(): [DATA_UTIL] Memory freed\n", - "[272646][V][data_utils.cpp:15] ~dataclass(): [DATA_UTIL] DATACLASS destroied\n", - "[272653][V][data_utils.cpp:22] clean(): [DATA_UTIL] Memory freed\n", - "[272659][V][PAM.cpp:298] MPF(): [PAM] RUN MPF with mode:1, pulse current:60, DC current 100\n", - "[272667][V][data_utils.cpp:10] dataclass(): [DATA_UTIL] DATACLASS Created\n", - "[272674][V][data_utils.cpp:10] dataclass(): [DATA_UTIL] DATACLASS Created\n", - "[272680][V][data_utils.cpp:32] init(): [DATA_UTIL] Allocation 4320 bytes\n", - "[272687][V][data_utils.cpp:61] clear(): [DATA_UTIL] ARR reset to 0\n", - "[272693][V][data_utils.cpp:32] init(): [DATA_UTIL] Allocation 4320 bytes\n", - "[272699][V][data_utils.cpp:61] clear(): [DATA_UTIL] ARR reset to 0\n", - "[272705][V][PAM.cpp:303] MPF(): [PAM] Memory allocation completed\n", - "[272712][V][PAM.cpp:359] MPF(): [PAM] Phase-1 Config\n", - "[272716][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 0\n", - "[272725][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 1\n", - "[272734][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 2\n", - "[272742][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 3\n", - "[272751][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 4\n", - "[272760][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 5\n", - "[272768][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 6\n", - "[272777][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 7\n", - "[272786][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 8\n", - "[272794][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 9\n", - "[272803][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 10\n", - "[272812][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 11\n", - "[272825][V][PAM.cpp:369] MPF(): [PAM] Phase-1 LED ON\n", - "[272839][V][PAM.cpp:386] MPF(): [PAM] Phase-1 Completed; Phase-2 start\n", - "[273148][V][PAM.cpp:414] MPF(): [PAM] Phase-2 Completed; Phase-3 Start\n", - "[273155][V][PAM.cpp:421] MPF(): [PAM] LED set to 220\n", - "[273221][V][PAM.cpp:421] MPF(): [PAM] LED set to 190\n", - "[273288][V][PAM.cpp:421] MPF(): [PAM] LED set to 160\n", - "[273354][V][PAM.cpp:421] MPF(): [PAM] LED set to 130\n", - "[273420][V][PAM.cpp:421] MPF(): [PAM] LED set to 100\n", - "[273486][V][PAM.cpp:421] MPF(): [PAM] LED set to 70\n", - "[273552][V][PAM.cpp:421] MPF(): [PAM] LED set to 40\n", - "[273618][V][PAM.cpp:421] MPF(): [PAM] LED set to 10\n", - "[273683][V][PAM.cpp:444] MPF(): [PAM] Phase-3 Completed; Phase-4 Start\n", - "[273690][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 0\n", - "[273999][V][PAM.cpp:484] MPF(): [PAM] Phase-4 Completed\n", - "[274004][V][PAM.cpp:507] MPF(): [PAM] Measurement Completed\n", - "[274327][V][PAM.cpp:526] MPF(): [PAM] All Completed\n", - "[274338][V][data_utils.cpp:15] ~dataclass(): [DATA_UTIL] DATACLASS destroied\n", - "[274345][V][data_utils.cpp:22] clean(): [DATA_UTIL] Memory freed\n", - "[274350][V][data_utils.cpp:15] ~dataclass(): [DATA_UTIL] DATACLASS destroied\n", - "[274357][V][data_utils.cpp:22] clean(): [DATA_UTIL] Memory freed\n", - "[274363][V][u_adpd6100.cpp:618] preset_config_1(): [ADPD] Preset_config 1 set for timeslot:0. Two ambient channels. Total 2 x 3 bytes\n", - "[274376][V][u_adpd6100.cpp:666] preset_config_2(): [ADPD] Preset_config 2 set for timeslot:1. Total 2 x 2 x 3 bytes\n", - "[274387][V][u_adpd6100.cpp:714] preset_config_3(): [ADPD] Preset_config 3 set for timeslot:2. Total 2 x 3 bytes\n", - "[274397][V][u_adpd6100.cpp:763] preset_config_4(): [ADPD] Preset_config 4 set for timeslot:3. Total 0 bytes\n", - "[274407][V][u_adpd6100.cpp:763] preset_config_4(): [ADPD] Preset_config 4 set for timeslot:4. Total 0 bytes\n", - "[274418][V][u_adpd6100.cpp:763] preset_config_4(): [ADPD] Preset_config 4 set for timeslot:5. Total 0 bytes\n", - "[274428][V][u_adpd6100.cpp:763] preset_config_4(): [ADPD] Preset_config 4 set for timeslot:6. Total 0 bytes\n", - "[274438][V][u_adpd6100.cpp:763] preset_config_4(): [ADPD] Preset_config 4 set for timeslot:7. Total 0 bytes\n", - "[274448][V][u_adpd6100.cpp:763] preset_config_4(): [ADPD] Preset_config 4 set for timeslot:8. Total 0 bytes\n", - "[274459][V][PAM.cpp:116] run_preprocess_type1(): [PAM] Run type:1, number:450, freq: 100, actinic: 100, subfactor 2\n", - "[274469][V][PAM.cpp:134] run_arr_type1(): [PAM] Sample & Ref: 450, optionals: 56\n", - "[274476][V][data_utils.cpp:10] dataclass(): [DATA_UTIL] DATACLASS Created\n", - "[274483][V][data_utils.cpp:10] dataclass(): [DATA_UTIL] DATACLASS Created\n", - "[274489][V][data_utils.cpp:10] dataclass(): [DATA_UTIL] DATACLASS Created\n", - "[274496][V][data_utils.cpp:10] dataclass(): [DATA_UTIL] DATACLASS Created\n", - "[274503][V][data_utils.cpp:10] dataclass(): [DATA_UTIL] DATACLASS Created\n", - "[274509][V][data_utils.cpp:10] dataclass(): [DATA_UTIL] DATACLASS Created\n", - "[274516][V][data_utils.cpp:32] init(): [DATA_UTIL] Allocation 1800 bytes\n", - "[274522][V][data_utils.cpp:61] clear(): [DATA_UTIL] ARR reset to 0\n", - "[274528][V][data_utils.cpp:32] init(): [DATA_UTIL] Allocation 1800 bytes\n", - "[274535][V][data_utils.cpp:61] clear(): [DATA_UTIL] ARR reset to 0\n", - "[274541][V][data_utils.cpp:32] init(): [DATA_UTIL] Allocation 224 bytes\n", - "[274547][V][data_utils.cpp:61] clear(): [DATA_UTIL] ARR reset to 0\n", - "[274553][V][data_utils.cpp:32] init(): [DATA_UTIL] Allocation 224 bytes\n", - "[274560][V][data_utils.cpp:61] clear(): [DATA_UTIL] ARR reset to 0\n", - "[274566][V][data_utils.cpp:32] init(): [DATA_UTIL] Allocation 224 bytes\n", - "[274572][V][data_utils.cpp:61] clear(): [DATA_UTIL] ARR reset to 0\n", - "[274578][V][data_utils.cpp:32] init(): [DATA_UTIL] Allocation 224 bytes\n", - "[274585][V][data_utils.cpp:61] clear(): [DATA_UTIL] ARR reset to 0\n", - "[274591][V][PAM.cpp:150] run_arr_type1(): [PAM] Memory allocation completed\n", - "[278879][V][data_utils.cpp:15] ~dataclass(): [DATA_UTIL] DATACLASS destroied\n", - "[278888][V][data_utils.cpp:22] clean(): [DATA_UTIL] Memory freed\n", - "[278893][V][data_utils.cpp:15] ~dataclass(): [DATA_UTIL] DATACLASS destroied\n", - "[278900][V][data_utils.cpp:22] clean(): [DATA_UTIL] Memory freed\n", - "[278906][V][data_utils.cpp:15] ~dataclass(): [DATA_UTIL] DATACLASS destroied\n", - "[278913][V][data_utils.cpp:22] clean(): [DATA_UTIL] Memory freed\n", - "[278919][V][data_utils.cpp:15] ~dataclass(): [DATA_UTIL] DATACLASS destroied\n", - "[278926][V][data_utils.cpp:22] clean(): [DATA_UTIL] Memory freed\n", - "[278931][V][data_utils.cpp:15] ~dataclass(): [DATA_UTIL] DATACLASS destroied\n", - "[278938][V][data_utils.cpp:22] clean(): [DATA_UTIL] Memory freed\n", - "[278944][V][data_utils.cpp:15] ~dataclass(): [DATA_UTIL] DATACLASS destroied\n", - "[278951][V][data_utils.cpp:22] clean(): [DATA_UTIL] Memory freed\n", - "[278957][V][PAM.cpp:298] MPF(): [PAM] RUN MPF with mode:1, pulse current:60, DC current 100\n", - "[278965][V][data_utils.cpp:10] dataclass(): [DATA_UTIL] DATACLASS Created\n", - "[278972][V][data_utils.cpp:10] dataclass(): [DATA_UTIL] DATACLASS Created\n", - "[278978][V][data_utils.cpp:32] init(): [DATA_UTIL] Allocation 4320 bytes\n", - "[278985][V][data_utils.cpp:61] clear(): [DATA_UTIL] ARR reset to 0\n", - "[278991][V][data_utils.cpp:32] init(): [DATA_UTIL] Allocation 4320 bytes\n", - "[278997][V][data_utils.cpp:61] clear(): [DATA_UTIL] ARR reset to 0\n", - "[279003][V][PAM.cpp:303] MPF(): [PAM] Memory allocation completed\n", - "[279010][V][PAM.cpp:359] MPF(): [PAM] Phase-1 Config\n", - "[279014][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 0\n", - "[279023][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 1\n", - "[279032][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 2\n", - "[279040][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 3\n", - "[279049][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 4\n", - "[279058][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 5\n", - "[279066][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 6\n", - "[279075][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 7\n", - "[279084][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 8\n", - "[279092][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 9\n", - "[279101][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 10\n", - "[279110][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 11\n", - "[279123][V][PAM.cpp:369] MPF(): [PAM] Phase-1 LED ON\n", - "[279137][V][PAM.cpp:386] MPF(): [PAM] Phase-1 Completed; Phase-2 start\n", - "[279446][V][PAM.cpp:414] MPF(): [PAM] Phase-2 Completed; Phase-3 Start\n", - "[279453][V][PAM.cpp:421] MPF(): [PAM] LED set to 220\n", - "[279519][V][PAM.cpp:421] MPF(): [PAM] LED set to 190\n", - "[279585][V][PAM.cpp:421] MPF(): [PAM] LED set to 160\n", - "[279652][V][PAM.cpp:421] MPF(): [PAM] LED set to 130\n", - "[279718][V][PAM.cpp:421] MPF(): [PAM] LED set to 100\n", - "[279784][V][PAM.cpp:421] MPF(): [PAM] LED set to 70\n", - "[279850][V][PAM.cpp:421] MPF(): [PAM] LED set to 40\n", - "[279915][V][PAM.cpp:421] MPF(): [PAM] LED set to 10\n", - "[279981][V][PAM.cpp:444] MPF(): [PAM] Phase-3 Completed; Phase-4 Start\n", - "[279988][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 0\n", - "[280297][V][PAM.cpp:484] MPF(): [PAM] Phase-4 Completed\n", - "[280302][V][PAM.cpp:507] MPF(): [PAM] Measurement Completed\n", - "[280625][V][PAM.cpp:526] MPF(): [PAM] All Completed\n", - "[280636][V][data_utils.cpp:15] ~dataclass(): [DATA_UTIL] DATACLASS destroied\n", - "[280643][V][data_utils.cpp:22] clean(): [DATA_UTIL] Memory freed\n", - "[280648][V][data_utils.cpp:15] ~dataclass(): [DATA_UTIL] DATACLASS destroied\n", - "[280655][V][data_utils.cpp:22] clean(): [DATA_UTIL] Memory freed\n", - "[280661][V][u_adpd6100.cpp:618] preset_config_1(): [ADPD] Preset_config 1 set for timeslot:0. Two ambient channels. Total 2 x 3 bytes\n", - "[280674][V][u_adpd6100.cpp:666] preset_config_2(): [ADPD] Preset_config 2 set for timeslot:1. Total 2 x 2 x 3 bytes\n", - "[280685][V][u_adpd6100.cpp:714] preset_config_3(): [ADPD] Preset_config 3 set for timeslot:2. Total 2 x 3 bytes\n", - "[280695][V][u_adpd6100.cpp:763] preset_config_4(): [ADPD] Preset_config 4 set for timeslot:3. Total 0 bytes\n", - "[280705][V][u_adpd6100.cpp:763] preset_config_4(): [ADPD] Preset_config 4 set for timeslot:4. Total 0 bytes\n", - "[280716][V][u_adpd6100.cpp:763] preset_config_4(): [ADPD] Preset_config 4 set for timeslot:5. Total 0 bytes\n", - "[280726][V][u_adpd6100.cpp:763] preset_config_4(): [ADPD] Preset_config 4 set for timeslot:6. Total 0 bytes\n", - "[280736][V][u_adpd6100.cpp:763] preset_config_4(): [ADPD] Preset_config 4 set for timeslot:7. Total 0 bytes\n", - "[280746][V][u_adpd6100.cpp:763] preset_config_4(): [ADPD] Preset_config 4 set for timeslot:8. Total 0 bytes\n", - "[280756][V][PAM.cpp:116] run_preprocess_type1(): [PAM] Run type:1, number:450, freq: 100, actinic: 100, subfactor 2\n", - "[280767][V][PAM.cpp:134] run_arr_type1(): [PAM] Sample & Ref: 450, optionals: 56\n", - "[280774][V][data_utils.cpp:10] dataclass(): [DATA_UTIL] DATACLASS Created\n", - "[280781][V][data_utils.cpp:10] dataclass(): [DATA_UTIL] DATACLASS Created\n", - "[280787][V][data_utils.cpp:10] dataclass(): [DATA_UTIL] DATACLASS Created\n", - "[280794][V][data_utils.cpp:10] dataclass(): [DATA_UTIL] DATACLASS Created\n", - "[280800][V][data_utils.cpp:10] dataclass(): [DATA_UTIL] DATACLASS Created\n", - "[280807][V][data_utils.cpp:10] dataclass(): [DATA_UTIL] DATACLASS Created\n", - "[280814][V][data_utils.cpp:32] init(): [DATA_UTIL] Allocation 1800 bytes\n", - "[280820][V][data_utils.cpp:61] clear(): [DATA_UTIL] ARR reset to 0\n", - "[280826][V][data_utils.cpp:32] init(): [DATA_UTIL] Allocation 1800 bytes\n", - "[280833][V][data_utils.cpp:61] clear(): [DATA_UTIL] ARR reset to 0\n", - "[280839][V][data_utils.cpp:32] init(): [DATA_UTIL] Allocation 224 bytes\n", - "[280845][V][data_utils.cpp:61] clear(): [DATA_UTIL] ARR reset to 0\n", - "[280851][V][data_utils.cpp:32] init(): [DATA_UTIL] Allocation 224 bytes\n", - "[280858][V][data_utils.cpp:61] clear(): [DATA_UTIL] ARR reset to 0\n", - "[280864][V][data_utils.cpp:32] init(): [DATA_UTIL] Allocation 224 bytes\n", - "[280870][V][data_utils.cpp:61] clear(): [DATA_UTIL] ARR reset to 0\n", - "[280876][V][data_utils.cpp:32] init(): [DATA_UTIL] Allocation 224 bytes\n", - "[280883][V][data_utils.cpp:61] clear(): [DATA_UTIL] ARR reset to 0\n", - "[280889][V][PAM.cpp:150] run_arr_type1(): [PAM] Memory allocation completed\n", - "[285177][V][data_utils.cpp:15] ~dataclass(): [DATA_UTIL] DATACLASS destroied\n", - "[285186][V][data_utils.cpp:22] clean(): [DATA_UTIL] Memory freed\n", - "[285191][V][data_utils.cpp:15] ~dataclass(): [DATA_UTIL] DATACLASS destroied\n", - "[285198][V][data_utils.cpp:22] clean(): [DATA_UTIL] Memory freed\n", - "[285204][V][data_utils.cpp:15] ~dataclass(): [DATA_UTIL] DATACLASS destroied\n", - "[285211][V][data_utils.cpp:22] clean(): [DATA_UTIL] Memory freed\n", - "[285217][V][data_utils.cpp:15] ~dataclass(): [DATA_UTIL] DATACLASS destroied\n", - "[285224][V][data_utils.cpp:22] clean(): [DATA_UTIL] Memory freed\n", - "[285229][V][data_utils.cpp:15] ~dataclass(): [DATA_UTIL] DATACLASS destroied\n", - "[285236][V][data_utils.cpp:22] clean(): [DATA_UTIL] Memory freed\n", - "[285242][V][data_utils.cpp:15] ~dataclass(): [DATA_UTIL] DATACLASS destroied\n", - "[285249][V][data_utils.cpp:22] clean(): [DATA_UTIL] Memory freed\n", - "[285255][V][PAM.cpp:298] MPF(): [PAM] RUN MPF with mode:1, pulse current:60, DC current 100\n", - "[285263][V][data_utils.cpp:10] dataclass(): [DATA_UTIL] DATACLASS Created\n", - "[285270][V][data_utils.cpp:10] dataclass(): [DATA_UTIL] DATACLASS Created\n", - "[285276][V][data_utils.cpp:32] init(): [DATA_UTIL] Allocation 4320 bytes\n", - "[285283][V][data_utils.cpp:61] clear(): [DATA_UTIL] ARR reset to 0\n", - "[285289][V][data_utils.cpp:32] init(): [DATA_UTIL] Allocation 4320 bytes\n", - "[285295][V][data_utils.cpp:61] clear(): [DATA_UTIL] ARR reset to 0\n", - "[285301][V][PAM.cpp:303] MPF(): [PAM] Memory allocation completed\n", - "[285308][V][PAM.cpp:359] MPF(): [PAM] Phase-1 Config\n", - "[285312][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 0\n", - "[285321][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 1\n", - "[285330][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 2\n", - "[285338][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 3\n", - "[285347][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 4\n", - "[285356][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 5\n", - "[285364][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 6\n", - "[285373][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 7\n", - "[285382][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 8\n", - "[285390][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 9\n", - "[285399][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 10\n", - "[285408][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 11\n", - "[285421][V][PAM.cpp:369] MPF(): [PAM] Phase-1 LED ON\n", - "[285435][V][PAM.cpp:386] MPF(): [PAM] Phase-1 Completed; Phase-2 start\n", - "[285744][V][PAM.cpp:414] MPF(): [PAM] Phase-2 Completed; Phase-3 Start\n", - "[285751][V][PAM.cpp:421] MPF(): [PAM] LED set to 220\n", - "[285817][V][PAM.cpp:421] MPF(): [PAM] LED set to 190\n", - "[285883][V][PAM.cpp:421] MPF(): [PAM] LED set to 160\n", - "[285950][V][PAM.cpp:421] MPF(): [PAM] LED set to 130\n", - "[286016][V][PAM.cpp:421] MPF(): [PAM] LED set to 100\n", - "[286082][V][PAM.cpp:421] MPF(): [PAM] LED set to 70\n", - "[286148][V][PAM.cpp:421] MPF(): [PAM] LED set to 40\n", - "[286213][V][PAM.cpp:421] MPF(): [PAM] LED set to 10\n", - "[286279][V][PAM.cpp:444] MPF(): [PAM] Phase-3 Completed; Phase-4 Start\n", - "[286286][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 0\n", - "[286595][V][PAM.cpp:484] MPF(): [PAM] Phase-4 Completed\n", - "[286600][V][PAM.cpp:507] MPF(): [PAM] Measurement Completed\n", - "[286923][V][PAM.cpp:526] MPF(): [PAM] All Completed\n", - "[286934][V][data_utils.cpp:15] ~dataclass(): [DATA_UTIL] DATACLASS destroied\n", - "[286941][V][data_utils.cpp:22] clean(): [DATA_UTIL] Memory freed\n", - "[286946][V][data_utils.cpp:15] ~dataclass(): [DATA_UTIL] DATACLASS destroied\n", - "[286953][V][data_utils.cpp:22] clean(): [DATA_UTIL] Memory freed\n", - "[286959][V][u_adpd6100.cpp:618] preset_config_1(): [ADPD] Preset_config 1 set for timeslot:0. Two ambient channels. Total 2 x 3 bytes\n", - "[286972][V][u_adpd6100.cpp:666] preset_config_2(): [ADPD] Preset_config 2 set for timeslot:1. Total 2 x 2 x 3 bytes\n", - "[286983][V][u_adpd6100.cpp:714] preset_config_3(): [ADPD] Preset_config 3 set for timeslot:2. Total 2 x 3 bytes\n", - "[286993][V][u_adpd6100.cpp:763] preset_config_4(): [ADPD] Preset_config 4 set for timeslot:3. Total 0 bytes\n", - "[287003][V][u_adpd6100.cpp:763] preset_config_4(): [ADPD] Preset_config 4 set for timeslot:4. Total 0 bytes\n", - "[287014][V][u_adpd6100.cpp:763] preset_config_4(): [ADPD] Preset_config 4 set for timeslot:5. Total 0 bytes\n", - "[287024][V][u_adpd6100.cpp:763] preset_config_4(): [ADPD] Preset_config 4 set for timeslot:6. Total 0 bytes\n", - "[287034][V][u_adpd6100.cpp:763] preset_config_4(): [ADPD] Preset_config 4 set for timeslot:7. Total 0 bytes\n", - "[287044][V][u_adpd6100.cpp:763] preset_config_4(): [ADPD] Preset_config 4 set for timeslot:8. Total 0 bytes\n", - "[287054][V][PAM.cpp:116] run_preprocess_type1(): [PAM] Run type:1, number:450, freq: 100, actinic: 100, subfactor 2\n", - "[287065][V][PAM.cpp:134] run_arr_type1(): [PAM] Sample & Ref: 450, optionals: 56\n", - "[287072][V][data_utils.cpp:10] dataclass(): [DATA_UTIL] DATACLASS Created\n", - "[287079][V][data_utils.cpp:10] dataclass(): [DATA_UTIL] DATACLASS Created\n", - "[287085][V][data_utils.cpp:10] dataclass(): [DATA_UTIL] DATACLASS Created\n", - "[287092][V][data_utils.cpp:10] dataclass(): [DATA_UTIL] DATACLASS Created\n", - "[287098][V][data_utils.cpp:10] dataclass(): [DATA_UTIL] DATACLASS Created\n", - "[287105][V][data_utils.cpp:10] dataclass(): [DATA_UTIL] DATACLASS Created\n", - "[287112][V][data_utils.cpp:32] init(): [DATA_UTIL] Allocation 1800 bytes\n", - "[287118][V][data_utils.cpp:61] clear(): [DATA_UTIL] ARR reset to 0\n", - "[287124][V][data_utils.cpp:32] init(): [DATA_UTIL] Allocation 1800 bytes\n", - "[287131][V][data_utils.cpp:61] clear(): [DATA_UTIL] ARR reset to 0\n", - "[287137][V][data_utils.cpp:32] init(): [DATA_UTIL] Allocation 224 bytes\n", - "[287143][V][data_utils.cpp:61] clear(): [DATA_UTIL] ARR reset to 0\n", - "[287149][V][data_utils.cpp:32] init(): [DATA_UTIL] Allocation 224 bytes\n", - "[287156][V][data_utils.cpp:61] clear(): [DATA_UTIL] ARR reset to 0\n", - "[287162][V][data_utils.cpp:32] init(): [DATA_UTIL] Allocation 224 bytes\n", - "[287168][V][data_utils.cpp:61] clear(): [DATA_UTIL] ARR reset to 0\n", - "[287174][V][data_utils.cpp:32] init(): [DATA_UTIL] Allocation 224 bytes\n", - "[287181][V][data_utils.cpp:61] clear(): [DATA_UTIL] ARR reset to 0\n", - "[287187][V][PAM.cpp:150] run_arr_type1(): [PAM] Memory allocation completed\n", - "[291475][V][data_utils.cpp:15] ~dataclass(): [DATA_UTIL] DATACLASS destroied\n", - "[291484][V][data_utils.cpp:22] clean(): [DATA_UTIL] Memory freed\n", - "[291489][V][data_utils.cpp:15] ~dataclass(): [DATA_UTIL] DATACLASS destroied\n", - "[291496][V][data_utils.cpp:22] clean(): [DATA_UTIL] Memory freed\n", - "[291502][V][data_utils.cpp:15] ~dataclass(): [DATA_UTIL] DATACLASS destroied\n", - "[291509][V][data_utils.cpp:22] clean(): [DATA_UTIL] Memory freed\n", - "[291515][V][data_utils.cpp:15] ~dataclass(): [DATA_UTIL] DATACLASS destroied\n", - "[291522][V][data_utils.cpp:22] clean(): [DATA_UTIL] Memory freed\n", - "[291527][V][data_utils.cpp:15] ~dataclass(): [DATA_UTIL] DATACLASS destroied\n", - "[291534][V][data_utils.cpp:22] clean(): [DATA_UTIL] Memory freed\n", - "[291540][V][data_utils.cpp:15] ~dataclass(): [DATA_UTIL] DATACLASS destroied\n", - "[291547][V][data_utils.cpp:22] clean(): [DATA_UTIL] Memory freed\n", - "[291553][V][PAM.cpp:298] MPF(): [PAM] RUN MPF with mode:1, pulse current:60, DC current 100\n", - "[291561][V][data_utils.cpp:10] dataclass(): [DATA_UTIL] DATACLASS Created\n", - "[291568][V][data_utils.cpp:10] dataclass(): [DATA_UTIL] DATACLASS Created\n", - "[291574][V][data_utils.cpp:32] init(): [DATA_UTIL] Allocation 4320 bytes\n", - "[291581][V][data_utils.cpp:61] clear(): [DATA_UTIL] ARR reset to 0\n", - "[291587][V][data_utils.cpp:32] init(): [DATA_UTIL] Allocation 4320 bytes\n", - "[291593][V][data_utils.cpp:61] clear(): [DATA_UTIL] ARR reset to 0\n", - "[291599][V][PAM.cpp:303] MPF(): [PAM] Memory allocation completed\n", - "[291606][V][PAM.cpp:359] MPF(): [PAM] Phase-1 Config\n", - "[291610][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 0\n", - "[291619][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 1\n", - "[291628][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 2\n", - "[291636][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 3\n", - "[291645][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 4\n", - "[291654][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 5\n", - "[291662][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 6\n", - "[291671][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 7\n", - "[291680][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 8\n", - "[291688][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 9\n", - "[291697][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 10\n", - "[291706][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 11\n", - "[291719][V][PAM.cpp:369] MPF(): [PAM] Phase-1 LED ON\n", - "[291733][V][PAM.cpp:386] MPF(): [PAM] Phase-1 Completed; Phase-2 start\n", - "[292042][V][PAM.cpp:414] MPF(): [PAM] Phase-2 Completed; Phase-3 Start\n", - "[292049][V][PAM.cpp:421] MPF(): [PAM] LED set to 220\n", - "[292115][V][PAM.cpp:421] MPF(): [PAM] LED set to 190\n", - "[292181][V][PAM.cpp:421] MPF(): [PAM] LED set to 160\n", - "[292248][V][PAM.cpp:421] MPF(): [PAM] LED set to 130\n", - "[292314][V][PAM.cpp:421] MPF(): [PAM] LED set to 100\n", - "[292380][V][PAM.cpp:421] MPF(): [PAM] LED set to 70\n", - "[292445][V][PAM.cpp:421] MPF(): [PAM] LED set to 40\n", - "[292511][V][PAM.cpp:421] MPF(): [PAM] LED set to 10\n", - "[292577][V][PAM.cpp:444] MPF(): [PAM] Phase-3 Completed; Phase-4 Start\n", - "[292584][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 0\n", - "[292893][V][PAM.cpp:484] MPF(): [PAM] Phase-4 Completed\n", - "[292898][V][PAM.cpp:507] MPF(): [PAM] Measurement Completed\n", - "[293221][V][PAM.cpp:526] MPF(): [PAM] All Completed\n", - "[293232][V][data_utils.cpp:15] ~dataclass(): [DATA_UTIL] DATACLASS destroied\n", - "[293239][V][data_utils.cpp:22] clean(): [DATA_UTIL] Memory freed\n", - "[293244][V][data_utils.cpp:15] ~dataclass(): [DATA_UTIL] DATACLASS destroied\n", - "[293251][V][data_utils.cpp:22] clean(): [DATA_UTIL] Memory freed\n", - "[293257][V][u_adpd6100.cpp:618] preset_config_1(): [ADPD] Preset_config 1 set for timeslot:0. Two ambient channels. Total 2 x 3 bytes\n", - "[293270][V][u_adpd6100.cpp:666] preset_config_2(): [ADPD] Preset_config 2 set for timeslot:1. Total 2 x 2 x 3 bytes\n", - "[293281][V][u_adpd6100.cpp:714] preset_config_3(): [ADPD] Preset_config 3 set for timeslot:2. Total 2 x 3 bytes\n", - "[293291][V][u_adpd6100.cpp:763] preset_config_4(): [ADPD] Preset_config 4 set for timeslot:3. Total 0 bytes\n", - "[293301][V][u_adpd6100.cpp:763] preset_config_4(): [ADPD] Preset_config 4 set for timeslot:4. Total 0 bytes\n", - "[293312][V][u_adpd6100.cpp:763] preset_config_4(): [ADPD] Preset_config 4 set for timeslot:5. Total 0 bytes\n", - "[293322][V][u_adpd6100.cpp:763] preset_config_4(): [ADPD] Preset_config 4 set for timeslot:6. Total 0 bytes\n", - "[293332][V][u_adpd6100.cpp:763] preset_config_4(): [ADPD] Preset_config 4 set for timeslot:7. Total 0 bytes\n", - "[293342][V][u_adpd6100.cpp:763] preset_config_4(): [ADPD] Preset_config 4 set for timeslot:8. Total 0 bytes\n", - "[293352][V][PAM.cpp:116] run_preprocess_type1(): [PAM] Run type:1, number:50, freq: 10, actinic: 100, subfactor 2\n", - "[293363][V][PAM.cpp:116] run_preprocess_type1(): [PAM] Run type:1, number:450, freq: 100, actinic: 0, subfactor 2\n", - "[293373][V][PAM.cpp:134] run_arr_type1(): [PAM] Sample & Ref: 500, optionals: 62\n", - "[293380][V][data_utils.cpp:10] dataclass(): [DATA_UTIL] DATACLASS Created\n", - "[293387][V][data_utils.cpp:10] dataclass(): [DATA_UTIL] DATACLASS Created\n", - "[293393][V][data_utils.cpp:10] dataclass(): [DATA_UTIL] DATACLASS Created\n", - "[293400][V][data_utils.cpp:10] dataclass(): [DATA_UTIL] DATACLASS Created\n", - "[293406][V][data_utils.cpp:10] dataclass(): [DATA_UTIL] DATACLASS Created\n", - "[293413][V][data_utils.cpp:10] dataclass(): [DATA_UTIL] DATACLASS Created\n", - "[293420][V][data_utils.cpp:32] init(): [DATA_UTIL] Allocation 2000 bytes\n", - "[293426][V][data_utils.cpp:61] clear(): [DATA_UTIL] ARR reset to 0\n", - "[293432][V][data_utils.cpp:32] init(): [DATA_UTIL] Allocation 2000 bytes\n", - "[293439][V][data_utils.cpp:61] clear(): [DATA_UTIL] ARR reset to 0\n", - "[293445][V][data_utils.cpp:32] init(): [DATA_UTIL] Allocation 248 bytes\n", - "[293451][V][data_utils.cpp:61] clear(): [DATA_UTIL] ARR reset to 0\n", - "[293457][V][data_utils.cpp:32] init(): [DATA_UTIL] Allocation 248 bytes\n", - "[293464][V][data_utils.cpp:61] clear(): [DATA_UTIL] ARR reset to 0\n", - "[293470][V][data_utils.cpp:32] init(): [DATA_UTIL] Allocation 248 bytes\n", - "[293476][V][data_utils.cpp:61] clear(): [DATA_UTIL] ARR reset to 0\n", - "[293482][V][data_utils.cpp:32] init(): [DATA_UTIL] Allocation 248 bytes\n", - "[293488][V][data_utils.cpp:61] clear(): [DATA_UTIL] ARR reset to 0\n", - "[293494][V][PAM.cpp:150] run_arr_type1(): [PAM] Memory allocation completed\n", - "[302035][V][data_utils.cpp:15] ~dataclass(): [DATA_UTIL] DATACLASS destroied\n", - "[302045][V][data_utils.cpp:22] clean(): [DATA_UTIL] Memory freed\n", - "[302051][V][data_utils.cpp:15] ~dataclass(): [DATA_UTIL] DATACLASS destroied\n", - "[302058][V][data_utils.cpp:22] clean(): [DATA_UTIL] Memory freed\n", - "[302064][V][data_utils.cpp:15] ~dataclass(): [DATA_UTIL] DATACLASS destroied\n", - "[302071][V][data_utils.cpp:22] clean(): [DATA_UTIL] Memory freed\n", - "[302076][V][data_utils.cpp:15] ~dataclass(): [DATA_UTIL] DATACLASS destroied\n", - "[302083][V][data_utils.cpp:22] clean(): [DATA_UTIL] Memory freed\n", - "[302089][V][data_utils.cpp:15] ~dataclass(): [DATA_UTIL] DATACLASS destroied\n", - "[302096][V][data_utils.cpp:22] clean(): [DATA_UTIL] Memory freed\n", - "[302102][V][data_utils.cpp:15] ~dataclass(): [DATA_UTIL] DATACLASS destroied\n", - "[302109][V][data_utils.cpp:22] clean(): [DATA_UTIL] Memory freed\n", - "[302115][V][PAM.cpp:298] MPF(): [PAM] RUN MPF with mode:1, pulse current:60, DC current 0\n", - "[302123][V][data_utils.cpp:10] dataclass(): [DATA_UTIL] DATACLASS Created\n", - "[302129][V][data_utils.cpp:10] dataclass(): [DATA_UTIL] DATACLASS Created\n", - "[302136][V][data_utils.cpp:32] init(): [DATA_UTIL] Allocation 4320 bytes\n", - "[302142][V][data_utils.cpp:61] clear(): [DATA_UTIL] ARR reset to 0\n", - "[302148][V][data_utils.cpp:32] init(): [DATA_UTIL] Allocation 4320 bytes\n", - "[302155][V][data_utils.cpp:61] clear(): [DATA_UTIL] ARR reset to 0\n", - "[302161][V][PAM.cpp:303] MPF(): [PAM] Memory allocation completed\n", - "[302167][V][PAM.cpp:359] MPF(): [PAM] Phase-1 Config\n", - "[302172][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 0\n", - "[302181][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 1\n", - "[302189][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 2\n", - "[302198][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 3\n", - "[302207][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 4\n", - "[302215][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 5\n", - "[302224][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 6\n", - "[302233][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 7\n", - "[302241][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 8\n", - "[302250][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 9\n", - "[302259][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 10\n", - "[302267][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 11\n", - "[302281][V][PAM.cpp:369] MPF(): [PAM] Phase-1 LED ON\n", - "[302295][V][PAM.cpp:386] MPF(): [PAM] Phase-1 Completed; Phase-2 start\n", - "[302604][V][PAM.cpp:414] MPF(): [PAM] Phase-2 Completed; Phase-3 Start\n", - "[302611][V][PAM.cpp:421] MPF(): [PAM] LED set to 220\n", - "[302677][V][PAM.cpp:421] MPF(): [PAM] LED set to 190\n", - "[302743][V][PAM.cpp:421] MPF(): [PAM] LED set to 160\n", - "[302810][V][PAM.cpp:421] MPF(): [PAM] LED set to 130\n", - "[302876][V][PAM.cpp:421] MPF(): [PAM] LED set to 100\n", - "[302942][V][PAM.cpp:421] MPF(): [PAM] LED set to 70\n", - "[303008][V][PAM.cpp:421] MPF(): [PAM] LED set to 40\n", - "[303073][V][PAM.cpp:421] MPF(): [PAM] LED set to 10\n", - "[303139][V][PAM.cpp:444] MPF(): [PAM] Phase-3 Completed; Phase-4 Start\n", - "[303146][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 0\n", - "[303456][V][PAM.cpp:484] MPF(): [PAM] Phase-4 Completed\n", - "[303462][V][PAM.cpp:507] MPF(): [PAM] Measurement Completed\n", - "[303784][V][PAM.cpp:526] MPF(): [PAM] All Completed\n", - "[303795][V][data_utils.cpp:15] ~dataclass(): [DATA_UTIL] DATACLASS destroied\n", - "[303802][V][data_utils.cpp:22] clean(): [DATA_UTIL] Memory freed\n", - "[303808][V][data_utils.cpp:15] ~dataclass(): [DATA_UTIL] DATACLASS destroied\n", - "[303814][V][data_utils.cpp:22] clean(): [DATA_UTIL] Memory freed\n", - "[303820][V][do_c.cpp:47] arr_set(): [DO_C] Set arr3, line 0 to type 1 with 50 x 5Hz samples, actinic:0, sub:2, IR:0\n", - "[303831][V][u_adpd6100.cpp:618] preset_config_1(): [ADPD] Preset_config 1 set for timeslot:0. Two ambient channels. Total 2 x 3 bytes\n", - "[303843][V][u_adpd6100.cpp:666] preset_config_2(): [ADPD] Preset_config 2 set for timeslot:1. Total 2 x 2 x 3 bytes\n", - "[303854][V][u_adpd6100.cpp:714] preset_config_3(): [ADPD] Preset_config 3 set for timeslot:2. Total 2 x 3 bytes\n", - "[303865][V][u_adpd6100.cpp:763] preset_config_4(): [ADPD] Preset_config 4 set for timeslot:3. Total 0 bytes\n", - "[303875][V][u_adpd6100.cpp:763] preset_config_4(): [ADPD] Preset_config 4 set for timeslot:4. Total 0 bytes\n", - "[303885][V][u_adpd6100.cpp:763] preset_config_4(): [ADPD] Preset_config 4 set for timeslot:5. Total 0 bytes\n", - "[303895][V][u_adpd6100.cpp:763] preset_config_4(): [ADPD] Preset_config 4 set for timeslot:6. Total 0 bytes\n", - "[303906][V][u_adpd6100.cpp:763] preset_config_4(): [ADPD] Preset_config 4 set for timeslot:7. Total 0 bytes\n", - "[303916][V][u_adpd6100.cpp:763] preset_config_4(): [ADPD] Preset_config 4 set for timeslot:8. Total 0 bytes\n", - "[303926][V][PAM.cpp:116] run_preprocess_type1(): [PAM] Run type:1, number:50, freq: 5, actinic: 0, subfactor 2\n", - "[303936][V][PAM.cpp:134] run_arr_type1(): [PAM] Sample & Ref: 50, optionals: 6\n", - "[303943][V][data_utils.cpp:10] dataclass(): [DATA_UTIL] DATACLASS Created\n", - "[303950][V][data_utils.cpp:10] dataclass(): [DATA_UTIL] DATACLASS Created\n", - "[303956][V][data_utils.cpp:10] dataclass(): [DATA_UTIL] DATACLASS Created\n", - "[303963][V][data_utils.cpp:10] dataclass(): [DATA_UTIL] DATACLASS Created\n", - "[303969][V][data_utils.cpp:10] dataclass(): [DATA_UTIL] DATACLASS Created\n", - "[303976][V][data_utils.cpp:10] dataclass(): [DATA_UTIL] DATACLASS Created\n", - "[303983][V][data_utils.cpp:32] init(): [DATA_UTIL] Allocation 200 bytes\n", - "[303989][V][data_utils.cpp:61] clear(): [DATA_UTIL] ARR reset to 0\n", - "[303995][V][data_utils.cpp:32] init(): [DATA_UTIL] Allocation 200 bytes\n", - "[304001][V][data_utils.cpp:61] clear(): [DATA_UTIL] ARR reset to 0\n", - "[304007][V][data_utils.cpp:32] init(): [DATA_UTIL] Allocation 24 bytes\n", - "[304014][V][data_utils.cpp:61] clear(): [DATA_UTIL] ARR reset to 0\n", - "[304020][V][data_utils.cpp:32] init(): [DATA_UTIL] Allocation 24 bytes\n", - "[304026][V][data_utils.cpp:61] clear(): [DATA_UTIL] ARR reset to 0\n", - "[304032][V][data_utils.cpp:32] init(): [DATA_UTIL] Allocation 24 bytes\n", - "[304038][V][data_utils.cpp:61] clear(): [DATA_UTIL] ARR reset to 0\n", - "[304044][V][data_utils.cpp:32] init(): [DATA_UTIL] Allocation 24 bytes\n", - "[304051][V][data_utils.cpp:61] clear(): [DATA_UTIL] ARR reset to 0\n", - "[304057][V][PAM.cpp:150] run_arr_type1(): [PAM] Memory allocation completed\n", - "[312530][V][data_utils.cpp:15] ~dataclass(): [DATA_UTIL] DATACLASS destroied\n", - "[312540][V][data_utils.cpp:22] clean(): [DATA_UTIL] Memory freed\n", - "[312546][V][data_utils.cpp:15] ~dataclass(): [DATA_UTIL] DATACLASS destroied\n", - "[312553][V][data_utils.cpp:22] clean(): [DATA_UTIL] Memory freed\n", - "[312559][V][data_utils.cpp:15] ~dataclass(): [DATA_UTIL] DATACLASS destroied\n", - "[312566][V][data_utils.cpp:22] clean(): [DATA_UTIL] Memory freed\n", - "[312571][V][data_utils.cpp:15] ~dataclass(): [DATA_UTIL] DATACLASS destroied\n", - "[312578][V][data_utils.cpp:22] clean(): [DATA_UTIL] Memory freed\n", - "[312584][V][data_utils.cpp:15] ~dataclass(): [DATA_UTIL] DATACLASS destroied\n", - "[312591][V][data_utils.cpp:22] clean(): [DATA_UTIL] Memory freed\n", - "[312597][V][data_utils.cpp:15] ~dataclass(): [DATA_UTIL] DATACLASS destroied\n", - "[312604][V][data_utils.cpp:22] clean(): [DATA_UTIL] Memory freed\n", - "[312609][V][PAM.cpp:298] MPF(): [PAM] RUN MPF with mode:1, pulse current:60, DC current 0\n", - "[312617][V][data_utils.cpp:10] dataclass(): [DATA_UTIL] DATACLASS Created\n", - "[312624][V][data_utils.cpp:10] dataclass(): [DATA_UTIL] DATACLASS Created\n", - "[312631][V][data_utils.cpp:32] init(): [DATA_UTIL] Allocation 4320 bytes\n", - "[312637][V][data_utils.cpp:61] clear(): [DATA_UTIL] ARR reset to 0\n", - "[312643][V][data_utils.cpp:32] init(): [DATA_UTIL] Allocation 4320 bytes\n", - "[312650][V][data_utils.cpp:61] clear(): [DATA_UTIL] ARR reset to 0\n", - "[312656][V][PAM.cpp:303] MPF(): [PAM] Memory allocation completed\n", - "[312662][V][PAM.cpp:359] MPF(): [PAM] Phase-1 Config\n", - "[312667][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 0\n", - "[312676][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 1\n", - "[312684][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 2\n", - "[312693][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 3\n", - "[312702][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 4\n", - "[312710][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 5\n", - "[312719][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 6\n", - "[312728][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 7\n", - "[312736][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 8\n", - "[312745][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 9\n", - "[312754][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 10\n", - "[312762][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 11\n", - "[312776][V][PAM.cpp:369] MPF(): [PAM] Phase-1 LED ON\n", - "[312790][V][PAM.cpp:386] MPF(): [PAM] Phase-1 Completed; Phase-2 start\n", - "[313099][V][PAM.cpp:414] MPF(): [PAM] Phase-2 Completed; Phase-3 Start\n", - "[313106][V][PAM.cpp:421] MPF(): [PAM] LED set to 220\n", - "[313172][V][PAM.cpp:421] MPF(): [PAM] LED set to 190\n", - "[313238][V][PAM.cpp:421] MPF(): [PAM] LED set to 160\n", - "[313304][V][PAM.cpp:421] MPF(): [PAM] LED set to 130\n", - "[313371][V][PAM.cpp:421] MPF(): [PAM] LED set to 100\n", - "[313437][V][PAM.cpp:421] MPF(): [PAM] LED set to 70\n", - "[313503][V][PAM.cpp:421] MPF(): [PAM] LED set to 40\n", - "[313568][V][PAM.cpp:421] MPF(): [PAM] LED set to 10\n", - "[313634][V][PAM.cpp:444] MPF(): [PAM] Phase-3 Completed; Phase-4 Start\n", - "[313641][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 0\n", - "[313951][V][PAM.cpp:484] MPF(): [PAM] Phase-4 Completed\n", - "[313956][V][PAM.cpp:507] MPF(): [PAM] Measurement Completed\n", - "[314279][V][PAM.cpp:526] MPF(): [PAM] All Completed\n", - "[314290][V][data_utils.cpp:15] ~dataclass(): [DATA_UTIL] DATACLASS destroied\n", - "[314297][V][data_utils.cpp:22] clean(): [DATA_UTIL] Memory freed\n", - "[314303][V][data_utils.cpp:15] ~dataclass(): [DATA_UTIL] DATACLASS destroied\n", - "[314310][V][data_utils.cpp:22] clean(): [DATA_UTIL] Memory freed\n", - "[314315][V][do_c.cpp:47] arr_set(): [DO_C] Set arr3, line 0 to type 1 with 60 x 5Hz samples, actinic:0, sub:2, IR:0\n", - "[314326][V][u_adpd6100.cpp:618] preset_config_1(): [ADPD] Preset_config 1 set for timeslot:0. Two ambient channels. Total 2 x 3 bytes\n", - "[314338][V][u_adpd6100.cpp:666] preset_config_2(): [ADPD] Preset_config 2 set for timeslot:1. Total 2 x 2 x 3 bytes\n", - "[314349][V][u_adpd6100.cpp:714] preset_config_3(): [ADPD] Preset_config 3 set for timeslot:2. Total 2 x 3 bytes\n", - "[314360][V][u_adpd6100.cpp:763] preset_config_4(): [ADPD] Preset_config 4 set for timeslot:3. Total 0 bytes\n", - "[314370][V][u_adpd6100.cpp:763] preset_config_4(): [ADPD] Preset_config 4 set for timeslot:4. Total 0 bytes\n", - "[314380][V][u_adpd6100.cpp:763] preset_config_4(): [ADPD] Preset_config 4 set for timeslot:5. Total 0 bytes\n", - "[314391][V][u_adpd6100.cpp:763] preset_config_4(): [ADPD] Preset_config 4 set for timeslot:6. Total 0 bytes\n", - "[314401][V][u_adpd6100.cpp:763] preset_config_4(): [ADPD] Preset_config 4 set for timeslot:7. Total 0 bytes\n", - "[314411][V][u_adpd6100.cpp:763] preset_config_4(): [ADPD] Preset_config 4 set for timeslot:8. Total 0 bytes\n", - "[314421][V][PAM.cpp:116] run_preprocess_type1(): [PAM] Run type:1, number:60, freq: 5, actinic: 0, subfactor 2\n", - "[314431][V][PAM.cpp:134] run_arr_type1(): [PAM] Sample & Ref: 60, optionals: 7\n", - "[314438][V][data_utils.cpp:10] dataclass(): [DATA_UTIL] DATACLASS Created\n", - "[314445][V][data_utils.cpp:10] dataclass(): [DATA_UTIL] DATACLASS Created\n", - "[314451][V][data_utils.cpp:10] dataclass(): [DATA_UTIL] DATACLASS Created\n", - "[314458][V][data_utils.cpp:10] dataclass(): [DATA_UTIL] DATACLASS Created\n", - "[314465][V][data_utils.cpp:10] dataclass(): [DATA_UTIL] DATACLASS Created\n", - "[314471][V][data_utils.cpp:10] dataclass(): [DATA_UTIL] DATACLASS Created\n", - "[314478][V][data_utils.cpp:32] init(): [DATA_UTIL] Allocation 240 bytes\n", - "[314484][V][data_utils.cpp:61] clear(): [DATA_UTIL] ARR reset to 0\n", - "[314490][V][data_utils.cpp:32] init(): [DATA_UTIL] Allocation 240 bytes\n", - "[314497][V][data_utils.cpp:61] clear(): [DATA_UTIL] ARR reset to 0\n", - "[314503][V][data_utils.cpp:32] init(): [DATA_UTIL] Allocation 28 bytes\n", - "[314509][V][data_utils.cpp:61] clear(): [DATA_UTIL] ARR reset to 0\n", - "[314515][V][data_utils.cpp:32] init(): [DATA_UTIL] Allocation 28 bytes\n", - "[314521][V][data_utils.cpp:61] clear(): [DATA_UTIL] ARR reset to 0\n", - "[314527][V][data_utils.cpp:32] init(): [DATA_UTIL] Allocation 28 bytes\n", - "[314534][V][data_utils.cpp:61] clear(): [DATA_UTIL] ARR reset to 0\n", - "[314540][V][data_utils.cpp:32] init(): [DATA_UTIL] Allocation 28 bytes\n", - "[314546][V][data_utils.cpp:61] clear(): [DATA_UTIL] ARR reset to 0\n", - "[314552][V][PAM.cpp:150] run_arr_type1(): [PAM] Memory allocation completed\n", - "[324752][V][data_utils.cpp:15] ~dataclass(): [DATA_UTIL] DATACLASS destroied\n", - "[324760][V][data_utils.cpp:22] clean(): [DATA_UTIL] Memory freed\n", - "[324766][V][data_utils.cpp:15] ~dataclass(): [DATA_UTIL] DATACLASS destroied\n", - "[324773][V][data_utils.cpp:22] clean(): [DATA_UTIL] Memory freed\n", - "[324778][V][data_utils.cpp:15] ~dataclass(): [DATA_UTIL] DATACLASS destroied\n", - "[324785][V][data_utils.cpp:22] clean(): [DATA_UTIL] Memory freed\n", - "[324791][V][data_utils.cpp:15] ~dataclass(): [DATA_UTIL] DATACLASS destroied\n", - "[324798][V][data_utils.cpp:22] clean(): [DATA_UTIL] Memory freed\n", - "[324804][V][data_utils.cpp:15] ~dataclass(): [DATA_UTIL] DATACLASS destroied\n", - "[324811][V][data_utils.cpp:22] clean(): [DATA_UTIL] Memory freed\n", - "[324817][V][data_utils.cpp:15] ~dataclass(): [DATA_UTIL] DATACLASS destroied\n", - "[324823][V][data_utils.cpp:22] clean(): [DATA_UTIL] Memory freed\n", - "[324829][V][PAM.cpp:298] MPF(): [PAM] RUN MPF with mode:1, pulse current:60, DC current 0\n", - "[324837][V][data_utils.cpp:10] dataclass(): [DATA_UTIL] DATACLASS Created\n", - "[324844][V][data_utils.cpp:10] dataclass(): [DATA_UTIL] DATACLASS Created\n", - "[324850][V][data_utils.cpp:32] init(): [DATA_UTIL] Allocation 4320 bytes\n", - "[324857][V][data_utils.cpp:61] clear(): [DATA_UTIL] ARR reset to 0\n", - "[324863][V][data_utils.cpp:32] init(): [DATA_UTIL] Allocation 4320 bytes\n", - "[324870][V][data_utils.cpp:61] clear(): [DATA_UTIL] ARR reset to 0\n", - "[324876][V][PAM.cpp:303] MPF(): [PAM] Memory allocation completed\n", - "[324882][V][PAM.cpp:359] MPF(): [PAM] Phase-1 Config\n", - "[324887][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 0\n", - "[324895][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 1\n", - "[324904][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 2\n", - "[324913][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 3\n", - "[324921][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 4\n", - "[324930][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 5\n", - "[324939][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 6\n", - "[324947][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 7\n", - "[324956][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 8\n", - "[324965][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 9\n", - "[324973][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 10\n", - "[324982][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 11\n", - "[324996][V][PAM.cpp:369] MPF(): [PAM] Phase-1 LED ON\n", - "[325010][V][PAM.cpp:386] MPF(): [PAM] Phase-1 Completed; Phase-2 start\n", - "[325319][V][PAM.cpp:414] MPF(): [PAM] Phase-2 Completed; Phase-3 Start\n", - "[325326][V][PAM.cpp:421] MPF(): [PAM] LED set to 220\n", - "[325392][V][PAM.cpp:421] MPF(): [PAM] LED set to 190\n", - "[325459][V][PAM.cpp:421] MPF(): [PAM] LED set to 160\n", - "[325525][V][PAM.cpp:421] MPF(): [PAM] LED set to 130\n", - "[325591][V][PAM.cpp:421] MPF(): [PAM] LED set to 100\n", - "[325657][V][PAM.cpp:421] MPF(): [PAM] LED set to 70\n", - "[325723][V][PAM.cpp:421] MPF(): [PAM] LED set to 40\n", - "[325788][V][PAM.cpp:421] MPF(): [PAM] LED set to 10\n", - "[325854][V][PAM.cpp:444] MPF(): [PAM] Phase-3 Completed; Phase-4 Start\n", - "[325861][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 0\n", - "[326171][V][PAM.cpp:484] MPF(): [PAM] Phase-4 Completed\n", - "[326176][V][PAM.cpp:507] MPF(): [PAM] Measurement Completed\n", - "[326499][V][PAM.cpp:526] MPF(): [PAM] All Completed\n", - "[326510][V][data_utils.cpp:15] ~dataclass(): [DATA_UTIL] DATACLASS destroied\n", - "[326517][V][data_utils.cpp:22] clean(): [DATA_UTIL] Memory freed\n", - "[326522][V][data_utils.cpp:15] ~dataclass(): [DATA_UTIL] DATACLASS destroied\n", - "[326529][V][data_utils.cpp:22] clean(): [DATA_UTIL] Memory freed\n", - "[326535][V][do_c.cpp:47] arr_set(): [DO_C] Set arr3, line 0 to type 1 with 70 x 5Hz samples, actinic:0, sub:2, IR:0\n", - "[326545][V][u_adpd6100.cpp:618] preset_config_1(): [ADPD] Preset_config 1 set for timeslot:0. Two ambient channels. Total 2 x 3 bytes\n", - "[326558][V][u_adpd6100.cpp:666] preset_config_2(): [ADPD] Preset_config 2 set for timeslot:1. Total 2 x 2 x 3 bytes\n", - "[326569][V][u_adpd6100.cpp:714] preset_config_3(): [ADPD] Preset_config 3 set for timeslot:2. Total 2 x 3 bytes\n", - "[326580][V][u_adpd6100.cpp:763] preset_config_4(): [ADPD] Preset_config 4 set for timeslot:3. Total 0 bytes\n", - "[326590][V][u_adpd6100.cpp:763] preset_config_4(): [ADPD] Preset_config 4 set for timeslot:4. Total 0 bytes\n", - "[326600][V][u_adpd6100.cpp:763] preset_config_4(): [ADPD] Preset_config 4 set for timeslot:5. Total 0 bytes\n", - "[326610][V][u_adpd6100.cpp:763] preset_config_4(): [ADPD] Preset_config 4 set for timeslot:6. Total 0 bytes\n", - "[326620][V][u_adpd6100.cpp:763] preset_config_4(): [ADPD] Preset_config 4 set for timeslot:7. Total 0 bytes\n", - "[326631][V][u_adpd6100.cpp:763] preset_config_4(): [ADPD] Preset_config 4 set for timeslot:8. Total 0 bytes\n", - "[326641][V][PAM.cpp:116] run_preprocess_type1(): [PAM] Run type:1, number:70, freq: 5, actinic: 0, subfactor 2\n", - "[326651][V][PAM.cpp:134] run_arr_type1(): [PAM] Sample & Ref: 70, optionals: 8\n", - "[326658][V][data_utils.cpp:10] dataclass(): [DATA_UTIL] DATACLASS Created\n", - "[326664][V][data_utils.cpp:10] dataclass(): [DATA_UTIL] DATACLASS Created\n", - "[326671][V][data_utils.cpp:10] dataclass(): [DATA_UTIL] DATACLASS Created\n", - "[326678][V][data_utils.cpp:10] dataclass(): [DATA_UTIL] DATACLASS Created\n", - "[326684][V][data_utils.cpp:10] dataclass(): [DATA_UTIL] DATACLASS Created\n", - "[326691][V][data_utils.cpp:10] dataclass(): [DATA_UTIL] DATACLASS Created\n", - "[326697][V][data_utils.cpp:32] init(): [DATA_UTIL] Allocation 280 bytes\n", - "[326704][V][data_utils.cpp:61] clear(): [DATA_UTIL] ARR reset to 0\n", - "[326710][V][data_utils.cpp:32] init(): [DATA_UTIL] Allocation 280 bytes\n", - "[326716][V][data_utils.cpp:61] clear(): [DATA_UTIL] ARR reset to 0\n", - "[326722][V][data_utils.cpp:32] init(): [DATA_UTIL] Allocation 32 bytes\n", - "[326729][V][data_utils.cpp:61] clear(): [DATA_UTIL] ARR reset to 0\n", - "[326735][V][data_utils.cpp:32] init(): [DATA_UTIL] Allocation 32 bytes\n", - "[326741][V][data_utils.cpp:61] clear(): [DATA_UTIL] ARR reset to 0\n", - "[326747][V][data_utils.cpp:32] init(): [DATA_UTIL] Allocation 32 bytes\n", - "[326753][V][data_utils.cpp:61] clear(): [DATA_UTIL] ARR reset to 0\n", - "[326759][V][data_utils.cpp:32] init(): [DATA_UTIL] Allocation 32 bytes\n", - "[326766][V][data_utils.cpp:61] clear(): [DATA_UTIL] ARR reset to 0\n", - "[326772][V][PAM.cpp:150] run_arr_type1(): [PAM] Memory allocation completed\n", - "[338688][V][data_utils.cpp:15] ~dataclass(): [DATA_UTIL] DATACLASS destroied\n", - "[338704][V][data_utils.cpp:22] clean(): [DATA_UTIL] Memory freed\n", - "[338710][V][data_utils.cpp:15] ~dataclass(): [DATA_UTIL] DATACLASS destroied\n", - "[338716][V][data_utils.cpp:22] clean(): [DATA_UTIL] Memory freed\n", - "[338722][V][data_utils.cpp:15] ~dataclass(): [DATA_UTIL] DATACLASS destroied\n", - "[338729][V][data_utils.cpp:22] clean(): [DATA_UTIL] Memory freed\n", - "[338735][V][data_utils.cpp:15] ~dataclass(): [DATA_UTIL] DATACLASS destroied\n", - "[338742][V][data_utils.cpp:22] clean(): [DATA_UTIL] Memory freed\n", - "[338748][V][data_utils.cpp:15] ~dataclass(): [DATA_UTIL] DATACLASS destroied\n", - "[338754][V][data_utils.cpp:22] clean(): [DATA_UTIL] Memory freed\n", - "[338760][V][data_utils.cpp:15] ~dataclass(): [DATA_UTIL] DATACLASS destroied\n", - "[338767][V][data_utils.cpp:22] clean(): [DATA_UTIL] Memory freed\n", - "[338773][V][PAM.cpp:298] MPF(): [PAM] RUN MPF with mode:1, pulse current:60, DC current 0\n", - "[338781][V][data_utils.cpp:10] dataclass(): [DATA_UTIL] DATACLASS Created\n", - "[338788][V][data_utils.cpp:10] dataclass(): [DATA_UTIL] DATACLASS Created\n", - "[338794][V][data_utils.cpp:32] init(): [DATA_UTIL] Allocation 4320 bytes\n", - "[338801][V][data_utils.cpp:61] clear(): [DATA_UTIL] ARR reset to 0\n", - "[338807][V][data_utils.cpp:32] init(): [DATA_UTIL] Allocation 4320 bytes\n", - "[338813][V][data_utils.cpp:61] clear(): [DATA_UTIL] ARR reset to 0\n", - "[338819][V][PAM.cpp:303] MPF(): [PAM] Memory allocation completed\n", - "[338826][V][PAM.cpp:359] MPF(): [PAM] Phase-1 Config\n", - "[338831][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 0\n", - "[338839][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 1\n", - "[338848][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 2\n", - "[338857][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 3\n", - "[338865][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 4\n", - "[338874][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 5\n", - "[338882][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 6\n", - "[338891][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 7\n", - "[338900][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 8\n", - "[338908][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 9\n", - "[338917][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 10\n", - "[338926][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 11\n", - "[338939][V][PAM.cpp:369] MPF(): [PAM] Phase-1 LED ON\n", - "[338953][V][PAM.cpp:386] MPF(): [PAM] Phase-1 Completed; Phase-2 start\n", - "[339262][V][PAM.cpp:414] MPF(): [PAM] Phase-2 Completed; Phase-3 Start\n", - "[339269][V][PAM.cpp:421] MPF(): [PAM] LED set to 220\n", - "[339335][V][PAM.cpp:421] MPF(): [PAM] LED set to 190\n", - "[339401][V][PAM.cpp:421] MPF(): [PAM] LED set to 160\n", - "[339468][V][PAM.cpp:421] MPF(): [PAM] LED set to 130\n", - "[339534][V][PAM.cpp:421] MPF(): [PAM] LED set to 100\n", - "[339600][V][PAM.cpp:421] MPF(): [PAM] LED set to 70\n", - "[339666][V][PAM.cpp:421] MPF(): [PAM] LED set to 40\n", - "[339731][V][PAM.cpp:421] MPF(): [PAM] LED set to 10\n", - "[339797][V][PAM.cpp:444] MPF(): [PAM] Phase-3 Completed; Phase-4 Start\n", - "[339804][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 0\n", - "[340114][V][PAM.cpp:484] MPF(): [PAM] Phase-4 Completed\n", - "[340119][V][PAM.cpp:507] MPF(): [PAM] Measurement Completed\n", - "[340442][V][PAM.cpp:526] MPF(): [PAM] All Completed\n", - "[340453][V][data_utils.cpp:15] ~dataclass(): [DATA_UTIL] DATACLASS destroied\n", - "[340460][V][data_utils.cpp:22] clean(): [DATA_UTIL] Memory freed\n", - "[340465][V][data_utils.cpp:15] ~dataclass(): [DATA_UTIL] DATACLASS destroied\n", - "[340472][V][data_utils.cpp:22] clean(): [DATA_UTIL] Memory freed\n", - "[340478][V][do_c.cpp:47] arr_set(): [DO_C] Set arr3, line 0 to type 1 with 80 x 5Hz samples, actinic:0, sub:2, IR:0\n", - "[340489][V][u_adpd6100.cpp:618] preset_config_1(): [ADPD] Preset_config 1 set for timeslot:0. Two ambient channels. Total 2 x 3 bytes\n", - "[340501][V][u_adpd6100.cpp:666] preset_config_2(): [ADPD] Preset_config 2 set for timeslot:1. Total 2 x 2 x 3 bytes\n", - "[340512][V][u_adpd6100.cpp:714] preset_config_3(): [ADPD] Preset_config 3 set for timeslot:2. Total 2 x 3 bytes\n", - "[340523][V][u_adpd6100.cpp:763] preset_config_4(): [ADPD] Preset_config 4 set for timeslot:3. Total 0 bytes\n", - "[340533][V][u_adpd6100.cpp:763] preset_config_4(): [ADPD] Preset_config 4 set for timeslot:4. Total 0 bytes\n", - "[340543][V][u_adpd6100.cpp:763] preset_config_4(): [ADPD] Preset_config 4 set for timeslot:5. Total 0 bytes\n", - "[340553][V][u_adpd6100.cpp:763] preset_config_4(): [ADPD] Preset_config 4 set for timeslot:6. Total 0 bytes\n", - "[340563][V][u_adpd6100.cpp:763] preset_config_4(): [ADPD] Preset_config 4 set for timeslot:7. Total 0 bytes\n", - "[340574][V][u_adpd6100.cpp:763] preset_config_4(): [ADPD] Preset_config 4 set for timeslot:8. Total 0 bytes\n", - "[340584][V][PAM.cpp:116] run_preprocess_type1(): [PAM] Run type:1, number:80, freq: 5, actinic: 0, subfactor 2\n", - "[340594][V][PAM.cpp:134] run_arr_type1(): [PAM] Sample & Ref: 80, optionals: 10\n", - "[340601][V][data_utils.cpp:10] dataclass(): [DATA_UTIL] DATACLASS Created\n", - "[340608][V][data_utils.cpp:10] dataclass(): [DATA_UTIL] DATACLASS Created\n", - "[340614][V][data_utils.cpp:10] dataclass(): [DATA_UTIL] DATACLASS Created\n", - "[340621][V][data_utils.cpp:10] dataclass(): [DATA_UTIL] DATACLASS Created\n", - "[340627][V][data_utils.cpp:10] dataclass(): [DATA_UTIL] DATACLASS Created\n", - "[340634][V][data_utils.cpp:10] dataclass(): [DATA_UTIL] DATACLASS Created\n", - "[340641][V][data_utils.cpp:32] init(): [DATA_UTIL] Allocation 320 bytes\n", - "[340647][V][data_utils.cpp:61] clear(): [DATA_UTIL] ARR reset to 0\n", - "[340653][V][data_utils.cpp:32] init(): [DATA_UTIL] Allocation 320 bytes\n", - "[340659][V][data_utils.cpp:61] clear(): [DATA_UTIL] ARR reset to 0\n", - "[340665][V][data_utils.cpp:32] init(): [DATA_UTIL] Allocation 40 bytes\n", - "[340672][V][data_utils.cpp:61] clear(): [DATA_UTIL] ARR reset to 0\n", - "[340678][V][data_utils.cpp:32] init(): [DATA_UTIL] Allocation 40 bytes\n", - "[340684][V][data_utils.cpp:61] clear(): [DATA_UTIL] ARR reset to 0\n", - "[340690][V][data_utils.cpp:32] init(): [DATA_UTIL] Allocation 40 bytes\n", - "[340696][V][data_utils.cpp:61] clear(): [DATA_UTIL] ARR reset to 0\n", - "[340702][V][data_utils.cpp:32] init(): [DATA_UTIL] Allocation 40 bytes\n", - "[340709][V][data_utils.cpp:61] clear(): [DATA_UTIL] ARR reset to 0\n", - "[340715][V][PAM.cpp:150] run_arr_type1(): [PAM] Memory allocation completed\n", - "[354358][V][data_utils.cpp:15] ~dataclass(): [DATA_UTIL] DATACLASS destroied\n", - "[354374][V][data_utils.cpp:22] clean(): [DATA_UTIL] Memory freed\n", - "[354379][V][data_utils.cpp:15] ~dataclass(): [DATA_UTIL] DATACLASS destroied\n", - "[354386][V][data_utils.cpp:22] clean(): [DATA_UTIL] Memory freed\n", - "[354392][V][data_utils.cpp:15] ~dataclass(): [DATA_UTIL] DATACLASS destroied\n", - "[354399][V][data_utils.cpp:22] clean(): [DATA_UTIL] Memory freed\n", - "[354405][V][data_utils.cpp:15] ~dataclass(): [DATA_UTIL] DATACLASS destroied\n", - "[354412][V][data_utils.cpp:22] clean(): [DATA_UTIL] Memory freed\n", - "[354418][V][data_utils.cpp:15] ~dataclass(): [DATA_UTIL] DATACLASS destroied\n", - "[354424][V][data_utils.cpp:22] clean(): [DATA_UTIL] Memory freed\n", - "[354430][V][data_utils.cpp:15] ~dataclass(): [DATA_UTIL] DATACLASS destroied\n", - "[354437][V][data_utils.cpp:22] clean(): [DATA_UTIL] Memory freed\n", - "[354443][V][PAM.cpp:298] MPF(): [PAM] RUN MPF with mode:1, pulse current:60, DC current 0\n", - "[354451][V][data_utils.cpp:10] dataclass(): [DATA_UTIL] DATACLASS Created\n", - "[354458][V][data_utils.cpp:10] dataclass(): [DATA_UTIL] DATACLASS Created\n", - "[354464][V][data_utils.cpp:32] init(): [DATA_UTIL] Allocation 4320 bytes\n", - "[354471][V][data_utils.cpp:61] clear(): [DATA_UTIL] ARR reset to 0\n", - "[354477][V][data_utils.cpp:32] init(): [DATA_UTIL] Allocation 4320 bytes\n", - "[354483][V][data_utils.cpp:61] clear(): [DATA_UTIL] ARR reset to 0\n", - "[354489][V][PAM.cpp:303] MPF(): [PAM] Memory allocation completed\n", - "[354496][V][PAM.cpp:359] MPF(): [PAM] Phase-1 Config\n", - "[354500][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 0\n", - "[354509][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 1\n", - "[354518][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 2\n", - "[354526][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 3\n", - "[354535][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 4\n", - "[354544][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 5\n", - "[354552][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 6\n", - "[354561][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 7\n", - "[354570][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 8\n", - "[354578][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 9\n", - "[354587][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 10\n", - "[354596][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 11\n", - "[354609][V][PAM.cpp:369] MPF(): [PAM] Phase-1 LED ON\n", - "[354623][V][PAM.cpp:386] MPF(): [PAM] Phase-1 Completed; Phase-2 start\n", - "[354932][V][PAM.cpp:414] MPF(): [PAM] Phase-2 Completed; Phase-3 Start\n", - "[354939][V][PAM.cpp:421] MPF(): [PAM] LED set to 220\n", - "[355005][V][PAM.cpp:421] MPF(): [PAM] LED set to 190\n", - "[355072][V][PAM.cpp:421] MPF(): [PAM] LED set to 160\n", - "[355138][V][PAM.cpp:421] MPF(): [PAM] LED set to 130\n", - "[355204][V][PAM.cpp:421] MPF(): [PAM] LED set to 100\n", - "[355270][V][PAM.cpp:421] MPF(): [PAM] LED set to 70\n", - "[355336][V][PAM.cpp:421] MPF(): [PAM] LED set to 40\n", - "[355402][V][PAM.cpp:421] MPF(): [PAM] LED set to 10\n", - "[355467][V][PAM.cpp:444] MPF(): [PAM] Phase-3 Completed; Phase-4 Start\n", - "[355474][V][u_adpd6100.cpp:826] preset_config_ext_fast(): [ADPD] External trigger test: 0\n", - "[355784][V][PAM.cpp:484] MPF(): [PAM] Phase-4 Completed\n", - "[355790][V][PAM.cpp:507] MPF(): [PAM] Measurement Completed\n", - "[356112][V][PAM.cpp:526] MPF(): [PAM] All Completed\n", - "[356123][V][data_utils.cpp:15] ~dataclass(): [DATA_UTIL] DATACLASS destroied\n", - "[356130][V][data_utils.cpp:22] clean(): [DATA_UTIL] Memory freed\n", - "[356136][V][data_utils.cpp:15] ~dataclass(): [DATA_UTIL] DATACLASS destroied\n", - "[356142][V][data_utils.cpp:22] clean(): [DATA_UTIL] Memory freed\n", - " Data sent\n", - "Data sent\n", - "Data sent\n", - "Data sent\n", - "Data sent\n", - "Data sent\n", - "Data sent\n", - "Data sent\n", - "Data sent\n", - "Data sent\n", - "Data sent\n", - "Data sent\n", - "Data sent\n", - "Data sent\n", - "Data sent\n", - "Data sent\n", - "Data sent\n", - "Data sent\n", - "Data sent\n", - "Data sent\n", - "Data sent\n", - "\n" - ] - } - ], - "source": [ - "print(info_outputs, other_outputs)" - ] - }, - { - "cell_type": "code", - "execution_count": 414, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "C:\\Users\\hjcbj\\AppData\\Local\\Temp\\ipykernel_12784\\944574406.py:2: RuntimeWarning: invalid value encountered in divide\n", - " plt.plot(x/y)\n" - ] - }, - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 414, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "x, y = np.array(data['Fluo']), np.array(data['Fluoref'])\n", - "plt.plot(x/y)\n", - "\n", - "# if \"730\" in data:\n", - "# plt.twinx()\n", - "# plt.plot(data['730'] / data['730ref'], 'm')\n", - "# plt.twinx()\n", - "# plt.plot(data['SUN'], 'y')\n", - "# plt.twinx()\n", - "# plt.plot(data['leaf'], 'r')\n", - "\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "sig = arr[1:, 1] - 16384\n", - "ref = arr[1:, 0] - 16384\n", - "plt.plot(ref, sig-ref - ref * 0.01)\n", - "plt.plot(ref, sig-ref - ref * 0.01 - 5 * np.sin(ref/3.14/26))\n", - "plt.grid(c = [.2, .2, .2, .2])\n" - ] - }, - { - "cell_type": "code", - "execution_count": 418, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "389" - ] - }, - "execution_count": 418, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "y[3000]" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": 254, - "metadata": {}, - "outputs": [], - "source": [ - "info_outputs = \"\"\n", - "other_outputs = \"\"\n", - "with serial.Serial(\"COM31\", 115200) as ser:\n", - " start_timer = time.time()\n", - " #ser.write(\"mpf, 0, 100, 100\".encode())\n", - " #ser.write(\"arrun, 500, 500, 0, 0, 0\".encode())\n", - " ser.write(\"sd\\n\".encode())\n", - " \n", - " data = []\n", - "\n", - " while (time.time() - start_timer < 40):\n", - " if ser.in_waiting > 2:\n", - " start_timer = time.time()\n", - " l = ser.readline().decode().strip()\n", - " if l[0] == '[':\n", - " info_outputs += l + \"\\n\"\n", - "\n", - "\n", - " elif l[:5] == 'Data:':\n", - " data.append(np.fromstring(l[5:], sep = ',', dtype=int))\n", - " \n", - " \n", - "\n", - " elif l == \"Cmd Done!\":\n", - " break\n", - " else:\n", - " other_outputs += l + \"\\n\"\n", - " else:\n", - " time.sleep(.5)\n", - " \n", - "arr = np.array(data)" - ] - }, - { - "cell_type": "code", - "execution_count": 382, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 382, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "n = 1.006\n", - "sig1 = arr[1:, 1] - arr[1:, 0] - (arr[1:, 0] - 16384) * 0.006\n", - "ref1= arr[1:, 3] - arr[1:, 2] - (arr[1:, 2] - 16384) * 0.006\n", - "\n", - "sig2 = arr[1:, 5] - arr[1:, 4] - (arr[1:, 4] - 16384 * 2) * 0.003\n", - "ref2= arr[1:, 7] - arr[1:, 6] - (arr[1:, 6] - 16384 * 2) * 0.003\n", - "\n", - "\n", - "sig3 = arr[1:, 9] - arr[1:, 8] - (arr[1:, 8] - 16384 * 3) * 0.0015\n", - "ref3= arr[1:, 11] - arr[1:, 10] - (arr[1:, 10] - 16384 * 3) * 0.0015\n", - "\n", - "sig4 = arr[1:, 13] - arr[1:, 12] - (arr[1:, 12] - 16384 * 4) * 0.0008\n", - "ref4= arr[1:, 15] - arr[1:, 14] - (arr[1:, 14] - 16384 * 4) * 0.0008\n", - "\n", - "plt.plot(sig1 / ref1 * 1.025 + .1)\n", - "plt.plot(sig2 / ref2)\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 377, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 377, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.plot((sig1 * 1) / ref1 , ((sig4 * 1) / ref4) - 1.05* (sig1 * 1) / ref1 - .2)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 344, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(1.0466826219966743, 1.1690711183330815, 1.3755932879073696)" - ] - }, - "execution_count": 344, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "(sig2.mean() - 60) / sig1.mean()/2, (sig3.mean() - 120) / sig1.mean()/3, (sig4.mean() - 120) / sig1.mean()/4, " - ] - }, - { - "cell_type": "code", - "execution_count": 345, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 345, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAk4AAAGdCAYAAADkG/zpAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAADkeUlEQVR4nOyddXxV5R/H34u7LtYBYwNGd0l3K6j8FAUDkQZJSQXEIERKkFAJEQlRMVAaka7RNXIwWLHuurv398fZPbt39643YNvzfr3O63XieZ5zzhi7n/tNI0CNQCAQCAQCgSBfjJ/1AwgEAoFAIBCUFYRwEggEAoFAICggQjgJBAKBQCAQFBAhnAQCgUAgEAgKiBBOAoFAIBAIBAVECCeBQCAQCASCAiKEk0AgEAgEAkEBEcJJIBAIBAKBoICYPusHeJ7x9PQkISHhWT+GQCAQCASCQmBra0tISEiprC2EUy54enoSHBz8rB9DIBAIBAJBEfDy8ioV8SSEUy5oLE1eXl7C6iQQCAQCQRnB1taW4ODgUvvsFsIpHxISEoRwEggEAoFAAIjgcIFAIBAIBIIC81SE0+jRo7l//z4pKSn4+/vTrl27XMe6u7uzZcsWAgICyMzMZNmyZXpjBg8ejFqt1tvMzc2LfF+BQCAQCASC/Ch14TRgwACWL1/OvHnzaNKkCceOHWPPnj1UqVLF4Hhzc3MiIiKYN28ely9fznXduLg43N3ddba0tLQi31cgEAgEAoGgIKhLczt9+rR69erVOudu3Lihnj9/fr5zDx8+rF62bJne+cGDB6tjYmJK7b6A2tbWVq1Wq9W2tral+vMRm9jEJjaxiU1sJbeV9ud3qVqcFAoFzZo1Y//+/Trn9+/fT5s2bYq1to2NDQ8ePODRo0fs2rWLxo0bF+u+ZmZm2Nra6mwCgUAgEAgE2pSqcHJ2dsbU1JTw8HCd8+Hh4bi7uxd53YCAAN577z369evHwIEDSU1N5cSJE9SoUaPI9505cybx8fHyJmo4CQQCgUAgyMlTCQ5Xq9U6x0ZGRnrnCsOZM2fYsmULV65c4fjx4wwYMIDbt28zbty4It93wYIF2NnZyZuXl1eRn08gEAgEAkH5pFTrOEVGRqJUKvWsPK6urnrWoOKgVqs5d+4cfn5+Rb5veno66enpJfZMAoFAIBAIyh+lanHKyMjg/PnzdO/eXed89+7dOXnyZIneq3HjxoSGhj71+woEAoFAIKhYlGp0+4ABA9RpaWnqIUOGqGvXrq1eunSpOiEhQe3t7a0G1PPnz1dv2rRJZ06jRo3UjRo1Up87d079008/qRs1aqSuU6eOfH3OnDnqHj16qH19fdWNGjVSr1+/Xp2enq5u0aJFge+b3yay6sQmNrGJTWxiK3vbU/j8Lv2XGD16tDowMFCdmpqq9vf3V7dv316+tnHjRvXhw4d1xhsiMDBQvr506VL1gwcP1Kmpqerw8HD13r171a1atSrUfZ+DH7zYxCY2sYlNbGIr4a20P7+NsnYEObC1tSU+Ph47OzvRq04gEAgEgjJCaX9+i151AoFAIBAISoyOHevz3ntdn/VjlBqlmlUnEAgEAoGg4uDl5cQ/u+diZWXO1asPOX/+7rN+pBJHWJwEAoFAIBDkS7dujXnllVZ5jvli3jtYWZkD0Llzg6fxWE8dIZwEAoFAIBDkiYmJMb//8TE7f/+YFi38DI5p0qQ6gwdnu+jad6j/tB7vqSKEk0AgEAgEgjxxdXXA2toCgI9nvWFwzOIl7wNw8eI9ANq3r4uxcfmTGeXvjQQCgUAgEJQobm4O8n6/fi/QuHE1net9+7akc+eGpKam89r/FhAfn4yDgw3163s/5SctfYRwEggEAoFAkCfu7pV0jmfNzrY6mZqasOirIQAsX/YngYHhnDx5E4AO5dBdJ4STQCAQCASCPNFYnO7cCUGlUtG/fxsaNPABYOTIXtSqVZknT2JZsOAXAI4dvQ5A+w71nsXjlipCOAkEAoFAIMgTjcXpxImb/PLLCQA++ngAFhZmzPlkIABzP9lKQkIKAEezhFMHIZwEAoFAIBBUNNzdHQAID4th3hc/A/D6622ZMKEfLi72BAVF8P33++Tx587dJjU1HTe3StSs6fUsHrnUEMJJIBAIBAJBnrhmuerCw2O5du0hO3eexNjYmAULBwPw+86TZGaq5PHp6UpOn74FlD+rkxBOAoFAIBAI8kTjqgsLiwHgi89/1rn++++n9eZo4pzatRfCSSAQCAQCQQXCTcviBHDp0n0SE1Pk68eP39Cbc/ToNUBYnAQCgUAgEFQwclqcAK5deyjv+/i46s05dSqAjAwlPj5ueHu7lP5DPiWEcBIIBAKBQJArZmamODraArrCycvLSd6fOfN1vXnJyWlyk9/25chdJ4STQCAQCASCXHF1dQAgPT2DmJhEAJo396NKlWwr0ruDu1C1qr7V6Vg5LEsghJNAIBAIBIJc0bjpNPFNAK++2gqAHTuOc+DARRQKU6ZP/5/e3KNyIczyU0FcCCeBQCAQCAS5kjMwHOCVV1sD8Mfvp+QMu/eHdqdyZWeduSdO3EClUlG7dmXZclXWEcJJIBAIBAJBrmQHhscCUKtWZerUqUJ6ega7d/tz7Nh1/vvvKmZmCqZN668zNzY2iStXHgDQvn3dp/nYpYYQTgKBQCAQCHJFY3F6Ei4FhmvcdIcOXSE+PhmAzz/bDsCw4T31GgJnxzmVD3edEE4CgUAgEAhyRdNuRWNx6tvvBUBy02k4fPgKx4/fwMLCjKlTda1OmnpO5aXhrxBOAoFAIBBUIMzNFbRvXw8Tk4JJALccNZw0FqirVx/ojPvic8nqNHJUb514pmPHpOKYDRv64OBgXYwnfz4QwkkgEAgEggrE9On/48jRhQwZ0q1A43MGh6enKwFQKEx1xu3ff5EzZ25hZWXOhx++Ip9/8iSWgIDHGBsb07Zt2Y9zEsJJIBAIBIIKhCbzrWZNrwKNz1k1PD09A5AKY+ZEE+s0ekwfnJzs5PPHylH7FSGcBAKBQCAo51hamtOv3wtYWprLLrpKlWwKNLegFieA3bv9OX/+LjY2lkya9LJ8PruekxBOAoFAIBAInnPWfjuWP/6cxYIF72KcJZwcCiCcLCzMsLeX4pKyLU6ScDJkcQLkuk4fjHtJFmca4dSsWQ2srS2K8SbPHiGcBAKBQCAo57zzTmcAxk/op2Vxyj9QW2NtSk1Nl0sP5Cec/vrrDJcvB2JnZ8WECf0AePQogocPn6BQmNKqVa1ivcuzRggngUAgEAgqCGFhMRgbZ1mcHPK3OOWMbwLIyMhbOKnVajnDbvyEvtjZWQHZVqeyXs9JCCeBQCAQCMoxtraW8n5oaHShYpwMCaf8LE4AO3ee4vr1IBwcbBg37iUgO0C8rMc5CeEkEAgEAkE5pm5db3nf2Ni4SK467T512cJJkes8tVrNvC+kWKdJk1/BxsZStji1alUrT9H1vCOEk0AgEAgE5Zj69avK+46ONrJwsrOzwsjIKM+5mqrh4VlVw6FgFieAHTuOc+vWYxwdbRk79kVu3w4mPDwGCwszWrSoWYQ3eT4QwkkgEAgEgnJMvXrZFidHR1uMjSWxZGxsjL29VZ5z3dwkV50hi5NCYZLnXJVKxbwvdgAw+cNXsLIyzy5LUIYb/grhJBAIBAJBOealvi3kfWtrC51yAIbinHr1akZs3M8MGNAON7lPnVZwuFwAM3dXnYZt245w924ILi72jBrVW274274MB4g/FeE0evRo7t+/T0pKCv7+/rRr1y7Xse7u7mzZsoWAgAAyMzNZtmyZ3phhw4Zx9OhRoqOjiY6O5sCBA7Ro0UJnzCeffIJardbZQkNDS/zdBAKBQCB4nqlRw1Pn2MXFXt43JJzatq2DnZ0Vb7/TxWCMU0ZGJpC/qw4gM1PFgvm/ADBlan/8/e/I9yhor7znjVJ/6gEDBrB8+XLmzZtHkyZNOHbsGHv27KFKlSoGx5ubmxMREcG8efO4fPmywTGdOnVi27ZtdO7cmdatWxMUFMT+/fvx9NT95bh27Rru7u7y1qBBgxJ/P4FAIBAIyhIuLtmtUAw13dWUG2jduhYeHo5A4bPqtNm8+TAPHoTj7l6J1q1rExOTiJ2dFY0a+Rb5HZ4lpS6cJk+ezPr161m/fj0BAQFMmjSJR48eMXr0aIPjHz58yMSJE9m8eTNxcXEGx7z99tusWbOGy5cvc+vWLYYPH46xsTFdu3bVGadUKgkPD5e3yMjIEn8/gUAgEAjKEvlZnN7Lav7r5GRHtWruQPGEk1KZKVudPpzyqmx1Kqv1nEpVOCkUCpo1a8b+/ft1zu/fv582bdqU2H2srKxQKBRER0frnPfz8yM4OJj79++zbds2fH3LproVCAQCgaCk0O4xZ0g4+fi46Z3TDQ7PvclvbmzadIigoAg8PZ1k12FZredUqsLJ2dkZU1NTwsPDdc6Hh4fj7u5eYvdZuHAhwcHBHDx4UD535swZ3n33XXr27Mnw4cNxd3fn5MmTODo6GlzDzMwMW1tbnU0gEAgEgvJMQYpgJiamkJSUKh8XpI5TTtLTlSz68lcAfH0lYda+fb18yyE8jzyVyCy1Wq1zbGRkpHeuqEydOpWBAwfSv39/0tLS5PN79+5l586dXLt2jUOHDvHiiy8CMHjwYIPrzJw5k/j4eHkLDg4ukecTCAQCgeB5xVCMU060rU1Q8HIEOVm//gAhIVHysbOzHXXqGI53fp4pVeEUGRmJUqnUsy65urrqWaGKwocffshHH31Ejx49uHr1ap5jk5OTuXr1Kn5+fgavL1iwADs7O3nz8vIq9vMJBAKBQPA8UxCLU2pqhs6xJnhcUcjq32lpGUybulHnXI8eTQq1xvNAqQqnjIwMzp8/T/fu3XXOd+/enZMnTxZr7SlTpjB79mx69erF+fPn8x1vZmZGnTp1ci1JkJ6eTkJCgs4mEAgEAkF5xsGAcDp8+IrOsY+Pq85xYYPDtdm69QgD31wkH3fu0rDQazxrSr1ZzNKlS9m8eTP+/v6cOnWKESNG4O3tzdq1awGYP38+Xl5eOi60Ro0aAWBjY4OLiwuNGjUiPT2dmzdvApJ77vPPP2fQoEE8ePAANzfJX5qYmEhSUhIAX331Fbt27SIoKAhXV1dmzZqFnZ0dmzZtKu1XFggEAoGgTGDI4nQr4DGdO2cLGu2CmVC0GCdtfv75GNHRiSxYOJgdPx8r0hrPklIXTjt27MDJyYk5c+bg4eHBtWvX6NOnD0FBQQB4eHjg7e2tM+fSpUvyfvPmzXnrrbd48OCBnBU3ZswYzM3N+e2333TmzZ07l08//RSAypUrs23bNpydnYmIiOD06dO0atVKvq9AIBAIBBWdnDFOLi72+VqBimNx0nDgwEUOHLhY5PnPkqfSnnjNmjWsWbPG4LUhQ4boncsvyr4gZQUGDhxYsIcTCAQCgaAcExUVj5OTncFrGotTkybVGTe+LwMHdsDcXN+SZGxsjEqlAkpGOJVlKuZbCwQCgUBQQbh/PzxX4VSzphdHji6kffu8ayrVq+fN1asPAK3g8EJm1ZUXymajGIFAIBAIBAUiOjrvZKf27euRkaFky5b/mDjhO4Nj2rSpLe8XN8aprCOEk0AgEAgE5ZiYmMR8x7z7zlLeeXsJBw8a7hHbuk0deb+iu+qEcBIIBAKBoBwTWwDhFBsrZaTnJrIMW5yEcBIIBAKBQFDOKIjFKSUlHcgWUDmpUcNTbg5clF515QkhnAQCgUAgKMfkJoa0SU6WWpalpKTlOqZ1a8nqJCxOAoFAIBAIyi0FszjlLpg0aNx1GRmZgAgOFwgEAoFAUA6Jjs5fOGksTnnRSrY4Sa46UY5AIBAIBAJBuaMwMU7SvmER1aKFHwqFqXDVPesHEAgEAoFAUHoUVjhFRMQbHGNpaU7jxr5COD3rBxAIBAKBQFB6FEQ4abvqIiLich3Xpk0dUQDzWT+AQCAQCASC0qMgwknTRgXyFk6tWteWhZOhnnYVASGcBAKBQCAox8THJ/PXX2cKPD43Vx1ImXXaIsvUtOIFiAvhJBAIBAJBOeeVl78o8NjoqNyFU5UqLri5OcjHCkXFi3MSwkkgEAgEgjJMo0a+/PnXbBYuHEzbtnUxMTH80X73bkiB1lMqVTrHJ07c0Dlu1qyGvF8RA8SFcBIIBAKBoAzTvn09+vZtybTpr3Hs+JeEhW9m04+TGTCgHXZ2VvK448dv5rqGhYWZvJ9TeB07el3nuEULP3lfCCeBQCAQCARliu++28u3a/fIx05OdrzzTme2/zydiMgtHDj4BRMnvkxqHtXBmzatLu/nFE5BQRHcvx8mH0sB4hW3X13Fe2OBQCAQCMoR6elKRo9ezZkzt1i9ZoxsPUpNTcfCwoyuXRvRtWujPNdo3bo2J09KFiljYyOda0lJqZw7d4dq1dwBaNKkmnytIgonYXESCAQCgaAc8MMPh2jbZhqBgeEAqFRq5n6yhUkTv+fgwUt5zn2hVS15P2dT4KSkNPzP3ZGPFQpTOSi8ItZyEsJJIBAIBIJywsWL92jRfBJ7957HysqcuZ++RfXq7rzY51Nat5qS67xWWsJp374LOteSklLx97+TcwogLE4CgUAgEAjKONHRCbz04md89uk2AD4Y15fD/82nXbu6uc6pXNmZypWdATh9+pbOtaSkVM6fv4dKpdKbVxEb/QrhJBAIBAJBOUOlUjF37lb6vvQZMTGJtGlTh68Wv5/nHI3VSanM1DmfmJhKYmIKAQGP9eYIi5NAIBAIBIJywz//nKNF80kGr2Vm6gokbXedxloFksUJwN//rt4aIsZJIBAIBAJBuSIkJJooA9XANT3nNLRqXVve12TYgZZwOqcf5yQsTgKBQCAQCMoVEyb0w8nJjocPn+icz+mSa9q0uiyELl68L5+3sjIH4JwQToAQTgKBQCAQPNfY21vTpEn1/AcawMnJjhkzXwNg1seb2bB+v3zN1tZKpw2LhYUZjRtLNZq0RVXDhr4AXL4cqNPgF4RwEggEAoFA8Jyx9tuxnL+wnF69mhV67qxZA7C3t+bixXts3XqEhw8jdK6fP39P51gT52RtbSGfa95c6k2XmprOtWsPdcYL4SQQCAQCgeC5QlNG4P2h3Qs1z9fXjdFj+gAwfdoPqNVqwsJidMZcOK8b8P2CAeGkHft0PkeAuKYQZkVCCCeBQCAQCJ5TbG0t8fJyAuCll1roNO3Njy/mvYOZmYJ9+y7IlcNDQ6N1xpzPIZwGDuzI++935+23O8nnWrTwk/vXacc5paamc/Pmo8K8TrlACCeBQCAQCJ5TatWqLO9bWJjRv39rg+NcXR2YN+8d3N0rAdC8uR8DB3ZEpVIxY/oP8riwsFideRcu6LrqANatH8/Hs96Qj62tLeQ4J41wiolJxLHSQIPzyztCOAkEAoFA8JxSp05lneNBb3UyOO7LRe8x86MBfPjhqwAs+moIAJs3H+by5UB5XE6LU2pqBvfvh+X7HG3aSO66a9cekpqaTqVKNrIlrKIhhJNAIBAIBM8ptWtLwmnPnvMAdOnSULYqabCwMOPVVyVLVPUaHvTp05xOnRqQmprOnNlbdMY+eRKnc+zqas+lS/fJSc7SAwMHdQSkbDvN+BYt/Ir6WmUaIZwEAoFAIHhOqZUlnPbuOc/JkzcxNjbmzTc76Izp3buZHPtUvbo7C798D4AVX//Fo0e6WXQ5ywkMGNCO/v3b6JwLCYli1Td/A1LT4PT0DNq0qSMLJU0hTCGcBAKBQCAQPFdoLE4BAY/ZtvUIkG390fCGlpBq0MCH+vWrEh2dwMKFv+a7/qKv9PvXOTjYYG9vDcC9e2Fs23YUgPET+gHZrVeaZZUpqGg8FeE0evRo7t+/T0pKCv7+/rRr1y7Xse7u7mzZsoWAgAAyMzNZtmyZwXH9+/fn+vXrpKamcv36dV555ZVi3VcgEAgEgucJU1MTatTwAODmzUfs2HEcpTKTFi388PPzBMDGxpKXXmqhN3feFz8TG5tUoPscPXpN59jKypxWraWyBElJqaz4ehcgWac8PR1lN17TptUxNq549pdSf+MBAwawfPly5s2bR5MmTTh27Bh79uyhSpUqBsebm5sTERHBvHnzuHz5ssExrVq14ueff2bz5s00atSIzZs3s2PHDlq2bFnk+woEAoFA8Dzh6+uGmZmCxMQUgoOjiIiI48CBSwAMyrI69e3bEisrc27fDtaZu2rVP3rr2dhYsmLFCL3znTrOJDAwXOdcly4NAUhOSuPixXscOXINhcKUMWNe5NatYBISkrGxsdQLXq8oqEtzO336tHr16tU6527cuKGeP39+vnMPHz6sXrZsmd757du3q3fv3q1zbs+ePeqtW7eWyH0Bta2trVqtVqttbW1L9ecjNrGJTWxiE5uhrV+/F9Qq9S71Of/sz8G33uqkVql3qQNurVUD6j/+nKVWqXepV60arVapd6lV6l3qrdum6q3Vu3cz9YOHG+Qx2hugXrZsmDo94w/1n3/N1rm2aNEQNaB+5ZVWapV6l/pJxBa1paW5+vB/C9Qq9S714MFdn/nPKedW2p/fpWpxUigUNGvWjP379+uc379/P23atMllVv60bt1ab819+/bJaxblvmZmZtja2upsAoFAIBA8K7TjmzT8+ecZkpPTqFnTi+7dm9CrV1MAavh5yGNOnwqQ952d7dj804f8s3su3t4u3L8fxj//nNO716RJ63ByHCgHhWtISkoF4K+/zhIYGI6zsx1vvdWxQgeIl6pwcnZ2xtTUlPBwXRNgeHg47u7uRV7X3d09zzWLct+ZM2cSHx8vb8HBwQbHCQQCgUDwNNBk1N3SEk6JiSn8+edpAHb8Mh0zMwVJSal06tRAHuPt7QJI7rzrN1bz1ludyMzMZOmS32nY4AO2/PSfwfslJKRw9uxtnXMa4aRSqfhmpRTrNGHiy/j7S8KpuRBOpYNardY5NjIy0jtXGmsW5r4LFizAzs5O3ry8vIr1fAKBQCAQFAdDFidAzq7TZL5ZW1vo9Izr1Lkhu/6ew09bpuDiYs+VK4G0bjWVKVM2kJycplcEU5vY2CRu3AiSj5OS0uT99esPkJCQTL163jg4SPdu1Mi3wvWrK1XhFBkZiVKp1LPyuLq66lmDCkNYWFieaxblvunp6SQkJOhsAoFAIBA8KzTCKWc/uH37LuY5r2nT6rz4YgvS0jKY9fFmWjSfLFuIQL8IZk7OnL4l7ycmpsj78fHJ/LDxEAB9+71AVFQ85uYKGjSoWrAXKieUqnDKyMjg/PnzdO+u29G5e/funDx5ssjrnjp1Sm/NHj16yGuW1n0FAoFAIHgauLk5UKmSDZmZmdy9G6pzLWcRS0P8999VGjcaz/z5O/TGOzvb6RxbW1voHJ/WEk7aFieAlSt3oVKp6NOnOfHxkqhq3rxiuetK3VW3dOlShg0bxpAhQ6hduzZLly7F29ubtWvXAjB//nw2bdqkM6dRo0Y0atQIGxsbXFxcaNSoEXXq1JGvf/311/To0YNp06ZRq1Ytpk2bRrdu3Vi+fHmB7ysQCAQCwfOKxtoUGBhOWlpGnmN/+ukw7dpOo1nTifK5l178lFu3HhscX6uWbiiKp6ejzvEpreByTYyThrt3Q/n7bym43NfXDaiYAeKlnho4evRodWBgoDo1NVXt7++vbt++vXxt48aN6sOHD+uMN0RgYKDOmP/973/qmzdvqtPS0tQ3btxQv/rqq4W6b36bKEcgNrGJTWxie1bbyJG91Cr1LvVfu+boXatc2VmnZMD//tdGvhYds02tUu9S16lTJde1Fy0aojO/U6cGOteNjY3VsXE/q1XqXep27erqze/SpaHO/IuXVjzzn5f29hQ+v5/9Sz6PmxBOYhOb2MQmtme1LVs2TK1S71J/9dX7etcmT35FR7j8+ttM+drFSyvUKvUude/ezXJd+/c/PtaZP2hQR70xU6f2V+/d95nawsLM4BqXr6yU56dn/KG2tDR/5j8zzVam6zgJBAKBQCAoPLVyyaiD7N50a9fsBuDFF1vIWW4PHkgJUFWruua6ds2akqtOk13n5eWkN+arr3bSq+ccUlPTDa7x9fK/5H1TUxMaN/bN+4XKEUI4CQQCgUDwnJFbRl316h60aOGHUpnJnDlbuHbtIebmCvr3l4o7Bz2MAMDHx7BwMjExpnp1KeP88OGrgH6MU0HYuvUIERHZ2XkVKc5JCCeBQCAQCJ4jrKzM8fGRAq9zWpzeeKM9AAcPXiIyMp6tW/4DYGBW7zqNxck7F4tT1aqumJkpSElJ41xWsUtPAxan/EhNTefbtXvk42YVKLNOCCeBQCAQCJ4xHh6OtG9fD8h2pUVExBEdrVtT8I03JeH08/ZjAGzbdhSAzp0b4OnpyMN8LE6ajLo7d0J49CgSMOyqKwhr1uwhPV3K+BMWJ4FAIBAIBKVO1aqurFkzhvuB6zhydCFbt02lefMagL61qV49bxo08CEtLYM//pDarjx8+ITjx29gbGzMG2+0zzfGSSPKbt8OITg4Ciiaqw6kGKmffz4OSK5FOzurIq1T1hDCSSAQCASCp0z16h6sWzeO23e+ZeSo3pibK1CpVLz5Zge++34coNujDrLddHv2nCcuLkk+r2nBMuitTrLFycPDEXNzhd59XV3tAQgJjiIkRAoO9/R0xMjIqEjvseLr7CDxpk2rF2mNsoYQTgKBQCAQPCVq1arMph8nE3BrDe8P7YFCYcr+/Rfp0H46HdrPICQkSh5bu04VnblvDpSy6X7eflTn/I4dx8nIUNKsWQ2cne3kNimaZr/amJqaAJCRkSln1ZmZKXBysi3S+5w/f5fjx28AkhisCAjhJBAIBAJBKVO/flW2bZ/G9RureOedzpiYmPD33+do3WoKvXrO4fjxG5w8eVOn+ne7dnVZsGAwJibGNGtWgxo1PElKSmXXrrM6a0dFxbN//0UABg3qqBXn5Kb3HBrhpFRmolRmEh4eAxQ9zglg+LCVLP5qJ3/+ebrIa5QlKlZLY4FAIBAIniJNmlRn1uw3ePXV1vK5338/xbwvfubChXt64yMi4lEqM2WBM33GazRv4UdQkCSGdu06S3Jymt68rVuO8OKLLRg4qAO3b4dQr543VavqW5xMTCR7iVKZCUBwcDRubpXw8nLi8uXAIr3jrVuPmTZtY5HmlkWEcBIIBAKBoBQYO/ZFVn4zCgCVSsUvv5xg/rwdXL36INc5Vau6YGpqQmpqOu8P+Zrvvv+Arl0bydc12XQ5+euvMyQlpVKjhiexsVL8U34WJ4Dg4CiaNq1e5ADxiohw1QkEAoFAUML06dOc5V8PB2D79qPUrzeWgW8uylM0QXbhy9u3g9m+/SgvtPxQbtYbF5fEnj3+BuclJaXKmXbNs2oqeRuwOGmEU2amCoDQkNyrhwsMI4STQCAQCAQlSIMGPmzbPhUTExO+/24vgwZ+ZbB1iiFqy61WggGpcnjLFpNZuOAXBr+7jPR0Za5zNdl1GgxbnHK66opXkqAiIlx1AoFAIBCUEG5uDvy1aza2tlYcOnSZsWPXFmq+RjhplyJISEjho49+zHfu/v0XiYyMx9nZDoCaNT0xMTGWrUsAxia6rjq5JIGwOBUYYXESCAQCgaAEsLAw4/c/PqZqVVdu3XrM668tkAVKQdGUICiohUobpTKTX3Ycl49dXR14+eVWOmM0FifHKpUxMTWVLU7CVVdwhHASCAQCQbmiqMUci3vPDRsn0KpVbaKi4un70mdykHZhyK25b0HZmsNdN2nyyzrHmhinF157lRavvlQqrrquwwfz3vKFmJqZldiazxNCOAkEAoGg3PDBBy8RFb2Vxo2rPdX7fvLJQN58swPp6Rn8r/8C7t4NLfQaTk52uLhIlb1v3w4u0nOcPHlTbrsC0LZtXVq2rCkfa4STCqjk7ia76lxdHTAzK370jpGREd2Gv0eDrh2p0bJpsdd7HhHCSSAQCATlhs5dGuLgYEPnzg2e2j0HDerInE8GAjBq5CqOHr1WpHU0DXgfPnxisFZTQVCr1WzfpltZfOKkbKuTpo6TWm2EwsKcqKh40tKkRr3u7pWKdE9t7F1dMLO0AKBqw/rFXu95RAgngUAgEJQbVCo1IFlQngatW9dm/YYJACz68ld++OFQkdfKzqgrfHyTNlu2/Kdz/NprbalSRSpNIFuc1KAwNweyA8RLIs7Jxcdb3q/asF6x13seEcJJIBAIBOUGlUrKIHNxsSv1e/n4uPH7Hx9jbq7g999PMXNm/plveVEnKzA8Z3PfwnL9ehBXrmRXATc1NWHcuJfkfQA1oLCQhFNJBohrCyfvBvWeSbxZaSOEk0AgEAjKDRqLk3NWrFBpYWdnxa6/5+Dq6sCFC/d45+0lqNXqYq1Zq4QsTiC1YNFm+Iie2NhYyll12hankgwQd6maLZws7Wxx9a1a7DWfN4RwEggEAkG5QWNxcnUtPeFkYmLMtu3TqFfPm+DgKPr1/azIMUna1K4txTgVNaNOm+3bs+OckpJSsbe3ZsiQbnKMk0ptJAunkqwe7uJTRee4PMY5CeEkEAgEgnKDxujjUooWp6VLh9G7dzOSk9N4ud/ncoxQcTA3V+DrK1X6LgmLU1BQhBykHhoqPd+Eif0wN1cAUladIiuIW2Nx8ihBi9PDy9K9vRuVvzgnIZwEAoFAUG7IjnEqHeE0Zkwfxo3vC8A7by/hwoV7JbJujRoemJiYEBubSHh4bImsqWnBkpmpIioqnmrV3Gnbti5QOsHhJgoFjl4eAJz7azcgLE4CgUAgEDzXaGKc7OysZOtKSdGzZ1O+XjECgJkzNvH776dKbO2SyqjT5pdfTpCRoaRWrcocPXpd55oayVVnYWFGgwZSHFJxhZNTZU+MTUxITUzi2r+Sq9C9RjXMra2Kte7zhhBOAoFAICg3aIQTlKzVqW5db7b/PA0TExM2bjzIl1/+WmJrQ3ZGnaa5b0kQHZ3A3r0XAIiJTiA9PUO+ZmaspkcDGx48XM+Mma8DknuvOGgy6iIeBpEQGUV0cCjGxsZ4169brHWfN4RwEggEAkG5Qa3KbmhbUsLJ2dmOXX/Pwd7emiNHrjFq5KoSWVebWgaa+5YEW7NqOnXq3JDt24/J5/tUSaBnHXNcXR148CCccR+s5eV+XxRozX7TJvDhb5uxsLHWOa+Jb4p4KAW3P7ySFedUzuo5CeEkEAgEgnKDdkmAksisMzdX8PsfH+Pr68bduyG89r8FZGQoi71uTorboy43du06S2JiCtWquXP6VIDOtfBEePutxdT0G8mqVf+QklKwzMB6ndrhWbMGNVu31DnvqrE4PQgC4OEVyT1Y3uKchHASCAQCQbmhpF11368bR9u2dYmJSaTvS58TFRVf7DVzYmRkVCoxTgDJyWn88cdpAOrWzS4VcDbCkg3XLNi69QhKZWah1szMEo5VG+kKIuesUgSycLp8VRonLE4CgUAgEDyf6Aqn4lUP//jjAbz9dmeUykxef20Bt26VrKjR4OXlhLW1BRkZSu7fDyvx9TXFMAe80V5uAHw/3gyFuUWR1lOmpQP6lqRsV50knIID7qBMT8fGsRJOVSoX6V7PI0I4CQQCgaDcoNKKcapWzR1j46J9zL3+ejs+/+IdAMaOWcO//14pkeczhCYw/O7d0EJbfwrCwYOXiIiIw9XVAR8fqVaUCjBRmGJsYlLo9ZTpknCqXLcWJqamAFjYWGPnLGXlaWKcMjMyeHzzFgBVy1E9JyGcBAKBQFBu0LY4jf3gJX75dUah12jZsiY/bJoIwLKlf/D99/tK6vEMUlpuOg1KZSY7fj6mc06llnrIaWo5FWq9jAx5rmftmkC2tSk+IpK0pGR5bHmMcxLCSSAQCATlhpz94l59tTV9+jQv8PwqVVz4489ZWFqa8/ff55g6dWNJP6IetUspo06brVt1e9dpfkwKyyIIpyyLE4BPVpyTptWKxtqkQVNBvDzFOQnhJBAIBIJyg7bFScOir4bIPdrywsbGkr92zcbdvRKXLwcyaOBXOq6/0qJWVo+60rI4AZw6FUBgYLh8rHmrIlmc0rKFk0YQaSxOTx481BmrEU6eNf1QWBT+Xs8jT0U4jR49mvv375OSkoK/vz/t2rXLc3yHDh3w9/cnJSWFe/fuMXLkSJ3rhw8fRq1W621///23POaTTz7Rux4aGloq7ycQCASC5wNDQqduXW+GD++Z5zxjY2O2bJ1Co0a+hIXF0K/v5yQmppTWY+pQWqUIcrJNy+pUEq46gKqNGgDgUlWyOEU+0H2H2LBw4p5EYKIwpXLd2oW+1/NIqQunAQMGsHz5cubNm0eTJk04duwYe/bsoUqVKgbH+/j4sHv3bo4dO0aTJk2YP38+K1asoH///vKY/v374+7uLm/16tVDqVTyyy+/6Kx17do1nXENGjQo1XcVCAQCwbMlp8XpVFbtormfDsLW1jLXeYsWvUffvi1JSUnjlZe/4NGj4lXRLih2dlZ4ekpB1bdulVzVcENsySqGCaD5KRXFCqTtqnP08sDW2QkXH6ltiyajTpvyFudU6sJp8uTJrF+/nvXr1xMQEMCkSZN49OgRo0ePNjh+1KhRBAUFMWnSJAICAli/fj0bNmxgypQp8piYmBjCw8PlrXv37iQnJ+sJJ6VSqTMuMjKyVN9VIBAIBM+WnMJp3hc/ExDwGFdXB2bMeM3gnOHDezL5w1cBeG/wcs6evV3qz6lBY20KCYkiPj45n9HF4+bNR3z/3V6uPUomLl36+C9KSQKlVusWkOKccotxgvIX51SqwkmhUNCsWTP279+vc37//v20adPG4JzWrVvrjd+3bx/NmzfHNCvtMSdDhw5l+/btJCfr/tL5+fkRHBzM/fv32bZtG76+vrk+q5mZGba2tjqbQCAQCMoWOYPD4+KSmT5NCvCeOOllqlRx0bnetWsjVq2WvsjPmf0Tv/xy/Ok8aBalnVGXk5EjV7H2UBSQ5aorpsUJoH7XjphbWZGpVBL1SN9qpmm9krNgZlmlVIWTs7MzpqamhIeH65wPDw/H3d3d4Bx3d3eD4xUKBc7OznrjW7RoQYMGDVi3bp3O+TNnzvDuu+/Ss2dPhg8fjru7OydPnsTR0dHgfWfOnEl8fLy8BQeXrslUIBAIBCVPzhin9PQMdu06y3//XcXS0pwv5r0jX6tVqzK//DoDU1MTfvrpMF988fPTflytjLqn95ljZGQk7xcpxilLOMVHRgHQoGsnAKKDQ8lU6rejeXwjgEylEntXFxzc3YrwxM8XTyU4POc3ACMjI71z+Y03dB4ka9PVq1c5d+6czvm9e/eyc+dOrl27xqFDh3jxxRcBGDx4sMF7LliwADs7O3nz8vLK/8UEAoFA8FyR01VXqZINAFM+XA/AO+90plmzGjg62rLr79k4ONhw4sQNhg9b+dSfFbKb+z4tixOAkVZR0KJZnCRXXXCA5NI0t5JixwzFNwFkpKYRcvsuUD6sTqUqnCIjI1EqlXrWJVdXVz2rkoawsDCD4zMyMoiKitI5b2lpyZtvvqlnbTJEcnIyV69exc/Pz+D19PR0EhISdDaBQCAQlC1yCidXVwcALly4x48//gvAipUj+W3nR9So4UlgYDj9X51PWlpGzqVKnbZt69KmjZRpVtoZddoYGZeMxSkmOJTk+OzefYbimzSUpzinUhVOGRkZnD9/nu7du+uc7969OydPnjQ459SpU3rje/Togb+/P8ocJsABAwZgbm7OTz/9lO+zmJmZUadOHVGSQCAQCMoxOV112v3qZn28mZSUNFq3rk3HjvWJj0+m70ufERER91SfsV49b/78azbHjn+Jm1slQkKiOHfuzlO7v5GRlsWpGMLJRKGQM+Ygu7mvIeQ4p3KQWVfqrrqlS5cybNgwhgwZQu3atVm6dCne3t6sXbsWgPnz57Np0yZ5/Nq1a6latSpLliyhdu3aDBkyhKFDh7J48WK9tYcOHcoff/xBdHS03rWvvvqKDh064OPjQ8uWLfn111+xs7PTuZdAIBAIyhc5IzpcXOzl/cePI1EospOM3hq0mBs3cv+wL2mqVHFhw8aJXL6ykr59W6JUZvLdt3tp0XwycXFJT+05dGKcilQ5XNNyxUy2JAFE5mlxkgRW5bq1MFEoCn3P5wnDaWolyI4dO3BycmLOnDl4eHhw7do1+vTpQ1CQ9Mvq4eGBt7e3PP7Bgwf06dOHZcuWMXbsWEJCQhg/fjw7d+7UWdfPz4/27dvrWac0VK5cmW3btuHs7ExERASnT5+mVatW8n0FAoFAUP7IaXFydc0WTq++2hpT0+ymtj4+rk/lmRwdbfnoo9cZM/ZFLCzMAPj11xPM+ngzt28//USkknLVmSgUOsIpZ9VwbaIePSYxOgYbx0p41fYj6OqNQt/3eaHUhRPAmjVrWLNmjcFrQ4YM0Tt39OhRmjVrluead+7c0VHNORk4cGDhHlIgEAgEZZ6cMU7OWRanpk2rs/mnDwHIyFCiUJjyydxB/PTTf6Vm7bGyMmfChH5Mm/4/7O2tATh8+Aozpv/wVF1zGkzNzVGrVLquumIEh5uaSRan+MgoUhMSiX+Sd63Eh1euU69TO6o2rF+mhZPoVScQCASCcoN+jJM9np6O/PnXbKyszNm79zx2tgO4cSMIZ2c7Pvro9RJ/BlNTE0aM6MXtO98yb/672Ntbc+nSfXr3+oSuXT5+JqIJYOrvPzH19y2YWWYXvSyaxSkNAFMzBWnJySzu/zYr3h6eZ7Y8aMc5le0AcSGcBAKBQFBuyGlx8vV1469dc/DycuL69SDefGMRaWkZTJsqFcUcP6EfVauWnMvuf/9rw9Vr37D227F4ejoRGBjO228tplnTiezbd6HE7lNYjIyNsXd1waVqFVx9q8rniyacsixO5pLbMSkmlpT4/DPRgzStVxqV7fZnQjgJBAKBoNyQ0+rh7l6Jpk2r8+RJLH1f+kxua7J7tz8HD17C3FzB/AXvFvu+nTo14NTpxfzy60xq1apMREQcE8Z/R53ao9i69Ui+1pjSRq1S8SRQPwapWK46hVmh5gVdu4FKpZL725VVhHASCAQCQblBY3GKjIzXOf/qK/N48EC3fuDUKRtQqVQMHNiRli1rFul+jRr58s/uufx7eD4vvFCLxMQUPvt0GzWqD2flyl2kp+tX0n5WPLn/QO9ccYLDTc0Klx2XlpRM2N37QNl21wnhJBAIBIIyj5mZKZ06NWDOJ1JikLNzdv2mGdN/4NSpAL05ly8HsmmTVBRz8ZKhhbqfj48bP26ezMVLK+jduxkZGUpWffM3NaqPYO7crSQkpBTjbUqH8BKzOEnCqSiiqzzEOT2VrDqBQCAQCEqaunW96d69Md17NKFjx/pYW1sYHHfgwKVc15g9azMDBrSjXbu69O/fhp07DRdn1uDiYs+sWW8wclQvzLIsLtu2HWHO7C3cu/d8F1gOvxeod6645QgKS9Dl67R+7RW8y3AhTCGcBAKBQFAmcHGxp1s3SSh1794YLy/dOJmwsBgOHLjEwQMXOXjwMv/s/oTGjavpVA/PSUhINEsW/86cTway8MvB7Np1lowMffeajY0lkye/zIdTXsXW1gqAffsu8NHMH7l48V7JvmgpEV5irjpNOYLCCyeNxalKvToYm5igysws9BrPGiGcBAKBQPDc0ry5H6+/3pZu3RvTpEl1nWspKWkcPXqdgwcusX//Ra5efaBzXdNKRdOvLje++monw0f0pEYNT8aM6cPXX/8lX1MoTBkxoiezZr+Bm1slAPz97zBj+g/8+++V4r/gUyTy4SMylUpMTLM/+s0sLQs8362aDzZOjiRGxwBSHafC8iTwISnxCVja2eLhV11uFFyWEMJJIBAIBM8llSs7c/rMYoyNs8NxL168JwulEydukpqanuv8iAgpQDwvixNAUlIqc2Zv4ft145g9501+/PFfYmOTeOON9nz+xdtUr+4BwJ07Icz6eDO//nrimWfJFYVMpZKoR8E65Qgq161VoLnGJiaM3rAKWydHuVaWtYN9PrP0UavVBF29Tq22rfBuWE8IJ4FAIBAISgofH1eMjY2JjIxn4oTvOHjwMk+exBZ4fkTWWO1+dbmxceNBxk/oS4MGPny/bhw+Pm40bSpZuMLCYvjs022sW7cfpbLsuZa0Cb//QEc4FRQHDzdsnRwBdITsqzMnc2zrL3n2qcvJwyuScKrasD6ndvxe6Gd51oisOoFAIBA8l2jalAQGhrN165FCiSbItjhp96vLDZVKxdQpGwDo378NTZtWJz4+mdmzNuNXYwRr1+4p86IJwMaxkt45ezeXfOc5V/ECJFfbP8tXy+fbDXqdmX/vYNjqJdRq2yrPVmgaNHFOPo3KZoC4EE4CgUAgeC6xt5eCsIvaS04T4+RcAIsTwP79F9m27QhpaRksX/Yn1asNZ968HSQlpRbp/s8b5lZWeNevq3e+1Wuv5DvXqUplQGrke3zrr/L526fPoVKpqNO+DSPWLmPan9to++b/8oydenhF6lPn4uONlX3ebtTnESGcBAKBQPBc4uAgWZxiY4smnJ48kYRTQVx1Gt5+awk21q8xefI6oqLi859QhvBt1ggThX6ETqv/9dMJGDeEs7cknCKDHqPMyI4r+/HDWSx8cQBHNm8nJSERV9+q9P94CnMO/knfKeNwrOypt1ZKfLxcxdy7DNZzEsJJIBAIBM8lGlddfDEtTq6u9pibK3jppRbymrmhVqvJzFTlOaas4teyucHzdi7O1O/aMc+52sJJpcyUywiYmimIehzMX4u+5vNuL7Nz/hIiHgRhaWdLp8GDmPnPLwz5eiE1WjbTWS+7EGbZc9eJ4HCBQCAQPJdku+qSizRfI5yqV/fgytVv8PPz5Ltv9zJq1KoSe8ayRE7xok2bN/pzed+hXK87Z7nqoh49BqRaTmaWJjq1nNKSkzmx7VdObv+NWm1foP1bb1C7XSvqd+lI/S4dCb1zj2NbdvAk8CE+jRsCUomDsoYQTgKBQCB4LnFwsAGKHuNkZpb9EefnJ7mMfKu5Ff/ByiBW9nZ41vbL9XqNFk1xr1FN7iWnjZGREU6VpeDwyEfBACgz0jGztDBYQFOtVhNw/DQBx0/j6luVdoNep3m/3nj4VWfA3JnyuNjwJxzeuKW4r/bUEa46gUAgEDyX2GVZnAob42RqasKHH77KqdOL5XO3b0sf+I6OtiX3gGWI6i2aYmxsTOideyTH6cZuBV2TgrXbvNHf4Fw7V2cUFuZkZiiJDZUaJWuqh+fXduVJ4EN2zlvMZ91e5s+vvibqsfTvcHH3fhb3f5tHWfcuSwjhJBAIBILnEk08UmFcde3a1eXCxa/5avH72NhkZ3YtW/oHAE5OFU849f1wHO8tWwDA3bPn9UoG+P+5G4BmfXvhXqMaU//YSuvXX5Wva9x00cEhcmyTMk0KEC9o9fDUhESO/ridBS8O4LNu/fhp+iekxCcU78WeEUI4CQQCgeC5RJNVVxBXnYuLPRs2TuTosS+pX78qkZHxDH3/a65ckRrbmphIH3cV0eLUsv9L8v7ds+chh3B6cPkqTwIfYmFtzVtffop7dV+a9e0lX5cDw7PimyC70W9h+9WpVSriwiMK/Q7PE0I4CQQCgeC5xL4ArjpjY2NGjepNwK21vPdeVwC+/24vtWuNYuPGg4SHxwJgYmICgJ2dFQoDKfnlGQsbG3n/nv9FjIwl4aRpnaIwM+fkzzsB8KxZA9AtlOkkB4YHy+eUGZKrTmFe+H51ZR0hnAQCgUDwXJKfq65ZsxqcOr2Y1WvGUKmSDRcv3qN1qymMHLmK6GjJDaSpHm5mZioLhUqVbAyuV17RbpFSpV5tjIyk44xUqbCnwsKcc3/tJi05RR6naa8CuqUINGgsTiYKIZwEAoFAIHguyK1yuIODNatWjebM2SW0aOFHXFwS48d9S8sWkzlz5pbOWE2/OicnW2JiEuX9ikqHd96UhVR6iiScTM3NSU1I5MLuffI4CxtrTLMy5jQxTjrCKa1orrrygBBOAoFAIHjuMDU1kYO7tV1177zTmYBbaxk9pg/Gxsb89NNh6tQezTff/G2wcKXG4uTiYk9UlGSFqsjCqU77NigsJEGkEU6a45Pbd+qMrd+pHQBO3lIpAjVq6nfpQLeRQ3DK6l1XEV11FcvRKxAIBIIygZ2dlbwfH59MvXrefLNqNB07SpWmb958xNgxa/jvv6t5rqMpguniai+77ypSgLim/pIh0lMk15ymFlPYPd0aTu8s/oKmL/bEwlpymQ5fvVRvjYSomJJ61DKDEE4CgUAgeO7QuOkA5s9/lwkT+6FQmJKUlMrnn21n2bI/ychQ5ruOdr+6imhxqvFC7tXCc1qc7F1d9MbU69xe3s9ISyP83gNC79wj7M49Hly+xoNLV0r4iZ9/hHASCAQCwXOHpmo4wJSpUmHG338/xaSJ3xMUVPB0dtni5GLH3buhQMWyOPnlaLOSqVTKDX1zWpwqebjnuk5s+BPm9ewv13GqyAjhJBAIBILniurVPThxcpF8HBgYzvhx3/LPP+cKvZZGOLm5ORAdJcU7VSyLk25jX41oAsjMstjlJZzSklMwt7LkxpETQjRlIYSTQCAQVGDs7KwwNjYqdFuT0sDcXMGMGa8xfcZrWFhkBx3XqzuG1NT0Iq35+HEUALa2VqhUaqDiWJzca1TTKSuQk9rtWgFgZmkBgIOHfh8/cyspQF+7hlNFRwgngUAgqKCYmBhz+cpKnJ3tGD1qNT/9dLjE72FjY8m8ee9gZWVOfHyy1paic+zuXokvF71HjRqeOvP37j1fZNEEkJKSRmhoNB4ejnIlcscKYnGq0TL3+CZtZIuTZ+6uOu1SBBUdIZwEAoGgglK3rjdVq7oC8OPmyXTqVJ9x474jJSWtxO4xZkwfxo3vW+DxwcFRTJr4PZ6ejiz/ekSJWMLu3QuThFNW4UtHx4pRANOvVfP8B5EdHO6YR4yTq2/VEnmm8oAQTgKBQFBBadHCD5DigJycbHl/aA9avlCLAa8vJCCgZCwMA96QsrK2bTtC0MMI7OyssLWzxM7OSmuzxNxcwS87jjN37jYSE1OYPftNAOIL0eA3N+7dC6Vdu7qyxcnJya7Yaz7vGJuYUL15U0DqT5eX9UljcXLIEk53Tvvria7a7Vvx7/ofS+lpyxZCOAkEAkEFpWXLmgBsWH+A/fsvsmXrFOrXr8o5/2WMGb2azZuL57qrUcODpk2ro1RmMn7cd0RlBWcXhMI0+M2P+/fCgOxWKxXB4uRVuyaWtjakxCcQcOJ0nsLJxccbyA4Ov/7fMT3h5NOwAaZmZnKrlYqMqBwuEAgEFZTmWRanc+fucPjwFZo0Hs/Bg5ewtrZg04+TWb9+PJaW5kVef8AAydp08OClQokmKFiD34Jy/74knCqSxUkjfO75XyD+SWSeY32bNMTawV4OEr9zxl9vjInCFJ/GDUr+QcsgT0U4jR49mvv375OSkoK/vz/t2rXLc3yHDh3w9/cnJSWFe/fuMXLkSJ3rgwcPRq1W623m5rr/wQt7X4FAIKgoWFiY0bChDwBnz94GIDw8ll49P+GTOVtQqVQMeb87Z84uoU6dKkW6x4A3pL+5O34+Vui5dvYlZ3G6d0+q36QRTlZW5jpZe+URjYXpzhl/EqKiDY65/t9xed+tRjUA4iMieRL40OB4v1YtSvgpyyalLpwGDBjA8uXLmTdvHk2aNOHYsWPs2bOHKlUM/0f08fFh9+7dHDt2jCZNmjB//nxWrFhB//79dcbFxcXh7u6us6WlZQc0Fva+AoFAUJFo0qQapqYmhIXF8PhxtkVCpVLx+efb6dZ1FqGh0dSvX5Wz55byzjudC7V+7dqVadjQl/T0DP7443Shn08jbNLS8q8Onh/37mksTtkuurLmrjMyMirwWBOFAt8mjQC4c+Y8yXGGrX2X9/8r73cfOQQAOxfnXOs11WwthBM8BeE0efJk1q9fz/r16wkICGDSpEk8evSI0aNHGxw/atQogoKCmDRpEgEBAaxfv54NGzYwZcoUnXFqtZrw8HCdrTj3FQgEgoqEJjBcY23KyX//XaVJ4wkcOHAx23W3YQJWVgVz3Q0YIFmb9u+/VCR3m3bF7+ISERFHYmKKzrmy5K7rPX4Unx/fh1t13wKNr9qwHmaWFsRHRhF+L1Cu15ST9OTswPuaWtakas0a8+j6Tb3x3vXrYmVfdn5upUWpCieFQkGzZs3Yv3+/zvn9+/fTpk0bg3Nat26tN37fvn00b94cU62KpzY2Njx48IBHjx6xa9cuGjduXKz7CgQCQUWiRVZg+LlchBPAkyex9O41lzmzfyIzM5MhQ7px5uzSArnuNNl0RXHTAYSHSc1j3d0rFWl+TjRWJw1lyeJUv0sHLO1safXaywUa75dVLfzu2fMYm5rwwv/6GRxnambYXelazYfQ2/cMXitobajyTKkKJ2dnZ0xNTfWsQeHh4bi7G64X4e7ubnC8QqHA2dkZgICAAN577z369evHwIEDSU1N5cSJE9SoUaPI9zUzM8PW1lZnEwgEgvJKC63A8LxQqVR88cXPdO82m9DQaOrV8+bsuaW8+26XXOfUq+dN3brepKVl8NdfZ4r0fGFZwsnVzaFI83OiiXPSUJYsTppst0bduxTIZacRN3fP+NPspV44enoYHGdhY1g8Onl5EPU4u1J40NUb8n7N1i0L/NzllacSHK5Wq3WOjYyM9M7lN177/JkzZ9iyZQtXrlzh+PHjDBgwgNu3bzNu3Lgi33fmzJnEx8fLW3CwKC8vEAjKJ5Uq2VCzpheQv3DSkNN198OmSbm67t7Isjbt2XOe+Pii1WEKK2GL0/0yanGydrCX257Yu7nkm9lmZmlB1Yb1Abh3/hLdhr8nX7t1QjfWzNLO8M/Axacq6amp8rF2/aYmvbsX6vnLI6UqnCIjI1EqlXpWHldXVz1rkIawsDCD4zMyMoiKijI4R61Wc+7cOfz8/Ip83wULFmBnZydvXl5eBXpHgUAgKGs0by79rbx7N4SYmMQCz9O47mbP2pyn6664bjqAsLBYoASF031d4VRWLE4526A06tk1z/G+TRtjojAl6nEIVRvUw9m7snzt4p4DHN7wU/baWZaspJhYnTVcfavi4J7dty7sXiARDx8BYGFjjWNl3bY4FY1SFU4ZGRmcP3+e7t11FWr37t05efKkwTmnTp3SG9+jRw/8/f1RKnPPrmjcuDGhoaFFvm96ejoJCQk6m0AgEJRHsgPDC2Zt0kalUjFv3g45607juhs8uCvGxsZMnvwKNWt6kZKSxt9/nyvyM2ZbnByKvIY2ZTXGSSNulBkZADTs3hkj49w/uv2y3HT3z1+k24j35PMZaWlcPXSEwxuzhVObN6RsdXMba501nKp44dMo27LlXKUyF/cckI8ruruu1F11S5cuZdiwYQwZMoTatWuzdOlSvL29Wbt2LQDz589n06ZN8vi1a9dStWpVlixZQu3atRkyZAhDhw5l8eLF8pg5c+bQo0cPfH19adSoEevXr6dx48bymgW5r0AgEFRUWrTMim/KIzA8P44cuUaTxhPYv19y3W38YSLKzD9ZvGQoIFUjz5nJVhjCw2MBqYRASdRc0o9xKhtxrJWy4pMCjp0kOT4ee1cXfJs0zHV8jRck4WTt4KDTX+7GkROkJiaRFBunN8dUoQAgLTmFtOQUTBUKqjasJ1/3qFmDG1o1n+q2r9hJVqXecmXHjh04OTkxZ84cPDw8uHbtGn369CEoKAgADw8PvL295fEPHjygT58+LFu2jLFjxxISEsL48ePZuXOnPMbBwYHvvvsOd3d34uLiuHjxIh06dODcuXMFvq9AIBBUVDStVgoa35QbT57E8vprC4iL36FzfuWKXUyc+H2x1o6LSyI1NR0LCzPc3Bx4+PBJsdYLCopAqczE1NQEgEqOZUQ4ZVmcIh4+Jjk+gZavvESjHl24f/6S3lhLOzu86tQC0IuF0rYY5UZMSCjK9Awq162lc96zZnUOb9gsH9fr3B4jY2PUKlVhX6dc8FSCw9esWYOvry8WFhY0b96cY8ey/d5Dhgyhc2fdwmpHjx6lWbNmWFhYUK1aNb799lud65MnT8bHxwcLCwvc3Nzo1asXp0/rF1jL674CgUBQEfHycsLDwxGlMpOLF+8Xa60XX2zBlavf6J0fOqxHnll3BaUkA8SVykyCgiLk47JjcZKEU0xoGJf3HQJyd9dVb94E46zz2vWWUhISuXnsVL73igkNI+KBftVwj1p+qNVqzv7+t3yucp1aeuMqCqJXnUAgEFQgNNama9cekpKSls9ow3h6OrLjlxns+nsOVau6EhgYTp/ec3FzfZv9+y9iZWXOxh8msvGHiQUumGmIks6s03bXOZYxi1NMSBh3TvuTHBePnYszvk0b6Y31e8FwjaWrh/5DqdVZw5C1CiAmNNxguxX3rMKb1/49Ip+ryHFOQjgJBAJBBUKu31SE+CZjY2PGjOnDjZtreO21tiiVmSz68lfq1xvL3r3niYiIo3evT5j1sZR1N3hwV86eW0q9et75L26A7Mw6hyLNz0ng/eys6rJncQolU6nk2r9HAWhsILtOuzhlekoqmVkJVRd36xaDPvfHPwbvFRMSxpMH+uEsUY9DALh9OjscpsM7bxTmNcoVQjgJBAJBBaJtu7pA4TPqGjb04cTJRXyzajR2dlacPh1As6YTmTFjk47lSq1WM3/+Drp2mUVISBR163pz5uxS3nsv7zR6Q5R89fCyZXEys7TE2sEekEQNwKUsd12Dbp103HW2zk64ZzXqBXgS+BATU1MSoqK5e/aCzrrxkZEYIjYsTM/idHTzz6wbMxmAjNQ0+bqNYyXMLC2K83plFiGcBAKBoILQrVtj2revh1KZyb//Xi7QHCsrc7788j38zy/nhRdqEReXxJjRq2nXdjpXrz7Idd7Ro1LW3b59F7CyMmfDxon8sGkS1tYF/7AteVdddkkCc3NFoZ7lWaCxNiXHx5OaKPX7u3PmnOSuc3aimpa7TtvalJacTEJ0NACX9h7Ua9qbmWG4tE9MSBgRD3UtTn8uWq4jpo78uE3e923auAhvVfYRwkkgEAjKOVWquPDGG+1Z/vVwAFZ98zeBgYaLAWvTu3czrl1fxdRp/8PU1IQdO45Tt84Y1q7dg6oAGVUREXH06T2Xjz/6kczMTN59t0uBXXfGxsbUqy+l09s7WOczumCUtZIEmlYpGmsTgEqZydVDUqyRdjFMPy3hdO6Pf2RRdSGHm65y3VrU7djO4P1iQsPJSE0jLlwKot8wfpremBtHTsj7TV/sUaj3KS8I4SQQCATlnB2/TGfb9mnUretNREQcc+duy3O8u3sltv88nX92z8XHx42HD5/Q96XPePONLwkNjS7UvdVqNQsW/EKXzh8THBxFnTpVOHN2KUOGdMt1jkJhytZtU+U4qs0//luoe+ZGzurhz7u7TjujThtD2XU1shr7pqekEvEwCHMrK6IeBxN05bo8z9jEhBFrlxuMT8pUKomPkFx4YXelBr/W9vZ64zRjAJr37V3kdyvLCOEkEAieGUOGdKN3b9FtvTSpVs2dF17ITh3/aOaPxMUlGRxrZGTEqFG9uRmwhgED2qFUZrL4q53UqzuGf/4pehVwgGPHrtOk8Xj27j2PlZU56zdMMOi6s7AwY+fvHzFgQDvS0zMY8PpC9uw5X+D72Do70axvb4yz6jVpk5CQQkREdgHI0rY4eTeoy7DVS/IsWJkXsnAK0RVOd876kxQbh62TI9WaNcbRywOnrDYoJ3fsxC9LRF3crVu7ybWaD9aVHAzeKy48QnbpaQLEtQtoanN86y/yvo1TybhRyxJCOAkEgmeCs7Md6zdM4I8/Z+Ht7fKsH6fc8tprbXWON248aHBc/fpVOX5iEavXjMHe3pqzZ2/Tovkkpk3bSHJy0coW5CQyMp4X+3zKRzM36bju6me55GxsLPn7nzm8+GILkpPT6Nf3c/74Q79GX170mTCKQfPn0KS3YTfS0woQ925Ql5HfraBO+za8MmNykdbQLkWgjUqZydWD/wFSdl2NlpJQykhN48xvf1E7q7J3TjddlXq1c71XTFj2PTQxTbkJp7N/ZNdzqtu+rcEx5RkhnAQCwTMhPV0KUFUoTPnoowHP+GnKBkZGRrz1Vie5pEBBWPjle/L+zZuP9GKTLC3NWbBgMOcvLKd169rExycz7oO1tGk9lcuXA0vq0WXUajULF/6aw3W3hLFjX2T/gc/o0qUR8fHJ9O71Cfv3Xyz0+hY2Ug86rzo1DV6//xRKElSuW5sRa5djkdUDrnLdWlRr3qTQ6+TmqgO4vF9yXzbo1kked+qXP/Bt0hBThYKQ23cJv6f771elXp1c76UtzjTCycXHcCxa8M3sUha9J4wqyKuUK4RwEggEz4T4+GQysrJ7hrzfTVidCkD16u5s/ulDjp9YxDvvdM53vK+vm85xzoDwHj2acPXaN0yf8RoKhSm//nqCunVGs2rVPwUK/i4O2q47S0tzVn4zilatahMVFU+3rrM4dux6/osYQNMGxM3Xx+D1+6VscfKqU5OR33+NpZ0t985fxP+vPQB0fPfNQq+Vm8UJ4O658yTFxGLr5MijazfZPHU2fy9bJVvabp88i7WDvc5Wu13rXO+VnpKKlb0dVvZ2JMbEAlKzXxNTw53ZIoMeA2Dn7FTo9yrrCOEkEAieGVFRCYBkdZo58/Vn/DTPP0+exKFSqVAoTNn042SmTu2f5/jvvh+nc+zhIcWjuLk58NOWKezd9xnVqrkTFBRBv76fMeD1hYSEFC74uzhoXHczZ2xCqcwkLCyGzp0+wt+/6D30NMIpNzeTdkmCkrY4edSswcjvVmBlZ0fgxSusHzOFQ+ukJvZ1O7bDqUrlAq9lolBg7yp9mTBkcVIpM7ly6D8A6nRow6W9B7F2sMevleS26/TeID47tldn08RBGaLNgFf5/Pg+Pj++j6k7f5KewdQUx1zm/L1slbzvVs2nwO9VHhDCSSAQPDMiI+Pl/SHvd6NKFWF1yov4+GQCAh7Lx18uGsLSpcMwMjIyOP7iBSk7SlMPycvLieHDe3Lj5hoGDepIZmYmy5b+Qb26Y/j77+IFfxcVtVrNl1/+iq/PUGrVHMm1a/otPwq1XpZwcvTyQGGh3+5FO8apJBv9uteoxqjvV2DtYM/Dy9f4fvQk0pKTeRL4kBtHT2BsbEyHtwvuknZwl6yF6SmpJEbHGBxzJctd17BbJ+xcXfjk313FfxEtIh4+Ii7ccHNl7d53HQcPKtH7Pu8YtsEJBALBU0AjnDIylJiZKZg58zXGjFnzjJ/q+ebMmdvUrevN/fthVKvmzsRJL+Pm7sCQ95bLcWMa5s7dyp9/nuHOnRDCwjfj6urAt999AIC//x1GjljFxYv3nsVr6BEcHFUi62i7GF19qhIcoNtaRrskQUlZnNyq+TBq3UpsHCsRdO0G342eRFpSsnz96OafqduhLS1eeZG9q74nJT4h3zUds+KWYsNyr7d19+wFkmJisXGsxCeH/pLPRz0OZuFLb8giEqDNG/3p//EUbp86q9NnLjNDyfTmHUGt1ltfbeCcBu3edy/078uOT+bn+07lBWFxEggEzwyNq+63304C8P7Q7sLqlA+aHnO3bwfz9luLychQMnBgR/7+5xNsbS11xiYnp3H+/F0mTuync37C+O9o9cKU50Y0lSRqVfaHvSF3XWhojNwixtHRptj3c/Wtyqj132Dr5MjjG7f4buREUhMSdcbcOX2OkNt3MbeyotX/+uWyki7Z8U2huY5RmJsbLC+w4q3hqDIzUavV8la5rpRR9/CqbuyYicIUCxtrnbGaLT+Ob/tV3jdU/qG8IoSTQCB4ZkRlWZwCbj7i0KHLstVJkDtnzkjCqWXLmmzdeoSXXvyMxMQUunVrzOH/FuDq6iCP7datMVeurmSGVvxY/1fnsXLlrlIP/n5WqNVaFicDwkmtVsuZdU5OdsW6l7N3ZUatW4mdsxPBAbf5dsT4XK1JRzdvB6DdoNcLJDI0mXLRBuKbNIz8foXeuZvHTxl07VXOKkXw6NpNvWu2To75Po8hDn73g7xfv3OHIq1RFhHCSSAQPDM0rjonJzs++1SqZv3+0O5Uruz8LB/ruebq1QekpKTh6GhLjRoeHDhwkc6dPuLJk1iaNq3OiZOLaN26Nj9unsz+A59To4Ynjx5FyPMzM8unYNKQn8UJst11xXHVOVX2YvSGVdi7uhB65x7fjphAclx8ruMv7j5AQlQ0Du5uNOyWf0ZkbsUvtbF31f9/krPoJYCZpQXu1X0BeHQ9QO+6bREz4xIis92rL0+fWKQ1yiJCOAkEgmdGVFSWcHK249ix6/z7r8bqJDLsckOpzORCVtC3piL4+fN3adtmGvfuhVK9ugcnTn7F2293JjMzk6+X/0m9umP5668zAHh4FM26UFbQbmjrmku2l6YkgaOjTa6B9Xnh6OXB6A3f4ODmStjd+6wdNo6krBT+3FCmp3Ny+28AdHx3YL73kF11eVic7p69oHfu2r9H9M551a6JsYkJcU8iiH8SoXfdzqXoX1SiHocA4ODmWuQ1yhpCOAkEgmeGxuLk7Cy5TD77VHJnCKtT3pw7K6Xrt2yZXeTx3r1Q2rWdJouqCxfu0eqFKUyatI7ExBRCs8oMaEoSlFe0Y3NcqlaRe7lpoylJYGJigp2dVaHWr+Thzqh131DJw50ngQ9ZO2xcrllvOTm543cy0tLwblAXn8Z5t2GRLU7Bucc43Tnjr3cuI02/ynvlrMKXj65LbrrUJN2WO7bORRfTf365TN6vKO1XhHASCAS50qpVLYYP74mxgQ+fkiDbVSe5TI4evcbhw1cwN1cwY4aIdcqN8+fvAtCgoY/O+fDwWNq1nUa7ttN4oeVkeRwgN+f19CxbFicThQJjk4IHHmtnkinMzWUBoo12Zl1hAsTt3VwYtX4lTpU9iXgQxJqhH5AQVfC6V4nRMVz4ex+AwUa7GoyMjXFwk8oR5OWqu3NGv4REjRb6vR+962cJp6z4poRI3We2cyp6Ecvr/x2X93uMGlrkdcoSQjgJBIJcWb1mDN9+9wEffVQ6rrP4pHQg2+IEyLFOQ4f1wMur4lUlLgiaOCVD8UqpqemcPHlT71poqGQVcS9DrjprB3s++XcXY39Yg6mZWYHm5Ax6N1RBXLcIZsECxO1cnBm9fhXOVSoT+egxa4Z9QHxEZIHmanP0p58BaNC1I45eHrncywkThSmZGUri8rhHXHiE3B5FQ+OeXfXGVZEtTlJ8U04hWtQYJw2BF68AcOtE4foKllWEcBIIBLmiif/4ZO5AOnVqUKJrm5qb8+aSRQC4uNjL548cucZ//10VVqc8sLGxACApKbXAc0LKoKvOt2ljrB3s8WncgJcmjy3QHHUO4WQoQDwwMEwWWAWxONk6OzF6/Te4VK1C1OMQ1rz/AXHh+rFCBSHs7n1unTiNsYkJ7QYZ/kLi6CkJqtjwJ3rvk5Pbp84CEJcVu9T0pZ46WXsWtjZyz7nHWa66nIVBi+OqA1g9ZAzze7+mY30qzwjhJBAIciUuToqFMDExYeu2qbi5OZTY2hY2VmAlfdu3sjKnfsfsPlqfzt0KwLDhPYXVyQDW1pJwSkwsmHAyNjUhOkGKfSlLweGetWrI++3fGkDdju3ynaOdVQeGhVN6upLHj6WMsPwsTjZOlRi1biWuvlWJDgllzdCxeRalLAhHNktWpxf698PcWj/GKq/mvjnZt3odu79ey8MrUn0mhbk5fi2by9erZNVvinocTFJsHABmFhY6axTX4qTKzCTqcXCx1ihLCOEkEAhyJS4uu/qxu3sltmydUmLxTsmx8aSrjMjM+pwb881CmvXtDUhWpyNHrmFurmD69P+VyP3KExrhlFxAi9Prc2bw9qqVALi7O5RazFpJ41nLD4DorCKQb37+MXaueRdI1dRxSktOAaDVay8bHKeJc8rL4mRdyYFR36/EvbovsWHhrB06Ls+Yo4Jy68Rpwu4FYmFjzQv99QtiVvKQLE4FuVdyXDzn/tpN3Y5t5XONtNx1VXLEN4EBi1MR6zhVVMrG/x6BQPBMiI2VLE7rvt9HYmIKXbo0Ys6cwnd5N4QqM5OkmDhSlZI70MbCmEHz59BtxHtAttVp+IheZS6gubQpjKvOwsaapi/1JA0FmZkqTExMcHEpXuHHp4VGOP0ydyGPbgRgXcmBtxbONZgpp0GVFdtlbpVdRV0jyLW5e0dKo9eI0JxY2dsx6vsVePhVJy48gjVDPyhRq8qxrFindoNe14s5KozFCaDD229gqlDIx8203HU545tMTE0xMdXttmbr5FihKn8XFyGcBAJBrsRnuerCwmIYOULqhj5r9ht069a4RNZPjIklJVP6M3TzwH4Aeo8byeufzODo8RscPaqxOolYJ20K46qr27EtpgoFaoyILUPuOgsba5wqewJSGv1P0+aQlpxMjRZN6Trs3VznaVcO1zBo/hw8albXObds2Z9s3HiQX37Rj8uxtLNj1Pcr8azlR3xEJGuGfUBk0GO9ccXBf9dekmJicarsSf0uulW3s9ut5C+cLO1saT3gFQAylVKvQlMzM/xeaAFoVwy/AehbmzTYOD7/vxPPC0I4CQSCXNG46uztrdm27QjffbsXY2NjftryYYl8+CZGx5CSKVmc7v13mJ3zFqPKzKTVay/z/sqvmL9AKhg4fETPMvFh/7SwtpY+/ApicWrQtZO8H5ckfbCWpgXPyNiYxj274pgleoqKR00pvik6JJSU+AQiHz7ity8WA9Bj9NBc6yDljHHSMHjpAixsrOXjmzcfMfT9rwkM1I1XsrC1YeR3y/GqU5OEqGjWDP2AiAdBxXoXQyjT0ji543cAOryja8UtjMWpzRv9sbC2JuT2XS7tPSifb9yzKzaOlXD09EClUvH45i0AFFnxTarMTFK0eurZFTNAvCIhhJNAIMiV2FjpD6udvRTAOnHi91y6dB9XVwe2bpuKiUnx/oQkRseQqpTWcHa248T23/hh4gzSU1Kp0641dYeM5eSpW1hYmIlYJy2srDWuOv1ih9qYWVpQu1120H1CmiQqSlOE9ho7nHcWf8FbC+cWax2v2pKbLvRWdi2q87v24L9rDyamprz15Vws7fRbpqhUmXrnQCqG+eYXs/O8p4WNNSPWLqdKvTokRsewdtg4vXT/kuTE9t9QZmTg26QhVerXlc8XpMEvSNajDm9L9aD+Xb+Z++cvydfqd+2AT2MpEzbiQRBpSdKXIE1geHpqqo4gtC1GLaeKhhBOAoEgVzQWJwcH6Zt6amo6A15fSHx8Mh071ufTT98q1vpJWq46TXbT9f+Os2boWBKioqlStza3TCUXy4iRvYTVKQsbGyl+JzExJc9xtdq2wswyO4YnKVOKYymtkgR12reRY9R8GjXAxrHo9/GsKQmnkNt3dc7v/GIxkUGPcfT04PVPZujNM2Rxunf+Isr0dBp07Uin9wz/zppbWTF8zTKqNqxHUmwca4ePI+zu/SI/f0FIiIzi4m7JRd0xqyCmdSUH+d8sNuxJnvNbvtoXG8dKRD0O5vK+QzrCycrOji7vvwPkCAzPWjsjNY0nD7JFYXEz6yoSQjgJBIJc0ZQjsLfPdnHcvRvK8GFShtZHHw+gZ8+mRV4/MTqGlKzgcO0imEFXb7Dy7RFEPHxErKUbj+KNimV16t+/DQcPfVFuhFdBXXW12r4ASD9PgFSkeaXhqqvk6c6gBZ8A2UUoa7ZuUeT1bF2kD/LoHC1H0pKT2Tx1NsqMDBr16EKr11/RuW6o7lFaUjK/L5Rag7w4cTTVmzfRuW5macmw1UvwadyA5Lh4vh0+ntDb94r87IXhyI9Sm6GGPbrg4O4mW5viIyJRpqfnOs/Y1IROgwcBcHjjFlSZmTwJfKjT/qVqo/oAPLp+Qz6nMJd+BzJS04h4+Eg+X9xaThUJIZwEAkGuaLLq7O11a8388stxVq/6B4DNP31YoFpLCgtzvWwo7eBwJ2fdTK+ox8GsfHs4Dy5d42yU5JIZMaoP7u6Ft2IMeqsjXbo0YsiQboWe+zxiXUBXnTJN+uDV1B3KUEiWqpKuHm6iUPDuknlY2dvx8Mp1OWOsVptWRV4zI1V6N4W5fsXwxzcC2L18DQCvTJuIe41q8jXtXnW3TkqNjd2q+XD6lz849+dujE1MePurz+XGtmaWFgxdtZhqzRqTEp/AtyPGExxwu8jPXVhCb9/lzhl/TExNaTfwtez4pnwCwxv36oajlwcJUdGc+3O3fF5TxVubIC2Lk1lWcHhOV11xGv1WNIRwEggEuZLtqtOvdTN58jrOn7+Ls7Md27ZPwzSPdGaPmjX4/Ng+/jd7qs75xOgYUjP1LU4akmLjWDNsHH//eZLgJFMszE1ZuenjQr9HdFQCAJ06l2z185LGyMgIc3NFvuM05Qjyc9VprDWaTKpUI2leSbvqXp42Ae/6dUmKjWPzlFlcP3wMkCxemurzhSU9RbKmKSwMlws4unk7AcdPo7Aw5+1Fn2GaZUlRZWbHOPn/JQmKSp4emJqb89sXiwi5fRc7ZyfeXfwF5tZWvL/iK2q0aEpKQiLfjpzI4xu3ivS8xeFoVkHMVq+9LIvAvALDjYyMZDfc0c0/o9Rq7Hv/wiW98SFacWLZrrpUnfgtUcup4AjhJBAIciXbVadf3Tg9XckbA74kLi6Jdu3q8sUXb+e6TuvXX0FhYU7Ll1/SiXuRXHWaGCf9QF+Qso9+/PBjvt8mNTR9uVsthsyfkWctn5yEhUnui7Zt6xRImDwr1q0fT1z8z0yb9r88BUdBLU7RwVm1iio5kJacTFLWz7okXZZNenen7ZuSC3XrzLnEhIbx4NJVUpOSsHVyxDMryLuwpKdIolA7RksbtVrNtlmfER8ZhYdfdV6eOl46rxXjdPPYKZLj4jE2NsalamUyUtPYNGkmKQmJ+DZtxPzTh/Br1ZzUpCS+Hz1JTtl/2tw8eoIngQ+xtLOl19jhQHbRT0PUbt8GD7/qpCYmcXLHTp1rgecv643XFlaa4PCM1DQig7JddXYixqnACOEkEAgAcKrshb2bblVmjavOzk5fOIFUfXno+ysAmDb9NV58UT+mxdjEhIbdOwNgojClSZ8e8jXtcgSGLE4a1CoVnw2fw9U7EZgaw9jhXRm8dH6uNWlyEh4eC4ClpTmtWtUq0JynTZ06VRgypBtmZgoWfvkef/41G0dHw2IyWzjlHeMU9VgSTk5ensRHRGkJp0pFtgRp4+pbldfnSgHaB77dSMBxqclrplLJ3bPnAajdtnWu8/NC46rL2R5Em8SoGLZ99CkgpeU36NZJruMU8SCIlPgE2aqiafYbGfSYXz9dqLPOutGTeXj5WpGesyRQq9Xs+GQ+GVoCJy9XXdehkrXp5I6dpGqVFAAIDrhNWnKyzjkTreKY2TFOqWSkpskCTQSHFxwhnAQCAdYO9mw+so51h9bpVDHWuOpMTU1yrbC8c+dJVq7YBcAPmyZSpYqu+KrRsqmOG6DlKy/K+0kxsTrlCPJjylgpKL2BYyqterZn9LpvsK7kkO88jXAC6NzZcP2fZ82HH74CwPXrQaSmpvPSSy04f2E5LVvW1Btb0Mrh2han9JQUkjOkn7VCYZqrha+gmFlaMnjZAsytrLhz2p99q9fpXNeIqFrtXsh3LWMTE6o3b0LlurUxt5JEumxx0qoAbojbp87x74bNAAz4dKbc+00T66MRTpqedSampnqVxDU93J4lgRevsO3jz+XjBl07Ghzn26Qhvk0bkZGWJrv4tFFlZuqJwJqtW8r7GlddepYw1cQ5ieDwgvNUhNPo0aO5f/8+KSkp+Pv7065d3o0aO3TogL+/PykpKdy7d4+RI0fqXB82bBhHjx4lOjqa6OhoDhw4QIsWut90P/nkE9Rqtc4WGpp3TQyBoKLyxvCX6VVNyf/qGfO/d7I/VNIzMsnIkIomakoSGGLq1A2cPXsbJyc7tv88DYUiu6VD417dAbi4ez/K9HQ8a/nhVVsSA0mxcSRlSK4Va2sLLCz0A4G1OXDgIidP3kRhDI1sY6naqD5Dli/Mcw6A2tpe3u/c5fkTTu7ulXjrbckqN2zoClq3msKdOyFUrerK0WMLGT++rzzW2NhY/jnlVzk8LSlZFgUKc3NUGBETJwkSjbvO1MyswJY7bV6bMw336r7EPYngpxlz9LLZNIHZPg0b6BSezIm7X3XGb/meMRtXM+nnjcw/c4g5B/+ix+ihALR983/UavMClTzdc7WS7Vn5LQ+vXMfKzo467drwy6cL2f21FDwefv8BIAknY1MT3l3yBXU7tkWZkSHPH7x0PmaWeQu0p8HlfYfk/ZqtW8qWWm26ZFVNP/fnbhIiowyuc/+CrruusVbvumxXnfS7o8msM7eyei5+BmWBUhdOAwYMYPny5cybN48mTZpw7Ngx9uzZQ5UqVQyO9/HxYffu3Rw7dowmTZowf/58VqxYQf/+/eUxnTp1Ytu2bXTu3JnWrVsTFBTE/v378fTUrVR77do13N3d5a1Bg+c7MFQgeFaMG5GdbbZk4SD5g3nIii/JQDLza5ckyEl6upI331hETEwirVvXZsEC6Y+7iUJBg27SN+eTO37n2r9HAWiRZXVSq1TERsfLjX4LYgX57NNtADR0SsVcnYZv00a4+1XPc061DtkfQC+8UBMrq8ILhdJk3LiXMDdXcPz4Dc6cucXly4E0bzaRHTuOY2amYPnXI/jl15nY2VnJpQigYJXDNVYn06zstNhESTB4ejpiZGTEh7/+yKx9v8s9zQpC69dfpdlLvchUKtk8dTaJUTF6Y6IfhxDxIAgThSk1WjbXu25sakK3Ee8x6eeNVKlXh5SEROIjIgH0XMYjvl3OrH2/M//Mv3z464+889Xn9Bw7nCZ9elC5bi1MFWb8NH0OqYlJVK5bC3s3VxKiooFsi5O7X3Xe/vIz6nfpSEZaGuvHfsgnnfoQ9yQC9xrVZJfjs0RjbdMwaMEnOhXSPWpWp26HtqgyM/nvh625rqNdzwmgXuf2srtOI5IzZIuTqOVUWEpdOE2ePJn169ezfv16AgICmDRpEo8ePWL06NEGx48aNYqgoCAmTZpEQEAA69evZ8OGDUyZMkUe8/bbb7NmzRouX77MrVu3GD58OMbGxnTt2lVnLaVSSXh4uLxFRkaW6rsKBGWR5s39aFSjEio1JGUYUdnNVm7k6+jlSbpK+pZfpYbhLzsaHjwI5/0hXwMw+cNX6dfvBWq1eQErOzviwiMIvHCZs39IJQyavthT/kOeqNXotyDuuv37L3LqVACWFmZUSw+U3sFAE1dtnkTEy/tmZgratq2bx+jiY2xsTLdujQsk0GxsLBk1ug8Ai7/KDvRNSEjhzTe+ZNwHa0lPz+B//2vD+QvLad++HgCZmZmkpWUYXFMbObMuK7YlPlWyDHl4VMLWxRlX36rYOFZi1LqV+DZtlO96levW5pUZEwHYvXwNgRf0g5E1BJyQ3HW12+mWJfCoWZ0JW9bTe9xITBUKrh0+ypf93uTTLn35uHU3lg8cKsdIAYTeuYcyPR0zSws8a/nRuFc3eox6n7e//JRJP//AgrP/MvaHNbJlq8eo9+k9biQO7m5EPJRcUR5+1WnUowvK9HQ2TpjB7VPnSIyK4ccPZ5GZoaRpnx60HfhseyJqShGkJCRy7d8jKMzNeX/lIlx8vAHkTLrL+/8l6lHuvfPun7/Ekc3b+eWzL4kNf4KlrQ212kguU+3K4QBPArVLEgjhVBBKVTgpFAqaNWvG/v37dc7v37+fNm3aGJzTunVrvfH79u2jefPmmObo6KzBysoKhUJBdHS0znk/Pz+Cg4O5f/8+27Ztw9fXN9dnNTMzw9bWVmcTCCoCs+dKlZQDYs05FCKVHZgytT+NG1cjNSGRtCzh9Nq0sblmOGn488/TLFv6BwAbf5hIjzclQXBp30HUajW3T50lLjwCawd76nZsC2gCxPPOrMuJxurUsZ49ViYqqRu8Se7lEMIfh6PU8iR1KWV33YIF77L/wOfs+CV/K8b773ejUiUbbt16zK5dZ/Wur1r1D+3aTufBg3CqV/fg73+kIpP5ZdRpiM4KENcIp8SM7Mw6R08PeZym3UheRSst7Wx5d8k8TM3MuHroCP9tyt3qAdnCSVOI09jUhO6j3mfi9o1UrluLpNg4fpr+CRvHT5fdTqmJSTy6doNTWX3c7p49z+L+bzOzZRfm936NdWM+5K+vVnDq1z+4d/6ibFlycHPVuXe3Ee8x+8AfzNilGwf02xeLuZX1XAAPLl1h19JvAOg3dbxcNPJZUCnr3yP6cQg/Tf+Eh1euY+1gz/A1S/FuWI/GvSTL8OENP+W5jlql4q9FX3P6lz+4sv8wAI16dgG0LU5ZrjrttivC4lQgSlU4OTs7Y2pqSni4bhPF8PBw3N3dDc5xd3c3OF6hUODsbLhA18KFCwkODubgwewGh2fOnOHdd9+lZ8+eDB8+HHd3d06ePIljLh2gZ86cSXx8vLwFBwcX5lUFgjJJnTpV6PtiMwB2nQnjWnA6t+PMMDU14ft140hPTiItS9R4eHvyxuez8l1zxoxNnD4dQKVKNkx5uxHGRmou7pH+b6pVKvx37QGg5SsvAZq2KwW3OAHs23eB06cDsLRQ0Mg2BjsXZ/xe0HcHaYh7EiFnlEHpxzlNnSal5/fpk/szAZiYGDNx0ssALF3yh07xRm38/e/QtMkE/vrrjHzOzs6KESN65fszi8ohnFLUkqXP09MRRy/p7/CDy1e5cfSEVAzym8XU66Qfh2pkZMTAeXNwquxJ5KPHbJ/9RZ73Bbjvf5GMtDQcPT1o3KsbE7duoNfY4ZgqFFw9dISvXhkktxzJSVpWHSdN3I0qM5Oox8HcPHaSIz9u49dPv2T1e2OY2+lFZrXtyYq3h7N91ucc3/pLns/k20T/3/7YTz9zad8hTLMKeRYk4aA0cJSb+4aSkZrGhnFTiXz0GKfKXoz9YQ3GJibcPH6qUAU6NXFT9Tq1z4pn0w0Ojw0Ll2tmiUa/BeOpBIfn/GNgZGSU6x+I3MYbOg8wdepUBg4cSP/+/UnTSuXcu3cvO3fu5Nq1axw6dIgXX5RiKgYPHmzwngsWLMDOzk7evLy8CvZyAkEZZlpWC5M7cWYc33eKwItXOBxqQ0JSGs2a1aBjLSvSskSNqTqDxj270mXou3mumZEhxTvFJaTiaaOihXW4Tn2cc39K7rpabV/A1tlJr9FvQfnsU6lVRSOXDMyNVTR/uU+uYxMio0jWEk7NmlXPtcRCSfLkSWye119/vR0+Pm48eRLL5s2H8xwbG5vEKy9/wc6dJ+Vza78dS0joj+w/8DnDh/c0+PPTxDiZZAXsp5tmVw/XWDie3H/IDxNmcHn/v5iamTF42QLZuqGh05C3qNepHRlpafw4+WO9NHhDpKekyvE273z1OV51apIUE8vmqbP5YeIM2VpkCI1FpCCB6ynx8Ty8fI1zf+7m9wVLWfLau7m2K8kZP6Vhx5z5PAl8iIObK28v+ixPC2ZpoWm3Ep1ViiAxOobvR00iKSYW0yzX9r/rNxdqzYdXrhEbFp7lrmupU8cJpM9VTT0n0ei3YJSqcIqMjESpVOpZl1xdXfWsShrCwsIMjs/IyCAqSjeD4MMPP+Sjjz6iR48eXL16Nc9nSU5O5urVq/j5GS7Glp6eTkJCgs5W3qjV5gU+2LRWTssVVAysKznIVZW1qVrVlbfe6gTAuUhL7pw5zz3/iyQrjfn1lPR/7dXWrliaSj6uu8ekatC9x4+kTnvDrnYNQUERbDwk/fFv42NK//7Z4yMeBPHg0lUpLfylXiTHxGCrkO5haVnwoO29e89z+XIgluamNHRMpUGXjnIqek7inkTqCCcTExM6dKhX4HsVldOn865C/eGUVwH4ZuXfpKbm3pdMm+++3Svv+/vfwdTUhG7dGvPtdx8QEvoj+/Z/piOiorKEk4YMheSO9fCohJOXlFATHRJKplLJT9Pm4L9rDyamprz15aeyVbB68yb0GT8KgN8XLC2UxSNAyy125cBhFr06iEt7D+YxQyK7AGbhM71Cbt1h1xLJ/aZdSRzAMpcwjLTkZH6YOIO05GRqtmrB24s+wySX8JDSQm63olU1PDLoMevHTSUlIZFbJ05z3/9iodZUq9VcPqBx13XVc9VBdmadcNUVjFIVThkZGZw/f57u3bvrnO/evTsnT540OOfUqVN643v06IG/vz9KpVI+N2XKFGbPnk2vXr04f/58zmX0MDMzo06dOhW6JEHL/n3xbdqI5v1y/2YuKF+4+lbl4707mbhtPRa2um1Tpkx5FVNTEx4mKgiOl2I97p27AECIZVUOHbqMmcKEytbS/7v4oAec3PE7xsbGvPXlp3LAqiHMra1Ir9IA/wjpQ2/9hvFUq5b9hejsH38DUnbd/zpXxd1KSUp6po41pSAsXSLFwTR0SMTc0oxGPboaHJcQEUmyUjeVvUuX/AOhi8uZPIRT584NadasBsnJaaxZs6fAa2rqaR0/foOWLSZTvdowZkz/QRZR3bs30RFR/+vdAHOj7L+dKZmSJcXDw5FKXlkxNVkB5KrMTLZ//Ln87/zG5x/Ta9wI3v7qc4xNTDj3527O/PZXoX4GZ3fu4sT239g0+SM2Tf7IYAaeITSupPzi6nLj+NZf2DJzLquHjOHav0fk85a2+u2DNITff8DmKbNRpqfTqEcX3lu+EFOzvEtklCQai1PO4pcPL1/j0y4v8f3oyUVaV9tdZ2UnCep0LeH0JCuzTtRyKhil7qpbunQpw4YNY8iQIdSuXZulS5fi7e3N2rVrAZg/fz6bNm2Sx69du5aqVauyZMkSateuzZAhQxg6dCiLFy+Wx0ydOpUvvviC999/nwcPHuDm5oabmxvW1tnp0l999RUdOnTAx8eHli1b8uuvv2JnZ6dzr4qG5j9FUVsgCMoevceNxNzKEg+/6gxeMg/jrH5yrq4OvD9U+oJyNsKSh1eukZ6SSnDAbVITk7Cyt2f2gl2kpmd/4NrbW/PHgqUEXriMpa0N769YlGt9nvqdO6AwN+e3U084ceIG9vbW/Lxjutzu5PK+Q6SnpNKsQWXe698YgJ9PxxIYaNgSnRvbtx8jODgKOwtjatun0byf4ey6+KjsqtkpWQKqtPrWmZllWynysjhprE0bNxwgKio+13E5yVk1PDAwnEWLfqNli8nUqD6cGdN/4Pz5u7KIWrNmNCPrxNDfJ476lVLRdCTx9MwODo/Rau+hVqv57fNFHPlRCsDvPmIIds5OhN65x855XxX4OTWkJiaxc95irhzI2xWZk/xarhSEC3/vI/DiFRK0xFrOLxA5uXnsJOs/mEp6Sip1O7bl/ZWLilTnqijk1eA3IzUtzxCXvAi6cp2Y0DAsbKyp1qyxtF6KlsUpK7POLpc4YoEupS6cduzYwcSJE5kzZw6XLl2iQ4cO9OnTh6CgrBRRDw+8vbO/uT548IA+ffrQqVMnLl26xOzZsxk/fjw7d2an6Y4ZMwZzc3N+++03wsLC5E27ZEHlypXZtm0bt27dYufOnaSnp9OqVSv5vhUR26zAeK9aQjhVBKrUq0PD7p1RZWZK7ofWLXl15ocATJzYD0tLc+4GJ/I4ScHdM5LVVpWZSeAlqeKyqZs3m37PdoHXrOVFplLJpskfERv+BFffqgxaMNdgUcImfSRRdmHPQd58YxGRkfE0a1aDJUukooapiUkEnjhG7yoJmBgbcT3GnFtxhf+AzMhQ8s1KyXrV1CmF6s0b4+jloTdOpcwkOk76oIhOk8Rj48bVcHIqeExVQdG2rF29+sDgmHr1vOnTpzmZmZksW/ZnodbPbvCrX8Pp/v0wFi36jRbNJ1Gj+nBmztjE+fN3MTE2oqpNBt29EhlYXSqIaW6uwL2yFO+jybzT5q+vVugch98LlIOInwYZ+TT5LQyJ0dnCydIu/8zN26fO8v2YyaQlJ1OrzQsMX7NMr8ZSSWNqZoadiyRc8mrwWxTUarUsXDWxbtrtXcLvS2U98ipUKsjmqQSHr1mzBl9fXywsLGjevDnHsmIlAIYMGULnzrrVUY8ePUqzZs2wsLCgWrVqfPvttzrXfX19MTIy0ts+/fRTeczAgQPx8vLC3NycypUr89prr3Hz5s3SfdHnHE3bCzsXZ9EJuwLQe7xUcf/833v5adonqFQq2gx4ld4j3mbMWClZwj/GFjDSqZlz3/8i1qaZTB7Xi9d6ZPd169pVcm0lREWzcfx0MtLSqNepHT2zmpICfPPNKK5cW0XrTlKm3qW9BwkOjuLdd5YCMGbsiwwYIGVsvdbEEluFipg0Yw6H2hQ5k+nbb/eQmJiCi2Um3tYZeu00NERGSlYdIyA8Qfrm3qlTyaeea7dI0dwzJ5M/lKxNO3ee4v79wn1IFrRP3f37YXz55a+0aD6JSauvcDzMivAUE7R1rpW5KZkZSuIi9Gvc1enQVue4ca9u9MtqpPs00Ig0Y2NjgzF6hUE7CN1UoSiQFeu+/0W+HTGBlIREqjdvwojvludrrSoODu5SOYX0lFSSYmJLfP1LWlXJIdsVCvD4xi32rfqe3SvWlvh9yyOiV10FwdTMTOeblmdt/f5XgvJD9RZNqdXmBZQZGexbvY4bR46za7HU523G3Pews7Pi5q0QQnEkPSWVh1euA1LczYdv1GFYrRheaeWKUyXdb9kvvywVMnx8I4Bf5kqtTrqPHEKDbp0AeOPN9tSv582bfokYhd2Ta8Ts3XueBfN3APDd9+NYtmwY3TrWRqlSs/uRHRkqI6wd7IuUyRQbm8TGDVKwcTPnlFyLYYaFSVYHK1MVIemW8vuWNPk1Efb0dOStt6Rq6ksW/17o9TWVw5MLUDVcQ8D1QM5FWrH1XiU23K7Eut+usnD5XuIzjIkJC9Nrl+Lo5cGgBXMAOLZlBzvnLwGg47sDeW3O9BJpEJwf2jE45sVw1wF62XsWBazT9/DyNdYO+4Ck2Dh8GjWQeiM62Oc/sQjINZxCSicON+jKdZ21M3JYD/ev3aDT8kWQO0I4VRBsHCvpHHuJOKdyTZ8JUgbU6V/+kOMljm7ezvk//qKZi/QH8+D1RMCIsOtXGTOqF9dvrObQv/Po3b0BxkbwOMmUT1cd4+vrTvx7S5qzavUoufXK+b/3ynEwA+fNxt2vumwNsTRVM7KdlU6hyTlztnDkyDXs7KyYMFGqXbT+9+s8Sc2OCSrqh9Ly5X+SmanCxzaDWn7uOm0qNIQES5mCVqZqHiVKsValUc+pVevaeV4fP74vZmYKjh69xtmzBc9O06D5GefXp06baK3Murh0E/acj+S3Q/cAIzkwXINJVi0jKzs7Hl6+xq7FKzmx7Ve2z/4CVWYmrV9/hTfnzS71dH21SiW7k4rrrtN21UHeAeI5eXzjFmuGjiUhKprKdWsxesMqbJwq5T+xkMiB4SXsptNGUwwTdF11gsIhhFMFIadrzlPEOZVb6nZsh0+jBqSnpHLwux90rjlHXcfKVE1cujFODVvQzTOB+QOr8PWKEdSpU4WEhGRWr/qHz399xC+BDtyKNUOlNuLYIxNu3w7G09OJuXMHyuv9vXQVt0+dxdzKiqErvpR73IUkm2JpoeCf3XN55RXJSpWZqWL4MN24mVkTv9E5tnYs2gdSYGC4nJHXzDnFYJD4o4fSB5KZiZrwFFNUajV16lSRm92WFI0bV8v1mq2tJSNHSc+m3V6lMNjYSNaygvSp0xCVQxzZOjvhWFkqRRCT49rL0yZQpV4dkmLj+HHKLDKzspnP/fEPW6Z/QmaGkuZ9e/POV5+Xerp+ulwEs5jCKYfFKbeSBLkRevseq4eMIS48Ag+/6ozduCbXelBFJa/A8JLi8v5si5K2RU9QOIRwqiDY5BBOXhXEVbdy5UhCQn+kalXX/AeXA4yMjOTYpmNbdui4KBQKU2bOkHpx2ZupGFQjjgaOaViam3Lt2kPGjF6Nl+d7fPDBWo7ulypUawS2wsqGyZPWATBwUEeMjaU/HarMTDZPnU3U42DcvLODsr/+6xG//XYSc3MFv/w6g/fek8oETJ+u2wusR/sa3DufXZfGphgVm5cu+QOA2vZptH2pi15cTFhQKBlZHikTIwhPkt6hU6fSya6Lj0/WOzdsWA/s7a25efMR//zjX6R1rbJcdYURTtGPdDsh2Dk7yRl12u6bpi/2oO2b/0OlUrFlxlxiw3SzHC/tO8SmyTNRpqfTsHtnhqz4stjxR3mhqTVUlFpO2uR01RXG4qThSeBDVr03muiQUFx9qzL2hzWy2CkJcitFUJIEXb1B4IXLxISGERNauAxWQTZCOFUQNBanR9elAHnnqlWK/S3ueee119oy9oOXcHevxOuvt81/Qjmgce/ueNasQUp8Aoc3Zvez8vFx49Hjjbi5ZVt0MtUQEGvG/B33adRwHGvXSkHWgFxkTyOwzW2sOXDgErGxibi6OtCyZbbFMjkung3jp6NOk+aq1XBq137efONLNqzfj4mJCRs2TmTrtqkMHdYDlUrFsWNSTNW3340l0j+7dlNOl3JhOHPmFidO3MTEGFpVNdFrG6JdPdwoJZ7gFOn3v7T61uUsRWBqaiK7KPNqr5IfdlmuUp8WLeTyEvkRFxGJMiO7IbCts5P8oa8RTm7VfHhtjtRb7+B3P+j0c9Pm+n/HWf/BFNJTUqnTvg3DVy8ptYyzkrI4pcQn6Ly/pX3RepFGPQ5m9XtjiAzKboPi7F25WM+mwVDxy9Jg9dCxzOvZH6Vw1RUZIZwqCBrhFHrnHnFPIjA2Nsbdr/ozfqrSw9XVgdVrxsjHHTqWjlWhOFhamuPj40arVrV4+eVWjBjRi9mz32TVqtH88utMjh77klu3vyU27mdu3/mW9u3zrnRtbGpCr6wMt8Mbt5ASn4CDgzW//jaT+4HrcHV1kMeu/+0y6245suexHZZ1W9Lzg+E6awVduym3ZAAps8lYYcbevVKBzL59W+qMD7tzj73LpODzDJURNo6OZGaqGDZspeySevPNDgAsmP8LnTt9xL//XsbGxpIlM7tjmSm177BxdKA4aApiNnJMpU1/3UKv2tXD4x/c4VFSycc5aQdN5yx+OWBAO7y9XQgLi+GnnwpX00ibKjUlV2C1Nq0ZtW5lgeJt1CqVjiXD1tkJR03V8MehmFlaMnjZAsytLLl9+hz716zPc73bp87x3aiJpCYmUaNls1LLOCsp4QQ5ShIUo4l7TGgYq94bTfj9B1TycGfsD2twq+ZT7Od7GhYnkEpzFFW0CySEcCoH1OvUDo+aNfIco/njmhgVTcitOwB41Sq/7rq1347F2dmOkBApILh9+7qYmDzbX/dXX23NkaMLuX3nW+LifyYp+VfuB67j5KnF/P7Hx6z9diyffvYWo8f04X//a0O7dnXx8/PEzs6KGjU8OXDwc4YO7ZHr+i1f7Yuzd2USoqI5tmUHTk52HDw0T6fdCUAlhzc588SSZKUxwTel4OTuI4bopPFnZmTw4LJuGyMLW2v+3nUWgJdyCCeA8IAAADJUUqZdlXp1AJg2bSMzZ0iFZ//77ypz525FpVLx5huLuHbtIV6ejrzmE4edIhOpWEDR+fPPMwQ+iMDCVM2rfRrpxPbFR2Q3+k0LDyY42ZRMlZpq1dxLzJXr6pod3H7unG7g95Sp/QGpvUpaWgZFwdrBHrfK0gdsWnom1Zs1YdL2jVSum3dAOugGiJtbWeKkiXEKDeX1uTNwq+ZDXHgEW6Z/opdlZ4jAC5dZO2wcyXHx+DRqwJj1q0q8Oa6mCGaJ1HKK0hZOxRN58RGRrB4yhpBbd7BzcWbMxtXFihs1MjbGwU36HYypwN0tygpCOJVxHNzdeH/lVwxbvSTPcZoPkISoGIIDsoRTnfIpnN5+uzOvvNKK9PQMXnrxM+LikrC3t84zaLe0qVvXm23bp9K+fT1q1PDE1lZybaSkpBEYGM7p0wH8+edpvv9uL198vp0Pxq7h9dcW0KH9dOrWGc3PPx/DzEzB9+ukVP6cItDU3JweI98H4OB3G7G3MePQv1/QtGl1njyJ5fZtKcZlwfwdJCSlytWDt836XA4gH/DpTHybZrchydkTy8LGhj17zqNUZtKggY+e2HDxko6Vakn8vPf1Qvn37ssvf6Wy12C6d5tFZqb0oRwZGU+3rrO4efMRzvbm9HZ4SKh/4Vqu5ESlUrF08W8ANHdJo9mLPeVrCVHRJGVkNSzOSCZDZUx4ihTc3LmEqoi7uGQLp69XjKRpU8mq27VrIxo3rkZSUipr1xa8vUpOOg15CzOF9A7bP1ssNaV1d+ODH9fmWr9KQ87sOQBlRgb1O3egaZ8eZCqVbJ46Sy8DLS8eXb/J6vfHkBAVjVedmozZsEou4lgSlFSME0BCdHacU3EsThoSo2NY/f4HPLp+ExvHSoze8I38ZaGw2Ls4Y6KQamrFR0TlP0HwTBHCqYyjMY87uLkarJisIVs4ZVucymNmnZeXEytWjgDg07nbuHTpPkePSvE0HTuWfLHDgmBsbMy69eMwM1OwZ8952rebTk2/EdjbDcDa6jWqVxtGm9ZTefWVeYwcuYo5c7awevVufvvtJMeP3yAg4DED31zE7FlSV/QJE1/mn91zcXDIrvLb9o3+2Lu5EB0SSuCxoxz+bz4NG/oSEhJFp44zuXdPMv/fuhWMd726mFtZkRQTK7nYvvmOy/v/xVShYMjyhThV9gLgnp5wsiYmJpETJ6Q4uZzuOmcPSTilpqsIv/8ABzdXBi+dL2dehYREy6JJw5MnsXTt8jG3bj3G082OfXvmUrly8T54N248SHxiGg7mKt4d2Vc+r1JmEpcouR+dnWx4EviQR0lSFmDnEupbp/k5A/j6uuF/fjl//jWbn3dMB2DD+gNERxetgbitkyPtBr6OmbHkZnl8N4ivBw3l+n/HUZibM2j+HF6eNjHXuKfoYP3q4KYKhVzU8p9lqwm8eKXQzxV6+x6r3htNbPgT3GtUk4KmPUomaDpN46orEYuTtnAqGbdiSnw8a4eNI/DiFazs7Bi1biW+TQrv+tXEN8WGhxfI2id4tgjhVI7wbpB7DIwm6DYxKlrubO5Zs0ap12J52qxbPx4HBxvOnLnFokWS5eHokWsAdCyl7Kn8+OCDF2nVqjZxcUkMH7aCEyducPduKAkJKYVaZ968Hfyv/3ySklLp0aMJp04vxs/PE3NrK7oOexeASzu2c+jgZ9St682jRxF06jiTgIDHWFllFU1MTqPGC1JV77vnLqBWq1Gr1Wz7+DOCrt7AupIDQ1ctxsLWhodXb6BMT5fvb2Ejfdjk5q5zcnWU77FxwnRSEhLxbdqIV2bm3Zg0LCyGrl0+5u7dEKpVc+fQv/Pw9Cx6iYDk5DTZqtOjUSUdN3ZkVBIAHp5O3D51NjvOqYQsTk5O2ZaMn346TGZmJn37tsTRUTp/6lRAkdfuMvRdzCwtMMqU3HxJSamkJiaxcfw0OSapwztvMPLbrw26zAy1VQGpOO7VQ0fkmlxFIeJBEKsGjyLqcTDO3pUZu6lkgqZLol+dBh1XXQHarhSU1MQkvhs5kbtnz2NhY83wtcup0bJZodbQNFsu7fgmQckghFNZRyvIz7th7sJJtjhFxxAV9Ji05GQUFuYllhHyPDB8eE969mxKSkoa7w1eLls3/vtPitXp0KGenEb/tKha1ZV58yVRM33aD4SEROczI29+//0U7dpOIygoglq1KnP6zBImLRiPdSUH0kIfsnxmd2rW9OLBg3A6dpjJ3buSe0ZHOGX9Ub9zJjsdPiM1jQ3jpxEbFo5bNR8GL52PKlMpVxSH7D5Wu7KEU6dO9bG1zXahOLpIv2MpKelEPAjip+lz5DYvrV5/Jc/3CgmJpmuXWQQGhuPn58mhf+fh5uZQ5J/T8iU7yVCq8LRWMuiDN+XzTyKkPm1urg7cOnmWkGQFykw1lSs74+fnWeT7afDwkL6gBAVF8O47S6lTe7TO9a3bprJn76e0zqdIZk7s3Vxo84bUpsVYSziB1Ids3+p1bJwwndQkKVh74vYNeq74nLWcNEQGPWb77C8K9TyGiA4O5ZvBWkHTm9biXqN47nFNgoKZVQm46qJK1lWnTXpKCuvGfsitE6cxt7Jk2Kol1G7XqsDzn0bxS0HJIYRTOcK7fl2D541NTeRvoIlR0ajVakJu3QXKTz0nX183liyVGsh+/NFmbt16DIClnR3RKks5zqlRI9+n+lxrvx2LtbUFR45c4/vv95XImpcvB9KyxWROnLhBpUo2fPFBWzq5J/Juw0yqV3fn7t0QOnaYyYMH2XVaNMIpTanCp7FkXdHuTwdSuv66sVOkhsCtWtD/oyk67jqNcLp9O5jbt4MxM1PQo0cT+bqDsxTfo/lADzh2ij0rpD6T/Wd+mK8L49GjCLp0/oiHD59Qq1ZlDv07TydmqDCEhcXwzwFJ9L33xguyZTU0q3q4s7MN985dID09k9AUyV1XEmUJPD2dAOSkhJSUdDIypAKSly8HkpGhpGfPppw4+RX7D3xOu3aG/8/mpNvw9zA1M+PuuQtYWkiuz5yVw6/9e5QVg4YR8SAIR08Pxv34HU1fzE4mMOSqA9g0+SNSExIL96K5EP8kIjto2tmJMRtWUblu3i1o8kK2OFkUv1aUdoyThV3JZwBmpKaxftw0rh0+isLCnCErFlG/S4cCzX0axS8FJYcQTmUc7bTSynVqGYxvsKkkfQtWZWaSFCt945bjnMpB6xUjIyPWb5iAjY0lR45c4+uv/wLAu0Fdpv2xhQ9+/I4LV6Xg6NJo6pob77zTmZ49m5Kams6I4StLNAVYExt08GwwxkbQxDkVTzc77t8Po1PHmTx6FKEzXiOc7L0qozA3Jy48Qu4jp03o7btyQ+DWr7+iI6wtbbI/bDTuur79XpDPOVSyAyAxIbvw47/rf+TS3oOYKEwZvGyBnDmUGw8fPqFrl495/DiSunW9OXDwc5yc7Ar6Y9Hh04+kgp11XKBz/24APH70BIBKdpakJSfz4MpV2V3XqQT61mksTqGhkltowoR+KBSm/PffVZo0Hk+tmqP4/ru9ZGQo6datMUePfcmhf+flGX/n6OXBC/37AfDvt+tRZHW3N1QAM/z+A5YPGsqNoydQWJjz1sJP6TtlHMYmJiTFxJKalKQz/s4Zf/lvQUmhCZp+eOU61pUcGLXuG4MtcApCegkGh5dkVl1uZGZksGnyR1zadwjTrNY1jXt2zXee41MqRSAoGYRwKutofRgrLMzxNFCWQOOmS4yJlQMPNXFO5cHiNG7cS3Tq1IDExBTeH7IctVpN0xd7MGbjajnD52GclInU4SkFiLu42LN02TBAClK/c8fwt/3iYFmpEg+tdYVvRoaS9HSl3lgrK8mq4uonjb9zNveq1doNgbWLSHrUyv7d0rjr+vRpLrs/7Rwk90d8nO6H889z5hEccBtbJ0fe+3phvpWm798Po0vnjwgJiaJhQ1/2H/iMSpUK/0F3+dJ9Lt6OwtgIpkwfAEDQfUlAW5qbYG1twe1T53TinIrbvFYTmxUaEo2dnRUjRvYCsturPHgQzsiRq/CrMYK1a3aTnp5B584NOfzfAg7/t8Cg1av7yPcxUZhy68RpntzOLnGQW+Xw1IRENoybxoHvNgLQafAghq9dhrWDPcq0dJ2xe1d+V6z3zY2U+Hi+HT6ee/4XsbS1YcS3y/F7oXmh10lPlt6xJMoRlKarThuVMpMt0z/B/689mJia8taXn9K8X58852ga/ApXXdlACKdyRhUD7jpNuxXtrJKQgPKRWVezphcLFg4GYOqUDTx48ITe40fx1sJPUZib8yTwIQCJtlKmWIcO9Z9KnNPXK0bg5GTHxYv3WJJVlLEoOFetwpCvFzLp5x9w9a2qc23oJx8wsJZugHmtWpU5c3Yp9evrjtVYnNzrSL8fOd10OTm6eTunfvlD51y9Tu3l/RMnbhIdnYCzs50cr2NjJ5VYiI/Tdfukp6SyccJ0kmJiqVKvDq9/Mj3PewPcvRtK1y6zCAuLoUmT6uw/8LlOFmFBWbzoVwA6N3bFvYobYY/C5LYrbm4O3D55hrAUU9IzpaKp9ep5F/oe2mj63oWGRjN8eE/s7Ky4cSOIPXt0f95BQRGMGbOGGtVHsHrVP6SlZdCxY30OHprH0WNf0r275AJ1rlpF7ru355vv5Qa/qanpehmK2qhVKvau/I4fJs2UXa+Tf9mkV5k9Khf3XUmQlpzM96MnEXBcivsZumoxddq3yX+iFtnlCEq2AKa1g32xRXJeqDIz2T7rc079+gfGJiYMnDeb1q+/mut4B3c3wHDJCMHzhxBOZZyc7p+qBgLENRan6rZpXLn6DY0a+RJ69z6qzExsnRxLtO7K08TExJgfNk3E0tKc/fsv8sPmo7y3fAHdhktC6tC6H1n5zghUmZkoHauQkJBCpUo2NGzoU6rP9dJLLXjzzQ4olZkMG7oSpTKz0GuYW1nx4qQxTP19C/W7dKRy3VqM2bhaDrbt3Kc1nw9vhpWpmqs3gnF2GkTdOqO5ezcEX183TpxcRD8tN5pGOLnUkKxGd8/kLZwAds5fzO1TZ+VjbfeGUpkpi4G+fVsAYJNVmyo2Ok5vrZiQMDZ9+DGZSqlBbId339Qbk5Nbtx7TressnjyJpVmzGuzd9xl2doVr7bFt/d+ExGViZgKz5o8gPiK77YqbmwOPrgeQGJdASLLG6lQ8d51HlsUpMjKeCRMl99qSxb/n6qZ9/DiSDz5YS/Vqw1i5Yhepqem0a1eXffs/48TJr5iyaBLGJsZcP3yMR9duYGMjCYiC9qm7evA/Vrw1nMigx/KHszY5m9+WNJqkg6uHjqAwN2fI11/SsEeXAs93qiJ94SmJ7N+kmFid45IIOM8LtVrNr59+ydGffgbgtTnTaP/2G3rjbBwrYWZpgUql0usNKHg+EcKpnGGoJIFtVtXw1tUtqF+/Kv37t0GZliZbY8pqnNOUKf3lNP8PP97GB5u/pX6XjmSkpbFl5lx2f72G5Lh4gq7eQI0RV+9IcT+lWc+palVXudXL0iW/c/HivUKv0fTFHkzftZ0u77+DqULBjaMnCL4pubrGbFhFn9e68tdv07A0VXM/LIUObT4kOjqBgIDHvNDyQw4evIStrRU7f/+IGTNew8zMFJOsDx6VsSmRjx4XyCWgUmay6cOPc72uXZbAu2E9rCwld2BMRKzB8ffOXeCvr1YA0HfyB9Rs3SLfZ7hxI4huXWcRGRlPy5Y12b1nLjY2hfvA2/zLOQAG9W9GSmy0XD3c3b0SapWKO6f9S6z9iibGqX2H+lSu7ExoaDRbtvyX77yQkGgmTPiOar7DWL7sT1JS0mjdujbTBvjxZrU40q8dB5AtTklJBe8zFnb3Pge+3WjwmtFTsL5mZmTw45SPufDPPkwUpryz6LN8i3UC1OnQlvZvSS7WC//sL/ZzqDIzdcRTabrrtPnzy+X8u/5HAF6ZPpEuQ9/Vua7JqEuIiCJTqe9mFzx/COFUTsjMytxxq+YjZz9p0LjqvJykP7q+1aRvnmW59Ur9+lX59LNBAHyxZA8DlizBs2YN4iOjWP3+WC78nZ3BpmlW+ihR+nDMWc/pzTc7kJb+O9eur2LFihG8/HIr7O0L7xZq3tyPU6cXU7myM7dvBzN3buHq4njVrskHm9by1sJPsf9/e3cdFlX2BnD8y5DSKig2tmssIvaaa6yN3YGxxs8uXFvXXWvtdm1du9bCFbsLG3sVCwUV6Zxh7u+PCwPjDEiIoHs+z3Ofh7l5LsNl3jnxnlz2vH/xitUDR7Fm4CiW9xnEizv3KJ7Pgt3bhmNhZoRvuBFN4jKjxwsMDKNJ4yksXXIQhULB9Bk92LrNXbNdpTZIUW1TvKjQMP5o3VXzOnGtxT//XEepVFG6dEHc183DOC4xY7CeGqd457bs5MrfB1EYGtLtj980yTaT4+39nAb1J/DhQyjVq3/HIY/JmgAiJeZMWUOY0gBbc0M6tK9JRFz28AKF5fQDjy4l9HOqUyd9TbnxfZw6d64NwOJFB/T2OUuKn18gI0aspkjhPhz2eodSDXnMVWxc+TNXrs6jVatqgJxWouUvw1MUfObInxfXMUP1bkvPpMqpoVbFsmXcr1zatQ+FoSGdp0+iWvukm65y5MtD5xmTADjz13a8T5z+LOXQ6ueUASPrknJowXKOLF0FQNNhA/hpYMLckF9qcl/h8xGB01cuvgkgOiKCgFdyx9eP+zlZ5cyBqUKNna38YVOkiPygxs9T9rXVOBkbG7F+w3BMTIw5c+UZuVr1wjJHdl7de8jCjr14kSj3EMCDC5cBiLSV+6/UqlVG07+hSBEHVv45EGNjI0qXLsigwc3Z+/d43gds5tLluUyf3p169ZwwMzNJtkwtWlTh1OkZODhk59YtH+r9OJ6oqJhkj4lnbmNNmwmjGbZ9HYUrOBEdEYnHwhX80aoL98+cl8seEsq9jStoWSAQU0OJF2HGrL0YyaPr3jrnU6liGTx4JQP6L0WpVGk+bGPVEmoMPtm/6WN+j5/w/JZ8naIVE9IPBAeHc/WGXGtZOo8x0cFyH5KIiORrQ3ZP+4Pnt+9ibmNNz0WzMLX4dPPbrVs+NGwwkaCgMGrWLMP+AxPJli1lQ9QDfP04ev09AMOHuxIcLudBKuAoPwePLl7hbaQRUSqwtbWkfPm0pawwMjLUSp8QFhaZ5ulVjLLn4oHZd6y6b8uSlccIC4ukYsXijBsv18CY2GSnZpf29Fk6L/nzmJjQfe7vmFtb8/yWN/M7uGlt/5I1HJJazc6pMzmzKa7paqI7dXp01tnPMG40WnyZD85d8tnK8KU6iOvjuWItB+fJ99Kwfy+ajRgEJJ7cV/Rv+lqIwOlbYQAv7twD5GH4iVnlzEFOs4R+NprASVPj9HUFTuPHt6dChaKEhMdw37oCRsYm3PI8wVK3/gT5v9XZ/6X3fSKCQwhWWBMWHk2OHFaUK1cIIyND/to8Eisrc06f9qZtmxksX+bBgwevMDQ0pHLlEvwyth1Hj/1GYNA2jp/4nfHj21O1akmtueIGDmzKnr3jMDc35fDha9SqOQZf30/PN2WgUFC9Q2vGHtpJ9Q6tUSgU3PDwZFaLDhxfvUEra3e9ek7s3T0GU2MFz8OM2ffcGkuHPJo55/RZufIffmo4iYCAEABUklzm1AZOAE+uyfmcEgdOBb8vQ3guOUdPHgJ4Fzfi61PNSKqYGNYPH0vIu/fkKV6UMfu3Uall0082G12//oRGP00mJCSCunW/Z9/+CZ8MaOMtnr8bpRqK5Lchh4kcOOXLbw/IGbXfvfDFNyJ9+Zzq1CmnVVu1ZrUnQUHhyRyRtPgaiQsHjjGk/0IKO/Zh5oydhManerC0BcAwLjVBUlzHDKNA6VKEBwaxcdQE3vokpKC44eGp0+/nS9g3e4FmfsTmowbTcEBvre0txwyjQJnvNGX+nMGd1rQrnzF7eEqdXLeZvTPkYLduzy60GjdSM1WWqHH6eojA6SuXuNNpUoGTZc4c5DRNCJwcHLKTLZuppqnO3rEgpuap63SbWVxcimm+dZ8NyEmESsGRpavYNGoCMZH6O8xKajWPLl1FjQEPngcB8ofchAkdqFq1FEFBYXTvNo89ey4wcOBySn83gAL53ejRfR4bNhzn1av3mJoaU7fu90z7rRsXLs4h4MNW9u2fyLr1w1i8pD8KhYKVKw7TovmvKZpKpXAFJ4ZvX0ebCaMxt7Hm9aN/Wdrzf/w1ZjLB/gk5mAwMDGjVqhoHDk7C3NwU75eR7HturZlIt8+yeckO8z516g5VKo/k0rXn3P5ght+/T7W+dadUfCLMInGBU8Hvy9B3xQJexsgfPkXsjDT9e1LScTnk7TvWDBrN+5evsMllT8dpExi+bd0np6q4cuURjRtNJjQ0gvr1y7Nn7zhMTY0/eb3z+zy59Vbu51XYTt7fIU/CtC5a06+kct66ChWKcuDgJDyPTtOsU0uwakPampcKfl+GMnVqEKtSaaZSCQgIYdy4jRR27MO4qbs4/UZuZkouCK7Q7Ceqt2+FWq1m89ipBPn5ExMZqRld5n3ybJrK9zkcXrwSj4UrAPjpf300tS8Vmv1E9Q6ttcr8OYV+SJzL6csHTiA3V++cOhO1Wk2NTm2p0kYeRPBB5HD6aojA6RthgIGmierjDuJyjZP2t7bChXMTHhikqaHJoyf/U1ZjamrMpi2jMTIy5GGQCd7+EhtGjsdzxdpPJpd8eF5urnsTLQeIY8e1Y/wEOQAb0H+ZTsJIX98ANm06SU+3BRQs0JNSJfsz8H/L2b37Ah8+hGJtbU7z5pXp0SMhuZ21jTlubvVxdNQdvaTZJ5c9XWZNZdCGFeQrVYKIkBD2TJ/L/PZuPI0LTgwMDPjhh9LMn9+HZ8/XsHvPOMzMTDh25iEnQvITFRXDjKbtuH/uojzMe8kcSlavkuQ1nz71Y/auJ5zzt0hTbROAz/VbqGNjsS9UgHL1atN3xQKyWVly7fwtHjx4hbGxkSYFQkpHfL2694DZrp3Z/8ciIkNCyfddCQasWULPRbOwd0w6LcDFiw9o2mQq4eFRNGrkws5dYzExSb7mRRkVzaZdXqgT/ZnY2yck1nx44YqmD1zNmqUxSmKi3MTKlCnIrt1j8bq2gKZNK2mNnnwUbELZVu0+eQ59GsXVNnntP8z7F6+0tn34EMr9yOwExcjlC3yjP7DIXbQwbSfKaR+OrVyn6ecHcrCljI7m+W3dZt4v6fjqDfw9cz4g1750nTU1yTJ/Ll8iCWZKXNq1j23jp6GOjcU4Lq+ZqHH6eojA6WsXHzAYGPDqwSNilSqs7XJq2s0NFAosbG20apwAisR3EI/L55TvK+jntHj1SEqVyEu40oC9t6JY0qMftz1PpOjYhxfkf8KhlnKH4Ny5s2NoaMjGjSfYvv3T37wfPfJl+XIP2rWdQS77rrhUGMbRoze09unUqTarVg/mqc9q/n2yij//HESHDjU1/V4qNPuJXw5so0KThqjVai7u/JuZTdtzfusukCRq1SrLokV9eflqHWfPzWLoMFcKFLAnNDSCxYsO8I9fDmIlAy5s38P7F69YN2SMZnqHXotnU7p2DX1FByBHPvm+05olOjo8QpM01W3BTLJZWfLv1eusGTiSA/sva+37qT5OicUqlZzeuJUZTdtxbstOYlUqytatxeg9m3EdMwxzG/1Zw8+du0ezplOJiIimWbNKbN8xRpNROykeG/byJCShaS9n9oRa1n+vXuNtBESqDLC0zEalSkk/D8WL5+WvzaO4dXsxrVtXR61Ws3HjCRo2mKgJnq69N6dSy6bkL526OemKuJSnZPUqqJRKjq5cq7Pd0MgIl6Y/aV5Xcm1Cjc7tqNyqOeUb1ad07RoUr1KRHvOmY2qejUcXr+C5Qvs8f7lPYkqdplkiS/XZzTvYMXk6arUa5yYNkyzz5xL2IXEfp8wLnACuHfyHTe6TNAN74kc5C1lf8v9phK+KKjqa14//pUDpUhQoV5rAN35YZLdBYWiIXVyNk4+PP4UL507Uz+kRpWv/kOUTYfab2J/eXX4AYMv5D8xoN5zQ95/uRxQv2P8dfv8+RVFMu+Pv4EErUl0WtVrNrVs+moBo6ZKD7Nhxjnr1nPixnhNVqpSgSBEHihRxoM/P8ofc3XuviMxZmFdRRly45M22X+fw5uFjatUqS7t2P9CqdTVy504Y4RQcHM6+fZfZves8np43KFHzB9zm9yQqPJzjq+WhzbFKJRtHjKfLrKk4NfwRt/kz2DR6AneO6zYRxXfAjgqP0NmWUk+8blCgzHcAmqApJjKKAweuMNq9jWa/1AyV1xwTFMzeGfM4v203zUYMokydGtTq2oGKLRpzdOU6zm/ZpdPX5fRpb1xbTGP/gYm4ulZly9bRdOo4O8m8WU+v3eTk/QiKV5X/7WW3SuhcHhUaxos793npWIgSNjH8+OP3XLz4QOt4R8fcTJzUke7d62rSO+zYcY6pU7Zw//5L5szphZGRIS/CjHkbZYRCAa3GjmBxt74p+h3YOuSm3eRfALi8e7/ewCZngXyaeSfjtRo7Qu/5gv3fsfmXKZrZAuJJkkRUWNr6XmWEy3sOEBMZRafpkwh++46/xkzWKfPnEpqoxsksE/o4fey25wkW+77BOpcdH15lXDJS4fMSNU6ZwNDIiEotm1KiWqUkv1GnVEKFk9znJb65rlBcc51VzhxkM1RjbiShVqvxOCTntPlaRtYpjAzpNMWd6eObY2AAZ26/Z+BPfVIVNMV7cP4SxWwSOlxv23YmRf2R9OnSpTblyxchKCiMyZO3cPbsXaZM2UKtmmPImaMzTZtMYd7cvdy8+RSAMqXzUzG3kpaFQpjexp6da3/m9ZuNHD/xO/0HNCF37uwEBoaxbt0xmjaZQu5cXXHrMZ8DB64Qo4yl8eB+AJzZuE2rQ2+sSsVf7pO47uEp58iZ8xvlG9XXKa+ZhZxeITo87R+Yd46eAuDxJS9N0ARy01l8B3RIeVOdPm99nrN28GhW/DyE1w8fY25tjevoobjv20q5erV19j9+/BatWv5OdLSSNm2qs+mvkVod9xOTJIm/Nx/mdYQcOJkaK7TSGiTu55R43rp8+XKybNkAHj5aQc+e9TE0NGTfvks4lx9Cxw6zuH//JTY2FvzcVw6Sr72X80zFKlU4li9HhWYJNURJyV20MIM3rSRX4UIE+fknmXfprc9ztk38TWvdzX+Oce/0ef69co0Xd+7x5vETXj/6l/Ujxmply87Kbhw+ym8NWzGnVdcM7bCeuH+feRYInABe3r3P3UzsbyaknqhxygSVWzWn7aSE3Dojy1VL+8k+6tvz0vse0EbTQdwqZw5NbdPTp37cuSNXBzsW1m6qy1O8KApDQ9Sxqc9ynVGyWVvTY+7v/NyqFNlNo3j7IYIWNQdqjTZLjZB/71Mvb8J0IJ9q2kmKqakx037rBsDMGbuo0LYNsUolJ9dtBuRh6IcPX9Nk1naqWZFpf82hgEUM1mGvKFzInipV5NFo79+H8Pfei+zadZ6TJ++gVOqOIKrYvBG5izgSHhTM6Y26uaHUsbFsGTuVWKWSSq5N6TJzCobGxlw7kDAUPr7GKTodNU7Pbt1hUq3GRAQFa/Upi41Vc+iQF927yxmh0xM4xXt86Srz2rtRqUUTGg/ph13B/LgtmMmTazfYP3sRr+4l1AZ5et6gTevp7Nk7jg4daqJSxdKj+3zUemotvPZ7cG10Z/IWDAXkgRJPnsjDwOV+TnLW+R9++I6CBe0ZPtyVfv0ba0bvHTlynUkT/+LqVe0mz379GmFlZY6393P+VZbDyBgu7d7HDx3b0GzYQLyPnyEmUn+Q7uhUjt5L52BuY43fv09Z1T/52tSrfx+iRNVKVGj6E/tmL+TMpm2p+M1mXSHv3mf4NbSa6rJI4CR8fUSNUybIXdTxs56vXt4wKjrIH7jP42qc8pcuhcLQEMsc2TX9m7y9X/D0qVz9H1/j9MH3NVFh4RibmlKg7HeftVzpkatwIYZtXcOP9b7HOaf8Qdyt40xCQtL2wa9QKJgyvD5mhgkf+LVrl03TfFWDBzejYEF7Xr58x9nHETQe3I9mIwbh6FRO7/61+vXlcYgpM5edpqhjLwoV7EWXznOoX288eRy60bfvEjw9b+gNmoxMTWk4QJ4s+MTqjUk2sUhqNdsn/q6ZG6vjbxOo3Kq5ZvvnaKoDedoKfR3x47OIQ+r6OCVHUqu58vdBZjRtj+eKtcRERlHUxZnh29fR6fdJ2ObOpdnXw8OL9u1moVSq6NKlDqvXDNH73r5/8YrjZx8REGWIWkIr19YL77u8+RCFSg1mZiY8e76WocNcMTMz4fRpb2rVHEPjRpN1giZjYyOGDJV/13Pn7NVMTHtp1z551GBue+rFTQP0sdK1a9B/9WLMbazxuXGbJT0G6E2p8bH46UKiI9L3fv7XJG6qy+7gkIklEb5mInD6wswsLTTTCMRLz7QHxYs78H2OKBo4Kqle/TvePXtBZGgYJtnMcChWRE5FEJfD6a73c3x85FE48YGTJEmaPjG19MyjlBlK1ajKkM2ryeuYl/oOchbq5cs8dDpjp8bo0a2pXasMUUo1Gx7bEhmtws7OmtKlC6TqPDlyWGnSIUybvpufhg7SbPuxdzed/Z0bN8DRqRzRERF4LJL7U718+Y6tW09z4sTtZCdqBWjQ140c+fIQ5OfPuW27k91XkiR2/zqbc1t3oVAo6PDrOKp3aA0kaqrLoA/aI0euExQUxocPoWkObpMSExnJkaWrmNW8A1775Vq0ii0a88vBHTQa1BeTbHIQsX//ZTp1/AOVKhY3t3r8+ecgvcHTlX0e7PCxYcPj7ARFJNSwWpqbUkbxEqNEj+OlSw9oUH8CdeuM5dy5e3rL17lzbfLmzYmvbwBbtpwmKq451NDISDPFTJ0enXSypFdq2RS3BTMwNjPl3unzrOw7hMiQEJ3z62OaTQ6EYyLS1tT8X6WKTgjqkxu5KQjJEYHTF1bIqRwWRmrymiuxMZH/aVvY2nziqKQZGiZ8MCxe0g8DAwNe3r0PyPlgrHLmwM5Ursnw9n7OixfviI2NxdzclNy5bQE4vXELAN83qKtJxpZZanXrSO8lc8hmZYmz0Qtssxnw5Mkb3N319/lICReXYvw6rQsAC9Zf5kO0ET5v5ZqGOnX01xIlZdy4dtjaWnL7tg9h+cpjlTMHAa98UavVlKlbUzMJL8i1RU2Hy/PWHV+9MdX9snIXcaROT7nce2fM1/qnnxRJktg7fS6nNsjvaZsJo6ndvZNmdvnoDOoUHBoaSUWX4VSuNOKTwWBaBfm/Zev4X5nfoSdPrt3A2MyUBv16MvbQDiq3ao6BQsGePRfo2mUOsbGx9O7TkGXLBuic59aR44RFqgiKMcTC1gYLCzPGjm3HU5/VtKhsr7Vv9WqjOX78VrLlGjlKnjpk8aIDKJUqTTBjamHO3ZNneXj+EkYmJrQYPVhzzI+9u9Fx2gQMjYy48vdB1g0bgzIq5TV1CTVOInBKq/hnQhBSSwROX9irew+oZB9BhyLBlM0uV+lb29sle0zOAvlxbtJQ/8ZErSbOzkXp379RQj6nsqW1soZ7ez9HqVTx8qXclyC+1unNoyc8PH8JhaEhtbp9etb6jGBobEz7qeNwdR+KwtCQmNtnqV7CErVaTa+eC9Pcb8bc3JS/No/E2NiInTvPsXCmHFC8V9gC8rx15X+qx8yrp+i5aJZW4POxQoVyMXBQMwAWrD5HpZbyz1t+mcqdY6cA7Vqn2t07kj2PAx9ev+H0xtT1QzEwMKDNJHeMjI25e/JsqufqOjBnMcdWbQCgxeghmvXpbapLztOnfpqm4Iz06t4Dlrn9j/XDfuH9i1dY29vR4ddxjNixnuJVK7FjxzlNH6d+/RuzeHE/reMjQ0LZO3M+1/cdpGubCjx5uorfp3cnRw4rHjx6zZk3cm2OUqn65Jx4jRq5ULZsIUJDI1i58h8gIZgxjQtu/p61gFilirI/1qbkD1Vp4T6UpsPkgPrEmo1sn/g76iRGAibFVDTVpdnX0mFeyLpE4PSFRYaGamZnNzeSv5lb50o6cDI1N+d/a5fQddZUKsd9UCf2cQfYab91I/SFPJKrYLnSFCiYC1NDCZUqlkeP5OGu8R9uhQsnJGo8uV4OKCq3ap7ukX6pZZkjO/1XLaJK6+aoY2M5vngp3erI/VcWzN/H2bN3P3GGpM2b14eSJfPz6tV7+vdbiv/TZwT5+fMmWv7gadTYhTHzRmFsZkrZurUYuXsTHX+bqJl4M7Fpv3XF1NSY4ydu49BQHn5/Yfsent26w/HVcpBSvlF9cuTLg7W9HfX6yLOgeyxYnqLaosQquTalqIsz0RGRmikaUuvwohWaiUUBVEolsUplms6VFd05fprZrp3YN3shESEh5C1ZnP6rFtFr8R8cu/iMXj0XolarGTioGfPm9dEcZ2JiRAX7GGb1LM6cP3qRK5ctjx+/pmuXOZT9bgBHbwcTHKPA2NiIH35Ivt9ffG3T6lWemsmW44OZ+H5lb32ec27bLgD6rphP7bgvJ/tmL+TQguVpuvf4GifRVJd6754lTDuTnm4Swn+X+Kv5wkrXqkGEUv61W8QFTja57JPcv8nQ/poZ6X/s3S3JBz1SBTduPCF7dkv6tJWnjMhdtDDflZQTHz57+UHT+djnqXY/J5BHMfnef4SpeTZNv5gvIU+JogzdsoYiLuWJDAll9f9G0qlWbvLmzcn9+y+ZMOGvNJ+7RYsq9O3XCLVaTY/u8wkMlEfUPTx/mTcRRtzzCcTSwowOpVU4Gb3A+9gJFAoFlVyb8MuB7bi6D9PMHu/sXJSuXesCsM8rCHvHggS/fcehhfIHn+/9Rzw8fwlDIyPquHWh8eB+mJqb8+zWHW4cPpqqcltkt6XZSLnvlOey1enKKOy5Yq3mwzkrJDz83GJVKs5s2saMJu0489d2YpUqytSpwag9fxGa35nBQ+UpS4YNd2X27J706tWAh49WsmTpAPLmzcnz52/p3Wshpb8bwJYtp1Gr1VppCZKbt87ZuSj16jmhUsWyYMF+zfqYuMDJJNE0Rqfjmk7jbf5lcrpGw8VPkSRqnFLv3fOXmp/NLC0ysSTC10oETl+YJKl1apxskmiqK+RUluod5ZqN6IhI7B0L4tSgrvb54iqc1JIBgwbKnY+7d61NtjA/FAoFRQrKH/z3H/hqjonvIF64iHatyqkN8nD6Gp3bYWSSsslT06NM3ZoM3vQnOfLl4d3zlyzq+jNlHAzp0qUOsbGxuPWYrzXqKTUcHLKzeo3cRDVv7t+cPHlbs+3BhctIGHAsohg3AuSmmB9LmdOnigk7h4/g8SUvjExMqNWtA2M9dtJwQG/+mCtPRLpnnxcFGsgjqP6eOZ+o0IT0BvGJKau0bk5F1yaAXKuQWs1HDsLC1obXDx9zZvP2NNy9thNrNrLUbQBrBo1K97myqojgEPbNWsDsVp3xPnEaQyMjanRqS75Og5i/Qc5dNmp0a1avGUKhQrl4/TqAgf9bTskS/Vi37phWv6yHFxOmX0lu3rpRo+Xapu3bz2pN2RPfHGoa12ndIrstbgtmah378MIV0sNU1DilWeL57zI7e7jwdfoigdOAAQN4+vQpkZGReHl5UaNG0lNDANSqVQsvLy8iIyN58uQJ/fr109mndevW3L17l6ioKO7evUvLli3Tfd0v4em1W0So4muc5A5K1npqnAyNjGg3+RcUCgVX93lwcp1c85LUsGYD5ESE69cfB6ChYwwGSNjFpSK4c9snoQwfpSSId/PIcQLf+GGVMwcuzRul4y4/rVb3jrgtmImpuTmPLl1lYec+SGFBLF8h9/2YOWOXzrDvlDIwMGDd+mHY2Vlz48YTJkzYpLX98SX5gzRWMuDUG0umLr9AUFAY1aqV4tCOIbw5uJkVPw/h5d37mFlY0Ne9Oz/WLUeMMpZ7hoU1/Y5uHz2pdd4nXjd4dusORiYmKBQKrh86oulvllJFKzpTybUparWanb/OSnXfl6Q8vXZTq4niW/X++UvWDf2FZb0G4nv/kZyrx6UxB+7JTZRv3wYxYvhqihXty/LlHsTE6KaA+PeyFy9C5RxfFSoUxcZGt1aiUKFctGsn/z+ZO2ev1rbEncOz53Vg8MaVFCxbmojghBFzjYfo/k9LKUMjI80Xm+gkckMJSQvLAhP9Cl+3DA+c2rdvz4IFC/j9999xdnbm7NmzHD58mAIF9A8Dd3R0xMPDg7Nnz+Ls7Mz06dNZtGgRrVsnNB9VrVqV7du3s2nTJpycnNi0aRM7duygcuXKab7ulxIZEkK4Sh4JZ26kxgBJb+fwur27kad4UUIDPrD/j4Wc27KLqPBw8pYszne1ftDsJ0nafZx+GbOe4OBwijiYUyZ7tKZj+HWvR5p9EgIn7clo1apYzmySazjq9OicphxHKZG7iCOuo4eiUCg4t3UXqwYMJzIkhOUr/oe9vQ23bvnw669pb8YYPLgZP/1UgcjIaLp0nqPz4RgZEqr1etqQ2VRwHsblyw/Jnt2SvX+P538dnFjWvS+bRo2nWnb5H+2dYAssHOXElXtn6u93dCKu1kkZFZ3q/iuGxsa0nSRPcnpp59+pDrqEBE+uXmd+x55smzCN4Lfv+Fedh9UPs7PggsSVN4ZIhkknP40IDuHBrUd8iDbE0FBBrVpldPYZNqwFRkaGHDt2U5MdPl58klHH8uUYvOlP7B0L8sH3DYu6/syS7nLAVKV1C/J9VyJN9xbfvwlEjVNaJM4eLpJgCmmR4YHTiBEjWLNmDWvWrOHBgwcMHz6cly9fMmCA7jBhgP79+/PixQuGDx/OgwcPWLNmDWvXrmXUqIRmhmHDhnH06FFmzpzJw4cPmTlzJsePH2fYsGFpvu6XFKlSIEmgMAAzQwlbh1xa23MVLkSDvm4A7Ju1gIjgECJDQriwfQ8A9fvqqXWKi3Hevg1i8qS4Jrfc4eSMS0Vw++YTza7xgVO+fDl1ZpW/vHs/kSGh5CpciNJ1MqaGrm4veeSZ94nT7J0+F7Uqls6da9O6dXViYpT06D5PbzLIlChbthAzZ7kBMGrkWh48eKWzT/mf6ml+fuvzHLUqlmfP/KlV8xfmzZVrD4YOc+Xc+dk0rWhHHhtDwiJiuPIuoc9Kn6VzKftjLZ1z3z11jh1TZrBm8GitJoGU+LF3N3IVLkTI+wBN3ykh7SS1mqv7PJjZrD1Hlq3mfXAM9sWK02bCaCafOEDbyWPIX7qk3mMfJWqu+7ifk62tBb37yKNc5/yxR+fY+FqgktWrYJPLnteP/mVxt768e/YCnxu3uX7oCAqFgla/6J9j7lPimwBVMTE68/cJn6YVOImmOiENMjRwMjY2xsXFBU9PT631np6eVK9eXe8x1apV09n/yJEjVKxYESMjo2T3iT9nWq5rYmKClZWV1pJR1BgQGStHOhZGavKVSvjmaZkzO2P2b8PIxIT7Zy9odSw+s3EbyuhoHJ3KUbSiMwCSWjeL89Klh/D2fkE2IwkjBShjJZ4+TfgQf/8+hNDQCBQKBYUKaQdt0RERXNwpBw91enT+fDcdJ0e+PFRoKn/oHF25HoC8eXOweEl/AH6duo3bt5+l6dympsZs3jIKMzMTDh68yvLlHjr7WObITqtxIzWv7QoVoNuc38hXqgRKpYpRo9bSovmvfPgQSsWKxTVTqxzyek9UrPy4RIaE4lCsCD0XzmLwX39SJO69iHd5935Nc2BK2RXMrxmFt3/2Qq2+U0L6xERG4bl8DdMauPL3zPn4PfHB1Nycam1bMnz7eoZuXUOV1s218vo8TGLeOoD+/RtjaZmN27d98PTUTcpavGpFzc9Prt1gqdsArelEDs5fSnREJIUrOCWdZiQZIodT+oimOiG9MjRwsrOzw8jICH9/7W/e/v7+OCSR7t7BwUHv/sbGxtjZ2SW7T/w503LdsWPHEhISoll8fX317ve5aDqIG2s3tXX5fRJ2ZioMkNg97Q+tbaEBH7iy9yAA9eNqpKS4RE6JG9ViY9UM/N8yzes3gUqdtAVP9Yysi3d2805USiVFXMpT8HvdZor0qOPWBUMjIx6ev6SZb2zV6iFkz27JlSuPmDVrV5rPPXNmD8qVc8TfP5DevfR3ym41biSWObLz+tG/XN3ngUKhoPxP9RixcwM/L59PEZfyHDx4FefyQzl/Xs4U/eZtCP45yxGrUjG3bXd+a9SaY3+uJzoiEkencgxct4w+y+dpBcCp1WaiO8ampjw8fynVo/CElIkMCeXs5h380bIzS90GcP3QEVQxMRQsW5r2U8cx6fgBWo8fRZ4SRXl+8w5P3su1OU5OhbGzk1N0mJgYMXhIwvQqH6va1pWiLgmB9J/9husEwcH+7zTpK5qNGJjqRIxiRF36JK5xsrLLmYklEb5WX6Rz+MdzWxkYGOid7yq5/T9en5Jzpua6M2bMwNraWrPky5dP736fS0IHce2AxqWEDd2KBVHT9p3eYegn1/5FrFJFiWqVKVC2dJL3c/bsXc7elue88nkTqrP946lXEgt5957rB48AUNetSyruKnlWdjmp3ErORXUsri9Q794NadzYhaioGNx6zE9z1umGDZ0ZOswVgF49F/LuXbDOPuXq16H8T/WIVanYNmEa2yZM44/WXbl28B/UsbGUqlGVgeuXM2jjSiwLl6BunXF06TqfbY/MiZUMOLNxG68fPiYqNIzDi1cyo2k7zm/bTaxSxXc1qjFi5wa6zppKzgL5U1X2Ck0bUqJqJZRR0ez+bU6a7l9InafXbrL5lyn8Wq8FB+Ys5t3zl2SzsuSHjm0Ytfsv/rduGWoTC95FGQIJGea7dKlDnjw5ePXqPdu2ac9oX79fT9pN/kXz+sm1G0nm7zq9YSsBr3yxzZ2LH+NqGlNK5HBKn8SBrL1j5vZ5Fb5OGRo4vX//HpVKpVPLkytXLp3aoHh+fn5691cqlQQEBCS7T/w503LdmJgYQkNDtZaMFK7UHziZRAYB4JJfgYtLMZ3jAt/4cd1DDmrq9elOMvEngwb/iedTBbPmHNDZ5pPEyLp48VN2lK1XO9WBQFJqd+uIsakpPjdu89TrBoUK5WLefHmY//hxG/X2R0oJOztr1q0fBsDSJQc5fPiazj4Wtja0mTAagBNrN+F7X+4s7/f4CVvGTmVGs/Zc2L4HZXQ0hZ2/p8/SOQzdvp5sVRqBrQMBr17juWKN1jlD3wew5/c5zGrRkeuH5PfEuUlDxuzbSpsJoz+ZER7kzqktRg8F4Oif6wh4lbE1nYK28KBgTm3YwqzmHVjRZzC3PE8Qq1ThWF4OlOL7OTVxrY6BgYEm4eWihfs1/fAMFApajRtJ40F9ATR/W8YmpkleVxUTw/4/FgNyk3iO/HlTXOaEGicROKWXmK9OSIsMDZyUSiXXrl2jQYMGWusbNGjAhQsX9B5z8eJFnf0bNmyIl5cXqriOkEntE3/OtFz3Szq1YQuls8vfRM0/CpwSD2SbO6+33uNPrNmEWq2mXL3a2CUT1Nw5c5lGRZvyz0bdyWE12cM/GlkXz/+JD/fOnEehUFC7e/qnYclmbU21DvKHzvFVGzAwMGDtuqFYWZlz9uxdFi7UDe5SatXqweTJk4N7914werT+Oe1a/jIcq5w5ePP4CUdX6O7z4dVrdv/2B783asOJtZvkEYwlilGmbk0Adv/2BzGR+qd9CXjly+ZfpjC3bXfunTmPobER1Tu0ZuyhnTQZOgCzZDqgNh32P6xy5sDviQ+n1m1Ow90Ln4MkSTy+7MXGkeOZ1sAVj4VxEzLH9XNq0a4ui4+spnTpgoSERPDnn3KgbGhsTNfZv1KjU1vUajV7Z8xl3+wFQELm8KR4nzjNo0tXMTY1pfnIwcnum5jI4fT55CpcKLOLIHyFMrypbt68efTp04eePXtSqlQp5s2bR8GCBVmxQv7HNH36dDZs2KDZf8WKFRQqVIi5c+dSqlQpevbsSe/evZkzJ6EJY+HChTRs2BB3d3dKliyJu7s79evXZ8GCBSm+bmZ6c/m85mfrj/o4Je6rVKtWWVq1qqZz/Fuf55q50aq0baFzXErom3blY/Ef5JVbNsMiu20qr6CtZue2mFlY4PvgEffPXmDgwKbUrfs94eFR9HRboNMHK6X69m2Eq2tVYmKUdOk8R2/CzDJ1alCh6U+oY2PZPvH3ZKcdCX0fwKH5y/itYSsOL15JwKvXnN60jYfnL32yLK8fPmbNwFEsdRvAs5t3MMlmRr0+3Rl/eDd1e3bB2Ey7BsLRqRzV2rUEYPe02WKEVBYRGvCB46s3MMrpB3zDjVFLkMM0lnY15Qmw7wZbULO3G/lKleDnZfMo/1M9VEolm90ncW7LroQpVxKlDUjK3zPnE6tS8X39OhSvUvGT+0OizuGRoo9Teplbf9nppYRvQ4YHTjt27GDYsGFMmjSJmzdvUqtWLZo0acKLF3Iyvjx58lCwYEJ16bNnz2jSpAl16tTh5s2bTJw4kSFDhrBnT8Kw34sXL9KxY0d69uzJ7du3cXNzo0OHDly5ciXF181M0cFBmp/zmOv/sFSq5EBi1mw3nZQBgKZzaaHvy6WpDMl1Do/3xOsGL+/ex9jMlB/iMpgnx8DAgApNG1KvTw8MjRLKbGpuTs2uHeLKvZE8eXIwY6acUsF99Lo0TwxbsmR+5s2X5yAbN3Yjt2756OyTzdpakxvp1IYtvLx7P0XnjgwJ5dif65neuA37U5n9++m1myzu1pe1g0fz5vETzG2saTZiEGMP7qRqW1cURoYojAxpO1ku15W9B3l67WaqriFkPEmt5uweD95Gyn/L9maxxKolvCNs+bFXN0bs3KAZQbd2sDs3j8jJZxMm+U2+xgnkmt3z2+QaYdcxw1AYGn7ymPjzihqntIsKC8/sIghfsS/SOXz58uUULlwYMzMzKlasyNmzCZ0qe/bsSd262tOInDlzBhcXF8zMzChSpAgrV67UOefu3bv57rvvMDU1pXTp0uzdqzvCJbnrZpYCBey5dSvhg9gyrsZJ8w8zrq3uwm0/3rz5QLFieRk4sKnOeXzvP+L+uYsJKwyS6eykx7NncuBkY2NBjhxJD8mNr3X6oWMbnRqTxHIXcWTAuqV0mTmVJkP7a/oTgTzSyNzGmnfPXnD76El+/bULFhZmnD9/jxUrDqeq3PGMjY34a/NIzM1NOXbsJvPn79O7n6v7UKzt7fB/+owjS1en6VppdffUOea27c6Wcb/ywfcNNrntaTf5F9z3bqHjtAnkKV6U8MAgDs5b8kXLJaTcowsJaQkAtm45zebpuu9Xx2njaTSoL9nzOGgCJ5MU1DgBeC5fQ3hgEHmKF6V6XHN2ckQ6gvR7++x5ZhdB+IqJueq+sKJF9dfwxE/0G9/kFhmlYmLcBLcTJ3UkZ07dKuXjf65P9Cp1jXXR0Up8feXO9snVOt0+doqAV6+xzJGdii2a6Gw3NjOl8eB+jNi1kaIuzkRHRKKOjaVKmxbU7t4JIxMT6rjJ+aBOrNlE6e/y49ZTTkA5etTaZEdXJmfcuHa4uBTjw4dQ3HrM13ue72pWp5JrE9RqNdsn/Y4qJm3z3qWHpFZz7cBhZjbvwN4Z8wgN+IC9Y0FcmslT2hyYu5jwIN0RgELW8Piyl1bgtHGXFz/GJXBVx8Zy859jhLwPwNrejgb9ejLun938NEDum2hoZISRadJfNuJFhoTisVj+cvjTwJ8/2SxuqgmcRFNdWr1PNNGvIKSWCJy+sDt3dL/pGBpIFK9aCUjoHC4B69cf59YtH2xtLZk0SbeDts+N27zwlnMNGZD6ACSpqVcSU8fGcmbTViBuGhZFwp9MyR+qMnrvZur3dcPI2BjvE6eZ7dqJ/X8sAqDZyEH0mD8da3s7At/4ce3gP8ya3RNDQ0N27jzHpUsPU11mkGubBg6S0xoMHrSS168/6OxjZmmhaQo7s2kbz295p+lan0usUsm5LTuZ0aQd/yxdRURICHeOn+bqPt0knULWEfYhkEtePjwONmHvmRfU/WUiVjlz4PvgEb/Wa8Gm0RP5rUFLNowYx+NLXigUCk3KDUhZPyeQk6b63n+EubU1jeJG5yVFNNWln7+PqHES0k4ETl/Yhw+6aQ4KWirp8Os4+UWiyEmtVjNqpDwEvv+Axnprhi5s36vZP7USOognXeMEcGXvISKCQ7ArmJ+yP9bC2t6Obn9Mo++K+eTMn4/AN36sHeLOuqG/EOTnz9nNO7iwYy8KhYLScfPqnVq/mdq1StOkSUWUShXjxm5MfYHjNG9eGTs7a3x9A9ixQ3/za4tRQ7DNnYt3z1/yz5I/03ytzy06IoKjK9Yy8YefWD/sl08fIGS6+xeucPClNc9yVMDM0oJ/r1xjWc//aRIpxqpU3D56khU/Dyb47TutfkopDZwktVoz/2HVtq7kLVk8yX1NsommuvRKPOG1wujT/coEITEROH1h+pqUWhaSZ00vV7+OpsEtPiP48eO3OHbsJsbGRnToUFPn2PhOxWlphvJJQY0TQExkJOe3yx1Y3ebPwH3fVso3qk+sSsWpDVuY7dqZuye1A5i9M+Zqvb5/5gKz/+gFwIrlh3ny5E2qyxuvZ6/6AGzccFxvwswS1SpTpU0LTROdMkp/EkJBSIlHFxOmz7nleYJVA0Yk2bn42c07Wq8/lZIgMZ/rt7hx+CgKhYKWY4cnuZ9oqku/xE112SzFfHVC6ojAKQvpMnNKwotE8dXuXXL6gmbNK+scEx+IpWUoe/zIusLJ9HGK9+zGbc3P2awseX77Lgs69uLAnMXEROp+85Vi1QS/fad5PX/7bCpUKEpwcDi//rot1WWNlzdvDho1qgDAunXHdLabmpvTbopck3N+6y58rt9K87UEAeDJ1etc3r0fzxVr2TR6YrJfUp7d+ihwypbywAng4NwlxERGUdTFWWsyaq1zisAp3YLfJfxvSm+qFeG/RwROmSAySn8eIWNTU6xyZAe0W94OHpS/8VapUgJ7exu9xxqkNpETyU+7Es/U3JwW7kPpvUR7KpDF3fry+uHjJI8rU7eWpsM7KiUtKsr3NXPGLgICQlJf2Djdu/+IoaEhZ8548++/urVWzUYMJEfePAS88sVj4fI0X0cQ4qljY9kxZQZHlq5C+kS+sfTUOAEE+b/l+Bq5GbvZyEF6R7KaiD5O6RYRlPA/6HPNjCD8d4jAKRN4P9CXt0gOlewK6s6R5+sbwPXrT1AoFDRpop0kL62j0iChj1PBgvYYGur+KZSrVxv3/Vup3a0jCkNDXt1L6MxtVzD5fzb1fpbn3zr65zqUZ3ZibaImJEbB3cjsOvuamhrTo0c9nJ2LfrLMPXvJ2eDXrdWtbSpW2YXqHVoDsH3S9CQzfQtCRvG9/whlovnpUpqSILFT67cQ8Oo12fM4aEbwJWYq0hGkmzo2VvNzLjHtipBKInD6wgoUsKdSed2JJc0Nk5+g+OABObmnvuY6SJgIOTX8/AKJjIzGyMiQAgXsNeuz53Gg1+I/cFswE9vcuXj/8hV/9hvG/A5ueJ88A0DtHp2SPG+JapUoWLY00RGR3D3kQd/u1QG48Nacuj/3wrlxwlQ4NWuW4cbNRaxbPwzPo79iYZH0TPE1apSmePG8hIZGsGvXea1tJtmy0X6q3MH+wvY9PLl6PdW/D0FIr1ilkld3H2hepyQJ5sdU0dEcmCvPY1e3Z1ey59WuETYRTXWflZivTkgtETh9YfXrO+ldH58IM6FzuLYDcYFTw4bltTKJp6PCCUmSEjXX5UZhZEgdty6M/nsLZerUQKVUcnTlOv5o1ZWHFy4D8rdhgIrNG2OZU7f2CKBeHzkr+KXd+xgxuBG2tpbcuPGE5QvkDuYdpo2n7A8V+fPPQZw+M5NSpeTaq5w5renVq4Hec0JCbdOO7ecID9euTWo6bAA58+flw+s3HJy3NK2/EkFIt8TNdaltqot359gpHl/2wthMdx47kY7g8xKBk5BaInD6wjw8vPSutzSO1V7xUUB0/foT3rz5gJWVOXXq6E6zkpYaJ0joIF6ptgvDt6+n+chBmJpn44nXDea26cY/S/5Elajpwef6LZ7f8sbY1JQandvpnM/RqRzFKrugUip5fuooA/4nJ810H72Og/OX4X3yDGXs4cKJyfT5+ScAVq44zC9j1gMwYmRLjPQMDzYzM6FdOzm1wcedwou4lNeUZeeUGeKbuJCpEncQT2k6An3+nrUAdWwsTg1/pGilCpr1CekIxN/55yCa6oTUEoHTF+bvH6R3va2JHDglpHHSbbo7FNdJvHmi5rr09HECePFKzkXTakAX8pYoRnhgENsmTGNZz//xNokkcSfXx03D0qENJtm0m9bq/SzXNnnt82DsyOaYmBhz+PA1jh+/Rf58OWlTLJKmBUOxNAH/kFjq1Z/EgAHLWLToAP7+gRQqlIv27WvoXLNxYxcsLbPh4+PPhQsJ880Zm5nS4dfxAFzatU9r6LggZAbtwCltNU4Afo+fcGGHnKet1dgRKAwNMVAoNMGYqHFKn+sengCauQIFIaVE4JRF5DTTrnHSFw/FN9c1bVbps1yzQrOfKFpfnvrDxiSWy3sOMKtFx09ms/Y+cYb3L15hbmOtlSXZzMqSUjWrARB84xzt29dArVYzbuwGhgxpzt17S2nS2IXoaCWnfGD7y1wUbilnI4+KimHxooMAjHbXnVC4bVxt0+6P+jY1HtwPu4L5CfLz1/QLEYTMFBYQyPsXr4C0dQ5P7J8lqwgPCiZP8aJUa9cSE7OELyqic3j6bB3/K/M79OT4qg2ZXRThKyMCpyzCIdun8zAdO3aLyMhoHB1zU7ZsISChxik1TXV2hQrQb9UiusyYQpSxnPwt6tVTdkyenqJ50yS1mtMb5WlYanXrpMmUXLBsaRQKBe9fvGL8KDmgunHjKSv/HMSChX2xtMzG2bN3cS4/BDfXMURFxVCmTg2ajRgIwPLlHoSFReLkVJiGDZ011zMzM9HUsr2UcmJllxOQmwVrdu0AwM6pM8WM50KWEd/PyczCIl3niQwJ4XDcPHaNBvXVdBSPVakyZe7Fb4laFcurew/SXWsv/PeIwCmLsIurcYoPf8ICg3T2iYyM5vhxORFl8yRG1yXHyMSEhv17MXrPX5SoWgllVDQH18nV1Ply604inJyr+w4R9iGQnPnz8n39OgAUcior30vkK2rWLAOAi0sxKlcuQVBQGP36LqFO7bE8ePCKF3fusW38NECeA69KmxYEBoax6s8jALiPSah1atSoApaW2QiJMcCxSWvGeeyiydABdJg2HoVCwdV9h3hw7lKqfx+CkFEeXpD/HiNDdadYSq1Lu/bx+uFjzG2saTF6CCCa6QQhM4nAKYt66/NC7/pDB7XTEsR/WfpUhVOxyi6M3LWRnwb+jJGJCQ/OXeKPVl3YNmcVAHZ21tjYpPzbsTIqWtM3oE7PLgAU+r4MCiSGtymmte/Oneco/d3/WLXqiNa3u5tHjnNkqXz9NuNHU6yyCwsW7EepVPHjj05UrCjP19W2ndzn6XGIKSqlCpNsZtTr051chQsR/PYd+2YvTHG5BeFLuOFxlCXd++GxcEW6zyXPYzcfgJLVqwAQrSdbvyAIX4YInDLBv75JfQuVNDVOaj1zsEHKsognZpkjO52mT2LAmiXkKlyIkHfv2TRqAqsGDCfglS/h4VG8fClPP3Dm7ExNTVFKnN+2G2VUNAXKfEfJqhVpUKc0Q8sGaLYHB4fj2mIaHdrPws8vUO85PFes5YaHJ4bGRvSYP51oI3O2bpVzRY0a3TqumU7u0/Uo2JQ9v89h7eDRvHn8BFVMDDumzCAyJP3f6gXhc5IkCZ8btz9bc9pTrxvcPHJc81rUOAlC5hGBUyaYtVg36zWAqSKhNsY0iYknP84inlQfJwMDA6q0acGY/duo2LwxarWac1t3MatFR61/wAAD+i/j/fsQypVz5PSZmWzcNAIHB/05mhILDwzi7eVT1HYI4+qpibT7LqGflkoVS8ECPTUd2pOzbdJ0nt26g7m1Nb2XzmHpyqMAtGlTjYEDm2JlZU5IjILnATHcPHyMu6fOMad1VybWaMSDsxc/eX5B+BYcnLtEM2G1SEUgCJlHBE6Z4PrNZ3rXWxqrURjIgdCg/g1wciqsd79PZRHPU6IoAzesoP2UsZjbWON7/xGLuvzM3ulz9Xag9vDwomSJfixf5oFaraZr17o8eLiC4cNd9eZUsre3YejQFly/sZA5A12oYBeFpan2n5J5tjaEhqbsW7EqOpp1Q8YQ8MoXuwL5qTpgCB6Hr2FoaMiMmXJ6g8chJtw6clLrA0Pf5MKC8K0KfOPHibWbAAgN+JDJpRGE/y4DdJNUC4CVlRUhISFYW1sT+hk6eCZW9sda3D4+Wmf9jfdmONslZMRWqWJZMH8fU6ZsISIiIQllxYrFuXJ1HmHh0XQZtp19q7qjVKlx3/keu4L5MbeRO3pHR0Twz5JVnNuyU2tupuRUqFCUJUv7U7VqKQC8vZ8zeNAKLlx4QJMmFenhVo+mTStibCxnL4+OVnLreQS+JgWwNFbTIF8YZ854U6f22FT/XnIVLsTgv/7E3NqaSO+LjOtYXLNt2xMbxrUdxLObt1N9XkH4ViiMDKnSqgVPvK4nmWdNEP7rMvLzG0TglKSM/MXb57XH33dtivf39Q9h+U5vnoebkrNAfuwL5WdYZRUWxhKeryxpmD8MlRoW37MDQK1W4338NPtmLSDI/22qy2dgYEDPnvWZMbNHkv2orlx5xIb1x9m27QzWBR0Z8tcqfswThlPOKOb8sQd393Wpvi5A0UoV6LtyAUbGRjS2/JdSjtkJVSqY8U8oM1t0TNM5BUEQhP+OjA6cjD69i/C5Naybsg7Yfz+zpm7eMPLltua3QdV5GGTCKT9LIlQKnoaGUi5HNLli3wLmSOpY1g/7hXcvXhHw8pWmL0Ra2NlZY2WVjchI3Y6tKlUsFV2Gcfv2M826wEBvrnt40r6vE2DIlSuP0nztJ1evs3PKTDr9PhFvqRDF1CHceG/Gpd2b03xOQRAEQfhcRB+nTPD0qV+S22Lj6v9OvLbAJ8yEJedjOeYdQqxaoqRtDJ3yv8ZvxzJ+HSDnQCqWU+4ULqnV3Dl+Gr/HT9IUNBkbG9GyZVX27B3PK9/1zF/wMwUL2hMdreTx49ea/YyMDNm8ZbTOfHm7J/9OLgu58OkJnAC89nvguWItL8NNWHwvJ1f8TPA6cDhd5xQEQRCEz0HUOGWC69efJLktJtaAbEYSk7v/wtULt4mJlPs8lS9fhJV/DqJSpeLM+rU9N27I57C0lKd0SOskv+XLF8HNrR6du9TBzi4hCeblyw/ZsP4427efJTAwDAMDA3r0+JFZs3tSpkxBTpycztatpxk9ai2vX3+gfPnCGBsb4ecXyIsX79JUlsSOLF2FXYF8VGj6E3dOnCbsg/50BoIgCILwJYk+TknI6DZStXQg2e05c3QiMDBMa51CoWDgwKb89ntXrKy0Jw9VKlWYmrRK0bXt7W3o0qUOPdzqaY3ce/06gL82nWTDhhPcv/9S77G2thZMm9aV/gMaY2hoSGhoBL9O3YaBAcz+oxf791+mpetvKSrHpyiMDCld6weeeN0kMiTks5xTEARB+LaJzuGZJKN/8ZFRezA1Nda7LUYZi5lJyySPzZ/fjkWL+9GyZVWt9QqD5kkeY2xsRNOm8qi4Jk20R8X9/fclNqw/ztGjN4hNIvHmx8qXL8KSpf2pXv07QO6QrlAomDB+E9On70jROQRBEAThc8voz2/RxymTrFt7NMltAcFRSW4DePXqPa1b/c7gQdrTOWzYOEJnFJyzc1EWLPgZ39cb2LN3PK6uVTE2NuLy5Yf8b8Ay8ubpTqeOs/nnn2spDpoAbt58Ss0aY+jptoC3b4NQKOQ/patXH6f4HIIgCILwtRE1TknI6Ii1U6fabN4ySu+2ez6BlC3SPUXnefR4JcWK5dW8DggIYdzYjVhamtHDrR7ff5+6pri0sLW1YPz4DjjkyU6vngtRKlWfPkgQBEEQMoBIR/CNuns36eR1SmP9063os3XLGSZOkvMb3bjxBGfnoqz8c5Bme1qb4lIjKCic0aNTnpdKEARBEL5Woqkukzx86JvkNpWZVYrPEz8XXEyMksqVRjBq5BpevnynaYrL49AtTU1xgiAIgiDoEjVOmSQ6WpnktnBlyuNZL6/HzJ61i6CgcGJj1cyb9zfz5v39GUooCIIgCMLHROCUBYWpdCfWTc4vv2zIoJIIgiAIgpCYaKrLgsKUCgyNREwrCIIgCFmNCJwyUVIj28JVCqzt7b5waQRBEARB+BQROGWi5cs89K4PUyqwyWX/hUsjCIIgCMKnZGjgZGtry8aNGwkKCiIoKIiNGzdiY2PzyeMmT56Mr68vERERnDx5ktKlS2u2Zc+enUWLFvHgwQPCw8N5/vw5CxcuxNraWuscPj4+SJKktcyYMeOz32N6eHh46V2vlsA6twicBEEQBCGrydDAacuWLZQvX55GjRrRqFEjypcvz6ZNm5I9xt3dnREjRjBo0CAqVaqEn58fR48exdJSzm2UN29e8ubNy6hRoyhXrhxubm40atSINWvW6Jxr4sSJODg4aJbffvs8c6h9Lr6+AXrXWxirsSuQ7wuXRhAEQRCElJAyYilVqpQkSZJUuXJlzboqVapIkiRJJUqUSPK4169fS+7u7prXJiYmUmBgoNS3b98kj2nbtq0UFRUlGRoaatb5+PhIQ4cOTXP5raysJEmSJCsrqwz5/cQvaumAzrLH57Q0ZPPqDL2uWMQiFrGIRSzf4pLRn98ZVuNUrVo1goKCuHLlimbd5cuXCQoKonr16nqPKVy4MHny5MHT01OzLiYmhtOnTyd5DICNjQ0hISHExsZqrR8zZgzv37/nxo0bjBs3DmNj/ZPqApiYmGBlZaW1ZJZSttEU+r5Mpl1fEARBEAT9MixwcnBw4O3btzrr3759i4ODQ5LHAPj7+2ut9/f3T/KYHDlyMHHiRFauXKm1fuHChXTs2JG6deuyZMkShg0bxrJly5Is79ixYwkJCdEsvr5JZ/bOaKVsozPt2oIgCIIgJC3VgdPkyZN1Ol1/vLi4uAAgSZLO8QYGBnrXJ/bx9qSOsbKy4tChQ9y7d4+pU6dqbVuwYAFnzpzhzp07rFmzhv79+9OnTx9y5Mih95ozZszA2tpas+TLl3l9jFRiZhRBEARByJJSnWVxyZIlbNu2Ldl9nj17xvfff0/u3Ll1ttnb2+vUKMXz8/MD5Jqn+J8BcuXKpXOMpaUl//zzD2FhYbRq1QqVSpVsmS5dugRAsWLFtJoP48XExBATE5PsOTLCoUNXadq0kta6NxFJNykKgiAIgpB5Uh04BQQEEBCgfzRYYhcvXsTW1pZKlSpx9epVACpXroytrS0XLlzQe4yPjw9v3ryhQYMG3Lx5EwBjY2Nq167NmDFjNPtZWVlx5MgRoqOjadGiBdHRn27acnZ2BuDNmzef3PdLunzpoU7gVMBSnsfOwtaG8KDgzCiWIAiCIAh6ZFgfpwcPHnD48GFWrVpFlSpVqFKlCqtWreLAgQM8evRIs9/9+/dp2bKl5vWCBQsYN24cLVu2pEyZMqxfv56IiAi2bNkCyDVNnp6eWFhY0Lt3b6ytrcmdOze5c+dGoZBvp2rVqgwbNgwnJyccHR1p164dK1euZN++fbx8qT9bd2a5dy/p8liLJJiCIAiCkOVk2JDA7NmzS5s2bZKCg4Ol4OBgadOmTZKNjY3WPpIkST169NBaN3nyZOn169dSZGSkdOrUKalMmTKabbVr15aSUqhQIQmQnJ2dpYsXL0qBgYFSRESEdP/+fWny5MlStmzZssxwxvilatWSelMSzL1zUSpVs1qmD+sUi1jEIhaxiOVrWjL689sg7gfhI1ZWVoSEhGBtbU1oaGiGXadgQXuePV+rs36+tx07pszg8u79GXZtQRAEQfjWZPTnt5irLpP5+QUmuc3UwvwLlkQQBEEQhE8RgVMmi4nRPxrwwvbdXD945AuXRhAEQRCE5IjAKQsICYnQWffvcU/CPiRdGyUIgiAIwpcnAqcs4MKF+zrrSpV2/PIFEQRBEAQhWSJwygJe++rmxerXp34mlEQQBEEQhOSIwCkLuHv3hc66OlULZ0JJBEEQBEFIjgicsoBbt3wyuwiCIAiCIKSACJyygNu3n2V2EQRBEARBSAEROGUB79+H6Kzb+8w6E0oiCIIgCEJyROCUBXm9z8azMJPMLoYgCIIgCB8RgVMWZG0cm9lFEARBEARBDxE4ZRED/7dc87M68C0LO/fOxNIIgiAIgqCPCJyyiFOn7mh+tjFV8+LOvUwsjSAIgiAI+ojAKYt49MhX83OePDkwNjbKxNIIgiAIgqCPCJyyiNhYNdeu/at5nTdvjkwsjSAIgiAI+ojAKQu5dfOp5ueCBe0zsSSCIAiCIOgjAqcs5NatZ5qfCxSwy7yCCIIgCIKglwicspDbtxOmXhE1ToIgCIKQ9YjAKQtJPGddmbKFMrEkgiAIgiDoIwKnLCQoKFzzc9OmFTOxJIIgCIIg6CMCpyxGqVQBYGtrmcklEQRBEAThYyJwymIOHLiS2UUQBEEQBCEJInDKYg4dvKr52dIyWyaWRBAEQRCEj4nAKYs5dy5hqhVHx1yZWBJBEARBED4mAqcs5skTP83PP/74fSaWRBAEQRCEj4nAKYtRq9Wan5s1r5yJJREEQRAE4WMicMqC3r4NAuDRQ9/kdxQEQRAE4YsyyuwCCLrKlR1Eu3Y/8NdfpzK7KIIgCIIgJGIASJldiKzIysqKkJAQrK2tCQ0NzeziCIIgCIKQAhn9+S2a6gRBEARBEFJIBE6CIAiCIAgpJAInQRAEQRCEFBKBkyAIgiAIQgplaOBka2vLxo0bCQoKIigoiI0bN2JjY/PJ4yZPnoyvry8RERGcPHmS0qVLa20/efIkkiRpLVu3bv0s1xYEQRAEQUiOlFGLh4eHdPv2balq1apS1apVpdu3b0v79+9P9hh3d3cpODhYatWqlVSmTBlp69atkq+vr2RpaanZ5+TJk9LKlSul3LlzaxZra+t0XzvxYmVlJUmSJFlZWWXY70csYhGLWMQiFrF83uULfH5nTMFLlSolSZIkVa5cWbOuSpUqkiRJUokSJZI87vXr15K7u7vmtYmJiRQYGCj17dtXs+7kyZPS/PnzP/u1v/AvXixiEYtYxCIWsXzmJaM/vzOsqa5atWoEBQVx5coVzbrLly8TFBRE9erV9R5TuHBh8uTJg6enp2ZdTEwMp0+f1jmmS5cuvHv3Dm9vb/744w8sLS3TdW0TExOsrKy0FkEQBEEQhMQyLHO4g4MDb9++1Vn/9u1bHBwckjwGwN/fX2u9v78/hQoV0rzevHkzPj4++Pn5UbZsWWbMmIGTkxMNGzZM87XHjh3LlClTUnRvgiAIgiD8N6W6xmny5Mk6HbM/XlxcXACQJEnneAMDA73rE/t4+8fHrF69muPHj3P37l22b99O27ZtadCgAc7Ozkme41PXnjFjBtbW1polX758yZZREARBEIT/nlTXOC1ZsoRt27Ylu8+zZ8/4/vvvyZ07t842e3t7nRqleH5+foBcYxT/M0CuXLmSPAbg+vXrxMTEULx4cW7cuIGfn1+qrx0TE0NMTEyy9yUIgiAIgpAhnafiO2hXqlRJs65y5cop6hw+evRozWtjY2OdzuEfL2XKlJEkSZJq1qyZrmsnXkTncLGIRSxiEYtYvr7lqx1VB3JKgJs3b0pVqlSRqlSpIt26dUsnJcD9+/elli1bal67u7tLgYGBUsuWLaUyZcpImzdv1kpHUKRIEWnixImSi4uLVKhQIalx48bSvXv3pGvXrkkKhSJV187kX7xYxCIWsYhFLGL5zEtGf35nWOdwkEe+LVq0SDNKbv/+/QwaNEhrn1KlSmklppw9ezbZsmVj2bJlZM+encuXL9OwYUPCwsIAuUmtXr16DB06FEtLS16+fMmhQ4eYOnUqarU6VddOCTG6ThAEQRC+Hhn9uW2AHEEJH8mbNy++vr6ZXQxBEARBENIgX758vH79+rOfVwROycibNy+hoaGZXYzPxsrKCl9fX/Lly/dN3VdKiHsX9y7u/b9D3Lu4dyBDgibIwDxO34KM+qVnttDQ0P/cAxVP3Lu49/8ace/i3v9rMvreM3SSX0EQBEEQhG+JCJwEQRAEQRBSSARO/yHR0dFMmTKF6OjozC7KFyfuXdz7f424d3Hv/zVf6t5F53BBEARBEIQUEjVOgiAIgiAIKSQCJ0EQBEEQhBQSgZMgCIIgCEIKicBJEARBEAQhhUTg9JUbMGAAT58+JTIyEi8vL2rUqJHs/rVq1cLLy4vIyEiePHlCv379dPZp3bo1d+/eJSoqirt379KyZcsMKn36pObeW7VqhaenJ2/fviU4OJgLFy7QsGFDrX169OiBJEk6i6mpaUbfSqql5t5r166t975Kliyptd+3+L6vW7dO7717e3tr9vka3veaNWuyf/9+fH19kSQJV1fXTx7zrTzrqb33b+lZT+29f0vPemrv/Us+6yJw+oq1b9+eBQsW8Pvvv+Ps7MzZs2c5fPgwBQoU0Lu/o6MjHh4enD17FmdnZ6ZPn86iRYto3bq1Zp+qVauyfft2Nm3ahJOTE5s2bWLHjh1Urlz5S91WiqT23mvVqsXRo0dp0qQJLi4unDx5kgMHDlC+fHmt/YKDg3FwcNBastqw3tTee7wSJUpo3dfjx481277V933o0KFa95w/f34CAgLYuXOn1n5Z/X23sLDg1q1bKZ6o/Ft61lN779/Ss57ae4/3LTzrqb33L/2sS2L5OpdLly5Jy5Yt01p37949afr06Xr3nzlzpnTv3j2tdcuXL5cuXLigeb1t2zbJw8NDa5/Dhw9LW7ZsyfT7Tc+961u8vb2liRMnal736NFDCgwMzPR7+9z3Xrt2bUmSJMnGxibJc/5X3ndXV1cpNjZWKliw4Ff3vscvkiRJrq6uye7zLT3rqb13fcvX+qyn9t6/pWc9ve97Rj7rosbpK2VsbIyLiwuenp5a6z09PalevbreY6pVq6az/5EjR6hYsSJGRkbJ7pPUOTNDWu79YwYGBlhZWfHhwwet9ZaWljx79oyXL1/q/Zaa2dJz7zdu3OD169ccO3aMOnXqaG37r7zvvXv35tixY7x48UJrfVZ/31PrW3nWP4ev9VlPj6/9Wf8cMvJZF4HTV8rOzg4jIyP8/f211vv7++Pg4KD3GAcHB737GxsbY2dnl+w+SZ0zM6Tl3j82cuRILCws2LFjh2bdgwcPcHNzo0WLFnTq1ImoqCjOnz9PsWLFPmv50yMt9/7mzRt+/vln2rRpQ+vWrXn48CHHjx+nZs2amn3+C++7g4MDjRs3ZvXq1Vrrv4b3PbW+lWf9c/han/W0+Fae9fTK6Gfd6HMWVvjyJEnSem1gYKCz7lP7f7w+tefMLGktZ8eOHZkyZQqurq68e/dOs/7y5ctcvnxZ8/r8+fNcv36dwYMHM3To0M9X8M8gNff+6NEjHj16pHl96dIlChQowKhRozh79myazpmZ0lpONzc3goKC+Pvvv7XWf03ve2p8S896Wn0Lz3pqfGvPelpl9LMuapy+Uu/fv0elUul8S8iVK5fOt4l4fn5+evdXKpUEBAQku09S58wMabn3eO3bt2fNmjW0b9+e48ePJ7uvJElcvXqV4sWLp7vMn0t67j2xS5cuad3Xt/6+A/Tq1YtNmzahVCqT3S8rvu+p9a086+nxtT/rn8vX+KynV0Y/6yJw+koplUquXbtGgwYNtNY3aNCACxcu6D3m4sWLOvs3bNgQLy8vVCpVsvskdc7MkJZ7B/nb5/r16+ncuTMeHh4pulb58uV58+ZNusr7OaX13j/m7OysdV/f8vsO8jDt4sWLs2bNmhRdK6u976n1rTzrafUtPOufy9f4rKfHl3rWM73HvFjStrRv316Kjo6WevbsKZUqVUqaN2+eFBoaqhlFMH36dGnDhg2a/R0dHaWwsDBp7ty5UqlSpaSePXtK0dHRUuvWrTX7VKtWTVIqlZK7u7tUsmRJyd3dXYqJiZEqV66c6febnnvv2LGjFBMTIw0YMEDKnTu3ZrG2ttbsM2nSJKlhw4ZS4cKFJScnJ2nNmjVSTEyMVKlSpUy/3/Tc+9ChQyVXV1epWLFiUunSpaXp06dLkiRJrVq1+ubf9/hl48aN0sWLF/We82t43y0sLCQnJyfJyclJkiRJGjZsmOTk5CQVKFBA731/S896au/9W3rWU3vv39Kzntp7j1++0LOe+b8gsaR9GTBggOTj4yNFRUVJXl5eUs2aNTXb1q1bJ508eVJr/1q1aknXrl2ToqKipKdPn0r9+vXTOWebNm2k+/fvS9HR0dK9e/e0HrqstKTm3k+ePCnps27dOs0+8+bNk549eyZFRUVJ/v7+0j///CNVrVo10+8zvfc+evRo6fHjx1JERIQUEBAgnTlzRmrcuPF/4n0HJGtrayk8PFzq06eP3vN9De97/DDzpP5+v+VnPbX3/i0966m992/pWU/L3/yXetYN4n4QBEEQBEEQPkH0cRIEQRAEQUghETgJgiAIgiCkkAicBEEQBEEQUkgEToIgCIIgCCkkAidBEARBEIQUEoGTIAiCIAhCConASRAEQRAEIYVE4CQIgiAIgpBCInASBEEQBEFIIRE4CYIgCIIgpJAInARBEARBEFJIBE6CIAiCIAgp9H9r82GOUZrWYwAAAABJRU5ErkJggg==", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "x = sig1 / ref1\n", - "y = (sig2 - 50) / (ref2)\n", - "\n", - "y2 = (sig4 - 240) / (ref4)\n", - "plt.plot(x, y - 1.0 * x)\n", - "plt.plot(x, y2 - 1.0 * x)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 232, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([ 4.78982041, 224.95172753])" - ] - }, - "execution_count": 232, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "np.polyfit(sig1, sig2, deg = 1)" - ] - }, - { - "cell_type": "code", - "execution_count": 231, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 231, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.plot(sig1, sig2)" - ] - }, - { - "cell_type": "code", - "execution_count": 208, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(4.179300299429111, 4.491380465109155)" - ] - }, - "execution_count": 208, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "(sig2/sig1).mean(), (ref2/ref1).mean()\n" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [], - "source": [ - "tl = []\n", - "\n", - "for x in range(20):\n", - " tl += [x * 500000]\n", - " \n", - "_z = tl[-1] + 1500\n", - "for x in range(4):\n", - " tl += (np.arange(12) * 120 + x * 1500 + _z).tolist()\n", - "\n", - "_z = tl[-1] + 1500\n", - "for x in range(200):\n", - " tl += [x * 1500 + _z]\n", - "\n", - "\n", - "_z = tl[-1] + 1500\n", - "for _ in range(8):\n", - " _z = tl[-1] + 1500\n", - " for x in range(20):\n", - " tl += [x * 1200 + _z]\n", - "\n", - "_z = tl[-1] + 1500\n", - "for x in range(50):\n", - " tl += [x * 1500 * 4 + _z]\n", - "\n", - "\n", - "_z = tl[-1] + 1500\n", - "inv = 1000\n", - "for x in range(40):\n", - " tl += [x * 1500 * 4 + x * inv + _z]\n", - " inv += 5000" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 25, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.plot(tl[:], plot_arr[:, 0] / plot_arr[:, 1], '-')\n", - "#plt.xscale('log')" - ] - }, - { - "cell_type": "code", - "execution_count": 143, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 143, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.plot((np.array(tl[-50:]) - tl[-50])/1e6, plot_arr[-50:, 0] / plot_arr[-50:, 1], '.-')\n", - "#plt.xscale('log')" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": 61, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[ 4942][V][u_adpd6100.cpp:584] preset_config_1(): [ADPD] Preset_config 1 set for timeslot:0. Two ambient channels. Total 6 bytes\n", - "[ 4943][V][u_adpd6100.cpp:631] preset_config_2(): [ADPD] Preset_config 2 set for timeslot:1. Total 8 bytes\n", - "[ 4953][I][PAM.cpp:37] detector_preset_1(): [PAM] Preset 1 set\n", - "[ 4958][V][do_c.cpp:83] detector_preset(): [DO_C] ADPD detector preset with current: 50\n", - "[ 4965][V][do_c.cpp:43] arr_set(): [DO_C] Set line 0 to type 1 with 100 x 10Hz samples, actinic:0, sub:1\n", - "[ 4975][V][PAM.cpp:74] run_preprocess(): [PAM] Run type:1, number:100, freq: 10, actinic: 0, subfactor 1\n", - "[ 4984][V][PAM.cpp:112] run_arr(): [PAM] Sample: 100, ref: 100, amb: 100, dark: 100\n", - "[ 4991][V][data_utils.cpp:10] dataclass(): [DATA_UTIL] DATACLASS Created\n", - "[ 4998][V][data_utils.cpp:10] dataclass(): [DATA_UTIL] DATACLASS Created\n", - "[ 5004][V][data_utils.cpp:10] dataclass(): [DATA_UTIL] DATACLASS Created\n", - "[ 5011][V][data_utils.cpp:10] dataclass(): [DATA_UTIL] DATACLASS Created\n", - "[ 5017][V][data_utils.cpp:32] init(): [DATA_UTIL] Allocation 400 bytes\n", - "[ 5024][V][data_utils.cpp:61] clear(): [DATA_UTIL] ARR reset to 0\n", - "[ 5030][V][data_utils.cpp:32] init(): [DATA_UTIL] Allocation 400 bytes\n", - "[ 5036][V][data_utils.cpp:61] clear(): [DATA_UTIL] ARR reset to 0\n", - "[ 5042][V][data_utils.cpp:32] init(): [DATA_UTIL] Allocation 400 bytes\n", - "[ 5048][V][data_utils.cpp:61] clear(): [DATA_UTIL] ARR reset to 0\n", - "[ 5054][V][data_utils.cpp:32] init(): [DATA_UTIL] Allocation 400 bytes\n", - "[ 5061][V][data_utils.cpp:61] clear(): [DATA_UTIL] ARR reset to 0\n", - "[ 5066][V][PAM.cpp:120] run_arr(): [PAM] Memory allocation completed\n", - "[ 13584][V][data_utils.cpp:15] ~dataclass(): [DATA_UTIL] DATACLASS destroied\n", - "[ 13585][V][data_utils.cpp:22] clean(): [DATA_UTIL] Memory freed\n", - "[ 13586][V][data_utils.cpp:15] ~dataclass(): [DATA_UTIL] DATACLASS destroied\n", - "[ 13593][V][data_utils.cpp:22] clean(): [DATA_UTIL] Memory freed\n", - "[ 13598][V][data_utils.cpp:15] ~dataclass(): [DATA_UTIL] DATACLASS destroied\n", - "[ 13605][V][data_utils.cpp:22] clean(): [DATA_UTIL] Memory freed\n", - "[ 13611][V][data_utils.cpp:15] ~dataclass(): [DATA_UTIL] DATACLASS destroied\n", - "[ 13618][V][data_utils.cpp:22] clean(): [DATA_UTIL] Memory freed\n", - "\n" - ] - } - ], - "source": [ - "print(outputs)" - ] - }, - { - "cell_type": "code", - "execution_count": 48, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "6\n", - "[ 35920][V][u_adpd6100.cpp:584] preset_config_1(): [ADPD] Preset_config 1 set for timeslot:0. Two ambient channels. Total 6 bytes\n", - "\n", - "[ 35921][V][u_adpd6100.cpp:631] preset_config_2(): [ADPD] Preset_config 2 set for timeslot:1. Total 8 bytes\n", - "\n", - "[ 35931][I][PAM.cpp:37] detector_preset_1(): [PAM] Preset 1 set\n", - "\n", - "[ 35936][V][do_c.cpp:83] detector_preset(): [DO_C] ADPD detector preset with current: 110\n", - "\n", - "[ 35943][V][do_c.cpp:43] arr_set(): [DO_C] Set line 0 to type 1 with 50 x 50Hz samples, actinic:50, sub:1\n", - "\n", - "[ 35953][V][PAM.cpp:74] run_preprocess(): [PAM] Run type:1, number:50, freq: 50, actinic: 50, subfactor 1\n", - "\n", - "[ 35962][V][PAM.cpp:112] run_arr(): [PAM] Sample: 50, ref: 50, amb: 50, dark: 50\n", - "\n", - "[ 35969][V][data_utils.cpp:10] dataclass(): [DATA_UTIL] DATACLASS Created\n", - "\n", - "[ 35976][V][data_utils.cpp:10] dataclass(): [DATA_UTIL] DATACLASS Created\n", - "\n", - "[ 35982][V][data_utils.cpp:10] dataclass(): [DATA_UTIL] DATACLASS Created\n", - "\n", - "[ 35989][V][data_utils.cpp:10] dataclass(): [DATA_UTIL] DATACLASS Created\n", - "\n", - "[ 35995][V][data_utils.cpp:32] init(): [DATA_UTIL] Allocation 200 bytes\n", - "\n", - "[ 36002][V][data_utils.cpp:61] clear(): [DATA_UTIL] ARR reset to 0\n", - "\n", - "[ 36007][V][data_utils.cpp:32] init(): [DATA_UTIL] Allocation 200 bytes\n", - "\n", - "[ 36014][V][data_utils.cpp:61] clear(): [DATA_UTIL] ARR reset to 0\n", - "\n", - "[ 36020][V][data_utils.cpp:32] init(): [DATA_UTIL] Allocation 200 bytes\n", - "\n", - "[ 36026][V][data_utils.cpp:61] clear(): [DATA_UTIL] ARR reset to 0\n", - "\n", - "[ 36032][V][data_utils.cpp:32] init(): [DATA_UTIL] Allocation 200 bytes\n", - "\n", - "[ 36038][V][data_utils.cpp:61] clear(): [DATA_UTIL] ARR reset to 0\n", - "\n", - "[ 36044][V][PAM.cpp:120] run_arr(): [PAM] Memory allocation completed\n", - "\n", - "0, 765, 16455, 16444\n", - "0, 717, 16451, 16440\n", - "0, 714, 16452, 16436\n", - "0, 713, 16451, 16437\n", - "[ 0 765 16455 16444 0 717 16451 16440 0 714\n", - " 16452 16436 0 713 16451 16437 134475]\n", - "0, 715, 16451, 16436\n", - "0, 716, 16451, 16436\n", - "0, 718, 16451, 16437\n", - "0, 714, 16452, 16436\n", - "[ 0 715 16451 16436 0 716 16451 16436 0 718\n", - " 16451 16437 0 714 16452 16436 134413]\n", - "0, 715, 16452, 16438\n", - "0, 716, 16451, 16436\n", - "0, 713, 16451, 16436\n", - "0, 715, 16450, 16437\n", - "[ 0 715 16452 16438 0 716 16451 16436 0 713\n", - " 16451 16436 0 715 16450 16437 134410]\n", - "0, 714, 16453, 16437\n", - "0, 715, 16452, 16437\n", - "0, 714, 16450, 16437\n", - "0, 716, 16451, 16438\n", - "[ 0 714 16453 16437 0 715 16452 16437 0 714\n", - " 16450 16437 0 716 16451 16438 134414]\n", - "0, 716, 16451, 16437\n", - "0, 714, 16451, 16437\n", - "0, 711, 16451, 16438\n", - "0, 716, 16450, 16436\n", - "[ 0 716 16451 16437 0 714 16451 16437 0 711\n", - " 16451 16438 0 716 16450 16436 134408]\n", - "0, 714, 16450, 16438\n", - "0, 714, 16451, 16438\n", - "0, 714, 16451, 16437\n", - "0, 713, 16450, 16438\n", - "[ 0 714 16450 16438 0 714 16451 16438 0 714\n", - " 16451 16437 0 713 16450 16438 134408]\n", - "0, 715, 16450, 16437\n", - "0, 713, 16451, 16436\n", - "0, 716, 16451, 16436\n", - "0, 717, 16452, 16438\n", - "[ 0 715 16450 16437 0 713 16451 16436 0 716\n", - " 16451 16436 0 717 16452 16438 134412]\n", - "0, 715, 16452, 16437\n", - "0, 715, 16452, 16437\n", - "0, 716, 16451, 16439\n", - "0, 713, 16450, 16438\n", - "[ 0 715 16452 16437 0 715 16452 16437 0 716\n", - " 16451 16439 0 713 16450 16438 134415]\n", - "0, 713, 16452, 16437\n", - "0, 715, 16453, 16436\n", - "0, 715, 16452, 16437\n", - "0, 715, 16451, 16438\n", - "[ 0 713 16452 16437 0 715 16453 16436 0 715\n", - " 16452 16437 0 715 16451 16438 134414]\n", - "0, 713, 16451, 16437\n", - "0, 714, 16453, 16438\n", - "0, 715, 16450, 16440\n", - "0, 715, 16451, 16437\n", - "[ 0 713 16451 16437 0 714 16453 16438 0 715\n", - " 16450 16440 0 715 16451 16437 134414]\n", - "0, 712, 16451, 16436\n", - "0, 715, 16451, 16438\n", - "0, 715, 16451, 16436\n", - "0, 713, 16451, 16438\n", - "[ 0 712 16451 16436 0 715 16451 16438 0 715\n", - " 16451 16436 0 713 16451 16438 134407]\n", - "0, 713, 16453, 16436\n", - "0, 716, 16450, 16438\n", - "0, 716, 16452, 16437\n", - "0, 715, 16451, 16437\n", - "[ 0 713 16453 16436 0 716 16450 16438 0 716\n", - " 16452 16437 0 715 16451 16437 134414]\n", - "[ 36895][V][data_utils.cpp:15] ~dataclass(): [DATA_UTIL] DATACLASS destroied\n", - "\n", - "[ 36896][V][data_utils.cpp:22] clean(): [DATA_UTIL] Memory freed\n", - "\n", - "[ 36897][V][data_utils.cpp:15] ~dataclass(): [DATA_UTIL] DATACLASS destroied\n", - "\n", - "[ 36904][V][data_utils.cpp:22] clean(): [DATA_UTIL] Memory freed\n", - "\n", - "[ 36909][V][data_utils.cpp:15] ~dataclass(): [DATA_UTIL] DATACLASS destroied\n", - "\n", - "[ 36916][V][data_utils.cpp:22] clean(): [DATA_UTIL] Memory freed\n", - "\n", - "[ 36922][V][data_utils.cpp:15] ~dataclass(): [DATA_UTIL] DATACLASS destroied\n", - "\n", - "[ 36929][V][data_utils.cpp:22] clean(): [DATA_UTIL] Memory freed\n", - "\n", - "\n" - ] - } - ], - "source": [ - "\n", - "def line_parse(l:str)->str:\n", - " l = l.strip()\n", - " if len(l) < 1:return \"\"\n", - " if l[0] == '[':\n", - " print(l)\n", - " return \"\"\n", - " else:\n", - " return l.strip()\n", - "\n", - "with serial.Serial(\"COM4\", 115200, timeout = 5) as ser:\n", - "\n", - "\n", - " ser.write(cmd_str.encode())\n", - " data_ready = False\n", - " checked = False\n", - " ts = time.time()\n", - " while time.time() - ts < 1:\n", - " if ser.in_waiting > 0:\n", - " l = line_parse(ser.readline().decode())\n", - " if l == \"Wake!\":\n", - " ser.write(\"Ready\".encode())\n", - " data_ready = True\n", - " elif data_ready and l.isdigit():\n", - " ts = time.time()\n", - " data_len = int(l)\n", - " ser.write(\"GO\".encode())\n", - " a1 = ser.read(4 * (data_len + 1))\n", - " _a = np.frombuffer(a1, dtype=\">i4\")\n", - " if (_a[:-1].sum() == _a[-1]):\n", - " checked = True\n", - " elif l == \"DONE\":\n", - " ser.write(\"Check\".encode())\n", - " data_ready = False\n", - " print(_a)\n", - "\n", - " elif l == \"Finish\":\n", - " print(l)\n", - " break\n", - " else:\n", - " print(l)\n", - "\n", - " " - ] - }, - { - "cell_type": "code", - "execution_count": 41, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "6932649" - ] - }, - "execution_count": 41, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "_a[:-1].sum()" - ] - }, - { - "cell_type": "code", - "execution_count": 40, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([56363, 56363, 56363, 56363, 56363, 56363, 56363, 56363, 56363,\n", - " 56363, 56363, 56363, 56363, 56363, 56363, 56363, 56363, 56363,\n", - " 56363, 56363, 56363, 56363, 56363, 56363, 56363, 56363, 56363,\n", - " 56363, 56363, 56363, 56363, 56363, 56363, 56363, 56363, 56363,\n", - " 56363, 56363, 56363, 56363, 56363, 56363, 56363, 56363, 56363,\n", - " 56363, 56363, 56363, 56363, 56363, 56363, 56363, 56363, 56363,\n", - " 56363, 56363, 56363, 56363, 56363, 56363, 56363, 56363, 56363,\n", - " 56363, 56363, 56363, 56363, 56363, 56363, 56363, 56363, 56363,\n", - " 56363, 56363, 56363, 56363, 56363, 56363, 56363, 56363, 56363,\n", - " 56363, 56363, 56363, 56363, 56363, 56363, 56363, 56363, 56363,\n", - " 56363, 56363, 56363, 56363, 56363, 56363, 56363, 56363, 56363,\n", - " 56363, 56363, 56363, 56363, 56363, 56363, 56363, 56363, 56363,\n", - " 56363, 56363, 56363, 56363, 56363, 56363, 56363, 56363, 56363,\n", - " 56363, 56363, 56363, 56363, 56363, 56363, 7503])" - ] - }, - "execution_count": 40, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "_a" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "'200'" - ] - }, - "execution_count": 20, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "l" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "base", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.11.9" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/.vscode/examples/traces_loads.ipynb b/.vscode/examples/traces_loads.ipynb deleted file mode 100644 index 9218081..0000000 --- a/.vscode/examples/traces_loads.ipynb +++ /dev/null @@ -1,463 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "import numpy as np\n", - "import serial\n", - "import time\n", - "import matplotlib.pyplot as plt\n", - "from IPython import display\n", - "plt.style.use(\"dark_background\")" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "%matplotlib widget" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "def parse_data(l:str):\n", - " if len(l) < 10: return \"\", []\n", - " if l[:5] != \"Data:\": return \"\", []\n", - " s = l.split('\\t')\n", - "\n", - " if len(s) < 2: return \"\", []\n", - " _t = s[0].split(',')\n", - " if len(_t) < 2: return \"\", []\n", - " _type = _t[0][5:]\n", - " _size = int(_t[1][7:])\n", - " arr = np.fromstring(s[1], sep = ',', dtype=np.uint32)\n", - " if _type == \"ENV\":\n", - " env_type = np.bitwise_and(arr, 0xF000) >> 12\n", - " env_read = np.bitwise_and(arr, 0x0FFF)\n", - " env_time = np.bitwise_and(arr, 0xFFFF0000) >> 10\n", - " leaftemp_t = env_time[env_type == 4]\n", - " leaftemp = env_read[env_type == 4] / 10\n", - " timestemp_t = env_time[env_type < 4]\n", - " timestemp = env_type[env_type < 4]\n", - " return \"ENV\", [timestemp_t, timestemp, leaftemp_t, leaftemp]\n", - " elif _type in [\"Fluo\", \"Fluoref\", \"SUN\", \"leaf\", \"730\", \"730ref\"]:\n", - " return _type, [arr]\n", - " else:\n", - " print(_type)\n", - "\n", - " return \"\", []\n", - "\n", - "def gen_cmd_arr_line(mode:int, ir:int, num:int, freq:int, actinic:int, sub:int)->list:\n", - " return [mode, ir, num//256, num%256, freq//256, freq%256, actinic, sub]\n", - "\n", - "def ambit_run_arr(cmd_str, port = \"COM31\"):\n", - " timeout = 300\n", - " s = ''\n", - " _l = 0\n", - " result = {\"env_t0\": time.time()}\n", - "\n", - " with serial.Serial(\"COM31\", baudrate=115200) as ser:\n", - " t0 = time.time()\n", - " ser.write(cmd_str.encode())\n", - " while time.time() - t0 < timeout:\n", - " try:\n", - " if ser.in_waiting > 1:\n", - " c = ser.read()\n", - " if (c > bytes([0])) and (c < bytes([128])):\n", - " s += c.decode()\n", - " _l += 1\n", - " if (c == b\"\\n\") or (c == b\"\\r\"):\n", - " l = s\n", - " s = ''\n", - " _l = 0\n", - " if l[:-1] == \"BAD COMMAND\":\n", - " timeout = 1\n", - " continue\n", - " if l[:-1] == \"Data sent\":\n", - " timeout = .1\n", - " continue\n", - " #print(l)\n", - " d_type, data = parse_data(l)\n", - " if d_type == \"ENV\":\n", - " result.update({\"env_stamp_t\": data[0], \"env_stamp\": data[1], \"env_leaf_t\": data[2], \"env_leaf\": data[3]})\n", - " elif d_type != \"\":\n", - " result.update({d_type: data[0][:-1]})\n", - " else:\n", - " time.sleep(.1)\n", - " except KeyboardInterrupt:\n", - " break\n", - " return result\n", - "\n", - "def calc_arr_param(cmd: list, persist:bool):\n", - " cmd_arr = np.reshape(cmd, (-1, 8))\n", - " arr_length = cmd_arr.shape[0]\n", - " cmd_str = \"arrun,\" + str(arr_length) + \",\" + str(persist) + \",\"+ str(cmd)[1:-1] + \",\\n\"\n", - " cmd_str = cmd_str.replace(\" \", \"\")\n", - "\n", - " num_pts = cmd_arr[:, 2] * 256 + cmd_arr[:, 3]\n", - " mea_feq = 1 / (cmd_arr[:, 4] * 256 + cmd_arr[:, 5])\n", - " _t, mea_tml = 0, []\n", - " for _n, _f in zip(num_pts, mea_feq):\n", - " mea_tml += (np.arange(_n) * _f + _t).tolist()\n", - " _t = mea_tml[-1]\n", - " mea_tml = np.array(mea_tml) * 0.854\n", - " return cmd_str, mea_tml \n" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "class ambit_run():\n", - " def __init__(self, persist:bool = False) -> None:\n", - " self.cmd_list = []\n", - " self.led_persist = int(persist)\n", - " \n", - " def add(self, mode:int = 2, ir:int = 0, num:int = 100, freq:int = 100, actinic:int = 0, sub:int = 1):\n", - " self.cmd_list += [mode, ir, num//256, num%256, freq//256, freq%256, actinic, sub]\n", - " return\n", - " def run(self):\n", - " cmd_str, self.mea_tml = calc_arr_param(self.cmd_list, self.led_persist)\n", - " self.result = {\"env_tl\": self.mea_tml, \"env_t0\": time.time()}\n", - " self.result.update(ambit_run_arr(cmd_str))\n", - " return self.result\n", - "\n", - " def plot(self):\n", - " result = self.result\n", - " mea_tml = self.mea_tml\n", - " plot_list = [_k for _k in result.keys() if _k[:4] != \"env_\"]\n", - " fig, axes = plt.subplots(1, len(plot_list) + 1, sharex = True, figsize = (20, 6))\n", - " for n, _p in enumerate(plot_list):\n", - " axes[n + 1].plot(mea_tml[1:], result[_p][1:])\n", - " axes[n + 1].set_title(_p)\n", - " axes[0].plot(mea_tml[1:], (result[\"Fluo\"]/ result[\"Fluoref\"])[1:])\n", - " # axes[0].plot(result['env_stamp_t'][:-1]/854, result['env_stamp'][:-1]* np.mean((result[\"Fluo\"]/ result[\"Fluoref\"])[1:]) + .1)\n", - " ax = axes[0].twinx()\n", - " ax.plot(result['env_leaf_t']/1000, result['env_leaf'], 'r.-')\n", - " \n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "MPF1 = ambit_run(True)\n", - "MPF1.add(num = 10, freq = 5, actinic=0)\n", - "MPF1.add(num = 40, freq = 100, actinic=250) # 0.4s max\n", - "\n", - "MPF1.add(num = 10, freq = 100, actinic=200) # 0.1s \n", - "MPF1.add(num = 10, freq = 100, actinic=120) # 0.1s \n", - "MPF1.add(num = 10, freq = 100, actinic=100) # 0.1s \n", - "MPF1.add(num = 10, freq = 100, actinic=80) # 0.1s \n", - "MPF1.add(num = 10, freq = 100, actinic=60) # 0.1s \n", - "\n", - "MPF1.add(num = 40, freq = 100, actinic=240)\n", - "MPF1.add(num = 25, freq = 100, actinic=0)\n", - "MPF1.add(num = 50, freq = 10, actinic=0)\n", - "\n", - "MPF1.run()\n", - "MPF1.plot()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "ret = MPF1.result\n", - "plt.figure()\n", - "plt.plot(ret['Fluo'][5:],ret['Fluoref'][5:])" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "MPF2 = ambit_run(True)\n", - "MPF2.add(num = 25, freq = 100, actinic=250)\n", - "MPF2.add(num = 25, freq = 100, actinic=200)\n", - "MPF2.add(num = 25, freq = 100, actinic=150)\n", - "MPF2.add(num = 25, freq = 100, actinic=100)\n", - "MPF2.add(num = 25, freq = 100, actinic=250)\n", - "MPF2.add(num = 25, freq = 100, actinic=50)\n", - "# ret = MPF2.run()\n", - "# MPF2.plot()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "MPF3 = ambit_run(True)\n", - "MPF3.add(num = 25, freq = 100, actinic=250)\n", - "MPF3.add(num = 25, freq = 100, actinic=200)\n", - "MPF3.add(num = 25, freq = 100, actinic=150)\n", - "MPF3.add(num = 25, freq = 100, actinic=100)\n", - "MPF3.add(num = 25, freq = 100, actinic=250)\n", - "MPF3.add(num = 25, freq = 100, actinic=0)\n", - "# ret = MPF3.run()\n", - "# MPF3.plot()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "RGF1 = ambit_run(True)\n", - "RGF1.add(num = 25, freq = 100, actinic=250)\n", - "RGF1.add(num = 25, freq = 100, actinic=0)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "ACT1 = ambit_run(True)\n", - "ACT1.add(num=100, freq = 20, actinic=50)\n", - "\n", - "AMB1 = ambit_run()\n", - "AMB1.add(num=100, freq = 20, actinic=0)\n", - "\n", - "AMB2 = ambit_run()\n", - "AMB2.add(num=100, freq = 10, actinic=0)\n", - "\n", - "AMB3 = ambit_run()\n", - "AMB3.add(num=100, freq = 5, actinic=0)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "runlist = [MPF1] + [ACT1, MPF2] * 4 + [AMB1, MPF3] * 2 + [AMB2, MPF3] * 3 + [AMB3, RGF1] * 4\n", - "fig, axes = plt.subplots(1, 5, sharex = True, figsize = (20, 6))\n", - "ax = axes[0].twinx()\n", - "results = []\n", - "for n in runlist:\n", - " ret = n.run()\n", - " results.append(ret)\n", - " _tl = ret['env_tl']\n", - " _TL = _tl + ret['env_t0']\n", - " plot_list = [_k for _k in ret.keys() if _k[:4] != \"env_\"]\n", - " for n, _p in enumerate(plot_list):\n", - " axes[n + 1].plot(_TL[1:], ret[_p][1:])\n", - " axes[n + 1].set_title(_p)\n", - " axes[0].plot(_TL[1:], (ret[\"Fluo\"]/ ret[\"Fluoref\"])[1:])\n", - " # axes[0].plot(result['env_stamp_t'][:-1]/854, result['env_stamp'][:-1]* np.mean((result[\"Fluo\"]/ result[\"Fluoref\"])[1:]) + .1)\n", - " ax.plot(ret['env_leaf_t']/1000 + ret['env_t0'], ret['env_leaf'], 'r.')\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "fig, axes = plt.subplots(1, 5, sharex = True, figsize = (16, 6))\n", - "ax = axes[0].twinx()\n", - "for ret in results:\n", - " _tl = ret['env_tl']\n", - " _TL = _tl + ret['env_t0']\n", - " plot_list = [_k for _k in ret.keys() if _k[:4] != \"env_\"]\n", - " for n, _p in enumerate(plot_list):\n", - " axes[n + 1].plot(_TL[1:], ret[_p][1:])\n", - " axes[n + 1].set_title(_p)\n", - " axes[0].plot(_TL[1:], (ret[\"Fluo\"]/ ret[\"Fluoref\"])[1:])\n", - " \n", - " ax.plot(ret['env_leaf_t']/1000 + ret['env_t0'], ret['env_leaf'], 'r.')" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "fig, axes = plt.subplots(1, 1, sharex = True, figsize = (16, 6), facecolor = [0, 0, 0, 0])\n", - "ax = axes.twinx()\n", - "for ret in results:\n", - " _tl = ret['env_tl']\n", - " _TL = _tl + ret['env_t0']\n", - " axes.plot(_TL[1:], (ret[\"Fluo\"]/ ret[\"Fluoref\"])[1:])\n", - " \n", - " ax.plot(ret['env_leaf_t']/1000 + ret['env_t0'], ret['env_leaf'], 'r.')" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": 26, - "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "58ef9ac2162448afbde1ea528d540e3e", - "version_major": 2, - "version_minor": 0 - }, - "image/png": "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", - "text/html": [ - "\n", - "
\n", - "
\n", - " Figure\n", - "
\n", - " \n", - "
\n", - " " - ], - "text/plain": [ - "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "TEMP1 = ambit_run()\n", - "TEMP1.add(num=50, freq = 5, actinic=0)\n", - "TEMP1.add(num=100, freq = 5, actinic=250)\n", - "TEMP1.add(num=200, freq = 5, actinic=0)\n", - "ret_M0 = TEMP1.run()\n", - "TEMP1.plot()" - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "metadata": {}, - "outputs": [], - "source": [ - "norm = lambda x: (x - x[-1]) / (x.max() - x[-1])\n", - "norm = lambda x:x - x[:4].mean()" - ] - }, - { - "cell_type": "code", - "execution_count": 29, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "C:\\Users\\hjcbj\\AppData\\Local\\Temp\\ipykernel_4868\\2471166036.py:1: RuntimeWarning: More than 20 figures have been opened. Figures created through the pyplot interface (`matplotlib.pyplot.figure`) are retained until explicitly closed and may consume too much memory. (To control this warning, see the rcParam `figure.max_open_warning`). Consider using `matplotlib.pyplot.close()`.\n", - " plt.figure()\n" - ] - }, - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 29, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "977f06e1bcc2475487cd817bfe46ae8f", - "version_major": 2, - "version_minor": 0 - }, - "image/png": "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", - "text/html": [ - "\n", - "
\n", - "
\n", - " Figure\n", - "
\n", - " \n", - "
\n", - " " - ], - "text/plain": [ - "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.figure()\n", - "plt.plot(ret_EPT['env_leaf_t']/60000, norm(ret_EPT['env_leaf']), label = 'empty')\n", - "plt.plot(ret_C1['env_leaf_t']/60000, norm(ret_C1['env_leaf']), label = 'c1')\n", - "plt.plot(ret_C2['env_leaf_t']/60000, norm(ret_C2['env_leaf']), label = 'c1')\n", - "\n", - "plt.plot(ret_M0['env_leaf_t']/60000, norm(ret_M0['env_leaf']), label = 'm0')\n", - "plt.plot(ret_M1['env_leaf_t']/60000, norm(ret_M1['env_leaf']), label = 'm1')\n", - "\n", - "\n", - "plt.plot(ret_OLD['env_leaf_t']/60000, norm(ret_OLD['env_leaf']), label = 'old')\n", - "\n", - "\n", - "\n", - "plt.legend()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "base", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.11.5" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/.vscode/examples/traces_loads_qProtocols.ipynb b/.vscode/examples/traces_loads_qProtocols.ipynb deleted file mode 100644 index 2adc495..0000000 --- a/.vscode/examples/traces_loads_qProtocols.ipynb +++ /dev/null @@ -1,550 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "import numpy as np\n", - "import serial\n", - "import time\n", - "import matplotlib.pyplot as plt\n", - "from IPython import display\n", - "plt.style.use(\"dark_background\")" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "%matplotlib widget" - ] - }, - { - "cell_type": "code", - "execution_count": 52, - "metadata": {}, - "outputs": [], - "source": [ - "def parse_data(l:str):\n", - " if len(l) < 10: return \"\", []\n", - " if l[:5] != \"Data:\": return \"\", []\n", - " s = l.split('\\t')\n", - "\n", - " if len(s) < 2: return \"\", []\n", - " _t = s[0].split(',')\n", - " if len(_t) < 2: return \"\", []\n", - " _type = _t[0][5:]\n", - " _size = int(_t[1][7:])\n", - " arr = np.fromstring(s[1], sep = ',', dtype=np.uint32)\n", - " if _type == \"ENV\":\n", - " env_type = np.bitwise_and(arr, 0xF000) >> 12\n", - " env_read = np.bitwise_and(arr, 0x0FFF)\n", - " env_time = np.bitwise_and(arr, 0xFFFF0000) >> 10\n", - " leaftemp_t = env_time[env_type == 4]\n", - " leaftemp = env_read[env_type == 4] / 10\n", - " timestemp_t = env_time[env_type < 4]\n", - " timestemp = env_type[env_type < 4]\n", - " return \"ENV\", [timestemp_t, timestemp, leaftemp_t, leaftemp]\n", - " elif _type in [\"Fluo\", \"Fluoref\", \"SUN\", \"leaf\", \"730\", \"730ref\"]:\n", - " return _type, [arr]\n", - " else:\n", - " print(_type)\n", - "\n", - " return \"\", []\n", - "\n", - "def gen_cmd_arr_line(mode:int, ir:int, num:int, freq:int, actinic:int, sub:int)->list:\n", - " return [mode, ir, num//256, num%256, freq//256, freq%256, actinic, sub]\n", - "\n", - "def ambit_run_arr(cmd_str, port = \"COM31\"):\n", - " timeout = 60\n", - " s = ''\n", - " _l = 0\n", - " result = {\"env_t0\": time.time()}\n", - "\n", - " with serial.Serial(port, baudrate=115200) as ser:\n", - " t0 = time.time()\n", - " ser.write(cmd_str.encode())\n", - " while time.time() - t0 < timeout:\n", - " try:\n", - " if ser.in_waiting > 1:\n", - " c = ser.read()\n", - " if (c > bytes([0])) and (c < bytes([128])):\n", - " s += c.decode()\n", - " _l += 1\n", - " if (c == b\"\\n\") or (c == b\"\\r\"):\n", - " l = s\n", - " s = ''\n", - " _l = 0\n", - " if l[:-1] == \"BAD COMMAND\":\n", - " timeout = 1\n", - " continue\n", - " if l[:-1] == \"Data sent\":\n", - " timeout = .1\n", - " continue\n", - " #print(l)\n", - " d_type, data = parse_data(l)\n", - " if d_type == \"ENV\":\n", - " result.update({\"env_stamp_t\": data[0], \"env_stamp\": data[1], \"env_leaf_t\": data[2], \"env_leaf\": data[3]})\n", - " elif d_type != \"\":\n", - " result.update({d_type: data[0][:-1]})\n", - " else:\n", - " time.sleep(.1)\n", - " except KeyboardInterrupt:\n", - " break\n", - " return result\n", - "\n", - "def calc_arr_param(cmd: list, persist:bool):\n", - " cmd_arr = np.reshape(cmd, (-1, 8))\n", - " arr_length = cmd_arr.shape[0]\n", - " cmd_str = \"arrun,\" + str(arr_length) + \",\" + str(persist) + \",\"+ str(cmd)[1:-1] + \",\\n\"\n", - " cmd_str = cmd_str.replace(\" \", \"\")\n", - "\n", - " num_pts = cmd_arr[:, 2] * 256 + cmd_arr[:, 3]\n", - " mea_feq = 1 / (cmd_arr[:, 4] * 256 + cmd_arr[:, 5])\n", - " _t, mea_tml = 0, []\n", - " for _n, _f in zip(num_pts, mea_feq):\n", - " mea_tml += (np.arange(_n) * _f + _t).tolist()\n", - " _t = mea_tml[-1]\n", - " mea_tml = np.array(mea_tml) * 0.854\n", - " return cmd_str, mea_tml \n" - ] - }, - { - "cell_type": "code", - "execution_count": 53, - "metadata": {}, - "outputs": [], - "source": [ - "class ambit_run():\n", - " def __init__(self, persist:bool = False) -> None:\n", - " self.cmd_list = []\n", - " self.led_persist = int(persist)\n", - " \n", - " def add(self, mode:int = 2, ir:int = 0, num:int = 100, freq:int = 100, actinic:int = 0, sub:int = 1):\n", - " self.cmd_list += [mode, ir, num//256, num%256, freq//256, freq%256, actinic, sub]\n", - " return\n", - " def run(self):\n", - " cmd_str, self.mea_tml = calc_arr_param(self.cmd_list, self.led_persist)\n", - " self.result = {\"env_tl\": self.mea_tml, \"env_t0\": time.time()}\n", - " self.result.update(ambit_run_arr(cmd_str))\n", - " return self.result\n", - "\n", - " def plot(self):\n", - " result = self.result\n", - " mea_tml = self.mea_tml\n", - " plot_list = [_k for _k in result.keys() if _k[:4] != \"env_\"]\n", - " fig, axes = plt.subplots(1, len(plot_list) + 1, sharex = True, figsize = (20, 6))\n", - " for n, _p in enumerate(plot_list):\n", - " axes[n + 1].plot(mea_tml[1:], result[_p][1:])\n", - " axes[n + 1].set_title(_p)\n", - " axes[0].plot(mea_tml[1:], (result[\"Fluo\"]/ result[\"Fluoref\"])[1:])\n", - " # axes[0].plot(result['env_stamp_t'][:-1]/854, result['env_stamp'][:-1]* np.mean((result[\"Fluo\"]/ result[\"Fluoref\"])[1:]) + .1)\n", - " ax = axes[0].twinx()\n", - " ax.plot(result['env_leaf_t']/1000, result['env_leaf'], 'r.-')\n", - " \n" - ] - }, - { - "cell_type": "code", - "execution_count": 74, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "cmd: set_currents\n", - "\n", - "Currents set to 110, 0, 80\n", - "\n" - ] - } - ], - "source": [ - "def set_led(port = \"COM31\"):\n", - " cmd_str = \"set_currents,110,0,80,\\n\"\n", - " #cmd_str = \"set_gains,1,4,4,1,5,5,\\n\"\n", - "\n", - " s = \"\"\n", - " with serial.Serial(port, baudrate=115200) as ser:\n", - " t0 = time.time()\n", - " ser.write(cmd_str.encode())\n", - " while time.time() - t0 < 1:\n", - " if ser.in_waiting > 0:\n", - " c = ser.read()\n", - " if (c > bytes([0])) and (c < bytes([128])):\n", - " s += c.decode()\n", - " if (c == b\"\\n\") or (c == b\"\\r\"):\n", - " l = s\n", - " s = ''\n", - " print(l)\n", - "\n", - "\n", - "set_led()" - ] - }, - { - "cell_type": "code", - "execution_count": 78, - "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "d02bd63e4cbd4c8799d429a5f3ddd235", - "version_major": 2, - "version_minor": 0 - }, - "image/png": "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", - "text/html": [ - "\n", - "
\n", - "
\n", - " Figure\n", - "
\n", - " \n", - "
\n", - " " - ], - "text/plain": [ - "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "ename": "ValueError", - "evalue": "5 is not a valid MouseButton", - "output_type": "error", - "traceback": [ - "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[1;31mValueError\u001b[0m Traceback (most recent call last)", - "File \u001b[1;32mc:\\Users\\hjcbj\\anaconda3\\Lib\\site-packages\\ipympl\\backend_nbagg.py:279\u001b[0m, in \u001b[0;36mCanvas._handle_message\u001b[1;34m(self, object, content, buffers)\u001b[0m\n\u001b[0;32m 276\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mmanager\u001b[38;5;241m.\u001b[39mhandle_json(content)\n\u001b[0;32m 278\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m--> 279\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mmanager\u001b[38;5;241m.\u001b[39mhandle_json(content)\n", - "File \u001b[1;32mc:\\Users\\hjcbj\\anaconda3\\Lib\\site-packages\\matplotlib\\backends\\backend_webagg_core.py:464\u001b[0m, in \u001b[0;36mFigureManagerWebAgg.handle_json\u001b[1;34m(self, content)\u001b[0m\n\u001b[0;32m 463\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mhandle_json\u001b[39m(\u001b[38;5;28mself\u001b[39m, content):\n\u001b[1;32m--> 464\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mcanvas\u001b[38;5;241m.\u001b[39mhandle_event(content)\n", - "File \u001b[1;32mc:\\Users\\hjcbj\\anaconda3\\Lib\\site-packages\\matplotlib\\backends\\backend_webagg_core.py:264\u001b[0m, in \u001b[0;36mFigureCanvasWebAggCore.handle_event\u001b[1;34m(self, event)\u001b[0m\n\u001b[0;32m 261\u001b[0m e_type \u001b[38;5;241m=\u001b[39m event[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mtype\u001b[39m\u001b[38;5;124m'\u001b[39m]\n\u001b[0;32m 262\u001b[0m handler \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mgetattr\u001b[39m(\u001b[38;5;28mself\u001b[39m, \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mhandle_\u001b[39m\u001b[38;5;132;01m{\u001b[39;00me_type\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m'\u001b[39m,\n\u001b[0;32m 263\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mhandle_unknown_event)\n\u001b[1;32m--> 264\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m handler(event)\n", - "File \u001b[1;32mc:\\Users\\hjcbj\\anaconda3\\Lib\\site-packages\\matplotlib\\backends\\backend_webagg_core.py:294\u001b[0m, in \u001b[0;36mFigureCanvasWebAggCore._handle_mouse\u001b[1;34m(self, event)\u001b[0m\n\u001b[0;32m 291\u001b[0m guiEvent \u001b[38;5;241m=\u001b[39m event\u001b[38;5;241m.\u001b[39mget(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mguiEvent\u001b[39m\u001b[38;5;124m'\u001b[39m)\n\u001b[0;32m 292\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m e_type \u001b[38;5;129;01min\u001b[39;00m [\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mbutton_press\u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mbutton_release\u001b[39m\u001b[38;5;124m'\u001b[39m]:\n\u001b[0;32m 293\u001b[0m MouseEvent(e_type \u001b[38;5;241m+\u001b[39m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124m_event\u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[38;5;28mself\u001b[39m, x, y, button,\n\u001b[1;32m--> 294\u001b[0m modifiers\u001b[38;5;241m=\u001b[39mmodifiers, guiEvent\u001b[38;5;241m=\u001b[39mguiEvent)\u001b[38;5;241m.\u001b[39m_process()\n\u001b[0;32m 295\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m e_type \u001b[38;5;241m==\u001b[39m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mdblclick\u001b[39m\u001b[38;5;124m'\u001b[39m:\n\u001b[0;32m 296\u001b[0m MouseEvent(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mbutton_press_event\u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[38;5;28mself\u001b[39m, x, y, button, dblclick\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m,\n\u001b[0;32m 297\u001b[0m modifiers\u001b[38;5;241m=\u001b[39mmodifiers, guiEvent\u001b[38;5;241m=\u001b[39mguiEvent)\u001b[38;5;241m.\u001b[39m_process()\n", - "File \u001b[1;32mc:\\Users\\hjcbj\\anaconda3\\Lib\\site-packages\\matplotlib\\backend_bases.py:1271\u001b[0m, in \u001b[0;36mEvent._process\u001b[1;34m(self)\u001b[0m\n\u001b[0;32m 1269\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_process\u001b[39m(\u001b[38;5;28mself\u001b[39m):\n\u001b[0;32m 1270\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124;03m\"\"\"Process this event on ``self.canvas``, then unset ``guiEvent``.\"\"\"\u001b[39;00m\n\u001b[1;32m-> 1271\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mcanvas\u001b[38;5;241m.\u001b[39mcallbacks\u001b[38;5;241m.\u001b[39mprocess(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mname, \u001b[38;5;28mself\u001b[39m)\n\u001b[0;32m 1272\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_guiEvent_deleted \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mTrue\u001b[39;00m\n", - "File \u001b[1;32mc:\\Users\\hjcbj\\anaconda3\\Lib\\site-packages\\matplotlib\\cbook.py:303\u001b[0m, in \u001b[0;36mCallbackRegistry.process\u001b[1;34m(self, s, *args, **kwargs)\u001b[0m\n\u001b[0;32m 301\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m exc:\n\u001b[0;32m 302\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mexception_handler \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m--> 303\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mexception_handler(exc)\n\u001b[0;32m 304\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m 305\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m\n", - "File \u001b[1;32mc:\\Users\\hjcbj\\anaconda3\\Lib\\site-packages\\matplotlib\\cbook.py:87\u001b[0m, in \u001b[0;36m_exception_printer\u001b[1;34m(exc)\u001b[0m\n\u001b[0;32m 85\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_exception_printer\u001b[39m(exc):\n\u001b[0;32m 86\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m _get_running_interactive_framework() \u001b[38;5;129;01min\u001b[39;00m [\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mheadless\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;28;01mNone\u001b[39;00m]:\n\u001b[1;32m---> 87\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m exc\n\u001b[0;32m 88\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m 89\u001b[0m traceback\u001b[38;5;241m.\u001b[39mprint_exc()\n", - "File \u001b[1;32mc:\\Users\\hjcbj\\anaconda3\\Lib\\site-packages\\matplotlib\\cbook.py:298\u001b[0m, in \u001b[0;36mCallbackRegistry.process\u001b[1;34m(self, s, *args, **kwargs)\u001b[0m\n\u001b[0;32m 296\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m func \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m 297\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m--> 298\u001b[0m func(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[0;32m 299\u001b[0m \u001b[38;5;66;03m# this does not capture KeyboardInterrupt, SystemExit,\u001b[39;00m\n\u001b[0;32m 300\u001b[0m \u001b[38;5;66;03m# and GeneratorExit\u001b[39;00m\n\u001b[0;32m 301\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m exc:\n", - "File \u001b[1;32mc:\\Users\\hjcbj\\anaconda3\\Lib\\site-packages\\matplotlib\\backend_bases.py:2567\u001b[0m, in \u001b[0;36mbutton_press_handler\u001b[1;34m(event, canvas, toolbar)\u001b[0m\n\u001b[0;32m 2565\u001b[0m toolbar \u001b[38;5;241m=\u001b[39m canvas\u001b[38;5;241m.\u001b[39mtoolbar\n\u001b[0;32m 2566\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m toolbar \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m-> 2567\u001b[0m button_name \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mstr\u001b[39m(MouseButton(event\u001b[38;5;241m.\u001b[39mbutton))\n\u001b[0;32m 2568\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m button_name \u001b[38;5;129;01min\u001b[39;00m rcParams[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mkeymap.back\u001b[39m\u001b[38;5;124m'\u001b[39m]:\n\u001b[0;32m 2569\u001b[0m toolbar\u001b[38;5;241m.\u001b[39mback()\n", - "File \u001b[1;32mc:\\Users\\hjcbj\\anaconda3\\Lib\\enum.py:712\u001b[0m, in \u001b[0;36mEnumType.__call__\u001b[1;34m(cls, value, names, module, qualname, type, start, boundary)\u001b[0m\n\u001b[0;32m 687\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[0;32m 688\u001b[0m \u001b[38;5;124;03mEither returns an existing member, or creates a new enum class.\u001b[39;00m\n\u001b[0;32m 689\u001b[0m \n\u001b[1;32m (...)\u001b[0m\n\u001b[0;32m 709\u001b[0m \u001b[38;5;124;03m`type`, if set, will be mixed in as the first base class.\u001b[39;00m\n\u001b[0;32m 710\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[0;32m 711\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m names \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m: \u001b[38;5;66;03m# simple value lookup\u001b[39;00m\n\u001b[1;32m--> 712\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mcls\u001b[39m\u001b[38;5;241m.\u001b[39m\u001b[38;5;21m__new__\u001b[39m(\u001b[38;5;28mcls\u001b[39m, value)\n\u001b[0;32m 713\u001b[0m \u001b[38;5;66;03m# otherwise, functional API: we're creating a new Enum type\u001b[39;00m\n\u001b[0;32m 714\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mcls\u001b[39m\u001b[38;5;241m.\u001b[39m_create_(\n\u001b[0;32m 715\u001b[0m value,\n\u001b[0;32m 716\u001b[0m names,\n\u001b[1;32m (...)\u001b[0m\n\u001b[0;32m 721\u001b[0m boundary\u001b[38;5;241m=\u001b[39mboundary,\n\u001b[0;32m 722\u001b[0m )\n", - "File \u001b[1;32mc:\\Users\\hjcbj\\anaconda3\\Lib\\enum.py:1128\u001b[0m, in \u001b[0;36mEnum.__new__\u001b[1;34m(cls, value)\u001b[0m\n\u001b[0;32m 1126\u001b[0m ve_exc \u001b[38;5;241m=\u001b[39m \u001b[38;5;167;01mValueError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;132;01m%r\u001b[39;00m\u001b[38;5;124m is not a valid \u001b[39m\u001b[38;5;132;01m%s\u001b[39;00m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;241m%\u001b[39m (value, \u001b[38;5;28mcls\u001b[39m\u001b[38;5;241m.\u001b[39m\u001b[38;5;18m__qualname__\u001b[39m))\n\u001b[0;32m 1127\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m result \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;129;01mand\u001b[39;00m exc \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m-> 1128\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m ve_exc\n\u001b[0;32m 1129\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m exc \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m 1130\u001b[0m exc \u001b[38;5;241m=\u001b[39m \u001b[38;5;167;01mTypeError\u001b[39;00m(\n\u001b[0;32m 1131\u001b[0m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124merror in \u001b[39m\u001b[38;5;132;01m%s\u001b[39;00m\u001b[38;5;124m._missing_: returned \u001b[39m\u001b[38;5;132;01m%r\u001b[39;00m\u001b[38;5;124m instead of None or a valid member\u001b[39m\u001b[38;5;124m'\u001b[39m\n\u001b[0;32m 1132\u001b[0m \u001b[38;5;241m%\u001b[39m (\u001b[38;5;28mcls\u001b[39m\u001b[38;5;241m.\u001b[39m\u001b[38;5;18m__name__\u001b[39m, result)\n\u001b[0;32m 1133\u001b[0m )\n", - "\u001b[1;31mValueError\u001b[0m: 5 is not a valid MouseButton" - ] - } - ], - "source": [ - "IR1 = ambit_run(False)\n", - "IR1.add(mode = 1, ir = 0, num = 20, freq = 2, actinic = 0, sub = 1)\n", - "IR1.add(mode = 1, ir = 0, num = 20, freq = 2, actinic = 5, sub = 1)\n", - "IR1.add(mode = 1, ir = 1, num = 20, freq = 2, actinic = 5, sub = 1)\n", - "IR1.add(mode = 1, ir = 0, num = 20, freq = 2, actinic = 5, sub = 1)\n", - "IR1.add(mode = 1, ir = 0, num = 20, freq = 2, actinic = 0, sub = 1)\n", - "IR1.run()\n", - "IR1.plot()\n" - ] - }, - { - "cell_type": "code", - "execution_count": 77, - "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "b360e1d6e7b644b692e2c8d5e9c88fab", - "version_major": 2, - "version_minor": 0 - }, - "image/png": "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", - "text/html": [ - "\n", - "
\n", - "
\n", - " Figure\n", - "
\n", - " \n", - "
\n", - " " - ], - "text/plain": [ - "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "IR1 = ambit_run(False)\n", - "IR1.add(mode = 1, ir = 0, num = 20, freq = 2, actinic = 0, sub = 1)\n", - "IR1.add(mode = 1, ir = 0, num = 20, freq = 2, actinic = 5, sub = 1)\n", - "IR1.add(mode = 1, ir = 0, num = 20, freq = 2, actinic = 5, sub = 1)\n", - "IR1.add(mode = 1, ir = 0, num = 20, freq = 2, actinic = 5, sub = 1)\n", - "IR1.add(mode = 1, ir = 0, num = 20, freq = 2, actinic = 0, sub = 1)\n", - "IR1.run()\n", - "IR1.plot()\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "MPF1 = ambit_run(True)\n", - "MPF1.add(num = 50, freq = 50, actinic=0)\n", - "MPF1.add(num = 50, freq = 50, actinic=10)\n", - "MPF1.add(num = 50, freq = 50, actinic=0)\n", - "\n", - "MPF1.add(num = 50, freq = 10, actinic=0)\n", - "\n", - "\n", - "MPF1.add(num = 50, freq = 50, actinic=0)\n", - "MPF1.add(num = 50, freq = 50, actinic=10)\n", - "MPF1.add(num = 50, freq = 50, actinic=0)\n", - "\n", - "MPF1.run()\n", - "MPF1.plot()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "plt.figure()\n", - "plt.plot(MPF1.result['Fluo']/MPF1.result['Fluoref'])" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "MPF1 = ambit_run(True)\n", - "MPF1.add(num = 10, freq = 5, actinic=0)\n", - "MPF1.add(num = 40, freq = 100, actinic=250) # 0.4s max\n", - "\n", - "MPF1.add(num = 10, freq = 100, actinic=200) # 0.1s \n", - "MPF1.add(num = 10, freq = 100, actinic=120) # 0.1s \n", - "MPF1.add(num = 10, freq = 100, actinic=100) # 0.1s \n", - "MPF1.add(num = 10, freq = 100, actinic=80) # 0.1s \n", - "MPF1.add(num = 10, freq = 100, actinic=60) # 0.1s \n", - "\n", - "MPF1.add(num = 40, freq = 100, actinic=240)\n", - "MPF1.add(num = 25, freq = 100, actinic=0)\n", - "MPF1.add(num = 50, freq = 10, actinic=0)\n", - "\n", - "MPF1.run()\n", - "MPF1.plot()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "actinic_setting = 10" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "MPF2 = ambit_run(True)\n", - "MPF2.add(num = 25, freq = 100, actinic=250)\n", - "MPF2.add(num = 25, freq = 100, actinic=200)\n", - "MPF2.add(num = 25, freq = 100, actinic=150)\n", - "MPF2.add(num = 25, freq = 100, actinic=100)\n", - "MPF2.add(num = 25, freq = 100, actinic=250)\n", - "MPF2.add(num = 25, freq = 100, actinic=actinic_setting)\n", - "# ret = MPF2.run()\n", - "# MPF2.plot()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "MPF3 = ambit_run(True)\n", - "MPF3.add(num = 25, freq = 100, actinic=250)\n", - "MPF3.add(num = 25, freq = 100, actinic=200)\n", - "MPF3.add(num = 25, freq = 100, actinic=150)\n", - "MPF3.add(num = 25, freq = 100, actinic=100)\n", - "MPF3.add(num = 25, freq = 100, actinic=250)\n", - "MPF3.add(num = 25, freq = 100, actinic=0)\n", - "# ret = MPF3.run()\n", - "# MPF3.plot()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "RGF1 = ambit_run(True)\n", - "RGF1.add(num = 50, freq = 100, actinic=250)\n", - "RGF1.add(num = 50, freq = 100, actinic=0)\n", - "\n", - "RGF2 = ambit_run(True)\n", - "RGF2.add(num = 50, freq = 100, actinic=250)\n", - "RGF2.add(num = 50, freq = 100, actinic=actinic_setting)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "ACT1 = ambit_run(True)\n", - "ACT1.add(num=100, freq = 20, actinic=actinic_setting)\n", - "\n", - "AMB1 = ambit_run()\n", - "AMB1.add(num = 100, freq = 20, actinic=0)\n", - "AMB1.add(num = 50, freq = 100, actinic=250)\n", - "AMB1.add(num = 50, freq = 100, actinic=0)\n", - "AMB1.add(num = 100, freq = 20, actinic=0)\n", - "\n", - "AMB2 = ambit_run()\n", - "AMB2.add(num=100, freq = 10, actinic=0)\n", - "AMB2.add(num = 50, freq = 100, actinic=250)\n", - "AMB2.add(num = 50, freq = 100, actinic=0)\n", - "AMB2.add(num=100, freq = 10, actinic=0)\n", - "\n", - "AMB3 = ambit_run()\n", - "AMB3.add(num=100, freq = 5, actinic=0)\n", - "AMB3.add(num = 50, freq = 100, actinic=250)\n", - "AMB3.add(num = 50, freq = 100, actinic=0)\n", - "AMB3.add(num=100, freq = 5, actinic=0)\n", - "\n", - "AMB4 = ambit_run()\n", - "AMB4.add(num=60, freq = 1, actinic=0)\n", - "AMB4.add(num = 50, freq = 100, actinic=250)\n", - "AMB4.add(num = 50, freq = 100, actinic=0)\n", - "AMB4.add(num=60, freq = 1, actinic=0)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "runlist = [MPF1] + [ACT1, RGF2] * 4 + [AMB1] * 2 + [AMB2] * 2 + [AMB3] * 2 + [AMB4] * 2\n", - "fig, axes = plt.subplots(1, 5, sharex = True, figsize = (20, 6))\n", - "ax = axes[0].twinx()\n", - "results = []\n", - "for n in runlist:\n", - " ret = n.run()\n", - " results.append(ret)\n", - " _tl = ret['env_tl']\n", - " _TL = _tl + ret['env_t0']\n", - " plot_list = [_k for _k in ret.keys() if _k[:4] != \"env_\"]\n", - " for n, _p in enumerate(plot_list):\n", - " axes[n + 1].plot(_TL[1:], ret[_p][1:])\n", - " axes[n + 1].set_title(_p)\n", - " axes[0].plot(_TL[1:], (ret[\"Fluo\"]/ ret[\"Fluoref\"])[1:])\n", - " # axes[0].plot(result['env_stamp_t'][:-1]/854, result['env_stamp'][:-1]* np.mean((result[\"Fluo\"]/ result[\"Fluoref\"])[1:]) + .1)\n", - " ax.plot(ret['env_leaf_t']/1000 + ret['env_t0'], ret['env_leaf'], 'r.')\n", - " display.display(fig)\n", - " display.clear_output(True)\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "fig, axes = plt.subplots(1, 1, sharex = True, figsize = (16, 6), facecolor = [0, 0, 0, 0])\n", - "ax = axes.twinx()\n", - "for ret in results:\n", - " _tl = ret['env_tl']\n", - " _TL = _tl + ret['env_t0']\n", - " axes.plot(_TL[1:], (ret[\"Fluo\"]/ ret[\"Fluoref\"])[1:])\n", - " \n", - " ax.plot(ret['env_leaf_t']/1000 + ret['env_t0'], ret['env_leaf'], 'r.')" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "base", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.11.5" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/.vscode/examples/uploader_v2.ipynb b/.vscode/examples/uploader_v2.ipynb deleted file mode 100644 index 88f7211..0000000 --- a/.vscode/examples/uploader_v2.ipynb +++ /dev/null @@ -1,278 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "id": "0cf1e568", - "metadata": {}, - "outputs": [], - "source": [ - "import serial\n", - "import serial.tools.list_ports\n", - "import subprocess, os\n", - "import sys\n", - "import time\n" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "5033d621", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "['COM34']" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "def serial_ports():\n", - " ports = serial.tools.list_ports.comports()\n", - " Flasherport = []\n", - " for port, desc, hwid in sorted(ports):\n", - " if hwid[:4] == \"USB \":\n", - " devices = hwid[4:].split(\" \")\n", - " if len(devices) > 1 and len(devices[0]) > 9:\n", - " if devices[0][-9:] == \"1A86:55D4\":\n", - " Flasherport.append(port)\n", - "\n", - " return Flasherport\n", - "\n", - "serial_ports()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "24669334", - "metadata": {}, - "outputs": [], - "source": [ - "while True:\n", - " flash_new_ambit = False\n", - "\n", - " with serial.Serial('COM34', 115200) as ser:\n", - " t0 = time.time()\n", - " s = \"\"\n", - " counter = 0\n", - " while time.time() - t0 < 5:\n", - " while (ser.in_waiting > 0) and (counter < 300):\n", - " c = ser.read()\n", - " if c > bytes([9]) and c < bytes([127]):\n", - " counter += 1\n", - " s += c.decode()\n", - "\n", - " if (counter > 20):\n", - " if \"invalid header\" in s:\n", - " flash_new_ambit = True\n", - " break\n", - " else:\n", - " if c.isascii():\n", - " print(c.decode(), end=\"\")\n", - " if (counter >= 49): break\n", - " if flash_new_ambit: break\n", - " time.sleep(.25)\n", - " print(\".\", end=\"\")" - ] - }, - { - "cell_type": "code", - "execution_count": 35, - "id": "31f542eb", - "metadata": {}, - "outputs": [], - "source": [ - "def ser_get_lines(ser: serial.Serial, n:int = -1, no_resp_timeout:float = 0.5, max_timeout:float = 50, display:bool = False, ter:str = \"\") -> list[str]:\n", - " start_t0:float = time.perf_counter()\n", - " last_char_t:float = time.perf_counter()\n", - " a_line:str = \"\"\n", - " ret_list:list[str] = []\n", - " counter:int = 0\n", - " if n == -1: n = 10000\n", - "\n", - " while True:\n", - " if time.perf_counter() - start_t0 > max_timeout: break\n", - " if time.perf_counter() - last_char_t > no_resp_timeout: break\n", - " if len(ret_list) >= n: break\n", - "\n", - " while (ser.in_waiting > 0):\n", - " c:bytes = ser.read()\n", - "\n", - " if c.isascii():\n", - " _char:str = c.decode()\n", - " if _char == '\\n' or _char == '\\r':\n", - " if counter > 0:\n", - " ret_list += [a_line]\n", - " if (display): print(a_line)\n", - " if len(ter) > 0 and (a_line == ter): return ret_list\n", - " a_line = \"\"\n", - " counter = 0\n", - "\n", - " else:\n", - " a_line += _char\n", - " counter += 1\n", - " last_char_t = time.perf_counter()\n", - " if time.perf_counter() - start_t0 > max_timeout: break\n", - " if counter > 100000: break\n", - " time.sleep(.05)\n", - "\n", - "\n", - " if len(a_line)>0:\n", - " ret_list += [a_line]\n", - "\n", - " return ret_list" - ] - }, - { - "cell_type": "code", - "execution_count": 36, - "id": "cf4a0273", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "ESP-ROM:esp32c3-api1-20210207\n", - "Build:Feb 7 2021\n", - "rst:0xc (RTC_SW_CPU_RST),boot:0xd (SPI_FAST_FLASH_BOOT)\n", - "Saved PC:0x403819c4\n", - "SPIWP:0xee\n", - "mode:DIO, clock div:1\n", - "load:0x3fcd5820,len:0x1144\n", - "load:0x403cc710,len:0xad8\n", - "load:0x403ce710,len:0x2f80\n", - "entry 0x403cc710\n", - "BOOT\n", - "256223\n", - "ADPD Found, chip version: 2\n", - "Metadata: lon:1.000000\tlat:1.000000\talt:1.000000\ttime:0\tacc:1.000000\tvacc:1.000000\tinfo1:New_Ambit\tx:0.000000\ty:0.000000\tz:0.000000\n", - "Calibration: Name:AmbitV002\tActinic:0.100000\tSpec:1.000000\tEmit:1.000000\tSun:1.000000\tTemp_offset:0.000000\tTemp_slope:1.000000\n", - "Calibration: Act_50:5\tAct_100:4\tAct_150:3\tAct_200:2\tAct_250:1\n", - "Calibration: ADPD: 0\t0\t0\t0\t0\t0\n", - "MLX: 5832480\t78523296\t0\t6400\t4907706\t5832480\t64774732\t-51539608\t-35734128\t16384\t0\t10752\t10752\t72641246\t\n", - "FW: MAC:f80b44a89110\tSize:539216\tDate:Mar 26 2025\n", - "FW: 0.0.3\n" - ] - } - ], - "source": [ - "with serial.Serial('COM34', 115200) as ser:\n", - " ser.write(b\"reboot\\r\\n\")\n", - " ser_get_lines(ser, display=True)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "459d9b0c", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "ESP-ROM:esp32c3-api1-20210207\n", - "Build:Feb 7 2021\n", - "rst:0x1 (POWERON),boot:0xd (SPI_FAST_FLASH_BOOT)\n", - "SPIWP:0xee\n", - "mode:DIO, clock div:1\n", - "load:0x3fcd5820,len:0x1144\n", - "load:0x403cc710,len:0xad8\n", - "load:0x403ce710,len:0x2f80\n", - "entry 0x403cc710\n", - "ESP-ROM:esp32c3-api1-20210207\n", - "Build:Feb 7 2021\n", - "rst:0x1 (POWERON),boot:0xd (SPI_FAST_FLASH_BOOT)\n", - "SPIWP:0xee\n", - "mode:DIO, clock div:1\n", - "load:0x3fcd5820,len:0x1144\n", - "load:0x403cc710,len:0xad8\n", - "load:0x403ce710,len:0x2f80\n", - "entry 0x403cc710\n", - "ESP-ROM:esp32c3-api1-20210207\n", - "Build:Feb 7 2021\n", - "rst:0x1 (POWERON),boot:0xd (SPI_FAST_FLASH_BOOT)\n", - "SPIWP:0xee\n", - "mode:DIO, clock div:1\n", - "load:0x3fcd5820,len:0x1144\n", - "load:0x403cc710,len:0xad8\n", - "load:0x403ce710,len:0x2f80\n", - "entry 0x403cc710\n", - "BOOT\n", - "256218\n", - "ADPD Found, chip version: 2\n", - "Metadata: lon:1.000000\tlat:1.000000\talt:1.000000\ttime:0\tacc:1.000000\tvacc:1.000000\tinfo1:New_Ambit\tx:0.000000\ty:0.000000\tz:0.000000\n", - "Calibration: Name:AmbitV002\tActinic:0.100000\tSpec:1.000000\tEmit:1.000000\tSun:1.000000\tTemp_offset:0.000000\tTemp_slope:1.000000\n", - "Calibration: Act_50:5\tAct_100:4\tAct_150:3\tAct_200:2\tAct_250:1\n", - "Calibration: ADPD: 0\t0\t0\t0\t0\t0\n", - "MLX: 5827307\t78665872\t0\t6400\t4916617\t5827307\t64589252\t-51539608\t-35734128\t16384\t0\t10752\t10752\t72596907\t\n", - "FW: MAC:f84044a89110\tSize:539216\tDate:Mar 26 2025\n", - "FW: 0.0.3\n" - ] - } - ], - "source": [ - "# 0: Conn/NA 1: New NoFW 2: has FW 3: ADPD exist -2: No ADPD\n", - "Ambit_status:int = -1\n", - "with serial.Serial('COM34', 115200) as ser:\n", - " t0:int = time.perf_counter()\n", - " loop_contiune:bool = True\n", - " Ambit_status = -1\n", - " \n", - " while time.perf_counter() - t0 < 50:\n", - " if not loop_contiune: break\n", - " _lines:list[str] = ser_get_lines(ser, display=True, ter = \"invalid header: 0xffffffff\")\n", - " if len(_lines) == 0:\n", - " time.sleep(.05)\n", - " continue\n", - "\n", - " for _l in _lines:\n", - " if \"invalid header: 0xffffffff\" in _l:\n", - " print(\"NEW ambit Found\")\n", - " loop_contiune = False\n", - " Ambit_status = 1\n", - "\n", - " if (\"esp\" in _l) or (\"load\" in _l) or (\"BOOT\" in _l):\n", - " Ambit_status = 2\n", - "\n", - "\n", - " if (\"ADPD Found\" in _l):\n", - " Ambit_status = 3\n", - " else:\n", - " if (\"BOOT\" in _l) and (\"Metadata\" in _l):\n", - " print(\"ADPD Not Found!\")\n", - " Ambit_status = -2\n", - "\n", - " " - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "base", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.13.5" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/.vscode/extensions.json b/.vscode/extensions.json new file mode 100644 index 0000000..080e70d --- /dev/null +++ b/.vscode/extensions.json @@ -0,0 +1,10 @@ +{ + // See http://go.microsoft.com/fwlink/?LinkId=827846 + // for the documentation about the extensions.json format + "recommendations": [ + "platformio.platformio-ide" + ], + "unwantedRecommendations": [ + "ms-vscode.cpptools-extension-pack" + ] +} diff --git a/.vscode/settings.json b/.vscode/settings.json deleted file mode 100644 index bebb363..0000000 --- a/.vscode/settings.json +++ /dev/null @@ -1,14 +0,0 @@ -{ - "files.associations": { - "bitset": "cpp", - "string_view": "cpp", - "*.tcc": "cpp", - "random": "cpp" - }, - "python-envs.defaultPackageManager": "ms-python.python:pip", - "python-envs.workspaceSearchPaths": [ - ".venv", - "*/.venv", - "D:\\Python_env\\conn_env\\.venv" - ] -} \ No newline at end of file diff --git a/260605_amBIT_DEMO.ipynb b/260605_amBIT_DEMO.ipynb new file mode 100644 index 0000000..8594eb6 --- /dev/null +++ b/260605_amBIT_DEMO.ipynb @@ -0,0 +1,508 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "import serial\n", + "import time\n", + "import matplotlib.pyplot as plt\n", + "from IPython import display\n", + "from datetime import datetime\n", + "import os \n", + "import re\n", + "import serial.tools.list_ports\n", + "\n", + "\n", + "plt.style.use(\"dark_background\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Function to find the connected devices on available serial ports\n", + "def findDevice(question=\"hello\", answer=\"Ready\", flush=True, timeout=3):\n", + " \"\"\"\n", + " Find the amBIT on an available serial port by sending `question` and looking\n", + " for `answer` in the reply. Returns the port name (str), or None if not found.\n", + " \"\"\"\n", + " if not question.endswith(\"\\n\"):\n", + " question += \"\\n\" # firmware is line-based\n", + " for p in serial.tools.list_ports.comports(): # only real ports, not COM1..COM256\n", + " port = p.device\n", + " try:\n", + " with serial.Serial(port, baudrate=115200, timeout=timeout) as ser:\n", + " ser.setRTS(False) # keep the ESP out of bootloader mode\n", + " ser.flush()\n", + " time.sleep(0.7) # let the device finish (re)booting\n", + " if flush:\n", + " ser.reset_input_buffer() # drop the boot-log / stale bytes\n", + " ser.write(question.encode())\n", + " time.sleep(0.5)\n", + "\n", + " reply = \"\"\n", + " t0 = time.monotonic()\n", + " while time.monotonic() - t0 < timeout:\n", + " line = ser.readline().decode(\"utf-8\", errors=\"replace\").strip()\n", + " if not line:\n", + " break\n", + " reply += line + \"\\n\"\n", + " if answer and answer in line:\n", + " break\n", + "\n", + " print(f\"[{port}] {p.description}: {reply.strip()!r}\")\n", + " if answer and answer in reply:\n", + " print(f\"Found device at: {port}\")\n", + " return port\n", + " except (OSError, serial.SerialException):\n", + " pass\n", + " print(\"No matching device found.\")\n", + " return None\n", + "\n", + " \n", + "def ensure_path_exists(path: str) -> None:\n", + " \"\"\"\n", + " Ensures that the given directory path exists.\n", + " If it does not exist, this function will create it (including any intermediate directories).\n", + "\n", + " :param path: The directory path to check (and potentially create).\n", + " \"\"\"\n", + " if not os.path.exists(path):\n", + " print(f\"Creating path: {path}\")\n", + " os.makedirs(path)\n", + " else:\n", + " print(f\"{path} exist\")\n", + "\n", + "def gen_cmd_arr_line(num: int, freq: int, actinic: int) -> list:\n", + " \"\"\"\n", + " Generate a single command-array entry of 8 parameters.\n", + " \n", + " :param num: Total number of measurement points (1-2000).\n", + " :param freq: Frequency measurement points (1-200).\n", + " :param actinic: Actinic light setting (0-255).\n", + " :return: List of 8 integer values representing the command.\n", + " \"\"\"\n", + " return [\n", + " 2, # Fixed flag or identifier\n", + " 0, # Another fixed flag or placeholder\n", + " num // 256, # High byte of 'num'\n", + " num % 256, # Low byte of 'num'\n", + " freq // 256, # High byte of 'freq'\n", + " freq % 256, # Low byte of 'freq'\n", + " actinic, # Actinic light parameter\n", + " 1 # Fixed flag or terminator\n", + " ]\n", + "\n", + "def calc_arr_param(cmd: list, persist: bool = False):\n", + " \"\"\"\n", + " Reshape a flat command list into a 2D array, construct a command string,\n", + " and calculate measurement timelines and actinic-array values.\n", + "\n", + " :param cmd: A 1D list of length 8*N (multiple commands concatenated).\n", + " :param persist: A flag indicating whether the command persists after completion.\n", + " :return: Tuple (cmd_str, mea_tml, mea_act)\n", + " - cmd_str: Formatted command string (e.g., for sending over serial).\n", + " - mea_tml: NumPy array of timestamps (scaled by 0.854).\n", + " - mea_act: List of actinic values (one per timestamp).\n", + " \"\"\"\n", + " # Reshape 'cmd' into an N x 8 array\n", + " cmd_arr = np.reshape(cmd, (-1, 8))\n", + " arr_length = cmd_arr.shape[0]\n", + "\n", + " # Create a comma-separated command string:\n", + " # e.g., \"arrun1,N,persist,,\\n\"\n", + " cmd_str = f\"arrun1,{arr_length},{persist},{str(cmd)[1:-1]},\\n\"\n", + " cmd_str = cmd_str.replace(\" \", \"\") # Remove spaces for a cleaner command\n", + "\n", + " # Parse the reshaped array into usable parameters\n", + " num_pts = cmd_arr[:, 2] * 256 + cmd_arr[:, 3] # Number of points (high/low bytes)\n", + " act_arr = cmd_arr[:, 6] # Actinic setting\n", + " mea_feq = 1 / (cmd_arr[:, 4] * 256 + cmd_arr[:, 5]) # Measurement frequency (1 / freq)\n", + "\n", + " # Build up the measurement timeline and actinic values\n", + " _t = 0\n", + " mea_tml = []\n", + " mea_act = []\n", + "\n", + " # For each command segment, create a timeline and corresponding actinic values\n", + " for _n, _f, _a in zip(num_pts, mea_feq, act_arr):\n", + " segment_times = (np.arange(_n) * _f) + _t\n", + " mea_tml.extend(segment_times) # Accumulate times\n", + " mea_act.extend([_a] * _n) # Repeat actinic value _n times\n", + " _t = segment_times[-1] # Update the offset for the next segment\n", + "\n", + " # Scale the entire timeline by 0.854\n", + " mea_tml = np.array(mea_tml) * 0.854\n", + "\n", + " return cmd_str, mea_tml, mea_act\n", + "\n", + "def send_read_command(port, string, required_string=None, baudrate=115200, timeout=10):\n", + " \"\"\"\n", + " Opens the serial port, sends a “hello” and then your command, and collects replies.\n", + " Stops reading when either:\n", + " • no more data arrives (an empty readline, i.e. per-read timeout fired), or\n", + " • we see `required_string` in the response, if given, or\n", + " • the overall `timeout` has elapsed.\n", + " Returns the list of lines read so far.\n", + " \"\"\"\n", + " lines = []\n", + " start = time.monotonic()\n", + " with serial.Serial(port, baudrate=baudrate, timeout=timeout) as ser:\n", + " # hand-shake / mode set\n", + " ser.setRTS(False)\n", + " ser.flush()\n", + " time.sleep(0.7)\n", + " ser.write(b\"hello\\n\")\n", + " time.sleep(0.5)\n", + " ser.write(f\"{string}\\n\".encode())\n", + " last_recv = time.monotonic()\n", + "\n", + " while True:\n", + " # Check idle timeout\n", + " now = time.monotonic()\n", + " if now - last_recv >= timeout:\n", + " print(f\"No (additional) responses within user-set timeout: {timeout}s\")\n", + " return lines\n", + " \n", + " try:\n", + " line = ser.readline().decode('utf-8', errors='replace').strip()\n", + " # print(line)\n", + " \n", + " last_recv = time.monotonic() # Reset idle timer since we got data\n", + " except Exception as e:\n", + " print(f\"Error reading line: {e!s}\")\n", + " break\n", + "\n", + " # if nothing arrived within per-read timeout, readline() returns b'' → line == ''\n", + " if not line:\n", + " print(f\"No (additional) responses within user-set timeout: {timeout}s\")\n", + " return lines\n", + " \n", + " lines.append(line)\n", + "\n", + " # if we were waiting for a specific marker, stop when we see it\n", + " if required_string and required_string in line:\n", + " break\n", + " return lines\n", + "\n", + "def parse_command_blocks(lines, cmd_prefix=\"cmd:\"):\n", + " \"\"\"\n", + " Parse a list of lines and group them by commands that match `cmd_prefix`.\n", + "\n", + " The function identifies lines containing commands (e.g., 'cmd: something')\n", + " and collects all subsequent lines into that command's \"block\" until the\n", + " next command (or end of list).\n", + "\n", + " :param lines: List of strings to parse.\n", + " :param cmd_prefix: The prefix that indicates a new command. Defaults to 'cmd:'.\n", + " :return: A dictionary mapping { command_name: [list_of_lines_until_next_command] }\n", + " If the same command appears multiple times, each occurrence will\n", + " overwrite previous data unless modified to handle duplicates.\n", + " \"\"\"\n", + " command_dict = {}\n", + " current_cmd = None\n", + " current_data = []\n", + "\n", + " for line in lines:\n", + " # Try to find a line that includes 'cmd:' (possibly with extra characters).\n", + " # The regex captures whatever follows 'cmd:' up to the first whitespace \n", + " # or end of string. E.g., 'cmd: hello' => group(1) = 'hello'.\n", + " match = re.search(r'cmd:\\s*([^\\s]+)', line)\n", + "\n", + " if match:\n", + " # If we have a \"current_cmd\", store its accumulated data first\n", + " if current_cmd is not None:\n", + " command_dict[current_cmd] = current_data\n", + "\n", + " # Extract the new command from the current line\n", + " current_cmd = match.group(1)\n", + " current_data = [] # Start a fresh list for data following this command\n", + " else:\n", + " # If this line does not declare a new command, and we've already seen a command,\n", + " # then add the line to the current command's block\n", + " if current_cmd is not None:\n", + " current_data.append(line)\n", + "\n", + " # At the end, if there is a command in progress, save its data\n", + " if current_cmd is not None:\n", + " command_dict[current_cmd] = current_data\n", + "\n", + " return command_dict\n", + "\n", + "\n", + "def parse_serial(lines):\n", + " \"\"\"\n", + " Efficiently parses a list of strings and returns a dictionary of lists for T, F, S, R, Sun, L.\n", + " Skips lines that do not match the expected format.\n", + " \"\"\"\n", + " import re\n", + " pattern = re.compile(r\"T:([\\d\\.]+),F:([\\d\\.]+),S:(\\d+),R:(\\d+),Sun:(\\d+),L:(\\d+)\")\n", + " result = {'T': [], 'F': [], 'S': [], 'R': [], 'Sun': [], 'L': []}\n", + " for line in lines:\n", + " m = pattern.search(line)\n", + " if m:\n", + " result['T'].append(float(m.group(1)))\n", + " result['F'].append(float(m.group(2)))\n", + " result['S'].append(int(m.group(3)))\n", + " result['R'].append(int(m.group(4)))\n", + " result['Sun'].append(int(m.group(5)))\n", + " result['L'].append(int(m.group(6)))\n", + " return result\n", + "\n", + "\n", + "def append_timeseries(base_series, *additional_series, additionalnumber=1):\n", + " \"\"\"\n", + " Appends one or more additional time series to an existing base series,\n", + " inserting a fixed gap (additionalnumber) between each appended series.\n", + "\n", + " :param base_series: List of time values (the initial series).\n", + " :param additional_series: One or more lists of time values to append.\n", + " :param additionalnumber: Gap to insert between each series (default 0).\n", + " :return: A new merged list with all timeseries concatenated and offset, including gaps.\n", + " \"\"\"\n", + " merged = list(base_series)\n", + " offset = merged[-1] if merged else 0\n", + " for s in additional_series:\n", + " if len(s) == 0:\n", + " continue\n", + " # Always add the gap before appending a new series (except before the first)\n", + " offset += additionalnumber\n", + " adjusted = [t + offset for t in s]\n", + " merged.extend(adjusted)\n", + " offset = adjusted[-1]\n", + " return merged\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "PORT = findDevice(question=\"hello\", answer=\"Ready\") #<----automatic find ambit\n", + "# PORT = \"COM5\" #<--- manual port selection (overrides the auto-detect above)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "SAVE = False\n", + "mytime = datetime.now().strftime(\"%y%m%d_%H%M_%S\")\n", + "\n", + "cmdA = []\n", + "cmdA += gen_cmd_arr_line(50, 10, 0) # 50 points, 10Hz, no actinic light\n", + "cmdA += gen_cmd_arr_line(8, 10, 255) # 8 points, 10Hz, no actinic light\n", + "cmdA += gen_cmd_arr_line(50, 10, 0) # 50 points, 10Hz, no actinic light\n", + "\n", + "cmd_strA, timelineA, act_arrA = calc_arr_param(cmdA, 0)\n", + "act_arrA = calc_arr_param(cmdA, 0)\n", + "data_serial = send_read_command(PORT, cmd_strA, required_string=\"Done\")\n", + "parsed_serial = parse_serial(data_serial)\n", + "\n", + "df = pd.DataFrame(parsed_serial)\n", + "df.insert(0,\"time (sec)\",timelineA)\n", + "\n", + "\n", + "plt.plot(df[\"time (sec)\"],df[\"F\"])\n", + "plt.xlabel(\"Time (sec)\")\n", + "plt.ylabel(\"Fluo. rel. yield\")\n", + "plt.title(\"Fluorescence Intensity over pulses\")\n", + "\n", + "\n", + "if SAVE:\n", + " df.to_csv(f\"{mytime}_output.csv\",sep=\",\", index=False)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "cmdA = []\n", + "cmdA += gen_cmd_arr_line(500, 500, 255) # 400 points, 200Hz, 255 actinic light (on scale of 0-255)\n", + "\n", + "cmd_strA, timelineA, act_arrA = calc_arr_param(cmdA, 0)\n", + "data_serial = send_read_command(PORT, cmd_strA, required_string=\"Done\")\n", + "parsed_serial = parse_serial(data_serial)\n", + "\n", + "df = pd.DataFrame(parsed_serial)\n", + "df.insert(0,\"time (sec)\",timelineA)\n", + "\n", + "\n", + "plt.plot(df[\"time (sec)\"],df[\"F\"])\n", + "plt.xscale(\"log\")\n", + "plt.xlabel(\"Time (sec)\")\n", + "plt.ylabel(\"Intensity\")\n", + "plt.title(\"Fluorescence Intensity over pulses\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "def STING(PORT, POINT_LOW = 10, FREQ_LOW = 10, POINT_HIGH = 40):\n", + " cmdA = gen_cmd_arr_line(POINT_LOW, FREQ_LOW, 0)\n", + " cmdA += gen_cmd_arr_line(POINT_HIGH, 1000, 0)\n", + " cmdA += gen_cmd_arr_line(POINT_LOW, FREQ_LOW, 0)\n", + " cmdA += gen_cmd_arr_line(POINT_HIGH, 1000, 0)\n", + " cmdA += gen_cmd_arr_line(POINT_LOW, FREQ_LOW, 0)\n", + " cmdA += gen_cmd_arr_line(POINT_HIGH, 1000, 0)\n", + " cmdA += gen_cmd_arr_line(POINT_LOW, FREQ_LOW, 0)\n", + " cmdA += gen_cmd_arr_line(POINT_HIGH, 1000, 0)\n", + " cmdA += gen_cmd_arr_line(POINT_LOW, FREQ_LOW, 0)\n", + " cmd_strA, timelineA, _ = calc_arr_param(cmdA, 0)\n", + " data_serial = send_read_command(PORT, cmd_strA, required_string=\"Done\")\n", + " parsed_serial = parse_serial(data_serial)\n", + " fluo =np.array(parsed_serial[\"F\"])\n", + " sun = np.array(parsed_serial[\"S\"])\n", + " leaf = np.array(parsed_serial[\"L\"])\n", + " return fluo, sun, leaf\n", + "\n", + "\n", + "results = []\n", + "for freq_low in [10,20,40,80,160]:\n", + " # time.sleep(30)\n", + " fluo, sun, leaf = STING(PORT, FREQ_LOW=freq_low)\n", + " results.append((freq_low,fluo, sun, leaf))\n", + " plt.plot(fluo,label=f\"Frequency low: {freq_low} Hz\")\n", + " plt.legend()\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "\n", + "results = []\n", + "for freq_low in [10,20,40,80,160]:\n", + " time.sleep(10)\n", + " fluo, sun, leaf, timeline = STING(PORT, FREQ_LOW=freq_low)\n", + " results.append((freq_low,fluo, sun, leaf, timeline))\n", + " plt.plot(fluo, label=f\"Frequency low: {freq_low} Hz\")\n", + " plt.legend()\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "\n", + "results = []\n", + "for freq_low in [10,20,40,80,160]:\n", + " time.sleep(10)\n", + " fluo, sun, leaf, timeline = STING(PORT, FREQ_LOW=freq_low)\n", + " results.append((freq_low,fluo, sun, leaf, timeline))\n", + " plt.plot(timeline, fluo, label=f\"Frequency low: {freq_low} Hz\")\n", + " plt.legend()\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "cmdA = gen_cmd_arr_line(1, 120, 0)\n", + "# cmdA += gen_cmd_arr_line(10, 100, 0)\n", + "cmd_strA, timelineA, _ = calc_arr_param(cmdA, 0)\n", + "data_serial = send_read_command(PORT, cmd_strA, required_string=\"Done\")\n", + "data_serial" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "def STING(PORT, POINT_LOW = 10, FREQ_LOW = 10, POINT_HIGH = 40):\n", + " cmdA = gen_cmd_arr_line(POINT_LOW, FREQ_LOW, 0)\n", + " cmdA += gen_cmd_arr_line(POINT_HIGH, 1000, 0)\n", + " cmdA += gen_cmd_arr_line(POINT_LOW, FREQ_LOW, 0)\n", + " cmdA += gen_cmd_arr_line(POINT_HIGH, 1000, 0)\n", + " cmdA += gen_cmd_arr_line(POINT_LOW, FREQ_LOW, 0)\n", + " cmdA += gen_cmd_arr_line(POINT_HIGH, 1000, 0)\n", + " cmdA += gen_cmd_arr_line(POINT_LOW, FREQ_LOW, 0)\n", + " cmdA += gen_cmd_arr_line(POINT_HIGH, 1000, 0)\n", + " cmdA += gen_cmd_arr_line(POINT_LOW, FREQ_LOW, 0)\n", + " cmd_strA, timelineA, _ = calc_arr_param(cmdA, 0)\n", + " data_serial = send_read_command(PORT, cmd_strA, required_string=\"Done\")\n", + " parsed_serial = parse_serial(data_serial)\n", + " fluo =np.array(parsed_serial[\"F\"])\n", + " sun = np.array(parsed_serial[\"S\"])\n", + " leaf = np.array(parsed_serial[\"L\"])\n", + " return fluo, sun, leaf\n", + "\n", + "results = []\n", + "for freq_low in [10,20,40,80,160]:\n", + " time.sleep(10)\n", + " fluo, sun, leaf, timeline = STING(PORT, FREQ_LOW=freq_low)\n", + " results.append((freq_low,fluo, sun, leaf, timeline))\n", + " plt.plot(timeline, fluo, label=f\"Frequency low: {freq_low} Hz\")\n", + " plt.legend()\n", + "\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.13.5" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/AGENTS.md b/AGENTS.md new file mode 100644 index 0000000..f7ef046 --- /dev/null +++ b/AGENTS.md @@ -0,0 +1,108 @@ +--- +title: "AGENTS.md — ambit-iot firmware" +date: 2026-08-04 +generated_by: skills-for-architects +--- + +# AGENTS.md — ambit-iot firmware + +ESP32-C3 (Arduino framework via PlatformIO) firmware for the AMBIT leaf-sensor board: +ADPD6100 (fluorescence), AS7341 (spectral/PAR), MLX90632 (leaf temperature). One image +serves every host at runtime over UART0: an Ambyte datalogger (binary FSM over the FFC), +the openJII app and the Calibratron (text console), and the openJII JSON envelope. + +## Commands + +- Build: `pio run` (single env `ambit`) +- Flash: add `-t upload`; serial monitor: 115200 8N1 +- Linux/macOS quirk: `platformio.ini` sets `build_dir = ${sysenv.LOCALAPPDATA}/pio_build/…` + (Windows OneDrive/AV workaround). Off Windows, export something sane first, e.g. + `LOCALAPPDATA=$HOME/.cache pio run`. +- Version is build-injected by `tools/version.py`: `$AMBIT_RELEASE_VERSION` (CI) → + `git describe` (dev) → `0.0.0-dev`. Never hand-edit a version literal; everything + (cmd 33/2, `hello`, JSON identity) reports the same injected value. +- Releases: semantic-release keyed on Conventional-Commit PR titles (squash-merge). + `pr.yml` validates the title, builds, and uploads the artifact; `release.yml` reuses + that artifact bit-identically and publishes the GitHub release (app image, + bootloader, partitions, boot_app0, `manifest.json` with offsets + sha256). The + Calibratron flashes devices from these release assets. +- No automated test suite. The regression gate for anything touching `run_esp.cpp`, + the `data_utils.cpp` FSM, or the `loop()` router is the hardware conformance + procedure in `plans/HW_CONFORMANCE.md` (byte-diff against a real Ambyte). + +## Architecture — one CORE + one CONFIG + thin transport adapters, routed at runtime + +`plans/MERGE_PLAN.md` is the historical design doc for the fork merge (its §10/§11 +build-variant split was superseded by the single image once every host landed on the +same UART0); read it before structural changes. The spine: + +``` +wire bytes → [adapter: decode + undo wire conventions] → normalized args → core op → [sink] +``` + +- **First-byte router** (`ambit-1.ino` `loop()`): >127 → binary FSM branch (every + frozen framing byte is >127); `{`/`[` → openJII JSON envelope (`ojii::poll`); other + printable → legacy text console (`do_command`). `ojii::poll()` must never see binary + traffic (it consumes bytes and drops >127 junk silently) — peek, then route. While + `ojii::busy()` the envelope owns the stream. +- **Sticky host latch** (`HOST_UNKNOWN/BINARY/TEXT`): BINARY/UNKNOWN idle in light + sleep (the Ambyte re-sends its wake until acked, so sleep-lost bytes are safe); + TEXT never sleeps (text/JSON hosts don't retry; UART sleep-wake eats in-flight + bytes) and releases after 2 min idle. The latch also gates the 0x85 idle heartbeat. +- `src/core.{h,cpp}` — transport-agnostic command core. Takes normalized typed args + (gains 0-indexed, real widths), does **no** wire I/O: no Serial/printf/JSON. +- `src/config.h` + PAM globals — single config (`adpd_*_config`, `adpd_mode`) with + "set, then apply on run" semantics. `CONNECTION_TYPE` (PLOTTING / AMBYTE / COMPUTER) + selects the measurement output sink; the JSON envelope path uses the `json_output` + flag through `run_arr_type1` instead. +- Adapters: + - `src/run_esp.cpp` — binary/Ambyte adapter. **Frozen wire contract** (below). + - `src/do_command.h` — text/console verbs (`hash()` dispatch switch). This is the + dialect the openJII platform's ambit driver and the Calibratron actually speak. + - `src/frontend_json.cpp` — openJII envelope handlers (snapshot tree-builders + + streamed `arrun`), registered from `setup()`. +- `lib/openjii_proto/` — device-agnostic openJII serial protocol module. Devices + register snapshot/stream handlers; `busy()`/`reset()` exist for router coexistence. + Bare-line LINE mode is intentionally unreachable in this firmware (no live consumer; + bare lines belong to the text console). +- `src/PAM.cpp` — measurement engine (array runs, MPF, triggers, env logging); + `src/data_utils.cpp` — FSM data framing + checksums; `src/nvs1.*` — calibration, + metadata, and fw-info structs persisted in NVS; `src/src/` — sensor drivers. + +## The frozen binary wire contract (do not break) + +The binary path is a wire contract with shipped Ambyte firmware. The source of truth is +the Ambyte repo (`ambyte-iot`): `components/uart_sensors/uart_sensors.c` and +`components/device_commands/include/ambit_protocol.h`. MERGE_PLAN §2 lists every frozen +element. Rules: + +- Refactor behind the wire freely; never change the bytes. Obscure-but-frozen encodings + stay: 1-indexed gains on the wire (stored −1), base-128 MPF length split + (`cmd[1]<<7 | cmd[2]`), byte-sum-mod-256 data checksum, struct sizes 140/48/248 with + `eof_mark==2025`. +- Wire conventions are decoded **in the adapter, never the core** — the core only ever + sees normalized values. +- The cmd 33/2 fw-info struct is 48 bytes with fixed offsets; `hw_rev` lives in the + first formerly-reserved byte (old readers never looked at it). Do not move fields. +- Any change to the binary path or the router re-runs `plans/HW_CONFORMANCE.md`. +- UART0 doubles as the log console; setup silences all ESP logging, and nothing may + `printf` outside explicit console replies — ASCII in front of a binary frame breaks + the Ambyte session. The boot banner + NVS dump predate the freeze and are tolerated; + do not add more. + +## Version reporting (single source) + +`tools/version.py` injects `AMBIT_FW_VERSION` (string) + `AMBIT_FW_MAJOR/MINOR/BATCH` +(uint8 fields of the cmd 33/2 struct). Reported by: binary cmd 33/2, text `hello` +(`NEW Ready FW:` — "NEW"/"Ready" are matched by the app driver and +Calibratron, the FW token is additive), and the JSON `hello`/envelope identity. + +## Conventions + +- Heavy rationale comments are the house style — a constraint's *why* lives at its + definition (wire freezes, sleep thresholds, build-dir workaround). Keep it that way. +- Conventional Commits for commits and PR titles: `type(scope): description`. + PR titles drive semantic-release (feat → minor, fix/perf → patch). +- License: CERN-OHL-S-2.0 (hardware-adjacent open license — keep headers/attribution). +- Vendored driver libs under `src/src/` (as7341, adpd, mlx90632) are third-party + imports; don't reformat or "clean up" wholesale. diff --git a/CLAUDE.md b/CLAUDE.md new file mode 100644 index 0000000..1fb4cfd --- /dev/null +++ b/CLAUDE.md @@ -0,0 +1,7 @@ +# CLAUDE.md + +This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository. + +The canonical agent guidance lives in AGENTS.md (shared with Codex and other agents): + +@AGENTS.md diff --git a/LICENSE.txt b/LICENSE.txt new file mode 100644 index 0000000..114486f --- /dev/null +++ b/LICENSE.txt @@ -0,0 +1,289 @@ +CERN Open Hardware Licence Version 2 - Strongly Reciprocal + + +Preamble + +CERN has developed this licence to promote collaboration among +hardware designers and to provide a legal tool which supports the +freedom to use, study, modify, share and distribute hardware designs +and products based on those designs. Version 2 of the CERN Open +Hardware Licence comes in three variants: CERN-OHL-P (permissive); and +two reciprocal licences: CERN-OHL-W (weakly reciprocal) and this +licence, CERN-OHL-S (strongly reciprocal). + +The CERN-OHL-S is copyright CERN 2020. Anyone is welcome to use it, in +unmodified form only. + +Use of this Licence does not imply any endorsement by CERN of any +Licensor or their designs nor does it imply any involvement by CERN in +their development. + + +1 Definitions + + 1.1 'Licence' means this CERN-OHL-S. + + 1.2 'Compatible Licence' means + + a) any earlier version of the CERN Open Hardware licence, or + + b) any version of the CERN-OHL-S, or + + c) any licence which permits You to treat the Source to which + it applies as licensed under CERN-OHL-S provided that on + Conveyance of any such Source, or any associated Product You + treat the Source in question as being licensed under + CERN-OHL-S. + + 1.3 'Source' means information such as design materials or digital + code which can be applied to Make or test a Product or to + prepare a Product for use, Conveyance or sale, regardless of its + medium or how it is expressed. It may include Notices. + + 1.4 'Covered Source' means Source that is explicitly made available + under this Licence. + + 1.5 'Product' means any device, component, work or physical object, + whether in finished or intermediate form, arising from the use, + application or processing of Covered Source. + + 1.6 'Make' means to create or configure something, whether by + manufacture, assembly, compiling, loading or applying Covered + Source or another Product or otherwise. + + 1.7 'Available Component' means any part, sub-assembly, library or + code which: + + a) is licensed to You as Complete Source under a Compatible + Licence; or + + b) is available, at the time a Product or the Source containing + it is first Conveyed, to You and any other prospective + licensees + + i) as a physical part with sufficient rights and + information (including any configuration and + programming files and information about its + characteristics and interfaces) to enable it either to + be Made itself, or to be sourced and used to Make the + Product; or + ii) as part of the normal distribution of a tool used to + design or Make the Product. + + 1.8 'Complete Source' means the set of all Source necessary to Make + a Product, in the preferred form for making modifications, + including necessary installation and interfacing information + both for the Product, and for any included Available Components. + If the format is proprietary, it must also be made available in + a format (if the proprietary tool can create it) which is + viewable with a tool available to potential licensees and + licensed under a licence approved by the Free Software + Foundation or the Open Source Initiative. Complete Source need + not include the Source of any Available Component, provided that + You include in the Complete Source sufficient information to + enable a recipient to Make or source and use the Available + Component to Make the Product. + + 1.9 'Source Location' means a location where a Licensor has placed + Covered Source, and which that Licensor reasonably believes will + remain easily accessible for at least three years for anyone to + obtain a digital copy. + + 1.10 'Notice' means copyright, acknowledgement and trademark notices, + Source Location references, modification notices (subsection + 3.3(b)) and all notices that refer to this Licence and to the + disclaimer of warranties that are included in the Covered + Source. + + 1.11 'Licensee' or 'You' means any person exercising rights under + this Licence. + + 1.12 'Licensor' means a natural or legal person who creates or + modifies Covered Source. A person may be a Licensee and a + Licensor at the same time. + + 1.13 'Convey' means to communicate to the public or distribute. + + +2 Applicability + + 2.1 This Licence governs the use, copying, modification, Conveying + of Covered Source and Products, and the Making of Products. By + exercising any right granted under this Licence, You irrevocably + accept these terms and conditions. + + 2.2 This Licence is granted by the Licensor directly to You, and + shall apply worldwide and without limitation in time. + + 2.3 You shall not attempt to restrict by contract or otherwise the + rights granted under this Licence to other Licensees. + + 2.4 This Licence is not intended to restrict fair use, fair dealing, + or any other similar right. + + +3 Copying, modifying and Conveying Covered Source + + 3.1 You may copy and Convey verbatim copies of Covered Source, in + any medium, provided You retain all Notices. + + 3.2 You may modify Covered Source, other than Notices, provided that + You irrevocably undertake to make that modified Covered Source + available from a Source Location should You Convey a Product in + circumstances where the recipient does not otherwise receive a + copy of the modified Covered Source. In each case subsection 3.3 + shall apply. + + You may only delete Notices if they are no longer applicable to + the corresponding Covered Source as modified by You and You may + add additional Notices applicable to Your modifications. + Including Covered Source in a larger work is modifying the + Covered Source, and the larger work becomes modified Covered + Source. + + 3.3 You may Convey modified Covered Source (with the effect that You + shall also become a Licensor) provided that You: + + a) retain Notices as required in subsection 3.2; + + b) add a Notice to the modified Covered Source stating that You + have modified it, with the date and brief description of how + You have modified it; + + c) add a Source Location Notice for the modified Covered Source + if You Convey in circumstances where the recipient does not + otherwise receive a copy of the modified Covered Source; and + + d) license the modified Covered Source under the terms and + conditions of this Licence (or, as set out in subsection + 8.3, a later version, if permitted by the licence of the + original Covered Source). Such modified Covered Source must + be licensed as a whole, but excluding Available Components + contained in it, which remain licensed under their own + applicable licences. + + +4 Making and Conveying Products + +You may Make Products, and/or Convey them, provided that You either +provide each recipient with a copy of the Complete Source or ensure +that each recipient is notified of the Source Location of the Complete +Source. That Complete Source is Covered Source, and You must +accordingly satisfy Your obligations set out in subsection 3.3. If +specified in a Notice, the Product must visibly and securely display +the Source Location on it or its packaging or documentation in the +manner specified in that Notice. + + +5 Research and Development + +You may Convey Covered Source, modified Covered Source or Products to +a legal entity carrying out development, testing or quality assurance +work on Your behalf provided that the work is performed on terms which +prevent the entity from both using the Source or Products for its own +internal purposes and Conveying the Source or Products or any +modifications to them to any person other than You. Any modifications +made by the entity shall be deemed to be made by You pursuant to +subsection 3.2. + + +6 DISCLAIMER AND LIABILITY + + 6.1 DISCLAIMER OF WARRANTY -- The Covered Source and any Products + are provided 'as is' and any express or implied warranties, + including, but not limited to, implied warranties of + merchantability, of satisfactory quality, non-infringement of + third party rights, and fitness for a particular purpose or use + are disclaimed in respect of any Source or Product to the + maximum extent permitted by law. The Licensor makes no + representation that any Source or Product does not or will not + infringe any patent, copyright, trade secret or other + proprietary right. The entire risk as to the use, quality, and + performance of any Source or Product shall be with You and not + the Licensor. This disclaimer of warranty is an essential part + of this Licence and a condition for the grant of any rights + granted under this Licence. + + 6.2 EXCLUSION AND LIMITATION OF LIABILITY -- The Licensor shall, to + the maximum extent permitted by law, have no liability for + direct, indirect, special, incidental, consequential, exemplary, + punitive or other damages of any character including, without + limitation, procurement of substitute goods or services, loss of + use, data or profits, or business interruption, however caused + and on any theory of contract, warranty, tort (including + negligence), product liability or otherwise, arising in any way + in relation to the Covered Source, modified Covered Source + and/or the Making or Conveyance of a Product, even if advised of + the possibility of such damages, and You shall hold the + Licensor(s) free and harmless from any liability, costs, + damages, fees and expenses, including claims by third parties, + in relation to such use. + + +7 Patents + + 7.1 Subject to the terms and conditions of this Licence, each + Licensor hereby grants to You a perpetual, worldwide, + non-exclusive, no-charge, royalty-free, irrevocable (except as + stated in subsections 7.2 and 8.4) patent license to Make, have + Made, use, offer to sell, sell, import, and otherwise transfer + the Covered Source and Products, where such licence applies only + to those patent claims licensable by such Licensor that are + necessarily infringed by exercising rights under the Covered + Source as Conveyed by that Licensor. + + 7.2 If You institute patent litigation against any entity (including + a cross-claim or counterclaim in a lawsuit) alleging that the + Covered Source or a Product constitutes direct or contributory + patent infringement, or You seek any declaration that a patent + licensed to You under this Licence is invalid or unenforceable + then any rights granted to You under this Licence shall + terminate as of the date such process is initiated. + + +8 General + + 8.1 If any provisions of this Licence are or subsequently become + invalid or unenforceable for any reason, the remaining + provisions shall remain effective. + + 8.2 You shall not use any of the name (including acronyms and + abbreviations), image, or logo by which the Licensor or CERN is + known, except where needed to comply with section 3, or where + the use is otherwise allowed by law. Any such permitted use + shall be factual and shall not be made so as to suggest any kind + of endorsement or implication of involvement by the Licensor or + its personnel. + + 8.3 CERN may publish updated versions and variants of this Licence + which it considers to be in the spirit of this version, but may + differ in detail to address new problems or concerns. New + versions will be published with a unique version number and a + variant identifier specifying the variant. If the Licensor has + specified that a given variant applies to the Covered Source + without specifying a version, You may treat that Covered Source + as being released under any version of the CERN-OHL with that + variant. If no variant is specified, the Covered Source shall be + treated as being released under CERN-OHL-S. The Licensor may + also specify that the Covered Source is subject to a specific + version of the CERN-OHL or any later version in which case You + may apply this or any later version of CERN-OHL with the same + variant identifier published by CERN. + + 8.4 This Licence shall terminate with immediate effect if You fail + to comply with any of its terms and conditions. + + 8.5 However, if You cease all breaches of this Licence, then Your + Licence from any Licensor is reinstated unless such Licensor has + terminated this Licence by giving You, while You remain in + breach, a notice specifying the breach and requiring You to cure + it within 30 days, and You have failed to come into compliance + in all material respects by the end of the 30 day period. Should + You repeat the breach after receipt of a cure notice and + subsequent reinstatement, this Licence will terminate + immediately and permanently. Section 6 shall continue to apply + after any termination. + + 8.6 This Licence shall not be enforceable except by a Licensor + acting as such, and third party beneficiary rights are + specifically excluded. diff --git a/ORIGIN.md b/ORIGIN.md new file mode 100644 index 0000000..3d5fc2e --- /dev/null +++ b/ORIGIN.md @@ -0,0 +1,18 @@ +# Origin and continuation history + +This repository is a genuine GitHub fork of +[`hjc2023/ambit`](https://github.com/hjc2023/ambit). The upstream v1 work and its authorship +remain visible in the inherited Git history and are not re-authored or presented as JII's +later work. + +The first JII continuation snapshot is based on upstream commit +`64b3bf72a757b594e61fd48398dd1db9a893fa93` and imports the maintained firmware tree from +JII private commit `bebd67b6e4141588a7a8943be70c4ee3ebd3ee41`. The private +repository's commits are deliberately not grafted onto the public fork: the snapshot records +a new continuation boundary without inventing historical ancestry. + +The continuation removes the ADPD6000 vendor SDK subtree from the current source tree and +uses a JII-owned driver written against public hardware-interface facts. This removal does +not rewrite or conceal objects already present in the inherited upstream history. Modified +inherited files retain their existing author notices; JII-authored files carry JII copyright +and SPDX identifiers. Other bundled third-party components retain their own notices. diff --git a/README.md b/README.md new file mode 100644 index 0000000..3cac60d --- /dev/null +++ b/README.md @@ -0,0 +1,27 @@ +# AMBIT firmware + +Firmware for the Jan IngenHousz Institute AMBIT instrument. + +This repository is the public JII continuation of +[`hjc2023/ambit`](https://github.com/hjc2023/ambit). The GitHub fork relationship and +upstream commit history are intentionally preserved; the JII continuation is imported as +a separate, truthful snapshot. See [ORIGIN.md](ORIGIN.md) for the boundary and attribution. + +## Build + +The supported build uses PlatformIO: + +```sh +AMBIT_RELEASE_VERSION=1.1.3-rc1 pio run -e ambit +``` + +Release bundles contain `manifest.json`, the OTA application image named by +`manifest.ota.file`, and the three boot/partition images used by the Calibratron. Stable +firmware is selected through GitHub's `/releases/latest`; prereleases must always be chosen +explicitly. + +## Licensing + +JII-authored firmware is provided under CERN-OHL-S-2.0; see [LICENSE.txt](LICENSE.txt). +Third-party components retain their own copyright and license notices in their source +directories. diff --git a/adpd6000.pdf b/adpd6000.pdf deleted file mode 100644 index ba509647804e0cc665d77acf6af99cc28cd26d35..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 2012199 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,R}M`PgAg`bS8=5Pb}vah5&IGhkPi3 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

wh1Ygs_^G7eN3ka0>-Sb}O%V9qcI?tO)e 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 S(839TYMo)1!OYL&n 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

~aA=HSH(0`WA7De5H}? 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

JjSf4Adzij?Q@p0QS$cntVzfW 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%0A#la6NMVsAU`} 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⋘^V<7&?pZvogY>*$H{`y6 zUY6qJM=6zROVDE$0`vUgaPu!Pz(1Wo?_Oi_(I&*x!-PP6q`5jTwdDUe6veJziE<=e z*fIpDcTf`sUA0@3MV0dhKUG2D)9D1yJY8GxD<-+>!;k{`ch*!+tc8{O6k7CcDdYwJ z3`R7BpZ?-vm;4L#zoWKKvS|+gMgy+=@8@_j!@GG^#_`)e16wAybw|!^HuR1;Iv!Uh zlRm-2S9LyX=WzpiDfdLY$Ch98+Fx%Njb=Fo5*EtolgSInXd56WZqpxGC8fW87RXX! z6WXBzz8_Xs_YcZ&)OO?^WfVQKO^MEO1gtdI;#!HKV4p&~dkqle^Kw4zfQpKSt_s7-Kd}IAit#O>j@t zf2|6B`oTZozS;4n5(d`fV#K&J~@H$ znUi-n)ry_<#Ep`&1JY9=GSlJm#3be-oHN1m8XybvZ~tPKPalL#aU!+3>ObbhXoU@W zQ)e@VDQ&Ww9f9TcEMFn#Fy!lye0HI=Ji`5RDc^`$D|C1@+JSOl7p)q(G~kjCzJ|h9pdd&t9G$V+Fq)rO7C&ZJsd*skz=m4su#GiebGher-=!eD?BFO_?cF za$LUqj{GualHjbqb{E~b{)SQM(?gGYydMvGWGzfBM`Xb|357$6Ifwk1zb7p&J~L9tYWcmF$GKqo>r9gWL4 zCsN%MAz$*Wt@vxfg9Bdz1u{we?|MSB2krSLN9k-kML*5sbwQ>-*<22931CKX0L?zv z_*a>ur0_;=7#s4#A*KQH*qt{vtm^xRVb^*N>j%XS z+NQ))&d7gDD;jpXM_co?*%1?;;JD0OT9L7W%#-RoX>U;Q``;pCPEQtel4&YG72UBR zZ7g1RxSwbAy%(|$;s|Be{whYcUtCe$G+_6MP?e9&KKclkWH>U`u8t+3*J8QOphd68 zIp;8+p&1ObrZd8Le)zkgOQNihp88y(pz^&u-awF$|Rb-$?NUnl-%>q>Ab0M#5s5>Bnr<+J(G~*nee}cUN z*2~N-8;cK=-H-FM(hNR7__7(AnYcTOVKm_9orrtKo4Icg%kJX(!8SG@QHW+~2S5h6 z-A^TC!dH2wGj=@pSwWV?lHy>TWDrD-yuzGDe9%*bb4!N~1@SQeS|_t2qZLF|9`_$(_9;dZFq;*& ziVt0z*I)uk#w1onr&CDHZ3b_cG;t=~MtUQEf`1O{9lRnq0zLl4J-}%kVRkHh^s^}N z-+Y$vP{$MYepRXw3eRtxWu6NuJ!i0N`9XDLD`?QxuzZd=6qdMs>w2h#k{`rya_m(< zj9FBh!f0fz5j{nZzqG#NOkT399b(f3@fTfr`@fo_ZvA)bAWnb%Hk1`W0-=eK3X!ro!(p4=WukViqvj@G5&-kni3&X7SpcUxcbX zq(RW2olzLpLF0~vIdZTu4F z7x^}aKmU)U>u`kn|NkG?HQp7fcO|Px^;R+}ap$b4th^CYh*0)kXJynig(x9+8OffR zkNSp21Xo3353 zdYm2@a^`r<8q&y6Y&M%B<)PY6&+a^;ZPa{9W7m*jQ`MfJSw`KG`6o|5K5hNfDfP<3)lD&| zp`VZKYtBzqietpHLREHRcR4?a>>Z;?oh zsCFUSpGMsD2Xsc2J;}_vx?|B(>4Dvi7apgne@*GR;+ZE74`rD7&`-vo3#S>D_=; zJD;a`wIGHZ&dh;C#FY?I#zkVi2ugupYGMcNbjH&gleFCvVspf#okMSww)xGx0spSW@nlsQ!RDlCR!?&y zLt^6ks)WpPuGy`(=y&%+%O}>%ZiKmpg&f$q+oxkli&VXUN#4rI^f1Hsol@nZuu3fV zHJ6+_O={0?$yJ@CQ75(o`q9u4OJ+U4n_{?*jHS0Br!w5HjRUK(TI&?Oh zb(F@-`W<>tJtTH*`;Bc%p5LcyNNl~I{G-uEKhHD|f=AYNPQEu!-YUcW!@g}mRfg>| zce>KTLmK@tSMHqpWvM|V^@0ZTd$3H2Mg#4t%u)JndME-FU6LcW&O5# zmfdIV$gh!yp1fdt#i6(2)q@#YN_K+qVz=M!h)*rKR+mX^T?{hY&za%|(MQh}j|oDA zgiC*i#zfze)?dl)Co@Fj3MAur9_sk~?_*TVW@)>PW%|t-fqgTIFP=j6=>dpoX+f+O zA=P=GK6yMAeXM=lPL1P?Au{+GS$V(}jh4z$zVBUD{zNASmEFl|g3nko5JV0dFm4Oh zll577)Z?*yMQ=xD2>#ad@lka9gIznw!KKsmT?|E|_zdyO* zYCWQ#Jb$O9U!DG#zbBx&5{50|TT5^}r!7|5okI@^18gvPUf|3mts>Ae`^{J|sJE5f z6vgG^B(Jl^*qL5MWfoZ4hj_X~sG+_J{+Fc%fM^xySWfgZ5JJ-n1vY$7X1?y2F?Ge#&8#=g|CwiR9un#&lGjXs}^+zFy12z+=_ZiM#q#n`(fAh69fkOs?9O0f5U?G`wu#Dsw zM09-+g#xsD`3@jQAf$bf3ZJIsMlqBWYDhOS)A=3l=)w2MmadyGW6+1PwmWh&lK;g8tb0tC3)xKpG8Oo&!{zqv_TC3vAscw73>9p? zH&9q1F{cL+Qursfa}jt|LaWW@qvLh=+j3$X>1{Xa9KvMXnojOn9-)}UIW~f1zt=~l z@;vNZ*aeuqfCP5kar&`4^WBn+-s%YL{ib&(@sfB{5g;$_pb3ACu2t6g8J(AttI4K} zssTzB;!g6$__k&xO`b@I@v>rk*t1N64J|6H!^#0rZGUOXw(eTEdlg#E-TuWrir{hbc;00XEpRRybGp zrfs&({M_2-dr_QEpV#*MkLUH}s1|>3q(tazjUig@P~MlXd?dkBF2B+O{&Q1`I>(lA zWeNAXsPK(;wdJ%Q_Etpn<}=+|VBU!5reJDI=t%hcDA^RiFF~_+c=Rh`~eEBuJdp;r2m&474NW}?hLCS^#Y$OO%gk{3GX}1P!vTv z$RYCit}7 zgU2@rCF+iRG#_n37;39@w19nJBIYrAzOenz#AWDIl1wCGzZwk@tDhtj)(q%@y94P4 z^jTBinc3#VskmiqGB@-37lhhodSomDCt2@%vZu^wk|>)mw1wWbOIyU5X*Mh|Mobsb z7II!iUeaLx;6KNmCV$^(GLRnlE1!}mGBmeKZ-jPi@nj-1ZDi9JEp%!B7;)v3z44B( zMRK0e6pD^7L0|HIlWHf)jhW>1et+4;3e;ab{l7h>_O|uNmeEnJA)5I&o`nIkC~x_q zx}(M&zsyAU^sPK>afp)kYSL6=v}41x{=aEWNJml?d)%V%S$+JK$RM(GSLA8IEt`c6 zW5guCQiHjVG#{7Zi(|B9$1_Vtd%KT0L*#(aMF9od$(8d5Dp0Ymu&<>bC_y|2>k+X5 zizY;~=bRvZQ=Ps8l`wfO*-Q`29Xx62=o8X9tX+)@jD@4Z^Sfo(cG`Uu(fLa3yX0#h zoO78buii9FVL7VGiWZ))d-ZVWt;;@G2C92dRIooQMr4L2A~WrWO)eZKzd8`==ieuz zK15u()ED-X7qc(2z!mwgR;GDnFS=?U97H5r+ktjCSXTVW4eiO|4~7g5-g- zxT&f0m*Fk~eC#<0j{Hg?(YYZClg~N>yi6b z1ypQJtsPl1yYQV98oJ}Ve3fa~@s11QZ+ zI*s5*m~Z-W&*)Hx?1f3%O~VH(=QMPzho7sW2xJq$yC5TE;FH=HK?rYpJ`R1h8 z_k+oJ6%VMvA$Dz7Wk4-G3Y*%U>|8;KOZ2h-UzNZ zv?=2ky-NR9UWhM4BkcLv(9#9hIDTYhag7|>m=Jw$U!QFkTa&JB#f*BX&f2~L8xLhJpXDITHea%G>HuZ%$B zI)5=^|N3G!+7RVTZcz!?^*CZHU6k~?70y(2d{(JNmX_TaQ|8Cie~$EmxP+I(-B@V= zYU3sKPTHMq*f@Jj4nPWbKNx5~BP?S0;ps*pTWp0!bsjiqzr z06o{&?oPa1kllvkA`r;BsMT$gyLx}GLHNgsU3^c;K@T@>y}GxL{R4gWh}5RV`r&x% zX*1JKr0T!Gv-rM6JLRp$?rJqCd&Pk*-*-{iUezU8obdd0@W?`xgMPQe)4}gQv-0ex zh5Y71P(CSLCpDi~MTd<6Ny*aH)69FDYmK&S+HnhP{t|m3{P@pd62;!RLkd)ZS>ei~ zCht0H&wQA=$BrIpdi`a6j%lCt;6mPj*^*NZ>fT(t3@+X>* z`SUk6dS=yQSmD7hzW2V_Wu9;Tm3pxveoAzlc&zku5k@Z##;~_rw?Cs2nBon+H|WlT z7|+N0FCANvq07a;{T_?v9DX*?=x}M8CUx6ErE{}*0xG;V&ih=O?*z7DX({eWXx#Di zPz0_h+kja0Z9B|x?w7w65_|}Id#cCzz2M#C{L3e?@1*vEQlU75R-Io1K{95ElRo*i zTSlw8i%yKuzI--Rrz>6wcMi>5*3k_x!M$!+&t0m!P>akMj1y#+oIA?4bN`C)jK7F2 z`5^0jF?2U3R9_QS?bAv?<()K>Esf(T{&v^So5%>ud8~Hbm0%==w<9r*A)H;^vmi+f z?nb;)>#hon6ZwM4Y~J(JowF7RAzF;vJ*ycryk5X=eaerw^xWMgT(*?2z%o;)&Vc)K zcWQ|R?se(&X)|5PJi#zPJyb|rFR%Q#aXk>WF{B?c2jsj5vJ2BKhOkp;smiYMo*1-; zdAA-Z-?Whih?4J&bJZK#RxMY;>7T4P=PdYDHjmLNKQaHMiKhKZy~UO*7faX{@QpV6 zXNI!*-iyF#zQO&j1n&Pnip)6?b_tth^nLJgtK(6MmEEv7bgIJ2VD5tIp0&RuP6^Cd zt9!xi>@M|>N2U_5@^BY-mR)>fU~91Pkbt&0*X}D(bIVHrrCp2Z%zv|W&(Drzx@WJU zZBwQ7h=z-AWTXnNcrcjppJkh|47I>GE#o~j5Y>nLTM(BsTN%!$@^?|rT+g=g6^v6z z=Z$bz%DCxZ(fQj7JDa;etFv>cZF1WPk{!MKWr1{wsR-I-InOQEK<6?eI!^oKndZz) zX)0mOPLHLY@Wy0uv8OJ~n)-u|))5xGhaPiF{uYn~HN~M1qqNd~6OTH-58>uk1%xEB35&!H)!bH7I8kO7t_}?(h3p|4h~U>4qnx z=mn?g%jCxJ|Dzb@mI#y&T>? zm?0YKxS!BH{Z+U!>&t9#_7momg3S;AlM==*gmS$^>He)Jl8fY6PbqNHdz2>8XNG7Zds(f=ul|#Go$xT09!N|G=ei&H2w;TNOvpP- z-pa_W^W^29{_$+z7;Tj|B5b?{*ks0v&*X@DH^&e$k|PoGWYR3Zrq+3a2{Ut;lF(l$ zGmt2X**d9DuKjonj9o{T6H{r;*2dtpSOl3Z%J;ZK(#s{9A=V@*ebhzifz!Ptw1gt& z>6@cf_vQW%+leu|OYfQx1*hLMz^XuhR&s;euTJhvE#maNhdMsCV0--o>CEf^8?LB5 zO(fd8y>Wj`5A4t#rOCepDzDh;-o8@PXjF`pvJEVZ@_y}NT;C`T5w~o=S3lE(4Cx+& zQ&`GPk!qY|vHzo8(Q3)1Bv?7UgTk6gTKZCw3M!C{1sA>gSy*)ILtb_MLJv&IGLjO6 z4mv~SX*W_iXIXjOjvcr%ke><_%{ku+0@Gl|9!vl#$ZD?1zjR%CM99C(7JeTN|Il^V z=*raBQ~*_@SEV}jc*#m(q$oQBfF!x=fzzhmSkvAcuk)c{QSLq2nQv5!bo8C!-$TRi z^PgqCơ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 z z4y1|sK7_}8hTpzHc-#QtxrX402dcy+^dGC?#&3g^e*p2YpPu1oac#iypi@nUo<(;a z!}8>j=N^b6fO%3G(L8ujgwA$|9qm~JJda~*tq#sJf_VlgkHKYUgYe89cxUdAu_5FE zxP!-%4HIjq9ke^MH4puE?^~*EY17s@@N@?SEt;8U)adon)!t!{Tm-Ttnt<=(;(+|cdrdmO=Ix;>)#O_czh z`qiGxqJH(ylQxsmdqQbLpYlqm|62)=JIS-BHd`r<&XA%`G>Ey&5cI)ImHhOoh5h6ZEoA;KjUXl4k zYT9@v1YFJj?jp{P4c*zzoq$Q}?k*C)Ywo`EXI4O}wRTsX=g`}|>)Woa-Ot@jV;Qq> zEgRD(1gEX-p%$M?Z+8owox1Msl>ge^9j#0!_ICejJ+$`db%fRhJ>c>p;e)sdt^kgHtyP|*4nsZXk0j$aMmLcICY#@6GBT{H;d4K zX*Np!E`jYw8)85gQEX{?1D_!Ftg&HlJ=?1iwIWv{Eev9{i>JDLZS`bNzoP&+f0MnLTKks?3}4BF}^J5 z-?A2QHqtul;EPb3Z8NH5*-Q=%4L93cbE7nraoDhDrE{t=sYrY5Wi_ERuK?w+`!PWz ztrvHPCZ7kCN$|QvtOs^Gv!>~!rLn`-(hI_1_5_<~*IzFzM$2S1GP(|1)y=ur6IyPb zV5lrv^+xhci=fQ54Q@p#p^VpAi#6`4V@bq)H76Dg>-q6vxZ5bzoE>y#&P-Y|Ke)}% z=k&vtc|7Deo172fqv(FsK z>OmuQ&E;=iJj@M35w8emu03Y?yJ|biWzlvT z4Sg99Nh}baLqBm=3u!oFL8Ks(9&Szi4U?s;xtSL>#zyo&2ti#pku7EFhov+JR>9b> z*yHIi0mjcu7n?3h_uOyV>m{-d=cbHsE!f^~;Bn^q243siDnY4<`yD(BdiQ`BnLSo*GjXjE+?VQD_w^S zEw|2`SQ)f5y5=Rf`nRSNk}_BT5S_A`QtAodK+GU6kcB+9M;0drf(O0p=0)p{40q^@~+{Vl?QErB@wzmQ)_AEqUq=Rz!PE6_k=Y z^LAn2(^N;(8w@&8ZKPx62mxbxVX+!^pD7J*C@ty?->1Erf{ZNIFce!t1ssns#gR$N zv07Gj)EvxGL2*pI+Hix?7*$3;LIpyvF=k|ZAOz;w-j!1mF(32>6I4_cJawl@M$NG@ zM;O=A6`wb~QIHifwPE=s(;9wsEfPaz3r-m>l|~+PM*c=+u(Lwb8oKnCwtGgMkq;^( zj~ZhdHHMk5?ux=lM{SXhx?;MoE0m?kltms@g+J;F7)83bZmSFTs=Ao&s0;U^y6AYK z4ho~OhVSHTGi8rTgt5z_q!Jp5Bp5KS%X3^xXUY}4|7b>MCQHHA>efU|bcJgSi;0O7Q@`YN zvGZpbCD8S$dx24^tgP~Jb4rxa;zE2tGTOb%w6T%sjF;xE63VP%UZR+HCHkutonS_n62uQ zRj$ueO+%h)%u;nZsv$u&=BLK&)FC%@NKK7-DR{`1m&%rwV)n+3S*d(TN>M3UQfkOa zWyHI~W(^-`K71r6HFY^D_lca;)aRt!2XazVpObP|b5d$qf0L8q2KKOdi1+2DoVy*1 z3$rbK9ODIl^|ED{=;ZR;15)orn6wwaM4Ef?F}e) zHzl>kwH9uC`!ogjB|~MrsctBGei;E|D1Uz`3^A|ni?w7D-;?LGa)iyTMYK&=|MW*+A!+xw~5_x6X34+ z*rmtaOCfzEdQOV-qU~cPj#;-Z6aw%VV(c9#O;Xy6W+ToX%Wg=3e?Sl$QxWHzr$LF5{#lE2TqQhu@}7Ewek z<=bC7)wdE-6jkm3m&)Tx0I^yqE}3%)H2nUBvTA*|t7leYDn>FnZwQ8}6TWs~j+8rg z1}#s`Ci>UKn#&<_VHohZfJmifE?c~{bZOpXeTD!apSg?z5a{unXm?B^7_Kl?65d!x z?gZq(9d0Khg8YcN=dfB|M-WL`r8bS;#rHOFSEPzFJ`JwLe?_*hR0luPwuH9CIk2yw$7M@25Umssp}9cN;rDOa zF-ACY)~u>owH6>?ouj2)cIM27({{W@j9`FiIXr8zdF+jDAg}wF1Nt103U0h?9vhQ{ zaJ1sCtu24di#V$Z+~n{`>Xc}TD?~@!JzXy)6w^w{wuEWK8Lt|Zds-DbmQah0>JBwI z-n9pVukjM3rLoDA9-FaLy3yXD+o+D+snMz#1U$cDE@p{iTQ|%TO5#I+n6mv_^ zsOe!m6|t))*)hchBAm*^VLE_XW5{l|cWNqgs#=T^$!`EkF1&By%tJfJYs#Mlvs+l0 z9utU&>cOZhdzXfzQbjK}qDKNHiS3wE7MA+zOahqqb=fIzBzg}2X3Q{qFDCa?3WXwL zwaC3liX6!b^Wl;srtx;a+qkGmQ&IazTniD`DO)92w1HJ`+Q14xK!V~SEQCw5Wf||D@d}QJe9(VpRoiFk3S)uFi$F24SH+OHwfX zN*WP&0%K%U=<1x*en*u|2r;F2|`c#5rY!DJkylxo#e4#+1t>*N9Ea?@AO5y!%bo^ z?ye1m>qda?wZ$B#1s=L@C&`o2^HV{rP8_1*g!kK9?)Vy}tKjaz-SxqVJu)4P6vL)s zq!`Xcy5p(E#Wr3Wx$LQ5{Hoaia5VI5rtEZ!^W=TyS~(LK&bw4HYgHq~8L9M*S+Tp9XQ(L> zRfh6s3NxEkS-|>^AMNrcIp{gkAs<*f4zoAxNXO)IpCkCd_fWH>JAAYwO`HF|J=ULl zdq*N=l3?^7_T*r8A+*;OS)1&(5uyK}>uqkl+QpwV-feQ{77A7K%S&UNNsYYd@!L_Ko5xd(Sjby#;idnx<>J=11b*cv^WA_L!1IHH>Xw6wd&;D zR@hR9z9~wHa2$v*C+yu!5@)*(3w^y*?ylRB%OY^jO_iSnOvP2 z@-1WPX_6@eBig|U!Xi0LPi$`0BgI{y%<5!k(b2Gz4uAzB8EqrcQZ;}=W9X`rt*;_% zOepj_D1rK-d$hw1%+p-0&emj;z2IhY(~QR=LQys!hjZn4RhGDUlsb*ms5QHlYz(qd zBI295aYAVUXZpDn4Rui%*!M*=B$kYnyv>3T&rDmZ6>nFn13pjN~Lq6k%!!;|>lR z!mv#*6*Z@2o3&#KH2HZG`j{F~k~7ddKM$7~^bv6`5k1Os#mG>U4|PhoXF9I!vo-`7 zbFe+}7Fu%C{7v#Rw#7OeKpuI5R4^v;bOA253FUE=tE{Xh(4P6A^YqU6M@&-h)#J1f zQ2$kuE&80vNirs;tglT@h)@U09Q?$ZCTTuTA`W%TWVr&xQ^WB*-DTsd6Y4|1WRikLLknMY+@l+VX(GAYYWvczJLy$#=ZX9O_rMhT>ku)?_ zm^PJ9YWD~b8+s{{Nomd`84&}#akoodZ59lr!6b=u^eLxi$}?kxQIFX`_+Qi&R??#9 z#W7;|3EO4dKGti6SrNf20N3Ir9+x$>Pa|~XCSp~GQZyMM>(!Cuv1=yZP~=$5JZkGw zo{Gm)uhy4`J#4 zy*fz0S2VG@fryPsy`*- z>ce*5r1$A&Qf%846SvKzzNZK;8W?m+7K!O;zn2W9JS+w}ac26u+BaCSV344YVj@p=rij9R7X$U}&Ot6`h)`^JV9YnLg)|NtjtqUz8BM}7^`noD} zaH=8{(RQdqVPOxkEoM$a&Pk_nh~iDjLBu8GjS+{ab&&=_u!l{zag9gZRa*^vkUegE z^%Ac^sKSUwS@09)fiE)~w{~_%V)&0)oL%)VUrlr|teu;zht>-am|VYib$RJo&Comd z0L_Z!02DvdJ0_5lRxzsy8d778sbB(XqB2zyPtds?C<|0oTuRh*F{h>*wTV-ob5k}T zmW7JsGn8n)y7y8gI9P($DNf9HJmwAU4~h!)nbEpYq7^!*(wg;aJ_>X z&dvQM++Qd&y?UZLss%i!?fxw+Nz*e9d7P8RQ^-wrIg8A)n>RE1#UTAmmdQUD- zjM=n2@kM&Hcz^`@o=A6amPJ0kU|T6EsnMZZ>!rODTdX~kOf)5KZ+^PJxX0*TXxyeA z-*+T>Hw%8;7o*mp^?9XZx~1ESG6Me^Nc{i`A1o76Fj7-(*XEoO?yz07Fk}os&}!;U zhr0aPi)#61I%eE#HOYjCW{=n3V^(ryH3nq_lF-)aExVURF(BNumJ88fxQxAXaAraG zE*jgJaAMoGZQHhOI}aE?~YxQ2;{k*$s?^@l@ zT9#=L-a$L|T*1h=C4q!(-;ut|DxEbSA1bWl6Fsct3B$FOJl7_=Xnvjtl3myJ&?>ubh)Ns*T(*K%EN3lk-8&hu4_bki<`Q zN1tNuQ}&GbX{?VdCVk_{NhTGFGu~W2i?`vJY<6!&qif8%a$PuGQbj=*>Bn$QNuyZW_ zVVvvonXbnMQxis$32~Yp@vpP57F=Pezmd8+&69qlMY%#P2=7GuLA2?Kf$SFP0BG5j zXePAet4K=FPhICHWName*BIbE4`H7H<^FAOsASb9Buv@IXVHnf;H|n2dHwC*nIkMA zw$k-ctH39$e(+8-dO9HeSKqN9Rn7K1!Qu(AVufe*4wc(OnB3wdwBLz2N6YFLFoYux zKMI&j!c+Cdpzmls7L$aufu_!sz<S(+cgrU+x=r^`EXPBXT^OpGPmot-|-cv+^;8YfSB9*WPQ>$ zfF|$dYSm?J;r^u+fP2lWk0)fwm-}XMMxywj4@if;|9x4_D5ddU<1Mq0_$Q(R5BDh> zYoGDbUBBVXx|_X!15wb=4)!HO@b3-M^D2;=7s4y0YD_)TDd*4?{f#_S9wj$FL;%&R zzMCol@0}UIzMJ>(mjdXA>NOfjxvh{uEI1UL#T7c3Ri{9+lvo1Jp+q!x+m_+=P!);H zv~1JJt~7VJ-iKb8C#R&;*ose9J}z>W@8d?}F>i;BsWQ4xP>R5hr%u?ff_`HP@&4rY7rs%f~ju3;~x1~*fTEelg)!z?d~TM2h7Z|7D=Tk5sNkg zwhlDKx@EMc^CwU+sgXEmF=6Z`N~o1YsP#MHyi*sBmKRJ z^m{P#D9_4rNjO+2XW7SLY%-~fEZrs7VZP8lthG24e9?G92ypXQq~J^yzdJ9Y{43HWm^KBS?=k%+bVuTO z#&a|C)&_f~02KKjb~AiAC=VMkpI&dr4fwwMH_{0E{mBfJ7|s$6=_YtmEBGItE1wVg zQ{J}6{4f0Cm!ucW*t|MKU2$mo+;%VAB2(gQYS-Q0+x{Oqa-ZnoE!`ha zfY!Bfnem%`>w}iFg?}7+%KPO?AUGLw$J!?JZqagp@zAzv!uQ=uo_fRauePRGw*6sc4K346o=xc;| zeXeOsX&)16m#0*p9~8(p2-TTYKGJNvmw0Zd@z}=!JCdJ(`+*j`vIA#rgf~v&w_j(p zqW3ay9MgPDF{p5Hm-ls_8es%4`pw&)r+-t#H+~;?`QOo`orydClx%gdeMGat(@ z*G_vIdYx6S`#U0rSG3H-aL^WAcCJ<+-deP}eZce>VYb$z;CZI`>kv8@f41wH$~b(5 zKXO>t;3ify)?vZ-h*H*@!&z#d@BH{#x*B$6WJu3U!yk}L{Nrj!@5z5^QikpP3*gWG zWAFvg@Q88T)5Zb)-SuFF|ZQXl-W#J!i)Y%PzR z5u|+9wLOp~3K7q?SK`yg-?S&|ShFj=W?*gIdmAJiqDaz=Btt&Q)P6@hjMVm$m9$TUGb-87@AW=5q)yUj^rP zX|k@!#+zJ7kI0(?UB; zH@RSz!3izGfDQp zEecsCLSL)I5ZzWBL1}6h@u08%Jh(O4W7&*~hH0TEG<9IZJwaWX{DX`coa(zl8_H35 zt|E>UQdM+xFJpcuX+8<3bF)I15R{QmdOxayQLu6|GWW>iH;?+{ zmZc#GC~Vne+n}5YQTe?!vBEXLq}YR21Z{!XUrsM-ViA-O(VcM86d1~VhJmbPC118! zmT4#FVW@w~>Rr&7l%TvlXf4CP#j^A&cvvt?QQ?NuTeY^RGQ2q*B-IO2YTh0u1*SzZ ztd0*K(KsNE6{=@U5XN|G*Z`8oCwN;Xnvc^mysa|6@nQx%Fsmpgn^7`>YiEWhc->zX_<6XGlu_Q)HQ@q zn$0ZhD}#o4Cjr6j#aMR@$;+LQ0Vb*k&kF0XmW{CB!ODQwZYV zP-cvbR^iZg5fg;U)$oA2zKWRf$?i6iayn0_5Y@sR{#2i^T%=^NT-b44Lzf;cGC9bG z2u*nk&a zlYv3&Dzb9QS%Gb}QF0M~ zM*~Q(uy;i!P0505K6>Gev~Pd6NyJ-a`BMy>W1i|_ZX)58DC9BZ7!rU|_Rs1xx2Gx zYy%^k9>0p|o7Mc3Ea9G~Z90t=_O*HNB3^O92;I+;8zbVL$@SbLUVu0;Cz9RfE_-lU zL00cQEV9*YL=;br{gZR!=cr+a*66MkS@^J9z4x-*R<{9p2jbzcRPMz-zS{y zdpx4;`+{NKf+1v)?g>e_hUCXQCT2L2?}{G|l-XXE?5|wMnHo^T4Zz?jFyE)hpWGe~ zYAtyuZq!-~4M5+(PL=wC-Ws*twc`+}8-Dd)ZvYz?M11cvFYpq6_|4`q15-5S9$i?C zfV;a+JLcf7fsb;5(|D4ZzRj zc(B~Jpx~7ox>{94=&S0hiH>yALzdSqVHWtlq9jYdw zpF7`r;A*&*$ReGvZ8BumAOM;FWC7I)$hoa?COuU9@vFQ9H@vCzsF|CJwzSQnd37&32+_6-j$a7O}60^u(x$8+~ zq~tj$x5wY|6cq5D7rHEoQ*OxypF*p%7n6U`u0rE`Qb|_m%w6;KhVj+Nw3jB2PGj0% zX_`8{#W0=bs*-&>DWHAt_`#`PoB7&&#qwO_&y&_0UW>fd@-}i8$v5v`50cz+-eSI$ zMe^w7NmnUcl=g-XlK8oiXk*7Ure_XU)GvYS{qMc)+ZcjxGJZR6)rx@P_g?o$CBWf- zi>CKp#JRMM(tA*T34JI1QN;HVz-f0f{ew@~4skE2};c zNpo`@ehm}j@zqGO?3~@qwnlpOW4L3%I)GH#klB-hJYe&sN!O@$UzT{5aURc zIuT-IWA--bv;|UXl!{4hnAuj1v%y8I3fEd7Njv_uk8}(SSR9)84eCU!=a-a2Kbjq% zY8pT=@bMS0r1X|WjJve;8?f~FYH`!Y@8ZMi|F(3~mYzPO$2aM#F1^!Iy=xnrueG(V z9_QA!bhKuerE|i!=a@F{wamDR?>xK6(EieJexmIjb))V!Bk!sKIowAyi7#4!X#Tkd zw$n0DlL5%q+SVl4#=%VT)?UI-&#^tLzHeHG8@U0}R1H!;{yc_c#%V#BE|#g@y?I!| zNVYTc;?~mF%X?}2m{RSA&yMwF@<-2Tx~xq6n1}GCaSxX0w;$z>gDuR&xwe){dW!^% zE%G&U>KzzyW=WV(RgRKXGcg+#_!)Cp=KRekOCbxrCIh8ueW!$GaT0AcWy%OQHJj?$ zbSbtm&{vTdZZ2zb zJ(ZC$@YE&(__1lOR6lNo5-q|~0Y5AemkoR&U2;+Pkm^CiSr5zRLjbT_)c#&0>F5(C za=djz^IBb*IMc4lfr|R>;*!<2NMp&S%SPVPn?pe=Bx&06bhSZVU`0!0TsuU@LDC6g+y-x^VXFoG#cl=raN|hMHcfWe(uHOT;ASZb@fL)E%*$dve!{)OB>PfZ;)V};#zt%gnD{PC+3Jw zZr^z%VOf7aNp@8Td`ZP`Y%LIPA~MZhJxBl~;%P8A#<~zR>6SFx2oyyWgnVf*F6($q z)2f(8q}`Lt+Ej+?Z^-dAOnl-XwF=+L1)t)UPIB2s#>kV!(q1cn13-0>3RukOl^<-2 zZ!0X3uV{-MJCw2bOBuN;7&EO38(zArTM_f~&I|xuoz?v=+V&GD+|lBiUe*k-vgg;1 zRy`Ji0w8VNezL+TqW47B8Fgy-)VujhiUO;@RrUu@*&C_E{q5-%3K2rKim)MiCaEmf zI1~{jFnLLYD2^rQH(^Zv&Q=k#vsyvN~uDzSh`%NHP(m5>qc@-qN zDFgXvGt%LWhcc*el4*|QbjJuuYrayNxWLd4@?-rL!{qp{T6Xo0+#wt%Mx0c3s*F+V zgQ;yG4bs@FmTYP7CbTfE%Q$lsmE#N>rSg3>Xz?PRX@&S^+Ude)vljScRtZbxcsqe| zL+gloqZbw0R00s-#@=wId+KG@@|2ckA_3w4N_zWMu-;!Q`qmMlCwc>YM{_uDse5>oY82;X-ir|42(U=Tgt~9#}dYdmj3C}Y|(!D<{U37DAIP|b~)C^;9tz~X{ zvkZJE=+KvTd=JEmlY^HWyh*+;e0JN0q|N*O@-sDjU*S<(Tyzx@(Z!RANZvo(i*WC( z-7yb4T_$4W?d?4H^V_L2HXiIA%3$~y9HIc5;?Wa_dK$Aso@%l(@qWXf%#lKSc<655 z+I#G|E+p$H!1NqOv;6wIEDn^-eAt@@fa*znd_z-UMOieOd+^*6O?9{R~ z%?Gvlg}rWhdI;TNQ|Ph|roqOYle`;T#aLCxRX){#_29+ICOyXHmFVu98B-o>5&h!s zH%Em1SQ}@4Doy;vm5&*d55W8%KGTp*XkWmG*hm?-H991+qtW#^6QC$fzEk_m3VWU^!bHHw^GIvW$xZT3*(=}t)`tK&S zI&~Le!WzMB_&{6PiFj!n8;s+|VVe(AI4D5t63slVnsjC`L7r#SFf1Ixh?)8YPrj3b z(@24cec1f?L(f@5M)0$#l4!oJRwq|^LO|qYnAQGC(;XW;q2rb3Ec`K(}AiaH(`sZ4={x(ahemI zqo7#q5ODJy0tbR$bPeQp{3+A zfK$?7TtqqxLb~mXxI7|~S}cm$kQIK*W%3j@%1>EabdL77P*-Kt08TY7ICIi+$$P|5 z&I2Ye)x_DJ`L9uG2%W``o_@D$-Ccu1p{kQ(Ja8M-7|5lXoK#7SW%1#X2zfA;bI)_v zZORe-qEuFFlnb6lQZDdfl@wY=h`By_Q$sAfA23s7)bAA*)AsGilf2f!)bpc>F2@0uR>$RQc%*qwZr9rGQzt-h$Tbx@)J=0i_Li zDpNS$%h>0O2@d!hDwZ?O3yN$?LYb-Nd z_kdfAc(O-NfHVz0)tIeM6*f46rF!jlY%UIq(m6T<+%xmh*PpTp1KMBfq9}Pn?JUYl zBuhU?GRP=>ScGFU^MXn=gy3&ef~qnpc{eTaNG4h`tqWQ#OnF`Puj+Hx;x5hzICWzO zQ_N;Lj!1x~2-^dF)J#`1X(N^t9$p7PgD+tnnBLusedK$~N{o>%TsXl{?H{h{J z`n!n4-T%}HK0$X!l~3nrRurAxIUgOF;n+X#1;w}05ly{0*^(pr|Ku*`07h+CFd*bg z^)8VjEpuL)4&z~ATSOL$a6ZpHGU@x=vf%n5(e@quVD4mM;G_T!>25DoM!^eaEM_J3 ztZ8O}z?tF~SU~>8P(IliQuCD9djDvBV0n`>)@)RiZv**^pxSr(peSCkOSD}(11TO{ z+d2vg$G#w!BpZjAAQof8?{J1?vsIl^uf7VhlD;9wEijpVG=qzj=)`0ame$2NW)U2k zM4x(b2#w}!@6lfB9_q5F)rpoF2RcwQn5+jixrUBDurj8XTOAT4Y?3TU2A2Sm(7a#Z zz;JNx=fI!%K|(n{(N>Xg_qo*mV5|5`VP!rTJR%bl5ro>W zJvnaNJSwi#joRk>hSVPD4#v(`f-jS97Gmgrg`ql+yWIMUu8|>pt|Uqi~_2cIFIPw+EYnyI|H`KZHwyiphB-e&y@$eMG1r=1}fYaFD?4JqR6Uo_2hI|NdB!zir|NNOQ!NT z-^6X3(h~KCyFhHZ#ZWZLteZG7U}%5g<9NBzFm~xYRL45qWXUSuY-TK_y8O{AJdF5) z7Bd)w5w|IPFx)O)c|EC}Zd`rYWiLt&l~X^mOq(hY#l~?p6#|_`PVgOl^0%iJ2Ka>= zduk1_$}@;3hV~T#JADswYu>2vWM1&;u} zAs4tUE%}+1JgX-OM#WQ;V+^$f?F)Fp!3easeNtoV`En_hha46-f0WH1r;k;TD~C^C zR1G6bJGjNI)9tMNg_XWNzOSug0Wjm3@vP}G=B~11DZonn6!PUtHdtY8@u>r{GVxz( z#<_cog@>4VqGQ!84{q)RHRjO|^4jI3=ZzwJiS{_~!_9WbP#_ry z{0`vaQ5gxCS)5X`35Glw!{P+Z<_K~h4T=$kEo22rnK}1^B$KhtO8M3cj75%-?g0e2 zMn#otZ=9#|EINZZq$-Z-QqvQF?5+!Wj)hhl(k(28nANoOr_xs^LhI3u@SA zA3RMxe;+H=Z<4^=@)y8g^23B&=tdb323~&d!4?G-733>{)T!MuBWXHyo$fyEV})h1 zY}`VppUGt;p%QaIz|qVqF*jx#IBl5S5Th!z?T;#m33DS=UrP^n!*A@3!apa=7-ds3#r zY+vWnZ6*#*qfCrDb1$NRrCX$!%R6lDxS9;xCGlzB2TJa_E0!427U6rOd_H%!$%? zbK{!KIK|nT8WmM~J}}Z%Bt5<5pCewU01_mvBg`hyP4$UwVFXa8Vph zm}6-Zy4hw(3j1R#eG3$j*CLu5k11~lfs)`_UjXdvjT?tv0AX3yfeS44>QrR zR|ve{)CXtksaEJYrPTw;(!|WzUFk>Mu~@3r9IC1{L50SO{5?@TNG&ZqXWXZmW^;&O z{Z$!I5D1Jukw7}<8pFd2YEetS1&C-jjG*8Y(9p0Xh8ahGH+!n|NJ>t%{vT4Uy9gbe z&81F`%1cl~4EC>}95ZydwDj(9I|=r0p2lrrsUL}9448T?zF|qr-pv`oExi%Xd=dre z+CgEmi2LOcy1JuroODRLDr5-rz$@6sZXI39${EUwCdmqZph`}_ez4|vl!tq)7zzce zv@{Cwks>0lh6^cs#tkD3`6uEJ5>+ynnWpG6T!8VtHh(f*YYq`U^_ta?h zWl9|petUM2eyw%jB_6e)aHN)sFE{NDP}8m{YCD4!s3w;CrtFGIt8Ub#%?GeHB^FVJ z-6lI{vhbcKL4qhv1m($VThEQp@@uw%V9b2#wdFtvU`j_ecQ)F=wL7_qB?$#uoCdWv z)DmK$)n-US(2tQUk~kggu!$-hGOF{jxw|Gaq7T#%zuPme4TtW`2)`rpRYs9Du8e#b z;yjJgw{)w3YQXo%U8VY~pITY7pU$E&v7!WaMZwR!!Yv{C(Da^j^^1cZi{(@y(Q|^V zsOSHO?-1ehkMFQ#`H$~#5i~f<%I=fY@fREUubQg?(vmfj)OcNI#H(bS)?aj)6{!NR zATYOqutqe2jWbscbvuXAOcfd)sJPce8R;>$KL+uek`6#&Y~Sg6O!vBXCSm`F?vR5> zPhfVL7V-!|Fjv=#%EX|6^;2<+o&`$fHe!!p>=#ArVT!k=9cSy#@~oEYhphT`^y@2% zduaX~sYl-tTLGOYh0cirS9_VNdn|LTS{ZCdNpt*xPoAKUe z2qgB30N_1oj$KuT2ciqrHmv5V@3^(?a7C6DDiG*P6Qf|T|2}W5F@<$^&_ies^CtC} zsO#jR$IM7klsT*pVYk)&iTkBipM0X+D}b9d8jIpMGC@%rAq```8tPV!{pXmKHp=ej zVgXv+Z11~#ZO6fhI_4+i_^3?ynNUQK&mU*&)&nuzpGo;8L=kz=Du~M>W()ZMoD4{rbwK2HqAxFzet{`4Ct)43=ZJ8vYBV{ze7rby?8ELYy;C^adJlJV*0ot zQLJWaWyF6aW5VGW;A1d*t`=t#2u&I{NrHI(`kT(V^DsSeQWyYNwx(v+j)DyZa%3nR zzTz?g&goCtNE8fEA5zWrL?PbBNXD4=vh=BCmFi(c)fwQ;-k<(<#B0C=l|GuyT$l*Vt9SnV3V zZPkX!DF680^O}1L2N&b+rs~B!+@HhYNXK`R_}VusWbIAp%9Sk2oUmD6yG$S=oFO-5Srd32)e9x<9T?n>? z;&;fDsKks?M*gkuUXD`0xa!55s+ibEm6EC0hQ@HY5a@JEAax3s*tOM=wFEHwC@}HxWY{w)mG$k2xqTy*@kqL%v zpwazQtsfzlb3I}0i>3&JIVw<2fh(e!rJ6w)ku7AnaMh6syi0KCMlgu;&hxqA9hq1D zws{HB0%@(CT1!A#zt)K*#$>p6+%2@Mw}|I;wrC|cl=z~yf>g{R(GPccHi7-Ic9rSp9G*SGnUs}y*mgaV>8Sr z+*hLg;f6^>DTr}L<%0vVFL@$#jjtPJU?z;jx2*K``9&sTz83(0=9eswyW_%AWkJj; zXpVW0x`wcH^Ah{aP-mQ(+AV3oFt^(WjfU^@CiX$X}ovR16 z8dHoG!k6P9a#HpH8uRo+2w-$gg&j;$VG0g*0Q+LCO%%qgC(y6H%Sftc95&%%1%kfv zGlg`3G2Nw$@!lYjf+NI3*r?XMk81^d$~al? zg{ao$rX3Xbmj3HB?YVuEsobg zH_GIm)AgJsn?=(V>%jS^>9#3=$bO?i*!FysdX?lp{(8ElXf=!^mA8Rf6!Ha`3}L;k z!cFHg_EWi@GE++q&-~ur=yr!D2tVAG6vgt_N!=~Ngk>UyA6mF25JrwG!(0;J!v{OS zKkbr#I$mF4?!%1CAef*=BUYF>E855qCmW$KW$tTpQAxT<)BQykmy#{?7 z4G3fN5BzWhai=xs;~>gxpt>D+8{F6Of$=>UblkY#PbZ=fS=E{8-WrCgVKMroJq9|+ zoN#l>NdOX_1aTXcGKTQ=J=@ia(*&qM9YP(6PzO}QpM%CC$^=yf)i~?34OciXzFsKU z;*#%ZR`sgpP9eG?UlC(i`xRB$WX|TuEbw-L)j(PHQNub-MoRtc^inHBN=75iR~YzR zfBUo0r>msASrqAI{E6?G@rLVpuZwDxr-^hypdJNj3o3?W-8 zD`jIPAEw+K!Y;B8HljPY)Rt&5tC$cO_f_q93&lb~&l@P+&~zBQ!Vql$q8pHjxu=xH z(keS4UV@YA5AN%wghv6MQuJLt?HqDAFe zGn$9*K-IS%$h=w5V{1a7?FZd2vb2y;yvg8~uKg%Vg&F-Bp{I@;zn5qgq`H+K!h zknC>1^Il@Ntf6?}S~A^%l^Mt!oPty;kd0k<4s@ ztQ~jC?GPiG$7CZR%TqePNmLSM9^I3edB%CtstX7S*mC5uPYBVLdPwMa;vwv3P1YZH z@WhkM647rf;L{i|XaoW0c|j7v;#ZK6LBwbxrf<&h9WrP<6ql_!UU(dE;=cE8Qc+)_ zj*UG*n-208SK8#Msck@xMRl6;Lq1skoaRMl-{eDMcf}u;y{-U1G#r6Dl(PEv-u_m} zY0qeX6bi^qR(2rvWM;Y=A)%UWw!xgiVHO_Uj(HNiBfRt^3}pt58_TSvN@5HnHvpbv zc}tme%Xj6Y)8*Aor${O`71*uCAay=!X>;I2g>9BFCtRrMY?M0UvH2m+W*!KHo3-n- z#ap`?z2-@ra35MD(V9)F;fq@0-wE!(I(9@;#2VsEI;hU%%Evw=p!Ui$V>hSp>Vsqa z$pg~(QA^a{L}h@Ks(FGgdi1d3i(g>z8uy+9Q0u&;&QqfE1Db)W6ulHbKP%49zJTP-64T``($p%Im0p$6rbL3uSUCFgD?rh}=; z!ug9O@UIz%H)EH#o&%lW86M2N)JB7Qk>XP)MSH}l=A!A0qw<10(c`?wPcj&~haC|_ z+-Qer%0FP(mLvL(l6o&B8Ki$`(!RqEN@AJ8Q&|^>`@jT>q-9hSYIy9yb427ILaaz= zi;+F_dt&>fpFF>Lo^8b@@}JCjj)J76mE6+xHa6}_sj_8X(PMy!rMJ|{UT?vTzP{gd z=^6Svf&OiWNj;VLj#a1DY1@9KDTs;*pQr>*vR7%cohrj8FI{m);5=Zz9t2%7Pz1Os zr_81PE0gq9J_&NkuAHiTR=F+XM!@snr>Qe@+FuZk(Na>gmWwa3CPZo192q|4*%MCy z-x3+_74#ciQB1fuXa`+fQg5_Rn#_{Xkoi<;CD=s~mXafK0vI(!Wn>ab9(Rm?3b7@s zO4{Yl&a=J$K_F-UwK{q~JK7&JJbh5e*RRJ>Vkm6Ynl5Wv=>~|ETu&k5TohDNV@ipj zG?BuFN@@kAOR{7tJC;ll+T!n?`a|f6pkrz;D&uHEPLKs^HtEXtwL-9b5I7{r0lCJ_ z|MhRCJpW8G*MGp*0}8MwC;K;??{wtL6^||-k*)+M3}9j-;NSIe?+LZJACq>GHK5;o z(E*ilf9(Ho?D#hC@95uVd;C#d+<;2dU|hjXIxnn#?Xc*P^>~_8U(u#L-7-}YZEtKjvX?7rpCGG@A>xYB-7Qe+BqaCPN+Jq7AaLMfsaMb_Ki1h)C&Hcl zp|PoYvzTTg1zrvyb6uy{^vLUB7Jy!r=2WNlP|oSIMZuP%hws=N>3! zOCo;;^;#$)QPurw(h;H}+abG8!hq5<;Bjx!NchD^DEp5`2g_(D5n?+L3tfXrZ?xq&j4x zQ34Dsh#QxVV!Szoeu5$V7<4AqW%p_(a@mm+#C#wtm_?ystKKKL7gH}vIH~CEFCd?> z6<^gyzcN`C)_(@=CSi`thh{mPmD38Me8Yyy%c)z7S_|L}q?N=KF<4{OMV^RD(LSz- z(=0!7117zUajrA}9Leeth_9Ru0)b6OPl^@YcZ78Y+ufhQ~sJBJr_N&$rYC9-yUL9ghi|Mb`aEKVW0=J~FB z*na=2H$|!ISGat2zD4}RG?n8Isk4vR)2cEJ`P8!q>HjNuU+limb(7~y56@<+aZk{} zhfijp?c@J*n%~%qZqTqLo6Gt1as!IqxIO;=UCRmq{Uny+g*-Bj7h!amEzo z+z%V`&A<$IT=;FgEISA0vh2^YavJwF!{4A|n76O!UyT+prgkRIE>5O~w*PAOMpiJ4 z9GnCU1pjJ0JoGA_4yN=9hUTU)-&ZG7I~M{*Hr8*o5&^xEsk6PSld-8Y!FN9~dpj2% z9vFHt27>>n>BSfc*#GsT7h@t|VfxPF-b-O0wxCL|Co_v`d9xqGbMs=L;q~anwnS|3fX%QXn#u?2-p~z z2-rE92)=CyJJ~z@9~DA2rluzUM~%3Xy{p6jUhsb!^vd)qPKI{Q4*%9|>`5=IOfO>U zW@&7yBrf!Cc;W9Qe*@yIO~AArBA1e?TXo|HeVt#TJHMj)0Nr8(2#xXBPraW*B-IQ#*4P3xfaJQTnH` zaWQowpck_-bTJh%HMTb~{fE&1{HY#mO}|Fr`vl-buM3vG^$bV|-c?cW?Q-Mun-kIq)OqGL07O3@EkFHpdcGFlYwrDv zKkm=zzZO4g{2e1U8afH29eJ~$yYo4e!x?pJEZ}KPa)UTNU45XjzF)#Xa zUsrm*mv#<-&n%b9hleOzrTa(q=ooy`#vl6p=9XCw*=akk#19&8GU-7--?zU?m%muG zKizw9?s~pjo=-myh2`I+*Iy88zHFbG2HuGWn7%hNe{J$skA&~>1y;xfUtDFv`13*l zJmG5mUuOEvJ21yz3AjQx({lRn^$_B`lJa6dUP&WkjCn(&PWmOL&R)j+?pjy=Y4v_JKa ztbo)wb>FwOYLbrljjS%$&mS+Ai&ihNj{aV)pMO1*m;AWI+|SdmdPj91pALOR`;1hl zJ<&bk{%9b!i6dqi74RPjfJiHVyYCP2|Cp}%dVU@6X(;+!Gv*j>Cfj^}jNH&aCU;sU zx7vs7cH|!o5=;5#&b#;`-?)tcy}sZ_`C$`pp?iN z=SnbTHHRV($i>q)oK9~vu>82^O6GG`JpG~nWLD?Tp?6+3B|oHMR$~GKNz94(rB0(U z`=QlQwN3v>;%BDOnS zQw(XrX++H%o4^z%d)gp7PWD4~rSC-W+hx&hBKO>0mOa*iJj1=^kcWGe{2hgxMl<;`DRI(PhkMEoUrBmrq?jxII=5fOg$<_M`<1GLO+GKPM z`t!k7&il1JGV$JFh>V1Po1WBcIEF^Y=!wk$fi%}EvL3uV>-^z8ZIx1H6JY#0?#F(# zCu?@q!LMi8)3eFBd1WSD=;y5ZRkb;_x_R{&zjC?Jw%+v#+>z7Jv3aiEv1$Kna5HQ3 z{4Gm2lN&}WOPM_7+V{Hc9kwo_6?}sKUTy*9T0EA$SQmkF(MQk|92 zQ^OrsGXLFIfldLV@2pk;wUMIxcM)HB%3H$VEHpNGoV29YeTiwsNyHaDsODK3P717JaC?rjPf=a>t!x^w-j;ReR{*<3z%am*I4yh1GiYzB(r6X$&s$1 z4)ht;IM$wJkED(Ip$Zby*l_E}mdVE{leD&L&q?C3Q7pq(6-`Ow+eL+Zky6tYjdR@OqM;GrF{mhW1VZB)b;YVyZk+WPlxhZ zM88(8N55@?>e|saG$DNrZytUXcfdA;Q?j>J6+J_z+xYFDOEX7`>5!Afs<3x%2tZty zv}TPA5{xVjSr+Iv_}2tWlj-Q5pd1({MN1#g&W^!3*$0BTlh=WFl1f%^86WOy2fsFq z{XHkdctMX{HcXNS?t7$5qsv9g_PJgi0J;}6u;`qk)C}?Q%||%c>UIuPOl>~ke77G} z@H;P3rc=Z0_lFZc_j8>2unb%Jm=y$+VrsePy3|}VHO4zvS4nMd^PTDqOPVJ&ZItRH z2v5xts$XEG={*Hd55K5&yLR4ss=>joA4XsGS5-DteFk~c4&vBGZ@v%TR6EIh`gU3~ z4rl7=ZuJM!(e!Y`ABPUehxINwAEz zzrBM>&vv_ql4FRXzioo@6(C&XBe!yI&lE8TIZlB7P2mmDwuXc=diLfN8OhOwd;j*=2n zLw(>J-2XqNP@kmDC-30?6m$MZyo3Am%=u^D!To*A`A6Qt{hiGDC*HyRea!hs-ogDn z%=s^Ox5P*7|MxdHJ-NTLyZzF1;5Vqjo131gy1SY5(&7H(yz={3g1AeM`bYBiKW3?3 zf19OpzsFL&zQaI#{WTk$N3$)JHDLeV>bJq;v`a2WI>qhxz|Qhq;H~+MefLbhL-U@z5Zv&UUMi zMdPz{$VLN1OD(GgNCX3Y{QZjL{#%OVekhVPvmEu>{NJriu4716KJxR->DHlN^Dye< zthKVpfYb%+;14^s$+1rVD%HyQ@6GYAvvYk5(Sj{4;NwH?FAW;IV;-0(@?4;4?m)E5 zhdK}E?=8^ZGAH~aUI1r%4mT@MFJ7P?)`a2a1ghB6C@TQt8N&-CRxTNKfRH~lugOJ@ z9+-^M6~ujmC7>?+q`_A?iX@qrIO9ulrOc8ZFz|$lvA6HOy;loR&M0mkA4A z(jSo5V}3^!viOd|&V|Mc4iM8NM9*1>r}I@)iB7Q3G5}bG z2U>rnepf-Q$KOx2h+6t-UXFn-Wx^)LCVWKCd<~;+(a|k@Vo=UglW(yD-G7cl)-@@t z!9y^6MpIJ+PIE%B7R!q!y9iGj5}zF#iK32{8*Qc|m@3AH@O*xt)wZM zhmu&GC8+vdGt?*rWKFlgX{oO@X&}m4z;?{NKmt-yr#+<<4>{~VznGbptu?%KS8RI7 z%AQ!e8pEQWEWfC-wa9&v_ozbE{Cw>-*b<8ygN&gMo=Z{o9B+?%NNUNk#7*C246!4pDHceR4I|G9D3%k z2}GAqF2-AhHiItgha4GdB+;3NB`c#@kyyyqaL9{u$IZnGlXjAL-M0d|scajbfKv&5 zda;EC&#B516_)-^nvfv|A3$p<56P`|8l0wm&e2SvFPEs|qO3z;yX(%M)u%tY@wC7f z0b!`z_r(cW7@-s&N#1yV@{Z<&iJ>$t-X|d2!cSTMSCYr3*)!b~PUM&J3%@F(ZnLQC zCx7nUu={B;K6m$?`Ea8BeSFV)`R^Begsn{SyltrP!+T?Yq&wIafrL{Avh9z;DFq?E z(?_25yiJ^%4{^qUqMZH{<#eBD?ed>cpj8!P(8OX%2=5ll zeIi-!iL{(2^4Nb}&J%oqE$@kheaJXZq-Y%`Xk5mBqUw%8hrRetuwaBg=t!(1%FB6z zR&z_NT3YTCyusF$ur3r#Q6}=xt%6SXb=>ma-oGIm8G}7BNIEk5_Y}DFC6^iA*IpJy z=2I0$onbWvCsi{ut?G^tnLF!c^B!RGq__$`zyR#OZ*Bt%fj)Sb<|60jRZOQQ6O_r1 zG)Xb4Z~$Mz$IyBZ4l=mKUaBODlYA9PFZ1W@)fFZP8!EDK$?da9Ey&Zw7hX7>H+xB@ zp$vlnJSVs`&zZg!u^7G4*725gOio1v-yeoVnP`x1RYt1QLpTZBJVE%&Wo;bHMaip95=(a(j(zc7xLCr!TBKyT^PGl@m6Kh3 z3vj1w#2<_xBlb-ksM?<8EB#)4i~hM~`E!)*vhvOZ^HLtWSdO+VcG3{h%?|mp6LWTL z@ty2}tDp${_+o+^nJmu26O?aca(1;*_H^RpTW?$neDUGcNos&KiCI6A5+qg8pYs(_ z=^124KPdjm&;;G5Gjr}#J^YT6gk&Hh4!Tnz(mg{&*187ezsp^+BF75PB^{&G)!p8UkzP}`>YjPcny3?ywDlr_` zzF6Fs3NrvXDC0zX%uWzLT<_k!sf=DU>CMn?(m^W0nb~3r#;Sd-jJ82 zKh_WnYeOfdLR=GM3YQ3xH&L3VH%%Bm5_h@{y(Aauogc!Zh@Es2o<+H>LQ*=CPk5eu ze2vEG&L#TtNWkwm>x*)y6irNoC@=>geOXx6@5vz6;z^|jnTv!h#~lM!JgG=swkJN4 z>PU{C61GC;OHKV*PV=?cdFJs|*}?QDhRg>N`_R-^sg~RviGS0&yzX>CWcnhzsg~LI zoSmgzk|x`Ls?r_F(TWxq0tRLD(0zluH8L}wnr=<|qX-LMwK&Op%5H!d z9<_OrLqe>htGHIgChjF+-+oeENn-ezV~uiMl8U3=h=Ug^Dq)R<)*?DOD9;}wL}8Dx zMgP?TnPhDNd6%`Q-ky+-s$!vN9>N9i_BoX0iemI1WP&k3A4P@ynx{q0Q|%f$TIx+& zlFkfmnfpq~Ev7Jk7u!vo#!(I3ObdN&W5^hpz2IfP`Z>n(0^$s#skMlVR&wB*a*k^0 zwcEgc6j(zn`YR}0ALFS2Eu4~zHFg`GO@~Qlb zC;if6b(xQ%aUHUvw&>cSw+`_>k*mkozWU{|d~w1dLZ!Lyl$H9@ z>ptuKHAOQnC{HUH(vSmzuK_A;*Khu2InkGjlvr?Kh4Gx!E64)$TI!P=wnM2v7p_QZ zbnesad>$(F3o6N+mkVJO2Q%{u5S{!1(f*EejxPN~s@ALu=Ka#^1B7~54}7m?sVHBG zyxa)&3L;SpzT^f%HN5opvG_Z^eK1qceb+-??-XLKx-T7ayWM}!Y#1Oa+1I{nV4=wN zCJI}hGxdWfAI=l^UzXrS^(cQeNYR~NxREAIauk7amouF%8!A;5u@W;l)E-}`De+z$ zI{l?(%_mbx)pK1;EmV}($Qz;*xtmqG`mSWw<+YG7wnw5$Y}egR&muWV_%MbNM6Qvd zITY!}ymWAm&6I%eG7y>@LuzrtIaxguQ84$VLE982w*CA7kNwJpA~%G;t)afH)i8o3 zB;osVBH84Z9;?3<3F40w)uhVanrg24&{c;^SxwC+WtW*d3Pxk?bUV9M)|mL8Ovy^( z1kGQq)* z!w3hLuFDLE^H@V1s?=KIgg-XL!O>~0alHSPLC)*@2089G402xkO885QoZyT}PWeNN zoIIY<9zL1m9MS->Lv4A7Df`G*qYg%g&QV=6)zm~o^0Fe*ErFMP+SBr!jOh_90v zZV*>0<_c;~M9nODDciuxC64S7Ojv-T=e6h0I@6AqxLD3+tx!%yoQ6CmQ9%ybxg;rZ zR5m~&7^k|7KIDSijKY!?8(|q-i(vG#3W=A9tCg+GzR4QVy7YF9%IEwk$F-!5J6Wt| z!LWKvHA8IkrJS$`yk+$ms}@f9C8>%;g23XbASa>R-&l@RjB-=H-nu6U=`u@ua*!Yk zp{SOCmG*YpYU;gg%&XsqhH9&>O38UK<9T1yx>e?V8ydXkO9QgCE{iI&(cfNQiESgj z2}iY;-pYXCUJ9IY|~6N;LmsOIcTXL+j9RTWprVr$#>omEdu|L`S3RE`X^ z7Tdbs(wZXaXV>**R$A=ZmBsCdIIXs=Gh9jx5o)nGH4A^Z_XuwQGQgE!8oUlfgv&}# z7Sz4MC z{p@{Mzx2FXX0NoP?>}G3$@P>b7a2WKf!H&47V&c02ft&H*eo~VKA*x7Ju2f;QUBo% z1N#}O--&8kw_Mf%>fs=YTbaosnKar*HHwwV3YEY6+I}QW%)knp#WqRB6;f~K6Pwcq=XT}%`G9+k3UV*mCQ(>t+X+t$*#?ygF3r?qeL->Qhc z(h9|+cDAw?iP^3fWoHOW%HmA2Eah=H=8KPNMca(A?2rqhT3fUhmusWjx^b_IyL}SH z%EnRV>D~T#Ww}4vI7+-%^@)65)llQQQh2R>b6NZP+MIQ;+h)><$f930EMAv>VHSt5 zL425nWK$`Xy+5m1Q0&n;P(o%iPj$#lq!%1P14HS(MX&3edaEVQzU8nb^~gN^)rzwZ z8=BCVyz?R0WO_+MRlQfEbeAvIPSuv8FI|lB+ZsM}<(=zxCQ<_uIjh7fK>}keQ*N1N zI=~bUdr7l5YL1%C9>5kRZn=?tZ4-y(osh*g^J}T;YZb$ivE4hOt_ow)z8GWk_a-)F zL3UN|_m|mgU)d_N?UETPjx{wbmj0C_1)^l^U42QD3aUloTGXIkSROL!)jsjgFGQ)~ zJSy0+VA-XOeNJpkcixEkIB!AEyk_6F3u;k4Fy6~j{7Zu8ed(Qx<)3@&U5kaHe2K$^E~a@c zQSFTUUfxXWZ#>1shg#dr%I>wn5)95O2WN~c9?fz(;akYE3lHXlnyp+64}-*7Boh+m zmdTNcZ431h{@yBUmQvPj687O5=JrM&>A?F_@|uTu#{EfojgifqY4=@O%|lZ2tFuIc z?q}YTbA>(j_Y8w*FaK%W3x(d`=Y=uY7Tak%|FAM6to>M*0`FCldh0&HX%KQ`HT{{? zPQk_ynE=OeWVQNCif1XSJ2P)ITmLQyog8#~r7zgJ7$8#(qG3+#i9`2-?L_jmA`N8m zaLcUJB1Jc;_?FiDEoz9R1(&JK*Os6g$%+ZC?8`Rs>CLTM-HKSbJdF58rK(H0RFOsV zFWh-?1I(3lV(vGifUwlSB-xv-hINBi*A(?GsA8(CXPB7bwG=JW+a*vV=k2-;S8|RS z%!mxy9fsF4>%CKf#5=vN0Pb8R+1;;bG;#;wt{5?s$_#Q-8AwjcmWj26D!zK{8%g1N zC4T&5Bl-aS6h-V!Y0YQ4awn!38vkw9INzNv;bb)&M?;wsqG z2DZXHZS6M6zke!XoCJOu<3KjY9QiQ&?gg1`ze3S_FE^)~(b}-Z4mvFs=_ujkWDqZg zI(~VH*G&vZ?suJFV_mk-hPjKp(zdhyI@Y07`4S(jBxkf|4`^XAcu8bA&ee<|%LP!4 z7P@j6P5H-QSvigc-K+o7?ioSy2ZEeTzxV+P=5t$$|aTiVIG}$*KQS#gJEW<(H%JN`DBRAA6_7D&gl#m2VGZT{=yfGp)v- zKVPbP`v93yU-7?sV0Zfv^B-@IhqNHat!Ai&*JTpvwywfuDY6*8w_YokyLZ_9o}~1^ zd~cwnrSxZhkFDkw!}r$E%);-f@KgA`FO~etjzj$*Icy{Q_i|(1IulY@IFT9!^@7#2OpKeg&MtXW4CLFHPTS}= z#3fV@uPrF5S&TKydNk?194VFC&`B~q)MMc>D zIUW6qn88eJ_DiHi8A{wtu@M|)rGHmddKBK8cthSklYBO=i#Q85Z?Ed&P@2{wYQtK@ zxU>pIYUd*CezSo0GT>j38Y>Bz<1+ImIg&TAErW77WOSmQa#?J`7m&*GYE}rnh|6Ak zjaq!-lvm>KG=j!-fQh~cO4$2fzExIBTa|R$*UNlBy0Gz9B0+)B<00Mkd=?k!#-PNz95W3-VvzOTzy;U zt#cBm2^qL-cb#NI3;lIl#p^urp=@K}6(wf{#M2XXYwCY8zp=?7=F^FC1_u<*CS;UUu2q?rLxpiR&GAv=nudcw315 zLk#ONyc9~}xaqB{xKlejb?_CRkRVq@O|g=G|4}WJ)Co-DR>`3(uFQ4GhZp5XShm`{ z)s+>aJ1y^(pDUPn&=ZmZB(g89UJ}$M@GXISiUup;FK4(6zf*4`bsWN`)T+^4q(jusssW zm>7oM7dDl?=*#>T&Vu+YIOiQb_mpjcbQ@t1RrP?BjoMip0wG|Qc zvaw`VK0p~p?&*3cKnJsc_Zshl42MDPFivTvEs3G3`VlCD9LF%u-q)wGOsGg8M-jWF z-;t4h2r0QD34NJBTsrDxOpH$A99h7YJ;$Yq0DrQN8p7es$Vj#WofXiN46EF9Eil`>N(7Z>nS7?a!EX~{qsw7 zMnBbzMgX?~QU3p2;URJF*6<)~=>*B7%#PNg0Zt`)5>~F6RL-K-_u;dV<7nj0_q$UTFgr1@ znj@)ts#dED5)F#ZDSw6h^kf{UBMMDDYTdpS`LZniOEt){Zqc)BTXm2*xkz7hiIW3| z#{X&ZnPW3dm00gA$%Du!yQF2-jv+jT=lFB7y26gB$!=U6uaRN$<~ zo?l#oK&mP6_9uVTFSU-0K_bV9jZWoTW8KgCEgQ2hW465ZmldNztfq6a_BE_A5_2}E zf8IK#%;u_XtGnNJQnXY|;HI%3;bHBid)pn)MqRBtu9rj|lpU-rw^31jnGGsPpr*Zr z=`N)?)B|(bO^N@WIN|klXH#V1 zOLczvW_(RTSP|rU(Y+7OMQSz}+KM=_kKOk&!cD?@$t24Xmx7Iy^2!`E=%R#`@Uji4 zW3O60>LqI`*y?DlvP?oK8_!6)d znub59qOZxK$KZvpR}D?SO&mT#oOG5=3iB|LAJyAZqLPTCC&lTjY6JDzx^Ff~%;axq zKh-8gJba_o<3zT?lxK?9)mcqKAiH2IOEPVIzqUOH`Phh5Qljf+J;{c6KrK5l;fGYG zNWlqSPqpK%nOtg1i6LfnnyN^b@` zGx6{6wnfL68*;+^^%V*v5exYF`VT7;UU0__x-toHWJ-Nr9c)bs*i6y0i@RoW3LsMw zn{e?5`s)G^!!2sAoM*K=4<~mH_a9!Rvtz)@qrg#5!!0YCTnZeydVvzotxTLg^Gt4` zrCkpvj~w&dB(cfLBY-<|MZ~l*nK*ssNkeAC&bA=U=`6`h<@g2byC{H6$73gbki&8m zS(KlLQ)ML!o3_R_M?U8f^OFBE3(a}-`mbx-5dWdPRMB6BIrzokdk#pVI+!`}3tW&$ zApaGI28^ahLzA3VZ`qL2T-UO2`NEaylvhU=&SKBLFVMtvLQ! z#OcdUcefzBu2P5ihoqJVkIz)H`>ML-6$w8hQso`z#jDfR`rstwF!iuyk9_S)-##`C z=FY-Z`@t6?ZZ=JZDSEe-uKYA;oO@o4cH$+ zW_jnqFFs1(c@*?XfvB(d*xEGR+j?X!c#Sux$+UdXu+pS$F%S|Gi=C0pTS=V3L|&2* z9`&*{S0ZT0N0T9MB7mJ^@h;ad@%dQ#S65i_AT~-_TmtioDoA49#F9lZTH~sAybrek zzR?hmWb%-BWe!&EDv5QE8n7Q-FUvZE;ugx#g)`>pA3VAhwx9Yxchx>tVC=kip1_7J z6t+eqJ;!%rbgjQAwUOOV2|R14E^_4<<%$Damgo1|SQRII4r;q|338RY zF~~f}UDHCESm%Mm&sVQTyuZxI&+j+NBNqiimmP^~8u$2MG{i#8Cbp7fnna?UBqAyj zDduxsl9VZ%b&0cvC&yfv8s<#H+IY6=fv}YW5@CtTV+MIGzzzc#(!?vE;mIuo7G@lk zM3w&Uc48Q&FL>1~o8CqayJUyNrP@94$OH?WFN&~v;djCg5+=VsqgdA@CeCMMm*Wtr zT07hhm}GKtQ{3xtY>BM4S{UD-$qVcljUetS_sCU5)W2)m$Szk{$EdwxzBHecrnKky z3Y(Iw35cM<=Vl1kwsX;wB~s$AS0w-^Jz0vHau>%OGVZ3`IEbae`@qO90dbM|_5~zJ zD5Zt$a*ef$#gphX@GGd)UL^~qz)zimo*DN@RUbAM#-pE^Ywt`wGvc0}OKxMd5zKz} zzBUUn#xuw&H^i)9&&I*V3TDQR#D|joeuIzIy;Mh&Flo9}$9};289=@Y7=drTtvkiJC#+0IDr9P^nv|0q}IO_{fM zAYz0eGb^f74q?pIQ?9gUB)2El976d>on+-C9rY=4Ii}d|X40U~n}kW!seT@$4QYwh z=p&Ofm1~1c5@$@JT2i$<$8_UL5(e@l2jW^nN5|73E*@wN0!XEr7eeJYnwiN}yxjuh z>|_ZXiqN)KXbzZ8NgzcXNg{o3KZjQ4`OuxogV;4Q4>PR<#Q11xV>xhJRY)Yc+ymiq zeH>UKJF*Lj&!IITrODN_ChfsSOu0dQ*n{apH~x}%I5)gxp*@Ot(nbJxltHAsGtW&M*hyXuozNUQ@07dc zRN76y)Z$6M#H7)smgnu^n0yYUz})n`YJmu~_^2SHQq5-lA6Vn&N}xr$atU&kqoC}s zBUd?V&lD%OAKT~yn@9~>6OO_Y+3mr8v@f2Ra?$y*w|l$+Ks_+qy~Tn|kj9kyh)_A| zXG`3NU3(Ks@xe|=YY%$1!Cz00r95{5qNn*XJ&wox@A>-3{hn{V+eu2DoE+4dXE5b< zEh9ab+Q{RYDx=YKHy>s6duRo|1qW6rHm0pACiT zGWUXW4|yW*&$%Y0+TK;1MNGMlZC@pjDA$F0%2pNx@a=75ToeJ_XtJS#QqyFi;;pFl?)p8!*6plPkQLPIm_WeFOkQ_Dx! zDp}??UCa>x6KmZjCnBU;pV=K4(V?;KpZhOO|IF+c?+~_JK_%tTH_f>LIXy$HM=T?vn z4Y{1bD9}NL=w2wsLMe-wa*gS#LaB)iJHdfKUEGeFe5HqSu3StuQ&Xw&(cZ@RhFs}6 z0h{ZIyk8%4)n?|%LfloZQ+tMbjVWa)4714gI==$~>93E4ZZ;;K-mELM0{1k5%gtVz zbv7{Us;cx*MYFf$O72Z(9-@$`q&=o1Tw#vB44G>x#+yidj%nm07Z90kYmSco7!*NH zr+TC3eoU4J@cx*GC}S$=$AUr`#L_o?Y2+AY*2@IaJ*GyA1@kpsqvwh2uF#-YxaMIa z^+Gf9oQW{SmKb>=pw}_)1v4V)Mw*3RA-f#(4W{!p#};qK?gcojENGT3=9 zh&#*W(2jZE=>4U(jwC`#e$W$&2j0SI8);;2y^n!LI*0Z$%9ch-hY8W?KA{QZeMC{3 zu0@_Rx2#(4n9et|t+!H6lR59NeDuzV^F2zTusO=iPUADgpfM7opm1*hD zQ@GkyNj0B{i*$3u&2;ze7(jys^kYcSA=s^dBIO=ZZ~1Dg_j5=iT-}92Vb5491C2sG z^3*-=kZkveHiF08J82E-BCVuNiB4LCjm-2xrA`Wjs{{~JC)5SiOzH!XGSDDYGo?GR zB6X|7J1G$AaiR*gRqCBI2Gx9zC-Qz`u9M2(tY`td7&Hb)m(oG4j^)48j*8SPN54h| zLFS{Kag8dMyT2Dg#cr(6^?Z$L1G^Y>2cYZfQW5ItZ0)2tIKLMZ2X)QXnPzgST}CIJ zLAA40pslIzq#yVNunRSAS`_x39!aPo`kjAo;huib6;!hqc6w)_%D#tWMU|d2cg%m$ zllQs6Q5$cFs2!StYBxj!v8s0hM2Z`5XQ7TJcfEs1p&IK>8UgJRbOCj1tUD}la$PrM zeEreP_wf7~p$w=-Ni!&HTQx`3AQ5&w4zEGt|LTrhwXK@476Tmb(0}(CwAhEyQ#Rr8Qup7=q%Dv$Y zQUzSOKqR5BW(`GN5%b*EpC*p{*ap*oVNC_|@Vumti{3yo+AEW}fX8h* z?)Jqk>mX0&LiMGG6@b)EDgrC8BGT;^08g-G1>{K;aB>s)={XY7vJE0(-!TmUWsa3@ z>_)hC1Jd>{bW+w9(BKA+R-qdx2iddGPOeKpCgF;`Qz^FYT>wC=CvcX6W}vLP(NEYA zm37Ud zz8Y<93%Vx))C5=W8q;#^ZNZb8;4u*l*o45n9&_XM0eZha=Np@H%|bVYp)|O9H_BrS zP#QeQv_YY8ASFSuE8Ie>Xdu-=G0QoSeNizpH<0GwoVkMSi5f^#@BuhWL3?0lZXhG0 z;|m8;9z6O9{lS$lGGR?ep+2}fN|@^Y3FueP88}NpRZzAa6Od>(mPnbBT@zZe@Z?!$ zhk?wEijheJ8Z>2%m^x52#5-SRA}%WlKsi5Kg&Lu3fi^mvyZMe>ay$nLodE>}Bc&1m zo`$O01(IpD8qv6dMo%09DGh!JnW9i7>=w|~n)vm;E5j$+mv7p!JwYPq_XFAIx^XgA<&sYpr&TX&@FyM02M z-FCDfA3Hi62M38@&txhZVmlxz8uBw=&Bp4Vp=Kwo7Hv9du}@OInC#YhL8fTTb}Ob1 z$9jDwI0W0ZsYQqV>Xa|VbHV^h&FlzLG?iyQCg+|*kyH?mRJ!>Up_0H`I)ma+M|2oZkX=ke6KeG z?cz#v&|DiI5*M_JCQ?ykJtSs-6InQAv)3f@g2~4|rr6rH5~(SkfICY;b#c}mn2ORq zAx#Hky179b4*D76Ih+p=6@{we&R5SS0QGp&RlqY}O8KVihD=c?EKa&6rlJ`;tVnOV zGG@q_iDWl$(G@C;v+m3UTRTD`4aTFJP-7fBLL%EIJ2?U6$9zqs&A9XRV}BuNv?pDm z-8ef}nTBgiOQhSli39D%#?aZyBs9|p`i;jhH@Lo9EBe*enjz@!D^wlF8cbvbmDdd- zsSx5pAp^F;{q2ir5EpULi;i5hF~wQ<#QDatwE%+R(M)gVUPYfEpsKY=M+9hR&3jsKk+Wobb=lBO;Zn@ig|jg=`J%`O z>ru=Gkx6e-MC01f*P6C?t5J?@WMEB7DaP7jAj4=bHsa25tWYtPHxjT(^8~Ou<>({p zRCFZhWa~zaL1XKO@<|G^I>oSRnJlO3`C)q@aqu|-Sn*<*rcCxzTZ~K4@K*6IMOojX zH(u)RV9_K?a=B!^>?MGa0fO2n0yr$GW`)qY941)`wA1zktVp~YrVsa_su5!IyxuQR62NExX=?8{x#%4{X7jP9Dhtc#zQaG&ffkZZ* zG$H^2t*D?#h>Kr9w&<|V3+QTQ^INql1CpLYWP6>p1`3&0_5HPgz>4(x?#17^3ek#X z?u{k%mp2J8_RCPaSs+ZmEvzVTrq1J(