source: svn/newcon3bcm2_21bu/dst/app/src/Function/App_Fnc_Comm.c

Last change on this file was 76, checked in by megakiss, 10 years ago

1W 대기전력을 만족시키기 위하여 POWEROFF시 튜너를 Standby 상태로 함
  • Property svn:executable set to *
File size: 12.3 KB
Line 
1
2
3//app fnc comm
4
5#include "App_Main.h"
6#include "App_Fnc_Common.h"
7
8#include "DHL_COM.h"
9#include "DHL_UIO.h"
10
11#include "UioFilter.h"
12
13#include "App_Fnc_Comm.h"
14#include "App_Fnc_Video.h"
15#include "App_Fnc_ChTune.h"
16#include "App_Fnc_SignalMonitor.h"
17#include "App_Fnc_Time.h"
18
19#include "App_Proc.h"
20
21#include "App_Res_Resources.h"
22
23DHL_MODULE("@f_comm", 0);
24
25#define COMM_UART_ID 1
26        //UART 0, 1¹ø Áß 1¹øÀ» »ç¿ëÇÔ
27
28#define INTER_DATA_SEND_DELAY 20 //ÃÖ¼Ò 20ms´Â µÇ¾î¾ß ÇÔ..
29        //ÇϳªÀÇ data¸¦ º¸³»°í ´ÙÀ½ µ¥ÀÌÅ͸¦ º¸³»´Âµ¥±îÁöÀÇ delay
30        //¿¬¼ÓÇؼ­ data¸¦ º¸³»¸é micom¿¡¼­ ¹ÞÁö ¸øÇÒ ¼ö ÀÖÀ¸¹Ç·Î ÃÖ¼Ò 100msÀÇ delay µÒ
31
32#define FAKE_MICOM_TASK_PRIO 40 //20->40
33        //taks priority´Â ÃßÈÄ Á¶Á¤ÀÌ ÇÊ¿äÇÒ ¼öµµ ÀÖÀ½
34       
35#define FAKE_MICOM_MSG_LEN MICOM_UART_MSG_LEN
36        //
37
38static int p_prev_uid;
39static int p_prev_rf;
40static int p_prev_program_num;
41
42
43static struct {
44        BOOL bexist_micom;
45       
46        DHL_OS_TASK_ID fake_micom_tid;
47        DHL_OS_MSGQ_ID fake_micom_msgq1; //micom send
48        DHL_OS_MSGQ_ID fake_micom_msgq2; //micom receive
49        DHL_OS_SEMA_ID mtx;
50        DHL_OS_TASK_ID rcv_tid;
51        DHL_OS_SEMA_ID sem;
52        UINT8 rcv_buf[MICOM_UART_MSG_LEN];
53        BOOL rcv_completed;
54        BOOL brcv_wait_func; //App_Fnc_ReceiveDataÇÔ¼ö°¡ Á¾·áµÇ±â¸¦ ±â´Ù¸®°í ÀÖÀ½.
55       
56        UINT32 ir_code;
57        UINT32 ir_ms;
58} p_comm_info;
59
60#define PINFO(x) p_comm_info.x
61
62
63static void p_lock(BOOL block)
64{
65        if(block) DHL_OS_TakeSemaphore(PINFO(mtx), DHL_TIMEOUT_FOREVER);
66        else DHL_OS_GiveSemaphore(PINFO(mtx));
67}
68
69
70static void p_led_ctrl(int mode)
71{
72        //mode 0 : standby, 1: normal
73        DHL_UIO_Control(eDHL_UIO_CT_LED, GPIO_LED_G, mode);
74        DHL_UIO_Control(eDHL_UIO_CT_LED, GPIO_LED_R, 1-mode);
75}
76
77
78static void p_av_mute(BOOL bmute)
79{
80        if(bmute) {
81                DHL_AV_DispSetFormat((tDHL_DispPort)0, eDHL_DISP_NO_OUTPUT, (tDHL_DispColorSpace)0);
82               
83                DHL_AV_AudioMuteControl(eDHL_AUDIO_MUTE_DECODER, TRUE);
84                DHL_AV_AudioMuteControl(eDHL_AUDIO_MUTE_HDMI, TRUE);
85                DHL_AV_AudioMuteControl(eDHL_AUDIO_MUTE_SPDIF, TRUE);
86                DHL_AV_AudioMuteControl(eDHL_AUDIO_MUTE_AMP, TRUE);
87#if 0
88                DHL_SYS_ResetGPIO(GPIO_5VDC_CTRL);
89#endif
90        }
91        else {
92#if 0
93                DHL_SYS_SetGPIO(GPIO_5VDC_CTRL);
94#endif
95               
96                App_VideoSetOutputResolution(App_VideoGetOutputResolution());
97               
98                DHL_AV_AudioMuteControl(eDHL_AUDIO_MUTE_DECODER, FALSE);
99                DHL_AV_AudioMuteControl(eDHL_AUDIO_MUTE_HDMI, FALSE);
100                DHL_AV_AudioMuteControl(eDHL_AUDIO_MUTE_SPDIF, FALSE);
101                DHL_AV_AudioMuteControl(eDHL_AUDIO_MUTE_AMP, FALSE);
102        }
103}
104
105
106
107static void p_do_before_stadby()
108{
109        p_prev_uid=APP_CUR_CH.nUid;
110        p_prev_rf=APP_CUR_CH.nRF;
111        p_prev_program_num=APP_CUR_CH.nProgramNumber;
112       
113        App_ChTuneStopTVEx(TRUE);
114        App_Pause_SMTask();
115        //sleep timer init
116        App_SetSleepTimer(0);
117}
118
119
120static void p_do_before_normal()
121{
122        //App_Menu_SetAllVars();
123       
124        //App_Menu_InitPos();
125       
126        if(p_prev_uid==0) { //¸¸¾à ±âÁ¸¿¡ ÀúÀåµÈ °ÍÀÌ ¾ø´Ù¸é ù ¹ø° ä³ÎÀ» ¼±ÅÃÇÔ
127                tApp_UcmShortInfo info;
128               
129                if(statusOK==App_Ucm_GetShortInfobyIndex(0, &info)) {
130                        APP_CUR_CH.nUid=info.uid;
131                        APP_CUR_CH.nRF=info.rf;
132                        APP_CUR_CH.nProgramNumber=info.prog_number;
133                }
134                else {
135                       
136                }
137        }
138        else {
139                APP_CUR_CH.nUid=p_prev_uid;
140                APP_CUR_CH.nRF=p_prev_rf;
141                APP_CUR_CH.nProgramNumber=p_prev_program_num;
142        }
143       
144        DHL_OS_Delay(2000);
145
146        App_VideoSetPreferedResolution(App_VideoGetPreferedResolution(), FALSE);
147       
148        /* ¸¸ÀÏ cable mode°¡ Á¸ÀçÇÏ´Ù°¡ ¾ø¾îÁö´Â °æ¿ì°¡ ÀÖÀ» ¼ö ÀÖÀ¸¹Ç·Î
149                ChangeChannelTypeÀ» È£ÃâÇØ¾ß ÇÔ
150        */
151       
152        App_ChangeChannelType(APP_CUR_CH.nChannelType==0?ChannelType_Air:ChannelType_Cable);
153       
154        if (APP_CUR_CH.nUid > 0)
155        {
156                App_TuneChannelByUidEx(APP_CUR_CH.nUid, APP_UID_TUNE_NORMAL);
157        }
158        else 
159        {
160                // cafrii 070426
161                //  program number ±îÁö ÁöÁ¤Çؼ­ Æ©´×Çϵµ·Ï ÇÏÀÚ.
162                App_ChTuneQuickScanAndTune(APP_CUR_CH.nRF, APP_CUR_CH.nProgramNumber, APP_QUICKSCAN_SIGMON);
163        }       
164}
165
166
167static void p_set_standby(BOOL bstandby)
168{
169        if(bstandby) {
170                p_do_before_stadby();
171                p_av_mute(TRUE);
172                p_led_ctrl(FALSE);
173        }
174        else {
175                p_do_before_normal();
176                p_led_ctrl(TRUE);
177                p_av_mute(FALSE);
178        }
179}
180
181
182static void p_fake_micom_task(void* arg)
183{
184        UINT8 rcv_buf[FAKE_MICOM_MSG_LEN];
185        UINT8 send_buf[FAKE_MICOM_MSG_LEN]={MICOM_UART_START_CODE,};
186        DHL_RESULT result;
187        static UINT32 next_ms;
188       
189        UINT8 wakeup_reason=ePOWER_ON_AC;
190       
191        UINT32 temp;
192        DHL_OS_Delay(1000);//BKTEST
193        p_set_standby(TRUE); // BKTODO:
194       
195        while(1) {
196               
197                result=DHL_OS_ReceiveMessage(PINFO(fake_micom_msgq2), rcv_buf, 100);
198               
199                if(result!=DHL_OK) {
200                       
201                        if(next_ms>0 && DHL_OS_GetMsCount()>=next_ms) {
202                               
203                                if(next_ms>3000)
204                                        wakeup_reason=ePOWER_ON_TIMER;
205                                else
206                                        wakeup_reason=ePOWER_ON_RESET;
207                               
208                                send_buf[1]=eCMD_PRIV_SMPS;
209                                send_buf[2]=TRUE;
210                               
211                                DHL_OS_SendMessage(PINFO(fake_micom_msgq1), send_buf, FAKE_MICOM_MSG_LEN);
212                               
213                                next_ms=0;
214                        }
215                       
216                        continue;
217                                //fake micom task´Â ¹º°¡ »õ·Î¿î ¸Þ½ÃÁö¸¦ »ý¼ºÇÏ¿© host¿¡ Àü´ÞÇÒ ÇÊ¿ä ¾øÀ½
218                                //¿Ö³ÄÇϸé IR, Kpd´Â hal ´Ü¿¡¼­ ¾Ë¾Æ¼­ 󸮵DZ⠶§¹®
219                }
220               
221                switch(rcv_buf[1]) { //rcv_buf[1]Àº cmdÀÓ
222                        case eCMD_READYTOSTART:
223                               
224                                p_set_standby(FALSE);
225                               
226                                send_buf[1]=eCMD_WAKEUP_INFO;
227                                send_buf[2]=wakeup_reason;
228                               
229                                DHL_OS_SendMessage(PINFO(fake_micom_msgq1), send_buf, FAKE_MICOM_MSG_LEN);
230                                break;
231                       
232                        case eCMD_SET_IRVENDER:
233                                //ir, venderÀÇ °æ¿ì´Â ¹«½ÃÇصµ »ó°ü ¾øÀ½.
234                                break;
235                       
236                        case eCMD_SET_LED:
237                                //Á÷Á¢ ctrlÇÔ..
238                               
239                                break;
240                       
241                        case eCMD_IAM_ALIVE:
242                                // watchdogÀÌ ±¸ÇöµÇ¾î ÀÖÁö ¾Ê´Ù¸é ¿©±â¼­ resetÀ» °É¾îÁÖ´Â °Íµµ ÁÁÀ»µí..
243                                // ¸¸¾à ÀÌ task°¡ »ì¾ÆÀÖ´Ù¸é..
244                               
245                                break;
246                       
247                        case eCMD_SET_STANDBY:
248                               
249                                send_buf[1]=eCMD_PRIV_SMPS;
250                                send_buf[2]=FALSE;
251                                DHL_OS_SendMessage(PINFO(fake_micom_msgq1), send_buf, FAKE_MICOM_MSG_LEN);
252                               
253                                //AV¸¦ ²÷¾î¾ß ÇÔ..
254                                p_set_standby(TRUE);
255                               
256                                temp=(rcv_buf[2]<<24)|(rcv_buf[3]<<16)|(rcv_buf[4]<<8)|rcv_buf[5];
257                               
258                                if(temp==0) {
259                                        next_ms=0;
260                                        break; //if zero, don't wakeup.
261                                }
262                               
263                                next_ms=DHL_OS_GetMsCount()+temp;
264                                break;
265                       
266                        case eCMD_PRIV_POWER:
267                                // power on...
268                                wakeup_reason=ePOWER_ON_KEY;
269                               
270                                send_buf[1]=eCMD_PRIV_SMPS;
271                                send_buf[2]=TRUE;
272                                DHL_OS_SendMessage(PINFO(fake_micom_msgq1), send_buf, FAKE_MICOM_MSG_LEN);
273                               
274                                break;
275                }
276                DHL_OS_Delay(100);
277        }
278        DHL_OS_SelfDeleteTask();
279}
280
281
282static void p_comm_rcv_cb(UINT8 *pdata, UINT32 size)
283{
284        //DHL_OS_GiveSemaphore(PINFO(sem));
285}
286
287
288static void p_comm_rcv_task(void* arg)
289{
290        UINT8 *prcv_data=NULL;
291
292        DHL_OS_Delay(1500);//just delay for making msgQ
293
294        while(1) {
295               
296                //if(DHL_OK!=DHL_OKDHL_OS_TakeSemaphore(PINFO(sem), 10)) continue; //10ms
297               
298                prcv_data=App_Fnc_ReceiveData(MICOM_UART_START_CODE, MICOM_UART_MSG_LEN, 0);
299               
300                if(!prcv_data) {
301                        DHL_OS_Delay(10);
302                        continue;
303                }
304               
305                dprint(0, "+++ receive data :[0x%x][0x%x:0x%02x,0x%02x,0x%02x,0x%02x]\n", 
306                        prcv_data[0], prcv_data[1], prcv_data[2], prcv_data[3], prcv_data[4], 
307                        prcv_data[5]);
308               
309                switch(prcv_data[1]) {
310                        case eCMD_INPUT_KEYPAD :
311                                {
312                                        UINT32 keycode;
313                                        UINT32 stamp = DHL_OS_GetMsCount();
314                                       
315                                        if(prcv_data[2]==eKPD_RELEASE) {
316                                                UioFilter_Feed(eDHL_UIO_INPUT_KEYPAD, eDHL_KEY_NONE, 
317                                                        DHL_UIO_FLAG_Released, stamp);
318                                                //ÀÏ´Ü ¸·À½.
319                                        }
320                                        else {
321                                                keycode=((0xff^prcv_data[2])<<24)|(prcv_data[2]<<16)|(0x6dcb);
322                                                UioFilter_Feed(eDHL_UIO_INPUT_KEYPAD, keycode, 0, stamp);
323                                        }
324                                }
325                                break;
326                       
327                        case eCMD_INPUT_IR1:
328                                {
329                                        UINT32 ircode=(prcv_data[5]<<24)|(prcv_data[4]<<16)|(prcv_data[3]<<8)|prcv_data[2];
330                                        UINT32 stamp = DHL_OS_GetMsCount();
331                                       
332                                        UioFilter_Feed(eDHL_UIO_INPUT_IR, ircode, 0, stamp);
333                                       
334                                        PINFO(ir_code)=ircode;
335                                        PINFO(ir_ms)=stamp;
336                                }
337                                break;
338                       
339                        case eCMD_INPUT_IR2:
340                                {
341                                        UINT32 stamp = DHL_OS_GetMsCount();
342                                        PINFO(ir_ms)+=prcv_data[2];
343                                       
344                                        //¾à 10ms Á¤µµÀÇ Â÷ÀÌ°¡ ³ª¸é º¸Á¤À» ½ÃµµÇÔ..
345                                        if(PINFO(ir_ms)-stamp>10) PINFO(ir_ms)=stamp;
346                                        else if(stamp-PINFO(ir_ms)>10) PINFO(ir_ms)=stamp;
347                                       
348                                        UioFilter_Feed(eDHL_UIO_INPUT_IR, PINFO(ir_code), 
349                                                DHL_UIO_FLAG_IsRepeat, PINFO(ir_ms));
350                                                //½Ã°£¿¡ ¸ÂÃç¼­ feedingÀ» ÇØ¾ß Çϳª??
351                                }
352                                break;
353               
354                        default:
355                                DMG_SetUserDefined(UD_ID_COMM_CMD, prcv_data[1],
356                                        (prcv_data[2]<<24)|(prcv_data[3]<<16)|(prcv_data[4]<<8)|(prcv_data[5]));
357                }
358               
359               
360               
361               
362               
363               
364        }
365        DHL_OS_SelfDeleteTask();
366}
367
368
369
370UINT8 *App_Fnc_ReceiveData(int start_code, int num_data, UINT32 ms_wait)
371{
372        int i;
373       
374        static UINT8 rcv_buf[MICOM_UART_MSG_LEN*3];
375        static int rcv_idx=0;
376
377        UINT8 *prcv_data=NULL;
378        UINT32 start_ms;
379       
380        if(!App_Fnc_ExistMicom()) {
381                if(DHL_OS_ReceiveMessage(PINFO(fake_micom_msgq1), rcv_buf, ms_wait)==0) {
382                        return rcv_buf;
383                }
384                return NULL;
385        }
386       
387        if(ms_wait==0) ms_wait=1;
388                //Ȥ½Ã ms_count°¡ 0ÀÌ¸é ¾Æ·¡ Äڵ尡 ½ÇÇàµÇÁö ¾ÊÀ» ¼öµµ ÀÖÀ½.
389               
390        for(start_ms=DHL_OS_GetMsCount(); 
391                  DHL_OS_GetMsCount()-start_ms<=ms_wait;
392                  DHL_OS_Delay(10)) {
393                       
394                UINT8 temp[MICOM_UART_MSG_LEN];
395                UINT32 num_read;
396               
397                DHL_COM_Receive(COMM_UART_ID, temp, MICOM_UART_MSG_LEN, &num_read);
398               
399                dprint(1, "com rcv length(%d)\n", num_read);
400               
401                if(num_read==0) continue;
402                       
403                if(num_read+rcv_idx>=MICOM_UART_MSG_LEN*3) { //¹öÆÛ »çÀÌÁ´Ù Å©¸é ¹ö¸²..
404                        dprint(1, "com rcv too big rcv_idx(%d) num_read(%d)\n", rcv_idx, num_read);
405                        continue;
406                }
407
408                for(i=0; i<num_read; i++) {
409                        rcv_buf[rcv_idx++]=temp[i];
410                }
411               
412                if(rcv_idx>=num_data) {
413                        //´Ù ä¿öÁ³À½..
414                        static UINT8 completed_buf[MICOM_UART_MSG_LEN];
415                        int new_idx=0;
416                        int idx_start=rcv_idx;
417                       
418                        //start code ã±â
419                        for(i=0; i<rcv_idx; i++) {
420                                if(rcv_buf[i]==start_code) {
421                                        idx_start=i;
422                                        break;
423                                }
424                        }
425                       
426                        if(rcv_idx-idx_start<MICOM_UART_MSG_LEN) {
427                                //µÚÂÊ ÄÚµå ¾ÕÂÊÀ¸·Î ¿Å±â±â
428                               
429                                if(idx_start==rcv_idx) { //start code°¡ ÀüÇô ¾øÀ½
430                                        rcv_idx=0;
431                                }
432                                else if(idx_start>0) { //¿Å±â´Â °úÁ¤ÀÌ ÇÊ¿äÇÔ.
433                                        for(i=idx_start; i<rcv_idx; i++) {
434                                                rcv_buf[new_idx++]=rcv_buf[i];
435                                        }
436                                        rcv_idx=new_idx;
437                                }
438                               
439                                continue;
440                                //start code¸¦ ã°í º¸´Ï, ³²Àº µ¥ÀÌÅÍ°¡ MICOM_UART_MSG_LENº¸´Ù ÀÛÀ» ¶§
441                                //󸮸¦ ÇÏÁö ¾ÊÀ½.
442                        }
443                       
444                        //ÄÚµå º¹»ç
445                        for(i=0; i<MICOM_UART_MSG_LEN; i++) {
446                                completed_buf[i]=rcv_buf[i+idx_start];
447                        }
448                       
449                        //µÚÂÊ ÄÚµå ¾ÕÂÊÀ¸·Î ¿Å±â±â
450                        for(i=MICOM_UART_MSG_LEN+idx_start; i<rcv_idx; i++) {
451                                rcv_buf[new_idx++]=rcv_buf[i];
452                        }
453                       
454                        rcv_idx=new_idx;
455                       
456                        return completed_buf;
457                }
458               
459        }
460       
461        return NULL;
462}
463               
464
465
466void App_Fnc_SendData(UINT8 *msg, int size)
467{
468        static UINT32 prev_ms=0;
469        UINT32 cur_ms=DHL_OS_GetMsCount();
470       
471        if(prev_ms>0 && cur_ms-prev_ms<INTER_DATA_SEND_DELAY) {
472                DHL_OS_Delay(INTER_DATA_SEND_DELAY-(cur_ms-prev_ms));
473                cur_ms=DHL_OS_GetMsCount();
474        }
475       
476        prev_ms=cur_ms;
477       
478        if(!App_Fnc_ExistMicom())
479                DHL_OS_SendMessage(PINFO(fake_micom_msgq2), msg, size);
480        else
481                DHL_COM_StartTx(COMM_UART_ID, msg, size);
482       
483        dprint(0, "---send_data :[0x%x][0x%x:0x%02x,0x%02x,0x%02x,0x%02x]\n", 
484                msg[0], msg[1], msg[2], msg[3], msg[4], msg[5]);
485}
486
487
488BOOL App_Fnc_ExistMicom()
489{
490        return PINFO(bexist_micom);
491}
492
493//for newby commands
494void App_Fnc_SendData2(UINT8 cmd, UINT8 d1, UINT8 d2, UINT8 d3, UINT8 d4)
495{
496        UINT8 msg[MICOM_UART_MSG_LEN]={MICOM_UART_START_CODE,};
497       
498        msg[1]=cmd;
499        msg[2]=d1;
500        msg[3]=d2;
501        msg[4]=d3;
502        msg[5]=d4;
503       
504        App_Fnc_SendData(msg, MICOM_UART_MSG_LEN);
505}
506
507
508
509void App_Fnc_CommInit()
510{
511        DHL_BOARD_TYPE board;
512        DHL_BOARD_REV rev;
513        //HW ¹öÀü Á¤º¸¸¦ Àоî¿È
514        DHL_SYS_GetBoardTypeVersion(&board, &rev);
515#if 1   
516        PINFO(bexist_micom)=    FALSE; //BKTODO:         (rev>=eREV_010)?TRUE:FALSE;
517       
518        PINFO(sem)=DHL_OS_CreateBinarySemaphore("comm", 0, FALSE);
519       
520        PINFO(rcv_tid)=DHL_OS_CreateTask(p_comm_rcv_task, "commrcv", 
521                        TASK_PRI_APP_COMM, 4096, 0);    //BK 8192 -> 4096
522       
523        if(PINFO(bexist_micom)) {
524                int baudrate = 38400;
525                DHL_COM_Init();
526                DHL_COM_RegisterRxCallback(COMM_UART_ID, p_comm_rcv_cb);
527                DHL_COM_Config(COMM_UART_ID, eDHL_COM_CT_Baudrate, (void *)baudrate);
528        }
529        else {
530                PINFO(mtx)=DHL_OS_CreateMutexSemaphore("comm");
531               
532                PINFO(fake_micom_msgq1)=DHL_OS_CreateMessageQueue("fmicomq1", 0, 4, FAKE_MICOM_MSG_LEN);
533                PINFO(fake_micom_msgq2)=DHL_OS_CreateMessageQueue("fmicomq2", 0, 4, FAKE_MICOM_MSG_LEN);
534       
535                PINFO(fake_micom_tid)=DHL_OS_CreateTask(
536                        p_fake_micom_task, "fakemicom", FAKE_MICOM_TASK_PRIO, 4096, 0); //BK 8192 ->4096
537        }
538#endif
539}
540
Note: See TracBrowser for help on using the repository browser.