【实验】基于webservice的嵌入式计算器的设计

目的：
1、加深对gSOAP WebService客户端和服务器端通信基本过程和方法的理解；
2、掌握嵌入式软件开发的一般流程。
? ? 要求：
1、掌握C语言基础知识；
2、掌握Linux环境下vi编辑器的使用方法；
3、掌握Makefile的编写和使用方法；
4、掌握Linux下的程序编译与交叉编译过程； ?

实验内容与分析设计：
? ? 所需硬件环境：
1、博创UP-CPU6410教学及科研平台；
2、PC机pentium500以上，硬盘40G以上，内存512MB以上；
? ? 所需软件环境：
1、4.3.1-eabi-armv6-up-cup6410.tar.gz交叉编译器
2、gsoap_linux_2.7.9e.tar.gz压缩包
? ? 设计过程：
? ? ? ? 1、解压4.3.1-eabi-armv6-up-cup6410.tar.gz软件包，搭建编译环境；
? ? ? ? 2、解压缩gsoap_linux_2.7.9e.tar.gz软件包；
? ? ? ? 3、进入解压后的gsoap_linux_2.7目录下，进入samples下，新建calc目录，在calc目录下，编写相应的客户端程序，服务器端程序，头文件和makefile文件。
4、执行make，生成相应的可执行程序；
5、挂载开发板，运行测试。 ?

步骤：

1、安装交叉编译工具；（不再详述）
2、新建一个目录，将这个实验所需要用到的压缩包复制到该目录中并解压从网站下载压缩包gsoap_linux_2.7.9e.tar.gz，CSDN网站有下载，并且准备解压缩
[root@localhost arm2410cl]# tar -zxvf gsoap_linux_2.7.9e.tar.gz
//解压gsoap_linux_2.7.9e.tar.gz压缩包
3、解压缩后的文件夹是gsoap-linux-2.7，之后进入该文件夹下的samples/calc/
[root@localhost calc]# ls
//显示/arm2410cl/gsoap-linux-2.7/samples/calc/目录下的文件
calcclient.c ?calc.h ?calcserver.c ?Makefile
[root@localhost calc]# vi Makefile
//编辑Makefile文件


?


calcserver: ? ? calc.h calcserver.c $(SOAPH) $(SOAPC)


? ? ? ? ? ? ? ? $(GSOAP) -c calc.h


? ? ? ? ? ? ? ? armv4l-unknown-linux-gcc $(CFLAGS) -o calcserver calcserver.c soapC.c soapServer.c $(SOAPC) -lm $(LIBS)


//将calcserver：中的$(CC)改为arm-linux-gcc编译器


4、[root@localhost calc]# vi calcclient.c


//编辑calc客户端文件,为了能看出效果可以用目录标板的IP地址，将下面的内容：


const char server[] = "http://websrv.cs.fsu.edu/~engelen/calcserver.cgi";


修改成：


const char server[] = http://192.168.1.199:8080;
?
[root@localhost calc]# make


//编译原程序代码，在编译的时候会显示一些关于限制范围的一些警告信息，但不会影响运行结果。
5、挂载：
mountnfs 宿主机的IP：挂载目录 ? ? /mnt/nfs
6、[/mnt/yaffs]cd /mnt/nfs


//切换到/mnt/nfs目录中


[/mnt/nfs]ls


//可以看到是挂载成功的


gsoap-linux-2.7 ? ? ? ? ? ?gsoap_linux_2.7.9e.tar.gz


[/mnt/nfs]cd gsoap-linux-2.7/samples/calc/


//切换到calc目录下的


[/mnt/nfs/gsoap-linux-2.7/samples/calc]ls


//显示目录下的文件


? [/mnt/nfs/gsoap-linux-2.7/samples/calc]./calcserver 8080


//执行calc服务器的执行文件加端口号8080，见到下面信息说明是成功的


Socket connection successful: master socket = 3


Socket connection successful: slave socket = 4


Socket connection successful: slave socket = 4

在linux 打开浏览器，在地址栏输入：http://192.168.1.199:8080/,显示下面界面，同时也会在目标板显示一个从slave socket接口号4连接成功的信息。


? ? ? ? ?[root@localhost calc]# ./calcclient mul 3 4
? ? ? ? //在linux界面下运行calc客户端执行程序，执行命令3*4=12，如果结果返回12说明测试成功，同时在目标板上也会看到返回辅助接口的连接成功信息。

疑难小结：

本次试验需要在linxu操作系统下独立完成，还需要用到开发板，需要学会最基本的操作命令，还要会挂载。
基于webservice的计算器，在linxu下移到开发板上运行，这需要很认真仔细的完成每一步的操作。

 #include<stdio.h> 
 #include<string.h> 
 #include<math.h> 

 #define SIZE1 20 
 #define SIZE2 100 

 int check(char ch[]); 
 double convert(int *place); 
 int OPSWR(char c); 
 int OVSWR(double s); 
 int OPSRE(char *c); 
 int OVSRE(double *s); 
 int OPSDEL(); 
 int OVSDEL(); 
 int ERRORINF(int flag); 
 int CALCULATE(); 
 int COMP(); 

 struct OPSSTA { 
     char stack[SIZE1]; 
     int top; 
 } OPS; 
 struct OVSSTA { 
     double stack[SIZE1]; 
     int top; 
 } OVS; 
 double RESULT; 
 char str[SIZE2],str1[SIZE1]; 

 int main () { 
     int flag=0,sign=0; 
     OPS.top=-1; 
     OVS.top=-1; 
     printf("请输入表达式："); 
     gets(str); 
     strcpy(str1,str);     
     flag=check(str); 
     sign=ERRORINF(flag); 
     if(sign!=1) { 
         getch(); 
         return -1; 
     } 
     flag=CALCULATE(); 
     sign=ERRORINF(flag); 
     if(sign!=1) { 
         getch(); 
         return -1; 
     } 
     else 
         printf("n%s = %.10f",str1,RESULT);         
     getch(); 
     return 1; 
 } 
 int check(char ch[])  { 
     int i=0,j=0,left=0,right=0;     
     for(i=0;ch[i]!='';i++) { 
         if(ch[i]>='('&&ch[i]<='9') { 
             if(ch[i]=='(') 
                 left++; 
             if(ch[i]==')') 
                 right++;             
             if(ch[i]==44) 
                 return -1;     
         } 
     } 
     ch[i]=';'; 
     ch[i+1]='';     
     if(left!=right) 
         return -1;     
     for(i=0;ch[i]!='';i++) { 
         if(ch[i]>='0'&&ch[i]<='9') 
             continue;             
         if(ch[i]=='.') 
             if(!((ch[i+1]>='0'&&ch[i+1]<='9')&&(ch[i-1]>='0'&&ch[i-1]<='9')))     
                 return -1;                 
         if(ch[i]=='+'||ch[i]=='-'||ch[i]=='*'||ch[i]=='/') { 
             if(!((ch[i+1]>='0'&&ch[i+1]<='9'||ch[i+1]=='(')&&(ch[i-1]>='0'&&ch[i-1]<='9'||ch[i-1]=='('))) 
                 return -1; 
             continue; 
         }         
         if(ch[i]=='(') 
             if(ch[i-1]>='0'&&ch[i-1]<='9') 
                 return -1;         
         if(ch[i]==')') 
             if(ch[i+1]>='0'&&ch[i+1]<='9') 
                 return -1; 
     } 
     return 1; 
 } 
 int ERRORINF(int flag) { 
     switch(flag) { 
         case 1: 
             return 1;         
         case -1: 
             printf("表达式格式错误！"); 
             return 0;         
         case -2: 
             printf("栈OPS溢出！"); 
             return 0;         
         case -3: 
             printf("除0！"); 
             return 0;         
         case -4: 
             printf("栈OVS溢出！"); 
             return 0;         
         case -5: 
             printf("栈OVS访问越界！"); 
             return 0;         
         case -6: 
             printf("栈OPS访问越界！"); 
             return 0;         
         default: 
             printf("程序运行错误！"); 
             return 0; 
     } 
 } 

 double convert(int *place) { 
     char num[SIZE1]; 
     int i=0,j=*place; 
      
     for(;str[j]>='0'&&str[j]<='9'||str[j]=='.';j++,i++) 
         num[i]=str[j]; 
     num[i]=''; 
     *place=j; 
     return atof(num); 
 } 
 int OPSWR(char c) { 
     OPS.top++; 
     if(OPS.top>=SIZE1) 
         return -2; 
     OPS.stack[OPS.top]=c; 
     return 1; 
 } 
 int OVSWR(double s) { 
     OVS.top++; 
     if(OVS.top>=SIZE1) 
         return -4; 
     OVS.stack[OVS.top]=s; 
     return 1; 
 } 
 int OPSRE(char *c) { 
     if(OPS.top<0) 
         return -5; 
     else { 
         *c=OPS.stack[OPS.top]; 
         OPSDEL(); 
     } 
     return 1; 
 } 
 int OVSRE(double *s) { 
     if(OVS.top<0) 
         return -6; 
     else { 
         *s=OVS.stack[OVS.top]; 
         OVSDEL();     
     } 
     return 1; 
 } 
 int OPSDEL() { 
     if(OPS.top<0) 
         return -5; 
     else { 
         OPS.stack[OPS.top]=''; 
         OPS.top--; 
     }     
     return 1; 
 } 
 int OVSDEL() { 
     if(OVS.top<0) 
         return -6; 
     else { 
         OVS.stack[OVS.top]=0; 
         OVS.top--; 
     } 
     return 1; 
 } 
 int CALCULATE() { 
     int place,flag=0; 
     double RES; 
     flag=OPSWR(';');     
     if(flag!=1) 
         return flag; 
     for(place=0;str[place]!='';place++) { 
         flag=0;         
         if(str[place]>='0'&&str[place]<='9') { 
             RES=convert(&place); 
             place--; 
             flag=OVSWR(RES); 
             if(flag!=1) 
                 return flag; 
             continue; 
         }         
         if(str[place]=='(') { 
             flag=OPSWR('('); 
             if(flag!=1) 
                 return flag; 
             continue; 
         }         
         if(str[place]==')')  { 
             if(OPS.stack[OPS.top]!='(') { 
                 flag=COMP(); 
                 if(flag!=1) 
                     return flag; 
                 place--; 
                 continue; 
             } 
             else { 
                 flag=OPSDEL(); 
                 if(flag!=1) { 
                     return flag; 
                 } 
             } 
             continue; 
         }         
         if(str[place]=='+'||str[place]=='-') { 
             if(OPS.stack[OPS.top]=='('||OPS.stack[OPS.top]==';') { 
                 flag=OPSWR(str[place]);     
                 if(flag!=1) { 
                     return flag; 
                 } 
                 continue; 
             } 
             else { 
                 flag=COMP(); 
                 if(flag!=1) 
                     return flag; 
                 place--; 
                 continue; 
             }         
         }         
         if(str[place]=='*'||str[place]=='/') { 
             if(OPS.stack[OPS.top]=='*'||OPS.stack[OPS.top]=='/') { 
                 flag=COMP(); 
                 if(flag!=1) 
                     return flag; 
                 place--; 
                 continue;             
             } 
             else { 
                 flag=OPSWR(str[place]); 
                 if(flag!=1) 
                     return flag; 
                 continue; 
             }     
         }         
         if(str[place]==';') { 
             if(OPS.stack[OPS.top]==';') { 
                 RESULT=OVS.stack[OVS.top]; 
                 return 1; 
             } 
             else { 
                 flag=COMP(); 
                 if(flag!=1) { 
                     return flag; 
                 } 
                 place--; 
                 continue;                 
             } 
         } 
         return -1; 
     } 
     return 1; 
 } 
 int COMP() { 
     int flag; 
     double A,B,RES; 
     char ops;     
     flag=OPSRE(&ops); 
     if(flag!=1) { 
         return flag; 
     }     
     flag=OVSRE(&B); 
     if(flag!=1) { 
         return flag; 
     }     
     flag=OVSRE(&A); 
     if(flag!=1) { 
         return flag; 
     } 
     switch(ops) { 
         case '+': 
             RES=A+B; 
             break; 
         case '-': 
             RES=A-B; 
             break; 
         case '*': 
             RES=A*B; 
             break; 
         case '/': 
             if(B==0.0) 
                 return -3; 
             RES=A/B; 
             break; 
         default: 
             return -1; 
     } 
     flag=OVSWR(RES); 
     if(flag!=1) { 
         return flag; 
     } 
     return 1; 
 } 

?"综合实验——基于webservice的嵌入式计算器的设计.doc"?点击打开链接

源代码：点击打开链接