mst705Ȧ

MST705源代码

        for( i=0;i<3;i++)
        {
            //AUTO_PRINTF("\r\n i= %x ",i);
            #if ENABLE_FW_ADC_OFFSET
            CD_data_min=0xff;
            CD_data_max=0x00;
            CD_data_sum=0x00;
            #endif//#if ENABLE_FW_ADC_OFFSET
            msWriteByte(BK0_CA_ATFCHSEL, i);
            for(j=0;j<READ_BACK_TIME;j++)
            {
                Delay1ms_WatchDog(ucVSyncTime);
                for( wCVBCnt = 0; wCVBCnt< 2000; wCVBCnt++ )
                {
                    if( (msReadByte(BK0_0F_ASCTRL)&_BIT7) != 0 )
                        break;
                }

                CD_data_temp =  msReadByte(BK0_CD_ATGVALUE);
                #if ENABLE_FW_ADC_OFFSET
                //AUTO_PRINTF("  %x  ",CD_data_temp);
                CD_data_sum += CD_data_temp;
                if(CD_data_temp < CD_data_min ) CD_data_min = CD_data_temp;
                if(CD_data_temp > CD_data_max ) CD_data_max = CD_data_temp;
                #endif//#if ENABLE_FW_ADC_OFFSET
            }
#if ENABLE_FW_ADC_OFFSET
            CD_data_sum -= CD_data_min ;
            CD_data_sum -= CD_data_max ;
            CD_data_temp = CD_data_sum/(READ_BACK_TIME-2);
            //AUTO_PRINTF(" tf = %x  ",CD_data_temp);
#endif//#if ENABLE_FW_ADC_OFFSET
            if(i==0 ) ucResultR= CD_data_temp;
            else if ( i==1) ucResultG= CD_data_temp;
            else if ( i==2) ucResultB= CD_data_temp;

        }
    
#if ENABLE_FW_ADC_OFFSET
        if(ucResultR>0 ) RO_init=5;
        if(ucResultG>0 ) GO_init=5;
        if(ucResultB>0 ) BO_init=5;
#endif//#if ENABLE_FW_ADC_OFFSET
        printf(" 0x%x",dat[3]);
        printf(" 0x%x  ",ucResultR);
        printf(" 0x%x ",dat[4]);
        printf(" 0x%x  ",ucResultG);
        printf(" 0x%x ",dat[5]);
        printf(" 0x%x    ",ucResultB);

#if 0
        printf("\r\nPr_OF %x ",dat[3]);
        printf(",Pr_Min %x ",ucResultR);
        printf("\r\nY_OF %x ",dat[4]);
        printf(",Y_Min %x ",ucResultG);
        printf("\r\nPb_OF %x ",dat[5]);
        printf(",Pb_Min %x \r\n",ucResultB);
#endif
        #if ENABLE_FW_ADC_OFFSET
        // if( ucResultR == R_target_min)   

        if(  ( ucResultR >= (R_target_min) ) && (ucResultR <= (R_target_min+Offset_target_delta)  ) )  
            ucStatus |= _BIT7;
        else
            ucStatus &= ~_BIT7;

        if( ucResultG == G_target_min)   
            if(  ( ucResultG >= (G_target_min) ) && (ucResultG <=  (G_target_min+Offset_target_delta) ) )  
                ucStatus |= _BIT6;
            else
                ucStatus &= ~_BIT6;

        // if( ucResultB == B_target_min)   
        if(  ( ucResultB >= (B_target_min)  ) && (ucResultB <= (B_target_min+Offset_target_delta)  ) )  
            ucStatus |= _BIT5;
        else
            ucStatus &= ~_BIT5;

        // Red - Pr
        if ( !(ucFlowFlag&_BIT0) )
        {
            if (_bit7_(ucStatus))
            {
                if(IsVGAInUse())
                    g_PcSetting.AdcRedOffset= dat[3]; // Save your ADC value
                else
                    g_YPbPrSetting.AdcRedOffset= dat[3]; // Save your ADC value
                ucFlowFlag |= _BIT0;
                // printf("\r\nPrO OK");
            }
            else
            {
                if( ucResultR ==0 && RO_init<5 ) 
                {
                    dat[3] +=( 0x600 / RO_init );
                    RO_init++;
                }
                else
                {
                    dat[3] += ((signed)(R_target_min - ucResultR))*gainstep;
                }
                if(dat[3] >0x8000 )  dat[3]+=0x2000;
                if(dat[3] >=0x2000 &&  dat[3] <0x8000)  dat[3]-=0x2000;
            }
        }
    
        // Green - Y
        if ( !(ucFlowFlag&_BIT2) )
        {
            if (_bit6_(ucStatus))
            {
                if(IsVGAInUse())
                    g_PcSetting.AdcGreenOffset= dat[4]; // Save your ADC value
                else
                    g_YPbPrSetting.AdcGreenOffset= dat[4]; // Save your ADC value
                ucFlowFlag |= _BIT2;
                //printf("\r\nYO OK");
            }
            else
            {
                if( ucResultG ==0 && GO_init <5 ) 
                {
                    dat[4] += ( 0x600 /GO_init )  ;
                    GO_init++;
                }
                else
                {
                    dat[4] += ((signed)(G_target_min - ucResultG))*gainstep;
                }
                if(dat[4] >0x8000 )  dat[4]+=0x2000;
                if(dat[4] >=0x2000 &&  dat[4] <0x8000)  dat[4]-=0x2000;
            }
        }
        
        // Blue - Pb
        if ( !(ucFlowFlag&_BIT4) )
        {
            if (_bit5_(ucStatus))
            {
                if(IsVGAInUse())
                    g_PcSetting.AdcBlueOffset= dat[5]; // Save your ADC value
                else
                    g_YPbPrSetting.AdcBlueOffset= dat[5]; // Save your ADC value
                ucFlowFlag |= _BIT4;
                //printf("\r\nPbO OK");
            }
            else
            {
                if( ucResultB ==0 && BO_init <5 ) 
                {
                    dat[5] += ( 0x600/BO_init);
                    BO_init++;
                }
                else
                {
                    dat[5] += ((signed)(B_target_min - ucResultB))*gainstep;
                }
                if(dat[5] >0x8000 )  dat[5]+=0x2000;
                if(dat[5] >=0x2000 &&  dat[5] <0x8000)  dat[5]-=0x2000;
            }
        }

	#endif//#if ENABLE_FW_ADC_OFFSET
       
//////////////////////////////////////////////////////////////////////////////////
// Tune Gain
//////////////////////////////////////////////////////////////////////////////////

        for( i=0;i<3;i++)
        {
            // printf("\r\n gi= %x ",i);
            CD_data_min=0xff;
            CD_data_max=0x00;
            CD_data_sum=0x00;
            msWriteByte(BK0_CA_ATFCHSEL, i+3);
            for(j=0;j<READ_BACK_TIME;j++)
            {
                Delay1ms_WatchDog(ucVSyncTime);
                for( wCVBCnt = 0; wCVBCnt< 2000; wCVBCnt++ )
                {
                    if( (msReadByte(BK0_0F_ASCTRL)&_BIT7) != 0 )
                        break;
                }
                CD_data_temp =  msReadByte(BK0_CD_ATGVALUE);
                // printf("  %x  ",CD_data_temp);
                CD_data_sum += CD_data_temp;
                if(CD_data_temp < CD_data_min ) CD_data_min = CD_data_temp;
                if(CD_data_temp > CD_data_max ) CD_data_max = CD_data_temp;
            }
            CD_data_sum -= CD_data_min ;
            CD_data_sum -= CD_data_max ;
            CD_data_temp = CD_data_sum/(READ_BACK_TIME-2);
            //   printf(" gtf = %x  ",CD_data_temp);
            if(i==0 )
            {
                ucResultR= CD_data_temp -ucResultR ;
                if(CD_data_temp==0xff) ucResultR=0xff;
            }
            else if ( i==1) 
            {
                ucResultG= CD_data_temp-ucResultG ;
                if(CD_data_temp==0xff) ucResultG=0xff;
            }
            else if ( i==2)
            {
                ucResultB= CD_data_temp -ucResultB ;
                if(CD_data_temp==0xff) ucResultB=0xff;
            }
        }

        if(ucResultR<0xff ) RG_init=5;
        if(ucResultG<0xff ) GG_init=5;
        if(ucResultB<0xff ) BG_init=5;

        printf(" 0x%x",dat[0]);
        printf(" 0x%x  ",ucResultR);
        printf(" 0x%x ",dat[1]);
        printf(" 0x%x  ",ucResultG);
        printf(" 0x%x ",dat[2]);
        printf(" 0x%x  ",ucResultB);
	
	#if 0
        printf("\r\nPr_G %x ",dat[0]);
        printf(",Pr_Act %d ",ucResultR);
        printf("\r\nY_G %x ",dat[1]);
        printf(",Y_Act %d ",ucResultG);
        printf("\r\nPb_G %x ",dat[2]);
        printf(",Pb_Act %d \r\n",ucResultB);
	#endif

        if((ucResultR >= (R_target_max-Gain_target_delta) ) && (ucResultR <= (R_target_max)))  // Range: 0x10~0xF0
        {
            ucStatus |= _BIT4;
        }
        else
        {
            ucFlowFlag &= ~(_BIT1+_BIT0);
            ucStatus &= ~_BIT4;
        }

        if((ucResultG >= (G_target_max-Gain_target_delta) ) && (ucResultG <= (G_target_max) ))  // Range: 0x00~0xDB
        {
            ucStatus |= _BIT3;
        }
        else
        {
            ucFlowFlag &= ~(_BIT3+_BIT2);
            ucStatus &= ~_BIT3;
        }

        if((ucResultB >= (B_target_max-Gain_target_delta) ) && (ucResultB <= (B_target_max)))  // Range: 0x10~0xF0
        {
            ucStatus |= _BIT2;
        }
        else
        {
            ucFlowFlag &= ~(_BIT5+_BIT4);
            ucStatus &= ~_BIT2;
        }

        // Red - Pr
        if ( !(ucFlowFlag&_BIT1) )
        {
            if (_bit4_(ucStatus))
            {
                if(IsVGAInUse())
                    g_PcSetting.AdcRedGain= dat[0]; // Save your ADC value
                else
                    g_YPbPrSetting.AdcRedGain= dat[0]; // Save your ADC value
                ucFlowFlag |= _BIT1;
                //   printf("\r\nPr OK");
            }
            else
            {
                //ucGainR++;
                if(ucResultR==0xff&& RG_init<5)
                {
                dat[0] -= (0x400/RG_init) ;
                RG_init++;
                }
                else
                dat[0] += ((signed)(R_target_max - ucResultR))*gainstep;
                ucFlowFlag &= ~_BIT1;
            }
        }

        // Green - Y
        if ( !(ucFlowFlag&_BIT3) )
        {
            if (_bit3_(ucStatus))
            {
                if(IsVGAInUse())
                    g_PcSetting.AdcGreenGain= dat[1]; // Save your ADC value
                else
                    g_YPbPrSetting.AdcGreenGain= dat[1]; // Save your ADC value
                ucFlowFlag |= _BIT3;
                //  printf("\r\nY OK");
            }
            else
            {
                //ucGainG++;
                if(ucResultG==0xff&& GG_init<5)
                {
                    dat[1] -= (0x400/GG_init) ;
                    GG_init++;
                }
                else
                    dat[1] += ((signed)(G_target_max - ucResultG))*gainstep;
            }
        }

        // Blue - Pb
        if ( !(ucFlowFlag&_BIT5) )
        {
            if (_bit2_(ucStatus))
            {
                if(IsVGAInUse())
                    g_PcSetting.AdcBlueGain= dat[2]; // Save your ADC value
                else
                    g_YPbPrSetting.AdcBlueGain= dat[2]; // Save your ADC value
                ucFlowFlag |= _BIT5;
                // printf("\r\nPb OK");
            }
            else
            {
                //ucGainB++;
                if(ucResultB==0xff&& BG_init<5)
                {
                    dat[2] -= (0x400/BG_init) ;
                    BG_init++;
                }
                else
                    dat[2] += ((signed)(B_target_max - ucResultB))*gainstep;
                ucFlowFlag &= ~_BIT5;
            }
        }
        
        #if ENABLE_FW_ADC_OFFSET	
        if ( ucFlowFlag == 0x3F )
            break;
        #else
        if ( ucFlowFlag == 0x2A )
            break;
        #endif
    }
    
    msWriteByte(BK0_00_REGBK, REG_BANK_SCALER);
    msWriteByte(BK0_C9_ATGST, 0x00);
    msWriteByte(BK0_CA_ATFCHSEL, 0x00);

    msWriteByte(BK0_00_REGBK, ucBank);
    printf(" 0x%x  ",ucFlowFlag);
#if ENABLE_FW_ADC_OFFSET	
    if ( ucFlowFlag == 0x3F )
#else
    if ( ucFlowFlag == 0x2A )
#endif
    {
        printMsg("\r\n Auto Color Finish!");
        return TRUE;
    }
    else
    {
        printMsg("\r\n  Auto Color Failed!");
        return FALSE;
    }
}
#endif