Jump to content

areben

Members
  • Content Count

    6
  • Joined

  • Last visited

  1. Still looking for people interested in helping us push the project further.
  2. 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: 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
  3. Any ideas? I have not been able to debug this one.
  4. 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; }
  5. 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
  6. 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 #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...