(txdata & 1) ? (CCTL0 &= ~OUTMOD2) : (CCTL0 |=  OUTMOD2);

#define OUTMOD2                (0x0080)       /* Output mode 2 */

#include <msp430g2231.h>
#include <stdlib.h>

volatile unsigned txdata = 0;         //

#pragma vector = TIMER0_A0_VECTOR
__interrupt void Timer0_A0(void)
{
    if(txdata) {
        (txdata & 1) ? (CCTL0 &= ~OUTMOD2) : (CCTL0 |=  OUTMOD2); // set/reset TA or toggle
        txdata >>= 1;
        CCR0 += 104;
    } else {
        CCTL0 &= ~CCIE;
    }
}

void putc(const char c)
{
    while(CCTL0 & CCIE);
    txdata = 0x0200 | (c << 1);
    CCR0 = TAR + 16;
    CCTL0 = OUTMOD0 | CCIE;
}

void print(const char *s)
{
    while(*s) putc(*s++);
}

void print_hex_digit(unsigned n)
{
    putc("0123456789ABCDEF"[n & 0x0F]);
}

void print_hex_byte(unsigned n)
{
    print_hex_digit(n >> 4);
    print_hex_digit(n);
}

void print_dec2(int n)
{
    // Print 2 decimal digits  0 to 99
    const div_t d = div(n, 10);
    if(d.quot) putc('0' + d.quot);
    putc('0' + d.rem);
}

int read_dht(unsigned char *p)
{
                                                                // Note: TimerA must be continuous mode (MC_2) at 1 MHz
    const unsigned b = BIT4;                                    // I/O bit
    const unsigned char *end = p + 6;                           // End of data buffer
    register unsigned char m = 1;                               // First byte will have only start bit
    register unsigned st, et;                                   // Start and end times
                                                                //
    p[0] = p[1] = p[2] = p[3] = p[4] = p[5] = 0;                // Clear data buffer
                                                                //
    P1OUT &= ~b;                                                // Pull low
    P1DIR |= b;                                                 // Output
    P1REN &= ~b;                                                // Drive low
    st = TAR; while((TAR - st) < 18000);                        // Wait 18 ms
    P1REN |= b;                                                 // Pull low
    P1OUT |= b;                                                 // Pull high
    P1DIR &= ~b;                                                // Input
                                                                //
    st = TAR;                                                   // Get start time for timeout
    while(P1IN & b) if((TAR - st) > 100) return -1;             // Wait while high, return if no response
    et = TAR;                                                   // Get start time for timeout
    do {                                                        //
        st = et;                                                // Start time of this bit is end time of previous bit
        while(!(P1IN & b)) if((TAR - st) > 100) return -2;      // Wait while low, return if stuck low
        while(P1IN & b) if((TAR - st) > 200) return -3;         // Wait while high, return if stuck high
        et = TAR;                                               // Get end time
        if((et - st) > 110) *p |= m;                            // If time > 110 us, then it is a one bit
        if(!(m >>= 1)) m = 0x80, ++p;                           // Shift mask, move to next byte when mask is zero
    } while(p < end);                                           // Do until array is full
                                                                //
    p -= 6;                                                     // Point to start of buffer
    if(p[0] != 1) return -4;                                    // No start bit
    if(((p[1] + p[2] + p[3] + p[4]) & 0xFF) != p[5]) return -5; // Bad checksum
                                                                //
    return 0;                                                   // Good read
}

void main(void)
{
    unsigned char dht[6];                           // Data from DHT11
    int err;                                        //
    unsigned n;                                     //
                                                    //
    WDTCTL = WDTPW | WDTHOLD;                       // Disable watchdog reset
    DCOCTL = 0;                                     // Run at 1 MHz
    BCSCTL1 = CALBC1_1MHZ;                          //
    DCOCTL  = CALDCO_1MHZ;                          //
    CCTL0 = OUT;                                    // Setup serial tx I/O
    P1SEL = BIT1;                                   //
    P1DIR = BIT1;                                   //
    TACTL = TASSEL_2 | MC_2;                        // TimerA SMCLK, continuous
    __enable_interrupt();                           //
                                                    //
    for(;;) {                                       // for-ever
        while(CCTL0 & CCIE);                        // Wait for any serial tx to finish
        err = read_dht(dht);                        // Read DHT11
        if(err) {                                   // If error...
            print("Error -");                       //
            putc('0' - err);                        //
            print("\r\n");                          //
        } else {                                    // No error...
            for(n = 0; n < sizeof(dht); ++n) {      // Show hex data
                print_hex_byte(dht[n]);             //
                putc(' ');                          //
            }                                       //
            print(" ");                             //
            print_dec2(dht[1]);                     // Show humimidy
            print(" RH  ");                         //
            print_dec2(dht[3]);                     // Show temperature
            print(" C\r\n");                        //
        }                                           //
        __delay_cycles(1000000);                    // Wait a while
    }                                               //
}