UART not sending correct data in STM32

Your code sends a byte from address 60.

What you likely want to do here is send a byte from the address of your buffer variable, where 60 is stored, to send 60.

In your code, you have a line where you send a byte to the UART to be transmitted:

HAL_UART_Transmit_IT(&huart1,(uint8_t*)buffer[0],1);

In the middle of that line, you have a "type-cast": (uint8_t*). Why did you put that there? Did the compiler give you a message telling you that it was expecting a different kind of variable?

A uint8_t * is a pointer to a uint8_t, in other words, it is the address of a byte - that's what the HAL_UART_Transmit_IT function wants - the address of the thing you want to send (not the thing itself).
By casting your buffer[0] like that, you're telling the compiler to take the value of buffer[0] and treat it as an address (pointer), even though it really isn't one.

What you should have done is take the address of buffer[0] and given that to the HAL_UART_Transmit_IT function instead, using:

HAL_UART_Transmit_IT(&huart1, &buffer[0], 1);

Assuming the type of buffer is uint32_t[], depending on the endianness, you may try

uint8_t val = buffer[0];

or

uint8_t val = buffer[0] >> 24;

and then

HAL_UART_Transmit_IT(&huart1,&val,1);

To send data through UART1 on an STM32F429 microcontroller using the current Hardware Abstraction Layer (HAL), you can use the following steps:

1. Configure the UART1 peripheral by using the HAL_UART_Init function. This function takes a pointer to a UART_HandleTypeDef structure as an argument. You will need to fill in the fields of this structure with the appropriate configuration values for the UART1 peripheral.
2. Once the UART1 peripheral is configured, you can send data through it by using the HAL_UART_Transmit function. This function takes a pointer to a UART_HandleTypeDef structure, a pointer to the data buffer, and the length of the data to be transmitted as arguments.
3. If you want to receive data through UART1, you can use the HAL_UART_Receive function. This function takes a pointer to a UART_HandleTypeDef structure, a pointer to a buffer to store the received data, and the length of the data to be received as arguments.

Here is an example of how you might use these functions in your code:

#include "stm32f4xx_hal.h"

UART_HandleTypeDef huart1;
uint8_t txData[] = "Hello World!";
uint8_t rxData[20];

int main(void)
{
  // Initialize the UART1 peripheral
  huart1.Instance = USART1;
  huart1.Init.BaudRate = 115200;
  huart1.Init.WordLength = UART_WORDLENGTH_8B;
  huart1.Init.StopBits = UART_STOPBITS_1;
  huart1.Init.Parity = UART_PARITY_NONE;
  huart1.Init.Mode = UART_MODE_TX_RX;
  huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
  huart1.Init.OverSampling = UART_OVERSAMPLING_16;
  if (HAL_UART_Init(&huart1) != HAL_OK)
  {
    // Error handling
  }

  // Transmit data through UART1
  if (HAL_UART_Transmit(&huart1, txData, sizeof(txData), 1000) != HAL_OK)
  {
    // Error handling
  }

  // Receive data through UART1
  if (HAL_UART_Receive(&huart1, rxData, sizeof(rxData), 1000) != HAL_OK)
  {
    // Error handling
  }

  return 0;
}

Note that the HAL_UART_Init, HAL_UART_Transmit, and HAL_UART_Receive functions all return a status code (HAL_OK if the operation was successful, or HAL_ERROR if there was an error). It is important to check the return value of these functions and handle any errors appropriately in your code.