113.c

用MSP430(C)写的红外抄表程序,是初学者好代码

//
//------------------------------------------------------------------------------------------
//About very big pressure and tempressure
//By Lostglory
//2007,7.3
//2 temp measure modes and 4 pressure measure
//------------------------------------------------------------------------------------------


#include<msp430x43x.h>
#include<math.h>
#include<stdio.h>
#include<string.h>
/*
#define SDA_1       P6OUT |=  BIT5             //SDA = 1
#define SDA_0       P6OUT &=~ BIT5              //SDA = 0
#define SCL_1       P6OUT |=  BIT4             //SCL = 1
#define SCL_0       P6OUT &=~ BIT4              //SCL = 0
#define DIR_IN      P6DIR &=~ BIT5     //I/O口为输入
#define DIR_OUT     P6DIR |=  BIT5     //I/0口为输出
#define SCL_OUT     P6DIR |=  BIT4
#define SDA_IN      ((P6IN >> 5) & 0x01)        //Read SDA
*/

#define SDA_1       P1OUT |=  BIT1              //SDA = 1
#define SDA_0       P1OUT &=~ BIT1              //SDA = 0
#define SCL_1       P1OUT |=  BIT0              //SCL = 1
#define SCL_0       P1OUT &=~ BIT0              //SCL = 0
#define DIR_IN      P1DIR &=~ BIT1;  SDA_1      //I/O口为输入
#define DIR_OUT     P1DIR |=  BIT1              //I/0口为输出
#define SDA_IN      ((P1IN >> 2) & 0x01)        //Read SDA
#define SCL_OUT     P1DIR |=  BIT0
//#define T_RST_1     P1OUT |=  BIT2              //REST = 1
//#define T_RST_0     P1OUT &=~ BIT2              //REST = 0

#define Clock_SDA_1       P2OUT |=  BIT1       //SDA = 1
#define Clock_SDA_0       P2OUT &=~ BIT1       //SDA = 0
#define Clock_CLK_1       P2OUT |=  BIT0       //SCL = 1
#define Clock_CLK_0       P2OUT &=~ BIT0       //SCL = 0 
#define Clock_DIR_IN      P2DIR &=~ BIT1      //I/O口为输入
#define Clock_DIR_OUT     P2DIR |=  BIT1     //I/0口为输出
#define Clock_CLK_OUT     P2DIR |=  BIT0
#define Clock_SDA_IN      ((P2IN >> 1) & 0x01)        //Read SDA
#define Clock_RST_1       P2OUT |=  BIT2 
#define Clock_RST_0       P2OUT &=~ BIT2
typedef union
{
unsigned int i;
float f;
}value;

#define noACK 0
#define ACK   1

#define STATUS_REG_W  0X06
#define STATUS_REG_R  0X07
#define MEASURE_TEMP  0X03
#define MEASURE_HUMI  0X05
#define RESET         0X1E

int n_point; 
int bz_point;
enum{N0,N1,N2};         //小数位数的定义，依次为0位，1位，2位小数
enum{UNITS_lux,UNITS_FC};       //上半屏幕的两个测量模式
enum{PSI,KPA,BAR,KG_CM2}; //下半屏幕的4个测量模式
enum{UPLCD,DOWNLCD};    //选择上或下屏幕对数据进行显示
enum{GEN,PMIN,PMAX,MAX,MIN,REL,POWEROFF}; //功能模式定义
enum{Time,Day,Year,Sampling,timehold};
enum{level1,level2,level3,level4,};
enum{APO,DISABLE_APO};
enum{hour,miniter,second,sampl,day,month,week,year};



//------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------
void main(void)
{



_DINT();                      //stop INT response
WDTCTL    = WDTPW + WDTHOLD;  //stop WDT
FLL_CTL0 |= XCAP18PF;   
SCFQCTL  |= 0x05;             //N=127 so,f(DCOCLK)=(N+1)f(crystal)=4.194304MHz,interior capatior 10p
FLL_CTL0 |= 0x30;  //DCO output is not divided

//P2SEL=0X00;
P2SEL |= 0x30;   
P2DIR=0X05;
//P2OUT=0X00;
P3SEL=0X00;       //keybutton input
P3DIR=0X00;
//P6SEL=0X8F;
P6DIR=0X10;
//P6OUT=0X00;
Device_int();
//delayms(10);
Lcd_statrt();
//AD 
ADC12CTL0 &= ~ENC;
ADC12CTL1=0X0210;
ADC12MCTL0=0x90;
ADC12CTL0=0xFFB3;

ADC12IE =0X0003;
ADC12IFG =0X0000;



//IIC
I2c_Addr=100;
I2c_Data=0x99;
DIR_OUT;
SCL_OUT;
//UART
  ME1 |= UTXE0 + URXE0;                     // Enable USART0 TXD/RXD
  UCTL0 |= CHAR;                            // 8-bit character
  UTCTL0 |= SSEL1;                          // UCLK = SMCLK
  UBR00 = 0x6D;                             // 1MHz 9600
  UBR10 = 0x00;                             // 1MHz 9600
  UMCTL0 = 0x03;                            // modulation
  UCTL0 &= ~SWRST;   // Initialize USART state machine

  IE1 |= URXIE0;                            // Enable USART0 RX interrupt
  P2DIR |= 0x10;                            // P2.4 output direction

 // _BIS_SR(LPM0_bits + GIE); 
 // Enter LPM0 w/ interrupt
//delayms(20);
write_clock=ReadWord(82); 
if((write_clock!=8))
{
  Write_Clock(0x8E, ClocK_write_data); 
  WriteWord(82,8);
}

//TA

  CCTL0 = CCIE;                             // CCR0 interrupt enabled
  CCR0 = 50000;
  TACTL = TASSEL_2 + MC_2;                  // SMCLK, continuous mode
//iic start
dataloger_no=ReadWord(92);
mem_no=ReadWord(80); 
if(mem_no==255){mem_no=0;}
read_mem_no=ReadWord(81); 
//if(read_mem_no==255){read_mem_no=0;}
if(read_mem_no>99||read_mem_no<=0){read_mem_no=1;}
Dataloger_start_Addr=ReadWord(90)*256+ ReadWord(91); 
if(Dataloger_start_Addr>=64000) {memory_ok=0;}
if(Dataloger_start_Addr<1450){Dataloger_I2c_Addr=1450;}
else {Dataloger_I2c_Addr = Dataloger_start_Addr+1;}
//Dataloger_start_Addr=63950;
//Dataloger_I2c_Addr=63950;
//Dataloger_I2c_Addr = 63900;
_EINT();  //Start all interrputs



while(1)
{ 
  if(memory_ok==0){LCD[9]=0X8D;LCD[8] |=0XF5;}  
  if(mode_status == PMAX || mode_status== PMIN) 
            {
              if(UNITS==UNITS_lux)souce_data=data_display*1.414;
              else souce_data=souce_data*1.076;
            }
       else {
               if(UNITS==UNITS_lux)souce_data=data_display;
               else souce_data=souce_data*1.076;
       
            }
  
   if(setup_ok==0 && sampling_ok==1) 
   setup();
   
   
}
}
//------------------------------------------------------------------------------------------
#pragma vector=TIMERA0_VECTOR              // Timer A0 interrupt service routine
__interrupt void Timer_A (void)
{ 
  //SVS SET
    SVSCTL = 0xF0;  
    CCR0 += 50000;   
    delayms(1);
    
    
    if(SVSCTL!=0Xf7) 
    {
    low_counter++;
    if(low_counter>=5) {LCD[12] |=0X08;status1 |=0x20;
    }   
    }
    else {LCD[12] &=0XF7;status1 &=0xDF;low_counter=0;}
    
   
    SVSCTL = 0;  //SVSCTL &=0XFE;
  sampling_counter++;                       //about the sample rate , one interrupt 50ms pre.
  apo_counter++;
  lcd_counter++;
  blight_counter++;
  if(sampling_counter==(sampling*20))       // the least sample rate is 1s=20 *50 ms
  {
   sampling_ok=1;
   sampling_counter=0x00; 
    if(usb_ok!=1) {LCD[8] &=0xf7;LCD[19] &=0xbf;}
  }
  if(setup_ok!=0)
  {
  if(lcd_counter==3)
  {
  lcd_counter=0;
  timer_ok=1; 
  }    
  }
  else {lcd_counter=0;timer_ok=1;}                                           //when it interrupt,displays the data what you want 
  if((backlight==1)&& (apo_counter==800))
  {P4OUT  &=0xFD;backlight=0;}             // when start the backlight, after 25seconds ,it will turn off automitsm
  if(apo_status==0)
  {if(apo_counter==15000) mode_status=POWEROFF;} // it about the automitsm power off
  else {apo_counter=0;} 
  if(blight_counter==400) {blight_counter=0;P4OUT  &=0xFD;}
                          // Add Offset to CCR0
  
}
  
//------------------------------------------------------------------------------------------
#pragma vector=UART0RX_VECTOR
__interrupt void usart0_rx (void)
{ 
  int i;
  //delayms(100);
  apo_status=1;
  LCD[8]|=0x08;usb_ok=1;
  while (!(IFG1 & UTXIFG0)); // USART0 TX buffer ready?
  pc_order=RXBUF0;
  pcorder=RXBUF0;
  //if(pc_order==0X87) {com_flag0=RXBUF0;}           //
 // else if (pc_order==0X83) {com_flag1=RXBUF0;}
  //else{
  if(pc_order==0X12)                              //tranmite the 99 number of memory data that could be display on the lcd
  { 
    LCD[19] |=0X20;LCD[19]|=0X20;delayms(100);pc_order=0;
    
    TXBUF0=0xBB;delayms(1);   TXBUF0=0x88;delayms(1);
    for(i=100;i<1450;i++) {TXBUF0=ReadWord(i);}
    LCD[19] &=0Xdf;delayms(500);com_status=0Xdc;
  
  }
  else if(pc_order==0X11)
  {
    transmite=0x0c;pc_order=0;delayms(1);
       int i;
   if(transmite==0x0c)
   {  
    
    LCD[19] |=0X40;                                       //when start the usb mode,transmite the data about the displays
       TXBUF0=0xAA;delayms(1); TXBUF0=0xDD ;
       
      for(i=0;i<8;i++)
      {com_buffer[i]=ClocK_read_data[i];}
             com_buffer[8]=real_usb_data/100;
             com_buffer[9]=real_usb_data%100;
             if( NO_HOLD==1)
             { com_buffer[10]=hold_data/100;com_buffer[11]=hold_data%100;
               for(i=0;i<8;i++)           {com_buffer[i]=hold_clock[i];}
                 
             }
             else if(mem_load_ok==0||lcd_ok==0){ com_buffer[10]=mem_display/100;com_buffer[11]=mem_display%100;}
             else {com_buffer[10]=data_display/100;com_buffer[11]=data_display%100;}
             
             com_buffer[12]=status0; 
             com_buffer[13]=status1;
             com_buffer[14]=mem_no;
             com_buffer[15]=read_mem_no;
             com_buffer[16]=sampling;
            
    for(i=0;i<17;i++) {TXBUF0=com_buffer[i];delayms(1);}
    transmite=0;
   }
  
  
  }  //scount realdsta
  else if(pc_order==0X15) {com_status=0X02;LCD[8]&=0xF7;pc_order=0;transmite=0x01;}  //stop the usb mode 
  else if(pc_order==0X13)                                // transmite the more than 16000 datalogger data that in the memory.
     { 
      // if(download_ok==0)
         //{download_ok=0;
           delayms(150);pc_order=0;
           TXBUF0=0xAA;delayms(1);  com_status=0X03; 
           TXBUF0=0xCC;delayms(1);     
           TXBUF0=dataloger_no; delayms(1);  
           TXBUF0=(Dataloger_start_Addr-1450)/256;delayms(1);         
           TXBUF0=(Dataloger_start_Addr-1450);delayms(10);  
 
          LCD[19]|=0X20;
          for(i=1450;i<Dataloger_start_Addr;i++)
            {  
            TXBUF0=ReadWord(i);
            }
          LCD[19] &=0Xdf;
          com_status=0xdc; delayms(500);//download_ok=1;
        // }
        // else download_ok=0;
     }
 // }
  usb_ok=0;
}
//------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------
#pragma vector=PORT1_VECTOR
__interrupt void PORT_ISR(void)
{ 
  P1IFG =0;   //when interrupt ,power off
  delayms(30);
  if((P1IN&0x04)==4)
  {
   if(setup_ok!=0)  
   {
   WriteWord(80,mem_no);                                      //before it ,store the memory number ,read memory number,dataloger address,and number.
  WriteWord(81,read_mem_no);
  WriteWord(90,Dataloger_I2c_Addr/256);
  WriteWord(91,Dataloger_I2c_Addr);
  WriteWord(92,dataloger_no);
  LCD[10]=0;LCD[11]=0;LCD[0]=0;LCD[1]=0;
 // LCD[10]|=0X37;LCD[11]|=0X02;LCD[0]|=0X02;LCD[1]=Digit[3];delayms(130);
 // LCD[10]|=0X37;LCD[11]|=0X02;LCD[0]|=0X02;LCD[1]=Digit[2];delayms(130);
  LCD[10]|=0X37;LCD[11]|=0X02;LCD[0]|=0X02;LCD[1]=Digit[1];delayms(130);
    P4OUT |=BIT0;  
   }     
  }
} 
//------------------------------------------------------------------------------------------
void  Device_int(void)
{
ADC12MEM0=0X00;
ADC12MEM1=0X00;
ADC12MEM2=0X00;
ADC12MEM3=0X00; 
ADC12MEM4=0X00;
ADC12MEM5=0X00;
ADC12MEM6=0X00;
ADC12MEM7=0X00;
ADC12MEM9=0X00;
ADC12MEM10=0X00;
ADC12MEM11=0X00;
ADC12MEM12=0X00;
ADC12MEM13=0X00;
ADC12MEM14=0X00;
ADC12MEM15=0X00;
P1DIR =0XC0;       // extenal interrupt
P1SEL =0X00;
P1IE =0X07;       //外部中断 
P1IES =0X00;
P1IFG =0x00;
 
}
//--------------------------------------------------------------------------------------
#pragma vector=BASICTIMER_VECTOR
__interrupt void Button_Scan(void)
 
{ 
 
  if(P3IN!=0xff) {key_status=P3IN;}        //basic timer interrupt start the key scan , about the P3IN
  else {key_status=pcorder;}
  if(ClocK_read_data[7]==0x80){ WriteWord(82,9);}
  if(key_scan==1||mem_load_ok==0)
  {
  switch(key_status)
  {
  case 0xFE:{if((mem_load_ok==0)||(NO_HOLD==1)) break;
  if(UNITS==UNITS_lux){UNITS=UNITS_FC;status0 |=0x04;}
  else {UNITS=UNITS_lux;status0 &=0xFB;} key_scan=0;break;}//fc/lux
  case 0xFD:{ 
                if((setup_ok==0)||(NO_HOLD==1)) break;
                do
             {
               button_counter++; 
                 delayms(10);
                 if(button_counter>20)
                  { 
                   button_counter=0;
                    if(mem_load_ok==1) mem_load_ok=0;
                    else 
                    {
                      mem_load_ok=1;                                  //read the data in memory 
                      LCD[8] &=0x08;LCD[9]=0; status1 &=0xFC;WriteWord(81,read_mem_no);
                    }

                   key_scan=0;button_counter=0; break;          
                }
             }
               while(P3IN==0xFD);
               if(key_scan!=0)
               {   
                  button_counter=0;
                 if(backlight==0){ P4OUT  |=0x02;backlight=1; }         // turn on the backlight
                  else  {P4OUT  &=0xFD;backlight=0;}
               }                                                        //turn off the backlight 
                break;
              }
              
                //load
  case 0xFB:{
             long int i;//memory_ok=0;
              if((setup_ok==0)||(NO_HOLD==1)) break;
              else if(mem_load_ok==0) break;
               do
             {
               button_counter++; 
                 delayms(10);
                 if(button_counter>20)
                  { 
                    
                   
                    if(com_status==0x00)
                   { 
                     if(apo_status==0) apo_status=1;
                    com_status=0xBB;dataloger_no++;
                    //Dataloger_I2c_Addr= Dataloger_start_Addr+1;
                    WriteWord(Dataloger_I2c_Addr,0xaa);
                    WriteWord(Dataloger_I2c_Addr+1,0x56);
                    WriteWord(Dataloger_I2c_Addr+2,dataloger_no);
                    WriteWord(Dataloger_I2c_Addr+3,sampling);
                    WriteWord(Dataloger_I2c_Addr+4,UNITS);
                    for(i=0;i<8;i++)
                     {
                       WriteWord(Dataloger_I2c_Addr+5+i,ClocK_read_data[i]);
                     }
                    Dataloger_I2c_Addr+=13; status1|=0x03;
                    
                    if(dataloger_no==256) dataloger_no=0;
                    
                   }
                   else{
                   apo_status=0;