Merge branch 'main' into pwm

libhal · Jan 16, 2025 · 916d6af · 916d6af
2 parents 471d01c + 3932397
commit 916d6af
Show file tree

Hide file tree

Showing 33 changed files with 2,395 additions and 232 deletions.
diff --git a/.clangd b/.clangd
@@ -1,8 +1,2 @@
-If:
-  PathMatch: demos/.*
-  CompileFlags:
-    CompilationDatabase: demos
-Else:
-  CompileFlags:
-    CompilationDatabase: .
-
+CompileFlags:
+  CompilationDatabase: .
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -46,6 +46,7 @@ libhal_test_and_make_library(
 
   # stm32_generic
   src/stm32_generic/spi.cpp
+  src/stm32_generic/uart.cpp
 
   # stm32f1
   src/stm32f1/can_reg.hpp
@@ -67,12 +68,15 @@ libhal_test_and_make_library(
   src/stm32f1/spi.cpp
 
   # stm32f411
+  src/stm32f411/clock.cpp
+  src/stm32f411/dma.cpp
   src/stm32f411/input_pin.cpp
+  src/stm32f411/interrupt.cpp
   src/stm32f411/output_pin.cpp
   src/stm32f411/pin.cpp
   src/stm32f411/power.cpp
   src/stm32f411/spi.cpp
-  src/stm32f411/clock.cpp
+  src/stm32f411/uart.cpp
 
   # stm32f40
   src/stm32f40/output_pin.cpp

diff --git a/conanfile.py b/conanfile.py
@@ -34,7 +34,7 @@ class libhal_arm_mcu_conan(ConanFile):
               "stm32f1", "stm32f103")
     settings = "compiler", "build_type", "os", "arch"
 
-    python_requires = "libhal-bootstrap/[^3.0.0]"
+    python_requires = "libhal-bootstrap/[^4.1.0]"
     python_requires_extend = "libhal-bootstrap.library"
 
     options = {
@@ -52,10 +52,8 @@ class libhal_arm_mcu_conan(ConanFile):
     }
 
     def requirements(self):
-        bootstrap = self.python_requires["libhal-bootstrap"]
-        bootstrap.module.add_library_requirements(
-            self, override_libhal_util_version="5.3.0")
-
+        self.requires("libhal/[^4.9.0]", transitive_headers=True)
+        self.requires("libhal-util/[^5.3.0]", transitive_headers=True)
         self.requires("ring-span-lite/[^0.7.0]", transitive_headers=True)
         self.requires("scope-lite/0.2.0")
 

diff --git a/demos/.clangd b/demos/.clangd
@@ -0,0 +1,2 @@
+CompileFlags:
+  CompilationDatabase: .
diff --git a/demos/applications/can.cpp b/demos/applications/can.cpp
@@ -14,56 +14,108 @@
 
 #include <libhal-util/serial.hpp>
 #include <libhal-util/steady_clock.hpp>
+#include <libhal/can.hpp>
 
 #include <resource_list.hpp>
 
+void print_can_message(hal::serial& p_console,
+                       hal::can_message const& p_message)
+{
+  hal::print<256>(p_console,
+                  "Received Message from ID: 0x%lX, length: %u \n"
+                  "payload = [ 0x%02X, 0x%02X, 0x%02X, 0x%02X, 0x%02X, "
+                  "0x%02X, 0x%02X, 0x%02X ]\n",
+                  p_message.id,
+                  p_message.length,
+                  p_message.payload[0],
+                  p_message.payload[1],
+                  p_message.payload[2],
+                  p_message.payload[3],
+                  p_message.payload[4],
+                  p_message.payload[5],
+                  p_message.payload[6],
+                  p_message.payload[7]);
+}
+
 void application(resource_list& p_map)
 {
   using namespace hal::literals;
 
   auto& clock = *p_map.clock.value();
-  auto& can = *p_map.can.value();
+  auto& can_transceiver = *p_map.can_transceiver.value();
+  auto& can_bus_manager = *p_map.can_bus_manager.value();
+  auto& can_interrupt = *p_map.can_interrupt.value();
   auto& console = *p_map.console.value();
 
   // Change the CAN baudrate here.
   static constexpr auto baudrate = 100.0_kHz;
 
   hal::print(console, "Starting CAN demo!\n");
 
-  can.configure({ .baud_rate = baudrate });
-
-  auto receive_handler = [&console](hal::can::message_t const& p_message) {
-    hal::print<1024>(console,
-                     "Received Message from ID: 0x%lX, length: %u \n"
-                     "payload = [ 0x%02X, 0x%02X, 0x%02X, 0x%02X, 0x%02X, "
-                     "0x%02X, 0x%02X, 0x%02X ]\n",
-                     p_message.id,
-                     p_message.length,
-                     p_message.payload[0],
-                     p_message.payload[1],
-                     p_message.payload[2],
-                     p_message.payload[3],
-                     p_message.payload[4],
-                     p_message.payload[5],
-                     p_message.payload[6],
-                     p_message.payload[7]);
-  };
-
-  can.on_receive(receive_handler);
+  can_bus_manager.baud_rate(baudrate);
+
+  can_interrupt.on_receive([&console](hal::can_interrupt::on_receive_tag,
+                                      hal::can_message const& p_message) {
+    hal::print(console, "Printing can message from interrupt!\n");
+    print_can_message(console, p_message);
+  });
+
+  hal::u32 receive_cursor = 0;
 
   while (true) {
     using namespace std::chrono_literals;
-
-    hal::can::message_t my_message{
-      .id = 0x0111,
-      .payload = { 0xAA, 0xBB, 0xCC, 0xDD, 0xDE, 0xAD, 0xBE, 0xEF },
+    hal::can_message standard_message {
+      .id=0x112,
+      .extended=false,
+      .remote_request=false,
       .length = 8,
-      .is_remote_request = false,
+      .payload = {
+        0xAA, 0xBB, 0xCC, 0xDD, 0xDE, 0xAD, 0xBE, 0xEF,
+      },
     };
 
-    hal::print(console, "Sending payload...\n");
-    can.send(my_message);
+    hal::can_message standard_message2{
+      .id = 0x333,
+      .length = 0,
+    };
+
+    hal::can_message extended_message{
+      .id = 0x0123'4567,
+      .extended = true,
+      .length = 3,
+      .payload = {
+        0xAA, 0xBB, 0xCC, 0xDD, 0xDE, 0xAD, 0xBE, 0xEF,
+      },
+    };
+
+    hal::can_message extended_message2 {
+      .id = 0x0222'0005,
+      .extended = true,
+      .length = 3,
+      .payload = {
+        0xAA, 0xBB, 0xCC, 0xDD, 0xDE, 0xAD, 0xBE, 0xEF,
+      },
+    };
+
+    hal::print(console, "Sending payload(s)...\n");
+
+    can_transceiver.send(standard_message);
+    can_transceiver.send(standard_message2);
+    can_transceiver.send(extended_message);
+    can_transceiver.send(extended_message2);
 
     hal::delay(clock, 1s);
+
+    hal::print(console,
+               "Printing received messages stored in circular buffer...\n");
+    auto const buffer = can_transceiver.receive_buffer();
+    auto cursor = can_transceiver.receive_cursor();
+    for (; receive_cursor != cursor;
+         receive_cursor = (receive_cursor + 1) % buffer.size()) {
+      print_can_message(console, buffer[receive_cursor]);
+      cursor = can_transceiver.receive_cursor();
+    }
+
+    hal::print(console, "Printing done.\n\n");
   }
 }
diff --git a/demos/applications/uart.cpp b/demos/applications/uart.cpp
@@ -12,9 +12,11 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+#include <array>
 #include <libhal-util/serial.hpp>
 #include <libhal-util/steady_clock.hpp>
 
+#include <libhal/timeout.hpp>
 #include <resource_list.hpp>
 
 void application(resource_list& p_map)
@@ -31,7 +33,6 @@ void application(resource_list& p_map)
 
     std::string_view message = "Hello, World!\n";
     hal::print(console, message);
-
     // Echo anything received
     std::array<hal::byte, 64> read_buffer;
     console.write(console.read(read_buffer).data);

diff --git a/demos/conanfile.py b/demos/conanfile.py
@@ -18,11 +18,11 @@
 
 
 class demos(ConanFile):
-    python_requires = "libhal-bootstrap/[^4.0.0]"
+    python_requires = "libhal-bootstrap/[^4.1.0]"
     python_requires_extend = "libhal-bootstrap.demo"
 
     def requirements(self):
         bootstrap = self.python_requires["libhal-bootstrap"]
-        bootstrap.module.add_demo_requirements(self, is_platform=True)
-        self.requires("libhal-arm-mcu/[^1.0.0 || latest]")
+        self.requires("libhal-arm-mcu/[^1.5.0 || latest]")
         self.requires("minimp3/cci.20211201")
+        bootstrap.module.add_demo_requirements(self, is_platform=True)
diff --git a/demos/platforms/lpc4078.cpp b/demos/platforms/lpc4078.cpp
@@ -58,9 +58,9 @@ void initialize_platform(resource_list& p_resources)
 
   static hal::lpc40::can can(2,
                              hal::can::settings{
-                               .baud_rate = 1.0_MHz,
+                               .baud_rate = 1.0_kHz,
                              });
-  p_resources.can = &can;
+  // p_resources.can = &can;
 
   static hal::lpc40::adc adc4(hal::channel<4>);
   p_resources.adc = &adc4;

diff --git a/demos/platforms/stm32f103c8.cpp b/demos/platforms/stm32f103c8.cpp
@@ -24,8 +24,8 @@
 #include <libhal-arm-mcu/system_control.hpp>
 #include <libhal-util/bit_bang_i2c.hpp>
 #include <libhal-util/bit_bang_spi.hpp>
+#include <libhal-util/inert_drivers/inert_adc.hpp>
 #include <libhal-util/steady_clock.hpp>
-
 #include <libhal/output_pin.hpp>
 #include <libhal/units.hpp>
 
@@ -48,9 +48,24 @@ void initialize_platform(resource_list& p_resources)
   static hal::stm32f1::uart uart1(hal::port<1>, hal::buffer<128>);
   p_resources.console = &uart1;
 
-  static hal::stm32f1::can can({ .baud_rate = 1'000'000 },
-                               hal::stm32f1::can_pins::pb9_pb8);
-  p_resources.can = &can;
+  static hal::stm32f1::can_peripheral_manager can(
+    100_kHz, hal::stm32f1::can_pins::pb9_pb8);
+
+  can.enable_self_test(true);
+
+  static std::array<hal::can_message, 8> receive_buffer{};
+  static auto can_transceiver = can.acquire_transceiver(receive_buffer);
+  p_resources.can_transceiver = &can_transceiver;
+
+  static auto can_bus_manager = can.acquire_bus_manager();
+  p_resources.can_bus_manager = &can_bus_manager;
+
+  static auto can_interrupt = can.acquire_interrupt();
+  p_resources.can_interrupt = &can_interrupt;
+
+  // Allow all messages
+  static auto mask_id_filters_x2 = can.acquire_mask_filter();
+  mask_id_filters_x2.filter[0].allow({ { .id = 0, .mask = 0 } });
 
   static hal::stm32f1::output_pin led('C', 13);
 
@@ -60,8 +75,8 @@ void initialize_platform(resource_list& p_resources)
   static hal::stm32f1::input_pin input_pin('B', 4);
   p_resources.input_pin = &input_pin;
 
-  static hal::stm32f1::output_pin sda_output_pin('B', 7);
-  static hal::stm32f1::output_pin scl_output_pin('B', 6);
+  static hal::stm32f1::output_pin sda_output_pin('A', 0);
+  static hal::stm32f1::output_pin scl_output_pin('A', 15);
 
   sda_output_pin.configure({
     .resistor = hal::pin_resistor::pull_up,
@@ -77,6 +92,8 @@ void initialize_platform(resource_list& p_resources)
   };
   static hal::bit_bang_i2c bit_bang_i2c(bit_bang_pins, steady_clock);
 
+  p_resources.i2c = &bit_bang_i2c;
+
   static hal::stm32f1::output_pin spi_chip_select('A', 4);
   p_resources.spi_chip_select = &spi_chip_select;
   static hal::stm32f1::output_pin sck('A', 5);

diff --git a/demos/platforms/stm32f411re.cpp b/demos/platforms/stm32f411re.cpp
@@ -17,10 +17,12 @@
 #include <libhal-arm-mcu/startup.hpp>
 #include <libhal-arm-mcu/stm32f411/clock.hpp>
 #include <libhal-arm-mcu/stm32f411/constants.hpp>
+#include <libhal-arm-mcu/stm32f411/dma.hpp>
 #include <libhal-arm-mcu/stm32f411/input_pin.hpp>
 #include <libhal-arm-mcu/stm32f411/output_pin.hpp>
 #include <libhal-arm-mcu/stm32f411/pin.hpp>
 #include <libhal-arm-mcu/stm32f411/spi.hpp>
+#include <libhal-arm-mcu/stm32f411/uart.hpp>
 #include <libhal-arm-mcu/system_control.hpp>
 #include <libhal/initializers.hpp>
 #include <libhal/output_pin.hpp>
@@ -47,6 +49,9 @@ void initialize_platform(resource_list& p_resources)
   hal::stm32f411::output_pin chip_select(hal::stm32f411::peripheral::gpio_b,
                                          13);
 
+  static hal::stm32f411::uart uart2(
+    hal::port<2>, hal::buffer<128>, { .baud_rate = 115200 });
+  p_resources.console = &uart2;
   p_resources.reset = []() { hal::cortex_m::reset(); };
   p_resources.status_led = &led;
   p_resources.clock = &steady_clock;

diff --git a/demos/resource_list.hpp b/demos/resource_list.hpp
@@ -42,7 +42,9 @@ struct resource_list
   std::optional<hal::serial*> console;
   std::optional<hal::output_pin*> status_led;
   std::optional<hal::steady_clock*> clock;
-  std::optional<hal::can*> can;
+  std::optional<hal::can_transceiver*> can_transceiver;
+  std::optional<hal::can_bus_manager*> can_bus_manager;
+  std::optional<hal::can_interrupt*> can_interrupt;
   std::optional<hal::adc*> adc;
   std::optional<hal::input_pin*> input_pin;
   std::optional<hal::i2c*> i2c;