自学教程：C++ HAL_UART_Transmit函数代码示例

int UART_Transmit(uint8_t* data, uint16_t size){	  HAL_StatusTypeDef status = HAL_UART_Transmit(&UartHandle, data, size, 0xffff);    if (status != HAL_OK) {        //while (1);        return 0;    }    return 1;}

/*** @brief This function handles EXTI line2 interrupt.*/void EXTI2_IRQHandler(void){  /* USER CODE BEGIN EXTI2_IRQn 0 */	HAL_UART_Transmit(&huart2,"IRQexti2/n",9,100);  /* USER CODE END EXTI2_IRQn 0 */  HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_2);  /* USER CODE BEGIN EXTI2_IRQn 1 */  /* USER CODE END EXTI2_IRQn 1 */}

/*** @brief This function handles Non maskable interrupt.*/void NMI_Handler(void){  /* USER CODE BEGIN NonMaskableInt_IRQn 0 */	HAL_UART_Transmit(&huart2,"IRQnmi/n",7,100);  /* USER CODE END NonMaskableInt_IRQn 0 */  HAL_RCC_NMI_IRQHandler();  /* USER CODE BEGIN NonMaskableInt_IRQn 1 */  /* USER CODE END NonMaskableInt_IRQn 1 */}

/**  * @brief  Transmit a byte to the HyperTerminal  * @param  param The byte to be sent  * @retval HAL_StatusTypeDef HAL_OK if OK  */HAL_StatusTypeDef Serial_PutByte( uint8_t param ){  /* May be timeouted... */  if ( UartHandle.State == HAL_UART_STATE_TIMEOUT )  {    UartHandle.State = HAL_UART_STATE_READY;  }  return HAL_UART_Transmit(&UartHandle, &param, 1, TX_TIMEOUT);}

int32_t hal_uart_send(uart_dev_t *uart, const void *data, uint32_t size, uint32_t timeout){    uint32_t i;    for(i = 0; i < size; i++)    {        HAL_UART_Transmit(&huart4, (uint8_t *)(&data[i]), 1, 0xFFFF);     }    return 0;}

int armPortWrite(void* port, const void* buf, size_t nbyte){		UART_HandleTypeDef* huart = (UART_HandleTypeDef*)port;		if(HAL_UART_Transmit(huart, (uint8_t*)buf, nbyte, 100) == HAL_OK)		return nbyte;		return -1;}

/** * @brief	Funzione di trasmissione BLOCCANTE per UART. * @param	numUart: numero della periferica UART da cui trasmettere. * 			numUart deve essere precedentemente abilitata per la trasmissione previa inizializzazione * 			e può assumere uno dei seguenti valori: * 			@arg HELPER_UART1: periferica UART 1; * 			@arg HELPER_UART2: periferica UART 2. * 			@arg HELPER_UART3: periferica UART 3; * 			@arg HELPER_UART4: periferica UART 4. * 			@arg HELPER_UART5: periferica UART 5; * 			@arg HELPER_UART6: periferica UART 6. * * @param	pData:	puntatore all'area di memoria da cui leggere il valore da trasferire. * * @param	Size: dimensione del trasferimento. * @retval	Stato, che può assumere uno dei seguenti valori: * 			@arg	HELPER_UART_OK:	trasmissione avvenuta con successo; * 			@arg	HELPER_UART_ERROR:	Errore qualsiasi avvenuto durante la trasmissione. */HELPER_UART_Status_TypeDef HELPER_UART_Transmit(HELPER_UART_TypeDef numUart,uint8_t *pData,uint16_t Size){	UART_HandleTypeDef  *UartHandle_x=HELPER_UART_GetHandle(numUart);	while(HAL_UART_Transmit(UartHandle_x, pData, Size, 10000)!=HAL_OK){	if (HAL_UART_GetError(UartHandle_x) != HAL_UART_ERROR_NONE)		return  HELPER_UART_ERROR;	}	return HELPER_UART_OK;}

BaseType_t xHardwareUartTx(char* data, uint8_t data_length){    if(HAL_UART_Transmit(&UartHandle, (uint8_t*)data, data_length, USARTx_TIMEOUT) != HAL_OK)    {        vErrorWarning("UART: transmit failed");        return pdFAIL;    }    return pdPASS;}

/* SendChar */void SendChar (char letter){	aTxBuffer[0]=letter;	if(	HAL_UART_Transmit(&huart2,(uint8_t*)aTxBuffer, 1, 500)!= HAL_OK){		while(1){		}	}}

void MainTask(){		for(;;)	{		// Wait for adc result and write it to the UART connected to the PC.		osEvent result = osMessageGet(mainTaskMessageQId, osWaitForever);		HAL_UART_Transmit(&huart2, (uint8_t*)&result.value.v, 4, 100);	}}

/**  * @brief  Print a string on the HyperTerminal  * @param  p_string: The string to be printed  * @retval None  */void Serial_PutString(uint8_t *p_string){  uint16_t length = 0;  while (p_string[length] != '/0')  {    length++;  }  HAL_UART_Transmit(&UartHandle, p_string, length, TX_TIMEOUT);}

int Uart_Tx_String(char *string, uint16_t len){    HAL_StatusTypeDef status = HAL_UART_Transmit(&UartHandle, (uint8_t *)string, len, 0xFFFF);    if (status != HAL_OK) {        //while (1);        return HAL_MSP_FAIL;    }    return HAL_MSP_SUCCESS;}

void SendInt(int num){	uint8_t array[5];	array[0]=num>>24;	array[1]=num>>16;	array[2]=num>>8;	array[3]=num;	array[4]='/n';	HAL_UART_Transmit(&UartResultHandle,array,5,5);}

int main(void) {  char msg[20];  HAL_Init();  Nucleo_BSP_Init();  /* Before we can access to every register of the PWR peripheral we must enable it */  __HAL_RCC_PWR_CLK_ENABLE();  while (1) {    if(__HAL_PWR_GET_FLAG(PWR_FLAG_SB)) {      /* If standby flag set in PWR->CSR, then the reset is generated from       * the exit of the standby mode */      sprintf(msg, "RESET after STANDBY mode/r/n");      HAL_UART_Transmit(&huart2, (uint8_t*)msg, strlen(msg), HAL_MAX_DELAY);      /* We have to explicitly clear the flag */      __HAL_PWR_CLEAR_FLAG(PWR_FLAG_WU|PWR_FLAG_SB);    }    sprintf(msg, "MCU in run mode/r/n");    HAL_UART_Transmit(&huart2, (uint8_t*)msg, strlen(msg), HAL_MAX_DELAY);    while(HAL_GPIO_ReadPin(GPIOC, GPIO_PIN_13) == GPIO_PIN_SET) {      HAL_GPIO_TogglePin(LD2_GPIO_Port, LD2_Pin);      HAL_Delay(100);    }    HAL_Delay(200);    sprintf(msg, "Entering in SLEEP mode/r/n");    HAL_UART_Transmit(&huart2, (uint8_t*)msg, strlen(msg), HAL_MAX_DELAY);    SleepMode();    sprintf(msg, "Exiting from SLEEP mode/r/n");    HAL_UART_Transmit(&huart2, (uint8_t*)msg, strlen(msg), HAL_MAX_DELAY);    while(HAL_GPIO_ReadPin(GPIOC, GPIO_PIN_13) == GPIO_PIN_SET);    HAL_Delay(200);    sprintf(msg, "Entering in STOP mode/r/n");    HAL_UART_Transmit(&huart2, (uint8_t*)msg, strlen(msg), HAL_MAX_DELAY);    StopMode();    sprintf(msg, "Exiting from STOP mode/r/n");    HAL_UART_Transmit(&huart2, (uint8_t*)msg, strlen(msg), HAL_MAX_DELAY);    while(HAL_GPIO_ReadPin(GPIOC, GPIO_PIN_13) == GPIO_PIN_SET);    HAL_Delay(200);    sprintf(msg, "Entering in STANDBY mode/r/n");    HAL_UART_Transmit(&huart2, (uint8_t*)msg, strlen(msg), HAL_MAX_DELAY);    StandbyMode();    while(1); //Never arrives here, since MCU is reset when exiting from STANDBY  }}

/**  * @brief  Send a message via UART  * @param  Msg the pointer to the message to be sent  * @retval None  */void UART_SendMsg(TMsg *Msg){  uint16_t CountOut;    CHK_ComputeAndAdd(Msg);    CountOut = ByteStuffCopy((uint8_t*) UART_TxBuffer, Msg);    HAL_UART_Transmit(&UartHandle, (uint8_t*)UART_TxBuffer, CountOut, 5000);}

void uartsent(int mode){uint32_t c;if (mode!=CMD_INTERACTIVE) return;fetch_uint32_arg(&c);USARTTxBuffer[0]=c;printf("sending a character/n");HAL_UART_Transmit(&UartHandle,USARTTxBuffer,1,1000);}

/* SendStr */void SendStr (char* stringToSend){	int i = strlen(stringToSend);	strcpy((char *)aTxBuffer,stringToSend);	if(	HAL_UART_Transmit(&huart2, (uint8_t*)aTxBuffer, i,500)!= HAL_OK){    while(1){    }  }}

static unsigned char uart_stm32_poll_out(struct device *dev,					unsigned char c){	struct uart_stm32_data *data = DEV_DATA(dev);	UART_HandleTypeDef *UartHandle = &data->huart;	HAL_UART_Transmit(UartHandle, (uint8_t *)&c, 1, TIMEOUT);	return c;}

void uart1Init(){	Uart1Handle.Instance = USART1;		Uart1Handle.Init.BaudRate     = 57600;  Uart1Handle.Init.WordLength   = UART_WORDLENGTH_8B;  Uart1Handle.Init.StopBits     = UART_STOPBITS_1;  Uart1Handle.Init.Parity       = UART_PARITY_NONE;  Uart1Handle.Init.HwFlowCtl    = UART_HWCONTROL_NONE;  Uart1Handle.Init.Mode         = UART_MODE_TX_RX;  Uart1Handle.Init.OverSampling = UART_OVERSAMPLING_16;  if(HAL_UART_Init(&Uart1Handle) != HAL_OK)  {    while(1);  }	HAL_UART_Transmit(&Uart1Handle, change_rate, sizeof(change_rate), 0xff);	HAL_Delay(10);	HAL_UART_Transmit(&Uart1Handle, change_rate, sizeof(change_rate), 0xff);}

void DoubleUart_transmit(uint32_t buffer[],uint32_t buffer2[]){	int i = 0;	int count = 0;	char tempbuffer[50] = {"Empty.."};	uint32_t twaalfbit = 4095;	//int acht = 8;	for(i=0; i<ADC_BUFFER_LENGTH;i++)	{		  buffer[i] &= twaalfbit;		  sprintf(tempbuffer,"pin a1: %05d   ",(int) buffer[i]);		  HAL_UART_Transmit(&huart6,(uint8_t*) tempbuffer,strlen(tempbuffer),HAL_MAX_DELAY);		  HAL_UART_Transmit(&huart6,(uint8_t*)"       ",strlen("       "),HAL_MAX_DELAY);		  buffer2[i] &= twaalfbit;		  sprintf(tempbuffer,"pin a2: %05d   ",(int) buffer2[i]);		  HAL_UART_Transmit(&huart6,(uint8_t*) tempbuffer,strlen(tempbuffer),HAL_MAX_DELAY);		  HAL_UART_Transmit(&huart6,(uint8_t*)"/r/n",strlen("/r/n"),HAL_MAX_DELAY);	}	HAL_UART_Transmit(&huart6,(uint8_t*)"/r/n",strlen("/r/n"),HAL_MAX_DELAY);}

/* GetChar */char GetChar (void){  //char retChar;	if(HAL_UART_Receive(&huart2, (uint8_t*)aRxBuffer, 1,60000)!=HAL_OK){		while(1){		}	}	HAL_UART_Transmit(&huart2, (uint8_t*)aRxBuffer, 1, 10000) ;	return aRxBuffer[0];}

void SendStr (char* stringToSend){  int i = strlen(stringToSend);  int n = 0;  strcpy((char *)aTxBuffer,stringToSend);  if(	HAL_UART_Transmit(&huart2, (uint8_t*)aTxBuffer, i, 500)!= HAL_OK){    while(1){      if( stringToSend[n]=='/0' ) break;      n++;    }  }}

void PutString(char * str){	uint8_t temp;	  while(*str != 0)  {		temp= (uint8_t) *str;			HAL_UART_Transmit(&huart1,&temp,1,10);    str++;  }}

/* StartDefaultTask function */void StartLaserTask(void const * argument){	uint8_t in[6];	in[0] = '0';	uint8_t * nl = "/n/r";	uint8_t inSize;	HAL_StatusTypeDef status;	double distance = 0; //(debug) was volatile	// LEDs	HAL_GPIO_WritePin(LED01P, LED01, GPIO_PIN_RESET);	HAL_GPIO_WritePin(LED11P, LED11, GPIO_PIN_RESET);	HAL_GPIO_WritePin(LED21P, LED21, GPIO_PIN_RESET);  /* Infinite loop */	for(;;)	{		if(HAL_UART_Transmit(&huart1, &in[0], 1, 1000) == HAL_OK)// send request		{			// Receive			for (inSize = 0; inSize < 7; inSize++)	// max = 25.00/n/r			{				HAL_UART_Receive(&huart1, &in[inSize], 1, 0xFFFF);				if(in[inSize] == '/n')	break;			}	  	// Send result to PC (opt)	  	HAL_UART_Transmit(&huart2, (uint8_t *)in, inSize-1, 0x1000);	  	strToUART(nl);	// makes debugging prettier	  	distance = atof(in);		}		// Process result		if(distance < 0.3048)			laserOut_1ft();		else if(distance < 0.6096)	laserOut_2ft();		else if(distance < 0.9144)	laserOut_3ft();		else							laserOut_safe();		// delay before checking again to save precious battery life		osDelay(150);  }}

/*#####################################################*/void _UARTCharPut(unsigned int BaseAddr, unsigned char byteTx){	Uart_t* UartSettings = (Uart_t *)BaseAddr;#if (USE_DRIVER_SEMAPHORE == true)	while(uart_semaphore[UartSettings->UartNr]);	uart_semaphore[UartSettings->UartNr] = true;#endif	HAL_UART_Transmit(UartSettings->udata, &byteTx, 1, 10);#if (USE_DRIVER_SEMAPHORE == true)	uart_semaphore[UartSettings->UartNr] = false;#endif}

/** * One of the newlib system call function used for printf(). In this project * ::_write() is implemented using HAL's ::HAL_UART_Transmit(). * @param file * @param ptr * @param len * @return */int _write(int32_t file, uint8_t *ptr, int32_t len) {  HAL_StatusTypeDef result;  result = HAL_UART_Transmit(&xUARTHandle, ptr, (uint16_t)len, 500);  if (result == HAL_OK)    {      return len;    }  else    {      return 0;    }}

int BrcmConsolePrintf(const char * fmt, ...){	 char buffer[256];    va_list ap;    va_start(ap, fmt);    vsprintf(buffer, fmt, ap);    va_end(ap);    HAL_UART_Transmit(&UartHandle, (uint8_t *)buffer, strlen(buffer), 2000);		return 0;}

/**  * @brief  Retargets the C library printf function to the USART.  * @param  None  * @retval None  */int fputc(int ch, FILE *f){    /* Place your implementation of fputc here */    /* e.g. write a character to the EVAL_COM1 and Loop until the end of transmission */    HAL_StatusTypeDef status = HAL_UART_Transmit(&UartHandle, (uint8_t *)&ch, 1, 0xFFFF);    if (status != HAL_OK) {        //while (1);        return 0;    }    return ch;}

//------------------------------------------------------------------------------void TaskTerminal(void*  NOTUSED(arg)){    static const char* msg = "Hello world/r/n";        for (;;) {        //HAL_UART_Transmit_IT(&uart1Handle, (uint8_t*)msg, 13);      HAL_UART_Transmit(&uart1Handle, (uint8_t*)msg, 13, 10000);      //HAL_GPIO_WritePin(GPIOC, LED_GREEN, 1);      vTaskDelay(8000);      //HAL_GPIO_WritePin(GPIOC, LED_GREEN, 0);      //vTaskDelay(4000);    }}

/**  * @brief  This function is executed in case of error occurrence.  * @param  None  * @retval None  */void _Error_Handler(char * file, int line){  /* USER CODE BEGIN Error_Handler_Debug */    /* User can add his own implementation to report the HAL error return state */    char buffer[80];    sprintf(buffer, "Error: %d/n", line);    HAL_UART_Transmit(&huart1, (uint8_t*) buffer, strlen(buffer), 5000);    while (1) {        HAL_GPIO_TogglePin(GPIOA, LED_Pin);        HAL_Delay(100);    }  /* USER CODE END Error_Handler_Debug */ }