diff --git a/Images_doku/AirTempSample.png b/Images_doku/AirTempSample.png new file mode 100644 index 0000000..01135de Binary files /dev/null and b/Images_doku/AirTempSample.png differ diff --git a/notebooks/Measurement_Analysis.ipynb b/notebooks/Measurement_Analysis.ipynb index db0e4db..c686bab 100644 --- a/notebooks/Measurement_Analysis.ipynb +++ b/notebooks/Measurement_Analysis.ipynb @@ -3,18 +3,17 @@ { "cell_type": "code", "id": "ca3c9c7af43b4e58", - "metadata": { - "ExecuteTime": { - "end_time": "2025-09-04T12:55:44.669890Z", - "start_time": "2025-09-04T12:55:44.665980Z" - } - }, + "metadata": {}, "source": [ "import sys\n", "from pathlib import Path\n", "import numpy as np\n", "from IPython.display import clear_output\n", - "\n", + "import os\n", + "import ipywidgets as widgets\n", + "from IPython.display import display\n", + "import matplotlib.pyplot as plt\n", + "import pandas as pd\n", "\n", "\n", "def check_path(path_str):\n", @@ -48,17 +47,8 @@ "from matplotlib.widgets import Cursor\n", "import ad" ], - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Path exists: C:\\Users\\berti_r\\Python_Projects\\StagePerformaceDocu\\Scripts\n", - "Path exists: C:\\Users\\berti_r\\Python_Projects\\StagePerformaceDocu\\Config\\config.json\n" - ] - } - ], - "execution_count": 4 + "outputs": [], + "execution_count": null }, { "cell_type": "markdown", @@ -75,18 +65,10 @@ "cell_type": "code", "id": "3e70c2ebec687fe0", "metadata": { - "scrolled": true, - "ExecuteTime": { - "end_time": "2025-09-04T12:55:46.043996Z", - "start_time": "2025-09-04T12:55:45.995872Z" - } + "scrolled": true }, "source": [ - "import os\n", - "import ipywidgets as widgets\n", - "from IPython.display import display\n", - "import matplotlib.pyplot as plt\n", - "import pandas as pd\n", + "\n", "from mpl_toolkits.axes_grid1 import make_axes_locatable\n", "\n", "plt.style.use('_mpl-gallery')\n", @@ -537,301 +519,190 @@ "tempCorrectionBtn.observe(set_temp_correction, names='value')\n", "display(tempCorrectionBtn, output5)\n" ], - "outputs": [ - { - "data": { - "text/plain": [ - "Dropdown(description='Folder:', index=19, layout=Layout(width='50%'), options=('20250715_alignment_tests', 'Cu…" - ], - "application/vnd.jupyter.widget-view+json": { - "version_major": 2, - "version_minor": 0, - "model_id": "1064d2770a8e4994b9778fbb32d32730" - } - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": [ - "Dropdown(description='Subfolder:', index=18, layout=Layout(width='50%'), options=('20250829_123734_static_0', …" - ], - "application/vnd.jupyter.widget-view+json": { - "version_major": 2, - "version_minor": 0, - "model_id": "335b6f15c719469c9caf619b9dcb7adf" - } - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": [ - "Button(description='Display Scatterplot', layout=Layout(width='50%'), style=ButtonStyle())" - ], - "application/vnd.jupyter.widget-view+json": { - "version_major": 2, - "version_minor": 0, - "model_id": "6d4b870e854746d59d4d43d244c4fdc6" - } - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": [ - "Output()" - ], - "application/vnd.jupyter.widget-view+json": { - "version_major": 2, - "version_minor": 0, - "model_id": "5e75eac791fc48949c5c7abe930a0b54" - } - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": [ - "Button(description='Display PFT', layout=Layout(width='50%'), style=ButtonStyle())" - ], - "application/vnd.jupyter.widget-view+json": { - "version_major": 2, - "version_minor": 0, - "model_id": "5599a12d14044dc2b2f61a323bcc699a" - } - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": [ - "Output()" - ], - "application/vnd.jupyter.widget-view+json": { - "version_major": 2, - "version_minor": 0, - "model_id": "3239a4f89be34d14a693ddebab709b56" - } - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": [ - "Button(description='Display RAW', layout=Layout(width='50%'), style=ButtonStyle())" - ], - "application/vnd.jupyter.widget-view+json": { - "version_major": 2, - "version_minor": 0, - "model_id": "f1cdb54e85994cb4bca18cc685247e2c" - } - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": [ - "Output()" - ], - "application/vnd.jupyter.widget-view+json": { - "version_major": 2, - "version_minor": 0, - "model_id": "a8efe2506b2840fb82d1bb8a4a6e83ea" - } - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": [ - "Button(description='Rolling Statistics', layout=Layout(width='50%'), style=ButtonStyle())" - ], - "application/vnd.jupyter.widget-view+json": { - "version_major": 2, - "version_minor": 0, - "model_id": "a706c5c09f544bc38aa5aa1e6364fae6" - } - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": [ - "Output()" - ], - "application/vnd.jupyter.widget-view+json": { - "version_major": 2, - "version_minor": 0, - "model_id": "2c2cc60adc134febbd6735ca9c2f3650" - } - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": [ - "ToggleButton(value=True, description='TempCorrection', tooltip='Toggle processing on/off')" - ], - "application/vnd.jupyter.widget-view+json": { - "version_major": 2, - "version_minor": 0, - "model_id": "156637e0c1934177a3d5df8499fd5886" - } - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": [ - "Output()" - ], - "application/vnd.jupyter.widget-view+json": { - "version_major": 2, - "version_minor": 0, - "model_id": "d8602eff8a1747dab2cb8afd41a2f895" - } - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "execution_count": 5 + "outputs": [], + "execution_count": null }, { - "metadata": {}, "cell_type": "markdown", + "id": "ca5359d36ec7f8ff", + "metadata": {}, "source": [ "## Temperature time plot analysis\n", "\n", "The two CrNi temperature probes show a peridical temperature fluctuation of 1${\\textdegree}$C which is unlikely to be true.\n", "Reason, only the CrNi probes have this fluctuation and the P304 at the same place dont show that fluctuation.\n", "For future data analysis i recomand to pass them throug a BP or LP filter since it looks like the avg is still usable.\n" - ], - "id": "ca5359d36ec7f8ff" + ] }, { + "cell_type": "code", + "id": "fec81d07edf0c8b2", "metadata": { "ExecuteTime": { - "end_time": "2025-09-04T13:04:34.562560Z", - "start_time": "2025-09-04T13:04:34.395226Z" + "end_time": "2025-09-05T08:55:14.557511Z", + "start_time": "2025-09-05T08:55:14.541374Z" } }, - "cell_type": "code", "source": [ - "data_folder = r'C:\\Users\\berti_r\\Python_Projects\\StagePerformaceDocu\\data\\Temp'\n", - "%matplotlib widget\n", + "import os\n", + "import ipywidgets as widgets\n", + "from IPython.display import display, clear_output\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", "\n", - "\n", - "# Load the newest file\n", - "\n", - "# Load file\n", - "file_path = myu.find_newest_dat_file(data_folder)\n", - "times, temps = myu.load_temp_data(r\"C:\\Users\\berti_r\\Python_Projects\\StagePerformaceDocu\\data\\Temp\\20250723_131041.dat\")\n", - "\n", - "# Initial plot range setup\n", - "initial_xlim = (mdates.date2num(times[0]), mdates.date2num(times[-1]))\n", + "# ========== Config ==========\n", + "ROOT_DIR = r\"C:\\Users\\berti_r\\Python_Projects\\StagePerformaceDocu\\data\\Temp\" # Replace with your folder path\n", "colors = ['red', 'green', 'blue', 'orange', 'purple']\n", - "labels = [f\"Chanel {i + 1}\" for i in range(5)]\n", + "labels = [\"CrNi poor quality\",\"CrNi poor quality\",\"Air\", \"X-Axis motor\",\"Back of stage\"]\n", + "# ========== Output widgets ==========\n", + "output_file = widgets.Output()\n", + "output_plot = widgets.Output()\n", "\n", - "# Setup plot\n", - "fig_temp, ax = plt.subplots(figsize=(10, 5))\n", - "lines = []\n", + "# ========== Helper functions ==========\n", + "def list_dat_files(path):\n", + " \"\"\"Return sorted list of .dat files in path\"\"\"\n", + " if os.path.isdir(path):\n", + " return sorted([f for f in os.listdir(path) if f.endswith('.dat')])\n", + " return []\n", "\n", + "def load_dat_file(filepath):\n", + " \"\"\"Dummy function to load .dat file\"\"\"\n", + " # Replace this with your actual .dat file reading code\n", + " data = np.loadtxt(filepath)\n", + " return data\n", "\n", - "# Plot initial downsampled data\n", - "def plot_initial():\n", - " ind_min, ind_max = 0, len(times)\n", - " step = max((ind_max - ind_min) // 1000, 1)\n", + "# ========== Widgets ==========\n", + "# 1. File selector\n", + "file_dropdown = widgets.Dropdown(\n", + " options=list_dat_files(ROOT_DIR),\n", + " description='Select File:',\n", + " layout=widgets.Layout(width='50%')\n", + ")\n", "\n", - " for i in range(5):\n", - " if (i == 2): # 2 ist raum\n", - " line, = ax.plot(times[ind_min:ind_max:step],\n", - " temps[i][ind_min:ind_max:step],\n", + "# 2. Set selector\n", + "set_selector = widgets.SelectMultiple(\n", + " options=[2, 3, 4],\n", + " value=[2],\n", + " description='Sets:',\n", + " layout=widgets.Layout(width='30%', height='100px')\n", + ")\n", + "\n", + "# 3. Plot button\n", + "plot_button = widgets.Button(\n", + " description='Plot Data',\n", + " button_style='success',\n", + " layout=widgets.Layout(width='30%')\n", + ")\n", + "\n", + "# ========== Callback functions ==========\n", + "def on_plot_clicked(b):\n", + " with output_plot:\n", + " clear_output()\n", + " if not file_dropdown.value:\n", + " print(\"No file selected!\")\n", + " return\n", + "\n", + " # Load data\n", + " filepath = os.path.join(ROOT_DIR, file_dropdown.value)\n", + " data = load_dat_file(filepath)\n", + " times, temps = myu.load_temp_data(filepath)\n", + "\n", + " # Setup plot\n", + " fig_temp_2, ax_8 = plt.subplots(figsize=(10, 5))\n", + " lines = []\n", + " selected_sets = set_selector.value\n", + "\n", + " \"\"\"for s in selected_sets:\n", + " if s <= data.shape[1]: # check column exists\n", + " plt.plot(data[:, s-1], label=f'Set {s}')\n", + "\n", + " plt.title(file_dropdown.value)\n", + " plt.xlabel('Index')\n", + " plt.ylabel('Value')\n", + " plt.legend()\n", + " plt.show()\n", + " \"\"\"\n", + "\n", + " for i in selected_sets:\n", + "\n", + " line, = ax_8.plot(times,\n", + " temps[i],\n", " label=labels[i], color=colors[i])\n", " lines.append(line)\n", "\n", - " ax.set_title(\"Temperature over time\")\n", - " ax.set_xlabel(\"Time\")\n", - " ax.set_ylabel(\"Temperature (°C)\")\n", - " ax.legend()\n", - " ax.xaxis.set_major_formatter(mdates.DateFormatter('%H:%M:%S'))\n", - " ax.set_xlim(initial_xlim)\n", - " ax.relim()\n", + " ax_8.set_title(\"Temperature over time\")\n", + " ax_8.set_xlabel(\"Time\")\n", + " ax_8.set_ylabel(\"Temperature (°C)\")\n", + " ax_8.legend()\n", + " ax_8.xaxis.set_major_formatter(mdates.DateFormatter('%H:%M:%S'))\n", "\n", + " plt.show()\n", "\n", + "# ========== Bind events ==========\n", + "plot_button.on_click(on_plot_clicked)\n", "\n", - "# Update on zoom/pan\n", - "def update_plot(event=None):\n", - " xlim = ax.get_xlim()\n", - " t_nums = mdates.date2num(times)\n", - " ind_min, ind_max = np.searchsorted(t_nums, xlim)\n", - " ind_max = min(len(times), ind_max)\n", - " step = max((ind_max - ind_min) // 1000, 1)\n", - "\n", - " for i in range(5):\n", - " if (i == 2): # 2 ist raum\n", - " line, = ax.plot(times[ind_min:ind_max:step],\n", - " temps[i][ind_min:ind_max:step],\n", - " label=labels[i], color=colors[i])\n", - " lines.append(line)\n", - "\n", - " ax.relim()\n", - " ax.autoscale_view()\n", - " fig_temp.canvas.draw_idle()\n", - "\n", - "\n", - "# Hook zoom & pan events\n", - "#fig_temp.canvas.mpl_connect('button_release_event', update_plot)\n", - "#fig_temp.canvas.mpl_connect('scroll_event', update_plot)\n", - "fig_temp.canvas.mpl_connect('motion_notify_event', update_plot)\n", - "\n", - "# Run\n", - "plot_initial()\n", - "update_plot()\n", - "plt.tight_layout()\n", - "#fig_temp.canvas.draw_idle()" + "# ========== Display widgets ==========\n", + "display(file_dropdown, set_selector, plot_button, output_plot)\n" ], - "id": "52db5e2c12fea30c", "outputs": [ { "data": { "text/plain": [ - "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" - ], - "image/png": "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", - "text/html": [ - "\n", - "
\n", - "
\n", - " Figure\n", - "
\n", - " \n", - "
\n", - " " + "Dropdown(description='Select File:', layout=Layout(width='50%'), options=('20250715_154024.dat', '20250715_174…" ], "application/vnd.jupyter.widget-view+json": { "version_major": 2, "version_minor": 0, - "model_id": "36e7aa13c54e48f78d09e29347071b6e" + "model_id": "abff8ffc21174afeaf93e29728e8e4f2" + } + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "SelectMultiple(description='Sets:', index=(0,), layout=Layout(height='100px', width='30%'), options=(2, 3, 4),…" + ], + "application/vnd.jupyter.widget-view+json": { + "version_major": 2, + "version_minor": 0, + "model_id": "4fd2eda176d44ec2b95916a7aa4ca30d" + } + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "Button(button_style='success', description='Plot Data', layout=Layout(width='30%'), style=ButtonStyle())" + ], + "application/vnd.jupyter.widget-view+json": { + "version_major": 2, + "version_minor": 0, + "model_id": "e4e6376a12964824891db07f8b9559e2" + } + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "Output()" + ], + "application/vnd.jupyter.widget-view+json": { + "version_major": 2, + "version_minor": 0, + "model_id": "d28bca96aa0d4206a4d0701b8982ddac" } }, "metadata": {}, "output_type": "display_data" } ], - "execution_count": 10 + "execution_count": 18 }, { "metadata": {}, @@ -847,6 +718,8 @@ { "metadata": {}, "cell_type": "code", + "outputs": [], + "execution_count": null, "source": [ "pooling = 0\n", "STATIC_LOG_FILE = \"CSV_logs/static_tests_log.csv\"\n", @@ -1028,7 +901,13 @@ "\n", "pd.read_csv(STATIC_LOG_FILE)\n" ], - "id": "39fcd9032d757549", + "id": "39fcd9032d757549" + }, + { + "cell_type": "code", + "id": "c508fa81b2ba05a1", + "metadata": {}, + "source": [], "outputs": [], "execution_count": null } diff --git a/notebooks/Results.ipynb b/notebooks/Results.ipynb index f0fdf3f..6b62d09 100644 --- a/notebooks/Results.ipynb +++ b/notebooks/Results.ipynb @@ -17,15 +17,14 @@ "| 4 | X-Axis Motor | P304 |\n", "| 5 | Base | P304 |\n", "\n", - "Currently the temperature is logged on a privat computer since the PSI doesent allow to select drivers for unkown devices. This would be necesary since the measuring device only has an rs232 connection.\n", - "A .dat file is safed on the laptop with the following format:\n", + "Currently, the temperature is logged on a private computer, since the PSI does not allow selecting drivers for unknown devices. This step is necessary because the measuring device only has an RS232 connection. A .dat file is saved on the laptop in the following format:\n", "\n", "| Temp1 |Temp2 | Temp3 |Temp4 |Temp5 |Unix Time |\n", "|-------|------|-------|------|------|----------|\n", "| float |float | float |float |float |float |\n", "\n", "### Microscope\n", - "The position was always measured relative to the Microscope. On which a region of intreset was selected. The top left corner of the image were the origin (X=0,Y=0)" + "The position was always measured relative to the microscope, on which a region of interest was selected. The top-left corner of the image served as the origin (X=0,Y=0)" ], "id": "a44247e84c3cfd1e" }, @@ -97,42 +96,41 @@ "source": [ "\n", "\n", - "## Desisions\n", + "## Decisions\n", + "\n", + "| What | Why | Contact |\n", + "| ------------------------------------------ | ---------------------------------------------------------------------------------------------------------- | ------- |\n", + "| Implementation of image processing | The original setup was sensitive to lens flares | Roman |\n", + "| Static testing for establishing a baseline | A preliminary measurement showed poor results | Roman |\n", + "| Static long-term testing | To assess the impact of air temperature | Roman |\n", + "| Windowing for Y-axis | A long timespan is not applicable to real-world conditions; the camera was mounted on a long aluminum pole | Roman |\n", "\n", - "| What | Why | Contact |\n", - "|--------------------------------------------|--------------------------------------------------------------------------------------|---------|\n", - "| Implementation of image processing | Original setup was sensible to lens flares | Roman |\n", - "| Static testing for establishing a baseline | a peliminary measurement showed bad results | Roman |\n", - "| Static long term testing | To get a feeling of th impact of air temp | Roman |\n", - "| Windowing for Y axis | Long timespan not applicable to real world, cammera mounted on a long aluminium pole | |\n", - "| | | |\n", "\n", "#### Image Processing\n", - "Originaly the position of the pinhole was determined by calculating the center of mass of the image. This led to errors caoused by a lens flare. The best performing algorythm was upscaling and a fitting two gausian curves. Other tested aproaches were gradient optimizer, threshholding.\n", + "Originally, the position of the pinhole was determined by calculating the center of mass of the image. However, this approach led to errors caused by lens flare. The best-performing algorithm involved upscaling the image and fitting two Gaussian curves. Other approaches that were tested included a gradient optimizer and thresholding.\n", "\n", "| Befor | After |\n", "|:----------------------------------------:|:----------------------------------------:|\n", "| ![](../Images_doku/pointofmassbefor.png) | ![](../Images_doku/pointofmassafter.png) |\n", "## Measurements\n", - "Initialy a set of two measurements was planed. A repeatability test where a measuring cycle was replicated as acuaratly as possible, and an absolut acuarcy test.\n", - "The repeabilty test was conducted as planed. The absolut acuary measurement was canceled due to timeconstraints.\n", + "Initially, a set of two measurements was planned: a repeatability test, where a measuring cycle was replicated as accurately as possible, and an absolute accuracy test. The repeatability test was conducted as planned, but **the absolute accuracy measurement was canceled due to time constraints**.\n", "### Static measurement\n", - "No motors were enabled, all breaks were \"pulled\". Images were taken as fast as the cammera/scripts allowed.\n", - "This measurement was used to get a feeling for the measuring accuarcy of the cammera with as little outside influence as possible.\n", - "Below is a the baseline visualized. The measurement was taken on the 18.07.25 with image processing enabled. Each bin is 0.02 $\\mu m$ and the duration was about 2 minuts in which the temperature rose slightly which led to a larger spread on the y axis.\n", + "No motors were enabled, and all brakes were engaged. Images were taken as quickly as the camera and scripts allowed. This measurement was used to assess the measurement accuracy of the camera with as little outside influence as possible.\n", + "\n", + "The baseline is visualized below. The measurement was taken on 18.07.25 with image processing enabled. Each bin corresponds to $0.02 \\mu m$. The total duration was about 2 minutes, during which the temperature rose slightly, leading to a larger spread along the Y-axis.\n", "\n", "\n", - "| standard deviation x | standard deviation y |\n", + "| Standard deviation X | Standard deviation Y |\n", "|:--------------------:|:--------------------:|\n", - "| $0.04 \\mu m$ | $0.06\\mu m$ |" + "| $0.04\\,\\mu m$ | $0.06\\,\\mu m$ |\n" ], "id": "5c9ee8eb009afe77" }, { "metadata": { "ExecuteTime": { - "end_time": "2025-09-04T12:05:08.480575Z", - "start_time": "2025-09-04T12:05:08.322812Z" + "end_time": "2025-09-05T07:04:03.333810Z", + "start_time": "2025-09-05T07:04:03.197804Z" } }, "cell_type": "code", @@ -141,6 +139,7 @@ "sys.path.append(rf\"..\\Scripts\")\n", "import numpy as np\n", "import myutility as myu\n", + "import matplotlib.pyplot as plt\n", "import pathlib as path\n", "from mpl_toolkits.axes_grid1 import make_axes_locatable\n", "axis_data_file_path_1 =rf\"..\\data\\data20250718_alignment_tests\\20250718_113013_static_0\\static_0.dat\"\n", @@ -158,6 +157,7 @@ "\n", " # the scatter plot:\n", "ax.scatter(x, y)\n", + "ax.set_xlabel(rf\"$\\mu m$\")\n", "\n", " # Set aspect of the main Axes.\n", "ax.set_aspect(1.)\n", @@ -204,12 +204,12 @@ { "data": { "text/plain": [ - "[,\n", - " ,\n", - " ]" + "[,\n", + " ,\n", + " ]" ] }, - "execution_count": 13, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" }, @@ -218,43 +218,48 @@ "text/plain": [ "
" ], - "image/png": "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" + "image/png": "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" }, "metadata": {}, "output_type": "display_data" } ], - "execution_count": 13 + "execution_count": 4 }, { "metadata": {}, "cell_type": "markdown", "source": [ - "#### Static long turn\n", - "After initial testing it was obvous that the setup was subsebtibal to outside influences. To analyze the behavior of the setup without any movement over a longer timespan it was decided to setup a measurement...\n", - "The result shows that the measurment moves a lot over time. Also that the Y axis moves more than the X axis.\n", + "#### Static Long-Term\n", + "After initial testing, it was obvious that the setup was susceptible to outside influences. To analyze the behavior of the setup without any movement over a longer timespan, a measurement was performed.\n", + "\n", + "The results show that the measurement drifts significantly over time, with the Y-axis exhibiting more movement than the X-axis.\n", "![longterm static](../Images_doku/longstatic.png)\n", "\n", - "### X axis\n", - "The X axis has a std of $0.19 \\mu m$ given all temperatures are stable within 0.15deg.\n", + "### X-Axis\n", + "The X-axis has a standard deviation of $0.19\\mu\\text{m}$, assuming all temperatures are stable within 0.15°C.\n", + "\n", "![](../Images_doku/stable_x.png)\n", - "### Y axis\n", - "The accuarcy over multiple hours and and temperature fluctuations is bad. Thus a window of 15 minutes was used. Focusing more on short term repabiltiy the accuarcy was enough with $0.2 \\mu m$\n", - "![](../Images_doku/Y_axis/Y_Axis_correction.png)\n" + "### Y-Axis\n", + "For the Y-axis measurement, some interfacing with the PLC was required. The solution is available on my Git repository; axes 1 and 4 correspond to the Y-axis.\n", + "\n", + "The accuracy over multiple hours and under temperature fluctuations is poor. Therefore, a 15-minute window was used. Focusing on short-term repeatability, the accuracy was sufficient, with a standard deviation of $0.2\\mu\\text{m}$.\n", + "![](../Images_doku/Y_axis/Y_Axis_correction.png)\n", + "\n", + "### Temperature\n", + "The temperature was measured using three PT100 sensors. Channel 0 was placed directly on the X-axis motor, channel 1 on the opposite side of the motor, and channel 2 in the air, roughly 50 cm above the table.\n", + "\n", + "The temperature drop and rise around 06:00 are caused by fresh air supplied by the ventilation system. Additionally, the AC control behaves differently during the night. This pattern was observed in all measurements except the one on 25.08.25. On that date, the air conditioning settings were changed by the facility management, causing significant disturbances in the measurements.\n", + "This measurement was taken on the 23.07.25\n", + "![](../Images_doku/AirTempSample.png)\n" ], "id": "89be0049e2430e" }, { - "cell_type": "code", - "execution_count": null, - "id": "initial_id", - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [ - "" - ] + "metadata": {}, + "cell_type": "markdown", + "source": "", + "id": "fc8011e123bed730" } ], "metadata": {