Electronic – Bit Banging UART

cmicrocontrollerpicserialuart

My full code is located here.

Basically, I'm transmitting to an Arduino, and I'm not receiving the correct value (you'll notice I'm trying to send d'22'). Here's the method where I actually bit bang the transmission:

// Method for transmitting value using serial bit banging
void uart_tx_bit_bang(unsigned char val) {
    unsigned char i;
    Tx_Pin = 0;                         // Start bit
    uart_time_delay();
    for ( i = 8 ; i != 0 ; --i ) {
        if (val & 0x01) Tx_Pin = 1;   // Begin with LSB
        else            Tx_Pin = 0;
        val >>= 1;
        uart_time_delay();
        }
    Tx_Pin = 1;                         // Stop bit
    uart_time_delay();
}

Since the delay should be 1/baud, uart_time_delay() should be a 104us delay. I'm using __delay_us(104) from the PIC libraries. Any help on this is greatly appreciated.

I'm positive that I'm using the correct baud rate on both ends.

Best Answer

While your calculation of 104uS is correct for 9600BPS your loop and the various operations it performs will be adding an additional delay. There are a few ways you could go about tuning the timing:

Subtract a constant from your uS delay until it starts working. It'd probably be best to determine the minimum / maximum number it works with and pick the middle value.
Do something similar using a scope to check the final timing if you have one available.
Look at the assembler output from the compiler and determine how many cycles the loop takes.

I also see you're using the RC clock. I normally like to keep my serial timing within 2% for reliable operation so also check to make sure the part has that much stability when using the RC clock for reliable operation.

Related Solutions

Electronic – Bit banging a UART

You probably want to use an ordinary timer interrupt and sample at perhaps 8 times the baud rate though four times might possibly work (in hardware implementations 16x is common, but I've personally done it at 8x).

Most processors of modern clock speed should be able to fire an interrupt that fast, at least if your code in the ISR is efficient and you don't have much else interrupt-driven running.

You will probably want to run a state machine, advancing one state on each interrupt. Basically you look for the start bit transition and then read each data bit an appropriate number of oversampled cycles later. There are lots of implementations of this for FPGAs in verilog or VHDL floating around the net, translating back to assembly or C should not be difficult.

However, as you can likely reprogram your timers and interrupt modes quickly, there is another option for optimization: You could start out by having an edge sensitive interrupt on the input pin. When that fires, you then program a timer interrupt to generate delays of precisely a bit period (not oversampled), and simply read out the state on each interrupt. When the word is concluded, re-arm the edge interrupt.

But there is a catch with this optimized method: because you are only "paying attention" at the important times, you have to work harder to make sure that the initial transition is a start bit, and that you aren't catching some data word in mid-flight when your code starts up. Probably you want to do this by using your edge interrupt to make sure that the input has been in a quiescent state long enough (long enough since the last interrupt) - if it hasn't, discard what your get and wait for a clean character.

Some googling on "UART state machine" or the like would be informative. There's always the chance you will find reference code for your particular processor, particularly if it has no hardware UART or only one.

Electronic – bit banging

Bit banging is creating the whole series of pulses in software, instead of relying on a piece of hardware inside the microcontroller.

Many microcontrollers have a hardware SPI, and then all you have to do is write a byte to the output register, and the SPI controller will shift the data out, and at the same time receive data from the slave. You can get an interrupt when the transfer is complete, and then read the received data.

But some microcontrollers don't have the SPI hardware on board and then you have to simulate it by doing everything manually. SPI has a number of different modes, I'll use this pulse diagram as an example:

enter image description here

So while a dedicated SPI controller takes care of all the pulses, data shifting and timing, when bit-banging you have to take every action yourself:

Make Slave Select low  
Short delay
Do 8 times
  Make the SCK (Serial Clock) pin low 
  Make the MOSI (Master-Out-Slave-In) pin high or low depending on bit 7 of the data  
  Add brief delay  
  Make the SCK output high
  Read MISO (Master-In-Slave-Out) pin
  Shift received data left, and shift the bit just read in as bit 0   
  Add brief delay  
  Shift the data byte 1 bit left
Make Slave Select high again

Bit-banging SPI is relatively simple, the code for bit-banging I2C for instance will be more complex, and you'll need a timer somehow if you want to bit-bang the UART protocol.

Best Answer

Related Solutions

Electronic – Bit banging a UART

Electronic – bit banging

Related Topic