Angle (Magnetic sensor) Forum Discussions

Dear Sir,

I checked the TLE5501 kit the Sinx(V), Cosx(V) show 0~3.3V ，can it be set 0~5V? thanks.

(Reposting in the correct forum)

I'm using the TLE5012B over SPI(SSC) with the STM32H503CB microcontroller. I found the Arduino library here (https://github.com/Infineon/TLE5012-Magnetic-Angle-Sensor/tree/master) and found that by implementing the Platform Abstraction Layer, I could get the same functionality on any microcontroller, so I went ahead and began work on that for the above microcontroller. Primarily, I implemented the SPI sendReceive function, and tested that I could get angles correctly. Since I have the sensor mounted on the back of a motor with a magnet, I verified that rotating the magnet gets me fairly accurate readings to around 0.1 degrees.

Where I'm having issue is the CRC and safety word, but before worrying about the CRC, I noticed that the STAT nibble returned is not all 1s like it should be in the datasheet. The library calls this an INVALID_ANGLE_ERROR, but who knows if that's the issue.

I tried with a more deterministic example than reading an angle, and tried to follow exactly the example given in 5.2.4 on the CRC, where I tried to enable prediction. This involves sending the command "write to mod 2", which is 0x5081, and then the data "enable prediction", which is 0x0804. I expect only the safety word as a response. I got back the following safety word: 0xef13, or 0b1110111100010011. Now notice that the first three bits are 1, but the fourth is 0, hence the INVALID_ANGLE_ERROR response. You may also notice that the CRC is wrong ( it is supposed to be 0x89, not 0x13).

This has me stumped, since by all metrics the angle readings are coming back very accurately. I have evidence that I can write to the chip since I have been able to set the filter settings in MOD1 and noticed a significant decrease in the spread (min-max values when not moving the magnet).

I attached my entire stm32 project for completeness, but I'll try to put what I believe to be the most relevant information here.

Below is my "sendReceive" function, which is the core function used by the library to talk over SSC with the sensor.

// This function is used by the library (and me) to talk to the TLE5012B over SSC. It sends sent_data and waits for the sensor 130ns and then receives a response of a given length.
SPIC::Error_t SPIC::sendReceive(uint16_t* sent_data, uint16_t size_of_sent_data, uint16_t* received_data, uint16_t size_of_received_data){

	uint8_t conv_sent_data[2*size_of_sent_data];
	uint8_t conv_received_data[2*size_of_received_data];
    for (int i = 0; i < size_of_sent_data; i++) {
    	conv_sent_data[i * 2] = (uint8_t)sent_data[i] & 0xFF;           // Low byte
    	conv_sent_data[i * 2 + 1] = ((uint8_t) (sent_data[i] >> 8)) & 0xFF;     // High byte
    }

	HAL_GPIO_WritePin(GPIOB, GPIO_PIN_0, GPIO_PIN_RESET);
	HAL_SPI_Transmit(this->spi, conv_sent_data, size_of_sent_data, 100);
	// Wait the required t_wr period
	for (int i = 0; i < 32; i++){
		asm("NOP");
	}
	HAL_SPI_Receive(this->spi, conv_received_data, size_of_received_data, 100);
	HAL_GPIO_WritePin(GPIOB, GPIO_PIN_0, GPIO_PIN_SET);

	for (int i = 0; i < size_of_received_data; i++) {
    	received_data[i] = (conv_received_data[i * 2 + 1] <<  | conv_received_data[i * 2];
    }

	return OK;
}

Here I am trying to replicate the safety word response from the datasheet:

// This is copied from the user manual, 5.2.4
uint16_t write_to_mod2 = 0x5081; // Write to the mod2 register
uint16_t enable_prediction = 0x0804;
uint16_t set_prediction_data[2] = {write_to_mod2, enable_prediction};
uint16_t get_prediction_safety;
spic.sendReceive(set_prediction_data, 2, &get_prediction_safety, 1);
// The result, placed in get_prediction_safety, here has the wrong status and CRC values.
// Result here: 0xEF13
// Expected result: 0xFE89

Here is my SPI initialization function. I thought that this was all good since I could read angles from the sensor, but maybe I configured something wrong here?

/**
  * @brief SPI2 Initialization Function
  * @param None
  * @retval None
  */
static void MX_SPI2_Init(void)
{

  /* USER CODE BEGIN SPI2_Init 0 */

  /* USER CODE END SPI2_Init 0 */

  /* USER CODE BEGIN SPI2_Init 1 */

  /* USER CODE END SPI2_Init 1 */
  /* SPI2 parameter configuration*/
  hspi2.Instance = SPI2;
  hspi2.Init.Mode = SPI_MODE_MASTER;
  hspi2.Init.Direction = SPI_DIRECTION_1LINE;
  hspi2.Init.DataSize = SPI_DATASIZE_16BIT;
  hspi2.Init.CLKPolarity = SPI_POLARITY_HIGH;
  hspi2.Init.CLKPhase = SPI_PHASE_1EDGE;
  hspi2.Init.NSS = SPI_NSS_SOFT;
  hspi2.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_32;
  hspi2.Init.FirstBit = SPI_FIRSTBIT_MSB;
  hspi2.Init.TIMode = SPI_TIMODE_DISABLE;
  hspi2.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
  hspi2.Init.CRCPolynomial = 0x7;
  hspi2.Init.NSSPMode = SPI_NSS_PULSE_DISABLE;
  hspi2.Init.NSSPolarity = SPI_NSS_POLARITY_LOW;
  hspi2.Init.FifoThreshold = SPI_FIFO_THRESHOLD_01DATA;
  hspi2.Init.MasterSSIdleness = SPI_MASTER_SS_IDLENESS_00CYCLE;
  hspi2.Init.MasterInterDataIdleness = SPI_MASTER_INTERDATA_IDLENESS_00CYCLE;
  hspi2.Init.MasterReceiverAutoSusp = SPI_MASTER_RX_AUTOSUSP_DISABLE;
  hspi2.Init.MasterKeepIOState = SPI_MASTER_KEEP_IO_STATE_DISABLE;
  hspi2.Init.IOSwap = SPI_IO_SWAP_DISABLE;
  hspi2.Init.ReadyMasterManagement = SPI_RDY_MASTER_MANAGEMENT_INTERNALLY;
  hspi2.Init.ReadyPolarity = SPI_RDY_POLARITY_HIGH;
  if (HAL_SPI_Init(&hspi2) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN SPI2_Init 2 */

  /* USER CODE END SPI2_Init 2 */

}

Below are the relevant schematic snippets, basically just showing how the sensor is connected to the microcontroller. Hopefully nothing exciting there.

In case anyone is curious, I tried scaling down the BAUD rate to 976.562kbps (originally it was around 7.8Mbps), with no change. I thought anything under 8Mbps should work, but the datasheet wasn't super clear (it just said 8Mbps typical, with no min or max values).

That's all of the relevant bits I think.

Max