에프에이리눅스 / 1611_0007_prime_oven

Download as
Browse Code »

Commit 5b54553bd36c92090aee4c1a178e4062d3869470

Authored by 김태훈
1 parent 337d4f1a3c
Exists in master and in 2 other branches fhd, fhd-demo

가스 오븐 프로토콜 반영

Showing 2 changed files with 176 additions and 161 deletions   Show diff stats
app/app-prime-modbus/app/app-prime-modbus/rs485_serial.c
  Diff comments   View file @5b54553
... ... @@ -8,8 +8,8 @@
8 8 /**
9 9 @file main_control.c
10 10 @date 2017/01/12
11   - @author 장길석 jks@falinux.com FALinux.Co.,Ltd.
12   - @brief 온도조절기 제어 프로그램
  11 + @author 占쏙옙轢 jks@falinux.com FALinux.Co.,Ltd.
  12 + @brief 占승듸옙占쏙옙占쏙옙占쏙옙 占쏙옙占쏙옙 占쏙옙占싸그뤄옙
13 13  
14 14 @todo
15 15 @bug
... ... @@ -17,8 +17,8 @@
17 17 @warning
18 18 */
19 19 //
20   -// 저작권 에프에이리눅스(주)
21   -// 외부공개 금지
  20 +// 占쏙옙占쌜깍옙 占쏙옙占쏙옙占쏙옙占싱몌옙占쏙옙占쏙옙(占쏙옙)
  21 +// 占쌤부곤옙占쏙옙 占쏙옙占쏙옙
22 22 //
23 23 //----------------------------------------------------------------------------
24 24  
... ... @@ -31,7 +31,7 @@
31 31 #include <rs485_serial.h>
32 32 #include <udp_gui.h>
33 33  
34   -#define MAX_RETRY 3 // 전송 실패 시 재 전송 횟수
  34 +#define MAX_RETRY 3 // 占쏙옙占쏙옙 占쏙옙占쏙옙 占쏙옙 占쏙옙 占쏙옙占쏙옙 횟占쏙옙
35 35 #define MAX_BUFF_SIZE 1024
36 36  
37 37 enum step_t {
... ... @@ -63,25 +63,25 @@ static char buff[MAX_BUFF_SIZE];
63 63 static poll_obj_t *obj_uart;
64 64 static enum step_t step_work = STEP_CONTROL;
65 65 static enum switch_t sw_uart = SW_WAIT_ADDRESS;
66   -static char tx_data[MAX_BUFF_SIZE]; // 전송 데이터 버퍼
67   -static int tx_szdata; // 전송 데이터 길이
  66 +static char tx_data[MAX_BUFF_SIZE]; // 占쏙옙占쏙옙 占쏙옙占쏙옙占쏙옙 占쏙옙占쏙옙
  67 +static int tx_szdata; // 占쏙옙占쏙옙 占쏙옙占쏙옙占쏙옙 占쏙옙占쏙옙
68 68 static U8 rx_data[MAX_BUFF_SIZE];
69 69 static int rx_index;
70 70 static int rx_szdata;
71   -static msec_t tm_recv; // 통신 상태 확인을 위한 시간 변수
72   -static int cnt_retry; // 전송 실패에 대한 재 전송 횟수
73   -static int bit_onoff19 = 0; // bit sw 0x19 변수 값
74   -static int bit_onoff21 = 0; // bit sw 0x21 변수 값
75   -static int bit_onoff22 = 0; // bit sw 0x22 변수 값
76   -static U16 oven_error_bit = 0; // 오븐 에러 비트 값
77   -static U16 ary_error_cnt[16]; // 에러 카운트
  71 +static msec_t tm_recv; // 占쏙옙占 占쏙옙占쏙옙 확占쏙옙占쏙옙 占쏙옙占쏙옙 占시곤옙 占쏙옙占쏙옙
  72 +static int cnt_retry; // 占쏙옙占쏙옙 占쏙옙占싻울옙 占쏙옙占쏙옙 占쏙옙 占쏙옙占쏙옙 횟占쏙옙
  73 +static int bit_onoff19 = 0; // bit sw 0x19 占쏙옙占쏙옙 占쏙옙
  74 +static int bit_onoff21 = 0; // bit sw 0x21 占쏙옙占쏙옙 占쏙옙
  75 +static int bit_onoff22 = 0; // bit sw 0x22 占쏙옙占쏙옙 占쏙옙
  76 +static U16 oven_error_bit = 0; // 占쏙옙占쏙옙 占쏙옙占쏙옙 占쏙옙트 占쏙옙
  77 +static U16 ary_error_cnt[16]; // 占쏙옙占쏙옙 카占쏙옙트
78 78  
79   -static void run_step_work( int n_step); // 지정된 작업을 실행
80   -static void run_next_step_work( void); // 다음 작업 실행
  79 +static void run_step_work( int n_step); // 占쏙옙占쏙옙占쏙옙 占쌜억옙占쏙옙 占쏙옙占쏙옙
  80 +static void run_next_step_work( void); // 占쏙옙占쏙옙 占쌜억옙 占쏙옙占쏙옙
81 81  
82 82 /** ----------------------------------------------------------------------------
83   -@brief WORD 바이트의 하위/상위 바이트 순서를 바꾼다.
84   -@remark 빅엔디안을 리틀엔디안으로, 리틀엔디안을 빅엔디안으로 변경
  83 +@brief WORD 占쏙옙占쏙옙트占쏙옙 占쏙옙占쏙옙/占쏙옙占쏙옙 占쏙옙占쏙옙트 占쏙옙占쏙옙占쏙옙 占쌕꾼댐옙.
  84 +@remark 占쏠엔듸옙占쏙옙占 占쏙옙틀占쏙옙占쏙옙占쏙옙占쏙옙占, 占쏙옙틀占쏙옙占쏙옙占쏙옙占 占쏠엔듸옙占쏙옙占쏙옙占 占쏙옙占쏙옙
85 85 @param -
86 86 @return -
87 87 -----------------------------------------------------------------------------*/
... ... @@ -94,14 +94,14 @@ static void swap_byte( U16 *p16){
94 94 }
95 95  
96 96 /** ----------------------------------------------------------------------------
97   -@brief uart로 실제 데이터 전송
98   -@remark 데이터 전송후 uart 수신 단계를 초기화한다.
  97 +@brief uart占쏙옙 占쏙옙占쏙옙 占쏙옙占쏙옙占쏙옙 占쏙옙占쏙옙
  98 +@remark 占쏙옙占쏙옙占쏙옙 占쏙옙占쏙옙占쏙옙 uart 占쏙옙占쏙옙 占쌤계를 占십깍옙화占싼댐옙.
99 99 @param
100 100 @return
101 101 -----------------------------------------------------------------------------*/
102 102 static int write_to_uart( void){
103 103  
104   - { // 디버깅 코드, 전송 데이터를 바이트 단위로 출력
  104 + { // 占쏙옙占쏙옙占 占쌘듸옙, 占쏙옙占쏙옙 占쏙옙占쏙옙占싶몌옙 占쏙옙占쏙옙트 占쏙옙占쏙옙占쏙옙 占쏙옙占
105 105 int ndx;
106 106  
107 107 printf( "send:");
... ... @@ -112,19 +112,19 @@ static int write_to_uart( void){
112 112 }
113 113  
114 114 int rst = uart_write( obj_uart, tx_data, tx_szdata);
115   - sw_uart = SW_WAIT_ADDRESS; // 데이터 전송 후 uart 수신 단계 초기화
  115 + sw_uart = SW_WAIT_ADDRESS; // 占쏙옙占쏙옙占쏙옙 占쏙옙占쏙옙 占쏙옙 uart 占쏙옙占쏙옙 占쌤곤옙 占십깍옙화
116 116  
117   - tm_recv = get_cur_msec(); // 현재 시간 갱신
  117 + tm_recv = get_cur_msec(); // 占쏙옙占쏙옙 占시곤옙 占쏙옙占쏙옙
118 118  
119 119 return rst;
120 120 }
121 121  
122 122 /** ----------------------------------------------------------------------------
123   -@brief uart로 전송할 데이터를 완성
124   -@remark tx_data <- 전송할 데이터
125   - tx_szdata <- 전송할 데이터 바이트 개수
126   -@param pdata : 데이터 포인터
127   - sz_data : 데이터 바이트 개수
  123 +@brief uart占쏙옙 占쏙옙占쏙옙占쏙옙 占쏙옙占쏙옙占싶몌옙 占싹쇽옙
  124 +@remark tx_data <- 占쏙옙占쏙옙占쏙옙 占쏙옙占쏙옙占쏙옙
  125 + tx_szdata <- 占쏙옙占쏙옙占쏙옙 占쏙옙占쏙옙占쏙옙 占쏙옙占쏙옙트 占쏙옙占쏙옙
  126 +@param pdata : 占쏙옙占쏙옙占쏙옙 占쏙옙占쏙옙占쏙옙
  127 + sz_data : 占쏙옙占쏙옙占쏙옙 占쏙옙占쏙옙트 占쏙옙占쏙옙
128 128 @return
129 129 -----------------------------------------------------------------------------*/
130 130 static void make_tx_data( char *pdata, int sz_data){
... ... @@ -141,11 +141,11 @@ static void make_tx_data( char *pdata, int sz_data){
141 141 }
142 142  
143 143 /** ----------------------------------------------------------------------------
144   -@brief 오븐으로부터 상태 데이터를 요청한다.
  144 +@brief 占쏙옙占쏙옙占쏙옙占싸븝옙占쏙옙 占쏙옙占쏙옙 占쏙옙占쏙옙占싶몌옙 占쏙옙청占싼댐옙.
145 145 @remark
146   -@param addr_high : 상위 address
147   - addr_low : 하위 address
148   - size : 요구할 데이터 바이트 개수
  146 +@param addr_high : 占쏙옙占쏙옙 address
  147 + addr_low : 占쏙옙占쏙옙 address
  148 + size : 占썰구占쏙옙 占쏙옙占쏙옙占쏙옙 占쏙옙占쏙옙트 占쏙옙占쏙옙
149 149 @return
150 150 -----------------------------------------------------------------------------*/
151 151 static void modbus_func03( int addr_high, int addr_low, int size){
... ... @@ -159,15 +159,15 @@ static void modbus_func03( int addr_high, int addr_low, int size){
159 159 buff[ndx++] = 0x00;
160 160 buff[ndx++] = size;
161 161  
162   - make_tx_data( buff, ndx); // 실제 전송 데이터를 생성
163   - write_to_uart(); // uart로 전송
  162 + make_tx_data( buff, ndx); // 占쏙옙占쏙옙 占쏙옙占쏙옙 占쏙옙占쏙옙占싶몌옙 占쏙옙占쏙옙
  163 + write_to_uart(); // uart占쏙옙 占쏙옙占쏙옙
164 164 }
165 165 /** ----------------------------------------------------------------------------
166   -@brief 오븐으로부터 상태 데이터를 요청한다.
  166 +@brief 占쏙옙占쏙옙占쏙옙占싸븝옙占쏙옙 占쏙옙占쏙옙 占쏙옙占쏙옙占싶몌옙 占쏙옙청占싼댐옙.
167 167 @remark
168   -@param addr_high : 상위 address
169   - addr_low : 하위 address
170   - size : 요구할 데이터 바이트 개수
  168 +@param addr_high : 占쏙옙占쏙옙 address
  169 + addr_low : 占쏙옙占쏙옙 address
  170 + size : 占썰구占쏙옙 占쏙옙占쏙옙占쏙옙 占쏙옙占쏙옙트 占쏙옙占쏙옙
171 171 @return
172 172 -----------------------------------------------------------------------------*/
173 173 static void modbus_func04( int addr_high, int addr_low, int size){
... ... @@ -181,17 +181,17 @@ static void modbus_func04( int addr_high, int addr_low, int size){
181 181 buff[ndx++] = 0x00;
182 182 buff[ndx++] = size;
183 183  
184   - make_tx_data( buff, ndx); // 실제 전송 데이터를 생성
185   - write_to_uart(); // uart로 전송
  184 + make_tx_data( buff, ndx); // 占쏙옙占쏙옙 占쏙옙占쏙옙 占쏙옙占쏙옙占싶몌옙 占쏙옙占쏙옙
  185 + write_to_uart(); // uart占쏙옙 占쏙옙占쏙옙
186 186 }
187 187  
188 188 /** ----------------------------------------------------------------------------
189   -@brief 오븐으로 명령 전송(쓰기 요청)
  189 +@brief 占쏙옙占쏙옙占쏙옙占쏙옙 占쏙옙占 占쏙옙占쏙옙(占쏙옙占쏙옙 占쏙옙청)
190 190 @remark
191   -@param addr_high : 상위 address
192   - addr_low : 하위 address
193   - data_high : 상위 data
194   - data_log : 하위 data
  191 +@param addr_high : 占쏙옙占쏙옙 address
  192 + addr_low : 占쏙옙占쏙옙 address
  193 + data_high : 占쏙옙占쏙옙 data
  194 + data_log : 占쏙옙占쏙옙 data
195 195 @return
196 196 -----------------------------------------------------------------------------*/
197 197 static void modbus_func06( int addr_high, int addr_low, int data_high, int data_low){
... ... @@ -205,14 +205,14 @@ static void modbus_func06( int addr_high, int addr_low, int data_high, int data_
205 205 buff[ndx++] = data_high;
206 206 buff[ndx++] = data_low;
207 207  
208   - make_tx_data( buff, ndx); // 실제 전송 데이터를 생성
209   - write_to_uart(); // uart로 전송
  208 + make_tx_data( buff, ndx); // 占쏙옙占쏙옙 占쏙옙占쏙옙 占쏙옙占쏙옙占싶몌옙 占쏙옙占쏙옙
  209 + write_to_uart(); // uart占쏙옙 占쏙옙占쏙옙
210 210 }
211 211  
212 212 /** ----------------------------------------------------------------------------
213   -@brief GUI의 쓰기 명령 실행
  213 +@brief GUI占쏙옙 占쏙옙占쏙옙 占쏙옙占 占쏙옙占쏙옙
214 214 @remark
215   -@param pcmd : GUI가 요청한 명령
  215 +@param pcmd : GUI占쏙옙 占쏙옙청占쏙옙 占쏙옙占
216 216 @return
217 217 -----------------------------------------------------------------------------*/
218 218 static void set_value( command_t *pcmd){
... ... @@ -234,19 +234,23 @@ static void set_value( command_t *pcmd){
234 234 case TG_FAN2_RPM : addr = 0x1e; break;
235 235 case TG_FAN1_DIRECTOIN : addr = 0x1f; break;
236 236 case TG_FAN2_DIRECTOIN : addr = 0x20; break;
  237 + case TG_BURNER1_1_RPM : addr = 0x28; break;
  238 + case TG_BURNER1_2_RPM : addr = 0x29; break;
  239 + case TG_BURNER23_1_RPM : addr = 0x2A; break;
  240 + case TG_BURNER23_2_RPM : addr = 0x2B; break;
237 241 case TG_ERROR_CLEAR : addr = 0x31; break;
238 242 }
239 243  
240 244 int value_high = ( pcmd->value >> 8) & 0xff;
241 245 int value_low = ( pcmd->value ) & 0xff;
242 246  
243   - modbus_func06( 0, addr, value_high, value_low); // Modbus Func 6 함수 호출
  247 + modbus_func06( 0, addr, value_high, value_low); // Modbus Func 6 占쌉쇽옙 호占쏙옙
244 248 }
245 249  
246 250 /** ----------------------------------------------------------------------------
247   -@brief GUI의 스위치 on/off 명령 실행
  251 +@brief GUI占쏙옙 占쏙옙占쏙옙치 on/off 占쏙옙占 占쏙옙占쏙옙
248 252 @remark
249   -@param pcmd : GUI가 요청한 명령
  253 +@param pcmd : GUI占쏙옙 占쏙옙청占쏙옙 占쏙옙占
250 254 @return
251 255 -----------------------------------------------------------------------------*/
252 256 static void onoff_switch( command_t *pcmd){
... ... @@ -265,13 +269,13 @@ static void onoff_switch( command_t *pcmd){
265 269 int value_high = 0;
266 270 int value_low = pcmd->value;
267 271  
268   - modbus_func06( 0, addr, value_high, value_low); // Modbus Func 6 함수 호출
  272 + modbus_func06( 0, addr, value_high, value_low); // Modbus Func 6 占쌉쇽옙 호占쏙옙
269 273 }
270 274  
271 275 /** ----------------------------------------------------------------------------
272   -@brief GUI의 비트 단위 스위치 on/off 명령 실행
273   -@remark 0x0021, 0x0022 비트 단위 스위치 제어
274   -@param pcmd : GUI가 요청한 명령
  276 +@brief GUI占쏙옙 占쏙옙트 占쏙옙占쏙옙 占쏙옙占쏙옙치 on/off 占쏙옙占 占쏙옙占쏙옙
  277 +@remark 0x0021, 0x0022 占쏙옙트 占쏙옙占쏙옙 占쏙옙占쏙옙치 占쏙옙占쏙옙
  278 +@param pcmd : GUI占쏙옙 占쏙옙청占쏙옙 占쏙옙占
275 279 @return
276 280 -----------------------------------------------------------------------------*/
277 281 static void onoff_bit( command_t *pcmd){
... ... @@ -346,11 +350,11 @@ static void onoff_bit( command_t *pcmd){
346 350 int value_high = ( *p_onoff >> 8) & 0xff;
347 351 int value_low = ( *p_onoff ) & 0xff;
348 352  
349   - modbus_func06( 0, addr, value_high, value_low); // Modbus Func 6 함수 호출
  353 + modbus_func06( 0, addr, value_high, value_low); // Modbus Func 6 占쌉쇽옙 호占쏙옙
350 354 }
351 355  
352 356 /** ----------------------------------------------------------------------------
353   -@brief 오븐 에러 비트별 카운트를 초기화
  357 +@brief 占쏙옙占쏙옙 占쏙옙占쏙옙 占쏙옙트占쏙옙 카占쏙옙트占쏙옙 占십깍옙화
354 358 @remark -
355 359 @param -
356 360 @return
... ... @@ -365,7 +369,7 @@ static void clear_error_cnt(){
365 369  
366 370 }
367 371 /** ----------------------------------------------------------------------------
368   -@brief GUI로부터 수신한 요청이 있다면
  372 +@brief GUI占싸븝옙占쏙옙 占쏙옙占쏙옙占쏙옙 占쏙옙청占쏙옙 占쌍다몌옙
369 373 @remark -
370 374 @param -
371 375 @return
... ... @@ -374,19 +378,19 @@ static void check_gui_cmd( void){
374 378  
375 379 command_t cmd;
376 380  
377   - if ( 0 < gui_get_command( &cmd)){ // GUI로부터 요청이 있다면
  381 + if ( 0 < gui_get_command( &cmd)){ // GUI占싸븝옙占쏙옙 占쏙옙청占쏙옙 占쌍다몌옙
378 382 switch( cmd.cmd){
379   - case CMD_VALUE : // 오븐 값 설정
  383 + case CMD_VALUE : // 占쏙옙占쏙옙 占쏙옙 占쏙옙占쏙옙
380 384 set_value( &cmd);
381 385 break;
382   - case CMD_ONOFF : // 오븐 스위치 변경
  386 + case CMD_ONOFF : // 占쏙옙占쏙옙 占쏙옙占쏙옙치 占쏙옙占쏙옙
383 387 if ( TG_BITONOFF > cmd.target){
384 388 onoff_switch( &cmd);
385 389 } else {
386 390 onoff_bit( &cmd);
387 391 }
388 392 break;
389   - case CMD_CLEAR_ERROR_CNT : // 에러 카운트 초기화
  393 + case CMD_CLEAR_ERROR_CNT : // 占쏙옙占쏙옙 카占쏙옙트 占십깍옙화
390 394 clear_error_cnt();
391 395 break;
392 396 }
... ... @@ -397,7 +401,7 @@ static void check_gui_cmd( void){
397 401 }
398 402  
399 403 /** ----------------------------------------------------------------------------
400   -@brief 오븐으로부터 상태 값을 받았음
  404 +@brief 占쏙옙占쏙옙占쏙옙占싸븝옙占쏙옙 占쏙옙占쏙옙 占쏙옙占쏙옙 占쌨억옙占쏙옙
401 405 @remark
402 406 @param -
403 407 @return
... ... @@ -407,14 +411,14 @@ static void on_rcv_control( void){
407 411 gui_oven_control_t oven;
408 412 int ndx;
409 413  
410   - // 빅엔디안을 리틀엔디안으로 변경
411   - U16 *pword = (U16 *)&rx_data[3]; // 데이터는 rx_data[3]에서 시작
  414 + // 占쏠엔듸옙占쏙옙占 占쏙옙틀占쏙옙占쏙옙占쏙옙占쏙옙占 占쏙옙占쏙옙
  415 + U16 *pword = (U16 *)&rx_data[3]; // 占쏙옙占쏙옙占싶댐옙 rx_data[3]占쏙옙占쏙옙 占쏙옙占쏙옙
412 416  
413 417 for ( ndx = 0; ndx < rx_szdata / 2; ndx++){
414 418 swap_byte( pword++);
415 419 }
416 420  
417   - // 변수 처리
  421 + // 占쏙옙占쏙옙 처占쏙옙
418 422  
419 423 oven.header = HDR_OVEN_CONTROL;
420 424 memcpy( ( char *)&oven.control, &rx_data[3], sizeof( oven_control_t));
... ... @@ -435,14 +439,14 @@ static void on_rcv_control( void){
435 439 printf( "manual_onoff21 = 0x%04x\n", bit_onoff21);
436 440 printf( "manual_onoff22 = 0x%04x\n", bit_onoff22);
437 441  
438   - // GUI로 전송
  442 + // GUI占쏙옙 占쏙옙占쏙옙
439 443 gui_send_data_to_gui( ( char *)&oven, sizeof( gui_oven_state_t));
440 444  
441   - // 다음 단계 실행
  445 + // 占쏙옙占쏙옙 占쌤곤옙 占쏙옙占쏙옙
442 446 run_next_step_work();
443 447 }
444 448 /** ----------------------------------------------------------------------------
445   -@brief 오븐으로부터 상태 값을 받았음
  449 +@brief 占쏙옙占쏙옙占쏙옙占싸븝옙占쏙옙 占쏙옙占쏙옙 占쏙옙占쏙옙 占쌨억옙占쏙옙
446 450 @remark
447 451 @param -
448 452 @return
... ... @@ -452,59 +456,59 @@ static void on_rcv_status( void){
452 456 gui_oven_state_t oven;
453 457 int ndx;
454 458  
455   - // 빅엔디안을 리틀엔디안으로 변경
456   - U16 *pword = (U16 *)&rx_data[3]; // 데이터는 rx_data[3]에서 시작
  459 + // 占쏠엔듸옙占쏙옙占 占쏙옙틀占쏙옙占쏙옙占쏙옙占쏙옙占 占쏙옙占쏙옙
  460 + U16 *pword = (U16 *)&rx_data[3]; // 占쏙옙占쏙옙占싶댐옙 rx_data[3]占쏙옙占쏙옙 占쏙옙占쏙옙
457 461  
458 462 for ( ndx = 0; ndx < rx_szdata / 2; ndx++){
459 463 swap_byte( pword++);
460 464 }
461 465  
462   - // 변수 처리
  466 + // 占쏙옙占쏙옙 처占쏙옙
463 467  
464 468 oven.header = HDR_OVEN_STATE;
465   - memcpy( ( char *)&oven.state, &rx_data[3], 0x32 * 2); // 0x32 : 오븐 상태 워드 2바이트 개수
  469 + memcpy( ( char *)&oven.state, &rx_data[3], 0x32 * 2); // 0x32 : 占쏙옙占쏙옙 占쏙옙占쏙옙 占쏙옙占쏙옙 2占쏙옙占쏙옙트 占쏙옙占쏙옙
466 470  
467   - bit_onoff21 = oven.state.onoff_state1; // 현재 오븐 상태를 반영
468   - bit_onoff22 = oven.state.onoff_state2; // 현재 오븐 상태를 반영
  471 + bit_onoff21 = oven.state.onoff_state1; // 占쏙옙占쏙옙 占쏙옙占쏙옙 占쏙옙占승몌옙 占쌥울옙
  472 + bit_onoff22 = oven.state.onoff_state2; // 占쏙옙占쏙옙 占쏙옙占쏙옙 占쏙옙占승몌옙 占쌥울옙
469 473  
470 474 if ( oven_error_bit != oven.state.system_error){
471 475  
472   - // 변경된 비트가 있는 지 확인
  476 + // 占쏙옙占쏙옙占 占쏙옙트占쏙옙 占쌍댐옙 占쏙옙 확占쏙옙
473 477 U16 bit_ndx = 0x0001;
474 478 int bit_prev;
475 479 int bit_curr;
476 480  
477 481 for ( ndx = 0; ndx < 16; ndx++){
478   - bit_prev = oven_error_bit & bit_ndx; // 이전 비트 상태
479   - bit_curr = oven.state.system_error & bit_ndx; // 현재 비트 상태
480   - if ( bit_prev != bit_curr){ // 비트 값에 차이가 있다면
481   - if ( 0 != bit_prev){ // 비트 값이 0->1 변화일 때 에러 카운트 증가
  482 + bit_prev = oven_error_bit & bit_ndx; // 占쏙옙占쏙옙 占쏙옙트 占쏙옙占쏙옙
  483 + bit_curr = oven.state.system_error & bit_ndx; // 占쏙옙占쏙옙 占쏙옙트 占쏙옙占쏙옙
  484 + if ( bit_prev != bit_curr){ // 占쏙옙트 占쏙옙占쏙옙 占쏙옙占싱곤옙 占쌍다몌옙
  485 + if ( 0 != bit_prev){ // 占쏙옙트 占쏙옙占쏙옙 0->1 占쏙옙화占쏙옙 占쏙옙 占쏙옙占쏙옙 카占쏙옙트 占쏙옙占쏙옙
482 486 ary_error_cnt[ndx]++;
483 487 }
484 488 }
485 489 bit_ndx <<= 1;
486 490 }
487 491  
488   - // GUI로 에러 카우트 전달
  492 + // GUI占쏙옙 占쏙옙占쏙옙 카占쏙옙트 占쏙옙占쏙옙
489 493 for ( ndx = 0; ndx < 16; ndx++){
490 494 oven.state.error_cnt[ndx] = ary_error_cnt[ndx];
491 495 }
492 496  
493   - oven_error_bit = oven.state.system_error; // 에러 비트 값 변경
  497 + oven_error_bit = oven.state.system_error; // 占쏙옙占쏙옙 占쏙옙트 占쏙옙 占쏙옙占쏙옙
494 498 }
495 499  
496 500 printf( "onoff_state1 = 0x%04x\n", oven.state.onoff_state1);
497 501 printf( "onoff_state2 = 0x%04x\n", oven.state.onoff_state2);
498 502 printf( "onoff_realy_load = 0x%04x\n", oven.state.onoff_relay_load);
499 503  
500   - // GUI로 전송
  504 + // GUI占쏙옙 占쏙옙占쏙옙
501 505 gui_send_data_to_gui( ( char *)&oven, sizeof( gui_oven_state_t));
502 506  
503   - // 다음 단계 실행
  507 + // 占쏙옙占쏙옙 占쌤곤옙 占쏙옙占쏙옙
504 508 run_next_step_work();
505 509 }
506 510 /** ----------------------------------------------------------------------------
507   -@brief 오븐으로부터 명령 수행 결과를 받았음
  511 +@brief 占쏙옙占쏙옙占쏙옙占싸븝옙占쏙옙 占쏙옙占 占쏙옙占쏙옙 占쏙옙占쏙옙占 占쌨억옙占쏙옙
508 512 @remark
509 513 @param -
510 514 @return
... ... @@ -513,15 +517,15 @@ static void on_rcv_echo( void){
513 517  
514 518 printf( "receive func code 0x%x\n", rx_data[1] & 0xff);
515 519  
516   - if ( gui_command_exists()){ // 처리해야할 명령이 남아 있다면
517   - check_gui_cmd(); // 다음 명령을 전송한다.
518   - } else { // 처리해야할 명령이 없다면
519   - run_next_step_work(); // 다음 단계로 넘어 간다.
  520 + if ( gui_command_exists()){ // 처占쏙옙占쌔억옙占쏙옙 占쏙옙占쏙옙占 占쏙옙占쏙옙 占쌍다몌옙
  521 + check_gui_cmd(); // 占쏙옙占쏙옙 占쏙옙占쏙옙占 占쏙옙占쏙옙占싼댐옙.
  522 + } else { // 처占쏙옙占쌔억옙占쏙옙 占쏙옙占쏙옙占 占쏙옙占쌕몌옙
  523 + run_next_step_work(); // 占쏙옙占쏙옙 占쌤곤옙占 占싼억옙 占쏙옙占쏙옙.
520 524 }
521 525 }
522 526  
523 527 /** ----------------------------------------------------------------------------
524   -@brief 오븐으로부터 Modbus 80 에러 코드 수신 시 처리
  528 +@brief 占쏙옙占쏙옙占쏙옙占싸븝옙占쏙옙 Modbus 80 占쏙옙占쏙옙 占쌘듸옙 占쏙옙占쏙옙 占쏙옙 처占쏙옙
525 529 @remark
526 530 @param -
527 531 @return
... ... @@ -533,7 +537,7 @@ static void on_rcv_80_code( void){
533 537 switch( step_work){
534 538 case STEP_CHECK :
535 539 printf( "failed to command to oven\n");
536   - gui_send_error_code( ERR_RECEIVE_80); // 0x80 코드 수령을 GUI에 알림
  540 + gui_send_error_code( ERR_RECEIVE_80); // 0x80 占쌘듸옙 占쏙옙占쏙옙占쏙옙 GUI占쏙옙 占싯몌옙
537 541 break;
538 542 default :
539 543 break;
... ... @@ -542,14 +546,14 @@ static void on_rcv_80_code( void){
542 546 }
543 547  
544 548 /** ----------------------------------------------------------------------------
545   -@brief uart로부터 CRC까지 확인한 전문을 수신했음
  549 +@brief uart占싸븝옙占쏙옙 CRC占쏙옙占쏙옙 확占쏙옙占쏙옙 占쏙옙占쏙옙占쏙옙 占쏙옙占쏙옙占쏙옙占쏙옙
546 550 @remark
547 551 @param
548 552 @return
549 553 -----------------------------------------------------------------------------*/
550 554 static void on_receive_data( void){
551 555  
552   - // function 코드별로 분류
  556 + // function 占쌘드별占쏙옙 占싻뤄옙
553 557 switch ( rx_data[1]){
554 558 case 0x03 : on_rcv_control(); break;
555 559 case 0x04 : on_rcv_status(); break;
... ... @@ -566,11 +570,11 @@ static void on_receive_data( void){
566 570 @brief CRC 체크
567 571 @remark
568 572 @param
569   -@return true: CRC 값 옳음
  573 +@return true: CRC 占쏙옙 占쏙옙占쏙옙
570 574 -----------------------------------------------------------------------------*/
571 575 static int is_crc_ok( void){
572 576  
573   - // rx_index는 새로운 바이트를 넣을 위치. 즉, 데이터 바이트 개수
  577 + // rx_index占쏙옙 占쏙옙占싸울옙 占쏙옙占쏙옙트占쏙옙 占쏙옙占쏙옙 占쏙옙치. 占쏙옙, 占쏙옙占쏙옙占쏙옙 占쏙옙占쏙옙트 占쏙옙占쏙옙
574 578 U16 crc = CRC16( ( unsigned char *)rx_data, rx_index-2);
575 579  
576 580 U32 data_crc_lo = rx_data[rx_index-2];
... ... @@ -582,10 +586,10 @@ static int is_crc_ok( void){
582 586 }
583 587  
584 588 /** ----------------------------------------------------------------------------
585   -@brief uart 포트로부터 수신한 데이터를 처리
  589 +@brief uart 占쏙옙트占싸븝옙占쏙옙 占쏙옙占쏙옙占쏙옙 占쏙옙占쏙옙占싶몌옙 처占쏙옙
586 590 @remark
587   -@param obj : 통신 객체
588   -@return 수신 바이트 개수
  591 +@param obj : 占쏙옙占 占쏙옙체
  592 +@return 占쏙옙占쏙옙 占쏙옙占쏙옙트 占쏙옙占쏙옙
589 593 -----------------------------------------------------------------------------*/
590 594 static int on_serial_read( poll_obj_t *obj )
591 595 {
... ... @@ -593,7 +597,7 @@ static int on_serial_read( poll_obj_t *obj )
593 597 int ndx;
594 598 int rdcnt;
595 599  
596   - tm_recv = get_cur_msec(); // 웨이트 타임 오버에 걸리지 않도록 현재 시간 갱신.
  600 + tm_recv = get_cur_msec(); // 占쏙옙占쏙옙트 타占쏙옙 占쏙옙占쏙옙占쏙옙 占심몌옙占쏙옙 占십듸옙占쏙옙 占쏙옙占쏙옙 占시곤옙 占쏙옙占쏙옙.
597 601  
598 602 memset(buff, 0, sizeof(buff));
599 603 rdcnt = uart_read(obj, buff, sizeof(buff));
... ... @@ -609,10 +613,10 @@ static int on_serial_read( poll_obj_t *obj )
609 613 case SW_WAIT_FUNCTION :
610 614 rx_data[rx_index++] = ch_data;
611 615 switch( ch_data){
612   - case 0x03 : // 모드버스 0x04는 COUNT 정보가 필요
  616 + case 0x03 : // 占쏙옙占쏙옙占쏙옙 0x04占쏙옙 COUNT 占쏙옙占쏙옙占쏙옙 占십울옙
613 617 sw_uart = SW_WAIT_COUNT;
614 618 break;
615   - case 0x04 : // 모드버스 0x04는 COUNT 정보가 필요
  619 + case 0x04 : // 占쏙옙占쏙옙占쏙옙 0x04占쏙옙 COUNT 占쏙옙占쏙옙占쏙옙 占십울옙
616 620 sw_uart = SW_WAIT_COUNT;
617 621 break;
618 622 default :
... ... @@ -620,28 +624,28 @@ static int on_serial_read( poll_obj_t *obj )
620 624 break;
621 625 }
622 626 break;
623   - case SW_WAIT_COUNT : // 데이터 길이를 구함
  627 + case SW_WAIT_COUNT : // 占쏙옙占쏙옙占쏙옙 占쏙옙占싱몌옙 占쏙옙占쏙옙
624 628 sw_uart = SW_WAIT_DATA_COUNT;
625 629 rx_data[rx_index++] = ch_data;
626   - rx_szdata = ch_data; // CRC를 제외한 바이트 개수
  630 + rx_szdata = ch_data; // CRC占쏙옙 占쏙옙占쏙옙占쏙옙 占쏙옙占쏙옙트 占쏙옙占쏙옙
627 631 break;
628 632 case SW_WAIT_DATA_COUNT :
629   - rx_data[rx_index++] = ch_data; // rx_szdata 개의 바이트 만큼 읽어 들임
630   - if ( rx_szdata == rx_index-3){ // -3: 국번 1바이트, FUN 1바이트, 데이터 길이 1바이트 선두 제거
  633 + rx_data[rx_index++] = ch_data; // rx_szdata 占쏙옙占쏙옙 占쏙옙占쏙옙트 占쏙옙큼 占싻억옙 占쏙옙占쏙옙
  634 + if ( rx_szdata == rx_index-3){ // -3: 占쏙옙占쏙옙 1占쏙옙占쏙옙트, FUN 1占쏙옙占쏙옙트, 占쏙옙占쏙옙占쏙옙 占쏙옙占쏙옙 1占쏙옙占쏙옙트 占쏙옙占쏙옙 占쏙옙占쏙옙
631 635 sw_uart = SW_WAIT_CRC_LOW;
632 636 }
633 637 break;
634   - case SW_WAIT_DATA : // 모드 버스 0x05에서 읽어 들일 데이터 개수는 4바이트
  638 + case SW_WAIT_DATA : // 占쏙옙占 占쏙옙占쏙옙 0x05占쏙옙占쏙옙 占싻억옙 占쏙옙占쏙옙 占쏙옙占쏙옙占쏙옙 占쏙옙占쏙옙占쏙옙 4占쏙옙占쏙옙트
635 639 rx_data[rx_index++] = ch_data;
636   - if ( 4 == rx_index-2){ // -2: 국번 1바이트, FUN 1바이트
  640 + if ( 4 == rx_index-2){ // -2: 占쏙옙占쏙옙 1占쏙옙占쏙옙트, FUN 1占쏙옙占쏙옙트
637 641 sw_uart = SW_WAIT_CRC_LOW;
638 642 }
639 643 break;
640   - case SW_WAIT_CRC_LOW : // crc low 바이트 수신
  644 + case SW_WAIT_CRC_LOW : // crc low 占쏙옙占쏙옙트 占쏙옙占쏙옙
641 645 sw_uart = SW_WAIT_CRC_HIGH;
642 646 rx_data[rx_index++] = ch_data;
643 647 break;
644   - case SW_WAIT_CRC_HIGH : // crc high 바이트 수신
  648 + case SW_WAIT_CRC_HIGH : // crc high 占쏙옙占쏙옙트 占쏙옙占쏙옙
645 649 sw_uart = SW_WAIT_ADDRESS;
646 650 rx_data[rx_index++] = ch_data;
647 651 if ( is_crc_ok()){
... ... @@ -655,9 +659,9 @@ static int on_serial_read( poll_obj_t *obj )
655 659 }
656 660  
657 661 /** ----------------------------------------------------------------------------
658   -@brief 데이터를 수신하지 못 했을 때의 처리
659   -@remark 온도를 못 읽었을 때는 공유 메모리의 온도 값에는 -9999로
660   - RUNSTOP 값 요청에 대한 데이터가 없다면 RUNSTOP_NOT_EXISTS로 지정
  662 +@brief 占쏙옙占쏙옙占싶몌옙 占쏙옙占쏙옙占쏙옙占쏙옙 占쏙옙 占쏙옙占쏙옙 占쏙옙占쏙옙 처占쏙옙
  663 +@remark 占승듸옙占쏙옙 占쏙옙 占싻억옙占쏙옙 占쏙옙占쏙옙 占쏙옙占쏙옙 占쌨몌옙占쏙옙 占승듸옙 占쏙옙占쏙옙占쏙옙 -9999占쏙옙
  664 + RUNSTOP 占쏙옙 占쏙옙청占쏙옙 占쏙옙占쏙옙 占쏙옙占쏙옙占싶곤옙 占쏙옙占쌕몌옙 RUNSTOP_NOT_EXISTS占쏙옙 占쏙옙占쏙옙
661 665 @param
662 666 @return
663 667 -----------------------------------------------------------------------------*/
... ... @@ -666,44 +670,44 @@ static void on_no_data( void){
666 670 if ( MAX_RETRY < cnt_retry){
667 671 printf( ">>>>>>>> failed to send data\n");
668 672  
669   - if ( STEP_CHECK == step_work){ // GUI 요청으로 명령을 전송 중이었다
670   - gui_send_error_code( ERR_SEND_COMMAND); // 명령 전송 실패를 GUI에 알림
  673 + if ( STEP_CHECK == step_work){ // GUI 占쏙옙청占쏙옙占쏙옙 占쏙옙占쏙옙占 占쏙옙占쏙옙 占쏙옙占싱억옙占쏙옙
  674 + gui_send_error_code( ERR_SEND_COMMAND); // 占쏙옙占 占쏙옙占쏙옙 占쏙옙占싻몌옙 GUI占쏙옙 占싯몌옙
671 675 }
672 676 } else {
673   - write_to_uart(); // 이전 전송 데이터를 다시 전송
  677 + write_to_uart(); // 占쏙옙占쏙옙 占쏙옙占쏙옙 占쏙옙占쏙옙占싶몌옙 占쌕쏙옙 占쏙옙占쏙옙
674 678 cnt_retry++;
675 679 return;
676 680 }
677 681  
678   - run_step_work( STEP_CONTROL); // 통신을 계속 실패했다면 오븐 상태를 구하는 작업부터 다시 시작
  682 + run_step_work( STEP_CONTROL); // 占쏙옙占쏙옙占 占쏙옙占 占쏙옙占쏙옙占쌩다몌옙 占쏙옙占쏙옙 占쏙옙占승몌옙 占쏙옙占싹댐옙 占쌜억옙占쏙옙占쏙옙 占쌕쏙옙 占쏙옙占쏙옙
679 683 }
680 684  
681 685 /** ----------------------------------------------------------------------------
682   -@brief 인수로 받은 작업 STEP을 실행한다.
  686 +@brief 占싸쇽옙占쏙옙 占쏙옙占쏙옙 占쌜억옙 STEP占쏙옙 占쏙옙占쏙옙占싼댐옙.
683 687 @remark
684   -@param n_step : 실행할 STEP
  688 +@param n_step : 占쏙옙占쏙옙占쏙옙 STEP
685 689 @return -
686 690 -----------------------------------------------------------------------------*/
687 691 static void run_step_work( int n_step){
688 692  
689   - step_work = n_step; // 작업 단계 변경
690   - cnt_retry = 0; // 현재 작업에 대한 재 전송 횟수 초기화
691   - msleep( 50); // 다음 명령 요청 전에 쉬지 않으면 수신이 안 되는 경우가 있음
  693 + step_work = n_step; // 占쌜억옙 占쌤곤옙 占쏙옙占쏙옙
  694 + cnt_retry = 0; // 占쏙옙占쏙옙 占쌜억옙占쏙옙 占쏙옙占쏙옙 占쏙옙 占쏙옙占쏙옙 횟占쏙옙 占십깍옙화
  695 + msleep( 50); // 占쏙옙占쏙옙 占쏙옙占 占쏙옙청 占쏙옙占쏙옙 占쏙옙占쏙옙 占쏙옙占쏙옙占쏙옙 占쏙옙占쏙옙占쏙옙 占쏙옙 占실댐옙 占쏙옙李 占쏙옙占쏙옙
692 696  
693 697 switch( step_work){
694   - case STEP_CONTROL : modbus_func03( 0x00, 0x00, sizeof( oven_control_t) /2); break; // 데이터 요청 개수 /2: word 개수의 절반, 2개로 요청하면 4 바이트 수령
695   - case STEP_STATE : modbus_func04( 0x00, 0x00, 0x32 ); break; // oven_stae_t에 error_cnt[] 변수가 있어서 직접 입력
696   - case STEP_CHECK : check_gui_cmd(); break; // GUI 요청 확인
  698 + case STEP_CONTROL : modbus_func03( 0x00, 0x00, sizeof( oven_control_t) /2); break; // 占쏙옙占쏙옙占쏙옙 占쏙옙청 占쏙옙占쏙옙 /2: word 占쏙옙占쏙옙占쏙옙 占쏙옙占쏙옙, 2占쏙옙占쏙옙 占쏙옙청占싹몌옙 4 占쏙옙占쏙옙트 占쏙옙占쏙옙
  699 + case STEP_STATE : modbus_func04( 0x00, 0x00, 0x32 ); break; // oven_stae_t占쏙옙 error_cnt[] 占쏙옙占쏙옙占쏙옙 占쌍어서 占쏙옙占쏙옙 占쌉뤄옙
  700 + case STEP_CHECK : check_gui_cmd(); break; // GUI 占쏙옙청 확占쏙옙
697 701 default :
698   - msleep( 100); // 100mm sec 휴식, 통신 간격 조절
699   - run_next_step_work(); // 다음 STEP 실행
  702 + msleep( 100); // 100mm sec 占쌨쏙옙, 占쏙옙占 占쏙옙占쏙옙 占쏙옙占쏙옙
  703 + run_next_step_work(); // 占쏙옙占쏙옙 STEP 占쏙옙占쏙옙
700 704 break;
701 705 }
702 706 }
703 707  
704 708 /** ----------------------------------------------------------------------------
705   -@brief 다음 작업 STEP을 실행한다.
706   -@remark STEP을 기억하는 step_work를 증가
  709 +@brief 占쏙옙占쏙옙 占쌜억옙 STEP占쏙옙 占쏙옙占쏙옙占싼댐옙.
  710 +@remark STEP占쏙옙 占쏙옙占쏙옙求占 step_work占쏙옙 占쏙옙占쏙옙
707 711 @param -
708 712 @return -
709 713 -----------------------------------------------------------------------------*/
... ... @@ -715,14 +719,14 @@ static void run_next_step_work( void){
715 719 }
716 720  
717 721 /** ----------------------------------------------------------------------------
718   -@brief 데이터 수신 여부 확인
  722 +@brief 占쏙옙占쏙옙占쏙옙 占쏙옙占쏙옙 占쏙옙占쏙옙 확占쏙옙
719 723 @remark
720   -@param msec_t tm_curr : 현재 시간
  724 +@param msec_t tm_curr : 占쏙옙占쏙옙 占시곤옙
721 725 @return
722 726 -----------------------------------------------------------------------------*/
723 727 int rs485_timer( msec_t tm_curr){
724 728  
725   - if ( 500 <= ( tm_curr - tm_recv) ){ // 1초 이상 수신되는 데이터가 없다면 통신 이상으로 판단
  729 + if ( 500 <= ( tm_curr - tm_recv) ){ // 1占쏙옙 占싱삼옙 占쏙옙占신되댐옙 占쏙옙占쏙옙占싶곤옙 占쏙옙占쌕몌옙 占쏙옙占 占싱삼옙占쏙옙占쏙옙 占실댐옙
726 730 on_no_data();
727 731 }
728 732 return 0;
... ... @@ -730,20 +734,20 @@ int rs485_timer( msec_t tm_curr){
730 734  
731 735  
732 736 /** ----------------------------------------------------------------------------
733   -@brief rs485 모듈 실행 시작
  737 +@brief rs485 占쏙옙占 占쏙옙占쏙옙 占쏙옙占쏙옙
734 738 @remark
735   -@param uart_name : uart 장치 이름
  739 +@param uart_name : uart 占쏙옙치 占싱몌옙
736 740 @return
737 741 -----------------------------------------------------------------------------*/
738 742 int rs845_run_start( void){
739 743  
740   - run_step_work( STEP_CONTROL); // 오븐 제어 상태를 구하는 작업부터 시작
  744 + run_step_work( STEP_CONTROL); // 占쏙옙占쏙옙 占쏙옙占쏙옙 占쏙옙占승몌옙 占쏙옙占싹댐옙 占쌜억옙占쏙옙占쏙옙 占쏙옙占쏙옙
741 745  
742 746 return 0;
743 747 }
744 748  
745 749 /** ----------------------------------------------------------------------------
746   -@brief 모듈 시작을 위한 초기활를 한다.
  750 +@brief 占쏙옙占 占쏙옙占쏙옙占쏙옙 占쏙옙占쏙옙 占십깍옙활占쏙옙 占싼댐옙.
747 751 @remark
748 752 @param
749 753 @return
... ... @@ -754,7 +758,7 @@ int rs485_initialize( void){
754 758 poll_obj_t *obj;
755 759 int ndx;
756 760  
757   - inifile = ini_create( INI_SYSTEM); // IniFile 생성
  761 + inifile = ini_create( INI_SYSTEM); // IniFile 占쏙옙占쏙옙
758 762 if ( NULL == inifile){
759 763 printf( "ini file error.\n");
760 764 return -1;
... ... @@ -775,12 +779,12 @@ int rs485_initialize( void){
775 779 ini_free( inifile);
776 780 }
777 781  
778   - memset( &rx_data, 0, sizeof( rx_data)); // 누적 수신 버퍼 초기화
  782 + memset( &rx_data, 0, sizeof( rx_data)); // 占쏙옙占쏙옙 占쏙옙占쏙옙 占쏙옙占쏙옙 占십깍옙화
779 783  
780 784 obj_uart = obj;
781 785  
782   - // 에러 카운트를 위한 비트 초기화
783   - // 추후 파일에서 읽어 들임
  786 + // 占쏙옙占쏙옙 카占쏙옙트占쏙옙 占쏙옙占쏙옙 占쏙옙트 占십깍옙화
  787 + // 占쏙옙占쏙옙 占쏙옙占싹울옙占쏙옙 占싻억옙 占쏙옙占쏙옙
784 788  
785 789 for ( ndx = 0; ndx < 16; ndx++){
786 790 ary_error_cnt[ndx] = 0;
... ...
app/app-prime-modbus/include/all_share.h
  Diff comments   View file @5b54553
1 1 //------------------------------------------------------------------------------
2   -// 화일명 : all_share.h
3   -// 프로젝트 :
4   -// 설 명 : 공유 메모리 구조체를 선언한다.
  2 +// 화占싹몌옙 : all_share.h
  3 +// 占쏙옙占쏙옙占쏙옙트 :
  4 +// 占쏙옙 占쏙옙 : 占쏙옙占쏙옙 占쌨몌옙 占쏙옙占쏙옙체占쏙옙 占쏙옙占쏙옙占싼댐옙.
5 5 //
6   -// 저작권 : FA리눅스주식회사
7   -// 주 의 :
  6 +// 占쏙옙占쌜깍옙 : FA占쏙옙占쏙옙占쏙옙占쌍쏙옙회占쏙옙
  7 +// 占쏙옙 占쏙옙 :
8 8 //------------------------------------------------------------------------------
9 9 #ifndef _ALL__SHARE_HEADER_
10 10 #define _ALL__SHARE_HEADER_
... ... @@ -25,9 +25,9 @@ typedef unsigned long long U64;
25 25 typedef signed short I16;
26 26  
27 27 enum command_enum_t {
28   - CMD_VALUE = 0, // 오븐 값 변경
29   - CMD_ONOFF, // 오븐 스위치 ON/OFF
30   - CMD_CLEAR_ERROR_CNT // 에러 카운트를 초기화
  28 + CMD_VALUE = 0, // 占쏙옙占쏙옙 占쏙옙 占쏙옙占쏙옙
  29 + CMD_ONOFF, // 占쏙옙占쏙옙 占쏙옙占쏙옙치 ON/OFF
  30 + CMD_CLEAR_ERROR_CNT // 占쏙옙占쏙옙 카占쏙옙트占쏙옙 占십깍옙화
31 31 };
32 32  
33 33 enum target_value_t {
... ... @@ -46,6 +46,10 @@ enum target_value_t {
46 46 TG_FAN2_RPM,
47 47 TG_FAN1_DIRECTOIN,
48 48 TG_FAN2_DIRECTOIN,
  49 + TG_BURNER1_1_RPM,
  50 + TG_BURNER1_2_RPM,
  51 + TG_BURNER23_1_RPM,
  52 + TG_BURNER23_2_RPM,
49 53 TG_ERROR_CLEAR
50 54 };
51 55  
... ... @@ -87,18 +91,18 @@ enum target_onoff_t {
87 91 };
88 92  
89 93 enum {
90   - HDR_OVEN_CONTROL = 0, // 40000 번지 값, 컨트롤 제어
91   - HDR_OVEN_STATE, // 30000 번지 값, 오븐 상태
92   - HDR_ERROR_CODE // 에러 코드
  94 + HDR_OVEN_CONTROL = 0, // 40000 占쏙옙占쏙옙 占쏙옙, 占쏙옙트占쏙옙 占쏙옙占쏙옙
  95 + HDR_OVEN_STATE, // 30000 占쏙옙占쏙옙 占쏙옙, 占쏙옙占쏙옙 占쏙옙占쏙옙
  96 + HDR_ERROR_CODE // 占쏙옙占쏙옙 占쌘듸옙
93 97 };
94 98  
95 99 enum {
96   - ERR_SEND_COMMAND = 0, // 명령 전송에 대한 응답이 없음
97   - ERR_RECEIVE_80 // 0x80 코드를 수신했음
  100 + ERR_SEND_COMMAND = 0, // 占쏙옙占 占쏙옙占쌜울옙 占쏙옙占쏙옙 占쏙옙占쏙옙占쏙옙 占쏙옙占쏙옙
  101 + ERR_RECEIVE_80 // 0x80 占쌘드를 占쏙옙占쏙옙占쏙옙占쏙옙
98 102 };
99 103  
100 104 //
101   -// 시스템 전체 공유 구조체 구조체
  105 +// 占시쏙옙占쏙옙 占쏙옙체 占쏙옙占쏙옙 占쏙옙占쏙옙체 占쏙옙占쏙옙체
102 106 //
103 107  
104 108 typedef struct
... ... @@ -149,10 +153,10 @@ typedef struct {
149 153 U16 reserved25; // 25
150 154 U16 reserved26; // 26
151 155 U16 reserved27; // 27
152   - U16 reserved28; // 28
153   - U16 reserved29; // 29
154   - U16 reserved2a; // 2A
155   - U16 reserved2b; // 2B
  156 + U16 burner1_1_rpm; // 28
  157 + U16 burner1_2_rpm; // 29
  158 + U16 burner23_1_rpm; // 2A
  159 + U16 burner23_2_rpm; // 2B
156 160 U16 reserved2c; // 2C
157 161 U16 reserved2d; // 2D
158 162 U16 reserved2e; // 2E
... ... @@ -212,7 +216,14 @@ typedef struct {
212 216 U16 communication_error; // 2F
213 217 U16 sensor_error; // 30
214 218 U16 reserved31; // 31
215   - U16 error_cnt[16]; // 에러 카운트
  219 + U16 burner1_ignition_rpm; // 32
  220 + U16 burner2_ignition_rpm; // 33
  221 + U16 burner3_ignition_rpm; // 34
  222 + U16 burner1_current_rpm; // 35
  223 + U16 burner2_current_rpm; // 36
  224 + U16 burner3_current_rpm; // 37
  225 + U16 controller_error; // 38
  226 + U16 error_cnt[16]; // 占쏙옙占쏙옙 카占쏙옙트
216 227 } STRUCT_PACK oven_state_t;
217 228  
218 229 typedef struct {
... ... @@ -232,13 +243,13 @@ typedef struct {
232 243  
233 244 //------------------------------------------------------------------------------
234 245 //
235   -// 프레임, 페이로드
  246 +// 占쏙옙占쏙옙占쏙옙, 占쏙옙占싱로듸옙
236 247 //
237 248 //------------------------------------------------------------------------------
238 249  
239 250 //------------------------------------------------------------------------------
240 251 //
241   -// 전역 변수 정의
  252 +// 占쏙옙占쏙옙 占쏙옙占쏙옙 占쏙옙占쏙옙
242 253 //
243 254 //------------------------------------------------------------------------------
244 255  
... ...