⭐ 欢迎来到虫虫下载站! | 📦 资源下载 📁 资源专辑 ℹ️ 关于我们
⭐ 虫虫下载站

📄 msp430f1611_2400_three.c

📁 利用MSP430F1611系列单片机内部的TIMER_A模块功能CCR0、CCR1和CCR2的捕获功能
💻 C
📖 第 1 页 / 共 2 页
字号:
                  //if (com6.BufferPtr >= (com6.RxBuf[12]+ 15))
          		{
          			CCTL2 &=  ~CCIE;        // All bits RXed, disable interrupt         		
          			com8.BufferPtr=0;          				             			//com6 RX
          			CCTL2 &=~0x3000;
                        com8_TX_Byte();
          		}
      	}	
     	}
      if (com8.Tx_status == 1)
      {
           	com8.Tx_status = 0 ;
           	if ( com8.BitCnt == 0)
    	  	{    		
           		if (com8.BufferPtr <= 0x11)
           		//if (com6.BufferPtr <= (com6.RxBuf[12]+ 17))		//check send byte number
          		{            			
                 		com8.TxTemp = com8.TxBuf[com8.BufferPtr++];
    				com8.BitCnt = 0x0b;
  				ii=com8.TxTemp;					//add even bit start
  				kk=0;		
  				for(jj=0;jj<8;jj++)
      			{
     			 		if(ii&0x80) kk^=0x100;
			 		ii<<=1;
     				}
  				com8.TxTemp |=kk;					//add even bit end
  				com8.TxTemp |=0x200;		 		//add stop bit
           			com8.TxTemp = com8.TxTemp << 1;    	 		// Add space start bit
                       	CCR2 = TAR;                         		// Current state of TA counter
           			CCR2 += Bitime;                     		// Some time till first bit
           		}	
      		else
      		{
      			com8.BufferPtr=0;
      			CCTL2 &= ~ CCIE;                    		// All bits TXed, disable interrupt
                 		com8.Tx_finish = 1;
      			_NOP();
      		}
    		}
    		else
    		{      			
      		if (com8.TxTemp & 0x01) CCTL2 &= ~ OUTMOD2;           // TX Mark
            	else CCTL2 |= OUTMOD2;                  			// TX Space
      			com8.TxTemp = com8.TxTemp >> 1;
      			com8.BitCnt --;
            }
      }

 }

}

// COM6 TX INTT
void com6_TX_Byte (void)
{
  unsigned char i,j;
  unsigned int k;
  //com6.BitCnt = 0x0b;							// Load Bit counter, ST+8data + EVEN + STOP
  com6.BufferPtr = 0x0;							//
  for(i=0;i<0x12;i++)							//RX DATA PUT TX BUFFER
  {
  	com6.TxBuf[i]=com6.RxBuf[i];
  	com6.RxBuf[i] = 0;  	
  }
  com6.TxTemp = com6.TxBuf[com6.BufferPtr];			//take first tx data for tx regest
  i=com6.TxBuf[com6.BufferPtr];					//get even start
  k=0;
  for(j=0;j<8;j++)
      {
      if(i&0x80)k^=0x100;
	i<<=1;
     	}
  com6.TxTemp |=k;							//add odd or even end
  com6.TxTemp |=0x200;							//add stop bit
  com6.TxTemp = com6.TxTemp << 1;             			// Add space start bit
  CCR0 = TAR;                           				// Current state of TA counter
  CCR0 += Bitime;                       				// Some time till first bit
  CCTL0 = OUTMOD0 + CCIE + CCIS_2;					// TXD = mark = idle
  //while ( CCTL0 & CCIE );               			// Wait for TX completion
  com6.Rx_status = 0;

}

// COM7 TX INTT
void com7_TX_Byte (void)
{
  unsigned char i,j;
  unsigned int k;

  //com7.BitCnt = 0x0b;							// Load Bit counter, ST+8data + EVEN + STOP
  com7.BufferPtr = 0x0;							//
  for(i=0;i<0x12;i++)							//RX DATA PUT TX BUFFER
  {
  	com7.TxBuf[i]=com7.RxBuf[i];
  	com7.RxBuf[i] = 0;  	
  }
  com7.TxTemp = com7.TxBuf[com7.BufferPtr];			//take first tx data for tx regest
  i=com7.TxBuf[com7.BufferPtr];					//get even start
  k=0;
  for(j=0;j<8;j++)
      {
      if(i&0x80)k^=0x100;
	i<<=1;
     	}
  com7.TxTemp |=k;							//add odd or even end
  com7.TxTemp |=0x200;							//add stop bit
  com7.TxTemp = com7.TxTemp << 1;             			// Add space start bit
  CCR1 = TAR;                           				// Current state of TA counter
  CCR1 += Bitime;                       				// Some time till first bit
  CCTL1 = OUTMOD0 + CCIE + CCIS_2;					// TXD = mark = idle
  //while ( CCTL1 & CCIE );               			// Wait for TX completion
}

// COM8 TX INTT
void com8_TX_Byte (void)
{
  unsigned char i,j;
  unsigned int k;

  //com8.BitCnt = 0x0b;							// Load Bit counter, ST+8data + EVEN + STOP
  com8.BufferPtr = 0x0;							//
  for(i=0;i<0x12;i++)							//RX DATA PUT TX BUFFER
  {
  	com8.TxBuf[i]=com8.RxBuf[i];
  	com8.RxBuf[i] = 0;  	
  }
  com8.TxTemp = com8.TxBuf[com8.BufferPtr];			//take first tx data for tx regest
  i=com8.TxBuf[com8.BufferPtr];					//get even start
  k=0;
  for(j=0;j<8;j++)
      {
      if(i&0x80)k^=0x100;
	i<<=1;
     	}
  com8.TxTemp |=k;							//add odd or even end
  com8.TxTemp |=0x200;							//add stop bit
  com8.TxTemp = com8.TxTemp << 1;             			// Add space start bit
  CCR2 = TAR;                           				// Current state of TA counter
  CCR2 += Bitime;                       				// Some time till first bit
  CCTL2 = OUTMOD0 + CCIE + CCIS_2;					// TXD = mark = idle
  //while ( CCTL2 & CCIE );               			// Wait for TX completion
}


// COM6 RX INIT
void com6_RX_Ready (void)
{

  com6.BitCnt = 0x9;                         			// Load Bit counter
  CCTL0 = SCS + CCIS_0 + OUTMOD0 + CM1 + CAP + CCIE;  	// Sync, Neg Edge, Capture
  TACTL = TASSEL_1 + MC_2;              				// ACLK, continuous mode
  com6.BufferPtr = 0x00;
  com6.RxTemp = 0x00;
  com6.Tx_finish = 0;
}

// COM7 RX INIT
void com7_RX_Ready (void)
{              		
  com7.BitCnt = 0x9;							// Load Bit counter
  CCTL1 = SCS + CCIS_0 + OUTMOD0 + CM1 + CAP + CCIE;  	// Sync, Neg Edge, Capture
  TACTL = TASSEL_1 + MC_2;              				// ACLK, continuous mode
  com7.BufferPtr = 0x00;
  com7.RxTemp = 0x00;
  com7.Tx_finish = 0;
}

// COM8 RX INIT
void com8_RX_Ready (void)
{
  com8.BitCnt = 0x9;							// Load Bit counter
  CCTL2 = SCS + CCIS_0 + OUTMOD0 + CM1 + CAP + CCIE;  	// Sync, Neg Edge, Capture
  TACTL = TASSEL_1 + MC_2;              // ACLK, continuous mode
  com8.BufferPtr = 0x00;
  com8.RxTemp = 0x00;
  com8.Tx_finish = 0;
}


// fe fe 68 10 01 00 00 00 00 00 00 01 03 1F 90 00 2c 16
#pragma vector=TIMERA0_VECTOR
__interrupt void Timer_A (void)
{	
  	CCR0 += Bitime;                       			// Add Offset to CCR0
      com6.Tx_finish = 0;
	//CCR0 RX
  	if ((CCTL0 & 0x3000) == 0)                   		// RX on CCI0A?
  	{    		
        	if( CCTL0 & CAP )                   		// Capture mode = start bit edge
    		{    			
    			CCTL0 &= ~ CAP;                     	// Switch from capture to compare mode
    			CCR0 += Bitime_5;
                  com6.BitCnt = 0x9;
                  com6.Checkbit = 0x00;
    		}
    		else
    		{    			
      		com6.Rx_status = 1;
              	if (CCTL0 & SCCI)
      		{      			      			
                    	com6.RxTemp |= 0x200;         	// Get bit waiting in receive latch
                        com6.Checkbit ^=0x1;      		
      		}
      		com6.BitCnt --;
      		com6.RxTemp = com6.RxTemp >> 1;           // All bits RXed?                   		
                  com6.Rx_status = 1;
    		}
  	}
	//CCR0 TX
  	else
  	{
		com6.Tx_status = 1;					// set TX status flag
        	com6.Tx_finish = 0;					// clear TX finish flag
  	}
}

#pragma vector=TIMERA1_VECTOR
__interrupt void Timer_A1 (void)
{

  switch( TAIV )
   {
     	// CCR1  com7
     	case  2:
     	{
  		CCR1 += Bitime;                       		// Add Offset to CCR0
            com7.Tx_finish = 0;
//CCR1 RX
  		if ((CCTL1 & 0x3000) == 0)                   	// RX on CCI0A?
  		{
    			if( CCTL1 & CAP )                   	// Capture mode = start bit edge
    			{    			
    				CCTL1 &= ~ CAP;                     // Switch from capture to compare mode
    				CCR1 += Bitime_5;
                  	com7.BitCnt = 0x9;
                  	com7.Checkbit = 0x00;
    			}
    			else
    			{    			
      			if (CCTL1 & SCCI)
      			{      			      			
                    		com7.RxTemp |= 0x200;         // Get bit waiting in receive latch
                        	com7.Checkbit ^=0x1;      			
      			}
      			com7.BitCnt --;
      			com7.RxTemp = com7.RxTemp >> 1;     // All bits RXed? 	
                  	com7.Rx_status = 1;                  	     		     		
    			}
  		}
//CCR1 TX  		
  		else
  		{	
    			com7.Tx_status = 1;				// set TX status flag
        		com7.Tx_finish = 0;				// clear TX finish flag            	
  		}
  	
  	}	 break;
  	
//--------------------- ccr2 rx/tx -----------------
  	case  4:
     	{
  		CCR2 += Bitime;                       		// Add Offset to CCR0
            com8.Tx_finish = 0;
//CCR2 RX
  		if ((CCTL2 & 0x3000) == 0)                   	// RX on CCI0A?
  		{
    			com8.Rx_status = 1;
              	if( CCTL2 & CAP )                   	// Capture mode = start bit edge
    			{    			
    				CCTL2 &= ~ CAP;                     // Switch from capture to compare mode
    				CCR2 += Bitime_5;
                 	 	com8.BitCnt = 0x9;
                  	com8.Checkbit = 0x00;
    			}
    			else
    			{    			
      			if (CCTL2 & SCCI)
      			{      			      			
                    		com8.RxTemp |= 0x200;         // Get bit waiting in receive latch
                        	com8.Checkbit ^=0x1;      			
      			}
      			com8.BitCnt --;
      			com8.RxTemp = com8.RxTemp >> 1;     // All bits RXed?                  	       		
                  	//com8.Rx_status = 1;                  	  		     		
    			}    			
  		}
//CCR2 TX
  		else
  		{	
    			com8.Tx_status = 1;				// set TX status flag        		          	
  		}
  	
  	}	 break;
   }
}



⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -