Make XPLAINBridge serial bridge much more reliable for the reception of characters...

[pub/USBasp.git] / Projects / XPLAINBridge / Lib / SoftUART.c

diff --git a/Projects/XPLAINBridge/Lib/SoftUART.c b/Projects/XPLAINBridge/Lib/SoftUART.c
index 194481d..02223af 100644 (file)
--- a/Projects/XPLAINBridge/Lib/SoftUART.c
+++ b/Projects/XPLAINBridge/Lib/SoftUART.c
@@ -30,114 +30,122 @@
   this software.
 */
 
   this software.
 */
 

-#include "SoftUART.h"
-
-volatile uint8_t srx_done, stx_count;
-volatile uint8_t srx_data, srx_mask, srx_tmp, stx_data;
-
-uint8_t SoftUART_IsReady(void)
-{
-       return !(stx_count);
-}
+/** \file
+ *
+ *  Software UART for both data transmission and reception. This
+ *  code continuously monitors the ring buffers set up by the main
+ *  project source file and reads/writes data as it becomes available.
+ */

 
 

-uint8_t SoftUART_TxByte(uint8_t Byte)
-{
-       while (stx_count);
-
-       stx_data  = ~Byte;
-       stx_count = 10;
-
-       return Byte;
-}
+#include "SoftUART.h"

 
 

-uint8_t SoftUART_IsReceived(void)
-{
-       return srx_done;
-}
+/** Total number of bits remaining to be sent in the current frame */
+static uint8_t TX_BitsRemaining;

 
 

-uint8_t SoftUART_RxByte(void)
-{
-       while (!(srx_done));
+/** Temporary data variable to hold the byte being transmitted as it is shifted out */
+static uint8_t TX_Data;

 
 

-       srx_done = 0;
+/** Current bit mask of the bit being shifted into the received data byte */
+static uint8_t RX_BitMask;

 
 

-       return srx_data;
-}
+/** Temporary data variable to hold the byte being received as it is shifted in */
+static uint8_t RX_Data;

 
 

+/** Initializes the software UART, ready for data transmission and reception into the global ring buffers. */

 void SoftUART_Init(void)
 {
 void SoftUART_Init(void)
 {

-       OCR2B  = TCNT2 + 1;                                             // force first compare
-       TCCR2A = (1 << COM2B1) | (1 << COM2B0); // T1 mode 0
-       TCCR2B = (1 << FOC2B)  | (1 << CS21);   // CLK/8, T1 mode 0
-       TIMSK2 = (1 << OCIE2B);                                 // enable tx and wait for start
-       EICRA  = (1 << ISC01);                                  // -ve edge
-       EIMSK  = (1 << INT0);                                   // enable INT0 interrupt
-
-       stx_count = 0;                                                  // nothing to send
-       srx_done = 0;                                                   // nothing received
-       STXPORT |= 1 << STX;                                    // TX output
-       STXDDR  |= 1 << STX;                                    // TX output
-       SRXPORT |= (1 << SRX);                                  // pullup on INT0
+       /* Set TX pin to output high, enable RX pull-up */
+       STXPORT |= (1 << STX);
+       STXDDR  |= (1 << STX);
+       SRXPORT |= (1 << SRX);
+
+       /* Enable INT0 for the detection of incoming start bits that signal the start of a byte */
+       EICRA  = (1 << ISC01);
+       EIMSK  = (1 << INT0);
+
+       /* Start software UART transmission and reception timers */
+       TIMSK3 = (1 << OCIE3A);
+       TCCR3B = (1 << CS30);
+       TCCR1B = (1 << CS10);

 }
 
 }
 

-/* ISR to detect the start of a bit being sent from the transmitter. */
-ISR(INT0_vect)
+/** ISR to detect the start of a bit being sent to the software UART. */
+ISR(INT0_vect, ISR_BLOCK)

 {
 {

-       OCR2A = TCNT2 + (BIT_TIME / 8 * 3 / 2); // scan 1.5 bits after start
+       /* Set reception channel to fire 1.5 bits past the beginning of the start bit */
+       OCR1A = TCNT1 + (BIT_TIME + (BIT_TIME / 2));

 
 

-       srx_tmp = 0;                                                    // clear bit storage
-       srx_mask = 1;                                                   // bit mask
+       /* Clear the received data temporary variable, reset the current received bit position mask */
+       RX_Data    = 0;
+       RX_BitMask = (1 << 0);

 
 

-       TIFR2 = (1 << OCF2A);                                   // clear pending interrupt
+       /* Clear reception channel ISR flag and enable the bit reception ISR */
+       TIFR1  = (1 << OCF1A);
+       TIMSK1 = (1 << OCIE1A);         

 
 

-       if (!(SRXPIN & (1 << SRX)))                             // still low
-       {
-               TIMSK2 = (1 << OCIE2A) | (1 << OCIE2B); // wait for first bit
-               EIMSK &= ~(1 << INT0);
-       }
+       /* Disable start bit detection ISR while the next byte is received */
+       EIMSK &= ~(1 << INT0);

 }
 
 }
 

-/* ISR to manage the reception of bits to the transmitter. */
-ISR(TIMER2_COMPA_vect)
+/** ISR to manage the reception of bits to the software UART. */
+ISR(TIMER1_COMPA_vect, ISR_BLOCK)

 {
 {

-       if (srx_mask)
+       /* Move the reception ISR compare position one bit ahead */
+       OCR1A += BIT_TIME;
+
+       /* Check if reception has finished */
+       if (RX_BitMask)

        {
        {

+               /* Store next bit into the received data variable */

                if (SRXPIN & (1 << SRX))
                if (SRXPIN & (1 << SRX))

-                 srx_tmp |= srx_mask;
-
-               srx_mask <<= 1;
+                 RX_Data |= RX_BitMask;

 
 

-               OCR2A += BIT_TIME / 8;                          // next bit slice
+               /* Shift the current received bit mask to the next bit position */
+               RX_BitMask <<= 1;

        }
        else
        {
        }
        else
        {

-               srx_done  = 1;                                          // mark rx data valid
-               srx_data  = srx_tmp;                            // store rx data
-               TIMSK2    = (1 << OCIE2B);                      // enable tx and wait for start
-               EIMSK    |= (1 << INT0);                        // enable START irq
-               EIFR      = (1 << INTF0);                       // clear any pending
+               /* Reception complete, store the received byte */
+               RingBuffer_Insert(&UARTtoUSB_Buffer, RX_Data);
+       
+               /* Disable the reception ISR as all data has now been received, re-enable start bit detection ISR */
+               TIMSK1 = 0;
+               EIFR   = (1 << INTF0);
+               EIMSK  = (1 << INT0);

        }
 }
 
        }
 }
 

-/* ISR to manage the transmission of bits to the receiver. */
-ISR(TIMER2_COMPB_vect)
+/** ISR to manage the transmission of bits via the software UART. */
+ISR(TIMER3_COMPA_vect, ISR_NOBLOCK)

 {
 {

-       OCR2B += BIT_TIME / 8;                                  // next bit slice
+       /* Move the transmission ISR compare position one bit ahead */
+       OCR3A += BIT_TIME;

 
 

-       if (stx_count)
+       /* Check if transmission has finished */
+       if (TX_BitsRemaining)

        {
        {

-               if (--stx_count != 9)                           // no start bit
+               /* Check if we are sending a data bit, or the start bit */
+               if (--TX_BitsRemaining != 9)

                {
                {

-                       if (!(stx_data & 1))                    // test inverted data
-                         TCCR2A = (1 << COM2B1) | (1 << COM2B0);
+                       /* Set the TX line to the value of the next bit in the byte to send */
+                       if (TX_Data & (1 << 0))
+                         STXPORT &= ~(1 << STX);

                        else
                        else

-                         TCCR2A = (1 << COM2B1);
+                         STXPORT |=  (1 << STX);

 
 

-                       stx_data >>= 1;                                 // shift zero in from left
+                       /* Shift the transmission byte to move the next bit into position */
+                       TX_Data >>= 1;

                }
                else
                {
                }
                else
                {

-                       TCCR2A = (1 << COM2B1);                 // START bit
+                       /* Start bit - keep TX line low */
+                       STXPORT &= ~(1 << STX);

                }
        }
                }
        }

+       else if (USBtoUART_Buffer.Count)
+       {
+               /* Transmission complete, get the next byte to send (if available) */
+               TX_Data = ~RingBuffer_Remove(&USBtoUART_Buffer);
+               TX_BitsRemaining = 10;
+       }

 } 
 }