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; }
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; }
void PutString(char * str) { uint8_t temp; while(*str != 0) { temp= (uint8_t) *str; HAL_UART_Transmit(&huart1,&temp,1,10); str++; } }
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 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 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 */ }
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; }
/** * @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; }
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 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, ¶m, 1, TX_TIMEOUT); }
/* SendChar */ void SendChar (char letter){ aTxBuffer[0]=letter; if( HAL_UART_Transmit(&huart2,(uint8_t*)aTxBuffer, 1, 500)!= HAL_OK){ while(1){ } } }
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 } }
/* 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){ } } }
/** * @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); }
/** * @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); }
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; }
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 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); }
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++; } } }
/* 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]; }
/* 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; } }
/** * @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; }
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 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 */ }
//------------------------------------------------------------------------------ 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); } }