source: asp3_tinet_ecnl_rx/trunk/asp3_dcre/tecsgen/tecs/rpc/tTDR_inline.h@ 337

Last change on this file since 337 was 337, checked in by coas-nagasima, 6 years ago

ASP3版ECNLを追加
  • Property svn:eol-style set to native
  • Property svn:mime-type set to text/x-chdr;charset=UTF-8
File size: 29.7 KB
Line 
1/*
2 * TECS Generator
3 * Generator for TOPPERS Embedded Component System
4 *
5 * Copyright (C) 2008-2013 by TOPPERS Project
6 *--
7 * 上記著作権者は，以下の(1)(4)の条件を満たす場合に限り，本ソフトウェ
8 * ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改
9 * 変・再配布（以下，利用と呼ぶ）することを無償で許諾する．
10 * (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作
11 * 権表示，この利用条件および下記の無保証規定が，そのままの形でソー
12 * スコード中に含まれていること．
13 * (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
14 * 用できる形で再配布する場合には，再配布に伴うドキュメント（利用
15 * 者マニュアルなど）に，上記の著作権表示，この利用条件および下記
16 * の無保証規定を掲載すること．
17 * (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
18 * 用できない形で再配布する場合には，次のいずれかの条件を満たすこ
19 * と．
20 * (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著
21 * 作権表示，この利用条件および下記の無保証規定を掲載すること．
22 * (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに
23 * 報告すること．
24 * (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
25 * 害からも，上記著作権者およびTOPPERSプロジェクトを免責すること．
26 * また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理
27 * 由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを
28 * 免責すること．
29 *
30 * 本ソフトウェアは，無保証で提供されているものである．上記著作権者お
31 * よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的
32 * に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ
33 * アの利用により直接的または間接的に生じたいかなる損害に関しても，そ
34 * の責任を負わない．
35 *
36 * $Id$
37 */
38
39/* #[<PREAMBLE>]#
40 * #[<...>]# から #[</...>]# で囲まれたコメントは編集しないでください
41 * tecsmerge によるマージに使用されます
42 *
43 * 属性アクセスマクロ #_CAAM_#
44 * tmo TMO VAR_tmo
45 *
46 * #[</PREAMBLE>]# */
47
48/*
49 * marhaler, unmarshaler が使用する STRLEN 関数を定義する
50 * marshaler, unmarshaler は必ず TDR は に結合されるため
51 */
52#include "rpc_string.h"
53
54/* 受け口関数 #_TEPF_# */
55/* #[<ENTRY_PORT>]# eTDR
56 * entry port: eTDR
57 * signature: sTDR
58 * context: task
59 * #[</ENTRY_PORT>]# */
60
61/* #[<ENTRY_FUNC>]# eTDR_reset
62 * name: eTDR_reset
63 * global_name: tTDR_eTDR_reset
64 * oneway: false
65 * #[</ENTRY_FUNC>]# */
66Inline ER
67eTDR_reset(CELLIDX idx)
68{
69 ER ercd = E_OK;
70 CELLCB *p_cellcb;
71 if (VALID_IDX(idx)) {
72 p_cellcb = GET_CELLCB(idx);
73 }
74 else {
75 return(E_ID);
76 }
77
78 syslog( LOG_INFO, "TDR: resetting channel" );
79 ercd = cChannel_reset();
80 return(ercd);
81}
82
83/* #[<ENTRY_FUNC>]# eTDR_sendSOP
84 * name: eTDR_sendSOP
85 * global_name: tTDR_eTDR_sendSOP
86 * oneway: false
87 * #[</ENTRY_FUNC>]# */
88Inline ER
89eTDR_sendSOP(CELLIDX idx, bool_t b_client )
90{
91 ER ercd = E_OK;
92 CELLCB *p_cellcb;
93 const uint16_t *p_sopMagic;
94 const uint16_t SOP_MAGIC1 = TDR_SOP_MAGIC1;
95 const uint16_t SOP_MAGIC2 = TDR_SOP_MAGIC2;
96 uint8_t val;
97
98 if (VALID_IDX(idx)) {
99 p_cellcb = GET_CELLCB(idx);
100 }
101 else {
102 return(E_ID);
103 }
104
105 /* ここに処理本体を記述します #_TEFB_# */
106#ifdef RPC_DEBUG
107 syslog(LOG_INFO, "eTDR_sendSOP(b_client=%d)", b_client);
108#endif
109 if( b_client )
110 p_sopMagic = &SOP_MAGIC1;
111 else
112 p_sopMagic = &SOP_MAGIC2;
113
114 /*
115 * SOP パケットの送信
116 * パケットシーケンスが多少崩れても回復できるように、バイト単位で送る
117 * 下位アドレス、上位アドレスの順に送る
118 */
119
120 val = (uint8_t)(*((uint8_t *)p_sopMagic));
121 ercd = eTDR_putUInt8( idx, val );
122 // syslog( LOG_INFO, "sendSOP:1 %02X", val );
123 if( ercd != E_OK )
124 return ercd;
125 val = (uint8_t)*(((uint8_t *)p_sopMagic)+1);
126 ercd = eTDR_putUInt8( idx, val );
127 // syslog( LOG_INFO, "sendSOP:2 %02X", val );
128
129 return ercd;
130}
131
132/* #[<ENTRY_FUNC>]# eTDR_receiveSOP
133 * name: eTDR_receiveSOP
134 * global_name: tTDR_eTDR_receiveSOP
135 * oneway: false
136 * #[</ENTRY_FUNC>]# */
137Inline ER
138eTDR_receiveSOP(CELLIDX idx, bool_t b_client)
139{
140 ER ercd = E_OK;
141 CELLCB *p_cellcb;
142 const uint16_t SOP_MAGIC1 = TDR_SOP_MAGIC1;
143 const uint16_t SOP_MAGIC2 = TDR_SOP_MAGIC2;
144 const uint16_t *p_sopMagic;
145 uint16_t magic;
146
147 if (VALID_IDX(idx)) {
148 p_cellcb = GET_CELLCB(idx);
149 }
150 else {
151 return(E_ID);
152 }
153
154 /* ここに処理本体を記述します #_TEFB_# */
155#ifdef RPC_DEBUG
156 syslog(LOG_INFO, "eTDR_receiveSOP(b_client=%d)", b_client);
157#endif
158
159 if( b_client )
160 p_sopMagic = &SOP_MAGIC2;
161 else
162 p_sopMagic = &SOP_MAGIC1;
163
164 if( (ercd=eTDR_getUInt8( idx, (uint8_t *)&magic )) != E_OK )
165 ;
166 else if( (uint8_t)magic != (uint8_t)(*((uint8_t *)p_sopMagic)) ){
167 // syslog( LOG_INFO, "receiveSOP:1 %02X expecting=%02X", (uint8_t)magic, (int8_t)(*((int8_t *)p_sopMagic)) );
168 ercd = E_MAGIC;
169 }
170 else if((ercd=eTDR_getUInt8( idx, ((uint8_t *)&magic)+1 )) != E_OK )
171 ;
172 else if( magic != *p_sopMagic){
173 // syslog( LOG_INFO, "receiveSOP:2 %04X expecting=%04X", magic, *p_sopMagic );
174 ercd = E_MAGIC;
175 }
176
177 if( ercd != E_OK )
178 syslog( LOG_INFO, "receiveSOP: ERCD=%d", ercd );
179
180 return ercd;
181}
182
183/* #[<ENTRY_FUNC>]# eTDR_sendEOP
184 * name: eTDR_sendEOP
185 * global_name: tTDR_eTDR_sendEOP
186 * oneway: false
187 * #[</ENTRY_FUNC>]# */
188Inline ER
189eTDR_sendEOP(CELLIDX idx, bool_t b_continue )
190{
191 ER ercd = E_OK;
192 CELLCB *p_cellcb;
193 uint16_t magic;
194 if (VALID_IDX(idx)) {
195 p_cellcb = GET_CELLCB(idx);
196 }
197 else {
198 return(E_ID);
199 }
200
201 /* ここに処理本体を記述します #_TEFB_# */
202#ifdef RPC_DEBUG
203 syslog(LOG_INFO, "eTDR_sendEOP(b_continue=%d)", b_continue);
204#endif
205
206 if( b_continue )
207 magic = TDR_EOP_MAGIC1;
208 else
209 magic = TDR_EOP_MAGIC2;
210
211 /* EOP magic の送信 */
212 if( (ercd = eTDR_putInt16( idx, (int16_t)magic )) != E_OK )
213 return ercd;
214
215 return cChannel_flush(VAR_tmo);
216}
217
218/* #[<ENTRY_FUNC>]# eTDR_receiveEOP
219 * name: eTDR_receiveEOP
220 * global_name: tTDR_eTDR_receiveEOP
221 * oneway: false
222 * #[</ENTRY_FUNC>]# */
223Inline ER
224eTDR_receiveEOP(CELLIDX idx, bool_t b_continue)
225{
226 ER ercd = E_OK, er2;
227 CELLCB *p_cellcb;
228 uint16_t magic;
229
230 if (VALID_IDX(idx)) {
231 p_cellcb = GET_CELLCB(idx);
232 }
233 else {
234 return(E_ID);
235 }
236
237 /* ここに処理本体を記述します #_TEFB_# */
238#ifdef RPC_DEBUG
239 syslog(LOG_INFO, "eTDR_receiveEOP(b_continue=%d)",b_continue);
240#endif
241/* mikan cChannel EOF get_* */
242/* mikan magic EOF */
243
244 if( (ercd=eTDR_getInt16( idx, (int16_t *)&magic )) == E_OK ){
245 if( (b_continue && magic == TDR_EOP_MAGIC1) || (!b_continue && magic == TDR_EOP_MAGIC2) ){
246 } else {
247 ercd = E_MAGIC;
248 }
249 }
250 er2 = cChannel_end_receive();
251 return ercd != E_OK ? ercd : er2;
252}
253
254/* #[<ENTRY_FUNC>]# eTDR_putInt8
255 * name: eTDR_putInt8
256 * global_name: tTDR_eTDR_putInt8
257 * oneway: false
258 * #[</ENTRY_FUNC>]# */
259Inline ER
260eTDR_putInt8(CELLIDX idx, int8_t in)
261{
262 CELLCB *p_cellcb;
263 if (VALID_IDX(idx)) {
264 p_cellcb = GET_CELLCB(idx);
265 }
266 else {
267 return(E_ID);
268 }
269
270 /* ここに処理本体を記述します #_TEFB_# */
271 return cChannel_send( (int8_t *)&in, (int16_t)sizeof( in ), VAR_tmo );
272}
273
274/* #[<ENTRY_FUNC>]# eTDR_putInt16
275 * name: eTDR_putInt16
276 * global_name: tTDR_eTDR_putInt16
277 * oneway: false
278 * #[</ENTRY_FUNC>]# */
279Inline ER
280eTDR_putInt16(CELLIDX idx, int16_t in)
281{
282 CELLCB *p_cellcb;
283 if (VALID_IDX(idx)) {
284 p_cellcb = GET_CELLCB(idx);
285 }
286 else {
287 return(E_ID);
288 }
289
290 /* ここに処理本体を記述します #_TEFB_# */
291 return cChannel_send( (int8_t *)&in, (int16_t)sizeof( in ), VAR_tmo );
292}
293
294/* #[<ENTRY_FUNC>]# eTDR_putInt32
295 * name: eTDR_putInt32
296 * global_name: tTDR_eTDR_putInt32
297 * oneway: false
298 * #[</ENTRY_FUNC>]# */
299Inline ER
300eTDR_putInt32(CELLIDX idx, int32_t in)
301{
302 CELLCB *p_cellcb;
303 if (VALID_IDX(idx)) {
304 p_cellcb = GET_CELLCB(idx);
305 }
306 else {
307 return(E_ID);
308 }
309
310 /* ここに処理本体を記述します #_TEFB_# */
311 return cChannel_send( (int8_t *)&in, (int16_t)sizeof( in ), VAR_tmo );
312}
313
314/* #[<ENTRY_FUNC>]# eTDR_putInt64
315 * name: eTDR_putInt64
316 * global_name: tTDR_eTDR_putInt64
317 * oneway: false
318 * #[</ENTRY_FUNC>]# */
319Inline ER
320eTDR_putInt64(CELLIDX idx, int64_t in)
321{
322 CELLCB *p_cellcb;
323 if (VALID_IDX(idx)) {
324 p_cellcb = GET_CELLCB(idx);
325 }
326 else {
327 return(E_ID);
328 }
329
330 /* ここに処理本体を記述します #_TEFB_# */
331 return cChannel_send( (int8_t *)&in, (int16_t)sizeof( in ), VAR_tmo );
332}
333
334/* #[<ENTRY_FUNC>]# eTDR_putInt128
335 * name: eTDR_putInt128
336 * global_name: tTDR_eTDR_putInt128
337 * oneway: false
338 * #[</ENTRY_FUNC>]# */
339Inline ER
340eTDR_putInt128(CELLIDX idx, int128_t in)
341{
342 CELLCB *p_cellcb;
343 if (VALID_IDX(idx)) {
344 p_cellcb = GET_CELLCB(idx);
345 }
346 else {
347 return(E_ID);
348 }
349
350 /* ここに処理本体を記述します #_TEFB_# */
351 return cChannel_send( (int8_t *)&in, (int16_t)sizeof( in ), VAR_tmo );
352}
353
354/* #[<ENTRY_FUNC>]# eTDR_getInt8
355 * name: eTDR_getInt8
356 * global_name: tTDR_eTDR_getInt8
357 * oneway: false
358 * #[</ENTRY_FUNC>]# */
359Inline ER
360eTDR_getInt8(CELLIDX idx, int8_t* out)
361{
362 ER_UINT er_sz;
363 CELLCB *p_cellcb;
364 if (VALID_IDX(idx)) {
365 p_cellcb = GET_CELLCB(idx);
366 }
367 else {
368 return(E_ID);
369 }
370
371 /* ここに処理本体を記述します #_TEFB_# */
372 er_sz = cChannel_receive( (int8_t *)out, (int16_t)sizeof( *out ), VAR_tmo );
373 return er_sz < 0 ? er_sz : ( er_sz == sizeof( *out ) ? E_OK : E_BOVR );
374}
375
376/* #[<ENTRY_FUNC>]# eTDR_getInt16
377 * name: eTDR_getInt16
378 * global_name: tTDR_eTDR_getInt16
379 * oneway: false
380 * #[</ENTRY_FUNC>]# */
381Inline ER
382eTDR_getInt16(CELLIDX idx, int16_t* out)
383{
384 ER_UINT er_sz;
385 CELLCB *p_cellcb;
386 if (VALID_IDX(idx)) {
387 p_cellcb = GET_CELLCB(idx);
388 }
389 else {
390 return(E_ID);
391 }
392
393 /* ここに処理本体を記述します #_TEFB_# */
394 er_sz = cChannel_receive( (int8_t *)out, (int16_t)sizeof( *out ), VAR_tmo );
395 return er_sz < 0 ? er_sz : ( er_sz == sizeof( *out ) ? E_OK : E_BOVR );
396}
397
398/* #[<ENTRY_FUNC>]# eTDR_getInt32
399 * name: eTDR_getInt32
400 * global_name: tTDR_eTDR_getInt32
401 * oneway: false
402 * #[</ENTRY_FUNC>]# */
403Inline ER
404eTDR_getInt32(CELLIDX idx, int32_t* out)
405{
406 ER_UINT er_sz;
407 CELLCB *p_cellcb;
408 if (VALID_IDX(idx)) {
409 p_cellcb = GET_CELLCB(idx);
410 }
411 else {
412 return(E_ID);
413 }
414
415 /* ここに処理本体を記述します #_TEFB_# */
416 er_sz = cChannel_receive( (int8_t *)out, (int16_t)sizeof( *out ), VAR_tmo );
417 return er_sz < 0 ? er_sz : ( er_sz == sizeof( *out ) ? E_OK : E_BOVR );
418}
419
420/* #[<ENTRY_FUNC>]# eTDR_getInt64
421 * name: eTDR_getInt64
422 * global_name: tTDR_eTDR_getInt64
423 * oneway: false
424 * #[</ENTRY_FUNC>]# */
425Inline ER
426eTDR_getInt64(CELLIDX idx, int64_t* out)
427{
428 ER_UINT er_sz;
429 CELLCB *p_cellcb;
430 if (VALID_IDX(idx)) {
431 p_cellcb = GET_CELLCB(idx);
432 }
433 else {
434 return(E_ID);
435 }
436
437 /* ここに処理本体を記述します #_TEFB_# */
438 er_sz = cChannel_receive( (int8_t *)out, (int16_t)sizeof( *out ), VAR_tmo );
439 return er_sz < 0 ? er_sz : ( er_sz == sizeof( *out ) ? E_OK : E_BOVR );
440}
441
442/* #[<ENTRY_FUNC>]# eTDR_getInt128
443 * name: eTDR_getInt128
444 * global_name: tTDR_eTDR_getInt128
445 * oneway: false
446 * #[</ENTRY_FUNC>]# */
447Inline ER
448eTDR_getInt128(CELLIDX idx, int128_t* out)
449{
450 ER_UINT er_sz;
451 CELLCB *p_cellcb;
452 if (VALID_IDX(idx)) {
453 p_cellcb = GET_CELLCB(idx);
454 }
455 else {
456 return(E_ID);
457 }
458
459 /* ここに処理本体を記述します #_TEFB_# */
460 er_sz = cChannel_receive( (int8_t *)out, (int16_t)sizeof( *out ), VAR_tmo );
461 return er_sz < 0 ? er_sz : ( er_sz == sizeof( *out ) ? E_OK : E_BOVR );
462}
463
464/* #[<ENTRY_FUNC>]# eTDR_putUInt8
465 * name: eTDR_putUInt8
466 * global_name: tTDR_eTDR_putUInt8
467 * oneway: false
468 * #[</ENTRY_FUNC>]# */
469Inline ER
470eTDR_putUInt8(CELLIDX idx, uint8_t in)
471{
472 CELLCB *p_cellcb;
473 if (VALID_IDX(idx)) {
474 p_cellcb = GET_CELLCB(idx);
475 }
476 else {
477 return(E_ID);
478 } /* end if VALID_IDX(idx) */
479
480 /* ここに処理本体を記述します #_TEFB_# */
481 return cChannel_send( (int8_t *)&in, (int16_t)sizeof( in ), VAR_tmo );
482}
483
484/* #[<ENTRY_FUNC>]# eTDR_putUInt16
485 * name: eTDR_putUInt16
486 * global_name: tTDR_eTDR_putUInt16
487 * oneway: false
488 * #[</ENTRY_FUNC>]# */
489Inline ER
490eTDR_putUInt16(CELLIDX idx, uint16_t in)
491{
492 CELLCB *p_cellcb;
493 if (VALID_IDX(idx)) {
494 p_cellcb = GET_CELLCB(idx);
495 }
496 else {
497 return(E_ID);
498 } /* end if VALID_IDX(idx) */
499
500 /* ここに処理本体を記述します #_TEFB_# */
501 return cChannel_send( (int8_t *)&in, (int16_t)sizeof( in ), VAR_tmo );
502}
503
504/* #[<ENTRY_FUNC>]# eTDR_putUInt32
505 * name: eTDR_putUInt32
506 * global_name: tTDR_eTDR_putUInt32
507 * oneway: false
508 * #[</ENTRY_FUNC>]# */
509Inline ER
510eTDR_putUInt32(CELLIDX idx, uint32_t in)
511{
512 CELLCB *p_cellcb;
513 if (VALID_IDX(idx)) {
514 p_cellcb = GET_CELLCB(idx);
515 }
516 else {
517 return(E_ID);
518 } /* end if VALID_IDX(idx) */
519
520 /* ここに処理本体を記述します #_TEFB_# */
521 return cChannel_send( (int8_t *)&in, (int16_t)sizeof( in ), VAR_tmo );
522}
523
524/* #[<ENTRY_FUNC>]# eTDR_putUInt64
525 * name: eTDR_putUInt64
526 * global_name: tTDR_eTDR_putUInt64
527 * oneway: false
528 * #[</ENTRY_FUNC>]# */
529Inline ER
530eTDR_putUInt64(CELLIDX idx, uint64_t in)
531{
532 CELLCB *p_cellcb;
533 if (VALID_IDX(idx)) {
534 p_cellcb = GET_CELLCB(idx);
535 }
536 else {
537 return(E_ID);
538 } /* end if VALID_IDX(idx) */
539
540 /* ここに処理本体を記述します #_TEFB_# */
541 return cChannel_send( (int8_t *)&in, (int16_t)sizeof( in ), VAR_tmo );
542}
543
544/* #[<ENTRY_FUNC>]# eTDR_putUInt128
545 * name: eTDR_putUInt128
546 * global_name: tTDR_eTDR_putUInt128
547 * oneway: false
548 * #[</ENTRY_FUNC>]# */
549Inline ER
550eTDR_putUInt128(CELLIDX idx, uint128_t in)
551{
552 CELLCB *p_cellcb;
553 if (VALID_IDX(idx)) {
554 p_cellcb = GET_CELLCB(idx);
555 }
556 else {
557 return(E_ID);
558 } /* end if VALID_IDX(idx) */
559
560 /* ここに処理本体を記述します #_TEFB_# */
561 return cChannel_send( (int8_t *)&in, (int16_t)sizeof( in ), VAR_tmo );
562}
563
564/* #[<ENTRY_FUNC>]# eTDR_getUInt8
565 * name: eTDR_getUInt8
566 * global_name: tTDR_eTDR_getUInt8
567 * oneway: false
568 * #[</ENTRY_FUNC>]# */
569Inline ER
570eTDR_getUInt8(CELLIDX idx, uint8_t* out)
571{
572 ER_UINT er_sz;
573 CELLCB *p_cellcb;
574 if (VALID_IDX(idx)) {
575 p_cellcb = GET_CELLCB(idx);
576 }
577 else {
578 return(E_ID);
579 } /* end if VALID_IDX(idx) */
580
581 /* ここに処理本体を記述します #_TEFB_# */
582 er_sz = cChannel_receive( (int8_t *)out, (int16_t)sizeof( *out ), VAR_tmo );
583 return er_sz < 0 ? er_sz : ( er_sz == sizeof( *out ) ? E_OK : E_BOVR );
584}
585
586/* #[<ENTRY_FUNC>]# eTDR_getUInt16
587 * name: eTDR_getUInt16
588 * global_name: tTDR_eTDR_getUInt16
589 * oneway: false
590 * #[</ENTRY_FUNC>]# */
591Inline ER
592eTDR_getUInt16(CELLIDX idx, uint16_t* out)
593{
594 ER_UINT er_sz;
595 CELLCB *p_cellcb;
596 if (VALID_IDX(idx)) {
597 p_cellcb = GET_CELLCB(idx);
598 }
599 else {
600 return(E_ID);
601 } /* end if VALID_IDX(idx) */
602
603 /* ここに処理本体を記述します #_TEFB_# */
604 er_sz = cChannel_receive( (int8_t *)out, (int16_t)sizeof( *out ), VAR_tmo );
605 return er_sz < 0 ? er_sz : ( er_sz == sizeof( *out ) ? E_OK : E_BOVR );
606}
607
608/* #[<ENTRY_FUNC>]# eTDR_getUInt32
609 * name: eTDR_getUInt32
610 * global_name: tTDR_eTDR_getUInt32
611 * oneway: false
612 * #[</ENTRY_FUNC>]# */
613Inline ER
614eTDR_getUInt32(CELLIDX idx, uint32_t* out)
615{
616 ER_UINT er_sz;
617 CELLCB *p_cellcb;
618 if (VALID_IDX(idx)) {
619 p_cellcb = GET_CELLCB(idx);
620 }
621 else {
622 return(E_ID);
623 } /* end if VALID_IDX(idx) */
624
625 /* ここに処理本体を記述します #_TEFB_# */
626 er_sz = cChannel_receive( (int8_t *)out, (int16_t)sizeof( *out ), VAR_tmo );
627 return er_sz < 0 ? er_sz : ( er_sz == sizeof( *out ) ? E_OK : E_BOVR );
628}
629
630/* #[<ENTRY_FUNC>]# eTDR_getUInt64
631 * name: eTDR_getUInt64
632 * global_name: tTDR_eTDR_getUInt64
633 * oneway: false
634 * #[</ENTRY_FUNC>]# */
635Inline ER
636eTDR_getUInt64(CELLIDX idx, uint64_t* out)
637{
638 ER_UINT er_sz;
639 CELLCB *p_cellcb;
640 if (VALID_IDX(idx)) {
641 p_cellcb = GET_CELLCB(idx);
642 }
643 else {
644 return(E_ID);
645 } /* end if VALID_IDX(idx) */
646
647 /* ここに処理本体を記述します #_TEFB_# */
648 er_sz = cChannel_receive( (int8_t *)out, (int16_t)sizeof( *out ), VAR_tmo );
649 return er_sz < 0 ? er_sz : ( er_sz == sizeof( *out ) ? E_OK : E_BOVR );
650}
651
652/* #[<ENTRY_FUNC>]# eTDR_getUInt128
653 * name: eTDR_getUInt128
654 * global_name: tTDR_eTDR_getUInt128
655 * oneway: false
656 * #[</ENTRY_FUNC>]# */
657Inline ER
658eTDR_getUInt128(CELLIDX idx, uint128_t* out)
659{
660 ER_UINT er_sz;
661 CELLCB *p_cellcb;
662 if (VALID_IDX(idx)) {
663 p_cellcb = GET_CELLCB(idx);
664 }
665 else {
666 return(E_ID);
667 } /* end if VALID_IDX(idx) */
668
669 /* ここに処理本体を記述します #_TEFB_# */
670 er_sz = cChannel_receive( (int8_t *)out, (int16_t)sizeof( *out ), VAR_tmo );
671 return er_sz < 0 ? er_sz : ( er_sz == sizeof( *out ) ? E_OK : E_BOVR );
672}
673
674/* #[<ENTRY_FUNC>]# eTDR_putBool
675 * name: eTDR_putBool
676 * global_name: tNBOTDR_eTDR_putBool
677 * oneway: false
678 * #[</ENTRY_FUNC>]# */
679Inline ER
680eTDR_putBool(CELLIDX idx, bool_t in)
681{
682 ER ercd = E_OK;
683 CELLCB *p_cellcb;
684 if (VALID_IDX(idx)) {
685 p_cellcb = GET_CELLCB(idx);
686 }
687 else {
688 return(E_ID);
689 } /* end if VALID_IDX(idx) */
690
691 /* ここに処理本体を記述します #_TEFB_# */
692 eTDR_putUInt8(idx, (uint8_t)(in != 0) );
693
694 return(ercd);
695}
696
697/* #[<ENTRY_FUNC>]# eTDR_getBool
698 * name: eTDR_getBool
699 * global_name: tNBOTDR_eTDR_getBool
700 * oneway: false
701 * #[</ENTRY_FUNC>]# */
702Inline ER
703eTDR_getBool(CELLIDX idx, bool_t* out)
704{
705 ER ercd = E_OK;
706 CELLCB *p_cellcb;
707 uint8_t val;
708 if (VALID_IDX(idx)) {
709 p_cellcb = GET_CELLCB(idx);
710 }
711 else {
712 return(E_ID);
713 } /* end if VALID_IDX(idx) */
714
715 /* ここに処理本体を記述します #_TEFB_# */
716 ercd = eTDR_getUInt8(idx, &val );
717 if( ercd != E_OK )
718 return ercd;
719 *out = (val != 0);
720
721 return(ercd);
722}
723
724/* #[<ENTRY_FUNC>]# eTDR_putFloat32
725 * name: eTDR_putFloat32
726 * global_name: tTDR_eTDR_putFloat32
727 * oneway: false
728 * #[</ENTRY_FUNC>]# */
729Inline ER
730eTDR_putFloat32(CELLIDX idx, float32_t in)
731{
732 CELLCB *p_cellcb;
733 if (VALID_IDX(idx)) {
734 p_cellcb = GET_CELLCB(idx);
735 }
736 else {
737 return(E_ID);
738 }
739
740 /* ここに処理本体を記述します #_TEFB_# */
741 return cChannel_send( (int8_t *)&in, (int16_t)sizeof( in ), VAR_tmo );
742}
743
744/* #[<ENTRY_FUNC>]# eTDR_putDouble64
745 * name: eTDR_putDouble64
746 * global_name: tTDR_eTDR_putDouble64
747 * oneway: false
748 * #[</ENTRY_FUNC>]# */
749Inline ER
750eTDR_putDouble64(CELLIDX idx, double64_t in)
751{
752 CELLCB *p_cellcb;
753 if (VALID_IDX(idx)) {
754 p_cellcb = GET_CELLCB(idx);
755 }
756 else {
757 return(E_ID);
758 }
759
760 /* ここに処理本体を記述します #_TEFB_# */
761 return cChannel_send( (int8_t *)&in, (int16_t)sizeof( in ), VAR_tmo );
762}
763
764/* #[<ENTRY_FUNC>]# eTDR_getFloat32
765 * name: eTDR_getFloat32
766 * global_name: tTDR_eTDR_getFloat32
767 * oneway: false
768 * #[</ENTRY_FUNC>]# */
769Inline ER
770eTDR_getFloat32(CELLIDX idx, float32_t* out)
771{
772 ER_UINT er_sz = E_OK;
773 CELLCB *p_cellcb;
774 if (VALID_IDX(idx)) {
775 p_cellcb = GET_CELLCB(idx);
776 }
777 else {
778 return(E_ID);
779 }
780
781 /* ここに処理本体を記述します #_TEFB_# */
782 er_sz = cChannel_receive( (int8_t *)out, (int16_t)sizeof( *out ), VAR_tmo );
783 return er_sz < 0 ? er_sz : ( er_sz == sizeof( *out ) ? E_OK : E_BOVR );
784}
785
786/* #[<ENTRY_FUNC>]# eTDR_getDouble64
787 * name: eTDR_getDouble64
788 * global_name: tTDR_eTDR_getDouble64
789 * oneway: false
790 * #[</ENTRY_FUNC>]# */
791Inline ER
792eTDR_getDouble64(CELLIDX idx, double64_t* out)
793{
794 ER_UINT er_sz = E_OK;
795 CELLCB *p_cellcb;
796 if (VALID_IDX(idx)) {
797 p_cellcb = GET_CELLCB(idx);
798 }
799 else {
800 return(E_ID);
801 }
802
803 /* ここに処理本体を記述します #_TEFB_# */
804 er_sz = cChannel_receive( (int8_t *)out, (int16_t)sizeof( *out ), VAR_tmo );
805 return er_sz < 0 ? er_sz : ( er_sz == sizeof( *out ) ? E_OK : E_BOVR );
806}
807
808/* #[<ENTRY_FUNC>]# eTDR_putChar
809 * name: eTDR_putChar
810 * global_name: tTDR_eTDR_putChar
811 * oneway: false
812 * #[</ENTRY_FUNC>]# */
813Inline ER
814eTDR_putChar(CELLIDX idx, char_t in)
815{
816 CELLCB *p_cellcb;
817 if (VALID_IDX(idx)) {
818 p_cellcb = GET_CELLCB(idx);
819 }
820 else {
821 return(E_ID);
822 }
823
824 /* ここに処理本体を記述します #_TEFB_# */
825 return cChannel_send( (int8_t *)&in, (int16_t)sizeof( in ), VAR_tmo );
826}
827
828/* #[<ENTRY_FUNC>]# eTDR_getChar
829 * name: eTDR_getChar
830 * global_name: tTDR_eTDR_getChar
831 * oneway: false
832 * #[</ENTRY_FUNC>]# */
833Inline ER
834eTDR_getChar(CELLIDX idx, char_t* out)
835{
836 ER_UINT er_sz;
837 CELLCB *p_cellcb;
838 if (VALID_IDX(idx)) {
839 p_cellcb = GET_CELLCB(idx);
840 }
841 else {
842 return(E_ID);
843 }
844
845 /* ここに処理本体を記述します #_TEFB_# */
846 er_sz = cChannel_receive( (int8_t *)out, (int16_t)sizeof( *out ), VAR_tmo );
847 return er_sz < 0 ? er_sz : ( er_sz == sizeof( *out ) ? E_OK : E_BOVR );
848}
849
850/* #[<ENTRY_FUNC>]# eTDR_putSChar
851 * name: eTDR_putSChar
852 * global_name: tTDR_eTDR_putSChar
853 * oneway: false
854 * #[</ENTRY_FUNC>]# */
855Inline ER
856eTDR_putSChar(CELLIDX idx, signed char in)
857{
858 CELLCB *p_cellcb;
859 if (VALID_IDX(idx)) {
860 p_cellcb = GET_CELLCB(idx);
861 }
862 else {
863 return(E_ID);
864 } /* end if VALID_IDX(idx) */
865
866 /* ここに処理本体を記述します #_TEFB_# */
867 return cChannel_send( (int8_t *)&in, (int16_t)sizeof( in ), VAR_tmo );
868}
869
870/* #[<ENTRY_FUNC>]# eTDR_putShort
871 * name: eTDR_putShort
872 * global_name: tTDR_eTDR_putShort
873 * oneway: false
874 * #[</ENTRY_FUNC>]# */
875Inline ER
876eTDR_putShort(CELLIDX idx, short_t in)
877{
878 CELLCB *p_cellcb;
879 if (VALID_IDX(idx)) {
880 p_cellcb = GET_CELLCB(idx);
881 }
882 else {
883 return(E_ID);
884 }
885
886 /* ここに処理本体を記述します #_TEFB_# */
887 return cChannel_send( (int8_t *)&in, (int16_t)sizeof( in ), VAR_tmo );
888}
889
890/* #[<ENTRY_FUNC>]# eTDR_putInt
891 * name: eTDR_putInt
892 * global_name: tTDR_eTDR_putInt
893 * oneway: false
894 * #[</ENTRY_FUNC>]# */
895Inline ER
896eTDR_putInt(CELLIDX idx, int_t in)
897{
898 CELLCB *p_cellcb;
899 if (VALID_IDX(idx)) {
900 p_cellcb = GET_CELLCB(idx);
901 }
902 else {
903 return(E_ID);
904 }
905
906 /* ここに処理本体を記述します #_TEFB_# */
907 return cChannel_send( (int8_t *)&in, (int16_t)sizeof( in ), VAR_tmo );
908}
909
910/* #[<ENTRY_FUNC>]# eTDR_putLong
911 * name: eTDR_putLong
912 * global_name: tTDR_eTDR_putLong
913 * oneway: false
914 * #[</ENTRY_FUNC>]# */
915Inline ER
916eTDR_putLong(CELLIDX idx, long_t in)
917{
918 CELLCB *p_cellcb;
919 if (VALID_IDX(idx)) {
920 p_cellcb = GET_CELLCB(idx);
921 }
922 else {
923 return(E_ID);
924 }
925
926 /* ここに処理本体を記述します #_TEFB_# */
927 return cChannel_send( (int8_t *)&in, (int16_t)sizeof( in ), VAR_tmo );
928}
929
930/* #[<ENTRY_FUNC>]# eTDR_getSChar
931 * name: eTDR_getSChar
932 * global_name: tTDR_eTDR_getSChar
933 * oneway: false
934 * #[</ENTRY_FUNC>]# */
935Inline ER
936eTDR_getSChar(CELLIDX idx, signed char* out)
937{
938 ER_UINT er_sz;
939 CELLCB *p_cellcb;
940 if (VALID_IDX(idx)) {
941 p_cellcb = GET_CELLCB(idx);
942 }
943 else {
944 return(E_ID);
945 } /* end if VALID_IDX(idx) */
946
947 /* ここに処理本体を記述します #_TEFB_# */
948 er_sz = cChannel_receive( (int8_t *)out, (int16_t)sizeof( *out ), VAR_tmo );
949 return er_sz < 0 ? er_sz : ( er_sz == sizeof( *out ) ? E_OK : E_BOVR );
950}
951
952/* #[<ENTRY_FUNC>]# eTDR_getShort
953 * name: eTDR_getShort
954 * global_name: tTDR_eTDR_getShort
955 * oneway: false
956 * #[</ENTRY_FUNC>]# */
957Inline ER
958eTDR_getShort(CELLIDX idx, short* out)
959{
960 ER_UINT er_sz;
961 CELLCB *p_cellcb;
962 if (VALID_IDX(idx)) {
963 p_cellcb = GET_CELLCB(idx);
964 }
965 else {
966 return(E_ID);
967 }
968
969 /* ここに処理本体を記述します #_TEFB_# */
970 er_sz = cChannel_receive( (int8_t *)out, (int16_t)sizeof( *out ), VAR_tmo );
971 return er_sz < 0 ? er_sz : ( er_sz == sizeof( *out ) ? E_OK : E_BOVR );
972}
973
974/* #[<ENTRY_FUNC>]# eTDR_getInt
975 * name: eTDR_getInt
976 * global_name: tTDR_eTDR_getInt
977 * oneway: false
978 * #[</ENTRY_FUNC>]# */
979Inline ER
980eTDR_getInt(CELLIDX idx, int_t* out)
981{
982 ER_UINT er_sz;
983 CELLCB *p_cellcb;
984 if (VALID_IDX(idx)) {
985 p_cellcb = GET_CELLCB(idx);
986 }
987 else {
988 return(E_ID);
989 }
990
991 /* ここに処理本体を記述します #_TEFB_# */
992 er_sz = cChannel_receive( (int8_t *)out, (int16_t)sizeof( *out ), VAR_tmo );
993 return er_sz < 0 ? er_sz : ( er_sz == sizeof( *out ) ? E_OK : E_BOVR );
994}
995
996/* #[<ENTRY_FUNC>]# eTDR_getLong
997 * name: eTDR_getLong
998 * global_name: tTDR_eTDR_getLong
999 * oneway: false
1000 * #[</ENTRY_FUNC>]# */
1001Inline ER
1002eTDR_getLong(CELLIDX idx, long_t* out)
1003{
1004 ER_UINT er_sz;
1005 CELLCB *p_cellcb;
1006 if (VALID_IDX(idx)) {
1007 p_cellcb = GET_CELLCB(idx);
1008 }
1009 else {
1010 return(E_ID);
1011 }
1012
1013 /* ここに処理本体を記述します #_TEFB_# */
1014 er_sz = cChannel_receive( (int8_t *)out, (int16_t)sizeof( *out ), VAR_tmo );
1015 return er_sz < 0 ? er_sz : ( er_sz == sizeof( *out ) ? E_OK : E_BOVR );
1016}
1017
1018/* #[<ENTRY_FUNC>]# eTDR_putUChar
1019 * name: eTDR_putUChar
1020 * global_name: tTDR_eTDR_putUChar
1021 * oneway: false
1022 * #[</ENTRY_FUNC>]# */
1023Inline ER
1024eTDR_putUChar(CELLIDX idx, unsigned char in)
1025{
1026 CELLCB *p_cellcb;
1027 if (VALID_IDX(idx)) {
1028 p_cellcb = GET_CELLCB(idx);
1029 }
1030 else {
1031 return(E_ID);
1032 } /* end if VALID_IDX(idx) */
1033
1034 /* ここに処理本体を記述します #_TEFB_# */
1035 return cChannel_send( (int8_t *)&in, (int16_t)sizeof( in ), VAR_tmo );
1036}
1037
1038/* #[<ENTRY_FUNC>]# eTDR_putUShort
1039 * name: eTDR_putUShort
1040 * global_name: tTDR_eTDR_putUShort
1041 * oneway: false
1042 * #[</ENTRY_FUNC>]# */
1043Inline ER
1044eTDR_putUShort(CELLIDX idx, ushort_t in)
1045{
1046 CELLCB *p_cellcb;
1047 if (VALID_IDX(idx)) {
1048 p_cellcb = GET_CELLCB(idx);
1049 }
1050 else {
1051 return(E_ID);
1052 } /* end if VALID_IDX(idx) */
1053
1054 /* ここに処理本体を記述します #_TEFB_# */
1055 return cChannel_send( (int8_t *)&in, (int16_t)sizeof( in ), VAR_tmo );
1056}
1057
1058/* #[<ENTRY_FUNC>]# eTDR_putUInt
1059 * name: eTDR_putUInt
1060 * global_name: tTDR_eTDR_putUInt
1061 * oneway: false
1062 * #[</ENTRY_FUNC>]# */
1063Inline ER
1064eTDR_putUInt(CELLIDX idx, uint_t in)
1065{
1066 CELLCB *p_cellcb;
1067 if (VALID_IDX(idx)) {
1068 p_cellcb = GET_CELLCB(idx);
1069 }
1070 else {
1071 return(E_ID);
1072 } /* end if VALID_IDX(idx) */
1073
1074 /* ここに処理本体を記述します #_TEFB_# */
1075 return cChannel_send( (int8_t *)&in, (int16_t)sizeof( in ), VAR_tmo );
1076}
1077
1078/* #[<ENTRY_FUNC>]# eTDR_putULong
1079 * name: eTDR_putULong
1080 * global_name: tTDR_eTDR_putULong
1081 * oneway: false
1082 * #[</ENTRY_FUNC>]# */
1083Inline ER
1084eTDR_putULong(CELLIDX idx, ulong_t in)
1085{
1086 CELLCB *p_cellcb;
1087 if (VALID_IDX(idx)) {
1088 p_cellcb = GET_CELLCB(idx);
1089 }
1090 else {
1091 return(E_ID);
1092 } /* end if VALID_IDX(idx) */
1093
1094 /* ここに処理本体を記述します #_TEFB_# */
1095 return cChannel_send( (int8_t *)&in, (int16_t)sizeof( in ), VAR_tmo );
1096}
1097
1098/* #[<ENTRY_FUNC>]# eTDR_getUChar
1099 * name: eTDR_getUChar
1100 * global_name: tTDR_eTDR_getUChar
1101 * oneway: false
1102 * #[</ENTRY_FUNC>]# */
1103Inline ER
1104eTDR_getUChar(CELLIDX idx, unsigned char* out)
1105{
1106 ER_UINT er_sz;
1107 CELLCB *p_cellcb;
1108 if (VALID_IDX(idx)) {
1109 p_cellcb = GET_CELLCB(idx);
1110 }
1111 else {
1112 return(E_ID);
1113 } /* end if VALID_IDX(idx) */
1114
1115 /* ここに処理本体を記述します #_TEFB_# */
1116 er_sz = cChannel_receive( (int8_t *)out, (int16_t)sizeof( *out ), VAR_tmo );
1117 return er_sz < 0 ? er_sz : ( er_sz == sizeof( *out ) ? E_OK : E_BOVR );
1118}
1119
1120/* #[<ENTRY_FUNC>]# eTDR_getUShort
1121 * name: eTDR_getUShort
1122 * global_name: tTDR_eTDR_getUShort
1123 * oneway: false
1124 * #[</ENTRY_FUNC>]# */
1125Inline ER
1126eTDR_getUShort(CELLIDX idx, unsigned short* out)
1127{
1128 ER_UINT er_sz;
1129 CELLCB *p_cellcb;
1130 if (VALID_IDX(idx)) {
1131 p_cellcb = GET_CELLCB(idx);
1132 }
1133 else {
1134 return(E_ID);
1135 } /* end if VALID_IDX(idx) */
1136
1137 /* ここに処理本体を記述します #_TEFB_# */
1138 er_sz = cChannel_receive( (int8_t *)out, (int16_t)sizeof( *out ), VAR_tmo );
1139 return er_sz < 0 ? er_sz : ( er_sz == sizeof( *out ) ? E_OK : E_BOVR );
1140}
1141
1142/* #[<ENTRY_FUNC>]# eTDR_getUInt
1143 * name: eTDR_getUInt
1144 * global_name: tTDR_eTDR_getUInt
1145 * oneway: false
1146 * #[</ENTRY_FUNC>]# */
1147Inline ER
1148eTDR_getUInt(CELLIDX idx, uint_t* out)
1149{
1150 ER_UINT er_sz;
1151 CELLCB *p_cellcb;
1152 if (VALID_IDX(idx)) {
1153 p_cellcb = GET_CELLCB(idx);
1154 }
1155 else {
1156 return(E_ID);
1157 } /* end if VALID_IDX(idx) */
1158
1159 /* ここに処理本体を記述します #_TEFB_# */
1160 er_sz = cChannel_receive( (int8_t *)out, (int16_t)sizeof( *out ), VAR_tmo );
1161 return er_sz < 0 ? er_sz : ( er_sz == sizeof( *out ) ? E_OK : E_BOVR );
1162}
1163
1164/* #[<ENTRY_FUNC>]# eTDR_getULong
1165 * name: eTDR_getULong
1166 * global_name: tTDR_eTDR_getULong
1167 * oneway: false
1168 * #[</ENTRY_FUNC>]# */
1169Inline ER
1170eTDR_getULong(CELLIDX idx, ulong_t* out)
1171{
1172 ER_UINT er_sz;
1173 CELLCB *p_cellcb;
1174 if (VALID_IDX(idx)) {
1175 p_cellcb = GET_CELLCB(idx);
1176 }
1177 else {
1178 return(E_ID);
1179 } /* end if VALID_IDX(idx) */
1180
1181 /* ここに処理本体を記述します #_TEFB_# */
1182 er_sz = cChannel_receive( (int8_t *)out, (int16_t)sizeof( *out ), VAR_tmo );
1183 return er_sz < 0 ? er_sz : ( er_sz == sizeof( *out ) ? E_OK : E_BOVR );
1184}
1185
1186/* #[<ENTRY_FUNC>]# eTDR_putIntptr
1187 * name: eTDR_putIntptr
1188 * global_name: tTDR_eTDR_putIntptr
1189 * oneway: false
1190 * #[</ENTRY_FUNC>]# */
1191Inline ER
1192eTDR_putIntptr(CELLIDX idx, const intptr_t ptr)
1193{
1194 CELLCB *p_cellcb;
1195 if (VALID_IDX(idx)) {
1196 p_cellcb = GET_CELLCB(idx);
1197 }
1198 else {
1199 return(E_ID);
1200 }
1201
1202 /* ここに処理本体を記述します #_TEFB_# */
1203 return cChannel_send( (int8_t *)&ptr, (int16_t)sizeof( ptr ), VAR_tmo );
1204}
1205
1206/* #[<ENTRY_FUNC>]# eTDR_getIntptr
1207 * name: eTDR_getIntptr
1208 * global_name: tTDR_eTDR_getIntptr
1209 * oneway: false
1210 * #[</ENTRY_FUNC>]# */
1211Inline ER
1212eTDR_getIntptr(CELLIDX idx, intptr_t* ptr)
1213{
1214 ER_UINT er_sz;
1215 CELLCB *p_cellcb;
1216 if (VALID_IDX(idx)) {
1217 p_cellcb = GET_CELLCB(idx);
1218 }
1219 else {
1220 return(E_ID);
1221 }
1222
1223 /* ここに処理本体を記述します #_TEFB_# */
1224 er_sz = cChannel_receive( (int8_t *)ptr, (int16_t)sizeof( *ptr ), VAR_tmo );
1225 return er_sz < 0 ? er_sz : ( er_sz == sizeof( *ptr ) ? E_OK : E_BOVR );
1226}
1227
1228
Note: See TracBrowser for help on using the repository browser.