modular-kbd/firmware/components/CAN/CAN-B/Src/main.c

/*
Sub-module CAN. Sends data to the master (CAN-A)
*/

#include "main.h"
#include "can.h"
#include "usb_device.h"
#include "usbd_cdc_if.h"
#include "string.h"
#include "gpio.h"

void SystemClock_Config(void);

CAN_TxHeaderTypeDef TxHeader;
CAN_RxHeaderTypeDef RxHeader;

uint8_t TxData[8]; //Buffer for output data
uint8_t RxData[8]; //Buffer for input data (probably will never get used)

//Think of this as a location that will hold the pending data to send untill its ready.
uint32_t TxMailbox; 

/**
  * @brief  The application entry point.
  * @retval int
  */
int main(void)
{


  HAL_Init();
  SystemClock_Config();

  /*
    FIXME: USB CDC would be super useful in debugging. This might be also
    Related to doing the USB HID since there are something going on with the
    USB not getting detected on my device properly

    At the mmoment, I'm getting device "address not responding" error using dmesg } grep usb
    Some searching up hints that this is a common problem with Bluepills but because BP comes from many
    Manufacturers its pretty hard to track it down to one problem. Can't find the schematic for ours too
    The problem seems to be related to the resistor on the DP+ and DP- on the USB

    Either that or we got a counterfiet STM32 board. I'll test it with a reputable brand to see. Other functionalities work though
  */
  /* USER CODE BEGIN SysInit */
  GPIO_InitTypeDef USB_RESISTOR = {0};
  USB_RESISTOR.Pin = GPIO_PIN_12;
  USB_RESISTOR.Mode = GPIO_MODE_OUTPUT_OD;
  USB_RESISTOR.Pull = GPIO_NOPULL;
  HAL_GPIO_Init(GPIOA,&USB_RESISTOR);

  //Force Reset USB
  HAL_GPIO_WritePin(GPIOA, GPIO_PIN_12, GPIO_PIN_RESET);
  HAL_Delay(50);
  HAL_GPIO_WritePin(GPIOA, GPIO_PIN_12, GPIO_PIN_SET);
  
  MX_GPIO_Init();
  MX_CAN_Init();
  
  //Enables an interrupt when a data is recieved. 
  //This includes your own data you sent so this is when filters comes to play
  HAL_CAN_ActivateNotification(&hcan, CAN_IT_RX_FIFO0_MSG_PENDING);

  HAL_CAN_Start(&hcan);

  TxHeader.DLC = 1; //The lenght of data to send (in bytes)
  TxHeader.ExtId = 0; //The ext. ID of the device
  TxHeader.IDE = CAN_ID_STD; //No need for us to use ext. ID
  TxHeader.RTR = CAN_RTR_DATA; //We are sending data...
  TxHeader.StdId = 0x100; //The ID of this module is now 100. Any devices with a filter matching this ID would read it
  TxHeader.TransmitGlobalTime = DISABLE; 

  //Sample message send
  TxData[0] = 0xf1;  

  MX_USB_DEVICE_Init();

  while (1)
  {
    HAL_CAN_AddTxMessage(&hcan, &TxHeader, TxData, &TxMailbox);
    HAL_Delay(1000);
  }

}

void HAL_CAN_RxFifo0MsgPendingCallback(CAN_HandleTypeDef *hcan)
{
  //Read message from the RxCAN and store it on RxHeader
  HAL_CAN_GetRxMessage(hcan, CAN_RX_FIFO0, &RxHeader, RxData);
  HAL_GPIO_TogglePin(GPIOC, GPIO_PIN_13);
  char *buf = RxData[0];
  CDC_Transmit_FS((uint8_t *)buf,strlen(buf));
}

/**
  * @brief System Clock Configuration
  * @retval None
  */
void SystemClock_Config(void)
{
  RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
  RCC_PeriphCLKInitTypeDef PeriphClkInit = {0};

  /** Initializes the RCC Oscillators according to the specified parameters
  * in the RCC_OscInitTypeDef structure.
  */
  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
  RCC_OscInitStruct.HSEState = RCC_HSE_ON;
  RCC_OscInitStruct.HSEPredivValue = RCC_HSE_PREDIV_DIV1;
  RCC_OscInitStruct.HSIState = RCC_HSI_ON;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
  RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL6;
  if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
  {
    Error_Handler();
  }

  /** Initializes the CPU, AHB and APB buses clocks
  */
  RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
                              |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV2;
  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;

  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_1) != HAL_OK)
  {
    Error_Handler();
  }
  PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_USB;
  PeriphClkInit.UsbClockSelection = RCC_USBCLKSOURCE_PLL;
  if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit) != HAL_OK)
  {
    Error_Handler();
  }
}

/* USER CODE BEGIN 4 */

/* USER CODE END 4 */

/**
  * @brief  This function is executed in case of error occurrence.
  * @retval None
  */
void Error_Handler(void)
{
  /* USER CODE BEGIN Error_Handler_Debug */
  /* User can add his own implementation to report the HAL error return state */
  __disable_irq();
  while (1)
  {
  }
  /* USER CODE END Error_Handler_Debug */
}

#ifdef  USE_FULL_ASSERT
/**
  * @brief  Reports the name of the source file and the source line number
  *         where the assert_param error has occurred.
  * @param  file: pointer to the source file name
  * @param  line: assert_param error line source number
  * @retval None
  */
void assert_failed(uint8_t *file, uint32_t line)
{
  /* USER CODE BEGIN 6 */
  /* User can add his own implementation to report the file name and line number,
     ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
  /* USER CODE END 6 */
}
#endif /* USE_FULL_ASSERT */