WebSVN – libSerial – Diff – /trunk/src/serial.c

 #endif
 #if defined SERIAL_UART5
 usart_ctl uc5;
 #endif
 /* returns the number of characters received by the Rx USART */
 uint16_t
-SerialCharsReceived (usart_ctl *instance)
+SerialCharsReceived(usart_ctl *instance)
+{
-  uint16_t result = 0;  // assume no characters received yet
+  uint16_t result = 0; // assume no characters received yet
-  __HAL_UART_DISABLE_IT (instance->Handle, UART_IT_RXNE);
+  __HAL_UART_DISABLE_IT(instance->Handle, UART_IT_RXNE);
   if (instance->rx_usart_buffer_full)
-    {   // buffer is full...
+  { // buffer is full...
-      result = RX_USART_BUFF_SIZ;
+    result = RX_USART_BUFF_SIZ;
-    }
+  }
   else if (instance->rx_usart_in_Ptr >= instance->rx_usart_out_Ptr)
-    {   // buffer has not wrapped...
+  { // buffer has not wrapped...
-      result = instance->rx_usart_in_Ptr - instance->rx_usart_out_Ptr;
+    result = instance->rx_usart_in_Ptr - instance->rx_usart_out_Ptr;
-    }
+  }
   else
-    {   // buffer has possibly wrapped...
+  { // buffer has possibly wrapped...
-      result = RX_USART_BUFF_SIZ - instance->rx_usart_out_Ptr
+    result = RX_USART_BUFF_SIZ - instance->rx_usart_out_Ptr + instance->rx_usart_in_Ptr;
-          + instance->rx_usart_in_Ptr;
-    }
+  }
-  __HAL_UART_ENABLE_IT (instance->Handle, UART_IT_RXNE);
+  __HAL_UART_ENABLE_IT(instance->Handle, UART_IT_RXNE);
   return result;
+}
-uint16_t SerialTransmitSpace(usart_ctl * instance)
+uint16_t SerialTransmitSpace(usart_ctl *instance)
+{
-  return TX_USART_BUFF_SIZ- instance->tx_usart_count;
+  return TX_USART_BUFF_SIZ - instance->tx_usart_count;
+}
 inline uint8_t
-PollSerial (usart_ctl *instance)
+PollSerial(usart_ctl *instance)
+{
   uint8_t rc;
-  __HAL_UART_DISABLE_IT (instance->Handle, UART_IT_RXNE);
+  __HAL_UART_DISABLE_IT(instance->Handle, UART_IT_RXNE);
-  rc = (instance->rx_usart_buffer_full
-      || (instance->rx_usart_in_Ptr != instance->rx_usart_out_Ptr));
+  rc = (instance->rx_usart_buffer_full || (instance->rx_usart_in_Ptr != instance->rx_usart_out_Ptr));
-  __HAL_UART_ENABLE_IT (instance->Handle, UART_IT_RXNE);
+  __HAL_UART_ENABLE_IT(instance->Handle, UART_IT_RXNE);
   return rc;
+}
 /***!
  * @brief return the next character in the Serial input buffer
  * This function will wait until a character arrives.
  */
 inline uint8_t
-GetCharSerial (usart_ctl *instance)
+GetCharSerial(usart_ctl *instance)
+{
   uint8_t c;
-  __HAL_UART_DISABLE_IT (instance->Handle, UART_IT_RXNE);
+  __HAL_UART_DISABLE_IT(instance->Handle, UART_IT_RXNE);
-  while (!instance->rx_usart_buffer_full
-      && (instance->rx_usart_in_Ptr == instance->rx_usart_out_Ptr))
+  while (!instance->rx_usart_buffer_full && (instance->rx_usart_in_Ptr == instance->rx_usart_out_Ptr))
-    {
+  {
-      __HAL_UART_ENABLE_IT (instance->Handle, UART_IT_RXNE);
+    __HAL_UART_ENABLE_IT(instance->Handle, UART_IT_RXNE);
-      __WFI (); /* wait for something */
+    __WFI(); /* wait for something */
-      __HAL_UART_DISABLE_IT (instance->Handle, UART_IT_RXNE);
+    __HAL_UART_DISABLE_IT(instance->Handle, UART_IT_RXNE);
-    }
+  }
   c = instance->rx_usart_buff[instance->rx_usart_out_Ptr];
   instance->rx_usart_buffer_full = 0; /* removed character */
   instance->rx_usart_out_Ptr++;
   if (instance->rx_usart_out_Ptr >= RX_USART_BUFF_SIZ)
-    {
+  {
-      instance->rx_usart_out_Ptr = 0;
+    instance->rx_usart_out_Ptr = 0;
-    }
+  }
-  __HAL_UART_ENABLE_IT (instance->Handle, UART_IT_RXNE);
+  __HAL_UART_ENABLE_IT(instance->Handle, UART_IT_RXNE);
   return c;
+}
 /*
  * \brief
  * void EnableSerialRxInterrupt(void) - this function is used from the interrupt handler and the main scheduler loop
  * to enable the serial rx interrupt after resetting the serial rx buffer...
  */
 inline void
-EnableSerialRxInterrupt (usart_ctl *instance)
+EnableSerialRxInterrupt(usart_ctl *instance)
+{
   /* cheat here - this is a macro and I have the same Instance member as the HAL handle, with the same meaning */
-  __HAL_UART_ENABLE_IT (instance->Handle, UART_IT_RXNE);
+  __HAL_UART_ENABLE_IT(instance->Handle, UART_IT_RXNE);
+}
 /****!
  * @brief send a character to the serial USART via placing it in the serial buffer
+ *
  */
 static void
-PutCharSerialFIFO (usart_ctl *instance, uint8_t c)
+PutCharSerialFIFO(usart_ctl *instance, uint8_t c)
+{
-  __HAL_UART_DISABLE_IT (instance->Handle, UART_IT_TXE);
+  __HAL_UART_DISABLE_IT(instance->Handle, UART_IT_TXE);
   instance->tx_usart_buff[instance->tx_usart_in_Ptr++] = c;
   instance->tx_usart_count += 1;
   if (instance->tx_usart_in_Ptr >= TX_USART_BUFF_SIZ)
-    {
+  {
-      instance->tx_usart_in_Ptr = 0;
+    instance->tx_usart_in_Ptr = 0;
-    }
+  }
   /* Handle overrun by losing oldest characters */
   if (instance->tx_usart_in_Ptr == instance->tx_usart_out_Ptr)
+  {
+    instance->tx_usart_out_Ptr++;
+    if (instance->tx_usart_out_Ptr >= TX_USART_BUFF_SIZ)
+    {
-      instance->tx_usart_out_Ptr++;
+      instance->tx_usart_out_Ptr = 0;
-      if (instance->tx_usart_out_Ptr >= TX_USART_BUFF_SIZ)
-        {
-          instance->tx_usart_out_Ptr = 0;
-        }
+    }
+  }
   instance->tx_usart_running = 1;
-  __HAL_UART_ENABLE_IT (instance->Handle, UART_IT_TXE);
+  __HAL_UART_ENABLE_IT(instance->Handle, UART_IT_TXE);
+}
-void
-UART_IRQHandler (usart_ctl *instance)
+void UART_IRQHandler(usart_ctl *instance)
+{
-  __disable_irq ();
+  __disable_irq();
-  uint32_t rxStatus;    // status from USART receiver
+  uint32_t rxStatus; // status from USART receiver
-  rxStatus = instance->Handle->Instance->SR;// read the status bits - this resets all the hardware signalling flags
+  rxStatus = instance->Handle->Instance->SR; // read the status bits - this resets all the hardware signalling flags
   if ((rxStatus & USART_SR_LBD))
-      __HAL_UART_CLEAR_FLAG(instance->Handle,USART_SR_LBD);
+    __HAL_UART_CLEAR_FLAG(instance->Handle, USART_SR_LBD);
-  if ((rxStatus & USART_SR_RXNE)!= RESET)
+  if ((rxStatus & USART_SR_RXNE) != RESET)
+  {
+    // no error has occurred...
+    uint8_t rxChar = (uint8_t)(instance->Handle->Instance->DR & 0xff); // read the bottom 8-bits only
+    if (!instance->rx_usart_buffer_full)
+    {
-      // no error has occurred...
-      uint8_t rxChar = (uint8_t) (instance->Handle->Instance->DR & 0xff);// read the bottom 8-bits only
+      instance->rx_usart_buff[instance->rx_usart_in_Ptr++] = rxChar;
-      if (!instance->rx_usart_buffer_full)
-        {
-          instance->rx_usart_buff[instance->rx_usart_in_Ptr++] = rxChar;
-          if (instance->rx_usart_in_Ptr >= RX_USART_BUFF_SIZ)
+      if (instance->rx_usart_in_Ptr >= RX_USART_BUFF_SIZ)
-            {
+      {
-              instance->rx_usart_in_Ptr = 0;
+        instance->rx_usart_in_Ptr = 0;
-            }
+      }
-          if (instance->rx_usart_in_Ptr == instance->rx_usart_out_Ptr)
+      if (instance->rx_usart_in_Ptr == instance->rx_usart_out_Ptr)
-            {
+      {
-              instance->rx_usart_buffer_full = 1; /* buffer overrun */
+        instance->rx_usart_buffer_full = 1; /* buffer overrun */
-            }
+      }
-        }
+    }
+  }
   /* check for transmitter interrupt : this code is used */
   if ((rxStatus & USART_SR_TXE) != RESET)
+  {
+    /* Only enable the transmitter when baud detect has completed or check expired.
+     * and the software is ready for it to be enabled as programming mode is wanting
+     * to receive a response and that can get blocked if we're streaming a lot of debug messages*/
+    if (instance->tx_usart_in_Ptr != instance->tx_usart_out_Ptr)
+    {
+      instance->Handle->Instance->DR =
+          instance->tx_usart_buff[instance->tx_usart_out_Ptr++];
+      if (instance->tx_usart_count != 0)
+        instance->tx_usart_count -= 1;
-      /* Only enable the transmitter when baud detect has completed or check expired.
-       * and the software is ready for it to be enabled as programming mode is wanting
-       * to receive a response and that can get blocked if we're streaming a lot of debug messages*/
-      if (instance->tx_usart_in_Ptr != instance->tx_usart_out_Ptr)
-        {
-          instance->Handle->Instance->DR =
-              instance->tx_usart_buff[instance->tx_usart_out_Ptr++];
-          if (instance->tx_usart_count != 0)
-            instance->tx_usart_count -= 1;
-          if (instance->tx_usart_out_Ptr >= TX_USART_BUFF_SIZ)
+      if (instance->tx_usart_out_Ptr >= TX_USART_BUFF_SIZ)
-            {
+      {
-              instance->tx_usart_out_Ptr = 0;
+        instance->tx_usart_out_Ptr = 0;
-            }
+      }
-        }
-      if (instance->tx_usart_count == 0)
-        {
-          __HAL_UART_DISABLE_IT (instance->Handle, UART_IT_TXE);
-          instance->tx_usart_running = 0;
-        }
+    }
+    if (instance->tx_usart_count == 0)
+    {
+      __HAL_UART_DISABLE_IT(instance->Handle, UART_IT_TXE);
+      instance->tx_usart_running = 0;
+    }
+  }
-  __enable_irq ();
+  __enable_irq();
+}
-void
-PutCharSerial (usart_ctl *instance, uint8_t c)
+void PutCharSerial(usart_ctl *instance, uint8_t c)
+{
   // Put character in Crayon/Pen interface
-  PutCharSerialFIFO (instance, c);
+  PutCharSerialFIFO(instance, c);
+}
 /*
  * \brief
  * ResetTxBuffer(void) - resets the serial transmitter buffer
  */
-void
-ResetTxBuffer (usart_ctl *instance)
+void ResetTxBuffer(usart_ctl *instance)
+{
   instance->tx_usart_out_Ptr = 0;
   instance->tx_usart_running = 0;
   instance->tx_usart_in_Ptr = 0; /* setup in pointer last to drop any chars come in */
   instance->tx_usart_count = 0;
+}
 /*
  * \brief
  * void ResetRxBuffer(void) - resets the serial receiver buffer
  */
-void
-ResetRxBuffer (usart_ctl *instance)
+void ResetRxBuffer(usart_ctl *instance)
+{
   instance->rx_usart_out_Ptr = 0;
   instance->rx_usart_buffer_full = 0;
   instance->rx_usart_in_Ptr = 0; /* setup in pointer last to drop any chars come in */
+}
 /***!
  * @brief Flush Serial input and output buffers
  */
-void
-FlushSerial (usart_ctl *instance)
+void FlushSerial(usart_ctl *instance)
+{
-  ResetRxBuffer (instance);
+  ResetRxBuffer(instance);
-  ResetTxBuffer (instance);
+  ResetTxBuffer(instance);
+}
 /***!
  * @brief check if tx buffer is empty...
  */
 uint8_t
-TxBufferEmpty (usart_ctl *instance)
+TxBufferEmpty(usart_ctl *instance)
+{
-  return (0 == instance->tx_usart_count );
+  return (0 == instance->tx_usart_count);
+}
 /***!
  * @brief wait for transmission to finish
  */
 void TxWaitEmpty(usart_ctl *instance)
+{
   while (instance->tx_usart_count ||
-       (instance->Handle->Instance->SR & USART_SR_TC) != RESET) {};
+         (instance->Handle->Instance->SR & USART_SR_TC) != RESET)
+  {
+  };
+}
 /****
  * @brief Initialise control structure
  */
-void
-init_usart_ctl (usart_ctl *instance, UART_HandleTypeDef * handle )
+void init_usart_ctl(usart_ctl *instance, UART_HandleTypeDef *handle)
+{
   instance->Handle = handle;
   /* cheat here - this is a macro and I have the same Instance member as the HAL handle, with the same meaning */
-   __HAL_UART_DISABLE_IT (instance->Handle, UART_IT_TXE);
+  __HAL_UART_DISABLE_IT(instance->Handle, UART_IT_TXE);
-  __HAL_UART_DISABLE_IT (instance->Handle, UART_IT_RXNE);
+  __HAL_UART_DISABLE_IT(instance->Handle, UART_IT_RXNE);
   instance->tx_usart_in_Ptr = 0;
   instance->tx_usart_out_Ptr = 0;
   instance->tx_usart_running = 0;
   instance->tx_usart_count = 0;
   instance->rx_usart_in_Ptr = 0;
   instance->rx_usart_out_Ptr = 0;
   instance->rx_usart_buffer_full = 0;
+}
-void
-setBaud (usart_ctl *ctl, uint32_t baud)
+void setBaud(usart_ctl *ctl, uint32_t baud)
+{
   ctl->Handle->Init.BaudRate = baud;
-  __disable_irq ();
+  __disable_irq();
-  HAL_UART_Init (ctl->Handle);
+  HAL_UART_Init(ctl->Handle);
-  __enable_irq ();
+  __enable_irq();
+}
-void sendString(usart_ctl *ctl, char *string, int length)
+void sendString(usart_ctl *ctl, char const * string , int length)
+{
-  int i;
-  for (i = 0; i < length; i++)
+  for (int i = 0; i < length; i++)
     PutCharSerial(ctl, string[i]);
+}
 /////////////////////////////////////////////////////////
 /// Moved from generated code  to avoid crappy HAL handler
 #if defined SERIAL_UART1
 void USART1_IRQHandler(void)
+{
-        UART_IRQHandler(&uc1);
+  UART_IRQHandler(&uc1);
+}
 #endif
 #if defined SERIAL_UART2
 void USART2_IRQHandler(void)
+{
-        UART_IRQHandler(&uc2);
+  UART_IRQHandler(&uc2);
+}
 #endif
 #if defined SERIAL_UART3
 void USART3_IRQHandler(void)
+{
-        UART_IRQHandler(&uc3);
+  UART_IRQHandler(&uc3);
+}
 #endif
 #if defined SERIAL_UART4
 void UART4_IRQHandler(void)
+{
-        UART_IRQHandler(&uc4);
+  UART_IRQHandler(&uc4);
+}
 #endif
 #if defined SERIAL_UART5
 void UART5_IRQHandler(void)
+{
-        UART_IRQHandler(&uc5);
+  UART_IRQHandler(&uc5);
+}
 #endif

Subversion Repositories libSerial

(root)/trunk/src/serial.c – Rev 7 → 8