Пример #1
2
void printWelcomeMessage(void) {
  char *strings[] = {"\033[0;0H", "\033[2J", WELCOME_MSG, MAIN_MENU, PROMPT};

  for (uint8_t i = 0; i < 5; i++) {
    HAL_UART_Transmit_IT(&huart2, (uint8_t*)strings[i], strlen(strings[i]));
    while (HAL_UART_GetState(&huart2) == HAL_UART_STATE_BUSY_TX || HAL_UART_GetState(&huart2) == HAL_UART_STATE_BUSY_TX_RX);
  }
}
Пример #2
0
uint16_t FillTxBuffer(const uint8_t *buffer, uint16_t count)
{
	uint8_t				irqEnabled = __get_PRIMASK() == 0;
	HAL_StatusTypeDef	st;
	uint16_t   			free, freestart, tocopy, copied = 0;

	UNUSED(st);

	__disable_irq();
	freestart = g_txStart + g_txCount;
	free = g_size - g_txCount;
	EnableIrq(irqEnabled);

	freestart -= (freestart >= g_size) ? g_size : 0;
	if(count > free) count = free;
	tocopy = freestart + count > g_size ? g_size - freestart : count;

	memcpy(g_buffer + freestart, buffer, tocopy);

	__disable_irq();
	if(!g_txCount) {
		EnableIrq(irqEnabled);
		g_chunkSize = tocopy;
		st = HAL_UART_Transmit_IT(g_huart, g_buffer + freestart, tocopy);
	}
	copied = tocopy;
	count -= tocopy;
	__disable_irq();
	g_txCount += tocopy;
	EnableIrq(irqEnabled);

	if(!count)
		return copied;

	buffer += tocopy;
	memcpy(g_buffer, buffer, count);

	uint8_t schedule;
	__disable_irq();
	schedule = !g_txCount;
	g_txCount += count;
	EnableIrq(irqEnabled);

	if(schedule)	//	unlikely corner case
		st = HAL_UART_Transmit_IT(g_huart, g_buffer, count);

	return copied + count;
}
Пример #3
0
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
	if(Rx_Data[0] != 59) // 받은 문자가 ';'이 아니면
	{
		if(Buffer_idx >= MAX_BUFFER_SIZE) // 수신버퍼의 사이즈가 5가 넘으면
		{
			Buffer_idx = 0;					// 버퍼인덱스도 0부터 시작
			for(int i = 0; i<MAX_BUFFER_SIZE; i++)
				Rx_Buffer[i] = '\0';
		}
		Rx_Buffer[Buffer_idx] = Rx_Data[0];	// 수신데이터를 버퍼에 처넣음		
		Buffer_idx++;
		HAL_UART_Receive_IT(&huart1, (uint8_t *)Rx_Data, 1); // 다시 받을 준비
	}
	else // ';'을 받으면
	{	
		char temp[50];
		sprintf(temp, "Rx_Data : %c\tBuffer : %s\tBuffer_Idx : %d\n", Rx_Data[0], Rx_Buffer, Buffer_idx);
		
		Buffer_idx = 0;		// 버퍼 초기화			
			for(int i = 0; i<MAX_BUFFER_SIZE; i++)
				Rx_Buffer[i] = '\0'; // 버퍼 초기화		
		HAL_UART_Transmit_IT(&huart1, (uint8_t *)temp, 50);
	}
}
Пример #4
0
uint8_t UART_Transmit(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t len) {
  if(HAL_UART_Transmit_IT(huart, pData, len) != HAL_OK) {
    if(RingBuffer_Write(&txBuf, pData, len) != RING_BUFFER_OK)
      return 0;
  }
  return 1;
}
Пример #5
0
/**
  * @brief  Transmite informaçao pela UART com IT
  * @param  huart: apontador para estrutura UART_HandleTypeDef que tem informaçºao sobre as 
	*                configuraçoes do modulo de UART
  * @param  data: apontador para buffer de informaçao a enviar
  * @param  Size: tamanho de informaçºao a enviar
  * @retval HAL status (HAL_OK , HAL_ERROR , HAL_BUSY)
  */
HAL_StatusTypeDef Lib_UART_Transmit_IT(UART_HandleTypeDef *huart, uint8_t * data, uint16_t Size)
{
	HAL_StatusTypeDef result;
  result = HAL_UART_Transmit_IT(huart, data , Size );
	
  return result;
}
Пример #6
0
/**
 * @brief	Transmit data
 * @param	Data: Pointer to the buffer to send
 * @param	Size: Size of the buffer
 * @retval	None
 */
void rs232Transmit(uint8_t* Data, uint32_t Size)
{
	/* Make sure the UART is available */
	if (Size != 0 && xSemaphoreTake(xSemaphore, 100) == pdTRUE)
	{
		HAL_UART_Transmit_IT(&UART_Handle, Data, Size);
	}
}
Пример #7
0
/**
  * @brief  CDC_Receive_FS
  *         Data received over USB OUT endpoint are sent over CDC interface 
  *         through this function.
  *           
  *         @note
  *         This function will block any OUT packet reception on USB endpoint 
  *         untill exiting this function. If you exit this function before transfer
  *         is complete on CDC interface (ie. using DMA controller) it will result 
  *         in receiving more data while previous ones are still not sent.
  *                 
  * @param  Buf: Buffer of data to be received
  * @param  Len: Number of data received (in bytes)
  * @retval Result of the operation: USBD_OK if all operations are OK else USBD_FAIL
  */
static int8_t CDC_Receive_FS (uint8_t* Buf, uint32_t *Len)
{
  /* USER CODE BEGIN 6 */
  USBD_CDC_SetRxBuffer(hUsbDevice_0, &Buf[0]);
  USBD_CDC_ReceivePacket(hUsbDevice_0);
	HAL_UART_Transmit_IT(&huart2, Buf, *Len);
  return (USBD_OK);
  /* USER CODE END 6 */ 
}
Пример #8
0
int serial_tx_asynch(serial_t *obj, const void *tx, size_t tx_length, uint8_t tx_width, uint32_t handler, uint32_t event, DMAUsage hint)
#endif
{
    // DMA usage is currently ignored
    (void) hint;
    
    // Check buffer is ok
    MBED_ASSERT(tx != (void*)0);
    MBED_ASSERT(tx_width == 8); // support only 8b width

    if (tx_length == 0) return 0;
  
    // Set up buffer
    h_serial_tx_buffer_set(obj, (void *)tx, tx_length, tx_width);
  
    // Set up events
    h_serial_tx_enable_event(obj, SERIAL_EVENT_TX_ALL, 0); // Clear all events
    h_serial_tx_enable_event(obj, event, 1); // Set only the wanted events
  
    UART_HandleTypeDef *handle = &UartHandle[SERIAL_OBJ(index)];
    // Enable interrupt
    IRQn_Type irqn = h_serial_get_irq_index(obj);
    NVIC_ClearPendingIRQ(irqn);
    NVIC_DisableIRQ(irqn);
    NVIC_SetPriority(irqn, 1);
    NVIC_SetVector(irqn, (uint32_t)handler);
    NVIC_EnableIRQ(irqn);

#if DEVICE_SERIAL_ASYNCH_DMA
    // Enable DMA interrupt
    irqn = h_serial_tx_get_irqdma_index(obj);
    NVIC_ClearPendingIRQ(irqn);
    NVIC_DisableIRQ(irqn);
    NVIC_SetPriority(irqn, 1);
    NVIC_SetVector(irqn, (uint32_t)handler);
    NVIC_EnableIRQ(irqn);

    // the following function will enable program and enable the DMA transfer
    if (HAL_UART_Transmit_DMA(handle, (uint8_t*)tx, tx_length) != HAL_OK)
    {
      /* Transfer error in transmission process */
      return 0;
    }
#else
    // the following function will enable UART_IT_TXE and error interrupts
    if (HAL_UART_Transmit_IT(handle, (uint8_t*)tx, tx_length) != HAL_OK)
    {
      /* Transfer error in transmission process */
      return 0;
    }
#endif

    DEBUG_PRINTF("UART%u: Tx: 0=(%u, %u) %x\n", obj->serial.module+1, tx_length, tx_width, HAL_UART_GetState(handle));

    return tx_length;
}
Пример #9
0
/**
 * @brief
 * @param   None
 * @retval  None
 */
void UART1_SendByte(uint8_t Byte)
{
  /*
   * We need to save the Byte to send in a variable here as the HAL_UART saves
   * a pointer to the variable. If we had used Byte directly it would save a
   * pointer to the register where Byte is stored temporarily.
   */
  static uint8_t temp = 0;
  temp = Byte;
  HAL_UART_Transmit_IT(&UART_Handle, &temp, 1);
}
Пример #10
0
/** Begin asynchronous TX transfer. The used buffer is specified in the serial object,
 *  tx_buff
 *
 * @param obj       The serial object
 * @param tx        The buffer for sending
 * @param tx_length The number of words to transmit
 * @param tx_width  The bit width of buffer word
 * @param handler   The serial handler
 * @param event     The logical OR of events to be registered
 * @param hint      A suggestion for how to use DMA with this transfer
 * @return Returns number of data transfered, or 0 otherwise
 */
int serial_tx_asynch(serial_t *obj, const void *tx, size_t tx_length, uint8_t tx_width, uint32_t handler, uint32_t event, DMAUsage hint)
{
  
    // Check buffer is ok
    MBED_ASSERT(tx != (void*)0);
    MBED_ASSERT(tx_width == 8); // support only 8b width

    if (tx_length == 0) return 0;
  
    // Set up buffer
    h_serial_tx_buffer_set(obj, (void *)tx, tx_length, tx_width);
  
    // Set up events
    h_serial_tx_enable_event(obj, SERIAL_EVENT_TX_ALL, 0); // Clear all events
    h_serial_tx_enable_event(obj, event, 1); // Set only the wanted events
  
    // Enable interrupt
    IRQn_Type irqn = h_serial_get_irq_index(obj);
    NVIC_ClearPendingIRQ(irqn);
    NVIC_DisableIRQ(irqn);
    NVIC_SetPriority(irqn, 1);
    NVIC_SetVector(irqn, (uint32_t)handler);
    UartHandle.Instance = (USART_TypeDef *)SERIAL_OBJ(uart);
    NVIC_EnableIRQ(irqn);

#if DEVICE_SERIAL_ASYNCH_DMA
    // Enable DMA interrupt
    irqn = h_serial_tx_get_irqdma_index(obj);
    NVIC_ClearPendingIRQ(irqn);
    NVIC_DisableIRQ(irqn);
    NVIC_SetPriority(irqn, 1);
//    NVIC_SetVector(irqn, (uint32_t)&h_serial_txdma_irq_handler_asynch);
    NVIC_SetVector(irqn, (uint32_t)handler);
    NVIC_EnableIRQ(irqn);

    // the following function will enable program and enable the DMA transfer
    if (HAL_UART_Transmit_DMA(&UartHandle, (uint8_t*)tx, tx_length) != HAL_OK)
    {
      /* Transfer error in transmission process */
      return 0;
    }
#else
    // the following function will enable UART_IT_TXE and error interrupts
    if (HAL_UART_Transmit_IT(&UartHandle, (uint8_t*)tx, tx_length) != HAL_OK)
    {
      /* Transfer error in transmission process */
      return 0;
    }
#endif
  
    return tx_length;
}
Пример #11
0
/***************************
*brif:串口2发送命令函数
*para:*command  命令地址
*     num       命令长度
*return : 0     成功
*         1     失败
****************************/
uint8_t Commands_Send(uint8_t *command, uint8_t num)
{
	HAL_UART_Transmit_IT(&huart2,command,num);
	FingerDelay(30);
	if(UART_SEND_FLAG == 1)
	{
		UART_SEND_FLAG = 0;
		return 0;
	}
	else
	{
		return 1;
	}
}
Пример #12
0
void Sendstring_Dia(void)
{
	  
	uint8_t value[]="Dia";
	
	if(HAL_UART_Transmit_IT(&UartHandle, (uint8_t*)value, 3)!= HAL_OK)
  {
    Error_Handler();
	}
			  while (UartReady != SET)
  {
  } 
	UartReady = RESET;

}
Пример #13
0
void HardwareSerial::write(unsigned char ch) {
	tx_in_progress = true;
	if ( HAL_UART_Transmit_IT(&huart6, &ch, 1) != HAL_OK ) {
		tx_in_progress = false;
	} else {
		serial_write_start_timestamp = HAL_GetTick();
		while ( tx_in_progress ) {
			if ( (HAL_GetTick() - serial_write_start_timestamp) > (unsigned long)SERIAL_WRITE_TIMEOUT_MS) {
				tx_in_progress = false;
				HAL_UART_ErrorCallback(&huart6);
			}
		}
	}

}
Пример #14
0
void Sendnewline(void)
{
	  
	uint8_t value[]="\n\r";
	
	if(HAL_UART_Transmit_IT(&UartHandle, (uint8_t*)value, 2)!= HAL_OK)
  {
    Error_Handler();
	}
			  while (UartReady != SET)
  {
  } 
	UartReady = RESET;

}
Пример #15
0
void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart)
{
	HAL_StatusTypeDef	st;
	UNUSED(st);

	if(huart == g_huart)
	{
		if(g_txCount) {
			g_txCount -= g_chunkSize;
			g_txStart += g_chunkSize;
			if(g_txStart >= g_size)
				g_txStart -= g_size;
			g_chunkSize = g_txStart + g_txCount > g_size ? g_size - g_txStart : g_txCount;
			if(g_chunkSize)
				st = HAL_UART_Transmit_IT(huart, g_buffer + g_txStart, g_chunkSize);
		}
	}
}
Пример #16
0
int main(void)
{

  /* USER CODE BEGIN 1 */
  uint8_t Data[10];
  /* USER CODE END 1 */

  /* MCU Configuration----------------------------------------------------------*/

  /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  HAL_Init();

  /* Configure the system clock */
  SystemClock_Config();

  /* Initialize all configured peripherals */
  MX_GPIO_Init();

  /* USER CODE BEGIN 2 */
  BSP_UART_Init(115200);

  /* Receive data on UART 6 */

  trace_printf("Hello\n");

  /* USER CODE END 2 */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
  /* USER CODE END WHILE */

  /* USER CODE BEGIN 3 */
    if(HAL_UART_Receive_IT(&huart6,Data,10) == HAL_OK)
    {
      HAL_UART_Transmit_IT(&huart6,Data,10);
    }
  }
  /* USER CODE END 3 */

}
Пример #17
0
void SendDecimal(uint16_t value)
{
 static char digit[4];
		digit[0] = (unsigned int)(value/1000);									 // Calculate digit1 of ADC_value
		digit[1] = (unsigned int)((value - digit[0]*1000)/100);						 // Calculate digit2 of ADC_value
		digit[2] = (unsigned int)((value - (digit[0]*1000+digit[1]*100))/10);			 // Calculate digit3 of ADC_value
		digit[3] = (unsigned int)((value - (digit[0]*1000+digit[1]*100+digit[2]*10))/1);	 // Calculate digit4 of ADC_value
		digit[0]=digit[0]+0x30;
		digit[1]=digit[1]+0x30;
		digit[2]=digit[2]+0x30;
		digit[3]=digit[3]+0x30;

		
		//LCD_Printf(digit2);
//LCD_Printf(digit3);
//LCD_Printf(digit4);
	
	  if(HAL_UART_Transmit_IT(&UartHandle, (uint8_t*)digit, 4)!= HAL_OK)
  {
    Error_Handler();
	}
	
		  while (UartReady != SET)
  {
  } 
	UartReady = RESET;
	
// 		  if(HAL_UART_Transmit_IT(&UartHandle, (uint8_t*)digit+1, 1)!= HAL_OK)
//   {
//     Error_Handler();
//   }
// 		  if(HAL_UART_Transmit_IT(&UartHandle, (uint8_t*)digit+2, 1)!= HAL_OK)
//   {
//     Error_Handler();
//   }
// 		  if(HAL_UART_Transmit_IT(&UartHandle, (uint8_t*)digit+3, 1)!= HAL_OK)
//   {
//     Error_Handler();
//   }
	
}
Пример #18
0
/**
  * @brief  CDC_Receive_FS
  *         Callback. Data received over USB OUT endpoint are sent over CDC interface
  *         through this function.
  *
  *         @note
  *         This function will block any OUT packet reception on USB endpoint
  *         untill exiting this function. If you exit this function before transfer
  *         is complete on CDC interface (ie. using DMA controller) it will result
  *         in receiving more data while previous ones are still not sent.
  *
  * @param  Buf: Buffer of data to be received
  * @param  Len: Number of data received (in bytes)
  * @retval Result of the operation: USBD_OK if all operations are OK else USBD_FAIL
  */
static int8_t CDC_Receive_FS (uint8_t* buf, uint32_t *len)
{
  if(len == 0)
    return USBD_OK; /* not sure if this ever happens but it might */

  /* Push the buffer we just received into the HAL UART TX quee */
  HAL_StatusTypeDef r;
  while((r = HAL_UART_Transmit_IT(&huart2, buf, *len)) == HAL_BUSY) {
    // We could go into STOP mode here, but USB is connected so who cares about power?
    // UART, transmit timer are both higher priority interrupts so will interrupt us here
  }

  /* Swap the buffer that we'll receive next CDC packet into */
  if(buf == cdc2usart_buf_a)
    USBD_CDC_SetRxBuffer(husb, cdc2usart_buf_b);
  else
    USBD_CDC_SetRxBuffer(husb, cdc2usart_buf_a);

  USBD_CDC_ReceivePacket(husb);
  return r == HAL_OK ? USBD_OK : USBD_FAIL;
}
Пример #19
0
void mavlink_rc(double x, double y, bool give_up){
	if( give_up ){ // 0 means give up
		roll = 0;
		pitch = 0;
	}else{
		roll	= pid.rollC + x*57.3f*10.0f;
		pitch = pid.pitchC + y*57.3f*10.0f;
	}
	// Pack the message
	mavlink_msg_rc_channels_override_pack(0xff, 0xbe, &tx_msg, 0x01, 0x01, roll, pitch, 0, 0, 0, 0, 0, 0);
	// Copy the message to the send buffer
	len = mavlink_msg_to_send_buffer(buf, &tx_msg);
	if( Uart1Ready ){ //
		Uart1Ready = false;
		HAL_UART_Transmit_IT(&Uart1Handle, buf, len);
	}/*else{
		HAL_UART_DeInit(&Uart1Handle);
		uart1Init();
		Uart1Ready = true;
	}*/
}
Пример #20
0
/** 
 * Begin asynchronous TX transfer. The used buffer is specified in the serial
 * object, tx_buff
 *
 * @param obj       The serial object
 * @param tx        The buffer for sending
 * @param tx_length The number of words to transmit
 * @param tx_width  The bit width of buffer word
 * @param handler   The serial handler
 * @param event     The logical OR of events to be registered
 * @param hint      A suggestion for how to use DMA with this transfer
 * @return Returns number of data transfered, or 0 otherwise
 */
int serial_tx_asynch(serial_t *obj, const void *tx, size_t tx_length, uint8_t tx_width, uint32_t handler, uint32_t event, DMAUsage hint)
{    
    // TODO: DMA usage is currently ignored
    (void) hint;
    
    // Check buffer is ok
    MBED_ASSERT(tx != (void*)0);
    MBED_ASSERT(tx_width == 8); // support only 8b width
    
    struct serial_s *obj_s = SERIAL_S(obj);
    UART_HandleTypeDef * huart = &uart_handlers[obj_s->index];

    if (tx_length == 0) {
        return 0;
    }
  
    // Set up buffer
    serial_tx_buffer_set(obj, (void *)tx, tx_length, tx_width);
  
    // Set up events
    serial_enable_event(obj, SERIAL_EVENT_TX_ALL, 0); // Clear all events
    serial_enable_event(obj, event, 1); // Set only the wanted events
    
    // Enable interrupt
    IRQn_Type irq_n = serial_get_irq_n(obj);
    NVIC_ClearPendingIRQ(irq_n);
    NVIC_DisableIRQ(irq_n);
    NVIC_SetPriority(irq_n, 1);
    NVIC_SetVector(irq_n, (uint32_t)handler);
    NVIC_EnableIRQ(irq_n);

    // the following function will enable UART_IT_TXE and error interrupts
    if (HAL_UART_Transmit_IT(huart, (uint8_t*)tx, tx_length) != HAL_OK) {
        return 0;
    }
    
    return tx_length;
}
Пример #21
0
int main(void)
{

  /* USER CODE BEGIN 1 */

  /* USER CODE END 1 */

  /* MCU Configuration----------------------------------------------------------*/

  /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  HAL_Init();

  /* Configure the system clock */
  SystemClock_Config();

  /* Initialize all configured peripherals */
  MX_GPIO_Init();
  MX_USART2_UART_Init();

  /* USER CODE BEGIN 2 */

  /* USER CODE END 2 */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
  /* USER CODE END WHILE */

  /* USER CODE BEGIN 3 */
		HAL_UART_Transmit_IT(&huart2,pString,sizeof(pString)/sizeof(char));
		HAL_Delay(500);
  }
  /* USER CODE END 3 */

}
Пример #22
0
void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart) {
  if(RingBuffer_GetDataLength(&txBuf) > 0) {
    RingBuffer_Read(&txBuf, &txData, 1);
    HAL_UART_Transmit_IT(huart, &txData, 1);
  }
}
// Private Methods
static void startTX(Client* c, bool timeout, bool kickstart, bool ack)
{
	static volatile uint8_t txState = TX_IDLE;
	static int packetLength;

	// If we are waiting for an Ack and a timeout occured
	// we resend the last publish packet.
	if (timeout)
	{
		if (txState == TX_WAIT)
		{
			// Ack did not arrive in time, resend last pub
			txState = TX_IDLE;
		} else
		{
			return;
		}
	}

	// If we write to the tx buffer and the uart is idling
	// we should initiate the transmit process.
	if (kickstart && (txState != TX_IDLE))
	{
		return;
	}

	// If we received an Ack, move on.
	if (ack && (txState == TX_WAIT))
	{
		c->txBuf.pH += (uint8_t)packetLength;
		c->txBuf.isFull = false;
		txState = TX_IDLE;
	}

	switch (txState)
	{
	// Start sending the next packet
	case TX_IDLE:
		if (c->txBuf.available(&c->txBuf) > 0)
		{
			packetLength = (int)(c->txBuf.Buf[c->txBuf.pH]) + 1;
			if ((int)c->txBuf.pH + packetLength > 256) // check if packet surpasses buffer end
			{
				if (HAL_UART_Transmit_IT(c->peripheral_UART, &c->txBuf.Buf[c->txBuf.pH], 256 - c->txBuf.pH) != HAL_OK)
					return; // TODO: react on this
				c->lastOutAct = HAL_GetTick();
				txState = TX_BUSY;
			} else
			{
				if (HAL_UART_Transmit_IT(c->peripheral_UART, &c->txBuf.Buf[c->txBuf.pH], (uint16_t)packetLength) != HAL_OK)
					return;
				c->lastOutAct = HAL_GetTick();
				if ((c->txBuf.Buf[c->txBuf.pH + 1] & 0x7F) == PROTOCOL_PUBLISH)
				{
					c->expectedAckSeq = (c->txBuf.Buf[c->txBuf.pH + 1] & 0x80) > 0;
					c->ackOutstanding = true;
					txState = TX_WAIT;
				} else
				{
					c->txBuf.pH += (uint8_t)packetLength;
					c->txBuf.isFull = false;
				}
			}
		}
		break;
	// Complete sending of current packet
	case TX_BUSY:
		if (HAL_UART_Transmit_IT(c->peripheral_UART, c->txBuf.Buf, packetLength + c->txBuf.pH - 256) != HAL_OK)
			return;
		c->lastOutAct = HAL_GetTick();
		if ((c->txBuf.Buf[c->txBuf.pH + 1] & 0x7F) == PROTOCOL_PUBLISH)
		{
			c->expectedAckSeq = (c->txBuf.Buf[c->txBuf.pH + 1] & 0x80) > 0;
			c->ackOutstanding = true;
			txState = TX_WAIT;
		} else
		{
			c->txBuf.pH += (uint8_t)packetLength;
			txState = TX_IDLE;
			c->txBuf.isFull = false;
		}
		break;
	case TX_WAIT:
		break;
	}
}
Пример #24
0
/**
  * @brief  Main program
  * @param  None
  * @retval None
  */
int main(void)
{
    /* STM32F4xx HAL library initialization:
         - Configure the Flash prefetch, instruction and Data caches
         - Systick timer is configured by default as source of time base, but user
           can eventually implement his proper time base source (a general purpose
           timer for example or other time source), keeping in mind that Time base
           duration should be kept 1ms since PPP_TIMEOUT_VALUEs are defined and
           handled in milliseconds basis.
         - Set NVIC Group Priority to 4
         - Low Level Initialization: global MSP (MCU Support Package) initialization
       */
    HAL_Init();

    /* Configure the system clock to 180 MHz */
    SystemClock_Config();

    /* Configure leds */
    BSP_LED_Init(LED1);
    BSP_LED_Init(LED3);

    /*##-1- Configure the UART peripheral ######################################*/
    /* Put the USART peripheral in the Asynchronous mode (UART Mode) */
    /* UART configured as follows:
        - Word Length = 8 Bits (7 data bit + 1 parity bit) :
                      BE CAREFUL : Program 7 data bits + 1 parity bit in PC HyperTerminal
        - Stop Bit    = One Stop bit
        - Parity      = ODD parity
        - BaudRate    = 9600 baud
        - Hardware flow control disabled (RTS and CTS signals) */
    UartHandle.Instance        = USARTx;

    UartHandle.Init.BaudRate   = 9600;
    UartHandle.Init.WordLength = UART_WORDLENGTH_8B;
    UartHandle.Init.StopBits   = UART_STOPBITS_1;
    UartHandle.Init.Parity     = UART_PARITY_ODD;
    UartHandle.Init.HwFlowCtl  = UART_HWCONTROL_NONE;
    UartHandle.Init.Mode       = UART_MODE_TX_RX;
    UartHandle.Init.OverSampling = UART_OVERSAMPLING_16;

    if(HAL_UART_Init(&UartHandle) != HAL_OK)
    {
        /* Initialization Error */
        Error_Handler();
    }

    /*##-2- Start the transmission process #####################################*/
    /* While the UART in reception process, user can transmit data through
       "aTxBuffer" buffer */
    if(HAL_UART_Transmit_IT(&UartHandle, (uint8_t*)aTxStartMessage, TXSTARTMESSAGESIZE)!= HAL_OK)
    {
        /* Transfer error in transmission process */
        Error_Handler();
    }

    /*##-3- Put UART peripheral in reception process ###########################*/
    /* Any data received will be stored "aRxBuffer" buffer : the number max of
       data received is 10 */
    if(HAL_UART_Receive_IT(&UartHandle, (uint8_t *)aRxBuffer, RXBUFFERSIZE) != HAL_OK)
    {
        /* Transfer error in reception process */
        Error_Handler();
    }

    /*##-4- Wait for the end of the transfer ###################################*/
    /*  Before starting a new communication transfer, you need to check the current
        state of the peripheral; if it’s busy you need to wait for the end of current
        transfer before starting a new one.
        For simplicity reasons, this example is just waiting till the end of the
        transfer, but application may perform other tasks while transfer operation
        is ongoing. */
    while (HAL_UART_GetState(&UartHandle) != HAL_UART_STATE_READY)
    {
        if (tx_complete == 1)
        {
            BSP_LED_Toggle(LED1);
            HAL_Delay(250);
        }
    }

    if (rx_complete == 1)
    {
        BSP_LED_On(LED1);
    }

    /*##-5- Send the received Buffer ###########################################*/
    if(HAL_UART_Transmit_IT(&UartHandle, (uint8_t*)aRxBuffer, RXBUFFERSIZE)!= HAL_OK)
    {
        /* Transfer error in transmission process */
        Error_Handler();
    }

    /*##-6- Wait for the end of the transfer ###################################*/
    /*  Before starting a new communication transfer, you need to check the current
        state of the peripheral; if it’s busy you need to wait for the end of current
        transfer before starting a new one.
        For simplicity reasons, this example is just waiting till the end of the
        transfer, but application may perform other tasks while transfer operation
        is ongoing. */
    while (HAL_UART_GetState(&UartHandle) != HAL_UART_STATE_READY)
    {
    }

    /*##-7- Send the End Message ###############################################*/
    if(HAL_UART_Transmit_IT(&UartHandle, (uint8_t*)aTxEndMessage, TXENDMESSAGESIZE)!= HAL_OK)
    {
        /* Turn LED3 on: Transfer error in transmission process */
        BSP_LED_On(LED3);
        while(1)
        {
        }
    }

    /*##-8- Wait for the end of the transfer ###################################*/
    while (HAL_UART_GetState(&UartHandle) != HAL_UART_STATE_READY)
    {
    }

    /* Infinite loop */
    while (1)
    {
    }
}
Пример #25
0
void SERVO_PROTOCOL_SendCommand (SERVO_PROTOCOL_Command cmd, uint8_t channelNum, uint16_t *data, uint32_t dataLength)
{
    //data contains values in Little-endian format.
    //ServoController protocol uses this format too.
    
    servoTxBuffer[0] = cmd;
    
    uint32_t origLength;;
    
    switch (cmd)
    {
        case SERVO_SET_CHANNEL:
            servoTxBuffer[1] = channelNum;
            servoTxBuffer[2] = (uint8_t)data[0];            // LO byte of uint16_t
            servoTxBuffer[3] = (uint8_t)(data[0] >> 8);     // HI byte of uint16_t
            
            origLength = 4;
        
            break;
            
        case SERVO_SET_CHANNELS:
            for (int i = 0; i < dataLength; i++)
            {
                uint16_t value = data[i];
                servoTxBuffer[1 + i * 2] = (uint8_t)value;            // LO byte of uint16_t
                servoTxBuffer[2 + i * 2] = (uint8_t)(value >> 8);     // HI byte of uint16_t
            }
        
            origLength = 1 + dataLength * 2;
            
            break;   
            
        default:
            return;
            
            break;
    }
    
    // Check buffer for special symbols.
    // Every special symbol increases 
    // transmit length by 1.
    uint32_t fullLength = origLength;
    
    for (int i = 0; i < origLength; i++)
    {
        uint8_t byte = servoTxBuffer[i];
        
        if (byte == END_PACKET_SYMBOL || byte == ESC_SYMBOL)
        {
            fullLength++;
        }
    }
    
    // Replace special symbols.
    // servoTxBuffer transmit length
    // is equal to fullLength.
    if (fullLength > origLength)
    {
        int32_t origIdx = origLength - 1;
        int32_t fullIdx = fullLength - 1;
        
        while (origIdx >= 0)
        {
            uint8_t byte = servoTxBuffer[origIdx--];
            switch (byte)
            {
                case END_PACKET_SYMBOL:
                    servoTxBuffer[fullIdx--] = ESC_END_REPLACE_SYMBOL;
                    servoTxBuffer[fullIdx--] = ESC_SYMBOL;
                
                    break;
                
                case ESC_SYMBOL:
                    servoTxBuffer[fullIdx--] = ESC_ESC_REPLACE_SYMBOL;
                    servoTxBuffer[fullIdx--] = ESC_SYMBOL;
                
                    break;
                
                default:
                    servoTxBuffer[fullIdx--] = byte;
                
                    break;
            }
        }
    }
    
    // Add END_PACKET_SYMBOL to the end of buffer
    servoTxBuffer[fullLength++] = END_PACKET_SYMBOL;
        
    HAL_UART_Transmit_IT(&huart2, servoTxBuffer, fullLength);
}
Пример #26
0
void uart::puts( const char * data)
{
  HAL_UART_Transmit_IT( &huart, (uint8_t *)data, strlen(data));
}
Пример #27
0
/**
  * @brief  Main program.
  * @param  None
  * @retval None
  */
int main(void)
{

  /* STM32L0xx HAL library initialization:
       - Configure the Flash prefetch, Flash preread and Buffer caches
       - Systick timer is configured by default as source of time base, but user 
             can eventually implement his proper time base source (a general purpose 
             timer for example or other time source), keeping in mind that Time base 
             duration should be kept 1ms since PPP_TIMEOUT_VALUEs are defined and 
             handled in milliseconds basis.
       - Low Level Initialization
     */
  HAL_Init();
  
  /* Configure LED3 */
  BSP_LED_Init(LED3);

  /* Configure the system clock to 32 Mhz */
  SystemClock_Config();

  /*##-1- Configure the UART peripheral ######################################*/
  /* Put the USART peripheral in the Asynchronous mode (UART Mode) */
  /* UART1 configured as follow:
      - Word Length = 8 Bits
      - Stop Bit = One Stop bit
      - Parity = None
      - BaudRate = 9600 baud
      - Hardware flow control disabled (RTS and CTS signals) */
  UartHandle.Instance        = USARTx;
  UartHandle.Init.BaudRate   = 9600;
  UartHandle.Init.WordLength = UART_WORDLENGTH_8B;
  UartHandle.Init.StopBits   = UART_STOPBITS_1;
  UartHandle.Init.Parity     = UART_PARITY_NONE;
  UartHandle.Init.HwFlowCtl  = UART_HWCONTROL_NONE;
  UartHandle.Init.Mode       = UART_MODE_TX_RX;
  
  if(HAL_UART_Init(&UartHandle) != HAL_OK)
  {
    Error_Handler();
  }
  
#ifdef TRANSMITTER_BOARD

  /* Configure Button Key */
  BSP_PB_Init(BUTTON_KEY, BUTTON_MODE_GPIO);

  /* Toggle led3 waiting for user to press button */
  BSP_LED_On(LED3);
    
  /* Wait for Button Key press before starting the Communication */
  while (BSP_PB_GetState(BUTTON_KEY) == RESET)
  {		
  }
  /* Wait for Button Key to be release before starting the Communication */
  while (BSP_PB_GetState(BUTTON_KEY) == SET)
  {
  }
  
  /* Turn led3 off */
  BSP_LED_Off(LED3);
  
  /* The board sends the message and expects to receive it back */
  
  /*##-2- Start the transmission process #####################################*/  
  /* While the UART in reception process, user can transmit data through 
     "aTxBuffer" buffer */
  if(HAL_UART_Transmit_IT(&UartHandle, (uint8_t*)aTxBuffer, TXBUFFERSIZE)!= HAL_OK)
  {
    Error_Handler();
  }
  
  /*##-3- Wait for the end of the transfer ###################################*/   
  while (UartReady != SET)
  {
  }
  
  /* Reset transmission flag */
  UartReady = RESET;
  
  /*##-4- Put UART peripheral in reception process ###########################*/  
  if(HAL_UART_Receive_IT(&UartHandle, (uint8_t *)aRxBuffer, RXBUFFERSIZE) != HAL_OK)
  {
    Error_Handler();
  }

#else
  
  /* The board receives the message and sends it back */

  /*##-2- Put UART peripheral in reception process ###########################*/  
  if(HAL_UART_Receive_IT(&UartHandle, (uint8_t *)aRxBuffer, RXBUFFERSIZE) != HAL_OK)
  {
    Error_Handler();
  }
  
  /*##-3- Wait for the end of the transfer ###################################*/   
  while (UartReady != SET)
  {
  } 
  
  /* Reset transmission flag */
  UartReady = RESET;
  
  /*##-4- Start the transmission process #####################################*/  
  /* While the UART in reception process, user can transmit data through 
     "aTxBuffer" buffer */
  if(HAL_UART_Transmit_IT(&UartHandle, (uint8_t*)aTxBuffer, TXBUFFERSIZE)!= HAL_OK)
  {
    Error_Handler();
  }
  
#endif /* TRANSMITTER_BOARD */
  
  /*##-5- Wait for the end of the transfer ###################################*/   
  while (UartReady != SET)
  {
  } 
  
  /* Reset transmission flag */
  UartReady = RESET;

  /*##-6- Compare the sent and received buffers ##############################*/
  if(Buffercmp((uint8_t*)aTxBuffer,(uint8_t*)aRxBuffer,RXBUFFERSIZE))
  {
    Error_Handler();
  }
  
  /* Turn LED3 on: Transfer process is correct */
  BSP_LED_On(LED3);
  
  /* Infinite loop */
  while (1)
  {
  }
}
Пример #28
0
/**
  * @brief  Main program
  * @param  None
  * @retval None
  */
int main(void)
{    
  /* STM32F4xx HAL library initialization:
       - Configure the Flash prefetch, instruction and Data caches
       - Configure the Systick to generate an interrupt each 1 msec
       - Set NVIC Group Priority to 4
       - Global MSP (MCU Support Package) initialization
     */
  HAL_Init();
  
  /* Configure the system clock to 168 MHz */
  SystemClock_Config();
  
  /* Configure LED1, LED2 and LED3 */
  BSP_LED_Init(LED1);
  BSP_LED_Init(LED2);
  BSP_LED_Init(LED3);
  
  /*##-1- Configure the UART peripheral ######################################*/
  /* Put the USART peripheral in the Asynchronous mode (UART Mode) */
  /* UART1 configured as follow:
      - Word Length = 8 Bits
      - Stop Bit = One Stop bit
      - Parity = ODD parity
      - BaudRate = 9600 baud
      - Hardware flow control disabled (RTS and CTS signals) */
  UartHandle.Instance          = USARTx;
  
  UartHandle.Init.BaudRate     = 9600;
  UartHandle.Init.WordLength   = UART_WORDLENGTH_8B;
  UartHandle.Init.StopBits     = UART_STOPBITS_1;
  UartHandle.Init.Parity       = UART_PARITY_ODD;
  UartHandle.Init.HwFlowCtl    = UART_HWCONTROL_NONE;
  UartHandle.Init.Mode         = UART_MODE_TX_RX;
  UartHandle.Init.OverSampling = UART_OVERSAMPLING_16;
    
  if(HAL_UART_Init(&UartHandle) != HAL_OK)
  {
    /* Turn LED3 on: in case of Initialization Error */
    BSP_LED_On(LED3);
    while(1)
    {
    }
  }
  
  /*##-2- Start the transmission process #####################################*/  
  /* While the UART in reception process, user can transmit data through 
     "aTxBuffer" buffer */
  if(HAL_UART_Transmit_IT(&UartHandle, (uint8_t*)aTxStartMessage, TXSTARTMESSAGESIZE)!= HAL_OK)
  {
    /* Turn LED3 on: Transfer error in transmission process */
    BSP_LED_On(LED3);
    while(1)
    {
    }   
  }
  
  /*##-3- Put UART peripheral in reception process ###########################*/  
  /* Any data received will be stored "aRxBuffer" buffer : the number max of 
     data received is 10 */
  if(HAL_UART_Receive_IT(&UartHandle, (uint8_t *)aRxBuffer, RXBUFFERSIZE) != HAL_OK)
  {
    /* Turn LED3 on: Transfer error in reception process */
    BSP_LED_On(LED3);
    while(1)
    {
    }     
  }

  /*##-4- Wait for the end of the transfer ###################################*/  
  /*  Before starting a new communication transfer, you need to check the current   
      state of the peripheral; if it’s busy you need to wait for the end of current
      transfer before starting a new one.
      For simplicity reasons, this example is just waiting till the end of the 
      transfer, but application may perform other tasks while transfer operation
      is ongoing. */  
  while (HAL_UART_GetState(&UartHandle) != HAL_UART_STATE_READY)
  {
  } 
 
  /*##-5- Send the received Buffer ###########################################*/  
  if(HAL_UART_Transmit_IT(&UartHandle, (uint8_t*)aRxBuffer, RXBUFFERSIZE)!= HAL_OK)
  {
    /* Turn LED3 on: Transfer error in transmission process */
    BSP_LED_On(LED3);
    while(1)
    {
    }      
  }
  
  /*##-6- Wait for the end of the transfer ###################################*/  
  while (HAL_UART_GetState(&UartHandle) != HAL_UART_STATE_READY)
  {
  }
  
  /*##-7- Send the End Message ###############################################*/  
  if(HAL_UART_Transmit_IT(&UartHandle, (uint8_t*)aTxEndMessage, TXENDMESSAGESIZE)!= HAL_OK)
  {
    /* Turn LED3 on: Transfer error in transmission process */
    BSP_LED_On(LED3);
    while(1)
    {
    }      
  }
  
  /*##-8- Wait for the end of the transfer ###################################*/  
  while (HAL_UART_GetState(&UartHandle) != HAL_UART_STATE_READY)
  {
  }
  
  /* Infinite loop */  
  while (1)
  {
  }
}
Пример #29
0
/**
  * @brief  Main program
  * @param  None
  * @retval None
  */
int main(void)
{

  /* STM32F0xx HAL library initialization:
       - Configure the Flash prefetch
       - Systick timer is configured by default as source of time base, but user 
         can eventually implement his proper time base source (a general purpose 
         timer for example or other time source), keeping in mind that Time base 
         duration should be kept 1ms since PPP_TIMEOUT_VALUEs are defined and 
         handled in milliseconds basis.
       - Low Level Initialization
     */
  HAL_Init();
  
  /* Configure LED2 */
  BSP_LED_Init(LED2);


  /* Configure the system clock to 48 MHz */
  SystemClock_Config();

  /*##-1- Configure the UART peripheral ######################################*/
  /* Put the USART peripheral in the Asynchronous mode (UART Mode) */
  /* UART configured as follows:
      - Word Length = 8 Bits
      - Stop Bit = One Stop bit
      - Parity = None
      - BaudRate = 9600 baud
      - Hardware flow control disabled (RTS and CTS signals) */
  UartHandle.Instance        = USARTx;

  UartHandle.Init.BaudRate   = 9600;
  UartHandle.Init.WordLength = UART_WORDLENGTH_8B;
  UartHandle.Init.StopBits   = UART_STOPBITS_1;
  UartHandle.Init.Parity     = UART_PARITY_NONE;
  UartHandle.Init.HwFlowCtl  = UART_HWCONTROL_NONE;
  UartHandle.Init.Mode       = UART_MODE_TX_RX;
  UartHandle.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT; 
  if(HAL_UART_DeInit(&UartHandle) != HAL_OK)
  {
    Error_Handler();
  }  
  if(HAL_UART_Init(&UartHandle) != HAL_OK)
  {
    Error_Handler();
  }
  
#ifdef TRANSMITTER_BOARD

  /* Configure User push-button in Interrupt mode */
  BSP_PB_Init(BUTTON_USER, BUTTON_MODE_EXTI);
  
  /* Wait for User push-button press before starting the Communication.
     In the meantime, LED2 is blinking */
  while(UserButtonStatus == 0)
  {
      /* Toggle LED2*/
      BSP_LED_Toggle(LED2); 
      HAL_Delay(100);
  }
  
  BSP_LED_Off(LED2); 
  
  
  /* The board sends the message and expects to receive it back */
  
  /*##-2- Start the transmission process #####################################*/  
  /* While the UART in reception process, user can transmit data through 
     "aTxBuffer" buffer */
  if(HAL_UART_Transmit_IT(&UartHandle, (uint8_t*)aTxBuffer, TXBUFFERSIZE)!= HAL_OK)
  {
    Error_Handler();
  }
  
  /*##-3- Wait for the end of the transfer ###################################*/   
  while (UartReady != SET)
  {
  }
  
  /* Reset transmission flag */
  UartReady = RESET;
  
  /*##-4- Put UART peripheral in reception process ###########################*/  
  if(HAL_UART_Receive_IT(&UartHandle, (uint8_t *)aRxBuffer, RXBUFFERSIZE) != HAL_OK)
  {
    Error_Handler();
  }

#else
  
  /* The board receives the message and sends it back */

  /*##-2- Put UART peripheral in reception process ###########################*/  
  if(HAL_UART_Receive_IT(&UartHandle, (uint8_t *)aRxBuffer, RXBUFFERSIZE) != HAL_OK)
  {
    Error_Handler();
  }
  
  /*##-3- Wait for the end of the transfer ###################################*/   
  /* While waiting for message to come from the other board, LED2 is
     blinking according to the following pattern: a double flash every half-second */  
  while (UartReady != SET)
  {
      BSP_LED_On(LED2); 
      HAL_Delay(100);
      BSP_LED_Off(LED2); 
      HAL_Delay(100);
      BSP_LED_On(LED2); 
      HAL_Delay(100);
      BSP_LED_Off(LED2); 
      HAL_Delay(500); 
  } 
  
  /* Reset transmission flag */
  UartReady = RESET;
  BSP_LED_Off(LED2); 
  
  /*##-4- Start the transmission process #####################################*/  
  /* While the UART in reception process, user can transmit data through 
     "aTxBuffer" buffer */
  if(HAL_UART_Transmit_IT(&UartHandle, (uint8_t*)aTxBuffer, TXBUFFERSIZE)!= HAL_OK)
  {
    Error_Handler();
  }
  
#endif /* TRANSMITTER_BOARD */
  
  /*##-5- Wait for the end of the transfer ###################################*/   
  while (UartReady != SET)
  {
  } 
  
  /* Reset transmission flag */
  UartReady = RESET;

  /*##-6- Compare the sent and received buffers ##############################*/
  if(Buffercmp((uint8_t*)aTxBuffer,(uint8_t*)aRxBuffer,RXBUFFERSIZE))
  {
    Error_Handler();
  }
  
  /* Turn on LED2 if test passes then enter infinite loop */
  BSP_LED_On(LED2); 
  /* Infinite loop */
  while (1)
  {
  }
}
Пример #30
-8
int main(void)
{

  /* USER CODE BEGIN 1 */
	char ADC_Tx_Data[70];
  /* USER CODE END 1 */

  /* MCU Configuration----------------------------------------------------------*/

  /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  HAL_Init();

  /* Configure the system clock */
  SystemClock_Config();

  /* Initialize all configured peripherals */
  MX_GPIO_Init();
  MX_DMA_Init();
  MX_ADC1_Init();
  MX_USART1_UART_Init();

  /* USER CODE BEGIN 2 */
	
	HAL_UART_Receive_IT(&huart1, (uint8_t *)Rx_Data, 1);
	HAL_ADC_Start_DMA(&hadc1, (uint32_t*)&ADC_Value, 6);

  /* USER CODE END 2 */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
		HAL_Delay(15);
		HAL_GPIO_TogglePin(GPIOC, GPIO_PIN_4);
		HAL_Delay(15);
		HAL_GPIO_TogglePin(GPIOC, GPIO_PIN_0);	
		HAL_Delay(15);
		HAL_GPIO_TogglePin(GPIOC, GPIO_PIN_1);	
		HAL_Delay(15);
		HAL_GPIO_TogglePin(GPIOC, GPIO_PIN_2);	
		HAL_Delay(15);		
	  sprintf(ADC_Tx_Data,"ADC1:%4d\tADC2:%4d\tADC3:%4d\tADC4:%4d\tADC5:%4d\tADC6:%4d\n\r", ADC_Value[0], ADC_Value[1], ADC_Value[2], ADC_Value[3], ADC_Value[4], ADC_Value[5]);
		HAL_UART_Transmit_IT(&huart1, (uint8_t *)ADC_Tx_Data, 70);
			
  /* USER CODE END WHILE */

  /* USER CODE BEGIN 3 */

  }
  /* USER CODE END 3 */

}