示例#1
0
文件: uflashtest.c 项目: mys812/hf
USER_FUNC void test_uflash_start(void)
{
	uint32_t i;
	uint32_t value;
	int pages;
	
	hfuflash_erase_page(0,1);
	for(i=0;i<HFFLASH_PAGE_SIZE;)
	{
		if(hfuflash_write(i,(char*)&i,sizeof(i))<sizeof(i))
		{
			u_printf("uflash eof\n");
			break;
		}
		i+=sizeof(i);
	}
	
	for(i=0;i<HFFLASH_PAGE_SIZE;)
	{
		if(hfuflash_read(i,(char*)&value,4)<4)
		{
			u_printf("uflash eof\n");
			break;
		}
		u_printf("%d\n",value);
		i+=4;
	}
	pages = (HFUFLASH_SIZE+HFUFLASH1_SIZE)/HFFLASH_PAGE_SIZE;
	for(i=0;i<pages;i++)
	{
		u_printf("erase test %d\n",i);
		msleep(1000);
		if(hfuflash_erase_page(i*HFFLASH_PAGE_SIZE,pages-i)!=HF_SUCCESS)
		{
			u_printf("test erase fail!\n");
			return ;
		}
	}
	
	for(i=0;i<HFUFLASH_SIZE+HFUFLASH1_SIZE;)
	{
		if(hfuflash_write(i,(char*)&i,sizeof(i))<sizeof(i))
		{
			u_printf("uflash eof\n");
			break;
		}
		if(hfuflash_read(i,(char*)&value,4)<4)
		{
			u_printf("uflash eof\n");
			break;
		}
		if(value!=i)
		{
			u_printf("test fail %d %d\n",i,value);
		}
		i+=sizeof(i);
	}
	
}
示例#2
0
static int hf_atcmd_flash(pat_session_t s,int argc,char *argv[],char *rsp,int len)
{
	char flash_data[33];
	
	if(argc == 0)
	{
		memset(flash_data, 0, 33);
		hfuflash_read(0, (uint8_t *)flash_data, 32);
		sprintf(rsp, "=%s", flash_data);
		return 0;
	}
	else if(argc == 1)
	{
		hfuflash_erase_page(0, 1);
		hfuflash_write(0, (uint8_t *)argv[0], 32);
	}
	
	return 0;
	
}
示例#3
0
文件: pet.c 项目: mmaizi/PET
///定时线程,需要连接跳线
USER_FUNC void time_fdthread(void *arg)
{
	while(1)
	{
		///第一步:读时钟模块上的时间值
		hfuart_send(huart, query_time_cmd, sizeof(query_time_cmd), 0);
		msleep(500);
		if (hfuart_recv(huart, recv_timebuf, sizeof(recv_timebuf), 0) > 0)
		{
			memset(time_str, 0, sizeof(time_str));
			hour = BCDToInt(recv_timebuf[0]);			 ///将BCD码转成十进制的时
			min  = BCDToInt(recv_timebuf[1]);
			time_str[0] = (hour / 10) + 48;              ///数字到字符
			time_str[1] = (hour % 10) + 48;
			time_str[2] = ':';
			time_str[3] = (min / 10) + 48;
			time_str[4] = (min % 10) + 48;
			
			// sendto(udp_fd, time_str, sizeof(time_str), 0, (struct sockaddr *)&address, sizeof(address));
		}
		
		
		///第二步:取内存中设定的时间值与当前获取的时间值进行匹配
		///	 备注:每次都轮询完flash中所有的时间设置,标识1~4为喂食,标识5~8为喂水,这样set和cancel不用作修改
		memset(read_timed_flashbuf, 0, sizeof(read_timed_flashbuf));
		hfuflash_read(0, read_timed_flashbuf, sizeof(read_timed_flashbuf));
		
		if (read_timed_flashbuf[1] == ',')							///如果不空
		{
			///2.1 分割整个竖线连接的字符串read_timed_flashbuf数组
			p_timed_str = strtok(read_timed_flashbuf, "|");
			n_timed = 0;
			while(p_timed_str)
			{
				timed_flash_set_str[n_timed] = p_timed_str;
				n_timed++;
				p_timed_str = strtok(NULL, "|");
			}
			
			///2.2 匹配时间并喂食,将需要连接的字符串标识存入存储数组中
			k_timed = -1;
			memset(store_timed_flashbuf, 0, sizeof(store_timed_flashbuf));
			while(k_timed < (n_timed - 1))
			{
				k_timed++;
				memset(timed_cmpbuf, 0, sizeof(timed_cmpbuf));
				strcpy(timed_cmpbuf, timed_flash_set_str[k_timed]);				///timed_flash_set_str[0 -  (n_timed-1)]的格式为:1,08:30,1,3
				// u_printf("timed_cmpbuf is: %s\n", timed_cmpbuf);
				
				///以","分割timed_cmpbuf
				k_cmd = 0;
				p_cmd = strtok(timed_cmpbuf, ",");
				while(p_cmd)
				{
					everyTimeCmd[k_cmd] = p_cmd;
					k_cmd++;
					p_cmd = strtok(NULL, ",");
				}
				
				///取everyTimeCmd[1]中时间值与时钟模块time_str比较
				if (strcmp(time_str, everyTimeCmd[1]) == 0)
				{
					sendto(udp_fd, "Got it", sizeof("Got it"), 0, (struct sockaddr *)&address, sizeof(address));
					//注:此处添加定时喂食、喂水的判断
					
					control_feed[3]=(char)(atoi(everyTimeCmd[3]) * 5);
					hfuart_send(huart, control_feed, sizeof(control_feed), 0);
					if (strcmp(everyTimeCmd[2], "1") == 0)
					{
						continue;
					}
				}
				
				///连接字符串
				strcat(store_timed_flashbuf, timed_flash_set_str[k_timed]);
				strcat(store_timed_flashbuf, vertLine);
				
			}
			
			///写进flash中
			hfuflash_erase_page(0,1);
			hfuflash_write(0, store_timed_flashbuf, sizeof(store_timed_flashbuf));
			sendto(udp_fd, "Only pet(A496): ", sizeof("Only pet(A496): "), 0, (struct sockaddr *)&address, sizeof(address));
			sendto(udp_fd, store_timed_flashbuf, sizeof(store_timed_flashbuf), 0, (struct sockaddr *)&address, sizeof(address));
		}
		
		sleep(75);							///保证每分钟轮询一次
	}
}
示例#4
0
文件: pet.c 项目: mmaizi/PET
//外网模式接收测试
USER_FUNC void recvTest(void *arg) 
{
	if (hfthread_create(fdthread, "feed", 256, NULL, HFTHREAD_PRIORITIES_LOW, NULL, NULL) != HF_SUCCESS)         		 //创建喂食线程
	{
		u_printf("create feed thread fail\n");
	}
	
	if (hfthread_create(wtthread, "water", 256, NULL, HFTHREAD_PRIORITIES_LOW, NULL, NULL) != HF_SUCCESS)         		 //创建喂水线程
	{
		u_printf("create water thread fail\n");
	}
	
	if (hfthread_create(time_fdthread, "timed_fd", 256, NULL, HFTHREAD_PRIORITIES_LOW, NULL, NULL) != HF_SUCCESS)        //创建定时线程
	{
		u_printf("create timed_fd thread fail\n");
	}
	
	while (getMessageThreadFlag())
	{
		sleep(1);								///因为设备在连接服务器过程中此线程一直在循环,实际使用时需要删除这个时延
		
		u_printf("Enter while!\n");
		int msgType = recvMessage();
		
		if (msgType == MESSAGE_FLAG)
		{
			//如果收到的是控制指令
			// u_printf("recv-> %s",getCurrentMsg());
			// sendMessage(getCurrentUser(),getCurrentMsg());
			/**
			 *第一步:调用getCurrentMsg()函数,获取收到的指令字符串,该函数返回字符数组(char*类型)
			 *第二步:根据需要解析字符串得到有效指令码,并发到底层进行控制
			 *第三步:控制结束后,反馈的信息通过sendMessage(user,msg)函数发出,该函数需要传入两个参数
			 *        user参数通过调用getCurrentUser()获得,msg参数即为底层要发给客户端的反馈信息(字符串类型)
			 *
			 *示例:char* codeStr = getCurrentMsg();
			 *      char* code = 指令解析函数();
			 *      进行底层控制,并得到反馈字符串;
			 *      sendMessage(getCurrentUser(),"反馈字符串");
			 *
			 */ 
			u_printf("recv control cmd!\n");

			memset(recvbuf, 0, sizeof(recvbuf));
			char* str = getCurrentMsg();
			u_printf("The client has received a message:    %s\n", str);
			strcpy(recvbuf, str);
			// sendto(udp_fd, recvbuf, sizeof(recvbuf), 0, (struct sockaddr *)&address, sizeof(address));

			p = strtok(recvbuf, "#");
			n = 0;
			while(p)
			{
				cmd[n] = p;
				n++;
				p = strtok(NULL, "#");
			}
			u_printf("cmd[1] is :%s\n", cmd[1]);
			if (strncmp(cmd[0],"action",sizeof("action"))==0)                         //控制喂水、喂食,指令格式:action#1,10
			{
				q = strtok(cmd[1], ",");
				j = 0;
				while(q)
				{
					actcmd[j] = q;
					j++;
					q = strtok(NULL, ",");
				}
				u_printf("actcmd[0] is :%s\n", actcmd[0]);
				
				if (strncmp(actcmd[0],"1",sizeof("1"))==0)
				{
					if (fdstate == 0)
					{
						fdstate = 1;                                                 //将喂食状态改为1,触发喂食线程
					}
					else
					{
						sendMessage(getCurrentUser(), "fdbusy");
						u_printf("Warning: fdbusy!\n");
					}
				}
				else if (strncmp(actcmd[0],"0",sizeof("0"))==0)
				{
					if (wtstate == 0)
					{
						wtstate = 1;                                                 //将喂水状态改为1,触发喂水线程
					}
					else
					{
						sendMessage(getCurrentUser(), "wtbusy");
						u_printf("Warning: wtbusy!\n");
					}
				}
			}
			else if(strncmp(cmd[0],"set",sizeof("set"))==0)							  //定时设置(添加和修改)
			{
				memset(read_flashbuf, 0, sizeof(read_flashbuf));
				hfuflash_read(0, read_flashbuf, sizeof(read_flashbuf));
				
				if (read_flashbuf[1] == ',') 								   									///用户flash中有定时设置
				{
					///第一步:竖线分割flash中时间值,存于指针数组flash_set_str中
					p_str = strtok(read_flashbuf, "|");
					n_str = 0;
					while(p_str)
					{
						flash_set_str[n_str] = p_str;
						n_str++;
						p_str = strtok(NULL, "|");
					}
					
					///第二步:取flash_set_str值中标识与cmd[1]进行比较
					
					k_str = n_str - 1;
					while(k_str >= 0)
					{
						memset(tmp_flash_strcmp, 0, sizeof(tmp_flash_strcmp));
						strcpy(tmp_flash_strcmp, flash_set_str[k_str]);               ///strcpy慎用
						u_printf("The tmp_flash_strcmp is: %s\n", tmp_flash_strcmp);
						
						memset(tmp_cmd_strcmp, 0, sizeof(tmp_cmd_strcmp));
						strcpy(tmp_cmd_strcmp, cmd[1]);
						u_printf("The tmp_cmd_strcmp is: %s\n", tmp_cmd_strcmp);
						
						if (strncmp(strtok(tmp_cmd_strcmp, ","), strtok(tmp_flash_strcmp, ","), 1) == 0)        ///比较时间的标识
						{
							// strcpy(flash_set_str[k_str], cmd[1]);
							flash_set_str[k_str] = cmd[1];
							
							break;
						}
						
						k_str--;
					}
					
					///第三步:连接字符串后放到store_flashbuf中
					memset(store_flashbuf, 0, sizeof(store_flashbuf));
					if (k_str < 0)								//flash中没有该标识,即表示添加
					{
						c_str = 0;
						while(c_str < n_str)
						{
							strcat(store_flashbuf, flash_set_str[c_str]);
							strcat(store_flashbuf, vertLine);
							c_str++;
						}
						strcat(store_flashbuf, cmd[1]);
					}
					else										//修改某个标识的设置
					{
						c_str = 0;
						while(c_str < n_str)
						{
							strcat(store_flashbuf, flash_set_str[c_str]);
							if (c_str < (n_str - 1))
								strcat(store_flashbuf, vertLine);
							c_str++;
						}
					}
				}
				else		///flash中为空
				{
					memset(store_flashbuf, 0, sizeof(store_flashbuf));
					strcat(store_flashbuf, cmd[1]);
				}
				
				///第四步:存储到用户flash中
				hfuflash_erase_page(0, 1);
				hfuflash_write(0, store_flashbuf, sizeof(store_flashbuf));
				u_printf("We have stored the store_flashbuf: %s\n", store_flashbuf);
				sendto(udp_fd, store_flashbuf, sizeof(store_flashbuf), 0, (struct sockaddr *)&address, sizeof(address));
				sendMessage(getCurrentUser(),"control success");
			}
			else if(strncmp(cmd[0], "cancel", sizeof("cancel")) == 0)				  //取消定时设置
			{
				memset(read_flashbuf, 0, sizeof(read_flashbuf));
				hfuflash_read(0, read_flashbuf, sizeof(read_flashbuf));
				
				if (read_flashbuf[1] == ',') 								   									///用户flash中有定时设置
				{
					///第一步:竖线分割flash中时间值,存于指针数组flash_set_str中
					p_str = strtok(read_flashbuf, "|");
					n_str = 0;
					while(p_str)
					{
						flash_set_str[n_str] = p_str;
						n_str++;
						p_str = strtok(NULL, "|");
					}
					
					///第二步:取flash_set_str值中标识与cmd[1]进行比较
					k_str = 0;
					while(k_str < n_str)
					{
				        memset(tmp_flash_strcmp, 0, sizeof(tmp_flash_strcmp));
				        strcpy(tmp_flash_strcmp, flash_set_str[k_str]);
						
						if (strncmp(strtok(tmp_flash_strcmp, ","), cmd[1], 1) == 0)
						{
							break;
						}
						
						k_str++;
					}
					
					///第三步:flash_set_str[k_str]即为要删除的定时字符串,连接其余的放到store_flashbuf中
					c_str = 0;
					memset(store_flashbuf, 0, sizeof(store_flashbuf));
					
					while(c_str < n_str) 
					{
						if(c_str == k_str)
						{
							c_str++;
							continue;
						}
						if (k_str < (n_str -1))
						{
							strcat(store_flashbuf, flash_set_str[c_str]);
							if (c_str < (n_str - 1))
								strcat(store_flashbuf, vertLine);
							c_str++;
						}
						else
						{
							strcat(store_flashbuf, flash_set_str[c_str]);
							if (c_str < (n_str - 2))
								strcat(store_flashbuf, vertLine);
							c_str++;
						}
					}
					
					///第四步:存储到用户flash中
					hfuflash_erase_page(0,1);
					hfuflash_write(0, store_flashbuf, sizeof(store_flashbuf));
					u_printf("We have stored the store_flashbuf: %s\n", store_flashbuf);
					sendto(udp_fd, store_flashbuf, sizeof(store_flashbuf), 0, (struct sockaddr *)&address, sizeof(address));
					sendMessage(getCurrentUser(),"control success");
				}
			}
			else if (strncmp(cmd[0],"flashMemory",sizeof("flashMemory"))==0)		  //读取内存中设定的时间值
			{
				memset(read_flashbuf, 0, sizeof(read_flashbuf));
				hfuflash_read(0, read_flashbuf, sizeof(read_flashbuf));
				u_printf("The time setting is: %s\n", read_flashbuf);
				sendto(udp_fd, read_flashbuf, sizeof(read_flashbuf), 0, (struct sockaddr *)&address, sizeof(address));
				
				sendMessage(getCurrentUser(), read_flashbuf);
			}
			// else if (strncmp(cmd[0],"clearAll",sizeof("clearAll"))==0)                //清空内存中所有设定的时间值
			// {
				// hfuflash_erase_page(0,1);
				// sendMessage(getCurrentUser(),"control success");
			// }
		}
	}
}