Adding Eigen Linear Algebra support

.gitmodules

@@ -52,3 +52,6 @@
 [submodule "ext/segger/rtt"]
 	path = ext/segger/rtt
 	url = https://github.com/modm-ext/segger-rtt.git
+[submodule "ext/libeigen/eigen"]
+	path = ext/libeigen/eigen
+	url = https://github.com/modm-ext/eigen-partial.git

examples/nucleo_g474re/eigen/main.cpp

@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 2025, Henrik Hose
+ *
+ * This file is part of the modm project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+#include <modm/board.hpp>
+#include <Eigen/Dense>
+
+using namespace Board;
+
+Eigen::IOFormat squarebrackets(5, 0, ", ", "\n", "[", "]");
+
+int
+main()
+{
+	Board::initialize();
+	LedD13::setOutput();
+
+	while (1)
+	{
+		Eigen::Matrix2f mat{{1, 2}, {3, 4}};
+		Eigen::Vector2f u{-1, 1}, v{2, 0};
+		MODM_LOG_INFO << "Here is mat*mat:\n" << mat * mat << modm::endl;
+		MODM_LOG_INFO << "Here is mat*u:\n" << mat * u << modm::endl;
+		MODM_LOG_INFO << "Here is u^T*mat:\n" << u.transpose() * mat << modm::endl;
+		MODM_LOG_INFO << "Here is u^T*v:\n" << u.transpose() * v << modm::endl;
+		MODM_LOG_INFO << "Here is u*v^T:\n" << u * v.transpose() << modm::endl;
+		MODM_LOG_INFO << "Let's multiply mat by itself" << modm::endl;
+		mat = mat * mat;
+		MODM_LOG_INFO << "Now mat is mat:\n" << mat.format(squarebrackets)<< modm::endl;
+
+		modm::delay(1s);
+	}
+
+	return 0;
+}

examples/nucleo_g474re/eigen/project.xml

@@ -0,0 +1,11 @@
+<library>
+  <extends>modm:nucleo-g474re</extends>
+  <options>
+    <option name="modm:build:build.path">../../../build/nucleo_g474re/eigen</option>
+  </options>
+  <modules>
+    <module>modm:build:scons</module>
+    <module>modm:platform:heap</module>
+    <module>modm:eigen</module>
+  </modules>
+</library>

ext/gcc/assert.cpp.in

@@ -11,7 +11,6 @@
 
 #include <cstdint>
 #include <bits/functexcept.h>
-#include <modm/math/utils/bit_constants.hpp>
 
 %% if options["assert_on_exception"]
 #include <modm/architecture/interface/assert.hpp>

ext/libeigen/Version.in

@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 2025, Henrik Hose
+ * Copyright (c) 2025, Niklas Hauser
+ *
+ * This file is part of the modm project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+// ----------------------------------------------------------------------------
+
+#pragma once
+
+#if __has_include(<eigen_conf_local.h>)
+#  include <eigen_conf_local.h>
+#endif
+
+%% if eigen_no_io
+#define EIGEN_NO_IO
+%% endif
+#define EIGEN_DONT_VECTORIZE
+#define EIGEN_DISABLE_UNALIGNED_ARRAY_ASSERT
+#define EIGEN_DONT_PARALLELIZE
+
+#define EIGEN_MALLOC_ALREADY_ALIGNED 1
+#ifndef EIGEN_MAX_ALIGN_BYTES
+#define EIGEN_MAX_ALIGN_BYTES 0
+#endif
+#ifndef EIGEN_MAX_STATIC_ALIGN_BYTES
+#define EIGEN_MAX_STATIC_ALIGN_BYTES 4
+#endif
+%#
+%% if eigen_no_malloc
+#define EIGEN_NO_MALLOC
+%% endif
+#ifndef EIGEN_STACK_ALLOCATION_LIMIT
+#define EIGEN_STACK_ALLOCATION_LIMIT 1024
+#endif
+
+#ifndef MODM_DEBUG_BUILD
+#define EIGEN_NO_DEBUG
+#endif
+
+#include <modm/architecture/interface/assert.hpp>
+
+#define eigen_assert(cond) \
+    modm_assert(cond, "eigen", __FILE__ ":" MODM_STRINGIFY(__LINE__) " -> \"" #cond "\"")
+
+#include "Version_orig"

ext/libeigen/eigen.lb

@@ -0,0 +1,38 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+#
+# Copyright (c) 2025, Henrik Hose
+# Copyright (c) 2025, Niklas Hauser
+#
+# This file is part of the modm project.
+#
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+# -----------------------------------------------------------------------------
+
+def init(module):
+    module.name = ":eigen"
+    module.description = """
+# Eigen Linear Algebra Library
+
+
+"""
+
+
+def prepare(module, options):
+    module.depends(":architecture:assert")
+    return True
+
+
+def build(env):
+    env.outbasepath = "modm/ext/eigen"
+    env.collect(":build:path.include", "modm/ext/eigen")
+
+    env.substitutions = {
+        "eigen_no_malloc": not env.has_module(":platform:heap"),
+        "eigen_no_io": not (env.has_module(":io") and env.has_module(":platform:heap"))
+    }
+    env.copy("eigen/Eigen", "Eigen", ignore=env.ignore_files("Version"))
+    env.copy("eigen/Eigen/Version", "Eigen/Version_orig")
+    env.template("Version.in", "Eigen/Version")

ext/libeigen/iostream_eigen.hpp

@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2025, Henrik Hose
+ * Copyright (c) 2025, Niklas Hauser
+ *
+ * This file is part of the modm project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+// ----------------------------------------------------------------------------
+
+#pragma once
+#include <Eigen/Dense>
+
+namespace modm
+{
+
+template<typename Derived>
+modm::IOStream& operator<<(modm::IOStream& s, const Eigen::MatrixBase<Derived>& m)
+{
+    for (Eigen::Index r = 0; r < m.rows(); ++r) {
+        for (Eigen::Index c = 0; c < m.cols(); ++c) {
+            s << m(r, c);
+            if (c + 1 < m.cols()) s << ", ";
+        }
+        if (r + 1 < m.rows()) s << "\n";
+    }
+    return s;
+}
+
+} // namespace modm

src/modm/architecture/interface/assert.hpp.in

@@ -12,7 +12,6 @@
 #pragma once
 
 #include "assert.h"
-#include <modm/architecture/interface/register.hpp>
 %% if core.startswith("avr")
 #include <modm/architecture/interface/accessor_flash.hpp>
 %% endif
@@ -27,13 +26,13 @@ namespace modm
 enum class
 Abandonment : uint8_t
 {
-	DontCare = Bit0,	///< Do not care about failure.
-	Ignore = Bit1,		///< Ignore this failure.
-	Fail = Bit2,		///< This failure is reason for abandonment.
-	Debug = Bit7		///< Only set for a debug-only failure.
+	DontCare = 0b001,	///< Do not care about failure.
+	Ignore = 0b010,		///< Ignore this failure.
+	Fail = 0b100,		///< This failure is reason for abandonment.
+	Debug = 0x80,		///< Only set for a debug-only failure.
 };
-using AbandonmentBehavior = Flags8<Abandonment>;
-MODM_TYPE_FLAGS(AbandonmentBehavior);
+/// Contains the superset of Abandonment behavior
+using AbandonmentBehavior = Abandonment;
 
 /// Contains information about the failed assertion.
 struct modm_packed

src/modm/architecture/module.lb

@@ -53,7 +53,6 @@ class Assert(Module):
                               default="release" if platform == "hosted" else "debug",
                               enumeration=["off", "debug", "release"]))
 
-        module.depends(":architecture:register")
         if platform == "avr":
             module.depends(":architecture:accessor")
         return True

src/modm/driver/color/tcs3472.hpp

@@ -17,6 +17,7 @@
 
 #include <stdint.h>
 #include <modm/architecture/interface/i2c_device.hpp>
+#include <modm/architecture/interface/register.hpp>
 #include <modm/math/utils.hpp>
 #include <modm/ui/color.hpp>
 

src/modm/driver/color/tcs3472.lb

@@ -19,6 +19,7 @@ def init(module):
 def prepare(module, options):
     module.depends(
         ":architecture:i2c.device",
+        ":architecture:register",
         ":ui:color",
         ":math:utils")
     return True

src/modm/driver/display/st7586s.lb

@@ -18,6 +18,7 @@ def init(module):
 def prepare(module, options):
     module.depends(
         ":architecture:fiber",
+        ":architecture:register",
         ":ui:display")
     return True
 

src/modm/driver/display/st7586s_protocol.hpp

@@ -11,6 +11,7 @@
 
 #pragma once
 
+#include <modm/architecture/interface/register.hpp>
 #include <modm/math/utils/endianness.hpp>
 
 /// @cond

src/modm/io/iostream.hpp.in

@@ -247,6 +247,20 @@ public:
 %% endif
 
 
+	inline size_t width() const { return 0; }
+	inline void width(size_t) {}
+	inline size_t precision() const { return fmt_precision; }
+    inline size_t precision(size_t p) {
+        size_t old = fmt_precision;
+        fmt_precision = p;
+        return old;
+    }
+	inline char fill() const { return ' '; }
+    inline char fill(char) {
+        return ' ';
+    }
+
+
 protected:
 	template< typename T >
 	void
@@ -273,7 +287,7 @@ protected:
 	void writeInteger(uint64_t value);
 %% endif
 
-%% if options.with_float
+%% if options.with_float and options.with_printf
 	inline void writeFloat(float value)
 	{ writeDouble(static_cast<double>(value)); }
 	void writeDouble(const double& value);
@@ -303,6 +317,9 @@ private:
 	{ if (c) reinterpret_cast<modm::IOStream*>(arg)->write(c); }
 	printf_output_gadget_t output_gadget{out_char, this, NULL, 0, INT_MAX};
 %% endif
+%% if options.with_float and options.with_printf
+	size_t fmt_precision = 0;
+%% endif
 };
 
 /// @ingroup modm_io

src/modm/io/iostream_printf.cpp.in

@@ -147,7 +147,7 @@ void
 IOStream::writeDouble(const double& value)
 {
 %% if options.with_printf
-	print_floating_point(&output_gadget, value, 0, 0, 0, true);
+	print_floating_point(&output_gadget, value, fmt_precision, 0, 0, true);
 %% else
 	if(!std::isfinite(value)) {
 		if(std::isinf(value)) {

src/modm/io/module.lb

@@ -48,7 +48,7 @@ def build(env):
         "is_avr": target.platform == "avr",
         "with_fiber": env.has_module(":processing:fiber"),
         "family": target.family,
-        "core": core,
+        "core": core
     }
     env.outbasepath = "modm/src/modm/io"
     env.copy("iodevice.hpp")

src/modm/platform/adc/at90_tiny_mega/module.lb

@@ -27,6 +27,7 @@ def prepare(module, options):
 
     module.depends(
         ":architecture:adc",
+        ":architecture:register",
         ":architecture:interrupt",
         ":platform:gpio",
         ":math:algorithm")

src/modm/platform/can/common/fdcan/module.lb

@@ -21,6 +21,7 @@ def prepare(module, options):
 
     module.depends(
         ":architecture:assert",
+        ":architecture:register",
         ":architecture:can",
         ":architecture:clock")
     return True

src/modm/platform/core/cortex/assert.cpp.in

@@ -57,22 +57,22 @@ void
 modm_assert_report(_modm_assertion_info *cinfo)
 {
 	auto info = reinterpret_cast<modm::AssertionInfo *>(cinfo);
-	AbandonmentBehavior behavior(info->behavior);
+	uint8_t behavior(uint8_t(info->behavior));
 
 	for (const AssertionHandler *handler = &__assertion_table_start;
 		 handler < &__assertion_table_end; handler++)
 	{
 %% if core.startswith("avr")
-		behavior |= ((AssertionHandler)pgm_read_ptr(handler))(*info);
+		behavior |= (uint8_t)((AssertionHandler)pgm_read_ptr(handler))(*info);
 %% else
-		behavior |= (*handler)(*info);
+		behavior |= (uint8_t)(*handler)(*info);
 %% endif
 	}
 
-	info->behavior = behavior;
-	behavior.reset(Abandonment::Debug);
-	if ((behavior == Abandonment::DontCare) or
-		(behavior & Abandonment::Fail))
+	info->behavior = AbandonmentBehavior(behavior);
+	behavior &= ~uint8_t(Abandonment::Debug);
+	if ((behavior == uint8_t(Abandonment::DontCare)) or
+		(behavior & uint8_t(Abandonment::Fail)))
 	{
 		modm_abandon(*info);
 %% if core.startswith("cortex-m")

src/modm/platform/pwm/sam_x7x/module.lb

@@ -44,6 +44,7 @@ def prepare(module, options):
         return False
 
     module.depends(
+        ":architecture:register",
         ":cmsis:device",
         ":platform:clock",
         ":platform:gpio")

src/modm/platform/timer/samg/module.lb

@@ -47,6 +47,7 @@ def prepare(module, options):
         return False
 
     module.depends(
+        ":architecture:register",
         ":cmsis:device",
         ":platform:gpio")
 

src/modm/platform/timer/samg/timer_channel_base.hpp.in

@@ -12,6 +12,7 @@
 #pragma once
 
 #include "../device.hpp"
+#include <modm/architecture/interface/register.hpp>
 
 namespace modm::platform
 {

src/modm/platform/uart/sam-sercom/module.lb

@@ -51,6 +51,7 @@ def prepare(module, options):
     module.depends(
         ":architecture:uart",
         ":architecture:fiber",
+        ":architecture:register",
         ":math:algorithm",
         ":cmsis:device",
         ":platform:gpio",