clutgen 0.0.1__tar.gz

clutgen-0.0.1/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   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.

clutgen-0.0.1/PKG-INFO

@@ -0,0 +1,70 @@
+Metadata-Version: 2.4
+Name: clutgen
+Version: 0.0.1
+Summary: CLUTGen, an ADC LUT generator for fast aquisition and calibration.
+Author-email: Paulo Santos <pauloxrms@gmail.com>
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://github.com/wkhadgar/clutgen
+Project-URL: Issues, https://github.com/wkhadgar/clutgen/issues
+Keywords: ADC,LUT,Look-up table,generator
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Embedded Systems
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: PyYAML
+Requires-Dist: pandas
+Requires-Dist: numpy
+Requires-Dist: matplotlib
+Dynamic: license-file
+
+---
+# C Lookup Table (LUT) Generator
+
+CLUTGen automates the creation of **Look-Up Tables** for embedded systems, specifically for converting raw ADC (Analog-to-Digital Converter) readings into calibrated physical units (like temperature, pressure, or distance).
+
+### Features
+
+* **Curve Fitting:** Automatically find your fit from many algorithms.
+    * Linear Interpolation
+    * Cubic Splines
+    * Polynomial Interpolation (up to 7th degree)
+    * Piecewise Interpolation
+* **Visual Preview:** Generates plots to compare calibration data against the calculated LUT.
+* **C Code Generation:** Outputs production-ready `.c` and `.h` files with Doxygen-style comments.
+
+### Requirements
+
+* Python 3.10+
+* `numpy`, `pandas`, `matplotlib`, `pyyaml`, `openpyxl` (for Excel support)
+
+### Usage
+
+```bash
+# From the root of the repository
+pip install .
+# Generate LUTs with cubic splines fit for every configuration yaml in the given paths.
+clutgen -s -i ./examples/calibration/*.y*ml ./examples/temperature_copy.yml
+```
+
+### YAML Configuration Template
+
+Create a table mapping your POIs with the given schema, where `raw` is the measured ADC raw value, and `calibration` is the desired output for the LUT at that given `raw` value:
+```csv
+raw,calibration
+```
+
+With your CSV table done (or Excel one), create a configuration YAML:
+
+```yaml
+# temperature.yaml
+
+name: "temp_sensor"                  # Used for variable names (e.g., temp_sensor_lut)
+description: "ambient temperature"   # Used for documentation and plot titles
+table_resolution_bits: 12            # Resolution (e.g., 12 bits = 4096 entries)
+lut_type: "int16_t"                  # C type (int8_t, uint16_t, etc.)
+ 
+generator: "./data/calibration.csv"  # Path to CSV/Excel with 'raw' and 'calibration' columns. Global or relative to this file.
+
+```

clutgen-0.0.1/README.md

@@ -0,0 +1,49 @@
+---
+# C Lookup Table (LUT) Generator
+
+CLUTGen automates the creation of **Look-Up Tables** for embedded systems, specifically for converting raw ADC (Analog-to-Digital Converter) readings into calibrated physical units (like temperature, pressure, or distance).
+
+### Features
+
+* **Curve Fitting:** Automatically find your fit from many algorithms.
+    * Linear Interpolation
+    * Cubic Splines
+    * Polynomial Interpolation (up to 7th degree)
+    * Piecewise Interpolation
+* **Visual Preview:** Generates plots to compare calibration data against the calculated LUT.
+* **C Code Generation:** Outputs production-ready `.c` and `.h` files with Doxygen-style comments.
+
+### Requirements
+
+* Python 3.10+
+* `numpy`, `pandas`, `matplotlib`, `pyyaml`, `openpyxl` (for Excel support)
+
+### Usage
+
+```bash
+# From the root of the repository
+pip install .
+# Generate LUTs with cubic splines fit for every configuration yaml in the given paths.
+clutgen -s -i ./examples/calibration/*.y*ml ./examples/temperature_copy.yml
+```
+
+### YAML Configuration Template
+
+Create a table mapping your POIs with the given schema, where `raw` is the measured ADC raw value, and `calibration` is the desired output for the LUT at that given `raw` value:
+```csv
+raw,calibration
+```
+
+With your CSV table done (or Excel one), create a configuration YAML:
+
+```yaml
+# temperature.yaml
+
+name: "temp_sensor"                  # Used for variable names (e.g., temp_sensor_lut)
+description: "ambient temperature"   # Used for documentation and plot titles
+table_resolution_bits: 12            # Resolution (e.g., 12 bits = 4096 entries)
+lut_type: "int16_t"                  # C type (int8_t, uint16_t, etc.)
+ 
+generator: "./data/calibration.csv"  # Path to CSV/Excel with 'raw' and 'calibration' columns. Global or relative to this file.
+
+```

clutgen-0.0.1/clutgen.egg-info/PKG-INFO

@@ -0,0 +1,70 @@
+Metadata-Version: 2.4
+Name: clutgen
+Version: 0.0.1
+Summary: CLUTGen, an ADC LUT generator for fast aquisition and calibration.
+Author-email: Paulo Santos <pauloxrms@gmail.com>
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://github.com/wkhadgar/clutgen
+Project-URL: Issues, https://github.com/wkhadgar/clutgen/issues
+Keywords: ADC,LUT,Look-up table,generator
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Embedded Systems
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: PyYAML
+Requires-Dist: pandas
+Requires-Dist: numpy
+Requires-Dist: matplotlib
+Dynamic: license-file
+
+---
+# C Lookup Table (LUT) Generator
+
+CLUTGen automates the creation of **Look-Up Tables** for embedded systems, specifically for converting raw ADC (Analog-to-Digital Converter) readings into calibrated physical units (like temperature, pressure, or distance).
+
+### Features
+
+* **Curve Fitting:** Automatically find your fit from many algorithms.
+    * Linear Interpolation
+    * Cubic Splines
+    * Polynomial Interpolation (up to 7th degree)
+    * Piecewise Interpolation
+* **Visual Preview:** Generates plots to compare calibration data against the calculated LUT.
+* **C Code Generation:** Outputs production-ready `.c` and `.h` files with Doxygen-style comments.
+
+### Requirements
+
+* Python 3.10+
+* `numpy`, `pandas`, `matplotlib`, `pyyaml`, `openpyxl` (for Excel support)
+
+### Usage
+
+```bash
+# From the root of the repository
+pip install .
+# Generate LUTs with cubic splines fit for every configuration yaml in the given paths.
+clutgen -s -i ./examples/calibration/*.y*ml ./examples/temperature_copy.yml
+```
+
+### YAML Configuration Template
+
+Create a table mapping your POIs with the given schema, where `raw` is the measured ADC raw value, and `calibration` is the desired output for the LUT at that given `raw` value:
+```csv
+raw,calibration
+```
+
+With your CSV table done (or Excel one), create a configuration YAML:
+
+```yaml
+# temperature.yaml
+
+name: "temp_sensor"                  # Used for variable names (e.g., temp_sensor_lut)
+description: "ambient temperature"   # Used for documentation and plot titles
+table_resolution_bits: 12            # Resolution (e.g., 12 bits = 4096 entries)
+lut_type: "int16_t"                  # C type (int8_t, uint16_t, etc.)
+ 
+generator: "./data/calibration.csv"  # Path to CSV/Excel with 'raw' and 'calibration' columns. Global or relative to this file.
+
+```

clutgen-0.0.1/clutgen.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+LICENSE
+README.md
+pyproject.toml
+clutgen.egg-info/PKG-INFO
+clutgen.egg-info/SOURCES.txt
+clutgen.egg-info/dependency_links.txt
+clutgen.egg-info/entry_points.txt
+clutgen.egg-info/requires.txt
+clutgen.egg-info/top_level.txt
+src/__init__.py
+src/cli.py
+src/generator.py

clutgen-0.0.1/clutgen.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

clutgen-0.0.1/clutgen.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+clutgen = src.cli:main

clutgen-0.0.1/clutgen.egg-info/requires.txt

@@ -0,0 +1,4 @@
+PyYAML
+pandas
+numpy
+matplotlib

clutgen-0.0.1/clutgen.egg-info/top_level.txt

@@ -0,0 +1 @@
+src

clutgen-0.0.1/pyproject.toml

@@ -0,0 +1,54 @@
+[project]
+name = "clutgen"
+version = "0.0.1"
+authors = [{ name = "Paulo Santos", email = "pauloxrms@gmail.com" }]
+description = "CLUTGen, an ADC LUT generator for fast aquisition and calibration."
+dependencies = ["PyYAML", "pandas", "numpy", "matplotlib"]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Intended Audience :: Developers",
+  "Programming Language :: Python :: 3",
+  "Topic :: Software Development :: Embedded Systems",
+]
+readme = "README.md"
+license = "Apache-2.0"
+license-files = ["LICENSE"]
+keywords = ["ADC", "LUT", "Look-up table", "generator"]
+
+[project.urls]
+Homepage = "https://github.com/wkhadgar/clutgen"
+Issues = "https://github.com/wkhadgar/clutgen/issues"
+
+[project.scripts]
+clutgen = "src.cli:main"
+
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools]
+py-modules = ["src.cli"]
+packages = ["src"]
+
+[tool.ruff]
+target-version = "py310"
+line-length = 100
+
+[tool.ruff.lint]
+select = [
+  "B",   # flake8-bugbear
+  "E",   # pycodestyle
+  "F",   # pyflakes
+  "I",   # isort
+  "SIM", # flake8-simplify
+  "UP",  # pyupgrade
+  "W",   # pycodestyle warnings
+]
+ignore = [
+  "SIM108", # Allow if-else blocks instead of forcing ternary operator
+  "E402",   # Allow module-level import outside top of file
+]
+
+[tool.ruff.format]
+quote-style = "preserve"
+line-ending = "lf"

clutgen-0.0.1/setup.cfg

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

clutgen-0.0.1/src/cli.py

@@ -0,0 +1,82 @@
+import argparse
+
+from src import generator as gen
+from src.generator import GenMethod
+
+
+def build_parser(parser: argparse.ArgumentParser) -> argparse.ArgumentParser:
+    parser.add_argument(
+        "-i",
+        metavar="path/to/yaml.yml",
+        help="Configuration YAMLs for the LUT generation.",
+        type=str,
+        nargs="+",
+        required=True,
+    )
+    parser.add_argument(
+        "-n",
+        "--name",
+        metavar="name",
+        help="Name of the generated LUT files.",
+        default="lookup_tables",
+    )
+
+    method_group = parser.add_mutually_exclusive_group()
+    parser.set_defaults(method=GenMethod.LINEAR)
+
+    method_group.add_argument(
+        "-l",
+        "--linear",
+        action="store_const",
+        const=GenMethod.LINEAR,
+        dest="method",
+        help="Linear Interpolation generation method. [default]",
+    )
+    method_group.add_argument(
+        "-s",
+        "--spline",
+        action="store_const",
+        const=GenMethod.SPLINE,
+        dest="method",
+        help="Cubic Splines Interpolation generation method.",
+    )
+    method_group.add_argument(
+        "-p",
+        "--polinomial",
+        action="store_const",
+        const=GenMethod.POLINOMIAL,
+        dest="method",
+        help="Polinomial Interpolation generation method.",
+    )
+    method_group.add_argument(
+        "-w",
+        "--piecewise",
+        action="store_const",
+        const=GenMethod.PIECEWISE,
+        dest="method",
+        help="Piecewise Interpolation generation method.",
+    )
+    method_group.add_argument(
+        "-d",
+        "--idw",
+        action="store_const",
+        const=GenMethod.IDW,
+        dest="method",
+        help="Inverse Distance Weighting generation method.",
+    )
+
+    return parser
+
+
+def main():
+    parser = build_parser(argparse.ArgumentParser())
+
+    gen.generate(
+        parser.parse_args().i,
+        parser.parse_args().name,
+        parser.parse_args().method,
+    )
+
+
+if __name__ == "__main__":
+    main()

clutgen-0.0.1/src/generator.py

@@ -0,0 +1,373 @@
+"""
+:file: generator.py
+:author: Paulo Santos (@wkhadgar)
+:brief: Look-up Table generation base.
+:version: 0.1
+:date: 23-02-2026
+
+:copyright: Copyright (c) 2026
+"""
+
+from __future__ import annotations
+
+import datetime
+import math
+import sys
+from enum import Enum
+from pathlib import Path
+
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+import yaml
+
+
+class GenMethod(Enum):
+    LINEAR = "linear"
+    SPLINE = "spline"
+    POLINOMIAL = "polynomial"
+    PIECEWISE = "piecewise"
+    IDW = "IDW"
+
+
+class VirtualSensor:
+    def __init__(
+        self,
+        measure_dict: dict[int, int | float] | None = None,
+        *,
+        resolution: int,
+    ):
+        """
+        Creates a virtual sensor for simulation.
+
+        :param measure_dict: Calibration measurement dictionary in the form [adc_raw:calibration].
+        :param resolution: Resolution of the measurements made, in bits of precision.
+        :param generator: Optional data generator of type `foo(raw, resolution) -> val`
+        """
+        self.resolution: int = resolution
+
+        if measure_dict is not None:
+            self.x = np.array(list(measure_dict.keys()))
+            self.y = np.array(list(measure_dict.values()))
+            return
+
+        raise ValueError(f"Unable to create virtual sensor with given data: {measure_dict}")
+
+    def __get_best_fit_lms(self) -> list:
+        """
+        Generates a list of polynomial coefficients that best approximate the measurements.
+
+        :return: List of polynomial coefficients, ordered from highest degree to lowest.
+        """
+        c, [residuals, _, _, _] = np.polynomial.polynomial.polyfit(self.x, self.y, 1, full=True)
+        minimal_dev = residuals
+        best_coefficients: np.ndarray = c
+        for deg in range(2, 8):
+            if (len(self.x) <= deg + 1) or minimal_dev < 1e-10:
+                break
+
+            c, [residuals, _, _, _] = np.polynomial.polynomial.polyfit(
+                self.x, self.y, deg, full=True
+            )
+            if residuals < minimal_dev:
+                minimal_dev = residuals
+                best_coefficients = c
+
+        return list(reversed(best_coefficients))
+
+    def data_gen(self, method: GenMethod, *, max_val: int, min_val: int) -> dict[int, int]:
+        max_raw = 2**self.resolution
+        virtual_measures_span = range(0, max_raw)
+
+        match method:
+            case GenMethod.POLINOMIAL:
+                virtual_measures: dict[int, int] = {}
+                coefficients = self.__get_best_fit_lms()
+                degree = len(coefficients)
+                for virtual_reading in virtual_measures_span:
+                    out = (virtual_reading * coefficients[0]) + coefficients[1]
+                    i = 2
+                    while i < degree:
+                        out = (out * virtual_reading) + coefficients[i]
+                        i += 1
+                    virtual_measures[virtual_reading] = int(
+                        max(min(math.trunc(out), max_val), min_val)
+                    )
+                return virtual_measures
+            case GenMethod.LINEAR:
+                if self.x[0] != 0:
+                    self.x = np.append([0], self.x)
+                    self.y = np.append(self.y[0], self.y)
+                if self.x[-1] != max_raw:
+                    self.x = np.append(self.x, [max_raw])
+                    self.y = np.append(self.y, self.y[-1])
+
+                y_interp = np.interp(virtual_measures_span, self.x, self.y)
+                return {
+                    xi: int(max(min(math.trunc(yi), max_val), min_val))
+                    for xi, yi in zip(virtual_measures_span, y_interp, strict=False)
+                }
+            case GenMethod.SPLINE:
+                x, y = self.x, self.y
+                n = len(x)
+                h = np.diff(x)
+
+                A = np.zeros((n, n))
+                B = np.zeros(n)
+                A[0, 0] = 1
+                A[-1, -1] = 1
+
+                for i in range(1, n - 1):
+                    A[i, i - 1] = h[i - 1] / 6
+                    A[i, i] = (h[i - 1] + h[i]) / 3
+                    A[i, i + 1] = h[i] / 6
+                    B[i] = (y[i + 1] - y[i]) / h[i] - (y[i] - y[i - 1]) / h[i - 1]
+
+                M = np.linalg.solve(A, B)
+
+                def interpolate(xi):
+                    idx = np.searchsorted(x, xi, side='right') - 1
+                    idx = np.clip(idx, 0, n - 2)
+
+                    dx = x[idx + 1] - x[idx]
+                    t = (xi - x[idx]) / dx
+
+                    val = (
+                        (M[idx] * (1 - t) ** 3 / 6 + M[idx + 1] * t**3 / 6) * dx**2
+                        + (y[idx] - M[idx] * dx**2 / 6) * (1 - t)
+                        + (y[idx + 1] - M[idx + 1] * dx**2 / 6) * t
+                    )
+                    return val
+
+                return {
+                    xi: int(max(min(math.trunc(interpolate(xi)), max_val), min_val))
+                    for xi in virtual_measures_span
+                }
+            case GenMethod.PIECEWISE:
+                indices = np.searchsorted(self.x, virtual_measures_span, side='right') - 1
+                indices = np.clip(indices, 0, len(self.y) - 1)
+                y_interp = self.y[indices]
+
+                return {
+                    xi: int(max(min(yi, max_val), min_val))
+                    for xi, yi in zip(virtual_measures_span, y_interp, strict=True)
+                }
+            case GenMethod.IDW:
+                virtual_measures: dict[int, int] = {}
+                power = 2
+
+                for xi in virtual_measures_span:
+                    distances = np.abs(self.x - xi)
+
+                    if np.any(distances == 0):
+                        yi = self.y[np.argmin(distances)]
+                    else:
+                        weights = 1.0 / (distances**power)
+                        yi = np.sum(weights * self.y) / np.sum(weights)
+
+                    virtual_measures[xi] = int(max(min(int(yi), max_val), min_val))
+
+                return virtual_measures
+
+
+class LUTStringify:
+    def __init__(
+        self,
+        out_path: Path,
+        sensor: VirtualSensor,
+        *,
+        output_type: str,
+        method: GenMethod,
+    ):
+        """
+        Creates an instance of a calibrated data generator based on a virtual sensor.
+
+        :param sensor: Virtual sensor to be used or generation function.
+        :param output_type: Type used in the generated output.
+        """
+
+        self.sensor = sensor
+        self.var_size_bits: int = int(
+            output_type.removeprefix("u").removeprefix("int").removesuffix("_t")
+        )
+        self.type_str = f"const {output_type}"
+        self.preview_out_dir = out_path / "preview"
+        self.preview_out_path = None
+        self.method: GenMethod = method
+
+        out_path.mkdir(exist_ok=True)
+        self.preview_out_dir.mkdir(exist_ok=True)
+
+        if output_type.startswith("u"):
+            self.max_int = (2**self.var_size_bits) - 1
+            self.min_int = 0
+        else:
+            self.max_int = (2 ** (self.var_size_bits - 1)) - 1
+            self.min_int = -self.max_int
+
+    def __get_lut_values_str(self):
+        """
+        Generates calibrated values based on previous measurements.
+
+        :return: String representing the values the sensor read.
+        """
+        line_dim = 0
+        output_str = ""
+
+        table = self.sensor.data_gen(self.method, max_val=self.max_int, min_val=self.min_int)
+
+        plt.figure(figsize=(15, 10), dpi=250)
+        plt.scatter(self.sensor.x, self.sensor.y, c="r", s=10, zorder=3)
+        plt.grid(visible=True, which="both")
+        plt.plot(range(len(table)), list(table.values()), c="b")
+        plt.legend(["Calibration values", "Calculated LUT"])
+        plt.savefig(self.preview_out_path, bbox_inches='tight')
+
+        for v in list(table.values()):
+            current_temp_str = f"{v}, "
+
+            if (line_dim + len(current_temp_str)) >= 95:
+                current_temp_str = "\n\t" + current_temp_str
+                line_dim = 0
+
+            output_str += current_temp_str
+            line_dim += len(current_temp_str)
+
+        return "{\n\t" + output_str + "\n};\n\n"
+
+    def get_lut_definition(self, code_name: str, doc_name: str):
+        """
+        Generates a syntactically correct C string for header assignment.
+
+        :param code_name: Name used in the code for the generated LUT.
+        :param doc_name: Natural language name for the generated LUT.
+        :return: Formatted string for use in headers.
+        """
+
+        self.preview_out_path = self.preview_out_dir / code_name
+        plt.close()
+        plt.title(f"{doc_name.capitalize()}")
+        plt.xlabel(f"ADC Value (scaled to {self.sensor.resolution} bits)")
+        plt.ylabel("LUT Value (in calibration unit)")
+        return (
+            f"{self.type_str} {code_name}_lut[{2**self.sensor.resolution}] = "
+            + self.__get_lut_values_str()
+        )
+
+    def get_lut_declaration(self, code_name: str, doc_name: str):
+        docs = (
+            "/**\n"
+            f" * @brief LUT for {doc_name} measurements.\n"
+            " *\n"
+            f" * @note The value read by the ADC is scaled to {self.sensor.resolution} bits "
+            f"(0 to {(2**self.sensor.resolution) - 1}), and used as an index for this LUT.\n"
+            " */"
+        )
+
+        return docs + f"\nextern {self.type_str} {code_name}_lut[{2**self.sensor.resolution}];\n\n"
+
+
+def generate(in_files: list[str], filename: str, method: GenMethod):
+    out_dir = Path("./generated_luts")
+    out_include_dir = Path("./include")
+    out_path_c = out_dir / (filename + ".c")
+    out_path_h = out_include_dir / (filename + ".h")
+
+    header_h = (
+        "/**\n"
+        f" * @file {filename}.h\n"
+        " * @brief Organizes lookup tables to speed up sensor readings.\n"
+        " * @note The code in this file is generated and should not be modified.\n"
+        " * @version 0.1\n"
+        f" * @date {datetime.datetime.now().strftime('%d-%m-%Y')}\n"
+        " *\n"
+        " */\n"
+        "\n"
+        f"#ifndef {filename.upper()}_H\n"
+        f"#define {filename.upper()}_H\n"
+        "\n"
+        "#include <stdint.h>\n\n"
+    )
+
+    footer = f"\n#endif /* {filename.upper()}_H */\n"
+
+    header_c = (
+        "/**\n"
+        f" * @file {filename}.c\n"
+        " * @brief Defines lookup tables to speed up sensor readings.\n"
+        " * @note The code in this file is generated and should not be modified.\n"
+        " * @version 0.1\n"
+        f" * @date {datetime.datetime.now().strftime('%d-%m-%Y')}\n"
+        " *\n"
+        " */\n"
+        "\n"
+        f'#include "{filename}.h"\n\n'
+    )
+
+    print("-- Running scripts to generate LUTs")
+
+    luts_c = []
+    luts_h = []
+
+    calibration_data_yamls: list[Path] = []
+    for file in in_files:
+        abs_file_path = Path(file).resolve()
+        if file.endswith(".yml") or file.endswith(".yaml"):
+            calibration_data_yamls.append(abs_file_path.resolve())
+
+    if len(calibration_data_yamls) == 0:
+        print("-- No configuration YAMLs found.")
+        return
+
+    for gen_yaml in calibration_data_yamls:
+        with open(gen_yaml, encoding="utf8") as stream:
+            lut_descriptor = yaml.safe_load(stream)
+
+            code_name: str = lut_descriptor["name"]
+            doc_name: str = lut_descriptor["description"]
+            resolution: int = int(lut_descriptor["table_resolution_bits"])
+            output_size_bits: str = lut_descriptor["lut_type"]
+            generator: Path = Path(lut_descriptor["generator"])
+
+            try:
+                path = (gen_yaml.parent / generator).resolve(strict=True)
+            except FileNotFoundError:
+                path = generator.resolve(strict=True)
+
+            if generator.suffix == ".csv":
+                gen_data = pd.read_csv(path)
+            elif generator.suffix in (".xls", ".xlsx", ".xlsm", ".xlsb", ".odf", ".ods", ".odt"):
+                gen_data = pd.read_excel(path)
+            else:
+                print(f"Could not obtain generator for {code_name}\nCheck the table format.")
+                sys.exit(1)
+
+        sensor = VirtualSensor(
+            {
+                int(raw): int(val)
+                for raw, val in zip(gen_data["raw"], gen_data["calibration"], strict=False)
+            },
+            resolution=resolution,
+        )
+        print(f"-- Generating {code_name} LUT based on '{path}'...")
+        printer = LUTStringify(out_dir, sensor, output_type=output_size_bits, method=method)
+        luts_c.append(printer.get_lut_definition(code_name=code_name, doc_name=doc_name))
+        luts_h.append(printer.get_lut_declaration(code_name=code_name, doc_name=doc_name))
+
+    out_dir.mkdir(exist_ok=True)
+    out_include_dir.mkdir(exist_ok=True)
+
+    with open(out_path_c, "w", encoding="utf8") as out:
+        print(f"-- Generating source {filename}.c...")
+        out.write(header_c)
+        for lut in luts_c:
+            out.write(lut)
+
+    with open(out_path_h, "w", encoding="utf8") as out:
+        print(f"-- Generating header {filename}.h...")
+        out.write(header_h)
+        for lut in luts_h:
+            out.write(lut)
+        out.write(footer)
+
+    print("-- LUTs generated successfully.")