source: asp3_tinet_ecnl_arm/trunk/asp3_dcre/tecsgen/tecs/rpc/tTDR_inline.h@ 374

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

mbed関連を更新
シリアルドライバをmbedのHALを使うよう変更
ファイルディスクリプタの処理を更新
  • Property svn:eol-style set to native
  • Property svn:mime-type set to text/x-chdr;charset=UTF-8
File size: 32.0 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 (void)p_cellcb; // to avoid unused warning
78
79 syslog( LOG_INFO, "TDR: resetting channel" );
80 ercd = cChannel_reset();
81 return(ercd);
82}
83
84/* #[<ENTRY_FUNC>]# eTDR_sendSOP
85 * name: eTDR_sendSOP
86 * global_name: tTDR_eTDR_sendSOP
87 * oneway: false
88 * #[</ENTRY_FUNC>]# */
89Inline ER
90eTDR_sendSOP(CELLIDX idx, bool_t b_client )
91{
92 ER ercd = E_OK;
93 CELLCB *p_cellcb;
94 const uint16_t *p_sopMagic;
95 const uint16_t SOP_MAGIC1 = TDR_SOP_MAGIC1;
96 const uint16_t SOP_MAGIC2 = TDR_SOP_MAGIC2;
97 uint8_t val;
98
99 if (VALID_IDX(idx)) {
100 p_cellcb = GET_CELLCB(idx);
101 }
102 else {
103 return(E_ID);
104 }
105 (void)p_cellcb; // to avoid unused warning
106
107 /* ここに処理本体を記述します #_TEFB_# */
108#ifdef RPC_DEBUG
109 syslog(LOG_INFO, "eTDR_sendSOP(b_client=%d)", b_client);
110#endif
111 if( b_client )
112 p_sopMagic = &SOP_MAGIC1;
113 else
114 p_sopMagic = &SOP_MAGIC2;
115
116 /*
117 * SOP パケットの送信
118 * パケットシーケンスが多少崩れても回復できるように、バイト単位で送る
119 * 下位アドレス、上位アドレスの順に送る
120 */
121
122 val = (uint8_t)(*((uint8_t *)p_sopMagic));
123 ercd = eTDR_putUInt8( idx, val );
124 // syslog( LOG_INFO, "sendSOP:1 %02X", val );
125 if( ercd != E_OK )
126 return ercd;
127 val = (uint8_t)*(((uint8_t *)p_sopMagic)+1);
128 ercd = eTDR_putUInt8( idx, val );
129 // syslog( LOG_INFO, "sendSOP:2 %02X", val );
130
131 return ercd;
132}
133
134/* #[<ENTRY_FUNC>]# eTDR_receiveSOP
135 * name: eTDR_receiveSOP
136 * global_name: tTDR_eTDR_receiveSOP
137 * oneway: false
138 * #[</ENTRY_FUNC>]# */
139Inline ER
140eTDR_receiveSOP(CELLIDX idx, bool_t b_client)
141{
142 ER ercd = E_OK;
143 CELLCB *p_cellcb;
144 const uint16_t SOP_MAGIC1 = TDR_SOP_MAGIC1;
145 const uint16_t SOP_MAGIC2 = TDR_SOP_MAGIC2;
146 const uint16_t *p_sopMagic;
147 uint16_t magic;
148
149 if (VALID_IDX(idx)) {
150 p_cellcb = GET_CELLCB(idx);
151 }
152 else {
153 return(E_ID);
154 }
155 (void)p_cellcb; // to avoid unused warning
156
157 /* ここに処理本体を記述します #_TEFB_# */
158#ifdef RPC_DEBUG
159 syslog(LOG_INFO, "eTDR_receiveSOP(b_client=%d)", b_client);
160#endif
161
162 if( b_client )
163 p_sopMagic = &SOP_MAGIC2;
164 else
165 p_sopMagic = &SOP_MAGIC1;
166
167 if( (ercd=eTDR_getUInt8( idx, (uint8_t *)&magic )) != E_OK )
168 ;
169 else if( (uint8_t)magic != (uint8_t)(*((uint8_t *)p_sopMagic)) ){
170 // syslog( LOG_INFO, "receiveSOP:1 %02X expecting=%02X", (uint8_t)magic, (int8_t)(*((int8_t *)p_sopMagic)) );
171 ercd = E_MAGIC;
172 }
173 else if((ercd=eTDR_getUInt8( idx, ((uint8_t *)&magic)+1 )) != E_OK )
174 ;
175 else if( magic != *p_sopMagic){
176 // syslog( LOG_INFO, "receiveSOP:2 %04X expecting=%04X", magic, *p_sopMagic );
177 ercd = E_MAGIC;
178 }
179
180 if( ercd != E_OK )
181 syslog( LOG_INFO, "receiveSOP: ERCD=%d", ercd );
182
183 return ercd;
184}
185
186/* #[<ENTRY_FUNC>]# eTDR_sendEOP
187 * name: eTDR_sendEOP
188 * global_name: tTDR_eTDR_sendEOP
189 * oneway: false
190 * #[</ENTRY_FUNC>]# */
191Inline ER
192eTDR_sendEOP(CELLIDX idx, bool_t b_continue )
193{
194 ER ercd = E_OK;
195 CELLCB *p_cellcb;
196 uint16_t magic;
197 if (VALID_IDX(idx)) {
198 p_cellcb = GET_CELLCB(idx);
199 }
200 else {
201 return(E_ID);
202 }
203 (void)p_cellcb; // to avoid unused warning
204
205 /* ここに処理本体を記述します #_TEFB_# */
206#ifdef RPC_DEBUG
207 syslog(LOG_INFO, "eTDR_sendEOP(b_continue=%d)", b_continue);
208#endif
209
210 if( b_continue )
211 magic = TDR_EOP_MAGIC1;
212 else
213 magic = TDR_EOP_MAGIC2;
214
215 /* EOP magic の送信 */
216 if( (ercd = eTDR_putInt16( idx, (int16_t)magic )) != E_OK )
217 return ercd;
218
219 return cChannel_flush(VAR_tmo);
220}
221
222/* #[<ENTRY_FUNC>]# eTDR_receiveEOP
223 * name: eTDR_receiveEOP
224 * global_name: tTDR_eTDR_receiveEOP
225 * oneway: false
226 * #[</ENTRY_FUNC>]# */
227Inline ER
228eTDR_receiveEOP(CELLIDX idx, bool_t b_continue)
229{
230 ER ercd = E_OK, er2;
231 CELLCB *p_cellcb;
232 uint16_t magic;
233
234 if (VALID_IDX(idx)) {
235 p_cellcb = GET_CELLCB(idx);
236 }
237 else {
238 return(E_ID);
239 }
240 (void)p_cellcb; // to avoid unused warning
241
242 /* ここに処理本体を記述します #_TEFB_# */
243#ifdef RPC_DEBUG
244 syslog(LOG_INFO, "eTDR_receiveEOP(b_continue=%d)",b_continue);
245#endif
246/* mikan cChannel EOF get_* */
247/* mikan magic EOF */
248
249 if( (ercd=eTDR_getInt16( idx, (int16_t *)&magic )) == E_OK ){
250 if( (b_continue && magic == TDR_EOP_MAGIC1) || (!b_continue && magic == TDR_EOP_MAGIC2) ){
251 } else {
252 ercd = E_MAGIC;
253 }
254 }
255 er2 = cChannel_end_receive();
256 return ercd != E_OK ? ercd : er2;
257}
258
259/* #[<ENTRY_FUNC>]# eTDR_putInt8
260 * name: eTDR_putInt8
261 * global_name: tTDR_eTDR_putInt8
262 * oneway: false
263 * #[</ENTRY_FUNC>]# */
264Inline ER
265eTDR_putInt8(CELLIDX idx, int8_t in)
266{
267 CELLCB *p_cellcb;
268 if (VALID_IDX(idx)) {
269 p_cellcb = GET_CELLCB(idx);
270 }
271 else {
272 return(E_ID);
273 }
274 (void)p_cellcb; // to avoid unused warning
275
276 /* ここに処理本体を記述します #_TEFB_# */
277 return cChannel_send( (int8_t *)&in, (int16_t)sizeof( in ), VAR_tmo );
278}
279
280/* #[<ENTRY_FUNC>]# eTDR_putInt16
281 * name: eTDR_putInt16
282 * global_name: tTDR_eTDR_putInt16
283 * oneway: false
284 * #[</ENTRY_FUNC>]# */
285Inline ER
286eTDR_putInt16(CELLIDX idx, int16_t in)
287{
288 CELLCB *p_cellcb;
289 if (VALID_IDX(idx)) {
290 p_cellcb = GET_CELLCB(idx);
291 }
292 else {
293 return(E_ID);
294 }
295 (void)p_cellcb; // to avoid unused warning
296
297 /* ここに処理本体を記述します #_TEFB_# */
298 return cChannel_send( (int8_t *)&in, (int16_t)sizeof( in ), VAR_tmo );
299}
300
301/* #[<ENTRY_FUNC>]# eTDR_putInt32
302 * name: eTDR_putInt32
303 * global_name: tTDR_eTDR_putInt32
304 * oneway: false
305 * #[</ENTRY_FUNC>]# */
306Inline ER
307eTDR_putInt32(CELLIDX idx, int32_t in)
308{
309 CELLCB *p_cellcb;
310 if (VALID_IDX(idx)) {
311 p_cellcb = GET_CELLCB(idx);
312 }
313 else {
314 return(E_ID);
315 }
316 (void)p_cellcb; // to avoid unused warning
317
318 /* ここに処理本体を記述します #_TEFB_# */
319 return cChannel_send( (int8_t *)&in, (int16_t)sizeof( in ), VAR_tmo );
320}
321
322/* #[<ENTRY_FUNC>]# eTDR_putInt64
323 * name: eTDR_putInt64
324 * global_name: tTDR_eTDR_putInt64
325 * oneway: false
326 * #[</ENTRY_FUNC>]# */
327Inline ER
328eTDR_putInt64(CELLIDX idx, int64_t in)
329{
330 CELLCB *p_cellcb;
331 if (VALID_IDX(idx)) {
332 p_cellcb = GET_CELLCB(idx);
333 }
334 else {
335 return(E_ID);
336 }
337 (void)p_cellcb; // to avoid unused warning
338
339 /* ここに処理本体を記述します #_TEFB_# */
340 return cChannel_send( (int8_t *)&in, (int16_t)sizeof( in ), VAR_tmo );
341}
342
343/* #[<ENTRY_FUNC>]# eTDR_putInt128
344 * name: eTDR_putInt128
345 * global_name: tTDR_eTDR_putInt128
346 * oneway: false
347 * #[</ENTRY_FUNC>]# */
348Inline ER
349eTDR_putInt128(CELLIDX idx, int128_t in)
350{
351 CELLCB *p_cellcb;
352 if (VALID_IDX(idx)) {
353 p_cellcb = GET_CELLCB(idx);
354 }
355 else {
356 return(E_ID);
357 }
358 (void)p_cellcb; // to avoid unused warning
359
360 /* ここに処理本体を記述します #_TEFB_# */
361 return cChannel_send( (int8_t *)&in, (int16_t)sizeof( in ), VAR_tmo );
362}
363
364/* #[<ENTRY_FUNC>]# eTDR_getInt8
365 * name: eTDR_getInt8
366 * global_name: tTDR_eTDR_getInt8
367 * oneway: false
368 * #[</ENTRY_FUNC>]# */
369Inline ER
370eTDR_getInt8(CELLIDX idx, int8_t* out)
371{
372 ER_UINT er_sz;
373 CELLCB *p_cellcb;
374 if (VALID_IDX(idx)) {
375 p_cellcb = GET_CELLCB(idx);
376 }
377 else {
378 return(E_ID);
379 }
380 (void)p_cellcb; // to avoid unused warning
381
382 /* ここに処理本体を記述します #_TEFB_# */
383 er_sz = cChannel_receive( (int8_t *)out, (int16_t)sizeof( *out ), VAR_tmo );
384 return er_sz < 0 ? er_sz : ( er_sz == sizeof( *out ) ? E_OK : E_BOVR );
385}
386
387/* #[<ENTRY_FUNC>]# eTDR_getInt16
388 * name: eTDR_getInt16
389 * global_name: tTDR_eTDR_getInt16
390 * oneway: false
391 * #[</ENTRY_FUNC>]# */
392Inline ER
393eTDR_getInt16(CELLIDX idx, int16_t* out)
394{
395 ER_UINT er_sz;
396 CELLCB *p_cellcb;
397 if (VALID_IDX(idx)) {
398 p_cellcb = GET_CELLCB(idx);
399 }
400 else {
401 return(E_ID);
402 }
403 (void)p_cellcb; // to avoid unused warning
404
405 /* ここに処理本体を記述します #_TEFB_# */
406 er_sz = cChannel_receive( (int8_t *)out, (int16_t)sizeof( *out ), VAR_tmo );
407 return er_sz < 0 ? er_sz : ( er_sz == sizeof( *out ) ? E_OK : E_BOVR );
408}
409
410/* #[<ENTRY_FUNC>]# eTDR_getInt32
411 * name: eTDR_getInt32
412 * global_name: tTDR_eTDR_getInt32
413 * oneway: false
414 * #[</ENTRY_FUNC>]# */
415Inline ER
416eTDR_getInt32(CELLIDX idx, int32_t* out)
417{
418 ER_UINT er_sz;
419 CELLCB *p_cellcb;
420 if (VALID_IDX(idx)) {
421 p_cellcb = GET_CELLCB(idx);
422 }
423 else {
424 return(E_ID);
425 }
426 (void)p_cellcb; // to avoid unused warning
427
428 /* ここに処理本体を記述します #_TEFB_# */
429 er_sz = cChannel_receive( (int8_t *)out, (int16_t)sizeof( *out ), VAR_tmo );
430 return er_sz < 0 ? er_sz : ( er_sz == sizeof( *out ) ? E_OK : E_BOVR );
431}
432
433/* #[<ENTRY_FUNC>]# eTDR_getInt64
434 * name: eTDR_getInt64
435 * global_name: tTDR_eTDR_getInt64
436 * oneway: false
437 * #[</ENTRY_FUNC>]# */
438Inline ER
439eTDR_getInt64(CELLIDX idx, int64_t* out)
440{
441 ER_UINT er_sz;
442 CELLCB *p_cellcb;
443 if (VALID_IDX(idx)) {
444 p_cellcb = GET_CELLCB(idx);
445 }
446 else {
447 return(E_ID);
448 }
449 (void)p_cellcb; // to avoid unused warning
450
451 /* ここに処理本体を記述します #_TEFB_# */
452 er_sz = cChannel_receive( (int8_t *)out, (int16_t)sizeof( *out ), VAR_tmo );
453 return er_sz < 0 ? er_sz : ( er_sz == sizeof( *out ) ? E_OK : E_BOVR );
454}
455
456/* #[<ENTRY_FUNC>]# eTDR_getInt128
457 * name: eTDR_getInt128
458 * global_name: tTDR_eTDR_getInt128
459 * oneway: false
460 * #[</ENTRY_FUNC>]# */
461Inline ER
462eTDR_getInt128(CELLIDX idx, int128_t* out)
463{
464 ER_UINT er_sz;
465 CELLCB *p_cellcb;
466 if (VALID_IDX(idx)) {
467 p_cellcb = GET_CELLCB(idx);
468 }
469 else {
470 return(E_ID);
471 }
472 (void)p_cellcb; // to avoid unused warning
473
474 /* ここに処理本体を記述します #_TEFB_# */
475 er_sz = cChannel_receive( (int8_t *)out, (int16_t)sizeof( *out ), VAR_tmo );
476 return er_sz < 0 ? er_sz : ( er_sz == sizeof( *out ) ? E_OK : E_BOVR );
477}
478
479/* #[<ENTRY_FUNC>]# eTDR_putUInt8
480 * name: eTDR_putUInt8
481 * global_name: tTDR_eTDR_putUInt8
482 * oneway: false
483 * #[</ENTRY_FUNC>]# */
484Inline ER
485eTDR_putUInt8(CELLIDX idx, uint8_t in)
486{
487 CELLCB *p_cellcb;
488 if (VALID_IDX(idx)) {
489 p_cellcb = GET_CELLCB(idx);
490 }
491 else {
492 return(E_ID);
493 } /* end if VALID_IDX(idx) */
494 (void)p_cellcb; // to avoid unused warning
495
496 /* ここに処理本体を記述します #_TEFB_# */
497 return cChannel_send( (int8_t *)&in, (int16_t)sizeof( in ), VAR_tmo );
498}
499
500/* #[<ENTRY_FUNC>]# eTDR_putUInt16
501 * name: eTDR_putUInt16
502 * global_name: tTDR_eTDR_putUInt16
503 * oneway: false
504 * #[</ENTRY_FUNC>]# */
505Inline ER
506eTDR_putUInt16(CELLIDX idx, uint16_t in)
507{
508 CELLCB *p_cellcb;
509 if (VALID_IDX(idx)) {
510 p_cellcb = GET_CELLCB(idx);
511 }
512 else {
513 return(E_ID);
514 } /* end if VALID_IDX(idx) */
515 (void)p_cellcb; // to avoid unused warning
516
517 /* ここに処理本体を記述します #_TEFB_# */
518 return cChannel_send( (int8_t *)&in, (int16_t)sizeof( in ), VAR_tmo );
519}
520
521/* #[<ENTRY_FUNC>]# eTDR_putUInt32
522 * name: eTDR_putUInt32
523 * global_name: tTDR_eTDR_putUInt32
524 * oneway: false
525 * #[</ENTRY_FUNC>]# */
526Inline ER
527eTDR_putUInt32(CELLIDX idx, uint32_t in)
528{
529 CELLCB *p_cellcb;
530 if (VALID_IDX(idx)) {
531 p_cellcb = GET_CELLCB(idx);
532 }
533 else {
534 return(E_ID);
535 } /* end if VALID_IDX(idx) */
536 (void)p_cellcb; // to avoid unused warning
537
538 /* ここに処理本体を記述します #_TEFB_# */
539 return cChannel_send( (int8_t *)&in, (int16_t)sizeof( in ), VAR_tmo );
540}
541
542/* #[<ENTRY_FUNC>]# eTDR_putUInt64
543 * name: eTDR_putUInt64
544 * global_name: tTDR_eTDR_putUInt64
545 * oneway: false
546 * #[</ENTRY_FUNC>]# */
547Inline ER
548eTDR_putUInt64(CELLIDX idx, uint64_t in)
549{
550 CELLCB *p_cellcb;
551 if (VALID_IDX(idx)) {
552 p_cellcb = GET_CELLCB(idx);
553 }
554 else {
555 return(E_ID);
556 } /* end if VALID_IDX(idx) */
557 (void)p_cellcb; // to avoid unused warning
558
559 /* ここに処理本体を記述します #_TEFB_# */
560 return cChannel_send( (int8_t *)&in, (int16_t)sizeof( in ), VAR_tmo );
561}
562
563/* #[<ENTRY_FUNC>]# eTDR_putUInt128
564 * name: eTDR_putUInt128
565 * global_name: tTDR_eTDR_putUInt128
566 * oneway: false
567 * #[</ENTRY_FUNC>]# */
568Inline ER
569eTDR_putUInt128(CELLIDX idx, uint128_t in)
570{
571 CELLCB *p_cellcb;
572 if (VALID_IDX(idx)) {
573 p_cellcb = GET_CELLCB(idx);
574 }
575 else {
576 return(E_ID);
577 } /* end if VALID_IDX(idx) */
578 (void)p_cellcb; // to avoid unused warning
579
580 /* ここに処理本体を記述します #_TEFB_# */
581 return cChannel_send( (int8_t *)&in, (int16_t)sizeof( in ), VAR_tmo );
582}
583
584/* #[<ENTRY_FUNC>]# eTDR_getUInt8
585 * name: eTDR_getUInt8
586 * global_name: tTDR_eTDR_getUInt8
587 * oneway: false
588 * #[</ENTRY_FUNC>]# */
589Inline ER
590eTDR_getUInt8(CELLIDX idx, uint8_t* out)
591{
592 ER_UINT er_sz;
593 CELLCB *p_cellcb;
594 if (VALID_IDX(idx)) {
595 p_cellcb = GET_CELLCB(idx);
596 }
597 else {
598 return(E_ID);
599 } /* end if VALID_IDX(idx) */
600 (void)p_cellcb; // to avoid unused warning
601
602 /* ここに処理本体を記述します #_TEFB_# */
603 er_sz = cChannel_receive( (int8_t *)out, (int16_t)sizeof( *out ), VAR_tmo );
604 return er_sz < 0 ? er_sz : ( er_sz == sizeof( *out ) ? E_OK : E_BOVR );
605}
606
607/* #[<ENTRY_FUNC>]# eTDR_getUInt16
608 * name: eTDR_getUInt16
609 * global_name: tTDR_eTDR_getUInt16
610 * oneway: false
611 * #[</ENTRY_FUNC>]# */
612Inline ER
613eTDR_getUInt16(CELLIDX idx, uint16_t* out)
614{
615 ER_UINT er_sz;
616 CELLCB *p_cellcb;
617 if (VALID_IDX(idx)) {
618 p_cellcb = GET_CELLCB(idx);
619 }
620 else {
621 return(E_ID);
622 } /* end if VALID_IDX(idx) */
623 (void)p_cellcb; // to avoid unused warning
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_getUInt32
631 * name: eTDR_getUInt32
632 * global_name: tTDR_eTDR_getUInt32
633 * oneway: false
634 * #[</ENTRY_FUNC>]# */
635Inline ER
636eTDR_getUInt32(CELLIDX idx, uint32_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 (void)p_cellcb; // to avoid unused warning
647
648 /* ここに処理本体を記述します #_TEFB_# */
649 er_sz = cChannel_receive( (int8_t *)out, (int16_t)sizeof( *out ), VAR_tmo );
650 return er_sz < 0 ? er_sz : ( er_sz == sizeof( *out ) ? E_OK : E_BOVR );
651}
652
653/* #[<ENTRY_FUNC>]# eTDR_getUInt64
654 * name: eTDR_getUInt64
655 * global_name: tTDR_eTDR_getUInt64
656 * oneway: false
657 * #[</ENTRY_FUNC>]# */
658Inline ER
659eTDR_getUInt64(CELLIDX idx, uint64_t* out)
660{
661 ER_UINT er_sz;
662 CELLCB *p_cellcb;
663 if (VALID_IDX(idx)) {
664 p_cellcb = GET_CELLCB(idx);
665 }
666 else {
667 return(E_ID);
668 } /* end if VALID_IDX(idx) */
669 (void)p_cellcb; // to avoid unused warning
670
671 /* ここに処理本体を記述します #_TEFB_# */
672 er_sz = cChannel_receive( (int8_t *)out, (int16_t)sizeof( *out ), VAR_tmo );
673 return er_sz < 0 ? er_sz : ( er_sz == sizeof( *out ) ? E_OK : E_BOVR );
674}
675
676/* #[<ENTRY_FUNC>]# eTDR_getUInt128
677 * name: eTDR_getUInt128
678 * global_name: tTDR_eTDR_getUInt128
679 * oneway: false
680 * #[</ENTRY_FUNC>]# */
681Inline ER
682eTDR_getUInt128(CELLIDX idx, uint128_t* out)
683{
684 ER_UINT er_sz;
685 CELLCB *p_cellcb;
686 if (VALID_IDX(idx)) {
687 p_cellcb = GET_CELLCB(idx);
688 }
689 else {
690 return(E_ID);
691 } /* end if VALID_IDX(idx) */
692 (void)p_cellcb; // to avoid unused warning
693
694 /* ここに処理本体を記述します #_TEFB_# */
695 er_sz = cChannel_receive( (int8_t *)out, (int16_t)sizeof( *out ), VAR_tmo );
696 return er_sz < 0 ? er_sz : ( er_sz == sizeof( *out ) ? E_OK : E_BOVR );
697}
698
699/* #[<ENTRY_FUNC>]# eTDR_putBool
700 * name: eTDR_putBool
701 * global_name: tNBOTDR_eTDR_putBool
702 * oneway: false
703 * #[</ENTRY_FUNC>]# */
704Inline ER
705eTDR_putBool(CELLIDX idx, bool_t in)
706{
707 ER ercd = E_OK;
708 CELLCB *p_cellcb;
709 if (VALID_IDX(idx)) {
710 p_cellcb = GET_CELLCB(idx);
711 }
712 else {
713 return(E_ID);
714 } /* end if VALID_IDX(idx) */
715 (void)p_cellcb; // to avoid unused warning
716
717 /* ここに処理本体を記述します #_TEFB_# */
718 eTDR_putUInt8(idx, (uint8_t)(in != 0) );
719
720 return(ercd);
721}
722
723/* #[<ENTRY_FUNC>]# eTDR_getBool
724 * name: eTDR_getBool
725 * global_name: tNBOTDR_eTDR_getBool
726 * oneway: false
727 * #[</ENTRY_FUNC>]# */
728Inline ER
729eTDR_getBool(CELLIDX idx, bool_t* out)
730{
731 ER ercd = E_OK;
732 CELLCB *p_cellcb;
733 uint8_t val = 0;
734 if (VALID_IDX(idx)) {
735 p_cellcb = GET_CELLCB(idx);
736 }
737 else {
738 return(E_ID);
739 } /* end if VALID_IDX(idx) */
740 (void)p_cellcb; // to avoid unused warning
741
742 /* ここに処理本体を記述します #_TEFB_# */
743 ercd = eTDR_getUInt8(idx, &val );
744 if( ercd != E_OK )
745 return ercd;
746 *out = (val != 0);
747
748 return(ercd);
749}
750
751/* #[<ENTRY_FUNC>]# eTDR_putFloat32
752 * name: eTDR_putFloat32
753 * global_name: tTDR_eTDR_putFloat32
754 * oneway: false
755 * #[</ENTRY_FUNC>]# */
756Inline ER
757eTDR_putFloat32(CELLIDX idx, float32_t in)
758{
759 CELLCB *p_cellcb;
760 if (VALID_IDX(idx)) {
761 p_cellcb = GET_CELLCB(idx);
762 }
763 else {
764 return(E_ID);
765 }
766 (void)p_cellcb; // to avoid unused warning
767
768 /* ここに処理本体を記述します #_TEFB_# */
769 return cChannel_send( (int8_t *)&in, (int16_t)sizeof( in ), VAR_tmo );
770}
771
772/* #[<ENTRY_FUNC>]# eTDR_putDouble64
773 * name: eTDR_putDouble64
774 * global_name: tTDR_eTDR_putDouble64
775 * oneway: false
776 * #[</ENTRY_FUNC>]# */
777Inline ER
778eTDR_putDouble64(CELLIDX idx, double64_t in)
779{
780 CELLCB *p_cellcb;
781 if (VALID_IDX(idx)) {
782 p_cellcb = GET_CELLCB(idx);
783 }
784 else {
785 return(E_ID);
786 }
787 (void)p_cellcb; // to avoid unused warning
788
789 /* ここに処理本体を記述します #_TEFB_# */
790 return cChannel_send( (int8_t *)&in, (int16_t)sizeof( in ), VAR_tmo );
791}
792
793/* #[<ENTRY_FUNC>]# eTDR_getFloat32
794 * name: eTDR_getFloat32
795 * global_name: tTDR_eTDR_getFloat32
796 * oneway: false
797 * #[</ENTRY_FUNC>]# */
798Inline ER
799eTDR_getFloat32(CELLIDX idx, float32_t* out)
800{
801 ER_UINT er_sz = E_OK;
802 CELLCB *p_cellcb;
803 if (VALID_IDX(idx)) {
804 p_cellcb = GET_CELLCB(idx);
805 }
806 else {
807 return(E_ID);
808 }
809 (void)p_cellcb; // to avoid unused warning
810
811 /* ここに処理本体を記述します #_TEFB_# */
812 er_sz = cChannel_receive( (int8_t *)out, (int16_t)sizeof( *out ), VAR_tmo );
813 return er_sz < 0 ? er_sz : ( er_sz == sizeof( *out ) ? E_OK : E_BOVR );
814}
815
816/* #[<ENTRY_FUNC>]# eTDR_getDouble64
817 * name: eTDR_getDouble64
818 * global_name: tTDR_eTDR_getDouble64
819 * oneway: false
820 * #[</ENTRY_FUNC>]# */
821Inline ER
822eTDR_getDouble64(CELLIDX idx, double64_t* out)
823{
824 ER_UINT er_sz = E_OK;
825 CELLCB *p_cellcb;
826 if (VALID_IDX(idx)) {
827 p_cellcb = GET_CELLCB(idx);
828 }
829 else {
830 return(E_ID);
831 }
832 (void)p_cellcb; // to avoid unused warning
833
834 /* ここに処理本体を記述します #_TEFB_# */
835 er_sz = cChannel_receive( (int8_t *)out, (int16_t)sizeof( *out ), VAR_tmo );
836 return er_sz < 0 ? er_sz : ( er_sz == sizeof( *out ) ? E_OK : E_BOVR );
837}
838
839/* #[<ENTRY_FUNC>]# eTDR_putChar
840 * name: eTDR_putChar
841 * global_name: tTDR_eTDR_putChar
842 * oneway: false
843 * #[</ENTRY_FUNC>]# */
844Inline ER
845eTDR_putChar(CELLIDX idx, char_t in)
846{
847 CELLCB *p_cellcb;
848 if (VALID_IDX(idx)) {
849 p_cellcb = GET_CELLCB(idx);
850 }
851 else {
852 return(E_ID);
853 }
854 (void)p_cellcb; // to avoid unused warning
855
856 /* ここに処理本体を記述します #_TEFB_# */
857 return cChannel_send( (int8_t *)&in, (int16_t)sizeof( in ), VAR_tmo );
858}
859
860/* #[<ENTRY_FUNC>]# eTDR_getChar
861 * name: eTDR_getChar
862 * global_name: tTDR_eTDR_getChar
863 * oneway: false
864 * #[</ENTRY_FUNC>]# */
865Inline ER
866eTDR_getChar(CELLIDX idx, char_t* out)
867{
868 ER_UINT er_sz;
869 CELLCB *p_cellcb;
870 if (VALID_IDX(idx)) {
871 p_cellcb = GET_CELLCB(idx);
872 }
873 else {
874 return(E_ID);
875 }
876
877 /* ここに処理本体を記述します #_TEFB_# */
878 er_sz = cChannel_receive( (int8_t *)out, (int16_t)sizeof( *out ), VAR_tmo );
879 return er_sz < 0 ? er_sz : ( er_sz == sizeof( *out ) ? E_OK : E_BOVR );
880}
881
882/* #[<ENTRY_FUNC>]# eTDR_putSChar
883 * name: eTDR_putSChar
884 * global_name: tTDR_eTDR_putSChar
885 * oneway: false
886 * #[</ENTRY_FUNC>]# */
887Inline ER
888eTDR_putSChar(CELLIDX idx, signed char in)
889{
890 CELLCB *p_cellcb;
891 if (VALID_IDX(idx)) {
892 p_cellcb = GET_CELLCB(idx);
893 }
894 else {
895 return(E_ID);
896 } /* end if VALID_IDX(idx) */
897 (void)p_cellcb; // to avoid unused warning
898
899 /* ここに処理本体を記述します #_TEFB_# */
900 return cChannel_send( (int8_t *)&in, (int16_t)sizeof( in ), VAR_tmo );
901}
902
903/* #[<ENTRY_FUNC>]# eTDR_putShort
904 * name: eTDR_putShort
905 * global_name: tTDR_eTDR_putShort
906 * oneway: false
907 * #[</ENTRY_FUNC>]# */
908Inline ER
909eTDR_putShort(CELLIDX idx, short_t in)
910{
911 CELLCB *p_cellcb;
912 if (VALID_IDX(idx)) {
913 p_cellcb = GET_CELLCB(idx);
914 }
915 else {
916 return(E_ID);
917 }
918 (void)p_cellcb; // to avoid unused warning
919
920 /* ここに処理本体を記述します #_TEFB_# */
921 return cChannel_send( (int8_t *)&in, (int16_t)sizeof( in ), VAR_tmo );
922}
923
924/* #[<ENTRY_FUNC>]# eTDR_putInt
925 * name: eTDR_putInt
926 * global_name: tTDR_eTDR_putInt
927 * oneway: false
928 * #[</ENTRY_FUNC>]# */
929Inline ER
930eTDR_putInt(CELLIDX idx, int_t in)
931{
932 CELLCB *p_cellcb;
933 if (VALID_IDX(idx)) {
934 p_cellcb = GET_CELLCB(idx);
935 }
936 else {
937 return(E_ID);
938 }
939 (void)p_cellcb; // to avoid unused warning
940
941 /* ここに処理本体を記述します #_TEFB_# */
942 return cChannel_send( (int8_t *)&in, (int16_t)sizeof( in ), VAR_tmo );
943}
944
945/* #[<ENTRY_FUNC>]# eTDR_putLong
946 * name: eTDR_putLong
947 * global_name: tTDR_eTDR_putLong
948 * oneway: false
949 * #[</ENTRY_FUNC>]# */
950Inline ER
951eTDR_putLong(CELLIDX idx, long_t in)
952{
953 CELLCB *p_cellcb;
954 if (VALID_IDX(idx)) {
955 p_cellcb = GET_CELLCB(idx);
956 }
957 else {
958 return(E_ID);
959 }
960 (void)p_cellcb; // to avoid unused warning
961
962 /* ここに処理本体を記述します #_TEFB_# */
963 return cChannel_send( (int8_t *)&in, (int16_t)sizeof( in ), VAR_tmo );
964}
965
966/* #[<ENTRY_FUNC>]# eTDR_getSChar
967 * name: eTDR_getSChar
968 * global_name: tTDR_eTDR_getSChar
969 * oneway: false
970 * #[</ENTRY_FUNC>]# */
971Inline ER
972eTDR_getSChar(CELLIDX idx, signed char* out)
973{
974 ER_UINT er_sz;
975 CELLCB *p_cellcb;
976 if (VALID_IDX(idx)) {
977 p_cellcb = GET_CELLCB(idx);
978 }
979 else {
980 return(E_ID);
981 } /* end if VALID_IDX(idx) */
982 (void)p_cellcb; // to avoid unused warning
983
984 /* ここに処理本体を記述します #_TEFB_# */
985 er_sz = cChannel_receive( (int8_t *)out, (int16_t)sizeof( *out ), VAR_tmo );
986 return er_sz < 0 ? er_sz : ( er_sz == sizeof( *out ) ? E_OK : E_BOVR );
987}
988
989/* #[<ENTRY_FUNC>]# eTDR_getShort
990 * name: eTDR_getShort
991 * global_name: tTDR_eTDR_getShort
992 * oneway: false
993 * #[</ENTRY_FUNC>]# */
994Inline ER
995eTDR_getShort(CELLIDX idx, short* out)
996{
997 ER_UINT er_sz;
998 CELLCB *p_cellcb;
999 if (VALID_IDX(idx)) {
1000 p_cellcb = GET_CELLCB(idx);
1001 }
1002 else {
1003 return(E_ID);
1004 }
1005 (void)p_cellcb; // to avoid unused warning
1006
1007 /* ここに処理本体を記述します #_TEFB_# */
1008 er_sz = cChannel_receive( (int8_t *)out, (int16_t)sizeof( *out ), VAR_tmo );
1009 return er_sz < 0 ? er_sz : ( er_sz == sizeof( *out ) ? E_OK : E_BOVR );
1010}
1011
1012/* #[<ENTRY_FUNC>]# eTDR_getInt
1013 * name: eTDR_getInt
1014 * global_name: tTDR_eTDR_getInt
1015 * oneway: false
1016 * #[</ENTRY_FUNC>]# */
1017Inline ER
1018eTDR_getInt(CELLIDX idx, int_t* out)
1019{
1020 ER_UINT er_sz;
1021 CELLCB *p_cellcb;
1022 if (VALID_IDX(idx)) {
1023 p_cellcb = GET_CELLCB(idx);
1024 }
1025 else {
1026 return(E_ID);
1027 }
1028 (void)p_cellcb; // to avoid unused warning
1029
1030 /* ここに処理本体を記述します #_TEFB_# */
1031 er_sz = cChannel_receive( (int8_t *)out, (int16_t)sizeof( *out ), VAR_tmo );
1032 return er_sz < 0 ? er_sz : ( er_sz == sizeof( *out ) ? E_OK : E_BOVR );
1033}
1034
1035/* #[<ENTRY_FUNC>]# eTDR_getLong
1036 * name: eTDR_getLong
1037 * global_name: tTDR_eTDR_getLong
1038 * oneway: false
1039 * #[</ENTRY_FUNC>]# */
1040Inline ER
1041eTDR_getLong(CELLIDX idx, long_t* out)
1042{
1043 ER_UINT er_sz;
1044 CELLCB *p_cellcb;
1045 if (VALID_IDX(idx)) {
1046 p_cellcb = GET_CELLCB(idx);
1047 }
1048 else {
1049 return(E_ID);
1050 }
1051 (void)p_cellcb; // to avoid unused warning
1052
1053 /* ここに処理本体を記述します #_TEFB_# */
1054 er_sz = cChannel_receive( (int8_t *)out, (int16_t)sizeof( *out ), VAR_tmo );
1055 return er_sz < 0 ? er_sz : ( er_sz == sizeof( *out ) ? E_OK : E_BOVR );
1056}
1057
1058/* #[<ENTRY_FUNC>]# eTDR_putUChar
1059 * name: eTDR_putUChar
1060 * global_name: tTDR_eTDR_putUChar
1061 * oneway: false
1062 * #[</ENTRY_FUNC>]# */
1063Inline ER
1064eTDR_putUChar(CELLIDX idx, unsigned char 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 (void)p_cellcb; // to avoid unused warning
1074
1075 /* ここに処理本体を記述します #_TEFB_# */
1076 return cChannel_send( (int8_t *)&in, (int16_t)sizeof( in ), VAR_tmo );
1077}
1078
1079/* #[<ENTRY_FUNC>]# eTDR_putUShort
1080 * name: eTDR_putUShort
1081 * global_name: tTDR_eTDR_putUShort
1082 * oneway: false
1083 * #[</ENTRY_FUNC>]# */
1084Inline ER
1085eTDR_putUShort(CELLIDX idx, ushort_t in)
1086{
1087 CELLCB *p_cellcb;
1088 if (VALID_IDX(idx)) {
1089 p_cellcb = GET_CELLCB(idx);
1090 }
1091 else {
1092 return(E_ID);
1093 } /* end if VALID_IDX(idx) */
1094 (void)p_cellcb; // to avoid unused warning
1095
1096 /* ここに処理本体を記述します #_TEFB_# */
1097 return cChannel_send( (int8_t *)&in, (int16_t)sizeof( in ), VAR_tmo );
1098}
1099
1100/* #[<ENTRY_FUNC>]# eTDR_putUInt
1101 * name: eTDR_putUInt
1102 * global_name: tTDR_eTDR_putUInt
1103 * oneway: false
1104 * #[</ENTRY_FUNC>]# */
1105Inline ER
1106eTDR_putUInt(CELLIDX idx, uint_t in)
1107{
1108 CELLCB *p_cellcb;
1109 if (VALID_IDX(idx)) {
1110 p_cellcb = GET_CELLCB(idx);
1111 }
1112 else {
1113 return(E_ID);
1114 } /* end if VALID_IDX(idx) */
1115 (void)p_cellcb; // to avoid unused warning
1116
1117 /* ここに処理本体を記述します #_TEFB_# */
1118 return cChannel_send( (int8_t *)&in, (int16_t)sizeof( in ), VAR_tmo );
1119}
1120
1121/* #[<ENTRY_FUNC>]# eTDR_putULong
1122 * name: eTDR_putULong
1123 * global_name: tTDR_eTDR_putULong
1124 * oneway: false
1125 * #[</ENTRY_FUNC>]# */
1126Inline ER
1127eTDR_putULong(CELLIDX idx, ulong_t in)
1128{
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 (void)p_cellcb; // to avoid unused warning
1137
1138 /* ここに処理本体を記述します #_TEFB_# */
1139 return cChannel_send( (int8_t *)&in, (int16_t)sizeof( in ), VAR_tmo );
1140}
1141
1142/* #[<ENTRY_FUNC>]# eTDR_getUChar
1143 * name: eTDR_getUChar
1144 * global_name: tTDR_eTDR_getUChar
1145 * oneway: false
1146 * #[</ENTRY_FUNC>]# */
1147Inline ER
1148eTDR_getUChar(CELLIDX idx, unsigned char* 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 (void)p_cellcb; // to avoid unused warning
1159
1160 /* ここに処理本体を記述します #_TEFB_# */
1161 er_sz = cChannel_receive( (int8_t *)out, (int16_t)sizeof( *out ), VAR_tmo );
1162 return er_sz < 0 ? er_sz : ( er_sz == sizeof( *out ) ? E_OK : E_BOVR );
1163}
1164
1165/* #[<ENTRY_FUNC>]# eTDR_getUShort
1166 * name: eTDR_getUShort
1167 * global_name: tTDR_eTDR_getUShort
1168 * oneway: false
1169 * #[</ENTRY_FUNC>]# */
1170Inline ER
1171eTDR_getUShort(CELLIDX idx, unsigned short* out)
1172{
1173 ER_UINT er_sz;
1174 CELLCB *p_cellcb;
1175 if (VALID_IDX(idx)) {
1176 p_cellcb = GET_CELLCB(idx);
1177 }
1178 else {
1179 return(E_ID);
1180 } /* end if VALID_IDX(idx) */
1181 (void)p_cellcb; // to avoid unused warning
1182
1183 /* ここに処理本体を記述します #_TEFB_# */
1184 er_sz = cChannel_receive( (int8_t *)out, (int16_t)sizeof( *out ), VAR_tmo );
1185 return er_sz < 0 ? er_sz : ( er_sz == sizeof( *out ) ? E_OK : E_BOVR );
1186}
1187
1188/* #[<ENTRY_FUNC>]# eTDR_getUInt
1189 * name: eTDR_getUInt
1190 * global_name: tTDR_eTDR_getUInt
1191 * oneway: false
1192 * #[</ENTRY_FUNC>]# */
1193Inline ER
1194eTDR_getUInt(CELLIDX idx, uint_t* out)
1195{
1196 ER_UINT er_sz;
1197 CELLCB *p_cellcb;
1198 if (VALID_IDX(idx)) {
1199 p_cellcb = GET_CELLCB(idx);
1200 }
1201 else {
1202 return(E_ID);
1203 } /* end if VALID_IDX(idx) */
1204 (void)p_cellcb; // to avoid unused warning
1205
1206 /* ここに処理本体を記述します #_TEFB_# */
1207 er_sz = cChannel_receive( (int8_t *)out, (int16_t)sizeof( *out ), VAR_tmo );
1208 return er_sz < 0 ? er_sz : ( er_sz == sizeof( *out ) ? E_OK : E_BOVR );
1209}
1210
1211/* #[<ENTRY_FUNC>]# eTDR_getULong
1212 * name: eTDR_getULong
1213 * global_name: tTDR_eTDR_getULong
1214 * oneway: false
1215 * #[</ENTRY_FUNC>]# */
1216Inline ER
1217eTDR_getULong(CELLIDX idx, ulong_t* out)
1218{
1219 ER_UINT er_sz;
1220 CELLCB *p_cellcb;
1221 if (VALID_IDX(idx)) {
1222 p_cellcb = GET_CELLCB(idx);
1223 }
1224 else {
1225 return(E_ID);
1226 } /* end if VALID_IDX(idx) */
1227 (void)p_cellcb; // to avoid unused warning
1228
1229 /* ここに処理本体を記述します #_TEFB_# */
1230 er_sz = cChannel_receive( (int8_t *)out, (int16_t)sizeof( *out ), VAR_tmo );
1231 return er_sz < 0 ? er_sz : ( er_sz == sizeof( *out ) ? E_OK : E_BOVR );
1232}
1233
1234/* #[<ENTRY_FUNC>]# eTDR_putIntptr
1235 * name: eTDR_putIntptr
1236 * global_name: tTDR_eTDR_putIntptr
1237 * oneway: false
1238 * #[</ENTRY_FUNC>]# */
1239Inline ER
1240eTDR_putIntptr(CELLIDX idx, const intptr_t ptr)
1241{
1242 CELLCB *p_cellcb;
1243 if (VALID_IDX(idx)) {
1244 p_cellcb = GET_CELLCB(idx);
1245 }
1246 else {
1247 return(E_ID);
1248 }
1249 (void)p_cellcb; // to avoid unused warning
1250
1251 /* ここに処理本体を記述します #_TEFB_# */
1252 return cChannel_send( (int8_t *)&ptr, (int16_t)sizeof( ptr ), VAR_tmo );
1253}
1254
1255/* #[<ENTRY_FUNC>]# eTDR_getIntptr
1256 * name: eTDR_getIntptr
1257 * global_name: tTDR_eTDR_getIntptr
1258 * oneway: false
1259 * #[</ENTRY_FUNC>]# */
1260Inline ER
1261eTDR_getIntptr(CELLIDX idx, intptr_t* ptr)
1262{
1263 ER_UINT er_sz;
1264 CELLCB *p_cellcb;
1265 if (VALID_IDX(idx)) {
1266 p_cellcb = GET_CELLCB(idx);
1267 }
1268 else {
1269 return(E_ID);
1270 }
1271 (void)p_cellcb; // to avoid unused warning
1272
1273 /* ここに処理本体を記述します #_TEFB_# */
1274 er_sz = cChannel_receive( (int8_t *)ptr, (int16_t)sizeof( *ptr ), VAR_tmo );
1275 return er_sz < 0 ? er_sz : ( er_sz == sizeof( *ptr ) ? E_OK : E_BOVR );
1276}
1277
1278
Note: See TracBrowser for help on using the repository browser.