source: azure_iot_hub/trunk/asp3_dcre/tecsgen/tecs/rpc/tTDR_inline.h@ 388

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

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