Added I2C support for raspi & first rework of debugging

include/sta/devices/stm32/can.hpp

@@ -0,0 +1,120 @@
+/**
+ * @file
+ * @brief Implementation of CanController using STM32 HAL.
+ *
+ * Configuration:
+ *   * STA_STM32_CAN_GLOBAL: Create global CanBus object using this CAN instance
+ */
+#ifndef STA_CORE_STM32_CAN_HPP
+#define STA_CORE_STM32_CAN_HPP
+
+/**
+ * @defgroup sta_core_stm32_can CAN
+ * @ingroup sta_core_stm32
+ * @brief STM32 CAN module.
+ *
+ * Check @ref stm32BuildConfig for configuration options.
+ */
+
+// Only enable module on STM32 platform w/ HAL CAN module enabled
+#include <sta/config.hpp>
+#ifdef STA_PLATFORM_STM32
+#  include <sta/stm32/hal.hpp>
+#  ifdef HAL_CAN_MODULE_ENABLED
+#    define STA_STM32_CAN_ENABLED
+#  endif // HAL_CAN_MODULE_ENABLED
+#endif // STA_PLATFORM_STM32
+
+
+#if defined(STA_STM32_CAN_ENABLED) || defined(DOXYGEN)
+
+#include <sta/can/controller.hpp>
+
+
+namespace sta
+{
+    /**
+     * @brief Implementation of CanController interface using HAL.
+     *
+     * @ingroup sta_core_stm32_can
+     */
+    class STM32CanController : public CanController
+    {
+    public:
+        static constexpr uint8_t MAX_FILTER_COUNT = 14; /**< Max number of filters */
+        static constexpr uint8_t MAX_FIFO_COUNT   = 2;  /**< Max number of FIFOs */
+        static constexpr uint8_t MAX_PAYLOAD_SIZE = 8;  /**< Maximum payload size */
+
+    public:
+        /**
+         * @param handle    CAN handle
+         */
+        STM32CanController(CAN_HandleTypeDef * handle);
+
+        /**
+         * @brief Enable RX pending interrupts.
+         */
+        void enableRxInterrupts();
+
+        /**
+         * @brief Start CAN controller.
+         */
+        void start();
+        /**
+         * @brief Stop CAN controller.
+         */
+        void stop();
+
+
+        // RX/TX
+        //
+
+        bool sendFrame(const CanTxHeader & header, const uint8_t * payload) override;
+        bool receiveFrame(uint8_t fifo, CanRxHeader * header, uint8_t * payload) override;
+
+        uint32_t getRxFifoFlags() override;
+
+        // RX Filter
+        //
+
+        void configureFilter(uint8_t idx, const CanFilter & filter, bool active = false) override;
+        void enableFilter(uint8_t idx) override;
+        void disableFilter(uint8_t idx) override;
+        void clearFilters() override;
+
+    private:
+        /**
+         * @brief Initialize filter settings.
+         */
+        void initFilters();
+
+    private:
+        CAN_HandleTypeDef * handle_;                    /**< CAN handle */
+        CAN_FilterTypeDef   filters_[MAX_FILTER_COUNT]; /**< Filter settings */
+    };
+
+
+
+#if defined(STA_STM32_CAN_GLOBAL) || DOXYGEN
+    /**
+     * @brief Global CAN instance.
+     *
+     * @ingroup sta_core_stm32_can
+     */
+    extern STM32CanController CanBus;
+
+    /**
+     * @brief Interrupt handler for pending RX frames.
+     *
+     * May be implemented by application.
+     *
+     * @ingroup sta_core_stm32_can
+     */
+    void CanBus_RxPendingCallback();
+#endif // STA_STM32_CAN_GLOBAL
+} // namespace sta
+
+
+#endif // STA_STM32_CAN_ENABLED
+
+#endif // STA_CORE_STM32_CAN_HPP