基于msp430单片机的体重计程序

说明：

智能体重秤主要由压力秤模块、MPU 模块和 App 模块构成，将智能体重秤放置在床边，每日清晨起床时站在秤上测量一下自己的体重，体重秤会通过数码管将体重显示出来，并与已知数据比较，系统会自动发出提示语音，然后通过内置在体重秤内的蓝牙模块将数据传送到手机App 客户端，将数据记录下来，坚持每日测量的话，系统会根据每日的测量数据绘制体重曲线，进而通过曲线分析人体健康状况，并给出合理建议。用户还可以随时查询之前的体重数据，通过对比来更好地把握自己的健康状况。

通过人体体重变化来监测人体健康情况已有相关文献研究，我们可以借鉴相关的一些研究成果来对人体健康状况进行分析。

模块划分：

①定时器模块：定时期间只记录一次数据，两次计数之间用定时器定时。

②HX711 数据采集模块：采集来自 HX711 的串行数据。

③串口模块：单片机与手机蓝牙串口助手交互功能。

④数码管模块：依据不同的工作模式显示不同的数据。

⑤按键功能模块：根据不同的按键，进入不同的工作模式。共包括：测量模式、记录模式、查询模式、清零模式

代码：

#include "io430.h"
#include "in430.h"

unsigned long int HX711_Read();                        //HX711数据采集函数声明
void Segshow(int n,int a,int b,int c,int d);        //数码管显示函数声明
void HC595SendData(unsigned char SendVal);        //HC5955数据移入函数声明
void HC595ShowData();        //HC5955数据发送函数声明
void HX711_delay();        //HX711采集延迟函数声明
void USCIA0_init();        //蓝牙设置初始化函数声明
void HX711_init();        //HX711设置初始化函数声明
void TAO_init();        //定时器设置初始化函数声明
void GPIO_init();        //GPIO设置初始化函数声明
char int_char(int n);        //数据格式转换函数声明
void delay();                //延时按键防抖函数声明
char buffer[32];        //蓝牙收发数据缓冲区
char advice1[50]="more exercise and less meat!”;//建议1字符串
char advice2[50]="good body and keep on!”;        //建议2字符串
int weightdata[32];             //记录体重数据的数据串
unsigned int j=0;                //计数变量i、j、k、l、p
unsigned int i=0;
unsigned int k=0;
unsigned int l=0;
unsigned int p=0;
int num1,num2,num3,num4,n;      //数码管参数
int count1=0;                   //两次采集数据之间间隔计时
int flag1=0;                    //测量模式
int flag2=0;                    //记录模式
int flag3=0;                    //查询模式
int flag4=0;                        //建议1发送
int flag5=0;                        //建议2发送

int main( void )
{
  WDTCTL = WDTPW + WDTHOLD;     //关闭看门狗                            
  unsigned int m=0;                //数码管选通计数变量

  _EINT();                        //中断总控位打开 
  USCIA0_init();  
  HX711_init();
  GPIO_init();
  TAO_init();
  IE2|=UCA0RXIE;                //接收中断位打开

//****************************************************
//主循环：功能模式、数码管显示
//****************************************************
  while(1)
  {   
    if(flag1==1)//测量模式
    {
      num4=(n)%10;
      num3=(n%100)/10;
      num2=n/100;
      num1=0; 
    }
    else if(flag2==1) //记录模式
    {
      num4=(weightdata[k-1])%10;
      num3=(weightdata[k-1]%100)/10;
      num2=weightdata[k-1]/100;
      num1=0; 
    }
    else if(flag3==1) //查询模式
    {
      num4=(weightdata[l])%10;
      num3=(weightdata[l]%100)/10;
      num2=weightdata[l]/100;
      num1=0; 
    } 
    else              //查询清零模式
    {
      num4=0;
      num3=0;
      num2=0;
      num1=0;
    }
    Segshow(m,num1,num2,num3,num4);
    m=m+1;
    if(m==4) m=0;
  }
}

//****************************************************
//中断子函数
//****************************************************

#pragma vector=TIMER0_A0_VECTOR                 //定时器中断
__interrupt void timer0_A0_ISR()
{
  if(count1<30)
    count1=count1+1;
  if(count1==30)                               
  {      
    n=(HX711_Read()-8529600)/1000;//采集数据
    count1=0;
  }
}

#pragma vector=USCIAB0RX_VECTOR                  //蓝牙接收中断
__interrupt void UCA0RX_isr()
{
    buffer[j]=UCA0RXBUF;         //读接收缓冲器保存一个字符
    j++;
    if(buffer[0]=='a')
    {
      j=0;
      flag4=1;
      flag5=0;
      IE2|=UCA0TXIE;             //打开发送中断位
    }   
    else if(buffer[0]=='b')
    {  
      j=0;
      flag4=0;
      flag5=1;
      IE2|=UCA0TXIE;             //打开发送中断位
    }
}

#pragma vector=USCIAB0TX_VECTOR                 //蓝牙发送中断
__interrupt void UCA0TX_isr()
{
  if(flag4==1)
  {
    buffer[0]=int_char(num1);
    buffer[1]=int_char(num2);
    buffer[2]=int_char(num3);
    buffer[3]=int_char(num4);
    if(i<4)
      {
        UCA0TXBUF= buffer[i];        //从发送缓冲器发送一个字符
      }
      i++;
    if(i==4)
      {
        i=0;
        IE2&=~UCA0TXIE;                //关闭发送中断位
      }
  }
  else if(flag5==1)
  {
    if(weightdata[k-1]<400)
    {
      P2OUT|=BIT7;
      if(i<50)
      {
        UCA0TXBUF=advice2[i];        //从发送缓冲器发送一个字符
      }
      i++;
      if(i==50)
      {
        i=0;
        IE2&=~UCA0TXIE;                //关闭发送中断位
      }
    }
    else if(weightdata[k-1]>400)
    {
      P2OUT&=~BIT7;
      if(i<50)
      {
        UCA0TXBUF=advice1[i];        //从发送缓冲器发送一个字符
      }
      i++;
      if(i==50)
      {
        i=0;
        IE2&=~UCA0TXIE;                //关闭发送中断位
      }
    }
  }
}

#pragma  vector=PORT1_VECTOR                          //P1向量中断        
__interrupt  void port_ISR1()
{ 
  delay();
  if((P1IFG&BIT7)!=0)                //进入记录模式
   {
     P2OUT|=BIT7;
     weightdata[k]=n; 
     if(k<5)
       k++;
     else if(k==5)
       k=0;
     flag1=0;
     flag2=1;
     flag3=0;
     p=0;
     P1IFG&=~BIT7;
   }
  if((P1IFG&BIT3)!=0)                //进入测量模式
   {
     P2OUT|=BIT7;
     flag1=1;
     flag2=0;
     flag3=0;
     p=0;
     P1IFG&=~BIT3;
   }
}

#pragma  vector=PORT2_VECTOR                          //P2向量中断                
__interrupt  void port_ISR2()
{   
  delay();
  if((P2IFG&BIT4)!=0)                //进入查询模式
   {
     flag1=0;
     flag2=0;
     flag3=1;
     p=0;
     if(l<5)
       l++;
     else if(l==5)
       l=0;
     P2IFG&=~BIT4;
   }
  if((P2IFG&BIT6)!=0)                //进入清零模式
  {
    P2OUT|=BIT7;
    flag1=0;
    flag2=0;
    flag3=0;
    while(p<32)                       //所有数据清零
    {
      weightdata[p]=0;
      p++;
    }
    k=0;                             //从头计数
    P2IFG&=~BIT6;
  }
}

//****************************************************
//子函数
//****************************************************

void HC595SendData(unsigned char SendVal)                //HC5955数据移入函数        
{  
  int m;                     
  for(m=0;m<8;m++) 
  {
  if((SendVal<<m)&0x80) P1OUT_bit.P4=1;
  else P1OUT_bit.P4=0;
  P1OUT_bit.P5=0;                       //从SHCP产生一上升沿(移入数据)
  P1OUT_bit.P5=1; 
   }
} 
void HC595ShowData()                                     //HC5955数据发送函数
{
  P1OUT_bit.P6=0;                        //STCP产生一上升沿(输出数据)
  P1OUT_bit.P6=1; 
} 

void HX711_delay()                                        //HX711采集延迟函数
{
  int m;
  for(m=0;m<2;m++);        
}

unsigned long int HX711_Read(int a,int b,int c,int d)        //HX711数据采集函数
{
        unsigned long int count; 
        unsigned int k;  
        HX711_delay();
          P1OUT_bit.P0=0; 
          count=0; 
          while(P2IN_bit.P5); 
          for(k=0;k<24;k++)                //前24个脉冲下降沿存下数据到count中
        { 
                  P1OUT_bit.P0=1; 
                  count=count<<1; 
                P1OUT_bit.P0=0; 
                  if(P2IN_bit.P5)
                        count++; 
        } 
        P1OUT_bit.P0=1; 
        count=count^0x800000;                //第25个脉冲下降沿来时，转换数据
        HX711_delay();
        P1OUT_bit.P0=0;  
        return(count);
}

void Segshow(int n,int a,int b,int c,int d)                //数码管显示函数
{
  unsigned char Segdata[]={0xc0,0xf9,0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80,0x90};
  switch(n)                                   
    {
    case 0:
      HC595SendData(Segdata[d]);        //注意数据和选通的先后顺序
      HC595ShowData();
      P2OUT&=~BIT3;
      P2OUT|=BIT0;
      break;
    case 1:
      HC595SendData(Segdata[c]);
      HC595ShowData();
      P2OUT&=~BIT0;
      P2OUT|=BIT1;
      break;
    case 2:
      HC595SendData(Segdata[b]);
      HC595ShowData();
      P2OUT&=~BIT1;
      P2OUT|=BIT2;
      break;
    case 3:
      HC595SendData(Segdata[a]);
      HC595ShowData();
      P2OUT&=~BIT2;
      P2OUT|=BIT3;
      break;
    }
}

void USCIA0_init()                                        //蓝牙设置初始化函数
{
  UCA0CTL1 |= UCSWRST;                         //swrst=1
  P1SEL |= BIT1+BIT2;
  P1SEL2 |= BIT1+BIT2;                         //P1.1和P1.2引脚功能设置
  UCA0CTL1 |= UCSSEL_2+UCRXEIE;                //时钟源选 SMCLK 默认约 1MHz 
  UCA0BR1 = 0;                                //高八位 0
  UCA0BR0 = 104;                        //低八位为 104
  UCA0MCTL = UCBRS_1;                        //由上述计算出 0.167*8 近似为 1
  UCA0CTL1 &=~UCSWRST ;                        //swrst=0
}

void HX711_init()                                        //HX711设置初始化函数
{
  P2SEL&=~BIT5;                                //对应HX711的DOUT
  P2DIR|=BIT5;
  P2DIR&=~BIT5;
  P2REN|=BIT5;  
  
  P1DIR|=BIT0;                                 //对应HX711的SCK
  P1SEL&=~BIT0;
  P1SEL2&=~BIT0;
  P1OUT&=~BIT0;
}

void TAO_init()                                                //定时器设置初始化函数
{
  TA0CTL|=TACLR+TASSEL_2+MC_1;          //设置TA0计时，选用DCO时钟源1MHz
  TA0CCR0=10000;
  TA0CCTL0|=CCIE;                        //进入定时器中断 
}

void GPIO_init()                                        //GPIO设置初始化函数
{
  P1DIR|=BIT4+BIT5+BIT6;                 //数码管显示设置
  P1SEL&=~(BIT4+BIT5+BIT6);
  P1SEL2&=~(BIT4+BIT5+BIT6);
  P1OUT&=~(BIT4+BIT5+BIT6);
  P2DIR|=BIT0+BIT1+BIT2+BIT3;         
  P2SEL&=~(BIT0+BIT1+BIT2+BIT3);
  P2SEL2&=~(BIT0+BIT1+BIT2+BIT3);
  P2OUT&=~(BIT0+BIT1+BIT2+BIT3);
  
  P2SEL&=~(BIT4+BIT6);                  //设置2.4、2.6允许中断 
  P2SEL2&=~(BIT4+BIT6);
  P2OUT|=(BIT4+BIT6);
  P2REN|=(BIT4+BIT6); 
  P2DIR&=~(BIT4+BIT6);
  P2IES|=(BIT4+BIT6);
  P2IFG&=~(BIT4+BIT6); 
  P2IE|=(BIT4+BIT6);
  
  P1SEL&=~(BIT3+BIT7);                  //设置1.3、1.7允许中断 
  P1SEL2&=~(BIT3+BIT7);
  P1OUT|=(BIT3+BIT7);
  P1REN|=(BIT3+BIT7); 
  P1DIR&=~(BIT3+BIT7);
  P1IES|=(BIT3+BIT7);
  P1IFG&=~(BIT3+BIT7); 
  P1IE|=(BIT3+BIT7);
  
  P2DIR|=BIT7;                          //蜂鸣器设置
  P2SEL&=~BIT7;                  
  P2SEL2&=~BIT7;              
  P2OUT|=BIT7;
}

char int_char(int n)                                        //数据格式转换函数
{
  char m;
  switch(n)
  {
    case(0): m='0';break;
    case(1): m='1';break;
    case(2): m='2';break;   
    case(3): m='3';break;
    case(4): m='4';break;
    case(5): m='5';break;
    case(6): m='6';break;
    case(7): m='7';break;
    case(8): m='8';break;
    case(9): m='9';break;
  }
  return m;
}

void delay()                                                //延时按键防抖函数
{   unsigned int o;
    for (o=0;o<0x00ff;o++);                    
}    

http://wiki.ocrobot.com/doku.php?id=learning arduino中文手册页面