Context Navigation

← Previous Revision
Latest Revision
Next Revision →
Blame
Revision Log

source: UsbWattMeter/trunk/ecnl_lwip/echonet_agent.c@ 164

Last change on this file since 164 was 164, checked in by coas-nagasima, 8 years ago
TOPPERS/ECNLサンプルアプリ「USB充電器電力計」を追加
Property svn:eol-style set to `native` Property svn:keywords set to `Id` Property svn:mime-type set to `text/x-csrc`
File size: 26.6 KB

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

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

Download in other formats: