int main(void) { WDTCTL = WDTPW + WDTHOLD; // Stop watchdog timer uart_timer_configure(); uart_init(); _enable_interrupts(); uart_puts("\n\r***************\n\r"); uart_puts("MSP430 SunV2\n\r"); uart_puts("***************\n\r\n\r"); uint8_t c; // Timeshare between UART and dimming while(1) { if(uart_getc(&c)) { if(c == '\r') { uart_putc('\n'); uart_putc('\r'); } else { uart_putc('['); uart_putc(c); uart_putc(']'); // Clear UART configuration _disable_interrupts(); timer_deconfigure(); uart_disable(); uart_timerA_disable(); switch (c) { case 'w': turnOn(); break; case 's': turnOff(); break; case 'r': remember(); break; case 'd': dimUp(); break; case 'a': dimDown(); break; } // UART configuration art_init(); timer_deconfigure(); uart_timer_configure(); uart_timerA_enable(); _enable_interrupts(); } } } }
interrupt void port1ISR(){ _disable_interrupts(); msdelay(20); // delay for 20 ms ISRc = getC(); P1IFG &= ~(ALLROWS); // clears the interrupt flag _enable_interrupts(); }
unsigned char SPI_RxFrame(unsigned char *pBuffer, unsigned int size) { if(size ==0 ) return (1); if(UCA0STAT & UCBUSY) return (0); _disable_interrupts(); SPI_Rx_Or_Tx = 0; SPI_Rx_Buffer = pBuffer; SPI_Rx_Size = size - 1; SPI_Interrupt_Sel(SPI_Rx_Or_Tx); _enable_interrupts(); UCA0TXBUF = 0xff; //在接收模式下,也先发送一次空字节,一遍提供时钟通信 _bis_SR_register(LPM0_bits); // unsigned int gie = _get_SR_register() & GIE; // IFG2 &= ~UCA0RXIFG; // // while(size--) // { // while( !(IFG2 & UCA0TXIFG) ); // UCA0TXBUF = 0xff; // while( !(IFG2 & UCA0RXIFG) ); // *pBuffer++ = UCA0RXBUF; // } return 1; }
void setup_timer_buttons(void){ init_button(); init_systimer(); initButtons(); _enable_interrupts(); }
/* * ======== leave ======== */ Void GateGIE_leave(GateGIE_Object *obj, IArg key) { if (key & GIE) { /* re-enable interrupts _only_ if we disabled them */ _enable_interrupts(); } }
void buttons_init(void) { _disable_interrupts(); P1SEL &= ~(1 << BUTTON1_PIN); /* Set pins 1.1 as I/O */ P1SEL &= ~(1 << BUTTON2_PIN); /* Set pins 1.2 as I/O */ P1REN |= (1 << BUTTON1_PIN); /* Enable internal resistor in pin 1.4 */ P1REN |= (1 << BUTTON2_PIN); /* Enable internal resistor in pin 2.6 */ P1OUT |= (1 << BUTTON1_PIN); /* Set internal resisistor as pull-upin P1.4 */ P1OUT |= (1 << BUTTON2_PIN); /* Set internal resisistor as pull-upin P2.6 */ P1DIR &= ~(1 << BUTTON1_PIN); /* Set pin 1.1 as input */ P1DIR &= ~(1 << BUTTON2_PIN); /* Set pin 1.2 as input */ P1IE |= (1 << BUTTON1_PIN); /* P1.1 interrupt enabled */ P1IES |= (1 << BUTTON1_PIN); /* P1.1 Hi/Lo edge */ P1IFG &= ~(1 << BUTTON1_PIN); /* P1.1 IFG cleared */ P1IE |= (1 << BUTTON2_PIN); /* P1.2 interrupt enabled */ P1IES |= (1 << BUTTON2_PIN); /* P1.2 Hi/Lo edge */ P1IFG &= ~(1 << BUTTON2_PIN); /* P1.2 IFG cleared */ msg.type = BUTTONS_MSG_TYPE;/* Set the buttons message type */ button1_timer.start = 0; button2_timer.start = 0; register_port1IntHandler(BUTTON1_PIN, button1_interrupt); register_port2IntHandler(BUTTON2_PIN, button2_interrupt); _enable_interrupts(); }
/*********************************************************************************** * @fn cc2520_init * * @brief Initialise cc2520 datastructures. Sets channel, short address and * PAN id in the chip and configures interrupt on packet reception * * txState - file scope variable that keeps tx state info * rxi - file scope variable info extracted from the last incoming * frame * * @return none */ uint8_t cc2520_init() { pConfig.panId = PAN_ID; pConfig.channel = RF_CHANNEL; pConfig.ackRequest = TRUE; pConfig.myAddr = NODE_ADDR; cc2520_interfaceInit(); // initialize the rest of the interface. cc2520_spiInit(); // initialize spi. if (cc2520_config() == FAILED) return FAILED; // initialize the ring buffer // bufInit(&rxBuffer, ringBuffer, 512); _disable_interrupts(); rxi.pPayload = NULL; txState.receiveOn = TRUE; txState.frameCounter = 0; // Set channel cc2520_setChannel(pConfig.channel); // Write the short address and the PAN ID to the CC2520 RAM cc2520_setShortAddr(pConfig.myAddr); cc2520_setPanId(pConfig.panId); // if security is enabled, write key and nonce #ifdef SECURITY_CCM //basicRfSecurityInit(pConfig); #endif // Set up receive interrupt (received data or acknowlegment) P2IES &= ~(CC2520_INT_PIN); // Set rising edge P2IFG &= ~(CC2520_INT_PIN); P2IE |= CC2520_INT_PIN; // Clear the exception CLEAR_EXC_RX_FRM_DONE(); // Enable general interrupts _enable_interrupts(); // And enable reception on cc2520 cc2520_receiveOn(); memset(eth_tx_buf, 0xFF, 6); memset(ð_tx_buf[6], 0, 6); eth_tx_buf[12] = 0x80; eth_tx_buf[13] = 0x9a; return SUCCESS; }
void matrixISRmode(){ matrixInit(); P1IE |= ALLROWS; P1IES = ~(ALLROWS); // enables rising edge interrupts P1IFG = ~(ALLROWS); P6OUT = ALLCOLS; _enable_interrupts(); }
void kernel_main() { int i = 0; //init_sys_mmu(); //start_mmu(); /* 开启MMU */ unsigned int end = (unsigned int)(&__end+PGDR_MASK)&0xffffc000; unsigned int physfree = init_paging(end-0xC0000000); init_ram(physfree); /* 重定位内核*/ asm volatile( "add sp, sp, #0xC0000000\n\t" ); /*清空恒等隐射*/ for(i = 1; i < NR_KERN_PAGETABLE; i++) PTD[i] = 0; uart_init(); char *_temp = "0000000000\r\n"; unsigned int temp; HexToString((unsigned int)&temp, _temp); uart_puts(_temp); task_init(); unsigned char rank = MAX_rank ; unsigned int task_func = (unsigned int)task_idle0; unsigned char TID = task_create( rank , task_func); task_run(TID); task_func = (unsigned int)task_idle1; TID = task_create( rank , task_func); task_run(TID); task_func = (unsigned int)task_idle2; TID = task_create( rank , task_func); task_run(TID); task_func = (unsigned int)task_idle3; TID = task_create( rank , task_func); task_run(TID); init_arm_timer(Kernel_1Hz); _enable_interrupts(); while(1) { char *_ch = "0000000000\r\n"; for(i = 0; i < 20; i++) { HexToString(PTD[i], _ch); uart_puts(_ch); } for(i = 0; i < 20; i++) { HexToString(PTD[i+0xC00], _ch); uart_puts(_ch); } sleep(500); } }
/****************************************************************************************************** * 名 称:I2C_Rx_Init() * 功 能:仅使能I2C的Rx中断 * 入口参数:无 * 出口参数:无 * 说 明:I2C通信只能半双工,只使能一个中断,可靠 * 范 例:无 ******************************************************************************************************/ void I2C_Rx_Init() { _disable_interrupts(); while ((UCB0STAT & UCBUSY)||UCB0CTL1 & UCTXSTP); // 确保总线空闲 IE2 &= ~UCB0TXIE; //关闭Rx中断 I2C_State=RX_STATE; IE2 |= UCB0RXIE; //允许Tx中断 _enable_interrupts(); // 开总中断 }
void i2c_init(uint16_t usi_clock_divider, uint16_t usi_clock_source) { _disable_interrupts(); USICTL0 = USIPE6|USIPE7|USIMST|USISWRST; // Port & USI mode setup USICTL1 = USII2C|USIIE; // Enable I2C mode & USI interrupt USICKCTL = usi_clock_divider | usi_clock_source | USICKPL; USICNT |= USIIFGCC; // Disable automatic clear control USICTL0 &= ~USISWRST; // Enable USI USICTL1 &= ~USIIFG; // Clear pending flag _enable_interrupts(); }
int_fast32_t get_sys_tick() { int_fast32_t elapsed_time; _disable_interrupts(); elapsed_time = sys_tick; sys_tick = 0; _enable_interrupts(); return elapsed_time; }
int main(void) { WDTCTL = WDTPW + WDTHOLD; // Stop watchdog timer _disable_interrupts(); sysInit(); _enable_interrupts(); while(1){ if(uartCheck) uartParse(); } }
int main(void) { uint16_t status; WDTCTL = WDTPW | WDTHOLD; // Stop watchdog timer LED_init(); LED_on(); /* configure the Basic Clock Module */ DCOCTL = CALDCO_1MHZ; BCSCTL1 = CALBC1_1MHZ; BCSCTL2 = SELM_3 + DIVM_0;//MCLK = LFXTCLK/1 #ifdef NECESSARY do { int i; IFG1 &= ~OFIFG; // Clear OSCFault flag for (i = 0xFF; i > 0; i--); // Time for flag to set } while ((IFG1 & OFIFG)); // OSCFault flag still set? #endif TACTL = TASSEL_2 | MC_1; /* SMCLK, upmode */ TACCR0 = TIMER_CLK_HZ/SYSTICK_HZ; TACCTL0 = CCIE; /*Enable timer A0 interrupt*/ //Enable SCLK, SDI, SDO, master USICTL0 |= USIPE7 | USIPE6 | USIPE5 | USIMST | USIOE; USICKCTL |= USIDIV_0 //this actually means divide by 1 | USISSEL_2//Use SMCLK to drive the SPI clk //| USICKPL ; USICTL1 |= USICKPH;//delay? //USICTL1 |= USIIE;//interrupt enable // ; P1OUT = BIT4;//Pull up nCS at first P1DIR |= BIT4;//nCS is P1.4 //P1REN |= 0x10;? _enable_interrupts();//vs. _BIS_SR(LPM0_bits + GIE); LED_off(); dSPIN_Soft_Stop(); dSPIN_Reset_Device(); status = dSPIN_Get_Status(); if(status & dSPIN_STATUS_SW_EVN || (status & dSPIN_STATUS_MOT_STATUS) != dSPIN_STATUS_MOT_STATUS_STOPPED || status & dSPIN_STATUS_NOTPERF_CMD || status & dSPIN_STATUS_WRONG_CMD // !(status & dSPIN_STATUS_UVLO) || !(status & dSPIN_STATUS_TH_SD) || !(status & dSPIN_STATUS_OCD)) Q_ERROR(); if(dSPIN_Busy_HW()) Q_ERROR(); return 0; }
__interrupt void USCIAB0TX_ISR(void) { _disable_interrupts(); //等同_DINT if(I2C_State==TX_STATE) //判断是收状态还是发状态 I2C_TxFrame_ISR(); // 事件:发送帧 else I2C_RxFrame_ISR(); // 事件:接收帧 //-------预留给主循环中唤醒CPU用途------- if(RxByteCnt == 0 || TxByteCnt == 0) //如果没有待发送或待接收数据 __bic_SR_register_on_exit(CPUOFF); // Exit LPM0 _enable_interrupts(); //等同_ENIT }
void do_non_blocking_interrupt() { _enable_interrupts(); // Because we have re-enabled interrupts in here, the 12kHz interrupt can happen again // But because we set the flag "inside_non_blocking_interrupt", this will not get called // again until this pops off the stack. // Essentially, this function gets called constantly, but only one will exist on the stack // at the same time. handle_full_sensors(); _disable_interrupts(); }
/****************************************************************************************************** * 名 称:SPI_TxFrame() * 功 能:主机向从机发送1个帧数据 * 入口参数:无 * 出口参数:无 * 说 明:无 * 范 例:无 ******************************************************************************************************/ unsigned char SPI_TxFrame(unsigned char *pBuffer, unsigned int size) { _disable_interrupts(); unsigned char i=0; for(i=0;i<size;i++) //然后依次发送各字节数据 { Tx_Char(*pBuffer); pBuffer++; } _enable_interrupts(); return 1; }
int main(void) { WDTCTL = WDTPW | WDTHOLD; // Stop Watchdog // Startup clock system with max DCO setting ~12MHz CSCTL0 = CSKEY; // Unlock clock registers CSCTL1 = DCOFSEL_6 | DCORSEL; // DCO - 12Mhz CSCTL2 = SELA__VLOCLK + SELS__DCOCLK + SELM__DCOCLK; CSCTL3 = DIVA__1 + DIVS__2 + DIVM__2; // set all dividers // Configure UART pins gps P2REN &= ~(BIT0 + BIT1); P2SEL1 |= BIT0 + BIT1; P2SEL0 &= ~(BIT0 + BIT1); // xbee P2REN &= ~(BIT5 + BIT6); P2SEL1 |= BIT5 + BIT6; P2SEL0 &= ~(BIT5 + BIT6); // Configure UART UCA0CTL1 |= UCSWRST; // Put eUSCI in reset UCA0CTL1 |= UCSSEL__SMCLK; // CLK = SMCLK // Baud Rate calculation // 12000000/(16*9600) = 52.083 // Fractional portion = 0.083 // User's Guide Table 21-4: UCBRSx = 0x04 // UCBRFx = int ( (52.083-52)*16) = 1 UCA0BR0 = 78; // 8000000/16/9600 UCA0BR1 = 0x00; UCA0MCTLW |= UCOS16 | UCBRF_2; UCA0CTL1 &= ~UCSWRST; // Initialize eUSCI UCA0IE |= UCRXIE; // Enable USCI_A0 RX interrupt // Configure UART xbee UCA1CTL1 |= UCSWRST; // Put eUSCI in reset UCA1CTL1 |= UCSSEL__SMCLK; // CLK = SMCLK // Baud Rate calculation // 12000000/(16*9600) = 52.083 // Fractional portion = 0.083 // User's Guide Table 21-4: UCBRSx = 0x04 // UCBRFx = int ( (52.083-52)*16) = 1 UCA1BR0 = 78; // 8000000/16/9600 UCA1BR1 = 0x00; UCA1MCTLW |= UCOS16 | UCBRF_2; UCA1CTL1 &= ~UCSWRST; // Initialize eUSCI shutdown_gps(); _enable_interrupts(); while(1); }
/****************************************************************************************************** * 名 称:SPI_RxFrame() * 功 能:主机接收从机1帧数据 * 入口参数:无 * 出口参数:无 * 说 明:无 * 范 例:无 ******************************************************************************************************/ unsigned char SPI_RxFrame(unsigned char *pBuffer, unsigned int size) { unsigned char i=0; _disable_interrupts(); for(i=0;i<size;i++) //然后依次接收各个字节数据 { *pBuffer=Rx_Char(); pBuffer++; } _enable_interrupts(); return 1; }
void func(void) { _disable_interrupts(); int statusInfo = 0; // hold inforamtion over the return values of the subtask uint8_t* target; target = GPTIMER2 | GPTIMER_TISR; *target = 0x00000003; //Set Interrupt pending = 0 statusInfo = startTimer(GPTIMER2); _enable_interrupts(); }
int try_receive (void* str) { _disable_interrupts(); int retv = -1; SYSCALL_PARAM (cur_thread->stack_pointer, cur_thread->pid, str, retv); asm volatile ("swi #0x02\t\n":::"memory"); SYSCALL_END (retv); _enable_interrupts(); return retv; }
void Setup_USI_Master_TX (void) { _disable_interrupts(); Bytecount = 0; Transmit = 1; USICTL0 = USIPE6+USIPE7+USIMST+USISWRST; // Port & USI mode setup USICTL1 = USII2C+USIIE; // Enable I2C mode & USI interrupt USICKCTL = USIDIV_7+USISSEL_2+USICKPL; // USI clk: SCL = SMCLK/128 USICNT |= USIIFGCC; // Disable automatic clear control USICTL0 &= ~USISWRST; // Enable USI USICTL1 &= ~USIIFG; // Clear pending flag _enable_interrupts(); }
/****************************************************************************************************** * 名 称:I2C_Init() * 功 能:初始化USCI_B0模块为I2C模式 * 入口参数:无 * 出口参数:无 * 说 明:I2C设为3线制主机状态,暂不使能Tx和Rx中断 * 范 例:无 ******************************************************************************************************/ void I2C_Init() { _disable_interrupts(); P1SEL |= BIT6 + BIT7; // GPIO 配置为USCI_B0功能 P1SEL2|= BIT6 + BIT7; // GPIO 配置为USCI_B0功能 UCB0CTL1 |= UCSWRST; // 软件复位状态 UCB0CTL0 = UCMST + UCMODE_3 + UCSYNC; // 同步通信I2C主机状态 UCB0CTL1 = UCSSEL_2 + UCSWRST; // 使用SMCLK,软件复位状态 UCB0BR0 =I2C_BAUDRATE_DIV ; // 除了分频系数,实际波特率还与SMCLK有关 UCB0BR1 = 0; //这一级别的分频一般不启用 UCB0I2CSA = SLAVE_ADDR; // I2C从机地址,可在宏定义中修改 UCB0CTL1 &= ~UCSWRST; // 开启I2C _enable_interrupts(); }
static void LOCAL_exampleInit(Uint8 pruNum) { Uint32 i; Uint32 *pruDataMem; // Turn on the EDMA CC and TCs DEVICE_LPSCTransition(CSL_PSC_0, CSL_PSC_CC0, 0, CSL_PSC_MDCTL_NEXT_ENABLE); DEVICE_LPSCTransition(CSL_PSC_0, CSL_PSC_TC0, 0, CSL_PSC_MDCTL_NEXT_ENABLE); DEVICE_LPSCTransition(CSL_PSC_0, CSL_PSC_TC1, 0, CSL_PSC_MDCTL_NEXT_ENABLE); // Initialize memory pointer if (pruNum == 0) { pruDataMem = (Uint32 *) PRU0_DATA_RAM_START; } else if (pruNum == 1) { pruDataMem = (Uint32 *) PRU1_DATA_RAM_START; } // Put src and dst addresses into PRU data memory so PRU code can read them pruDataMem[0] = (Uint32) srcBuf; pruDataMem[1] = (Uint32) dstBuf; // Init src and dst buffers for (i = 0; i < sizeof(srcBuf); i++) { srcBuf[i] = rand() & 0xFF; dstBuf[i] = 0; } // Clear EDMA CC0 interrupt CSL_FINST(intcRegs->EVTCLR[0], DSPINTC_EVTCLR_EC8, SET); // Connect the EDMA CC0 event to the DSP interrupt 12 CSL_FINS(intcRegs->INTMUX3, DSPINTC_INTMUX3_INTSEL12, EDMA3_CC0_INT1); // Set ISTP to point to the vector table address ISTP = (Uint32)intcVectorTable; // Clear all interrupts, bits 4 thru 15 ICR = 0xFFF0; // Enable the bits for non maskable interrupt 12 and NMIE IER = 0x1002; // Enable interrupts, set GIE bit _enable_interrupts(); }
/****************************************************************************************************** * 名 称:I2C_TxFrame(unsigned char *p_Tx,unsigned char num) * 功 能:主机发送若干字节的1帧数据 * 入口参数:无 * 出口参数:无 * 说 明:无 * 范 例:无 ******************************************************************************************************/ unsigned char I2C_TxFrame(unsigned char *p_Tx,unsigned char num) { _disable_interrupts(); unsigned char i=0; I2C_START; Send_Char(SLAVE_ADDR_W); //先发送器件地址和写标志 for(i=0;i<num;i++) //然后依次发送各字节数据 { Send_Char(*p_Tx); p_Tx++; } I2C_STOP; _enable_interrupts(); return 1; }
/****************************************************************************************************** * 名 称:I2C_RxFrame(unsigned char *p_Tx,unsigned char num) * 功 能:主机接收若干字节的1帧数据 * 入口参数:无 * 出口参数:无 * 说 明:无 * 范 例:无 ******************************************************************************************************/ unsigned char I2C_RxFrame(unsigned char *p_Tx,unsigned char num) { unsigned char i=0; _disable_interrupts();; I2C_START; Send_Char(SLAVE_ADDR_R); //先发送器件地址和读标志 for(i=0;i<num;i++) //然后依次接收各个字节数据 { *p_Tx=Get_Char(); p_Tx++; } I2C_STOP; _enable_interrupts(); return 1; }
/*********************************************************************************** * @fn cc2520_waitTransceiverReady * * @brief Wait until the transceiver is ready (SFD low). * * @param none * * @return none */ void cc2520_waitTransceiverReady(void) { #ifdef INCLUDE_PA // GPIO3 is not conncted to combo board; use SFD at GPIO2 instead _disable_interrupts(); // GPIO2 = SFD CC2520_CFG_GPIO_OUT(2,CC2520_GPIO_SFD); while (CC2520_SFD_PIN); // GPIO2 = default (RSSI_VALID) CC2520_CFG_GPIO_OUT(2,CC2520_GPIO_RSSI_VALID); _enable_interrupts(); #else while (CC2520_SFD_PIN); #endif }
/**************************************************************************** * 名 称:SPI_TxFrame() * 功 能:3线硬件SPI模式下,发送指定数目的字节缓存 * 入口参数:pBuffer:指向待发送的数组地址 * size:待发送的字节数 * 出口参数:0:当前硬件SPI在忙, * 1:当前数据已发送完毕, * 说 明:使用该函数可以发送指定个数的一帧数据 * 使用范例:SPI_TxFrame(CMD,6); // 从CMD中取出并发送6个字节 ****************************************************************************/ unsigned char SPI_TxFrame(unsigned char *pBuffer, unsigned int size) { if(size==0) return (1); if(UCB0STAT & UCBUSY) return (0); // 判断硬件SPI正忙,返回0 _disable_interrupts(); // 关闭总中断 SPI_Rx_Or_Tx = 1; // 开启发送模式 SPI_Tx_Buffer = pBuffer; // 将发送缓存指向待发送的数组地址 SPI_Tx_Size = size-1; // 待发送的数据个数 SPI_Interrupt_Sel(SPI_Rx_Or_Tx); // SPI中断开启选择 _enable_interrupts(); // 开总中断 UCB0TXBUF = *SPI_Tx_Buffer; // 先发送第一个字节人工触发第一次"发送"中断 _bis_SR_register(LPM0_bits); // 进入低功耗模式0 //flagTx = 1; //while(flagTx); return (1); }
//=============================================================================================== //=============================================================================================== //=============================================================================================== //Очистка очереди от дубликатов задач с разным временем void clear_duplicates (void) //not tested { uint8_t index=0; bit nointerrupted = 0; TPTR task_src; if (STATUS_REG & (1<<Interrupt_Flag)){_disable_interrupts();nointerrupted = 1;} // Проверка запрета прерывания for(index=0;index!=timers_cnt_tail;++index) { task_src = TTask[index].GoToTask; for(index+1;index!=timers_cnt_tail;++index) { if (TTask[index].GoToTask == task_src) {TTask[index].GoToTask = Idle;} } } if (nointerrupted){_enable_interrupts();} // Разрешаем прерывания }
/**************************************************************************** * 名 称:SPI_RxFrame() * 功 能:3线硬件SPI模式下,接收指定数目的字节 * 入口参数:pBuffer:指向存放接收数据的数组 * size:要接收的字节数 * 出口参数:0:当前硬件SPI在忙, * 1:当前数据已发送完毕, * 说 明:使用该函数可以接收指定个数的一帧数据 * 使用范例:SPI_RxFrame(CMD,6);// 接收6个字节,并依次放入CMD中 ****************************************************************************/ unsigned char SPI_RxFrame(unsigned char *pBuffer, unsigned int size) { if(size==0) return (1); if(UCB0STAT & UCBUSY) return (0); // 判断硬件SPI正忙,返回0 _disable_interrupts(); // 关闭总中断 SPI_Rx_Or_Tx = 0; // 开启接收模式 SPI_Rx_Buffer = pBuffer; // 将发送缓存指向待发送的数组地址 SPI_Rx_Size = size-1; // 待发送的数据个数 SPI_Interrupt_Sel(SPI_Rx_Or_Tx); // SPI中断开启选择 // 开总中断 UCB0TXBUF = 0xFF; // 在接收模式下,也要先发送一次空字节,以便提供通信时钟。 IFG2 |= UCB0RXIFG; _enable_interrupts(); //flagRx = 1; // 进入低功耗模式0 //while(flagRx); _bis_SR_register(LPM0_bits); return (1); }