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);
}
}
