[337] | 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>]# */
|
---|
| 66 | Inline ER
|
---|
| 67 | eTDR_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 | }
|
---|
[374] | 77 | (void)p_cellcb; // to avoid unused warning
|
---|
[337] | 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>]# */
|
---|
| 89 | Inline ER
|
---|
| 90 | eTDR_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 | }
|
---|
[374] | 105 | (void)p_cellcb; // to avoid unused warning
|
---|
[337] | 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>]# */
|
---|
| 139 | Inline ER
|
---|
| 140 | eTDR_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 | }
|
---|
[374] | 155 | (void)p_cellcb; // to avoid unused warning
|
---|
[337] | 156 |
|
---|
| 157 | /* ここに処理本体を記述します #_TEFB_# */
|
---|
| 158 | #ifdef RPC_DEBUG
|
---|
| 159 | syslog(LOG_INFO, "eTDR_receiveSOP(b_client=%d)", b_client);
|
---|
| 160 | #endif
|
---|
| 161 |
|
---|
[374] | 162 | if( b_client )
|
---|
[337] | 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>]# */
|
---|
| 191 | Inline ER
|
---|
| 192 | eTDR_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 | }
|
---|
[374] | 203 | (void)p_cellcb; // to avoid unused warning
|
---|
[337] | 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>]# */
|
---|
| 227 | Inline ER
|
---|
| 228 | eTDR_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 | }
|
---|
[374] | 240 | (void)p_cellcb; // to avoid unused warning
|
---|
[337] | 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>]# */
|
---|
| 264 | Inline ER
|
---|
| 265 | eTDR_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 | }
|
---|
[374] | 274 | (void)p_cellcb; // to avoid unused warning
|
---|
[337] | 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>]# */
|
---|
| 285 | Inline ER
|
---|
| 286 | eTDR_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 | }
|
---|
[374] | 295 | (void)p_cellcb; // to avoid unused warning
|
---|
[337] | 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>]# */
|
---|
| 306 | Inline ER
|
---|
| 307 | eTDR_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 | }
|
---|
[374] | 316 | (void)p_cellcb; // to avoid unused warning
|
---|
[337] | 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>]# */
|
---|
| 327 | Inline ER
|
---|
| 328 | eTDR_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 | }
|
---|
[374] | 337 | (void)p_cellcb; // to avoid unused warning
|
---|
[337] | 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>]# */
|
---|
| 348 | Inline ER
|
---|
| 349 | eTDR_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 | }
|
---|
[374] | 358 | (void)p_cellcb; // to avoid unused warning
|
---|
[337] | 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>]# */
|
---|
| 369 | Inline ER
|
---|
| 370 | eTDR_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 | }
|
---|
[374] | 380 | (void)p_cellcb; // to avoid unused warning
|
---|
[337] | 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>]# */
|
---|
| 392 | Inline ER
|
---|
| 393 | eTDR_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 | }
|
---|
[374] | 403 | (void)p_cellcb; // to avoid unused warning
|
---|
[337] | 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>]# */
|
---|
| 415 | Inline ER
|
---|
| 416 | eTDR_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 | }
|
---|
[374] | 426 | (void)p_cellcb; // to avoid unused warning
|
---|
[337] | 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>]# */
|
---|
| 438 | Inline ER
|
---|
| 439 | eTDR_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 | }
|
---|
[374] | 449 | (void)p_cellcb; // to avoid unused warning
|
---|
[337] | 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>]# */
|
---|
| 461 | Inline ER
|
---|
| 462 | eTDR_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 | }
|
---|
[374] | 472 | (void)p_cellcb; // to avoid unused warning
|
---|
[337] | 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>]# */
|
---|
| 484 | Inline ER
|
---|
| 485 | eTDR_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) */
|
---|
[374] | 494 | (void)p_cellcb; // to avoid unused warning
|
---|
[337] | 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>]# */
|
---|
| 505 | Inline ER
|
---|
| 506 | eTDR_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) */
|
---|
[374] | 515 | (void)p_cellcb; // to avoid unused warning
|
---|
[337] | 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>]# */
|
---|
| 526 | Inline ER
|
---|
| 527 | eTDR_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) */
|
---|
[374] | 536 | (void)p_cellcb; // to avoid unused warning
|
---|
[337] | 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>]# */
|
---|
| 547 | Inline ER
|
---|
| 548 | eTDR_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) */
|
---|
[374] | 557 | (void)p_cellcb; // to avoid unused warning
|
---|
[337] | 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>]# */
|
---|
| 568 | Inline ER
|
---|
| 569 | eTDR_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) */
|
---|
[374] | 578 | (void)p_cellcb; // to avoid unused warning
|
---|
[337] | 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>]# */
|
---|
| 589 | Inline ER
|
---|
| 590 | eTDR_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) */
|
---|
[374] | 600 | (void)p_cellcb; // to avoid unused warning
|
---|
[337] | 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>]# */
|
---|
| 612 | Inline ER
|
---|
| 613 | eTDR_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) */
|
---|
[374] | 623 | (void)p_cellcb; // to avoid unused warning
|
---|
[337] | 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>]# */
|
---|
| 635 | Inline ER
|
---|
| 636 | eTDR_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) */
|
---|
[374] | 646 | (void)p_cellcb; // to avoid unused warning
|
---|
[337] | 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>]# */
|
---|
| 658 | Inline ER
|
---|
| 659 | eTDR_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) */
|
---|
[374] | 669 | (void)p_cellcb; // to avoid unused warning
|
---|
[337] | 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>]# */
|
---|
| 681 | Inline ER
|
---|
| 682 | eTDR_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) */
|
---|
[374] | 692 | (void)p_cellcb; // to avoid unused warning
|
---|
[337] | 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>]# */
|
---|
| 704 | Inline ER
|
---|
| 705 | eTDR_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) */
|
---|
[374] | 715 | (void)p_cellcb; // to avoid unused warning
|
---|
[337] | 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>]# */
|
---|
| 728 | Inline ER
|
---|
| 729 | eTDR_getBool(CELLIDX idx, bool_t* out)
|
---|
| 730 | {
|
---|
| 731 | ER ercd = E_OK;
|
---|
| 732 | CELLCB *p_cellcb;
|
---|
[374] | 733 | uint8_t val = 0;
|
---|
[337] | 734 | if (VALID_IDX(idx)) {
|
---|
| 735 | p_cellcb = GET_CELLCB(idx);
|
---|
| 736 | }
|
---|
| 737 | else {
|
---|
| 738 | return(E_ID);
|
---|
| 739 | } /* end if VALID_IDX(idx) */
|
---|
[374] | 740 | (void)p_cellcb; // to avoid unused warning
|
---|
[337] | 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>]# */
|
---|
| 756 | Inline ER
|
---|
| 757 | eTDR_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 | }
|
---|
[374] | 766 | (void)p_cellcb; // to avoid unused warning
|
---|
[337] | 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>]# */
|
---|
| 777 | Inline ER
|
---|
| 778 | eTDR_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 | }
|
---|
[374] | 787 | (void)p_cellcb; // to avoid unused warning
|
---|
[337] | 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>]# */
|
---|
| 798 | Inline ER
|
---|
| 799 | eTDR_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 | }
|
---|
[374] | 809 | (void)p_cellcb; // to avoid unused warning
|
---|
[337] | 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>]# */
|
---|
| 821 | Inline ER
|
---|
| 822 | eTDR_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 | }
|
---|
[374] | 832 | (void)p_cellcb; // to avoid unused warning
|
---|
[337] | 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>]# */
|
---|
| 844 | Inline ER
|
---|
| 845 | eTDR_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 | }
|
---|
[374] | 854 | (void)p_cellcb; // to avoid unused warning
|
---|
[337] | 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>]# */
|
---|
| 865 | Inline ER
|
---|
| 866 | eTDR_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>]# */
|
---|
| 887 | Inline ER
|
---|
| 888 | eTDR_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) */
|
---|
[374] | 897 | (void)p_cellcb; // to avoid unused warning
|
---|
[337] | 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>]# */
|
---|
| 908 | Inline ER
|
---|
| 909 | eTDR_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 | }
|
---|
[374] | 918 | (void)p_cellcb; // to avoid unused warning
|
---|
[337] | 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>]# */
|
---|
| 929 | Inline ER
|
---|
| 930 | eTDR_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 | }
|
---|
[374] | 939 | (void)p_cellcb; // to avoid unused warning
|
---|
[337] | 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>]# */
|
---|
| 950 | Inline ER
|
---|
| 951 | eTDR_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 | }
|
---|
[374] | 960 | (void)p_cellcb; // to avoid unused warning
|
---|
[337] | 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>]# */
|
---|
| 971 | Inline ER
|
---|
| 972 | eTDR_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) */
|
---|
[374] | 982 | (void)p_cellcb; // to avoid unused warning
|
---|
[337] | 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>]# */
|
---|
| 994 | Inline ER
|
---|
| 995 | eTDR_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 | }
|
---|
[374] | 1005 | (void)p_cellcb; // to avoid unused warning
|
---|
[337] | 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>]# */
|
---|
| 1017 | Inline ER
|
---|
| 1018 | eTDR_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 | }
|
---|
[374] | 1028 | (void)p_cellcb; // to avoid unused warning
|
---|
[337] | 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>]# */
|
---|
| 1040 | Inline ER
|
---|
| 1041 | eTDR_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 | }
|
---|
[374] | 1051 | (void)p_cellcb; // to avoid unused warning
|
---|
[337] | 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>]# */
|
---|
| 1063 | Inline ER
|
---|
| 1064 | eTDR_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) */
|
---|
[374] | 1073 | (void)p_cellcb; // to avoid unused warning
|
---|
[337] | 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>]# */
|
---|
| 1084 | Inline ER
|
---|
| 1085 | eTDR_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) */
|
---|
[374] | 1094 | (void)p_cellcb; // to avoid unused warning
|
---|
[337] | 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>]# */
|
---|
| 1105 | Inline ER
|
---|
| 1106 | eTDR_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) */
|
---|
[374] | 1115 | (void)p_cellcb; // to avoid unused warning
|
---|
[337] | 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>]# */
|
---|
| 1126 | Inline ER
|
---|
| 1127 | eTDR_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) */
|
---|
[374] | 1136 | (void)p_cellcb; // to avoid unused warning
|
---|
[337] | 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>]# */
|
---|
| 1147 | Inline ER
|
---|
| 1148 | eTDR_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) */
|
---|
[374] | 1158 | (void)p_cellcb; // to avoid unused warning
|
---|
[337] | 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>]# */
|
---|
| 1170 | Inline ER
|
---|
| 1171 | eTDR_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) */
|
---|
[374] | 1181 | (void)p_cellcb; // to avoid unused warning
|
---|
[337] | 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>]# */
|
---|
| 1193 | Inline ER
|
---|
| 1194 | eTDR_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) */
|
---|
[374] | 1204 | (void)p_cellcb; // to avoid unused warning
|
---|
[337] | 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>]# */
|
---|
| 1216 | Inline ER
|
---|
| 1217 | eTDR_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) */
|
---|
[374] | 1227 | (void)p_cellcb; // to avoid unused warning
|
---|
[337] | 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>]# */
|
---|
| 1239 | Inline ER
|
---|
| 1240 | eTDR_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 | }
|
---|
[374] | 1249 | (void)p_cellcb; // to avoid unused warning
|
---|
[337] | 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>]# */
|
---|
| 1260 | Inline ER
|
---|
| 1261 | eTDR_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 | }
|
---|
[374] | 1271 | (void)p_cellcb; // to avoid unused warning
|
---|
[337] | 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 |
|
---|