⭐ 欢迎来到虫虫下载站! | 📦 资源下载 📁 资源专辑 ℹ️ 关于我们
⭐ 虫虫下载站

📄 cl680.c

📁 这是用W77E58编写的控制GSM模块
💻 C
字号:
/************************************************************************************
*                            MPEG control code                                                                                          *                                       
*                                                                                                                                                 * 
*use: cl680                                                                                                                                  * 
*       vcd1.1                                                                                                                                * 
************************************************************************************/

#define MPEG_DigestReady                0
#define MPEG_DisplayDigest              2
#define MPEG_DisplayGraphics          4
#define MPEG_Logo                             6



unsigned char code mpeg_cmd[]=
{

  
     0x00,0x1D,                                   //MPEG_DigestReady();

     0x04,0x1B,                                   //MPEG_DisplayDigest();
     //0x00,0x00,
     //0x00,0x00,
     //0x00,0x00,
     //0xff,0xff,



     0x06,0x17,                                   //MPEG_DisplayGraphics();

     0x03,0x0c,                                   //MPEG_DisplayRomStill();
     0x00,0x00,
     0x80,0x00,
     0x3e,0x30,
     0x00,0x00,
     
     0x00,0x0C,                                   //MPEG_DisplayStill();
     0x01,0x22,                                   //MPEG_PitchShift();
     0x00,0x0B,                                    //MPEG_Play();
     0x02,0x13,                                    //MPEG_SetStreams();
     0x00,0x05,                                    //MPEG_SetVideoFormat();
     0x01,0x85,                                    //MPEG_SetVolume();
     0x01,0x09,                                    //MPEG_Slow();
     //0x00,0x00,                              
   
}






void MPEG_DigestReady(void)
{


       MPEG_write_command(MPEG_DigestReady,1);
       



}



void MPEG_SetFormt(unsigned char video_format)
{


       MPEG_write(MPEG_ADDR_VIDEO_FORMAT,video_format );
       MPEG_write_command(MPEG_SetVideoFormat,0,0,0,0,0,0,1);

}


void MPEG_Pitch(unsigned char pitchshift)
{

       if(pitchshif>7)
          MPEG_write_command(MPEG_PitchShift,pitchshift -7,0,0,0,0,2);
       else
           MPEG_write_command(MPEG_PitchShift,(0xffff-pitchshift+1) & 0xffff ,0,0,0,0,2);
}
	


#define MPEG_ADDR_CMD_ID     (MPEG_ADDR_DRAM_NAUTO|0x00C8)
#define MPEG_ABORT                  0x801A
#define MPEG_RESET                  0x8000

void MPEG_Abort(void)
{
        while(MPEG_read(MPEG_ADDR_CMD_ID) );
        MPEG_write(MPEG_ADDR_CMD_ID,MPEG_ABORT);
        
}

void MPEG_Reset(void)
{
            
        while(MPEG_read(MPEG_ADDR_CMD_ID) );
        MPEG_write(MPEG_ADDR_CMD_ID,MPEG_RESET);
    
}



void MPEG_Logo(void)
{

               
                MPEG_write_command(MPEG_Logo,0,0,0,0,0,0,5);
      	  

}






unsigned int MPEG_read(unsigned long ReadAddr)
{
         unsigned char i;
         unsigned int   Data;

         MPEG_write_address(ReadAddr);
         
         MPEG_HDAT_HIGH;                         //issue R/W =1
	  MPEG_HCK_LOW;
	  MPEG_HCK_HIGH;
	  MPEG_HSEL_LOW;

         for(i=0;i<255;++)
        {
             if(MPEG_HRDY_HIGH) break;	
         
        } 	
        if(i==255)return 0;

        for(i=0;i<16;i++)
        {
              
              MPEG_HCK_LOW;
              Data |= MPEG_HDAT_HIGH?(1:0);
              
              MPEG_HCK_HIGH;
              Data <<= 1;
        }
        MPEG_HSEL_HIGH;

        return Data;

}

unsigned int MPEG_write(unsigned long WriteAddr,unsigned int WriteData)
{
         unsigned char i;
        
         for(i=0;i<255;++)
         {
             if(MPEG_HRDY_HIGH) break;	
         
         } 	
         if(i==255)return 0;


         MPEG_write_address(WriteAddr);
         
         MPEG_HDAT_LOW;                         
	  MPEG_HCK_LOW;
	  MPEG_HCK_HIGH;                                  //ISSUE R/W = 0;
	  MPEG_HSEL_LOW;

        
        for(i=0;i<16;i++)
        {
              WriteData <<= 1;
              MPEG_HDAT =(bit)( WriteData & 0x80);
              MPEG_HCK_LOW;
              MPEG_HCK_HIGH;
              
        }
        MPEG_HSEL_HIGH;

        return 1;

}



char MPEG_write_address(unsigned long Waddress)
{

        unsigned char i,BAddr;

	 MPEG_HSEL_HIGH;

        BAddr = Waddress >> 16;
        if((BAddr & 0xc0) == MPEG_ADDR_GBUS)
        {
             
	   // For write GBUS address, only output 8 bits
          // for now, assume that GBUS address will be in A21 - A16
	   // fill A23, A24 with zeros
               BAddr  & = 0x3f;
               for(i=0;i<8;i++)
               {
                     BAddr <<= 1;
                     MPEG_HDAT = (bit)(BAddr & 0x80);
                     MPEG_HCK_LOW;
	              MPEG_HCK_HIGH;
                     
               }

               MPEG_HDAT_HIGH;                  //issue    G/M# =1
	        MPEG_HCK_LOW;
	        MPEG_HCK_HIGH;
        }
        else
        { 	

               WAddress  << = 2;
               for(i=0;i<22;i++)
               {
                     WAddress <<= 1;
                     MPEG_HDAT = (bit)(BAddr & 0x80);
                     MPEG_HCK_LOW;
	              MPEG_HCK_HIGH;
                     
               }

               MPEG_HDAT_LOW;                  //issue    G/M# =0
	        MPEG_HCK_LOW;
	        MPEG_HCK_HIGH;
               //if autoinc bit is set, then increment address

               if((BAddr & 0xc0) == MPEG_ADDR_DRAM_AUTO)
                    MpegAddress++;

        }	

}



void MPEG_write_command(unsigned char cmd_id,unsigned int cmd_p0,unsigned int cmd_p1,unsigned int cmd_p2,unsigned int cmd_p3,unsigned int cmd_p4,unsigned int cmd_p5,unsigned char cmd_count)
{
         unsigned char i;
         unsigned int Data;
         unsigned int temp[];
         temp[0] = cmd_p1;
         temp[1] = cmd_p2;
         temp[2] = cmd_p3;
         temp[3] = cmd_p4;
         temp[4] = cmd_p5;

         
         MpegAddress = MPEG_ADDR_DRAM_NAUTO;
         Data = MPEG_read(MPEG_CMDF_WRITE);                                                    //Read out write pointer,shuold be 0x80--0xc0;
         if((Data & 0x00ff) == CMDF_SADDR) Data = ADDR_CMD_FIFO_START;        //ADDR_CMD_FIFO_START = 0x80;
                                                                                                                          //CMDF_SADDR = 0xc0;
         MpegAddress |= Data;
         for(i=0;i<cmd_count;i++)
         {

                   if(cmd_id == MPEG_SetVoume ||cmd_id == MPEG_Slow||)
                       Data = temp[i];
                   else
                       Data = mpeg_cmd[i+cmd_id];


                   MPEG_write(MpegAddress,Data);
                   MpegAddress++;
                   if((MpegAddress & 0xffff) == CMDF_SADDR) Data = ADDR_CMD_FIFO_START;

         }
         }
         MPEG_write(MPEG_CMDF_WRITE,(unsigned int)MpegAddress);

}

char MPEG_read_para(void)
{
        

              MpegMinSec       =  MPEG_read(MPEG_ADDR_MINSEC);           //0x00F8 Minutes,seconds
              MpegFCh            = MPEG_read(MPEG_ADDR_FCh);                 //0x00FA FileNumber,ChanelNumber
              MpegCodeInfo    = MPEG_read(MPEG_ADDR_CODING);          //0x00FB CodingInfo
  
}


void MPEG_servo(void)
{
         unsigned int  MpegMinSec,MpegFCh,MpegCodeInfo;


         switch(mpeg_task)
         {
                    case MPEG_IDLE:
                             MpegMinSec       =  MPEG_read(MPEG_ADDR_MINSEC);           //0x00F8 Minutes,seconds
                             MpegFCh            = MPEG_read(MPEG_ADDR_FCh);                 //0x00FA FileNumber,ChanelNumber
                             MpegCodeInfo    = MPEG_read(MPEG_ADDR_CODING);          //0x00FB CodingInfo

                             if(MpegMinSec)
                             {

                                     switch((MpegFCh>>8) & 0xff)
                                    {
                                            case 0:
                                                     if(!MPEG_STILL_flag)
                                                     {
                                                     	  MPEG_STILL_flag = 1;
                                                          mpeg_task = MPEG_VCD20_PROC; 
                                                     }
                                                     break;
                                            case 1:
                                                     if(MPEG_STILL_flag)
                                                     {

                                                           if((MpegFCh & 0xff) ==1)
                                                           {
                                                           	if(( (MpegCodeInfo & 0xff) == 0x7f)||( (MpegCodeInfo & 0xff) == 0x0f))
                                                                     mpeg_task = MPEG_VCD11_PROC;
                                                               

                                                           }//if((MpegFCh & 0xff) ==1)
                                                           
                                                     }//if(MPEG_STILL_flag)	
                                                     else
                                                     {
                                                              if(( MpegMinSec>>8) && 0xff){
                                                                      if((((MpegFCh & 0xff) ==2) && ((MpegCodeInfo & 0xff) ==0x1F))||(((MpegFCh & 0xff) ==3) && ((MpegCodeInfo & 0xff) ==0x3F)))
                                                                                mpeg_task = MPEG_VCD20_PROC;
                                                              }
                                                              else
                                                              {
                                                                    if((MpegMinSec >= 3) && (MpegMinSec <6))mpeg_task =MPEG_VCD20_PROC;
                                                                    else
                                                                    if(MpegMinSec >= 6){

                                                                         if((((MpegFCh & 0xff) ==2) && ((MpegCodeInfo & 0xff) ==0x1F))||(((MpegFCh & 0xff) ==3) && ((MpegCodeInfo & 0xff) ==0x3F)))
                                                                                mpeg_task = MPEG_VCD20_PROC;

                                                                    }	

                                                                     
                                                              }

                                                              
                                                          
                                                     }
                                                     break;
                                            default:
                                                     mpeg_task = MPEG_VCD11_PROC;
                                                     break;
                                            	
                                     }//switch((MpegFCh>>8) & 0xff)
                                     

                                         
                                     	

                             }//if(MpegMinSec)
                             else
                             {           //MpegMinSec = 0;
                             
                                                             

                             
                             }
                             break;
                    	        
                    case MPEG_VCD11_PROC:
                             if(!MPEG_STILL_flag) break;
                             MPEG_STILL_flag = 0;
                             MPEG_Abort();
                             mpeg_task = MPEG_STREAM_PLAY;                             
                             break;
                    case MPEG_VCD20_PROC:
                             if(MPEG_STILL_flag) break;
                             MPEG_STILL_flag = 1;
                             MPEG_Abort();
                             mpeg_task = MPEG_STREAM_PLAY;                             
                             break;
                    case MPEG_STREAM_PLAY:
                             if(MPEG_STILL_flag) {
                                 MPEG_write_command(MPEG_SetStream,0x00E1,0x00C0,0,0,0,3);
                                 MPEG_write_command(0x0C,0,0,0,0,0,3);
                             }
                             else
                             {
                                 MPEG_write_command(MPEG_SetStream,0x00E0,0x00C0,0,0,0,3);
                                 MPEG_write_command(0x0D,0,0,0,0,0,3);
                                 
                             }


                             mpeg_task = MPEG_IDLE;                             
                             break;
                    



                    case MPEG_RESET_START:
                             MPEG_RESET_HIGH;
                             mpeg_task++;
                    	        break;
                    case MPEG_RESET_ACTION:
                             MPEG_RESET_LOW;
                             mpeg_task++;
                    	        break;
                    case MPEG_RESET_END:
                             MPEG_RESET_HIGH;
                             mpeg_task = 0;
                    	        break;
                    case MPEG_SLOW_ACTION:
                             MPEG_write_command(MPEG_SLOW,slow_state++,0,0,0,0,0,2);
                    	        break;
                    
                    case MPEG_PLAY_START:
                             MPEG_Abort();
                             MPEG_write_command(MPEG_Play,1);
                             mpeg_task++;
                             break;
                    case MPEG_PLAY_CHECK:
                    	       if(MPEG_read(MPEG_ADDR_PROC_STATE) == MPEG_Play)mpeg_task = MPEG_IDLE;
                    	       else mpeg_task = MPEG_PLAY_START;
                            break;
                    

              

                    default:
                    	        break;
              



         }//switch(mpeg_task)
         


}





⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -