can-halal setup

.gitmodules

@@ -1,6 +1,3 @@
-[submodule "can-halal"]
-	path = can-halal
-	url = ssh://git@git.fasttube.de:313/FaSTTUBe/can-halal.git
-[submodule "Software/Core/can-halal"]
-	path = Software/Core/can-halal
+[submodule "Software/Core/Lib/can-halal"]
+	path = Software/Core/Lib/can-halal
 	url = ssh://git@git.fasttube.de:313/FaSTTUBe/can-halal.git

Software/Core/Lib/can-halal/README.md

@@ -1,77 +0,0 @@
-# FaSTTUBe CAN HAL Abstraction Layer
-
-This repository contains an abstraction layer to provide a simplified & unified
-interface to the STM32 bxCAN and FDCAN peripherals.
-
-## Installation
-
-Simply add the repository to your `Core/Lib` directory. You can also add it as a
-git submodule:
-
-    mkdir -p Core/Lib
-    cd Core/Lib
-    git submodule add ssh://git@git.fasttube.de:313/FaSTTUBe/can-halal.git
-
-The library needs to be told what STM family you're using, so make sure one of
-the following symbols is defined when `can-halal.c` is compiled or `can-halal.h`
-is included:
-
-- `STM32F3`
-- `STM32H7`
-
-When using the FDCAN peripheral (H7 series), you also need to define
-`FTCAN_NUM_FILTERS` (and set it to the value of "Std Filters Nbr" you configured
-in your `.ioc`).
-
-If you use
-[VSCode with the stm-32-for-vscode extension](https://podio.com/fasttubede/modulubergreifend/apps/tech-tutorials/items/57),
-you can add these definitions in the `STM32-for-VSCode-config.yaml` file, e.g.:
-
-```yaml
-# Compiler definitions. The -D prefix for the compiler will be automatically added.
-cDefinitions:
-  - STM32H7
-  - FTCAN_NUM_FILTERS=32
-```
-
-## Usage
-
-1. Include `can-halal.h`
-2. Call `ftcan_init()` with the appropriate handle
-3. Call `ftcan_add_filter()` with all your filters
-4. To transmit messages, call `ftcan_transmit()`
-5. When a message is received, `ftcan_msg_received_cb()` is called. It has a
-   default empty implementation, which you can simply override.
-
-## Enabling CAN in STM32CubeMX
-
-This isn't specific to `can-halal`, but for completeness sake is included here.
-
-### bxCAN (e.g. STM32F3xx)
-
-1. Enable the CAN peripheral  
-   ![Connectivity -> CAN -> Activated](doc/bxcan-activate.png)
-2. Setup the [bit timings](http://bittiming.can-wiki.info/).  
-   **Note:** the baud rate depends on your system clock, so make sure that is
-   setup correctly first!  
-   ![Connectivity -> CAN -> Parameter Settings -> Bit Timings Parameters](doc/bxcan-bittimings.png)
-3. Make sure the CAN_RX0 interrupt is enabled  
-   ![Connectivity -> CAN -> NVIC Settings -> CAN_RX0 interrupt](doc/bxcan-interrupt.png)
-
-### FDCAN (e.g. STM32H7xx)
-
-1. Enable the CAN peripheral  
-   ![Connectivity -> FDCAN(1)](doc/fdcan-activate.png)
-2. Setup the frame format, nominal SJW, filters, and FIFOs. The numbers for
-   filters/FIFOs in the screenshot are examples.  
-   **Note:** You need to tell `can-halal` about the number of filters by
-   defining `FTCAN_NUM_FILTERS` (see above).  
-   ![Connectivity -> FDCAN(1) -> Parameter Settings -> Basic Parameters](doc/fdcan-basic.png)
-3. Setup the [bit timings](http://bittiming.can-wiki.info/). We only use CAN in
-   classic mode, not FD mode, so we only need to worry about the nominal bit
-   timings  
-   **Note:** the baud rate depends on your system clock, so make sure that is
-   setup correctly first!  
-   ![Connectivity -> FDCAN(1) -> Parameter Settings -> Bit Timings Parameters](doc/fdcan-bittimings.png)
-4. Make sure the interrupts are enabled
-   ![Connectivity -> FDCAN(1) -> NVIC Settings](doc/fdcan-interrupt.png)

Software/Core/Lib/can-halal/can-halal.c

@@ -1,273 +0,0 @@
-#include "can-halal.h"
-
-#include <string.h>
-
-#if defined(FTCAN_IS_BXCAN)
-static CAN_HandleTypeDef *hcan;
-
-HAL_StatusTypeDef ftcan_init(CAN_HandleTypeDef *handle) {
-  hcan = handle;
-
-  HAL_StatusTypeDef status =
-      HAL_CAN_ActivateNotification(hcan, CAN_IT_RX_FIFO0_MSG_PENDING);
-  if (status != HAL_OK) {
-    return status;
-  }
-
-  return HAL_CAN_Start(hcan);
-}
-
-HAL_StatusTypeDef ftcan_transmit(uint16_t id, const uint8_t *data,
-                                 size_t datalen) {
-  static CAN_TxHeaderTypeDef header;
-  header.StdId = id;
-  header.IDE = CAN_ID_STD;
-  header.RTR = CAN_RTR_DATA;
-  header.DLC = datalen;
-  uint32_t mailbox;
-  return HAL_CAN_AddTxMessage(hcan, &header, data, &mailbox);
-}
-
-HAL_StatusTypeDef ftcan_add_filter(uint16_t id, uint16_t mask) {
-  static uint32_t next_filter_no = 0;
-  static CAN_FilterTypeDef filter;
-  if (next_filter_no % 2 == 0) {
-    filter.FilterIdHigh = id << 5;
-    filter.FilterMaskIdHigh = mask << 5;
-    filter.FilterIdLow = id << 5;
-    filter.FilterMaskIdLow = mask << 5;
-  } else {
-    // Leave high filter untouched from the last configuration
-    filter.FilterIdLow = id << 5;
-    filter.FilterMaskIdLow = mask << 5;
-  }
-  filter.FilterFIFOAssignment = CAN_FILTER_FIFO0;
-  filter.FilterBank = next_filter_no / 2;
-  if (filter.FilterBank > FTCAN_NUM_FILTERS + 1) {
-    return HAL_ERROR;
-  }
-  filter.FilterMode = CAN_FILTERMODE_IDMASK;
-  filter.FilterScale = CAN_FILTERSCALE_16BIT;
-  filter.FilterActivation = CAN_FILTER_ENABLE;
-
-  // Disable slave filters
-  // TODO: Some STM32 have multiple CAN peripherals, and one uses the slave
-  // filter bank
-  filter.SlaveStartFilterBank = FTCAN_NUM_FILTERS;
-
-  HAL_StatusTypeDef status = HAL_CAN_ConfigFilter(hcan, &filter);
-  if (status == HAL_OK) {
-    next_filter_no++;
-  }
-  return status;
-}
-
-void HAL_CAN_RxFifo0MsgPendingCallback(CAN_HandleTypeDef *handle) {
-  if (handle != hcan) {
-    return;
-  }
-  CAN_RxHeaderTypeDef header;
-  uint8_t data[8];
-  if (HAL_CAN_GetRxMessage(hcan, CAN_RX_FIFO0, &header, data) != HAL_OK) {
-    return;
-  }
-
-  if (header.IDE != CAN_ID_STD) {
-    return;
-  }
-
-  ftcan_msg_received_cb(header.StdId, header.DLC, data);
-}
-#elif defined(FTCAN_IS_FDCAN)
-static FDCAN_HandleTypeDef *hcan;
-
-HAL_StatusTypeDef ftcan_init(FDCAN_HandleTypeDef *handle) {
-  hcan = handle;
-
-  HAL_StatusTypeDef status =
-      HAL_FDCAN_ActivateNotification(hcan, FDCAN_IT_RX_FIFO0_NEW_MESSAGE, 0);
-  if (status != HAL_OK) {
-    return status;
-  }
-  // Reject non-matching messages
-  status =
-      HAL_FDCAN_ConfigGlobalFilter(hcan, FDCAN_REJECT, FDCAN_REJECT,
-                                   FDCAN_REJECT_REMOTE, FDCAN_REJECT_REMOTE);
-  if (status != HAL_OK) {
-    return status;
-  }
-
-  return HAL_FDCAN_Start(hcan);
-}
-
-HAL_StatusTypeDef ftcan_transmit(uint16_t id, const uint8_t *data,
-                                 size_t datalen) {
-  static FDCAN_TxHeaderTypeDef header;
-  header.Identifier = id;
-  header.IdType = FDCAN_STANDARD_ID;
-  header.TxFrameType = FDCAN_DATA_FRAME;
-  switch (datalen) {
-  case 0:
-    header.DataLength = FDCAN_DLC_BYTES_0;
-    break;
-  case 1:
-    header.DataLength = FDCAN_DLC_BYTES_1;
-    break;
-  case 2:
-    header.DataLength = FDCAN_DLC_BYTES_2;
-    break;
-  case 3:
-    header.DataLength = FDCAN_DLC_BYTES_3;
-    break;
-  case 4:
-    header.DataLength = FDCAN_DLC_BYTES_4;
-    break;
-  case 5:
-    header.DataLength = FDCAN_DLC_BYTES_5;
-    break;
-  case 6:
-    header.DataLength = FDCAN_DLC_BYTES_6;
-    break;
-  case 7:
-    header.DataLength = FDCAN_DLC_BYTES_7;
-    break;
-  case 8:
-  default:
-    header.DataLength = FDCAN_DLC_BYTES_8;
-    break;
-  }
-  header.ErrorStateIndicator = FDCAN_ESI_PASSIVE;
-  header.BitRateSwitch = FDCAN_BRS_OFF;
-  header.FDFormat = FDCAN_CLASSIC_CAN;
-  header.TxEventFifoControl = FDCAN_NO_TX_EVENTS;
-
-  // HAL_FDCAN_AddMessageToTxFifoQ doesn't modify the data, but it's not marked
-  // as const for some reason.
-  uint8_t *data_nonconst = (uint8_t *)data;
-  return HAL_FDCAN_AddMessageToTxFifoQ(hcan, &header, data_nonconst);
-}
-
-HAL_StatusTypeDef ftcan_add_filter(uint16_t id, uint16_t mask) {
-  static uint32_t next_filter_no = 0;
-  static FDCAN_FilterTypeDef filter;
-  filter.IdType = FDCAN_STANDARD_ID;
-  filter.FilterIndex = next_filter_no;
-  if (filter.FilterIndex > FTCAN_NUM_FILTERS + 1) {
-    return HAL_ERROR;
-  }
-  filter.FilterType = FDCAN_FILTER_MASK;
-  filter.FilterConfig = FDCAN_FILTER_TO_RXFIFO0;
-  filter.FilterID1 = id;
-  filter.FilterID2 = mask;
-
-  HAL_StatusTypeDef status = HAL_FDCAN_ConfigFilter(hcan, &filter);
-  if (status == HAL_OK) {
-    next_filter_no++;
-  }
-  return status;
-}
-
-void HAL_FDCAN_RxFifo0Callback(FDCAN_HandleTypeDef *handle,
-                               uint32_t RxFifo0ITs) {
-  if (handle != hcan || (RxFifo0ITs & FDCAN_IT_RX_FIFO0_NEW_MESSAGE) == RESET) {
-    return;
-  }
-
-  static FDCAN_RxHeaderTypeDef header;
-  static uint8_t data[8];
-  if (HAL_FDCAN_GetRxMessage(hcan, FDCAN_RX_FIFO0, &header, data) != HAL_OK) {
-    return;
-  }
-
-  if (header.FDFormat != FDCAN_CLASSIC_CAN ||
-      header.RxFrameType != FDCAN_DATA_FRAME ||
-      header.IdType != FDCAN_STANDARD_ID) {
-    return;
-  }
-
-  size_t datalen;
-  switch (header.DataLength) {
-  case FDCAN_DLC_BYTES_0:
-    datalen = 0;
-    break;
-  case FDCAN_DLC_BYTES_1:
-    datalen = 1;
-    break;
-  case FDCAN_DLC_BYTES_2:
-    datalen = 2;
-    break;
-  case FDCAN_DLC_BYTES_3:
-    datalen = 3;
-    break;
-  case FDCAN_DLC_BYTES_4:
-    datalen = 4;
-    break;
-  case FDCAN_DLC_BYTES_5:
-    datalen = 5;
-    break;
-  case FDCAN_DLC_BYTES_6:
-    datalen = 6;
-    break;
-  case FDCAN_DLC_BYTES_7:
-    datalen = 7;
-    break;
-  case FDCAN_DLC_BYTES_8:
-    datalen = 8;
-    break;
-  default:
-    return;
-  }
-
-  ftcan_msg_received_cb(header.Identifier, datalen, data);
-}
-#endif
-
-__weak void ftcan_msg_received_cb(uint16_t id, size_t datalen,
-                                  const uint8_t *data) {}
-
-uint64_t ftcan_unmarshal_unsigned(const uint8_t **data_ptr, size_t num_bytes) {
-  if (num_bytes > 8) {
-    num_bytes = 8;
-  }
-
-  const uint8_t *data = *data_ptr;
-  uint64_t result = 0;
-  for (size_t i = 0; i < num_bytes; i++) {
-    result <<= 8;
-    result |= data[i];
-  }
-  *data_ptr += num_bytes;
-  return result;
-}
-
-int64_t ftcan_unmarshal_signed(const uint8_t **data_ptr, size_t num_bytes) {
-  if (num_bytes > 8) {
-    num_bytes = 8;
-  }
-
-  uint64_t result_unsigned = ftcan_unmarshal_unsigned(data_ptr, num_bytes);
-  // Sign extend by shifting left, then copying to a signed int and shifting
-  // back to the right
-  size_t diff_to_64 = 64 - num_bytes * 8;
-  result_unsigned <<= diff_to_64;
-  int64_t result;
-  memcpy(&result, &result_unsigned, 8);
-  return result >> diff_to_64;
-}
-
-uint8_t *ftcan_marshal_unsigned(uint8_t *data, uint64_t val, size_t num_bytes) {
-  if (num_bytes > 8) {
-    num_bytes = 8;
-  }
-
-  for (int i = num_bytes - 1; i >= 0; i--) {
-    data[i] = val & 0xFF;
-    val >>= 8;
-  }
-
-  return data + num_bytes;
-}
-
-uint8_t *ftcan_marshal_signed(uint8_t *data, int64_t val, size_t num_bytes) {
-  return ftcan_marshal_unsigned(data, val, num_bytes);
-}

Software/Core/Lib/can-halal/can-halal.h

@@ -1,71 +0,0 @@
-#ifndef CAN_HALAL_H
-#define CAN_HALAL_H
-
-// Define family macros if none are defined and we recognize a chip macro
-#if !defined(STM32F3) && !defined(STM32H7) && !defined(STM32F0)
-#if defined(STM32F302x6) || defined(STM32F302x8) || defined(STM32F302xB) ||    \
-    defined(STM32F302xC)
-#define STM32F3
-#endif
-#if defined(STM32H7A3xx)
-#define STM32H7
-#endif
-#if defined(STM32F042x6)
-#define STM32F0
-#endif
-#endif
-
-#if defined(STM32F3)
-    #include "stm32f3xx_hal.h"
-    #define FTCAN_IS_BXCAN
-    #define FTCAN_NUM_FILTERS 13
-#elif defined(STM32H7)
-    #include "stm32h7xx_hal.h"
-    #define FTCAN_IS_FDCAN
-    #ifndef FTCAN_NUM_FILTERS
-        #error "Please configure the number of filters in CubeMX, and then add a compiler define for FTCAN_NUM_FILTERS"
-    #endif
-#elif defined(STM32F0)
-    #include "stm32f0xx_hal.h"
-    #define FTCAN_IS_BXCAN
-    #define FTCAN_NUM_FILTERS 13
-#else
-    #error "Couldn't detect STM family"
-#endif
-
-#if defined(FTCAN_IS_BXCAN)
-HAL_StatusTypeDef ftcan_init(CAN_HandleTypeDef *handle);
-#elif defined(FTCAN_IS_FDCAN)
-HAL_StatusTypeDef ftcan_init(FDCAN_HandleTypeDef *handle);
-#else
-#error "Unknown CAN peripheral"
-#endif
-
-HAL_StatusTypeDef ftcan_transmit(uint16_t id, const uint8_t *data,
-                                 size_t datalen);
-
-HAL_StatusTypeDef ftcan_add_filter(uint16_t id, uint16_t mask);
-
-/**
- * Define this function to be notified of incoming CAN messages
- */
-void ftcan_msg_received_cb(uint16_t id, size_t datalen, const uint8_t *data);
-
-/**
- * Read num_bytes bytes from a message (unmarshalled network byte order). The
- * msg pointer is advanced by the corresponding number of bytes.
- *
- * Both methods return a 64-bit integer, but you can safely cast it to a smaller
- * integer type.
- */
-uint64_t ftcan_unmarshal_unsigned(const uint8_t **data, size_t num_bytes);
-int64_t ftcan_unmarshal_signed(const uint8_t **data, size_t num_bytes);
-
-/**
- * Write num_bytes to a message (marshalled in network byte order). The pointer
- * is advanced by the corresponding number of bytes and returned.
- */
-uint8_t *ftcan_marshal_unsigned(uint8_t *data, uint64_t val, size_t num_bytes);
-uint8_t *ftcan_marshal_signed(uint8_t *data, int64_t val, size_t num_bytes);
-
-#endif // CAN_HALAL_H