TI

【MCU方案】+嵌入式WiFi输液智能云监控系统

2019-07-27 17:17发布

站内问答 / TI MCU
7334 9 1228
功能介绍：
        我们以TI公司MSP430单片机为控制核心，利用庆科的WiFi开发闪电套件为通信媒介，基于传感器技术、单片机技术、无线通信技术、NFC技术、智能云技术等研究设计了一套嵌入式WiFi智能输液云监控系统。采用光电检测模块检测输液速度，通过步进电机对点滴速度进行控制，利用液晶和按键设定并实时显示点滴速度，当h1降到警戒值（1~2cm）时，发出报警信号，实现人机交互。软件部分采用软件滤波、PID算法等，实现系统精确控制，利用庆科WiFi开发套件发出来的信号，配合带有WiFi功能的摄像头，建立起专用的视频监控网络，实现远程监控、网络会诊等功能。
友情提示: 此问题已得到解决，问题已经关闭,关闭后问题禁止继续编辑，回答。
该问题目前已经被作者或者管理员关闭, 无法添加新回复
9条回答
sharknarduo
1楼-- · 2019-07-27 18:07
方案描述：
一、总体方案设计
本输液智能云监控系统有两大部分组成：（1）主站（即监控中心）由单片机或PC机作为上位机，收集各从站的实时信息，进行显示及报警。（2）从站 由单片机系统构成，完成对某一具体的输液控制的监控。其中包括：滴速测定，滴速预设和监控，液位极限报警，人工呼叫等。同时，将这些信息传送到主站，以便实时监控。
sharknarduo
2楼-- · 2019-07-27 18:44
作品主控实物：
sharknarduo
3楼-- · 2019-07-27 21:53
监控软件：
该系统具有以下特点：
1.        高效性：该平台上CPU的利用率极高，为智能硬件提供了多线程实施操作方案。
2.        实时性：精确的时间的控制，可以实现硬件端、移动端、云端的实时交互、状态更新。
3.        灵活性：用户可以在多种MCU平台上，用户可以针对应用方向和喜好选择嵌入式硬件平台。
4.        连通性：拥有完整的解决方案，包括简易的无线网络设置，智能硬件的初次设置，超快速无线网络接入，本地设备，服务的发现，异常处理，身份认证，安全交互等。
5.        云服务：提供完整的接入和应用范例，支持国内外典型的云计算平台，如阿里云。
6.        低功耗：先进的动态功耗管理技术，可根据当前的应用负载，采用自适应的功耗控制策略。
7.        安全性：完整的网络安全算法，保证云端数据的安全可靠。
8.        稳定性： 用户可以用不同的设备,如PC、手机、pad等通过网络访问我们的云平台。
sharknarduo
4楼-- · 2019-07-28 00:45
 精彩回答 2  元偷偷看……
JY-DX-JY
5楼-- · 2019-07-28 05:14
顶一个。。
sharknarduo
6楼-- · 2019-07-28 09:44
部分源代码：
void main()
{
          unsigned char str[10];  
          LCD_Init();
          EXTI_config();
          Timer_config();
          EA=1;
          LCD_P14x16Ch(28,2,26);
          LCD_P14x16Ch(42,2,27);
          LCD_P14x16Ch(56,2,28);
         delay(8000);
         LCD_CLS();
          LCD_P14x16Ch(0,0,18);         
      LCD_P14x16Ch(18,0,19);
          LCD_P14x16Ch(46,0,20);         
          LCD_P14x16Ch(60,0,21);  
           LCD_P14x16Ch(74,0,22);
            LCD_P14x16Ch(88,0,23);
          delay(2000);
          LCD_P14x16Ch(0,2,14);         
      LCD_P14x16Ch(18,2,15);
          LCD_P14x16Ch(46,2,16);       
          LCD_P14x16Ch(60,2,17);  
           LCD_P14x16Ch(0,4,29);       
      LCD_P14x16Ch(18,4,30);
          LCD_P6x8Str(46,5,"10993285");
          LCD_P14x16Ch(0,6,31);         
          LCD_P14x16Ch(14,6,32);
          LCD_P14x16Ch(33,6,33);
           //zheye gongren
                LCD_P14x16Ch(56,6,34);
                LCD_P14x16Ch(69,6,35);
                LCD_P14x16Ch(86,6,36);
                LCD_P14x16Ch(100,6,37);
           delay(8000);
        LCD_CLS();
                //shifoujinruyemian
          LCD_P14x16Ch(14,2,38);
          LCD_P14x16Ch(28,2,39);
          LCD_P14x16Ch(42,2,40);
          LCD_P14x16Ch(56,2,41);
          LCD_P14x16Ch(70,2,42);
          LCD_P14x16Ch(84,2,43);
          LCD_P14x16Ch(100,2,44);
          LCD_P14x16Ch(114,2,45);
          LCD_P14x16Ch(0,6,38);  
            LCD_P14x16Ch(114,6,39);       
                while(K3);
           delay(8000);
       LCD_CLS();
          //////////////////////////////
      LCD_P14x16Ch(18,0,0);
          LCD_P14x16Ch(32,0,1);       
          LCD_P14x16Ch(46,0,2);       
          LCD_P14x16Ch(60,0,3);
          LCD_P14x16Ch(74,0,4);
          LCD_P14x16Ch(88,0,5);

          LCD_P14x16Ch(0,2,6);
          LCD_P14x16Ch(14,2,7);
          LCD_P14x16Ch(28,2,8);
          LCD_P14x16Ch(42,2,9);

          LCD_P14x16Ch(0,4,10);
          LCD_P14x16Ch(14,4,11);
          LCD_P14x16Ch(28,4,12);
          LCD_P14x16Ch(42,4,13);

          LCD_P14x16Ch(0,6,24);
          LCD_P14x16Ch(14,6,25);

          LCD_P6x8Str(80,7,"14.9.25");        
  while(1)
  {          
     
           if(flog==1)
           {
             sprintf(str,"%5.0f",(float)yd_zs);     
         LCD_P6x8Str(58,3,str);
             sprintf(str,"%5.0f",(float)yd_sd);     
         LCD_P6x8Str(58,5,str);
                 flog=0;
                }
            sprintf(str,"%3.0f",(float)S_D);     
        LCD_P6x8Str(28,7,str);
           if(K0==0)
           {
                delay(20);
                           if(K0==0)
                        {
                                while(!K0);
                                S_D_g++;
                                S_D=S_D_b*100+S_D_s*10+S_D_g;
                        }
           }
            if(K1==0)
           {
                           delay(20);
                        if(K1==0)
                        {
                                while(!K1);
                                S_D_s++;
                                S_D=S_D_b*100+S_D_s*10+S_D_g;
                        }
           }
            if(K2==0)
           {
                           delay(20);
                        if(K2==0)
                        {
                                while(!K2);
                                S_D_b++;
                                S_D=S_D_b*100+S_D_s*10+S_D_g;
                        }
           }
            if(K3==0)
           {
                           delay(20);
                        if(K3==0)
                        {
                                while(!K3);
                                flag=1;
                                Q_D=1;
                                S_D=S_D_b*100+S_D_s*10+S_D_g;
                        }
           }
             if(K4==0)
           {
                           delay(20);
                        if(K4==0)
                        {
                                while(!K4);
                                flag=0;
                                S_D_g=0;
                                S_D_s=0;
                                S_D_b=0;
                                S_D=0;       
                                Q_D=0;                          
                        }
           }
           if((flag==1)&&(flagg==1))
           {
                           direction_control();
                        DirectinControlOutput();
                        flagg=0;
                        K_S=0;
                               
           }
           if((yd_sd<(S_D+10))&&(yd_sd>(S_D-10)))
           {        duty1=0;duty2=0;}       
           if(flag==0)
           {
                duty1=0;duty2=0;               
           }
  }
}
void direction_control(void)
{
int fvalue,fDvalue,ERROR1,fvalue_old;
md=S_D-yd_sd;
fvalue=md;
D_P=1;      D_D=0;     
g_fDirectionControolOld=g_fDirectionControolNew;
ERROR1=fvalue -fvalue_old;
fDvalue=fvalue*D_P+ERROR1*D_D;
fvalue_old=fvalue;
g_fDirectionControolNew=fDvalue;

}
void DirectinControlOutput(void)
{
//         int fValue ;
//        fValue=g_fDirectionControolNew-g_fDirectionControolOld;
//        g_fDirectionControlOut= fValue*(g_nDirectionControlPeriod+1)/DIRECTION_PERIOD+g_fDirectionControolOld;
         g_fDirectionControlOut=g_fDirectionControolNew;
         if(g_fDirectionControlOut>15)
         {g_fDirectionControlOut=15;}
         if(g_fDirectionControlOut<-15)
         {g_fDirectionControlOut=-15;}
        if(g_fDirectionControlOut>=0)
        {
                g_fDirectionControlOut=g_fDirectionControlOut;
                duty1=0;duty2=g_fDirectionControlOut;
        }
        else if(g_fDirectionControlOut<0)
        {
                g_fDirectionControlOut=-g_fDirectionControlOut;
                duty2=0;duty1=g_fDirectionControlOut;
        }
}
void delay(unsigned int ms)
{
   unsigned int ii,jj;
   if (ms<1) ms=1;
   for(ii=0;ii<ms;ii++)
     for(jj=0;jj<500;jj++);  
}
1 2 下一页

一周热门 更多>

相关文章