Jump to content
43oh

areben

Members
  • Content Count

    6
  • Joined

  • Last visited

Posts posted by areben

  1. ROCKETuC is a library for launchpad, processing and Java which allows for control of the microcontroller through USB.

     

    Stefan Wendler and I (mostly Stefan :) ) have been putting this together to get it to a state to release for feedback.

     

    "ROCKETuC is a Library for fast prototyping of micro-controllers through serial protocols.

    Currently the TI Launchpad with an MSP430G2553 installed is the only supported

    hardware."

     

    Right now, we have a github page with a pre-alpha release

     

    https://github.com/areben/ROCKETuC

     

     

    A how-to for processing

     

    Processing example code

     

    Here is an image of a simple GUI in processing by Stefan:

    wis4z.png

     

    Source code for the GUI

     

    We are looking for people to try it out and give some feedback.

    We are also looking for coders to help with the project, specifically with the processing library, add-on modules, documentation and website.

     

    We will also have a homepage up at

    homepage: http://rocketuc.com

  2. Hello

     

    I am having trouble getting my code to receive an RX byte when I use the cap sense library.

    It either freezes the code or does not echo.

     

    Here is my (hacked up) code:

     

    /*******************************************************************************
    *
    *  CapTouchBoosterPack_UserExperience.c
    *     - MSP430 firmware application to demonstrate the capacitive touch
    *       capability of the MSP430G2452 interfacing with the LaunchPad CapTouch
    *       BoosterPack.
    *
    *  Copyright (C) 2011 Texas Instruments Incorporated - 
    *
    *  Redistribution and use in source and binary forms, with or without
    *  modification, are permitted provided that the following conditions
    *  are met:
    *
    *    Redistributions of source code must retain the above copyright
    *    notice, this list of conditions and the following disclaimer.
    *
    *    Redistributions in binary form must reproduce the above copyright
    *    notice, this list of conditions and the following disclaimer in the
    *    documentation and/or other materials provided with the
    *    distribution.
    *
    *    Neither the name of Texas Instruments Incorporated nor the names of
    *    its contributors may be used to endorse or promote products derived
    *    from this software without specific prior written permission.
    *
    *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
    *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
    *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
    *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
    *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
    *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
    *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
    *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
    *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
    *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
    *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    *
    *
    ******************************************************************************/
    
    /******************************************************************************
    *         MSP430G2-LaunchPad CapTouch BoosterPack User Experience
    *
    * This application operates on the LaunchPad platform using the MSP430G2452
    * device and the CapTouch BoosterPack plugin board. The capacitive touch and
    * proximity sensing are enabled by the pin oscillator feature new to the
    * MSP430G2xx2 family devices. The User Experience application also utilizes
    * the cap touch library to realize & measure the capacitive touch and proximity
    * sensors. The cap touch library also provides layers of abstractions to
    * generate higher logical outputs such as logical touches, geometry (in this
    * hardware, a four-button wheel), and even gestures.
    *
    * The User Experience application starts up and remains in 'sleep' mode,
    * sampling the proximity sensor every ~8.3ms [VLO/100=12kHz/100=120Hz]. Upon
    * registering a valid proximity event [hand/finger/object hovering ~3-5cm from
    * the BoosterPack], the application wakes up to operate in the 'active' mode.
    *
    * In active mode, the application samples and registers individual finger touches
    * on the 16-position wheel or the center button as well as simple gestures
    * [Clockwise & Counter-clockwise] while the finger moves along and remains on
    * the wheel.
    *
    * a 9600 baud UART link is also implemented using SW TimerA to provide
    * application and cap touch data back to the PC via the UART-USB back channel.
    * The application sends UART data upon events such as wake up, sleep, touch,
    * or gesture.
    *
    * D. Dang
    * Texas Instruments, Inc.
    * Ver 0.90 Feb 2011
    ******************************************************************************/
    
    
    
    #include "CTS_Layer.h"
    #include "uart.h"
    
    
    #define WAKE_UP_UART_CODE       0xBE
    #define WAKE_UP_UART_CODE2      0xEF
    #define SLEEP_MODE_UART_CODE    0xDE
    #define SLEEP_MODE_UART_CODE2   0xAD
    #define MIDDLE_BUTTON_CODE      0x80
    #define INVALID_GESTURE         0xFD
    #define GESTURE_START           0xFC
    #define GESTURE_STOP            0xFB
    #define COUNTER_CLOCKWISE       1
    #define CLOCKWISE               2
    #define GESTURE_POSITION_OFFSET 0x20
    #define WHEEL_POSITION_OFFSET   0x30
    
    #define WHEEL_TOUCH_DELAY		    12			    //Delay between re-sendings of touches
    #define MAX_IDLE_TIME           200
    #define PROXIMITY_THRESHOLD     60
    
    unsigned int wheel_position=ILLEGAL_SLIDER_WHEEL_POSITION, last_wheel_position=ILLEGAL_SLIDER_WHEEL_POSITION;
    unsigned int deltaCnts[1];
    unsigned int prox_raw_Cnts;
    
    
    
    
    /*----------------- LED definition---------------------------------------------
    * There are 8 LEDs to represent different positions around the wheel. They are
    * controlled by 5 pins of Port 1 using a muxing scheme. The LEDs are divided
    * vertically into two groups of 4, in which each LED is paired up [muxed] with
    * the LED mirrored on the other side of the imaginary center vertical line via
    * the use of pin P1.3 and one specific port pin.
    * Specifically, the pairs are LEDs [0,7], [1,6], [2,5], [3,4], as shown in the
    * diagram below.
    *     LED                        Position (degrees, clockwise)
    * --RIGHT SIDE--
    *      0       BIT4,!BIT3                  45
    *      1       BIT5,!BIT3                  80
    *      2       BIT6,!BIT3                 100
    *      3       BIT7,!BIT3                 135 *
    *
    * --LEFT SIDE--
    *      4       BIT3,(BIT4,5,6)             225
    *      5       BIT3,(BIT4,5,7)             260
    *      6       BIT3,(BIT4,6,7)             280
    *      7       BIT3,(BIT5,6,7)             315
    *----------------------------------------------------------------------------*/
    #define MASK7                   BIT4
    #define MASK6                   BIT5
    #define MASK5                   BIT6
    #define MASK4                   BIT7
    
    #define MASK3                   (BIT3+BIT4+BIT5+BIT6)
    #define MASK2                   (BIT3+BIT4+BIT5+BIT7)
    #define MASK1                   (BIT3+BIT4+BIT6+BIT7)
    #define MASK0                   (BIT3+BIT5+BIT6+BIT7)
    
    const unsigned char LedWheelPosition[16] =
                                   {
                                     MASK0, MASK0, MASK0 & MASK1, MASK1,
                                     MASK1 & MASK2, MASK2, MASK2 & MASK3, MASK3,
                                     MASK4, MASK4, MASK4 | MASK5, MASK5,
                                     MASK5 | MASK6,  MASK6, MASK6 | MASK7, MASK7
                                   };
    const unsigned char startSequence[8] =
                                   {
    							    MASK0,
    							    MASK1,
    							    MASK2,
    							    MASK3,
    							    MASK4,
    							    MASK5,
    							    MASK6,
    							    MASK7
    							   };
    /*----------------- LED definition------------------------------*/
    
    void echo();
    
    
    void InitLaunchPadCore(void)
    
    {
     BCSCTL1 |= DIVA_0;                    // ACLK/(0:1,1:2,2:4,3:8)
     BCSCTL3 |= LFXT1S_2;                  // LFXT1 = VLO
    
     // Port init
     P1OUT &= ~(BIT3+BIT4+BIT5+BIT6+BIT7+BIT0);
     P1DIR |= BIT3+BIT4+BIT5+BIT6+BIT7+BIT0;
     P2SEL = 0x00;                         // No XTAL
     P2DIR |= (BIT0+BIT4+BIT2+BIT3+BIT1+BIT5);
     P2OUT &= ~(BIT0+BIT4+BIT2+BIT3+BIT1+BIT5);
    }
    
    void SendByte(unsigned char touch)
    {
    // TimerA_UART_init();
     TimerA_UART_tx(touch);
    //  TimerA_UART_shutdown();
    }
    
    
    /* ----------------MeasureCapBaseLine--------------------------------------
    * Re-measure the baseline capacitance of the wheel elements & the center
    * button. To be called after each wake up event.
    * ------------------------------------------------------------------------*/
    void MeasureCapBaseLine(void)
    {
     //P1OUT = BIT0;
     /* Set DCO to 8MHz */
     /* SMCLK = 8MHz/8 = 1MHz */
     BCSCTL1 = CALBC1_8MHZ;
     DCOCTL = CALDCO_8MHZ;
     BCSCTL2 |= DIVS_3;
    
     TI_CAPT_Init_Baseline(&wheel);
     TI_CAPT_Update_Baseline(&wheel,2);
     TI_CAPT_Init_Baseline(&middle_button);
     TI_CAPT_Update_Baseline(&middle_button,2);
    }
    
    /* ----------------GetGesture----------------------------------------------
    * Determine immediate gesture based on current & previous wheel position
    * ------------------------------------------------------------------------*/
    unsigned char GetGesture(unsigned char wheel_position)
    {
    unsigned char gesture = INVALID_GESTURE, direction, ccw_check, cw_check;
    // ******************************************************************************
    // gesturing
    // determine if a direction/swipe is occuring
    // the difference between the initial position and
    // the current wheel position should not exceed 8
    // 0-1-2-3-4-5-6-7-8-9-A-B-C-D-E-F-0...
    //
    // E-F-0-1-2:  cw, 4
    // 2-1-0-F-E: ccw, 4
    // A-B-C-D-E-F
    
     //if(initial_wheel_position == INVALID_WHEEL_POSITION)
     //{
       //gesture = 0;
       //initial_wheel_position = wheel_position;
     //}
     //else
    
     if(last_wheel_position != ILLEGAL_SLIDER_WHEEL_POSITION)
     {
       if(last_wheel_position  > wheel_position)
       {
         // E-D-C-B-A:  ccw, 4
         // counter clockwise: 0 < (init_wheel_position - wheel_position) < 8
         //                    gesture = init_wheel_position - wheel_position
         //
         // E-F-0-1-2:  cw, 4
         // clockwise:        0 < (init_wheel_position+wheel_position)-16 <8
         //
         ccw_check = last_wheel_position  - wheel_position;
         if(ccw_check < 8)
         {
           gesture = ccw_check;
           direction = COUNTER_CLOCKWISE;
         }
         else
         {
           // E-F-0-1-2:  cw, 4
           // 16 - 14 + 2 = 4
           cw_check = 16 - last_wheel_position  + wheel_position ;
           if(cw_check < 8)
           {
               gesture = cw_check;
               direction = CLOCKWISE;
           }
         }
       }
       else
       {
         // initial_wheel_position <= wheel_position
         //
         // 2-1-0-F-E: ccw, 4
         // counter clockwise:
         //                    0 < (init_wheel_position+wheel_position)-16 <8
         //                    gesture = init_wheel_position - wheel_position
         //
         // 0-1-2-3-4:  cw, 4
         // clockwise:        0 < (wheel_position - init_wheel_position) < 8
         //
         cw_check = wheel_position - last_wheel_position ;
         if(cw_check < 8)
         {
           gesture = cw_check;
           direction = CLOCKWISE;
         }
         else
         {
           // 2-1-0-F-E: ccw, 4
           // 16 + 2 - 14 = 4
           ccw_check = 16 + last_wheel_position  - wheel_position ;
           if(ccw_check < 8)
           {
             gesture = ccw_check;
             direction = COUNTER_CLOCKWISE;
           }
         }
       }
     }
     if (gesture == INVALID_GESTURE)
     	return gesture;
     if (direction == COUNTER_CLOCKWISE)
       return (gesture + 16);
     else
       return gesture;
    }
    
    /* ----------------CapTouchActiveMode----------------------------------------------
    * Determine immediate gesture based on current & previous wheel position
    *
    *
    *
    *
    *
    *
    *
    * -------------------------------------------------------------------------------*/
    void CapTouchActiveMode()
    {
     unsigned char idleCounter, activeCounter;
     unsigned char gesture, gestureDetected;
     unsigned char centerButtonTouched = 0;
     unsigned int wheelTouchCounter = WHEEL_TOUCH_DELAY - 1;
    
    
     gesture = INVALID_GESTURE;            // Wipes out gesture history
    
     /* Send status via UART: 'wake up' = [0xBE, 0xEF] */
    // SendByte(WAKE_UP_UART_CODE);
     //SendByte(WAKE_UP_UART_CODE2);
    
     idleCounter = 0;
     activeCounter = 0;
     gestureDetected = 0;
    
     while (idleCounter++ < MAX_IDLE_TIME)
     {
      /* Set DCO to 8MHz */
      /* SMCLK = 8MHz/8 = 1MHz */
       BCSCTL1 = CALBC1_8MHZ;
       DCOCTL = CALDCO_8MHZ;
       BCSCTL2 |= DIVS_3;
       TACCTL0 &= ~CCIE;
    
    
       wheel_position = ILLEGAL_SLIDER_WHEEL_POSITION;
       wheel_position = TI_CAPT_Wheel(&wheel);
    
       /* Process wheel touch/position/gesture  if a wheel touch is registered*/
       /* Wheel processing has higher priority than center button*/
    
       if(wheel_position != ILLEGAL_SLIDER_WHEEL_POSITION)
       {
         centerButtonTouched = 0;
    
         /* Adjust wheel position based: rotate CCW by 2 positions */
         if (wheel_position < 0x08)
         {
            wheel_position += 0x40 - 0x08;
         }
         else
         {
            wheel_position -= 0x08;
               /* Adjust wheel position based: rotate CCW by 2 positions */
         }
    
         wheel_position = wheel_position >>2;  // divide by four
    
         gesture = GetGesture(wheel_position);
    
         /* Add hysteresis to reduce toggling between wheel positions if no gesture
          * has been TRULY detected. */
    
         if ( (gestureDetected==0) && ((gesture<=1) || (gesture==0x11) || (gesture==0x10)))
         {
           if (last_wheel_position != ILLEGAL_SLIDER_WHEEL_POSITION)
               wheel_position = last_wheel_position;
           gesture = 0;
         }
    
         /* Turn on corresponding LED(s) */
         P1OUT = (P1OUT & BIT0) | LedWheelPosition[wheel_position];
    
    
         if ((gesture != 0) && (gesture != 16) && (gesture != INVALID_GESTURE))
         { /* A gesture has been detected */
    
           if (gestureDetected ==0)
           { /* Starting of a new gesture sequence */
             gestureDetected = 1;
    
             /* Transmit gesture start status update & position via UART to PC */
             SendByte(GESTURE_START);
             SendByte(last_wheel_position + GESTURE_POSITION_OFFSET);
           }
    
           /* Transmit gesture & position via UART to PC */
           SendByte(gesture);
           SendByte(wheel_position + GESTURE_POSITION_OFFSET);
         }
         else
           if (gestureDetected==0)
           { /* If no gesture was detected, this is constituted as a touch/tap */
             if (++wheelTouchCounter >= WHEEL_TOUCH_DELAY)
             {
             	/* Transmit wheel position [twice] via UART to PC */
             	wheelTouchCounter = 0;
             	SendByte(wheel_position + WHEEL_POSITION_OFFSET );
             	SendByte(wheel_position + WHEEL_POSITION_OFFSET );
             }
           }
          	else
             wheelTouchCounter = WHEEL_TOUCH_DELAY - 1;
    
         idleCounter = 0;                      // Reset idle counter
         activeCounter++;
         last_wheel_position = wheel_position;
       }
       else
       { /* no wheel position was detected */
    
         if(TI_CAPT_Button(&middle_button))
         { /* Middle button was touched */
           if (centerButtonTouched==0)
           {
             /* Transmit center button code [twice] via UART to PC */
             SendByte(MIDDLE_BUTTON_CODE);
             SendByte(MIDDLE_BUTTON_CODE);
    
             centerButtonTouched = 1;
    
             P1OUT = (P1OUT&BIT0) ^ BIT0;      // Toggle Center LED
           }
           idleCounter = 0;
         }
         else
         { /* No touch was registered at all [Not wheel or center button */
           centerButtonTouched = 0;
           P1OUT &= BIT0;
           if ( (gesture == INVALID_GESTURE) || (gestureDetected ==0))
           { /* No gesture was registered previously */
             if (last_wheel_position  != ILLEGAL_SLIDER_WHEEL_POSITION)
               {
                 /* Transmit last wheel position [twice] via UART to PC */
                 SendByte(last_wheel_position  + WHEEL_POSITION_OFFSET );
                 SendByte(last_wheel_position  + WHEEL_POSITION_OFFSET );
                 wheelTouchCounter = WHEEL_TOUCH_DELAY - 1;
               }
           }
    
             if (gestureDetected == 1)
             { /* A gesture was registered previously */
    
               /* Transmit status update: stop gesture tracking [twice] via UART to PC */
               SendByte(GESTURE_STOP);
               SendByte(GESTURE_STOP);
             }
    
         }
    
         // Reset all touch conditions, turn off LEDs,
         last_wheel_position= ILLEGAL_SLIDER_WHEEL_POSITION;
         gesture = INVALID_GESTURE;
         gestureDetected = 0;
    
       }
    
     /* ------------------------------------------------------------------------
      * Option:
      * Add delay/sleep cycle here to reduce active duty cycle. This lowers power
      * consumption but sacrifices wheel responsiveness. Additional timing
      * refinement must be taken into consideration when interfacing with PC
      * applications GUI to retain proper communication protocol.
      * -----------------------------------------------------------------------*/
     }
    }
    
    void echo(){
        char in = getRx();
    	  SendByte(in);
    }
    
    void main(void)
    {
    
     WDTCTL = WDTPW + WDTHOLD;             // Stop watchdog timer
    
     InitLaunchPadCore();
     TimerA_UART_init();
    
     /* Set DCO to 1MHz */
     /* Set SMCLK to 1MHz / 8 = 125kHz */
     BCSCTL1 = CALBC1_1MHZ;
     DCOCTL = CALDCO_1MHZ;
     BCSCTL2 |= DIVS_3;
     /* Establish baseline for the proximity sensor */
     TI_CAPT_Init_Baseline(&proximity_sensor);
     TI_CAPT_Update_Baseline(&proximity_sensor,5);
     MeasureCapBaseLine();
     __enable_interrupt();
     while (1)
     {
       echo();
       CapTouchActiveMode();
     }
    
    }
    

     

     

    and the UART code:

     

    /*******************************************************************************
    *
    *  uart.c - c file for UART communication using MSP430 TimerA 
    *         - peripheral  
    *
    *  Copyright (C) 2011 Texas Instruments Incorporated - 
    * 
    *  Redistribution and use in source and binary forms, with or without 
    *  modification, are permitted provided that the following conditions 
    *  are met:
    *
    *    Redistributions of source code must retain the above copyright 
    *    notice, this list of conditions and the following disclaimer.
    *
    *    Redistributions in binary form must reproduce the above copyright
    *    notice, this list of conditions and the following disclaimer in the 
    *    documentation and/or other materials provided with the   
    *    distribution.
    *
    *    Neither the name of Texas Instruments Incorporated nor the names of
    *    its contributors may be used to endorse or promote products derived
    *    from this software without specific prior written permission.
    *
    *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
    *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
    *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
    *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
    *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
    *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
    *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
    *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
    *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
    *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
    *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    *
    *
    ******************************************************************************/
    #include "uart.h"
    unsigned int txData;
    unsigned int rxBuffer;
    
    //------------------------------------------------------------------------------
    // Function configures Timer_A for full-duplex UART operation
    //------------------------------------------------------------------------------
    void TimerA_UART_init(void)
    {
     DCOCTL = 0x00;                          // Set DCOCLK to 1MHz
     BCSCTL1 = CALBC1_1MHZ;
     DCOCTL = CALDCO_1MHZ;
     BCSCTL2 &= ~DIVS_3;                     // SMCLK = 1MHz  
    
     P1SEL |= UART_TXD + UART_RXD;            // Timer function for TXD/RXD pins
    //  P1SEL |= UART_TXD ;
     P1DIR |= UART_TXD;                        // TXD 
     P1DIR &= ~UART_RXD;
    
     TACCTL0 = OUT;                          // Set TXD Idle as Mark = '1'
      TACCTL1 = SCS + CM1 + CAP + CCIE;       // Sync, Neg Edge, Capture, Int
     TACTL |= TACLR;                           // SMCLK, start in continuous mode  
     TACTL = TASSEL_2 + MC_2;                // SMCLK, start in continuous mode
    
    
    }
    
    //------------------------------------------------------------------------------
    // Outputs one byte using the Timer_A UART
    //------------------------------------------------------------------------------
    void TimerA_UART_tx(unsigned char byte)
    {
       while (TACCTL0 & CCIE);                 // Ensure last char got TX'd
       TACCR0 = TAR;                           // Current state of TA counter
       TACCR0 += UART_TBIT;                    // One bit time till first bit
       txData = byte;                          // Load global variable
       txData |= 0x100;                        // Add mark stop bit to TXData
       txData <<= 1;                           // Add space start bit
       TACCTL0 = OUTMOD0 + CCIE;               // Set TXD on EQU2 (idle), Int
     __bis_SR_register(GIE);
    }
    //------------------------------------------------------------------------------
    // Prints a string over using the Timer_A UART
    //------------------------------------------------------------------------------
    void TimerA_UART_print(char *string)
    {
       while (*string) {
           TimerA_UART_tx(*string++);
       }
    }
    //------------------------------------------------------------------------------
    // Timer_A UART - Transmit Interrupt Handler
    //------------------------------------------------------------------------------
    #pragma vector = TIMER0_A0_VECTOR
    __interrupt void Timer_A0_ISR(void)
    {
       static unsigned char txBitCnt = 10;
         TACCR0 += UART_TBIT;                    // Add Offset to CCRx
         if (--txBitCnt == 0)                    // All bits TXed?
         {                    
             TACCTL0 &= ~CCIE;                   // All bits TXed, disable interrupt
             txBitCnt = 10;
             __bic_SR_register_on_exit(GIE);
         }
         else {
             if (txData & 0x01) {
               TACCTL0 &= ~OUTMOD2;              // TX Mark '1'
             }
             else {
               TACCTL0 |= OUTMOD2;               // TX Space '0'
             }
             txData >>= 1;
    
         }
    }
    
    
    //------------------------------------------------------------------------------
    // Timer_A UART - Receive Interrupt Handler
    //------------------------------------------------------------------------------
    #pragma vector = TIMER0_A1_VECTOR
    __interrupt void Timer_A1_ISR(void)
    {
       static unsigned char rxBitCnt = 8;
       static unsigned char rxData = 0;
    
       switch (__even_in_range(TA0IV, TA0IV_TAIFG)) { // Use calculated branching
           case TA0IV_TACCR1:                        // TACCR1 CCIFG - UART RX
               TACCR1 += UART_TBIT;                 // Add Offset to CCRx
               if (TACCTL1 & CAP) {                 // Capture mode = start bit edge
                   TACCTL1 &= ~CAP;                 // Switch capture to compare mode
                   TACCR1 += UART_TBIT_DIV_2;       // Point CCRx to middle of D0
               }
               else {
                   rxData >>= 1;
                   if (TACCTL1 & SCCI) {            // Get bit waiting in receive latch
                       rxData |= 0x80;
                   }
                   rxBitCnt--;
                   if (rxBitCnt == 0) {             // All bits RXed?
                       rxBuffer = rxData;           // Store in global variable
                       rxBitCnt = 8;                // Re-load bit counter
                       TACCTL1 |= CAP;              // Switch compare to capture mode
                       __bic_SR_register_on_exit(LPM0_bits);  // Clear LPM0 bits from 0(SR)
                   }
               }
               break;
       }
    }
    //------------------------------------------------------------------------------
    
    int getRx()
    {
    return rxBuffer;
    }
    
    

  3. Ok,

     

    Solved my own problem

     

    in the example code

     

    __bis_SR_register(LPM0_bits + GIE); // Enter LPM0, interrupts enabled

     

    puts the CPU to sleep

     

    changing it to

     

    __bis_SR_register(GIE);

     

    worked

  4. Hello

     

    I'm sure this is obvious, but I used the example code for hardware serial for the MSP430

    My problem is:

     

    The code never runs my while(1)

    The code returns "Hello World" when I send u

    The code does not toggle the pin when I send c

     

    Tips appreciated :D

     

    #include  "msp430g2553.h"
    
    #define BEEP_PIN BIT0
    
    
    const char string1[] = { "Hello World\r\n" };
    unsigned int charLoop;
    
    void main(void)
    {
     WDTCTL = WDTPW + WDTHOLD;                 // Stop WDT
     BCSCTL1 = CALBC1_1MHZ;                    // Set DCO
     DCOCTL = CALDCO_1MHZ;
     P1SEL = BIT1 + BIT2 ;                     // P1.1 = RXD, P1.2=TXD
     P1SEL2 = BIT1 + BIT2 ;                     // P1.1 = RXD, P1.2=TXD
     UCA0CTL1 |= UCSSEL_2;                     // SMCLK
     UCA0BR0 = 104;                            // 1MHz 9600
     UCA0BR1 = 0;                              // 1MHz 9600
     UCA0MCTL = UCBRS0;                        // Modulation UCBRSx = 1
     UCA0CTL1 &= ~UCSWRST;                     // **Initialize USCI state machine**
     IE2 |= UCA0RXIE;                          // Enable USCI_A0 RX interrupt
    
     //set outputs
     P1DIR |= BEEP_PIN;
     P1OUT = 0x00; //clear port 1
    
    
    __bis_SR_register(LPM0_bits + GIE);       // Enter LPM0, interrupts enabled
    
     while (1) {
         P1OUT ^= BEEP_PIN;              // Toggle LED on P1.0
         __delay_cycles(1000000);     // Wait ~100ms at default DCO of ~1MHz
     }
    }
    
    #pragma vector=USCIAB0TX_VECTOR
    __interrupt void USCI0TX_ISR(void)
    {
     UCA0TXBUF = string1[charLoop++];                 // TX next character
    
     if (charLoop == sizeof string1 - 1)              // TX over?
       IE2 &= ~UCA0TXIE;                       // Disable USCI_A0 TX interrupt
    }
    
    #pragma vector=USCIAB0RX_VECTOR
    __interrupt void USCI0RX_ISR(void)
    {
     if (UCA0RXBUF == 'u')                     // 'u' received?
     {
       charLoop = 0;
       IE2 |= UCA0TXIE;                        // Enable USCI_A0 TX interrupt
       UCA0TXBUF = string1[charLoop++];
     }
     else if (UCA0RXBUF == 'c')
     {
    P1OUT &= BEEP_PIN;
       __delay_cycles(100000);
    P1OUT &= ~BEEP_PIN;
     }
    }
    
    
    

×
×
  • Create New...