版权声明：本文为博主原创文章，未经博主同意不得转载。 https://blog.csdn.net/BlueCloudMatrix/article/details/24184461

摘要：

随着智能家居的普及。安全性问题的研究已成当务之急。针对物联网网关自身的易受攻击性和网络传输过程中的信息窃听，我们分别採用SHA-1和AES算法对网关中的操作系统和节点採集的信息进行验证和加密，在一定程度上实现可信。我们创造性地将可信模块与网关平台进行解耦，利于可信模块的升级和维护。

 

简单介绍：

智能家居通过物联网技术将家中的各种设备（如照明系统、空调控制、安防系统）连接到一起。智能家居最初的发展主要以灯光遥控、电器远程控制和电动窗帘控制为主，后来延伸到家庭安防报警、背景音乐、可视对讲、门禁指纹控制等领域。

可见智能家居中的中央控制系统已经担当起大管家的职责，然而随之而来的安全性问题日益突出，须要我们对大管家进行特殊的防护。

物联网网关，作为一个新的名词。在未来的物联网时代将会扮演很重要的角色。它将成为连接感知网络与传统通信网络的纽带。作为网关设备，物联网网关能够实现感知网络与通信网络。以及不同类型感知网络之间的协议转换。既能够实现广域互联．也能够实现局域互联。物联网网关在智能家居中处于核心地位，在我们的设计中网关便担当了大管家的职责，因此我们将重点针对物联网网关进行防护。

可信计算是在计算和通信系统中广泛使用基于硬件安全模块支持下的计算平台。以提高系统总体的安全性与可靠性。

可信计算包含5个完整的可信系统所必须的关键技术概念：签注密钥、安全输入输出、储存器屏蔽、密封储存、以及远程认证。因此将可信计算用于物联网网关，实现一套完毕的物联网网关可信平台模块。而眼下国内还暂无技术较成熟的基于可信计算的物联网网关平台，项目较为新颖。

 

系统设计：

将可信平台模块（TPM）用于对嵌入式物联网网关设备的安全管理。实现网关的安全信息处理及通信。我们设计并在Devkit8500平台上实现了TPM模块的主要基本功能，并搭配基于ARM9的TQ2440平台的嵌入式物联网网关以及基于Zigbee通信协议的无线传感器网络。通过TPM模块对网关启动时（包含Boot Loader以及OS Kernel）的完整性验证，能够在启动前保证网关的核心系统程序的安全性。同一时候。网关应用程序（传感器数据收集、Web Service等）对数据的处理以及同外部设备通信也将通过TPM模块进行加解密处理，以保证数据的安全性。

 

 

 

功能模块设计：

1、TPM模块：

 

1）通过RS232与网关进行通信。

2）上面运行SHA-1验证算法，当网关启动时，网关会先后将其操作系统的bootloader和kernel通过RS232串口传送到TPM。届时SHA-1算法利用传来的信息生成信息摘要并与正确摘要匹配达到开机可信验证的目的，这是针对对物联网网关系统级的攻击的防护，一旦系统发生修改，SHA-1验证算法便会检測到异常。提醒用户。

3）AES加密算法。主要针对传感网节点传来的信息，若以明文存在网关数据库中。相同面临被窃取的风险。我们借鉴https的加密策略。在TPM上集成AES加密算法，节点传来的信息经由TPM进行加密，以密文的信息存在网关上的sqlite数据库中。

 

2、网关模块：

 

1）搭载GoAhead webserver。并编写CGI程序作为逻辑与界面控制。

2）通过RS232与TPM通信，并与温湿度传感器节点组成的Zigbee网络中协调器
进行RS232通讯。

3）自己定义通信协议，实现网关与TPM通信的有序性。

当两路或多路节点信息同一时候经由TPM进行加密处理时。它们是在争用一条串口线。这时就须要定义规则，对多路信息进行惟一标识和排队等候。

 

3、用户端：

通过訪问网关上的CGI页面，用户先进行身份验证，然后可选择是否将请求信息进行AES加密处理。防止用户指令遭窃听。大规模用户訪问对可信模块的计算能力提出了严峻的挑战。而实现的TPM和网关的解耦。却不利于大规模用户訪问，也造成了性能瓶颈。

 

4、传感节点：

 

温湿度传感器配备Zigbee通信模块，组建传感网。协调器节点负责发起并维护一个无线网络。识别网络中的设备增加网络；路由器节点支撑网络链路结构，完毕数据包的转发。终端节点是网络的感知者和运行者，负责数据採集和可运行的网络动作。

 

总结：

针对智能家居。我们搭建了一个模拟环境，建立起TPM负责可信验证，实现节点信息的安全存储、用户訪问信息的加密传输以及系统级的可信验证，并对大规模訪问有所探究。同一时候涉及Zigbee网络的组建，而解耦设计能够对TPM进行单独维护和升级。我们所构建的原始模型。不仅能够用于开发智能家居，并且我们曾将这一模型用于火车站自己主动检票机的设计。这也是我们大胆的将可信计算平台应用于物联网网关设计的一次尝试。

附：

AESListen.c

  1. /*********************************************************
  2.  *TPM  AES jiemi
  3.  *
  4. **********************************************************/
  6. #include<stdio.h>
  7. #include<stdlib.h>
  8. #include<unistd.h>
  9. #include<string.h>
  10. #include<sys/types.h>
  11. #include<sys/stat.h>
  12. #include<fcntl.h>
  13. #include<termios.h>
  14. #include<errno.h>
  15. #include<sys/time.h>
  16. #include <time.h> 
  18. #include "aes.h"
  20. #define FALSE -1
  21. #define TRUE 1
  23. int speed_arr[] = {B115200, B38400, B19200, B9600, B4800, B2400, B1200, B300,
  24. 	B38400, B19200, B9600, B4800, B2400, B1200, B300, };
  25. int name_arr[] = {115200,38400, 19200, 9600, 4800, 2400, 1200, 300,
  26. 	38400, 19200, 9600, 4800, 2400, 1200, 300, }; 
  28. void set_speed(int fd, int speed);
  29. int set_Parity(int fd,int databits,int stopbits,int parity);
  31. void Print(BYTE a[])
  32. {
  33. 	int i;
  34. 	for(i=0; i<4*Nb; i++)
  35. 	{
  36. 		printf("%02X ", a[i]);
  37. 	}
  38. 	printf("\n\n");
  39. }
  41. int main(void)
  42. {
  44. 	char *serialport="/dev/ttyUSB0";
  45. 	int fd;
  46. 	int nread;
  47. 	int count;
  48. 	char buffer[16]={'\0'};
  49. 	char buffer_all[16]={'\0'};
  51. 	fd=open(serialport,O_RDWR|O_NOCTTY|O_NDELAY);
  53. 	if(fd==-1)
  54. 	{
  55. 		printf("%s open error!\n",serialport);
  56. 		return -1;
  57. 	}
  58. 	printf("open %s successfully !",serialport);
  59. 	fflush(stdout);
  60. 	set_speed(fd,115200);
  61. 	if (set_Parity(fd,8,1,'N')==FALSE)
  62. 	{
  63. 		printf("Set Parity Error\n");
  64. 		exit(1);
  65. 	}
  67. 	DWORD e_key[Nb*(MaxNr+1)];
  69. 	BYTE key[4*MaxNk]={              //miyao
  70. 		0x00, 0x01, 0x02, 0x03,
  71. 		0x04, 0x05, 0x06, 0x07,
  72. 		0x08, 0x09, 0x0a, 0x0b,
  73. 		0x0c, 0x0d, 0x0e, 0x0f,
  74. 		0x10, 0x11, 0x12, 0x13,
  75. 		0x14, 0x15, 0x16, 0x17};
  77. 	BYTE decrypted_msg[4*Nb];
  79. 	int filelen;
  80. 	int times=0;
  82. 	SetKey(192);
  83. 	KeyExpansion(key, e_key);
  85. 	tcflush(fd,TCIOFLUSH);
  86. 	count=0;
  87. 	while(1)
  88. 	{
  90. 		nread=read(fd,buffer,16);
  91. 		if(nread>0)
  92. 		{
  93. 			memcpy(buffer_all+count,buffer,nread);
  95. 			count +=nread;
  96. 		}
  98. 		if(count==16)
  99. 		{
  100. 			printf("total_size : %d\n",count);
  101. 			break;
  102. 		}
  103. 		sleep(1);
  104. 		printf("loop one second\n");
  106. 	}
  107. 	printf("encrypted message:\n");
  108. 	Print(buffer_all);
  109. 	AesDecrypt(buffer_all, decrypted_msg, e_key); //jiemi
  110. 	printf("decrypted message:\n");
  111. 	Print(decrypted_msg);
  113. 	write(fd,decrypted_msg,16);
  115. 	return 0;
  117. }
  118. void set_speed(int fd, int speed)
  119. {
  120. 	int i;
  121. 	int status;
  122. 	struct termios Opt;
  123. 	tcgetattr(fd, &Opt);
  124. 	for ( i= 0; i < sizeof(speed_arr) / sizeof(int); i++)
  125. 	{
  126. 	if (speed == name_arr[i])
  127. 	{
  128. 	tcflush(fd, TCIOFLUSH);
  129. 	cfsetispeed(&Opt, speed_arr[i]);    /*  */
  130. 	cfsetospeed(&Opt, speed_arr[i]);
  131. 	status = tcsetattr(fd, TCSANOW, &Opt);    /*     */
  132. 	if (status != 0)
  133. 	{
  134. 		perror("tcsetattr fd1");
  135. 		return;
  136. 	}
  137. 	}
  138. 	tcflush(fd,TCIOFLUSH);    /*          */
  139. 	}
  140. }
  141. int set_Parity(int fd,int databits,int stopbits,int parity)
  142. {
  143. 	struct termios options;
  144. 	if (tcgetattr( fd,&options) != 0)
  145. 	{
  146. 		printf("SetupSerial 1");
  147. 		return(FALSE);
  148. 	}
  149. 	options.c_cflag &= ~CSIZE;   /*     */
  150. 	switch (databits) /**/
  151. 	{
  152. 		case 7:
  153. 			options.c_cflag |= CS7;
  154. 			break;
  155. 		case 8:
  156. 			options.c_cflag |= CS8;
  157. 			break;
  158. 		default:
  159. 			fprintf(stderr,"Unsupported data size\n");
  160. 			return (FALSE);
  161. 	}
  162. 	switch (parity)
  163. 	{
  164. 		case 'n':
  165. 		case 'N':
  166. 			options.c_cflag &= ~PARENB; /* Clear parity enable */
  167. 			options.c_iflag &= ~INPCK; /* Enable parity checking */
  168. 			break;
  169. 		case 'o':
  170. 		case 'O':
  171. 			options.c_cflag |= (PARODD | PARENB); /* */
  172. 			options.c_iflag |= INPCK; /* Disnable parity checking */
  173. 			break;
  174. 		case 'e':
  175. 		case 'E':
  176. 			options.c_cflag |= PARENB; /* Enable parity */
  177. 			options.c_cflag &= ~PARODD; /* */
  178. 			options.c_iflag |= INPCK; /* Disnable parity checking */
  179. 			break;
  180. 		case 'S':
  181. 		case 's': /*as no parity*/
  182. 			options.c_cflag &= ~PARENB;
  183. 			options.c_cflag &= ~CSTOPB;
  184. 			break;
  185. 		default:
  186. 			fprintf(stderr,"Unsupported parity\n");
  187. 			return (FALSE);
  188. 	}
  189. 	/**/
  190. 	switch (stopbits)
  191. 	{
  192. 		case 1:
  193. 			options.c_cflag &= ~CSTOPB;
  194. 			break;
  195. 		case 2:
  196. 			options.c_cflag |= CSTOPB;
  197. 			break;
  198. 		default:
  199. 			fprintf(stderr,"Unsupported stop bits\n");
  200. 			return (FALSE);
  201. 	}
  202. 	/* Set input parity option */
  203. 	if (parity != 'n')
  204. 		options.c_iflag |= INPCK;
  205. 	options.c_cc[VTIME] = 150; // 15 seconds
  206. 	options.c_cc[VMIN] = 0; 
  208. 	options.c_lflag &= ~(ICANON |ISIG);
  209. 	options.c_iflag &= ~(ICRNL|IGNCR);
  211. 	tcflush(fd,TCIFLUSH); /* Update the options and do it NOW */
  212. 	if (tcsetattr(fd,TCSANOW,&options) != 0)
  213. 	{
  214. 		printf("SetupSerial 3");
  215. 		return (FALSE);
  216. 	}
  217. 	return (TRUE);
  218. 	}

Listenarm.c

  1. #include <stdlib.h>
  2. #include <stdio.h>
  3. #include <unistd.h>
  4. #include <string.h>
  5. #include <sys/types.h>
  6. #include <sys/stat.h>
  7. #include <fcntl.h>
  8. #include <termios.h>
  9. #include <errno.h>
  10. #include <sys/time.h>
  11. #include <time.h>
  12. #include "sha1.h"
  13. #include "stdint.h"
  15. #define MAX 1024
  16. #define FALSE -1
  17. #define TRUE 1
  18. #define BUFFER_SIZE 1024
  19. typedef unsigned char TPM_TAG ;
  20. typedef unsigned int UINT32;
  21. typedef unsigned char TPM_COMMAND_CODE;
  23. int speed_arr[] = {B115200, B38400, B19200, B9600, B4800, B2400, B1200, B300,
  24. 	B38400, B19200, B9600, B4800, B2400, B1200, B300, };
  25. int name_arr[] = {115200,38400, 19200, 9600, 4800, 2400, 1200, 300,
  26. 	38400, 19200, 9600, 4800, 2400, 1200, 300, }; 
  28. void set_speed(int fd, int speed);
  29. int set_Parity(int fd,int databits,int stopbits,int parity);
  30. void itoa ( unsigned int val, char *buf, int radix );
  31. unsigned char buffer_all_bootloader[1024*1024];
  32. int buffer_len_bootloader;
  33. unsigned char buffer_all_kernel[1024*1024];
  34. int buffer_len_kernel;
  35. unsigned char Message_Digest_bootloader[SHA1HashSize];
  36. unsigned char Message_Digest_kernel[SHA1HashSize];
  38. typedef struct
  39. {
  40. 	TPM_TAG tag;
  41. 	UINT32 paramSize;
  42. 	TPM_COMMAND_CODE ordinal;
  43. }TPM_COMMAND;
  45. //unsigned char bootloader_sha1_checksum[20]={31,79,191,25,22,207,68,233,254,242,171,148,233,85,122,172,52,150,227,121};
  46. unsigned char bootloader_sha1_checksum[20]={0x77,0xCA,0x04,0xD2,0x41,0xA7,0xF7,0xCD,0x9F,0x69,0x11,0x06,0x68,0x28,0x95,0xE3,0x71,0x7F,0x24,0xEC};
  47. //unsigned char kernel_sha1_checksum[20]={161,76,7,206,132,245,247,137,244,45,3,48,49,98,232,213,32,219,62,17};
  48. unsigned char kernel_sha1_checksum[20]={0x70,0xD0,0x0C,0x51,0x7C,0x10,0xFB,0xCB,0x93,0x81,0x2C,0x0C,0x5C,0x8C,0xBF,0x35,0x23,0xB8,0xE5,0x99};
  49. int main(void)
  50. {
  51.  	char *serialport = "/dev/ttyUSB0";
  52. 	int fd=open(serialport,O_RDWR,O_NOCTTY);
  54. 	if(fd == -1)
  55. 	{
  56. 		printf("%s Open Error!\n",serialport);
  57. 		return -1;
  58. 	}
  59. 	printf("open %s successfully !\n",serialport);
  61. 	fflush(stdout);
  63. 	set_speed(fd,115200);
  65. 	if (set_Parity(fd,8,1,'N')== FALSE)
  66. 	{
  67. 		printf("Set Parity Error\n");
  68. 		exit(1);
  69. 	} 
  71. 	/*******************************************************************************/
  72. 	struct timeval tpstart,tpend;
  73.  	float timeuse;
  74. 	gettimeofday(&tpstart,NULL);
  75. 	write(fd,"s",1);
  76. 	/*TPM帧格式*/
  77. 	TPM_COMMAND request_bootloader={'t',6,'s'};
  78. 	unsigned char d[5];
  79. 	itoa(request_bootloader.paramSize,d,10);
  80. 	unsigned char dest[strlen(d)+5];
  81. 	sprintf(dest,"%c%d%c",request_bootloader.tag,request_bootloader.paramSize,request_bootloader.ordinal);
  82.         dest[3]='a';
  83. 	dest[4]='b';
  84. 	dest[5]='c';
  85. 	write(fd,dest,strlen(d)+5);
  86. 	/*******************************************************************************/
  87. 	//监听bootloader
  88. 	int nread = 1,nwrite = 0;
  89. 	int total_size = 0;
  90. 	unsigned char buffer[BUFFER_SIZE] = {'\0'};
  91.         int i;
  92. 	buffer_len_bootloader = 0;
  94. 	while(1)
  95. 	{
  96. 		nread=read(fd,buffer,1024);
  97. 		if(nread>0)
  98. 		{
  99. 			total_size+=nread;
  100. 			memcpy(buffer_all_bootloader+buffer_len_bootloader,buffer,nread);
  101. 			buffer_len_bootloader+=nread;
  102. #if 0
  103. 			for(i = 0;i<nread;i++)
  104. 			{
  105. 				if(i%8==0)
  106. 				{
  107. 					printf("\n");
  108. 				}
  109. 				printf("0x%x,",buffer[i]);
  111. 			}
  112. #endif
  113. 		}
  114. 		if(total_size==29700)
  115. 		{
  116. 			printf("total_size:%d\n",total_size);
  117. 			break;
  118. 		}
  119. 	}
  120. 	//生成bootloader摘要值
  121. 	sha1_test(buffer_all_bootloader,buffer_len_bootloader,Message_Digest_bootloader);
  122. 	/* sha-1 */
  123. 	sleep(1);
  124. 	int count;
  125.     	for(count=0;count<20;count++)
  126. 	{
  127.             if(bootloader_sha1_checksum[count]==Message_Digest_bootloader[count])
  128.                 continue;
  129.             else
  130.                 goto close;
  131. 	}
  132.         write(fd,"s",1);
  133.         write(fd,"abcdef",6);
  134.         gettimeofday(&tpend,NULL);
  135.     	timeuse=1000000*(tpend.tv_sec-tpstart.tv_sec)+tpend.tv_usec-tpstart.tv_usec;
  136.    	timeuse/=1000000;
  137.    	printf("Used Time:%f\n",timeuse);
  138. 	/*******************************************************************************/
  139.     	//监听kernel0
  140. 	struct timeval tpstart2,tpend2;
  141.  	float timeuse2;
  142. 	gettimeofday(&tpstart2,NULL);
  143. 	nread = 1,nwrite = 0;
  144. 	total_size = 0;
  145. 	unsigned char buffer2[BUFFER_SIZE] = {'\0'};
  146. 	buffer_len_kernel = 0;
  148. 	while(1)
  149. 	{
  150. 		nread=read(fd,buffer2,1024);
  152. 		if(nread>0)
  153. 		{
  154. 			total_size+=nread;
  155. 			memcpy(buffer_all_kernel+buffer_len_kernel,buffer2,nread);
  156. 			buffer_len_kernel+=nread;
  157. #if 0
  158. 			for(i = 0;i<nread;i++)
  159. 			{
  160. 				if(i%8==0)
  161. 				{
  162. 					printf("\n");
  163. 				}
  164. 				//printf("0x%x,",buffer2[i]);
  166. 			}
  167. #endif
  168. 		}
  169. 		if(total_size==29386)
  170. 		{
  171. 			printf("total_size:%d\n",total_size);
  172. 			break;
  173. 		}
  174. 	}
  175. 	//生成kernel摘要值
  176. 	sha1_test(buffer_all_kernel,buffer_len_kernel,Message_Digest_kernel);
  177.     	sleep(1);
  178. 	for(count=0;count<20;count++)
  179. 	{
  180.             if(kernel_sha1_checksum[count]==Message_Digest_kernel[count])
  181.                 continue;
  182.             else
  183.                 goto close;
  184. 	}
  185.         write(fd,"s",1);
  186.         write(fd,"abcdef",6);
  187.     	gettimeofday(&tpend2,NULL);
  188.     	timeuse2=1000000*(tpend2.tv_sec-tpstart2.tv_sec)+tpend2.tv_usec-tpstart2.tv_usec;
  189.    	timeuse2/=1000000;
  190.    	printf("Used Time:%f\n",timeuse2);
  191. close:
  192.         close(fd);
  194. 	return 0;
  195. }
  197. void set_speed(int fd, int speed)
  198. {
  199. 	int i;
  200. 	int status;
  201. 	struct termios Opt;
  202. 	tcgetattr(fd, &Opt);
  203. 	for ( i= 0; i < sizeof(speed_arr) / sizeof(int); i++)
  204. 	{
  205. 	if (speed == name_arr[i])
  206. 	{
  207. 	tcflush(fd, TCIOFLUSH);
  208. 	cfsetispeed(&Opt, speed_arr[i]);    /* 指定输入波特率 */
  209. 	cfsetospeed(&Opt, speed_arr[i]);
  210. 	status = tcsetattr(fd, TCSANOW, &Opt);    /*   将修改后的termios数据设置到串口中   */
  211. 	if (status != 0)
  212. 	{
  213. 		perror("tcsetattr fd1");
  214. 		return;
  215. 	}
  216. 	}
  217. 	tcflush(fd,TCIOFLUSH);    /*          */
  218. 	}
  219. } 
  221. int set_Parity(int fd,int databits,int stopbits,int parity)
  222. {
  223. 	struct termios options;
  224. 	/*if (tcgetattr( fd,&options) != 0)
  225. 	{
  226. 		printf("SetupSerial 1");
  227. 		return(FALSE);
  228. 	} */
  229. 	options.c_cflag &= ~CSIZE;   /*  设置数据位前必须先使用CSIZE做位屏蔽   */
  230. 	switch (databits) /*设置数据位数*/
  231. 	{
  232. 		case 7:
  233. 			options.c_cflag |= CS7;
  234. 			break;
  235. 		case 8:
  236. 			options.c_cflag |= CS8;
  237. 			break;
  238. 		default:
  239. 			fprintf(stderr,"Unsupported data size\n");
  240. 			return (FALSE);
  241. 	}
  242. 	switch (parity)
  243. 	{
  244. 		case 'n':
  245. 		case 'N':
  246. 			options.c_cflag &= ~PARENB; /* Clear parity enable */
  247. 			options.c_iflag &= ~INPCK; /* Enable parity checking */
  248. 			break;
  249. 		case 'o':
  250. 		case 'O':
  251. 			options.c_cflag |= (PARODD | PARENB); /* 设置为奇效验*/
  252. 			options.c_iflag |= INPCK; /* Disnable parity checking */
  253. 			break;
  254. 		case 'e':
  255. 		case 'E':
  256. 			options.c_cflag |= PARENB; /* Enable parity */
  257. 			options.c_cflag &= ~PARODD; /*  转换为偶效验*/
  258. 			options.c_iflag |= INPCK; /* Disnable parity checking */
  259. 			break;
  260. 		case 'S':
  261. 		case 's': /*as no parity*/
  262. 			options.c_cflag &= ~PARENB;
  263. 			options.c_cflag &= ~CSTOPB;
  264. 			break;
  265. 		default:
  266. 			fprintf(stderr,"Unsupported parity\n");
  267. 			return (FALSE);
  268. 	}
  269. 	/* 设置停止位*/
  270. 	switch (stopbits)
  271. 	{
  272. 		case 1:
  273. 			options.c_cflag &= ~CSTOPB;
  274. 			break;
  275. 		case 2:
  276. 			options.c_cflag |= CSTOPB;
  277. 			break;
  278. 		default:
  279. 			fprintf(stderr,"Unsupported stop bits\n");
  280. 			return (FALSE);
  281. 	}
  282. 	/* Set input parity option */
  283. 	if (parity != 'n')
  284. 		options.c_iflag |= INPCK;
  285. 	options.c_cc[VTIME] = 150; // 15 seconds
  286. 	options.c_cc[VMIN] = 0; 
  288. 	options.c_lflag &= ~(ICANON |ISIG);
  289. 	options.c_iflag &= ~(ICRNL|IGNCR);
  291. 	tcflush(fd,TCIFLUSH); /* Update the options and do it NOW */
  292. 	if (tcsetattr(fd,TCSANOW,&options) != 0)
  293. 	{
  294. 		printf("SetupSerial 3");
  295. 		return (FALSE);
  296. 	}
  297. 	return (TRUE);
  298. 	} 
  300. void itoa ( unsigned int val, char *buf, int radix )
  301. {
  302. char *p; /* pointer to traverse string */
  303. char *firstdig; /* pointer to first digit */
  304. char temp; /* temp char */
  305. unsigned int digval; /* value of digit */
  307. p = buf;
  308. firstdig = p; /* save pointer to first digit */
  310. do {
  311. digval = (unsigned int) (val % radix);
  312. val /= radix; /* get next digit */
  314. /* convert to ascii and store */
  315. if (digval > 9)
  316. *p++ = (char)(digval - 10 + 'a'); /* a letter */ ///////////////////////////////
  317. else
  318. *p++ = (char ) (digval + '0'); /* a digit */ ////////////////////////////////
  319. } while (val > 0);
  321. /* We now have the digit of the number in the buffer, but in reverse
  322. order. Thus we reverse them now. */
  324. *p-- = '\0'; /* terminate string; p points to last digit */ /////////////////////
  326. do {
  327. temp = *p;
  328. *p = *firstdig;
  329. *firstdig = temp; /* swap *p and *firstdig */
  330. --p;
  331. ++firstdig; /* advance to next two digits */
  332. } while (firstdig < p); /* repeat until halfway */
  333. }

CGI.c

  1. /*****************
  2.  * CGI
  3.  *
  4.  *
  5. ******************/
  7. #include<stdio.h>
  8. #include<stdlib.h>
  9. #include<string.h>
  10. #include <unistd.h>
  11. #include <sys/types.h>
  12. #include <sys/stat.h>
  13. #include <fcntl.h>
  14. #include <termios.h>
  15. #include <errno.h>
  16. #include <sys/time.h>
  17. #include <time.h> 
  19. #define MAX 1024
  20. #define FALSE -1
  21. #define TRUE 1
  22. #define BUFFER_SIZE 1024
  24. typedef unsigned char BYTE;
  26. int speed_arr[] = {B115200, B38400, B19200, B9600, B4800, B2400, B1200, B300,
  27. 	B38400, B19200, B9600, B4800, B2400, B1200, B300, };
  28. int name_arr[] = {115200,38400, 19200, 9600, 4800, 2400, 1200, 300,
  29. 	38400, 19200, 9600, 4800, 2400, 1200, 300, }; 
  31. void set_speed(int fd, int speed);
  32. int set_Parity(int fd,int databits,int stopbits,int parity);
  34. void Print(BYTE a[])
  35. {
  36. 	int i;
  37. 	for(i=0; i<4*4; i++)
  38. 	{
  39. 		printf("%02X ", a[i]);
  40. 	}
  41. 	printf("\n\n");
  42. }
  44. int main()
  45. {
  46. 	char *method;
  47. 	char *data;
  48. 	int count;
  49. 	int i;
  50. 	int j;
  51. 	char *serialport = "/dev/tq2440_serial1" ;            //
  52. 	int fd;
  53. 	int nread;
  54. 	char buffer[16] = {'\0'};
  55. 	char buffer_all[16]={'\0'};
  56. 	FILE *fp;
  57. 	time_t rawtime;
  58. 	struct tm *timeinfo;
  59. 	int end=5;
  61. 	printf("Content-type:text/html\n\n");
  63. 	printf("<p>this is a cgi");
  65. 	if((method=getenv("REQUEST_METHOD"))==NULL)    //
  66. 		return 1;
  67. 	printf("<p>method: %s",method);
  69. 	if((data=getenv("QUERY_STRING"))==NULL)        //
  70. 		return 1;
  72. 	printf("<p>%s",data);
  74. 	/*if((i=sscanf(data,"command=%s",command))==0)
  75. 		return 1;
  77. 	printf("%s",command);*/
  78. 	/**************************
  79. 	 *
  80. 	 *
  81. 	 *
  82. 	 **************************/
  84. 	fd=open(serialport,O_RDWR|O_NOCTTY|O_NDELAY);
  86. 	if(fd == -1)
  87. 	{
  88. 		printf("%s Open Error!\n",serialport);
  89. 		return -1;
  90. 	}
  91. 	printf("<p>open %s successfully !",serialport);
  93. 	set_speed(fd,115200);
  94. 	if (set_Parity(fd,8,1,'N')== FALSE)
  95. 	{
  96. 		printf("Set Parity Error\n");
  97. 		exit(1);
  98. 	} 
  100. 	tcflush(fd,TCIOFLUSH);
  101. 	write(fd,data,16);
  103. 	count=0;
  104. 	while(end)
  105. 	{
  106. 		end--;
  107. 		nread=read(fd,buffer,16); 
  109. 		if(nread>0)
  110. 		{
  111. 			memcpy(buffer_all+count,buffer,nread);
  113. 			count += nread;
  114. 		}
  116. 		if(count==16)
  117. 		{
  118. 			printf("<p>receive success !");
  119. 			break;
  120. 		}
  121. 		sleep(1);
  122. 		printf("<p>loop one time");
  123. 	}
  124. 	Print(buffer_all);
  126. 	time(&rawtime);
  127. 	timeinfo=localtime(&rawtime);
  128. 	if((fp=fopen("/mnt/usrcommand.txt","ab+"))==NULL)
  129. 		return 1;
  130. 	fprintf(fp,"%4d-%02d-%02d %02d%02d%02d\n",1900+timeinfo->tm_year,1+timeinfo->tm_mon,timeinfo->tm_mday,timeinfo->tm_hour,timeinfo->tm_min,timeinfo->tm_sec);
  132. 	//fwrite(data,sizeof(char),strlen(data),fp);
  134. 	for(j=0; j<4*4; j++)
  135. 	{
  136. 		fprintf(fp,"%02X",buffer_all[j]);
  137. 	}
  139. 	//fwrite(buffer_all,sizeof(char),16,fp);
  141. 	fclose(fp);
  143. 	return 0;
  145. }
  147. void set_speed(int fd, int speed)
  148. {
  149. 	int i;
  150. 	int status;
  151. 	struct termios Opt;
  152. 	tcgetattr(fd, &Opt);
  153. 	for ( i= 0; i < sizeof(speed_arr) / sizeof(int); i++)
  154. 	{
  155. 	if (speed == name_arr[i])
  156. 	{
  157. 	tcflush(fd, TCIOFLUSH);
  158. 	cfsetispeed(&Opt, speed_arr[i]);    /*  */
  159. 	cfsetospeed(&Opt, speed_arr[i]);
  160. 	status = tcsetattr(fd, TCSANOW, &Opt);    /*     */
  161. 	if (status != 0)
  162. 	{
  163. 		perror("tcsetattr fd1");
  164. 		return;
  165. 	}
  166. 	}
  167. 	tcflush(fd,TCIOFLUSH);    /*          */
  168. 	}
  169. } 
  171. int set_Parity(int fd,int databits,int stopbits,int parity)
  172. {
  173. 	struct termios options;
  174. 	if (tcgetattr( fd,&options) != 0)
  175. 	{
  176. 		printf("SetupSerial 1");
  177. 		return(FALSE);
  178. 	}
  179. 	options.c_cflag &= ~CSIZE;   /*    */
  180. 	switch (databits) /**/
  181. 	{
  182. 		case 7:
  183. 			options.c_cflag |= CS7;
  184. 			break;
  185. 		case 8:
  186. 			options.c_cflag |= CS8;
  187. 			break;
  188. 		default:
  189. 			fprintf(stderr,"Unsupported data size\n");
  190. 			return (FALSE);
  191. 	}
  192. 	switch (parity)
  193. 	{
  194. 		case 'n':
  195. 		case 'N':
  196. 			options.c_cflag &= ~PARENB; /* Clear parity enable */
  197. 			options.c_iflag &= ~INPCK; /* Enable parity checking */
  198. 			break;
  199. 		case 'o':
  200. 		case 'O':
  201. 			options.c_cflag |= (PARODD | PARENB); /* 设置为奇效验*/
  202. 			options.c_iflag |= INPCK; /* Disnable parity checking */
  203. 			break;
  204. 		case 'e':
  205. 		case 'E':
  206. 			options.c_cflag |= PARENB; /* Enable parity */
  207. 			options.c_cflag &= ~PARODD; /* */
  208. 			options.c_iflag |= INPCK; /* Disnable parity checking */
  209. 			break;
  210. 		case 'S':
  211. 		case 's': /*as no parity*/
  212. 			options.c_cflag &= ~PARENB;
  213. 			options.c_cflag &= ~CSTOPB;
  214. 			break;
  215. 		default:
  216. 			fprintf(stderr,"Unsupported parity\n");
  217. 			return (FALSE);
  218. 	}
  219. 	/**/
  220. 	switch (stopbits)
  221. 	{
  222. 		case 1:
  223. 			options.c_cflag &= ~CSTOPB;
  224. 			break;
  225. 		case 2:
  226. 			options.c_cflag |= CSTOPB;
  227. 			break;
  228. 		default:
  229. 			fprintf(stderr,"Unsupported stop bits\n");
  230. 			return (FALSE);
  231. 	}
  232. 	/* Set input parity option */
  233. 	if (parity != 'n')
  234. 		options.c_iflag |= INPCK;
  235. 	options.c_cc[VTIME] = 150; // 15 seconds
  236. 	options.c_cc[VMIN] = 0; 
  238. 	options.c_lflag &= ~(ICANON |ISIG);
  239. 	options.c_iflag &= ~(ICRNL|IGNCR);
  241. 	tcflush(fd,TCIFLUSH); /* Update the options and do it NOW */
  242. 	if (tcsetattr(fd,TCSANOW,&options) != 0)
  243. 	{
  244. 		printf("SetupSerial 3");
  245. 		return (FALSE);
  246. 	}
  247. 	return (TRUE);
  248. 	}

智能家居中的物联网网关的可信计算平台模块（TPM）设计的更多相关文章

  1. 迅为4412开发平台Zigbee模块在物联网智能家居中的应用

      物联网智能家居的发展物联网随着互联网的发展,可以通过互联网实现物和物的互联,就有了物联网的概念.传统家居电器 有了物联网之后,在家居电器范围中,就是通过物联网技术将家中的各种设备连接到一起,家居中 ...

  2. 一款新型的智能家居WiFi选择方案——SimpleWiFi在无线智能家居中的应用

    一款新型的智能家居WiFi选择方案——SimpleWiFi在无线智能家居中的应用 先上图:     随着科学技术的不断发展,局域网也正逐渐向无线化,多网合一的方向发展,在这个多网合一快速发展过程中,带 ...

  3. 【智能家居篇】wifi在智能家居中的应用

    转载请注明出处:http://blog.csdn.net/Righthek 谢谢! 在设计智能家居系统方案时,一个很关键的point就是组网方式.组网方式关系到整个智能家居系统的稳定性.可扩展性.实时 ...

  4. 基于能量收集的智能家居-2013国家级大学生创业实践项目申报_商业计划书_V0.2

    SmartHome项目商业计划 基于能量收集的 免电池无线智能家居系统    IA-SmartHome团队    2012.12     l  基于无线的智能家居解决方案,节省施工成本: l  基于能 ...

  5. DIY智能家居——零基础入门篇

    概要 本文主要根据笔者从零开始接触硬件,以小白视角开启IoT探索,根据相关资料DIY一个温湿度传感器.后经过探索发现新大陆--Home Assistant&Homebridge,最终实现了一个 ...

  6. 物联网网关开发：基于MQTT消息总线的设计过程(上)

    道哥的第 021 篇原创 目录 一.前言 二.网关的作用 2.1 指令转发 2.2 外网通信 2.3 协议转换 2.4 设备管理 2.5 边沿计算(自动化控制) 三.网关内部进程之间的通信 3.1 网 ...

  7. 利用Socket与硬件通信（智能家居）

    前几天做一个智能家居APP,硬件段使用的是ESP8266WIFI模块,其实不管是WIFI模块还是蓝牙,通信都是同样一个道理,获取IP和端口来进行通信. 我是通过XCOM v2.0 发送信息,移动端接收 ...

  8. 入门智能家居，从 IFTTT 到 HomeKit 自动化（二）

    入门智能家居,从 IFTTT 到 HomeKit 自动化(二)   目录 0. HomeKit.HomeBridge.HomeAssistant 分别是什么?关系是什么? 1. 开始前的准备 2. 整 ...

  9. Android利用Socket与硬件通信之智能家居APP

    前几天做一个智能家居APP,硬件段使用的是ESP8266WIFI模块,其实不管是WIFI模块还是蓝牙,通信都是同样一个道理,获取IP和端口来进行通信. 我是通过XCOM v2.0 发送信息,移动端接收 ...

随机推荐

  1. MySQL 学习 --- 数据结构和索引

    本文参考了多篇文章集成的笔记,希望各位学习之前可以阅读以下参考资料先 概述 文章分几个部分 :第一部分介绍了B-Tree 和 B+Tree 这种数据结构作为索引:第二部分介绍索引的最左前缀原则和覆盖索 ...

  2. [Linux] Linux系统（用户管理）

    Linux中有三种用户 Root用户:超级管理员 系统用户:Linux运行某些程序所必需的用户,不建议修改 普通用户:一般修改这个 使用命令groupadd,添加用户组,参数:组名称 在文件/etc/ ...

  3. static关键字的内存分析

    通常情况下,Java把内存分为栈内存.堆内存和方法区 栈内存用来存放一些基本类型的变量和数组(数组也是一种引用类型)及对象的引用变量 堆内存主要是来放置对象的,即我们在程序中new出来的对象. sta ...

  4. 设置TableView section header的颜色

      - (void)tableView:(UITableView *)tableView willDisplayHeaderView:(UIView *)view forSection:(NSInte ...

  5. Hive Metastore 连接报错

    背景 项目中需要通过一些自定义的组件来操控hive的元数据,于是使用了remote方式来存储hive元数据,使用一个服务后台作为gateway,由它来控制hive元数据. 现象 在windows上连接 ...

  6. html5备忘录——张鑫旭

    by zhangxinxu from http://www.zhangxinxu.com本文地址:http://www.zhangxinxu.com/wordpress/?p=1544 一.前言兼图片 ...

  7. canvas框架：：createjs入门

    createjs是一个轻量级的框架,稍微有点时间和耐心,就可以把全部源代码都看一遍,毕竟只有三十几个js文件.地址:http://www.createjs.com/ 开发createjs的动画或游戏, ...

  8. javaSE——字节流

    IO流:InputStream/OutputStream 字节流:         文件输出流 :内存 ——>文件 文件输入流 :内存<——文件 应用             文件输入/出 ...

  9. CentOS7.4+MongoBD3.6.4集群(Shard)部署以及大数据量入库

    前言 mongodb支持自动分片,集群自动的切分数据,做负载均衡.避免上面的分片管理难度.mongodb分片是将集合切合成小块,分散到若干片里面,每个片负责所有数据的一部分.这些块对应用程序来说是透明 ...

  10. ComboBox Style

    <SolidColorBrush x:Key="ComboBoxNormalBorderBrush" Color="#e3e9ef" /> < ...