Context Navigation

← Previous Revision
Latest Revision
Next Revision →
Normal
Revision Log

echonet_agent.c@ 101

Last change on this file since 101 was 101, checked in by coas-nagasima, 9 years ago
TOPPERS/uKadecotのソースコードを追加
Property svn:eol-style set to `native` Property svn:keywords set to `Id` Property svn:mime-type set to `text/plain`
File size: 28.0 KB

Rev	Line
[101]	1	/*
	2	* TOPPERS ECHONET Lite Communication Middleware
	3	*
	4	* Copyright (C) 2015 Cores Co., Ltd. Japan
	5	*
	6	* ãLì ÒÍCÈºÌ(1)`(4)Ìðð½·êÉÀèC{\tgEF
	7	* Ai{\tgEFAðüÏµ½àÌðÜÞDÈº¯¶jðgpE¡»Eü
	8	* ÏEÄzziÈºCpÆÄÔj·é±Æð³Åø·éD
	9	* (1) {\tgEFAð\[XR[hÌ`Åp·éêÉÍCãLÌì
	10	* \¦C±Ìpð¨æÑºLÌ³ÛØKèªC»ÌÜÜÌ`Å\[
	11	* XR[hÉÜÜêÄ¢é±ÆD
	12	* (2) {\tgEFAðCCu`®ÈÇC¼Ì\tgEFAJÉg
	13	* pÅ«é`ÅÄzz·éêÉÍCÄzzÉº¤hL
	14	gip
	15	* Ò}j
	16	AÈÇjÉCãLÌì \¦C±Ìpð¨æÑºL
	17	* Ì³ÛØKèðfÚ·é±ÆD
	18	* (3) {\tgEFAðC@íÉgÝÞÈÇC¼Ì\tgEFAJÉg
	19	* pÅ«È¢`ÅÄzz·éêÉÍCÌ¢¸ê©Ìðð½·±
	20	* ÆD
	21	* (a) ÄzzÉº¤hL
	22	gipÒ}j
	23	AÈÇjÉCãLÌ
	24	* ì \¦C±Ìpð¨æÑºLÌ³ÛØKèðfÚ·é±ÆD
	25	* (b) ÄzzÌ`ÔðCÊÉèßéû@ÉæÁÄCTOPPERSvWFNgÉ
	26	* ñ·é±ÆD
	27	* (4) {\tgEFAÌpÉæè¼ÚIÜ½ÍÔÚIÉ¶¶é¢©Èé¹
	28	* Q©çàCãLì Ò¨æÑTOPPERSvWFNgðÆÓ·é±ÆD
	29	* Ü½C{\tgEFAÌ[UÜ½ÍGh[U©çÌ¢©Èé
	30	* RÉîÃ¿©çàCãLì Ò¨æÑTOPPERSvWFNgð
	31	* ÆÓ·é±ÆD
	32	*
	33	* {\tgEFAÍC³ÛØÅñ³êÄ¢éàÌÅ éDãLì Ò¨
	34	* æÑTOPPERSvWFNgÍC{\tgEFAÉÖµÄCÁèÌgpÚI
	35	* ÉÎ·éK«àÜßÄC¢©ÈéÛØàsíÈ¢DÜ½C{\tgEF
	36	* AÌpÉæè¼ÚIÜ½ÍÔÚIÉ¶¶½¢©Èé¹QÉÖµÄàC»
	37	* ÌÓCðíÈ¢D
	38	*
	39	* @(#) $Id: echonet_agent.c 101 2015-06-02 15:37:23Z coas-nagasima $
	40	*/
	41
	42	/*
	43	* ECHONET Lite ®I¶¬m[h
	44	*/
	45
	46	#include <kernel.h>
	47	#include <stdio.h>
	48	#include <stdlib.h>
	49	#include <stdarg.h>
	50	#include <string.h>
	51	#include <t_syslog.h>
	52	#include "echonet.h"
	53	#include "echonet_fbs.h"
	54	#include "echonet_agent.h"
	55	#include "echonet_task.h"
	56	#include "echonet_lcl_task.h"
	57
	58	extern bool_t g_forward_esv;
	59
	60	typedef struct ecn_agent_buffer
	61	{
	62	union{
	63	struct ecn_agent_buffer *free;
	64	ecn_agent_queue_t queue;
	65	};
	66	union{
	67	ecn_obj_t obj;
	68	ecn_node_t node;
	69	ecn_device_t device;
	70	};
	71	} ecn_agent_buffer_t;
	72
	73	typedef struct ecn_agent
	74	{
	75	EPRPINIB eprpinib;
	76	ecn_agent_queue_t nodes;
	77	ecn_node_t *current_node;
	78	bool_t msg_proced;
	79	int blkpos;
	80	ecn_agent_buffer_t *free;
	81	ecn_agent_buffer_t blockes[TNUM_AEOBJID];
	82	int requestid;
	83	} ecn_agent_t;
	84
	85	static ER ecn_agent_proc_get_device_list(ecn_agent_t *agent, ECN_FBS_ID req);
	86	static ER ecn_agent_proc_get_device_info(ecn_agent_t *agent, ECN_FBS_ID req);
	87	static void ecn_node_send_set_prop_map(ecn_node_t *node);
	88	static void ecn_node_send_get_prop_map(ecn_node_t *node);
	89	static void ecn_node_send_anno_prop_map(ecn_node_t *node);
	90	static void ecn_node_timeout_on_start(ecn_node_t *node);
	91	static void ecn_node_next_proc_on_set_prpmap_wait(ecn_node_t node, ecn_obj_t sobj);
	92	static void ecn_node_timeout_on_set_prpmap_wait(ecn_node_t *node);
	93	static void ecn_node_next_proc_on_get_prpmap_wait(ecn_node_t node, ecn_obj_t sobj);
	94	static void ecn_node_timeout_on_get_prpmap_wait(ecn_node_t *node);
	95	static void ecn_node_next_proc_on_anno_prpmap_wait(ecn_node_t node, ecn_obj_t sobj);
	96	static void ecn_node_timeout_on_anno_prpmap_wait(ecn_node_t *node);
	97
	98	int ecn_agent_eprpset(const EPRPINIB item, const void src, int size, bool_t *anno);
	99	int ecn_agent_eprpget(const EPRPINIB item, void dst, int size);
	100
	101	static ecn_agent_queue_t cast_queue(ecn_obj_t obj)
	102	{
	103	return (ecn_agent_queue_t *)((intptr_t)obj - offsetof(ecn_agent_buffer_t, obj));
	104	}
	105
	106	static ecn_obj_t cast_obj(ecn_agent_queue_t queue)
	107	{
	108	return (ecn_obj_t *)((intptr_t)queue + offsetof(ecn_agent_buffer_t, obj));
	109	}
	110
	111	static ecn_node_t cast_node(const EOBJCB eobj)
	112	{
	113	return (ecn_node_t *)((intptr_t)eobj - offsetof(ecn_node_t, eobj));
	114	}
	115
	116	static ecn_obj_t cast_obj2(const EOBJINIB inib)
	117	{
	118	return (ecn_obj_t *)((intptr_t)inib - offsetof(ecn_obj_t, inib));
	119	}
	120
	121	static ecn_agent_t cast_agent(const EPRPINIB inib)
	122	{
	123	return (ecn_agent_t *)((intptr_t)inib - offsetof(ecn_agent_t, eprpinib));
	124	}
	125
	126	ecn_agent_t g_ecn_agent = {
	127	/eprpinib/{
	128	0x00,
	129	EPC_RULE_SET \| EPC_RULE_GET,
	130	255,
	131	(intptr_t)&g_ecn_agent,
	132	ecn_agent_eprpset,
	133	ecn_agent_eprpget
	134	},
	135	};
	136
	137	ER get_buf(ecn_agent_t agent, ecn_agent_buffer_t *buf)
	138	{
	139	ER ret = E_OK;
	140
	141	loc_cpu();
	142
	143	if (agent->blkpos < TNUM_AEOBJID) {
	144	*buf = &agent->blockes[agent->blkpos++];
	145	}
	146	else if (agent->free == NULL) {
	147	ret = E_TMOUT;
	148	}
	149	else{
	150	*buf = agent->free;
	151	agent->free = agent->free->free;
	152	}
	153
	154	unl_cpu();
	155
	156	return ret;
	157	}
	158
	159	ER rel_buf(ecn_agent_t agent, ecn_agent_buffer_t buf)
	160	{
	161	if ((buf < &agent->blockes[0]) \|\| (buf >= &agent->blockes[TNUM_AEOBJID]))
	162	return E_PAR;
	163
	164	if ((((intptr_t)buf - (intptr_t)&agent->blockes[0]) % sizeof(ecn_agent_buffer_t)) != 0)
	165	return E_PAR;
	166
	167	loc_cpu();
	168
	169	if (agent->free == NULL) {
	170	agent->free = buf;
	171	agent->free->free = NULL;
	172	}
	173	else {
	174	ecn_agent_buffer_t *next = agent->free;
	175	agent->free = buf;
	176	agent->free->free = next;
	177	}
	178
	179	unl_cpu();
	180
	181	return E_OK;
	182	}
	183
	184	/*
	185	* L
	186	[Ìú»
	187	*
	188	* p_queueÉÍL
	189	[wb_ðwè·éD
	190	*/
	191	Inline void
	192	ecn_agent_queue_init(ecn_agent_queue_t *p_queue)
	193	{
	194	#ifdef _DEBUG
	195	p_queue->p_parent = p_queue;
	196	#endif
	197	p_queue->p_prev = p_queue;
	198	p_queue->p_next = p_queue;
	199	}
	200
	201	/*
	202	* L
	203	[ÌOGgÖÌ}ü
	204	*
	205	* p_queueÌOÉp_entryð}ü·éDp_queueÉL
	206	[wb_ðwèµ½ê
	207	* ÉÍCL
	208	[ÌöÉp_entryð}ü·é±ÆÉÈéD
	209	*/
	210	Inline void
	211	ecn_agent_queue_add(ecn_agent_queue_t p_queue, ecn_agent_queue_t p_entry)
	212	{
	213	#ifdef _DEBUG
	214	assert((p_queue->p_parent == p_queue) && (p_entry->p_parent == NULL));
	215	p_entry->p_parent = p_queue;
	216	#endif
	217	p_entry->p_prev = p_queue->p_prev;
	218	p_entry->p_next = p_queue;
	219	p_queue->p_prev->p_next = p_entry;
	220	p_queue->p_prev = p_entry;
	221	}
	222
	223	/*
	224	* GgÌí
	225	*
	226	* p_entryðL
	227	[©çí·éD
	228	*/
	229	Inline void
	230	ecn_agent_queue_remove(ecn_agent_queue_t p_queue, ecn_agent_queue_t p_entry)
	231	{
	232	#ifdef _DEBUG
	233	assert((p_queue->p_parent == p_queue) && (p_entry->p_parent == p_queue));
	234	p_entry->p_parent = NULL;
	235	#endif
	236	p_entry->p_prev->p_next = p_entry->p_next;
	237	p_entry->p_next->p_prev = p_entry->p_prev;
	238	}
	239
	240	ecn_node_t *ecn_agent_find_node(ECN_ENOD_ID enodid)
	241	{
	242	ecn_agent_t *agent = &g_ecn_agent;
	243	ecn_agent_queue_t *queue = agent->nodes.p_next;
	244	#ifdef _DEBUG
	245	assert(queue->p_parent == &agent->nodes);
	246	#endif
	247	for (; queue != &agent->nodes; queue = queue->p_next) {
	248	ecn_node_t node = (ecn_node_t )cast_obj(queue);
	249	if(node->enodId == enodid)
	250	return node;
	251	}
	252
	253	return NULL;
	254	}
	255
	256	ecn_node_t ecn_agent_find_node2(const EOBJCB pk_eobj)
	257	{
	258	ecn_agent_t *agent = &g_ecn_agent;
	259	ecn_agent_queue_t *queue;
	260
	261	if(pk_eobj == NULL)
	262	return NULL;
	263
	264	queue = agent->nodes.p_next;
	265	#ifdef _DEBUG
	266	assert(queue->p_parent == &agent->nodes);
	267	#endif
	268	for (; queue != &agent->nodes; queue = queue->p_next) {
	269	ecn_node_t node = (ecn_node_t )cast_obj(queue);
	270	if(&node->eobj == pk_eobj)
	271	return node;
	272	}
	273
	274	return NULL;
	275	}
	276
	277	ecn_obj_t ecn_agent_find_eobj(const EOBJCB pk_nod, T_ECN_EOJ eoj)
	278	{
	279	ecn_agent_queue_t *devices = &cast_node(pk_nod)->devices;
	280	ecn_agent_queue_t *queue = devices->p_next;
	281	#ifdef _DEBUG
	282	assert(queue->p_parent == devices);
	283	#endif
	284	for (; queue != devices; queue = queue->p_next) {
	285	ecn_obj_t *obj = cast_obj(queue);
	286	if (obj->inib.eojx1 != eoj.eojx1)
	287	continue;
	288	if (obj->inib.eojx2 != eoj.eojx2)
	289	continue;
	290	if (obj->inib.eojx3 != eoj.eojx3)
	291	continue;
	292
	293	return obj;
	294	}
	295
	296	return NULL;
	297	}
	298
	299	ecn_obj_t ecn_agent_find_obj2(ecn_node_t pk_nod, const EOBJINIB *pk_obj)
	300	{
	301	ecn_agent_queue_t *devices = &pk_nod->devices;
	302	ecn_agent_queue_t *queue = devices->p_next;
	303	#ifdef _DEBUG
	304	assert(queue->p_parent == devices);
	305	#endif
	306	for (; queue != devices; queue = queue->p_next) {
	307	ecn_obj_t *obj = cast_obj(queue);
	308	if (&obj->inib == pk_obj)
	309	return obj;
	310	}
	311
	312	return NULL;
	313	}
	314
	315	ID ecn_agent_get_eobj(const EOBJINIB *pk_obj)
	316	{
	317	return cast_obj2(pk_obj)->eobjId;
	318	}
	319
	320	const EOBJINIB ecn_agent_next_eobj(const EOBJCB pk_nod, const EOBJINIB *pk_obj)
	321	{
	322	ecn_agent_queue_t *devices = &cast_node(pk_nod)->devices;
	323	ecn_obj_t device = (ecn_obj_t )pk_obj->exinf;
	324	ecn_agent_queue_t *queue = cast_queue(device);
	325	#ifdef _DEBUG
	326	assert(queue->p_parent == devices);
	327	#endif
	328	if (queue == devices)
	329	return NULL;
	330
	331	return &cast_obj(queue->p_next)->inib;
	332	}
	333
	334	bool_t ecn_agent_get_eoj_enodid(ID eobjid, T_ECN_EOJ eoj, ECN_ENOD_ID enodid)
	335	{
	336	ecn_agent_t *agent = &g_ecn_agent;
	337	ecn_agent_buffer_t *buf;
	338	int i = eobjid;
	339
	340	/* IuWFNgID©çÀÌðæ¾ */
	341	i -= (tmax_eobjid + 1);
	342	if ((i < 0)
	343	\|\| (i >= (sizeof(agent->blockes) / sizeof(agent->blockes[0])))){
	344	return false;
	345	}
	346
	347	buf = &agent->blockes[i];
	348	if(buf->obj.eobjId != eobjid)
	349	return false;
	350
	351	/* IuWFNgÌEOJðRs[ */
	352	memcpy(eoj, &buf->obj.inib.eojx1, sizeof(*eoj));
	353
	354	/* ®·ém[hÌIuWFNgIDðæ¾ */
	355	if(buf->obj.inib.enodid == 0)
	356	i = buf->obj.eobjId;
	357	else
	358	i = buf->obj.inib.enodid;
	359
	360	i -= (tmax_eobjid + 1);
	361	if ((i < 0)
	362	\|\| (i >= (sizeof(agent->blockes) / sizeof(agent->blockes[0])))){
	363	return false;
	364	}
	365
	366	/* m[hIDðæ¾ */
	367	buf = &agent->blockes[i];
	368	*enodid = buf->node.enodId;
	369
	370	return true;
	371	}
	372
	373	void ecn_agent_set_epc_to_prop_map(uint8_t epc, uint8_t *propMap)
	374	{
	375	int i, j;
	376	assert((epc & 0x80) != 0);
	377	i = epc & 0xF;
	378	j = (epc >> 4) - 8;
	379	propMap[i] \|= (1 << j);
	380	}
	381
	382	bool_t ecn_agent_contains_epc_in_prop_map(uint8_t epc, uint8_t *propMap)
	383	{
	384	int i, j;
	385	assert((epc & 0x80) != 0);
	386	i = epc & 0xF;
	387	j = (epc >> 4) - 8;
	388	return (propMap[i] & (1 << j)) != 0;
	389	}
	390
	391	void ecn_agent_init(void)
	392	{
	393	ecn_agent_queue_init(&g_ecn_agent.nodes);
	394	}
	395
	396	ecn_node_t ecn_agent_create_node(ecn_agent_t agent, T_EDATA *esv)
	397	{
	398	ecn_agent_buffer_t *result = NULL;
	399	ecn_node_t *node;
	400	uint8_t epc;
	401	uint8_t pdc;
	402	uint8_t edt[256];
	403	T_ENUM_EPC enm;
	404	ER ret;
	405	T_ECN_EOJ eoj, end;
	406
	407	// vpeBÊm©æ¾ÅA
	408	switch (esv->hdr.edata.esv) {
	409	case ESV_GET_RES:
	410	case ESV_GET_SNA:
	411	case ESV_INF:
	412	break;
	413	default:
	414	return NULL;
	415	}
	416
	417	// m[hvt@C¶Ìê
	418	eoj = &esv->hdr.edata.seoj;
	419	if ((eoj->eojx1 != EOJ_X1_PROFILE) \|\| (eoj->eojx2 != EOJ_X2_NODE_PROFILE)
	420	\|\| (eoj->eojx3 != 0x01))
	421	return NULL;
	422
	423	ret = ecn_itr_ini(&enm, esv);
	424	if(ret != E_OK){
	425	syslog(LOG_WARNING, "ecn_itr_ini");
	426	}
	427
	428	while (ecn_itr_nxt(&enm, &epc, &pdc, &edt) == E_OK) {
	429	switch (epc) {
	430	// CX^XXgÊmÌê
	431	case 0xD5:
	432	// ©m[hCX^XXgrÊmÌê
	433	case 0xD6:
	434	// TCYªíÈ¢ê
	435	if (pdc != (1 + edt[0] * sizeof(T_ECN_EOJ)))
	436	return NULL;
	437
	438	ret = get_buf(agent, &result);
	439	if(ret != E_OK){
	440	syslog(LOG_WARNING, "get_buf");
	441	return NULL;
	442	}
	443
	444	memset(result, 0, sizeof(*result));
	445	node = &result->node;
	446	node->enodId = ((T_ECN_FST_BLK *)esv)->hdr.sender;
	447	node->base.eobjId = tmax_eobjid + 1 + (((intptr_t)result - (intptr_t)agent->blockes) / sizeof(agent->blockes[0]));
	448	node->base.inib.enodid = 0;
	449	node->base.inib.eobjatr = EOBJ_SYNC_REMOTE_NODE;
	450	node->base.inib.exinf = (intptr_t)node;
	451	node->base.inib.eojx1 = eoj->eojx1;
	452	node->base.inib.eojx2 = eoj->eojx2;
	453	node->base.inib.eojx3 = eoj->eojx3;
	454	node->base.inib.eprp = &agent->eprpinib;
	455	node->base.inib.eprpcnt = 0;
	456	ecn_agent_set_epc_to_prop_map(0xD5, node->base.pmapGet);
	457	ecn_agent_set_epc_to_prop_map(0xD6, node->base.pmapGet);
	458	ecn_agent_set_epc_to_prop_map(0x9D, node->base.pmapGet);
	459	ecn_agent_set_epc_to_prop_map(0x9E, node->base.pmapGet);
	460	ecn_agent_set_epc_to_prop_map(0x9F, node->base.pmapGet);
	461	ecn_agent_queue_init(&node->devices);
	462	node->eobj.profile = &node->base.inib;
	463	node->eobj.eobjs = NULL;
	464	node->eobj.eobjcnt = pdc / 3;
	465	node->state = ecn_node_state_idle;
	466	node->timer = TMO_FEVR;
	467
	468	end = (T_ECN_EOJ *)&edt[pdc];
	469	for (eoj = (T_ECN_EOJ *)&edt[1]; eoj < end; eoj++) {
	470	ecn_device_t *device;
	471	ecn_agent_buffer_t *obj;
	472
	473	ret = get_buf(agent, &obj);
	474	if(ret != E_OK){
	475	syslog(LOG_WARNING, "get_buf");
	476	return NULL;
	477	}
	478
	479	memset(obj, 0, sizeof(*obj));
	480	device = &obj->device;
	481	device->node = node;
	482	device->base.eobjId = tmax_eobjid + 1 + (((intptr_t)obj - (intptr_t)agent->blockes) / sizeof(agent->blockes[0]));
	483	device->base.inib.eobjatr = EOBJ_DEVICE;
	484	device->base.inib.enodid = node->base.eobjId;
	485	device->base.inib.exinf = (intptr_t)device;
	486	device->base.inib.eojx1 = eoj->eojx1;
	487	device->base.inib.eojx2 = eoj->eojx2;
	488	device->base.inib.eojx3 = eoj->eojx3;
	489	device->base.inib.eprp = &agent->eprpinib;
	490	device->base.inib.eprpcnt = 0;
	491	ecn_agent_set_epc_to_prop_map(0x9D, device->base.pmapGet);
	492	ecn_agent_set_epc_to_prop_map(0x9E, device->base.pmapGet);
	493	ecn_agent_set_epc_to_prop_map(0x9F, device->base.pmapGet);
	494
	495	ecn_agent_queue_add(&node->devices, &obj->queue);
	496	}
	497	break;
	498	default:
	499	continue;
	500	}
	501	break;
	502	}
	503
	504	if (result == NULL)
	505	return NULL;
	506
	507	ecn_agent_queue_add(&agent->nodes, &result->queue);
	508
	509	return node;
	510	}
	511
	512	static ER ecn_agent_proc_get_device_list(ecn_agent_t *agent, ECN_FBS_ID req)
	513	{
	514	ER ret;
	515	ECN_FBS_ID res;
	516	ecn_inm_get_device_list_req_t msg;
	517	ECN_FBS_SSIZE_T len;
	518	ecn_agent_buffer_t pos, end = &agent->blockes[TNUM_AEOBJID];
	519	ecn_inm_get_device_item_t item;
	520	int i, j;
	521
	522	ret = _ecn_fbs_get_data(req, &msg, sizeof(msg), &len);
	523	if (ret != E_OK) {
	524	return ret;
	525	}
	526
	527	ret = _ecn_tsk_cre_res_fbs(req, ECN_INM_GET_DEVICE_LIST_RES, &res);
	528	if (ret != E_OK) {
	529	return ret;
	530	}
	531
	532	ret = _ecn_fbs_add_data_ex(res, &msg.requestid, sizeof(((ecn_inm_get_device_list_res_t *)0)->requestid));
	533	if (ret != E_OK) {
	534	_ecn_fbs_del(res);
	535	return ret;
	536	}
	537
	538	for (i = 0; i < tnum_enodid; i++) {
	539	const EOBJCB *enod = &eobjcb_table[i];
	540	for (j = 0; j < enod->eobjcnt; j++) {
	541	const EOBJINIB *eobj = enod->eobjs[i];
	542	item.eobjid = 1 + (((intptr_t)eobj - (intptr_t)eobjinib_table) / sizeof(EOBJINIB));
	543	item.enodid = eobj->enodid;
	544	item.state = true;
	545	item.eojx1 = eobj->eojx1;
	546	item.eojx2 = eobj->eojx2;
	547	item.eojx3 = eobj->eojx3;
	548	item.addrid = (i == 0) ? ENOD_LOCAL_ID : (ENOD_REMOTE_ID + i);
	549
	550	ret = _ecn_fbs_add_data_ex(res, &item, sizeof(item));
	551	if (ret != E_OK) {
	552	_ecn_fbs_del(res);
	553	return ret;
	554	}
	555	}
	556	}
	557
	558	for (pos = &agent->blockes[0]; pos < end; pos++){
	559	if(pos->obj.eobjId == 0)
	560	continue;
	561
	562	item.eobjid = pos->obj.eobjId;
	563	item.enodid = pos->obj.inib.enodid;
	564	item.state = (pos->obj.pmapFlag & (PMAP_FLAG_SET \| PMAP_FLAG_GET \| PMAP_FLAG_ANNO))
	565	== (PMAP_FLAG_SET \| PMAP_FLAG_GET \| PMAP_FLAG_ANNO);
	566	item.eojx1 = pos->obj.inib.eojx1;
	567	item.eojx2 = pos->obj.inib.eojx2;
	568	item.eojx3 = pos->obj.inib.eojx3;
	569
	570	if(pos->device.node != NULL)
	571	item.addrid = pos->device.node->enodId;
	572	else
	573	item.addrid = pos->node.enodId;
	574
	575	ret = _ecn_fbs_add_data_ex(res, &item, sizeof(item));
	576	if (ret != E_OK) {
	577	_ecn_fbs_del(res);
	578	return ret;
	579	}
	580	}
	581
	582	ret = psnd_dtq(res.ptr->hdr.target_mbxid, (intptr_t)res.ptr);
	583	if (ret != E_OK) {
	584	_ecn_fbs_del(res);
	585	return ret;
	586	}
	587
	588	return E_OK;
	589	}
	590
	591	static ER ecn_agent_proc_get_device_info(ecn_agent_t *agent, ECN_FBS_ID req)
	592	{
	593	ER ret;
	594	ECN_FBS_ID res;
	595	ecn_inm_get_device_info_req_t msg;
	596	ecn_inm_get_device_info_res_t rmsg;
	597	ECN_FBS_SSIZE_T len;
	598
	599	ret = _ecn_fbs_get_data(req, &msg, sizeof(msg), &len);
	600	if (ret != E_OK) {
	601	return ret;
	602	}
	603
	604	memset(&rmsg, 0, sizeof(rmsg));
	605
	606	if (msg.eobjid <= tmax_eobjid) {
	607	const EOBJINIB *eobj = &eobjinib_table[msg.eobjid - 1];
	608	int i;
	609
	610	rmsg.requestid = msg.requestid;
	611	rmsg.eobjid = msg.eobjid;
	612	for (i = 0; i < eobj->eprpcnt; i++) {
	613	uint8_t epc = eobj->eprp[i].eprpcd;
	614	ecn_agent_set_epc_to_prop_map(epc, rmsg.pmapSet);
	615	ecn_agent_set_epc_to_prop_map(epc, rmsg.pmapGet);
	616	ecn_agent_set_epc_to_prop_map(epc, rmsg.pmapAnno);
	617	}
	618	rmsg.eprpcnt = eobj->eprpcnt;
	619	}
	620	else {
	621	int eobjId;
	622	ecn_agent_buffer_t *pos;
	623
	624	eobjId = msg.eobjid - tmax_eobjid - 1;
	625	pos = &agent->blockes[eobjId];
	626
	627	rmsg.requestid = msg.requestid;
	628	rmsg.eobjid = pos->obj.eobjId;
	629	memcpy(rmsg.pmapSet, pos->obj.pmapSet, sizeof(rmsg.pmapSet));
	630	memcpy(rmsg.pmapGet, pos->obj.pmapGet, sizeof(rmsg.pmapGet));
	631	memcpy(rmsg.pmapAnno, pos->obj.pmapAnno, sizeof(rmsg.pmapAnno));
	632	rmsg.eprpcnt = pos->obj.eprpcnt;
	633	}
	634
	635	ret = _ecn_tsk_cre_res_fbs(req, ECN_INM_GET_DEVICE_INFO_RES, &res);
	636	if (ret != E_OK) {
	637	return ret;
	638	}
	639
	640	ret = _ecn_fbs_add_data_ex(res, &rmsg, sizeof(rmsg));
	641	if (ret != E_OK) {
	642	_ecn_fbs_del(res);
	643	return ret;
	644	}
	645
	646	ret = psnd_dtq(res.ptr->hdr.target_mbxid, (intptr_t)res.ptr);
	647	if (ret != E_OK) {
	648	_ecn_fbs_del(res);
	649	return ret;
	650	}
	651
	652	return E_OK;
	653	}
	654
	655	TMO ecn_agent_get_timer()
	656	{
	657	TMO timer = TMO_FEVR, temp;
	658	ecn_agent_t *agent = &g_ecn_agent;
	659	ecn_node_t *node;
	660	ecn_agent_queue_t *queue;
	661
	662	queue = &agent->nodes;
	663	for (;;) {
	664	queue = queue->p_next;
	665	#ifdef _DEBUG
	666	assert(queue->p_parent == &agent->nodes);
	667	#endif
	668	if(&agent->nodes == queue)
	669	break;
	670
	671	node = (ecn_node_t *)cast_obj(queue);
	672	temp = node->timer;
	673	if (temp != TMO_FEVR) {
	674	if ((timer == TMO_FEVR) \|\| (temp < timer)) {
	675	timer = temp;
	676	}
	677	}
	678	}
	679
	680	return timer;
	681	}
	682
	683	void ecn_agent_progress(TMO interval)
	684	{
	685	ecn_agent_t *agent = &g_ecn_agent;
	686	ecn_node_t *node;
	687	ecn_agent_queue_t *queue;
	688
	689	queue = &agent->nodes;
	690	for (;;) {
	691	queue = queue->p_next;
	692	#ifdef _DEBUG
	693	assert(queue->p_parent == &agent->nodes);
	694	#endif
	695	if(&agent->nodes == queue)
	696	break;
	697
	698	node = (ecn_node_t *)cast_obj(queue);
	699	if (node->timer == TMO_FEVR)
	700	continue;
	701
	702	node->timer -= interval;
	703	if (node->timer <= 0) {
	704	node->timer = 0;
	705	}
	706	}
	707	}
	708
	709	void ecn_agent_timeout()
	710	{
	711	ecn_agent_t *agent = &g_ecn_agent;
	712	ecn_node_t *node;
	713	ecn_agent_queue_t *queue;
	714
	715	queue = &agent->nodes;
	716	for (;;) {
	717	queue = queue->p_next;
	718	#ifdef _DEBUG
	719	assert(queue->p_parent == &agent->nodes);
	720	#endif
	721	if(&agent->nodes == queue)
	722	break;
	723
	724	node = (ecn_node_t *)cast_obj(queue);
	725	if (node->timer != 0)
	726	continue;
	727
	728	switch (node->state) {
	729	case ecn_node_state_start:
	730	ecn_node_timeout_on_start(node);
	731	break;
	732	case ecn_node_state_set_prpmap_wait:
	733	ecn_node_timeout_on_set_prpmap_wait(node);
	734	break;
	735	case ecn_node_state_get_prpmap_wait:
	736	ecn_node_timeout_on_get_prpmap_wait(node);
	737	break;
	738	case ecn_node_state_anno_prpmap_wait:
	739	ecn_node_timeout_on_anno_prpmap_wait(node);
	740	break;
	741	case ecn_node_state_fault:
	742	ecn_node_timeout_on_start(node);
	743	break;
	744	default:
	745	assert(0);
	746	}
	747	}
	748	}
	749
	750	bool_t ecn_agent_proc_int_msg(ECN_FBS_ID fbs, uint8_t cmd)
	751	{
	752	ecn_agent_t *agent = &g_ecn_agent;
	753
	754	switch(cmd)
	755	{
	756	case ECN_INM_GET_DEVICE_LIST_REQ:
	757	ecn_agent_proc_get_device_list(agent, fbs);
	758	break;
	759	case ECN_INM_GET_DEVICE_INFO_REQ:
	760	ecn_agent_proc_get_device_info(agent, fbs);
	761	break;
	762	default:
	763	return false;
	764	}
	765
	766	return true;
	767	}
	768
	769	void ecn_agent_proc_ecn_msg(const EOBJCB ppk_snod, const EOBJINIB ppk_sobj, T_EDATA *esv)
	770	{
	771	ecn_agent_t *agent = &g_ecn_agent;
	772	ecn_node_t *snod;
	773	ecn_obj_t *sobj;
	774
	775	/* ÃIÉè`³ê½M³Ìê */
	776	if ((ppk_snod != NULL) && (ppk_snod)->eobjs != NULL) {
	777	/* µÈ¢ */
	778	return;
	779	}
	780
	781	snod = ecn_agent_find_node2(*ppk_snod);
	782
	783	/* M³ðmçÈ©Á½ç */
	784	if (snod == NULL) {
	785	/* M³Ìm[hîñðVKÉì¬ */
	786	snod = ecn_agent_create_node(agent, esv);
	787	if (snod == NULL)
	788	return;
	789	}
	790
	791	sobj = ecn_agent_find_obj2(snod, *ppk_sobj);
	792
	793	/* m[hvt@CÌê */
	794	if ((esv->hdr.edata.seoj.eojx1 == EOJ_X1_PROFILE)
	795	&& (esv->hdr.edata.seoj.eojx2 == EOJ_X2_NODE_PROFILE)) {
	796	sobj = &snod->base;
	797	}
	798	/* @íIuWFNgÌê */
	799	else {
	800	sobj = ecn_agent_find_eobj(&snod->eobj, esv->hdr.edata.seoj);
	801	}
	802
	803	*ppk_snod = &snod->eobj;
	804	*ppk_sobj = &sobj->inib;
	805
	806	agent->current_node = snod;
	807	agent->msg_proced = false;
	808	}
	809
	810	void ecn_agent_proc_ecn_msg_end()
	811	{
	812	ecn_agent_t *agent = &g_ecn_agent;
	813	ecn_node_t *node = agent->current_node;
	814	ecn_obj_t *sobj;
	815
	816	if(node == NULL)
	817	return;
	818
	819	sobj = node->current;
	820	if(sobj == NULL)
	821	return;
	822
	823	if (agent->msg_proced) {
	824	switch (node->state) {
	825	case ecn_node_state_set_prpmap_wait:
	826	ecn_node_next_proc_on_set_prpmap_wait(node, sobj);
	827	break;
	828	case ecn_node_state_get_prpmap_wait:
	829	ecn_node_next_proc_on_get_prpmap_wait(node, sobj);
	830	break;
	831	case ecn_node_state_anno_prpmap_wait:
	832	ecn_node_next_proc_on_anno_prpmap_wait(node, sobj);
	833	break;
	834	}
	835	}
	836	}
	837
	838	static void ecn_node_send_set_prop_map(ecn_node_t *node)
	839	{
	840	T_EDATA *esv;
	841	ecn_obj_t *obj = node->current;
	842
	843	// vpeBlÇÝoµv
	844	ecn_esv_get(&esv, obj->eobjId, 0x9E);
	845	ecn_snd_esv(esv);
	846
	847	node->state = ecn_node_state_set_prpmap_wait;
	848	node->timer = (TMO)5000;
	849	}
	850
	851	static void ecn_node_send_get_prop_map(ecn_node_t *node)
	852	{
	853	T_EDATA *esv;
	854	ecn_obj_t *obj = node->current;
	855
	856	// vpeBlÇÝoµv
	857	ecn_esv_get(&esv, obj->eobjId, 0x9F);
	858	ecn_snd_esv(esv);
	859
	860	node->state = ecn_node_state_get_prpmap_wait;
	861	node->timer = (TMO)5000;
	862	}
	863
	864	static void ecn_node_send_anno_prop_map(ecn_node_t *node)
	865	{
	866	T_EDATA *esv;
	867	ecn_obj_t *obj = node->current;
	868
	869	// vpeBlÇÝoµv
	870	ecn_esv_get(&esv, obj->eobjId, 0x9D);
	871	ecn_snd_esv(esv);
	872
	873	node->state = ecn_node_state_anno_prpmap_wait;
	874	node->timer = (TMO)5000;
	875	}
	876
	877	static void ecn_node_next_obj(ecn_node_t *node)
	878	{
	879	ecn_obj_t *obj = node->current;
	880	ecn_agent_queue_t *queue;
	881	ecn_device_t *device;
	882
	883	/* objªwè³êÄ¢È¢ê */
	884	if(obj == NULL){
	885	/* ±Ìm[hðÔ· */
	886	node->current = &node->base;
	887	return;
	888	}
	889	/* m[hÌê */
	890	else if((obj->inib.eojx1 == EOJ_X1_PROFILE) && (obj->inib.eojx2 == EOJ_X2_NODE_PROFILE)){
	891	node = (ecn_node_t *)obj;
	892
	893	/* zºÌ@íðÔ· */
	894	queue = node->devices.p_next;
	895	device = (ecn_device_t *)cast_obj(queue);
	896	}
	897	/* @íÌê */
	898	else{
	899	/* Ì@íðÔ· */
	900	node = ((ecn_device_t *)obj)->node;
	901	queue = cast_queue(obj)->p_next;
	902	device = (ecn_device_t *)cast_obj(queue);
	903	}
	904
	905	/* »Ì@íªö¾Á½ê */
	906	if(&node->devices == queue){
	907	node->current = NULL;
	908	}
	909	else {
	910	node->current = &device->base;
	911	}
	912	}
	913
	914	static void ecn_node_timeout_on_start(ecn_node_t *node)
	915	{
	916	for (;;) {
	917	ecn_obj_t *obj = node->current;
	918	if (obj == NULL) {
	919	node->state = ecn_node_state_idle;
	920	node->timer = TMO_FEVR;
	921	return;
	922	}
	923
	924	if((obj->pmapFlag & PMAP_FLAG_SET) == 0){
	925	ecn_node_send_set_prop_map(node);
	926	break;
	927	}
	928	else if((obj->pmapFlag & PMAP_FLAG_GET) == 0){
	929	ecn_node_send_get_prop_map(node);
	930	break;
	931	}
	932	else if((obj->pmapFlag & PMAP_FLAG_ANNO) == 0){
	933	ecn_node_send_anno_prop_map(node);
	934	break;
	935	}
	936	else{
	937	ecn_node_next_obj(node);
	938	}
	939	}
	940	}
	941
	942	static void ecn_node_next_proc_on_set_prpmap_wait(ecn_node_t node, ecn_obj_t sobj)
	943	{
	944	if((sobj->pmapFlag & PMAP_FLAG_GET) == 0){
	945	ecn_node_send_get_prop_map(node);
	946	}
	947	else if((sobj->pmapFlag & PMAP_FLAG_ANNO) == 0){
	948	ecn_node_send_anno_prop_map(node);
	949	}
	950	else if((sobj->pmapFlag & PMAP_FLAG_SET) == 0){
	951	ecn_node_send_set_prop_map(node);
	952	}
	953	else{
	954	ecn_node_next_obj(node);
	955	ecn_node_timeout_on_start(node);
	956	}
	957	}
	958
	959	static void ecn_node_timeout_on_set_prpmap_wait(ecn_node_t *node)
	960	{
	961	ecn_obj_t *obj = node->current;
	962	if(obj == NULL){
	963	node->state = ecn_node_state_idle;
	964	node->timer = TMO_FEVR;
	965	return;
	966	}
	967
	968	node->retry++;
	969	if(node->retry < 3){
	970	ecn_node_next_proc_on_set_prpmap_wait(node, obj);
	971	}
	972	else{
	973	node->retry = 0;
	974	node->state = ecn_node_state_fault;
	975	node->timer = TMO_FEVR;
	976	}
	977	}
	978
	979	static void ecn_node_next_proc_on_get_prpmap_wait(ecn_node_t node, ecn_obj_t sobj)
	980	{
	981	if((sobj->pmapFlag & PMAP_FLAG_ANNO) == 0){
	982	ecn_node_send_anno_prop_map(node);
	983	}
	984	else if((sobj->pmapFlag & PMAP_FLAG_SET) == 0){
	985	ecn_node_send_set_prop_map(node);
	986	}
	987	else if((sobj->pmapFlag & PMAP_FLAG_GET) == 0){
	988	ecn_node_send_get_prop_map(node);
	989	}
	990	else{
	991	ecn_node_next_obj(node);
	992	ecn_node_timeout_on_start(node);
	993	}
	994	}
	995
	996	static void ecn_node_timeout_on_get_prpmap_wait(ecn_node_t *node)
	997	{
	998	ecn_obj_t *obj = node->current;
	999	if(obj == NULL){
	1000	node->state = ecn_node_state_idle;
	1001	node->timer = TMO_FEVR;
	1002	return;
	1003	}
	1004
	1005	ecn_node_next_proc_on_get_prpmap_wait(node, obj);
	1006	}
	1007
	1008	static void ecn_node_next_proc_on_anno_prpmap_wait(ecn_node_t node, ecn_obj_t sobj)
	1009	{
	1010	if((sobj->pmapFlag & PMAP_FLAG_SET) == 0){
	1011	ecn_node_send_set_prop_map(node);
	1012	}
	1013	else if((sobj->pmapFlag & PMAP_FLAG_GET) == 0){
	1014	ecn_node_send_get_prop_map(node);
	1015	}
	1016	else if((sobj->pmapFlag & PMAP_FLAG_ANNO) == 0){
	1017	ecn_node_send_anno_prop_map(node);
	1018	}
	1019	else{
	1020	ecn_node_next_obj(node);
	1021	ecn_node_timeout_on_start(node);
	1022	}
	1023	}
	1024
	1025	static void ecn_node_timeout_on_anno_prpmap_wait(ecn_node_t *node)
	1026	{
	1027	ecn_obj_t *obj = node->current;
	1028	if(obj == NULL){
	1029	node->state = ecn_node_state_idle;
	1030	node->timer = TMO_FEVR;
	1031	return;
	1032	}
	1033
	1034	ecn_node_next_proc_on_anno_prpmap_wait(node, obj);
	1035	}
	1036
	1037	const EPRPINIB ecn_agent_get_property(const EOBJINIB fp_obj, uint8_t fa_epc, const EPRPINIB *item)
	1038	{
	1039	ecn_obj_t *obj = cast_obj2(fp_obj);
	1040	bool_t has = false;
	1041
	1042	/* m[hÌêÍCX^XXgÊmÆ©m[hCX^XXgrÊmðK{Åó¯æé */
	1043	if ((fp_obj->enodid == 0) && ((fa_epc == 0xD5) \|\| (fa_epc == 0xD6)))
	1044	has = true;
	1045	else if (ecn_agent_contains_epc_in_prop_map(fa_epc, obj->pmapGet))
	1046	has = true;
	1047	else if (ecn_agent_contains_epc_in_prop_map(fa_epc, obj->pmapSet))
	1048	has = true;
	1049	else if (ecn_agent_contains_epc_in_prop_map(fa_epc, obj->pmapAnno))
	1050	has = true;
	1051
	1052	if(!has)
	1053	return NULL;
	1054
	1055	((EPRPINIB *)item)->eprpcd = fa_epc;
	1056	((EPRPINIB *)item)->exinf = (intptr_t)fp_obj;
	1057
	1058	return item;
	1059	}
	1060
	1061	int ecn_agent_eprpget(const EPRPINIB item, void dst, int size)
	1062	{
	1063	return 0;
	1064	}
	1065
	1066	int ecn_agent_eprpset(const EPRPINIB item, const void src, int size, bool_t *anno)
	1067	{
	1068	ecn_agent_t *agent = cast_agent(item);
	1069	ecn_node_t *node = agent->current_node;
	1070	const uint8_t edt = (const uint8_t )src;
	1071	ecn_obj_t sobj = cast_obj2((const EOBJINIB )item->exinf);
	1072	uint8_t eprpcnt;
	1073	int i;
	1074
	1075	switch (item->eprpcd) {
	1076	/* CX^XXgÊmÌê */
	1077	case 0xD5:
	1078	/* ©m[hCX^XXgrÊmÌê */
	1079	case 0xD6:
	1080	if ((node != NULL) && (node->state == ecn_node_state_idle)) {
	1081	ecn_agent_queue_t *devices = &node->devices;
	1082	ecn_agent_queue_t *queue = devices->p_next;
	1083	#ifdef _DEBUG
	1084	assert(queue->p_parent == devices);
	1085	#endif
	1086	for (; queue != devices; queue = queue->p_next) {
	1087	ecn_obj_t *obj = cast_obj(queue);
	1088	obj->pmapFlag = 0;
	1089	}
	1090	node->base.pmapFlag = 0;
	1091	node->state = ecn_node_state_start;
	1092	node->timer = (TMO)1000;
	1093	node->current = sobj;
	1094	}
	1095	break;
	1096	/* ÊmvpeB}bvÌê */
	1097	case 0x9D:
	1098	eprpcnt = edt[0];
	1099
	1100	if (eprpcnt < 16) {
	1101	/* TCY`FbN */
	1102	if (eprpcnt + 1 != size)
	1103	return 0;
	1104
	1105	for (i = 1; i < size; i++)
	1106	ecn_agent_set_epc_to_prop_map(edt[i], sobj->pmapAnno);
	1107	}
	1108	else {
	1109	/* TCY`FbN */
	1110	if (size != 17)
	1111	return 0;
	1112
	1113	memcpy(sobj->pmapAnno, &edt[1], 16);
	1114	}
	1115	sobj->eprpcnt = eprpcnt;
	1116	sobj->pmapFlag \|= PMAP_FLAG_ANNO;
	1117	break;
	1118	/* SETvpeB}bvÌê */
	1119	case 0x9E:
	1120	eprpcnt = edt[0];
	1121
	1122	if (eprpcnt < 16) {
	1123	/* TCY`FbN */
	1124	if (eprpcnt + 1 != size)
	1125	return 0;
	1126
	1127	for (i = 1; i < size; i++)
	1128	ecn_agent_set_epc_to_prop_map(edt[i], sobj->pmapSet);
	1129	}
	1130	else {
	1131	/* TCY`FbN */
	1132	if (size != 17)
	1133	return 0;
	1134
	1135	memcpy(sobj->pmapSet, &edt[1], 16);
	1136	}
	1137	sobj->eprpcnt = eprpcnt;
	1138	sobj->pmapFlag \|= PMAP_FLAG_SET;
	1139	break;
	1140	/* GETvpeB}bvÌê */
	1141	case 0x9F:
	1142	eprpcnt = edt[0];
	1143
	1144	if (eprpcnt < 16) {
	1145	/* TCY`FbN */
	1146	if (eprpcnt + 1 != size)
	1147	return 0;
	1148
	1149	for (i = 1; i < size; i++)
	1150	ecn_agent_set_epc_to_prop_map(edt[i], sobj->pmapGet);
	1151	}
	1152	else {
	1153	/* TCY`FbN */
	1154	if (size != 17)
	1155	return 0;
	1156
	1157	memcpy(sobj->pmapGet, &edt[1], 16);
	1158	}
	1159	sobj->eprpcnt = eprpcnt;
	1160	sobj->pmapFlag \|= PMAP_FLAG_GET;
	1161	break;
	1162	default:
	1163	g_forward_esv = true;
	1164	return 0;
	1165	}
	1166
	1167	agent->msg_proced = true;
	1168
	1169	return size;
	1170	}
	1171
	1172	ER ecn_agent_get_device_list(ID sender, int requestid, ECN_FBS_ID *pk_req)
	1173	{
	1174	ER a_ret;
	1175	ECN_FBS_ID req;
	1176
	1177	a_ret = _ecn_tsk_cre_req_fbs(sender, ECN_INM_GET_DEVICE_LIST_REQ, &req);
	1178	if (a_ret != E_OK) {
	1179	return a_ret;
	1180	}
	1181
	1182	a_ret = _ecn_fbs_add_data_ex(req, &requestid, sizeof(((ecn_inm_get_device_list_req_t *)0)->requestid));
	1183	if (a_ret != E_OK) {
	1184	_ecn_fbs_del(req);
	1185	return a_ret;
	1186	}
	1187
	1188	*pk_req = req;
	1189
	1190	return E_OK;
	1191	}
	1192
	1193	ER ecn_agent_get_device_info(ID sender, int requestid, ID eobjid, ECN_FBS_ID *pk_req)
	1194	{
	1195	ER a_ret;
	1196	ECN_FBS_ID req;
	1197
	1198	a_ret = _ecn_tsk_cre_req_fbs(sender, ECN_INM_GET_DEVICE_INFO_REQ, &req);
	1199	if (a_ret != E_OK) {
	1200	return a_ret;
	1201	}
	1202
	1203	a_ret = _ecn_fbs_add_data_ex(req, &requestid, sizeof(((ecn_inm_get_device_info_req_t *)0)->requestid));
	1204	if (a_ret != E_OK) {
	1205	_ecn_fbs_del(req);
	1206	return a_ret;
	1207	}
	1208
	1209	a_ret = _ecn_fbs_add_data_ex(req, &eobjid, sizeof(((ecn_inm_get_device_info_req_t *)0)->eobjid));
	1210	if (a_ret != E_OK) {
	1211	_ecn_fbs_del(req);
	1212	return a_ret;
	1213	}
	1214
	1215	*pk_req = req;
	1216
	1217	return E_OK;
	1218	}

Note: See TracBrowser for help on using the repository browser.

Download in other formats:

Original Format