bu1923.c

sunplus spca514 cdmp3 源码

#include <macros.h>
#include "BU1923.H"
#include "..\bu2624\bu2624.h"
#include <iom163.h>
//#define pty_dis_type	rds_dis_string[0]
//#define pty_search_type rds_dis_string[1]
//#define pty_search_delay rds_dis_string[2]
//#define 
unsigned char rds_display_type = 0;
unsigned int c_word_val = C_OFF_WORD;
//unsigned char off_word_bit;
unsigned char rds_status = 0;
unsigned long rds_bit_buffer;
unsigned char rds_dis_buffer[10];
unsigned char rds_dis_string[65];
unsigned char rds_dis_control;
unsigned char rds_buffer0_flag;
unsigned int rds_buffer[4];
unsigned char pty_is_searching = 0;
static unsigned long buffer_reg;
static unsigned int syndrome_reg;
//const unsigned int gx = 0x1b9;
//const unsigned int gx_m = 0x31b;
static unsigned char bit_count;
RDS_DATA_STRUCT rds_data;//={0,0,0,0,0,0,0,0};
static unsigned char rds_step = SEARCH_SYC_STEP;
//static unsigned int temp_syc_word;

const unsigned int matrix_H[26]=
{
	0x200,0x100,0x080,0x040,0x020,0x010,0x008,0x004,0x002,0x001,
	0x2dc,0x16e,0x0b7,0x287,0x39f,0x313,0x355,0x376,
	0x1bb,0x201,0x3dc,0x1ee,0x0f7,0x2a7,0x38f,0x31b
};
extern unsigned char is_autosearching;
//extern unsigned char is_search_all_station;
extern unsigned char search_ok;
extern unsigned char search_dir;
extern unsigned char autosrch_step;
unsigned char rds_delay;
void get_rds_block(void);
void rds_syc_detect(void);
void close_rds(void)
{
	GIMSK &= 0x7f;//ENIR_EN3 = 0;  //disable irterupt
}
void rds_init()
{
	//ELVR_LB3 = 1;
	//ELVR_LA3 = 1;               //following edge
	//ICR03 = 20;      //interrupt levels REMOTE CONTROLLED = 19
					//timer = 2
	//EIRR_ER3 = 0;  //clear interrupt request
	//MCUCR |= 0x08; 
    
	rds_data.A_word = 0;
	rds_data.B_word = 0;
	rds_data.C_word = 0;
	rds_data.D_word = 0;
	rds_data.block_count = 0;
	rds_data.word_err_count = 0;
	rds_data.syc_flag = 0;
	rds_data.err_flag = 0;
	rds_step = SEARCH_SYC_STEP;
	rds_bit_buffer = 0;
	rds_delay = 60;
	bit_count = 0;
	rds_status = 0;
	rds_buffer0_flag = 0;
	//ENIR_EN3 = 1;  //enable irterupt
}
void open_rds(void)
{
    MCUCR |= 0x08;
	GIMSK |= 0x80;
	//printf("rds int init completed\n");
}
#pragma interrupt_handler int1_isr:3
void int1_isr(void)
{
	//EIRR_ER3 = 0;
	rds_bit_buffer<<=1;
	if(RDATA)
		rds_bit_buffer |=1;
	if(!rds_data.syc_flag)
	{	
		if(bit_count>=25)
			rds_syc_detect();
		else
			bit_count++;
	}
	else
	{
	//	printf("get_rds_block\n");
		get_rds_block();
	}
	//EIRR_ER3 = 0;
}
/*
unsigned int compute_syc(void)
{
	unsigned int i,syc_value;
	unsigned long k;
	syc_value = 0;
	k= 0x02000000;
	for(i=0;i<26;i++)
	{
		if(rds_buffer&k)
			syc_value ^= matrix_H[i];
		k>>1;
	}
	return syc_value;
}*/

void rds_syc_detect(void)
{
	unsigned char i;
	unsigned long k;
	unsigned int temp_syc_word;
	temp_syc_word = 0;
	//printf("rds sys detect\n");
	k = 0x02000000;
	for(i=0;i<26;i++)
	{
		if(rds_bit_buffer&k)
			temp_syc_word ^= matrix_H[i];
		k>>=1;
	}
	switch(rds_step)
	{
	
		case SEARCH_SYC_STEP:
			switch(temp_syc_word)
			{
				case A_SYC_WORD:
					rds_step = SYC_B_STEP;
					bit_count = 0;
					//printf("get a word\n");
					break;
				case B_SYC_WORD:
					rds_step = SYC_C_STEP;
					bit_count = 0;
				//	printf("get b word\n");
					break;
				case C_SYC_WORD:
				case C1_SYC_WORD:
					rds_step = SYC_D_STEP;
					bit_count = 0;
					if(temp_syc_word == C_SYC_WORD)
					 c_word_val = C_OFF_WORD;
					else
						c_word_val = C1_OFF_WORD;
					//printf("get c word\n");
					break;
				case D_SYC_WORD:
					rds_step = SYC_A_STEP;
					bit_count = 0;
					//printf("get d word\n");
					break;
			}
			break; 
		case SYC_A_STEP:
			if(temp_syc_word!=A_SYC_WORD)
			{
				rds_step = SEARCH_SYC_STEP;
			}
			else
			{
				bit_count = 0;
				rds_step = SYC_B_STEP;
				//rds_data.syc_flag = 1;
			};
			break;
		case SYC_B_STEP:
			if(temp_syc_word == B_SYC_WORD)
			{
				bit_count = 0;
				rds_step = SYC_C_STEP;
				//rds_data.syc_flag = 1;
			}
			else
				rds_step = SEARCH_SYC_STEP;
			break;
		case SYC_C_STEP:
		case SYC_C1_STEP:
			if((temp_syc_word == C_SYC_WORD)||(temp_syc_word == C1_SYC_WORD))
			{
				bit_count = 0;
				rds_step = SYC_D_STEP;
				if(temp_syc_word == C_SYC_WORD)
					c_word_val = C_OFF_WORD;
				else
					c_word_val = C1_OFF_WORD;
				//rds_data.syc_flag = 1;
			}
			else
				rds_step = SEARCH_SYC_STEP;
			break;
		case SYC_D_STEP:
			if(temp_syc_word == D_SYC_WORD)
			{
				bit_count = 0;
				rds_step = FULL_SYCA_STEP;
				rds_data.syc_flag = 1;
				//rds_data.err_flag = 0;
			}
			else
				rds_step = SEARCH_SYC_STEP;
			break;
	}
}

void get_rds_block(void)
{	
	
	if(bit_count==0)
	{
		syndrome_reg = 0;
	}
	
	if(rds_bit_buffer&0x1)
		syndrome_reg ^= matrix_H[bit_count];
	
	bit_count++;
	/*if(bit_count>16)
	{
	}
	if(bit_count<=16)
	{
	};
	if(bit_count=16)
	{
		off_word_bit = 0x200;
	};*/
	
	if(bit_count==26)
	{
		bit_count = 0;
		buffer_reg = (rds_bit_buffer>>10);
		rds_bit_buffer = 0;
		//error check;
		switch(rds_step)
		{
			case FULL_SYCA_STEP:
				if(syndrome_reg!=A_SYC_WORD)
				{
					//rds_data.err_flag |= A_WORD_ERR;
					rds_data.word_err_count++;
				}
				else
				{
					rds_data.A_word = (unsigned int)buffer_reg;
					rds_data.err_flag |= A_WORD_UPDATE;
				};
				rds_step = FULL_SYCB_STEP;	
				break;
			case FULL_SYCB_STEP:
				if(syndrome_reg!=B_SYC_WORD)
				{
					//rds_data.err_flag |= B_WORD_ERR;
					rds_data.word_err_count++;
				}
				else
				{
					rds_data.B_word = (unsigned int)buffer_reg;
					rds_data.err_flag |= B_WORD_UPDATE;
				}
				rds_step = FULL_SYCC_STEP;	
				break;
			case FULL_SYCC_STEP:
				if((syndrome_reg!=C_SYC_WORD)&&(syndrome_reg!=C1_SYC_WORD))
				{
					//rds_data.err_flag |=  C_WORD_ERR;
					rds_data.word_err_count++;
				}
				else
				{
					rds_data.C_word = (unsigned int)buffer_reg;
					rds_data.err_flag |= C_WORD_UPDATE;
				}
				rds_step = FULL_SYCD_STEP;	
				break;
			case FULL_SYCD_STEP:
				if(syndrome_reg!=D_SYC_WORD)
				{
					//rds_data.err_flag |= D_WORD_ERR;
					rds_data.word_err_count++;
					rds_data.err_flag = 0;
				}
				else
				{
					rds_data.D_word = (unsigned int)buffer_reg;
					rds_data.err_flag |= D_WORD_UPDATE;
				};
				rds_step = FULL_SYCA_STEP;	
				
				rds_data.block_count++;
				//if(rds_data.err_flag&0x0f)
					//rds_data.word_err_count++;
				//STORE RDS_BLOCK TO RDS BLOCK BUFFER
				rds_buffer0_flag = rds_data.err_flag;
				rds_buffer[0] = rds_data.A_word;
				rds_buffer[1] = rds_data.B_word;
				rds_buffer[2] = rds_data.C_word;
				rds_buffer[3] = rds_data.D_word;
				//CLEAR ERR_FLAG 
				rds_data.err_flag = 0;
			
				//Judge if losing syndrome; if yes,restart syndrome detecting
				if(rds_data.block_count>=30)
				{
					if(rds_data.word_err_count>20)
					{
						rds_step = SEARCH_SYC_STEP;  //restart search syc word
						rds_data.syc_flag = 0;
						rds_status = 0;
						bit_count = 0;
						syndrome_reg = 0;
					};
					rds_data.word_err_count = 0;
					rds_data.block_count = 0;
				};
	
				break;

		};
	}

}


void rds_handler(void)
{
    register unsigned char temp_buffer0_flag;
	unsigned int temp_buffer[4];
	register unsigned char i;
	
	//if(rds_delay)
	//{
		//rds_delay--;
		//if(!rds_delay)
			//rds_status = 0;
	//};

	//printf("rds handler\n");
	if(pty_is_searching==2)
	{
		if(search_ok)
		{
			if(pty_search_delay)
			{
				if((rds_status&PTY_EXIST)&&(pty_dis_type == pty_search_type))
				{
					pty_is_searching = 0;
					//pty_search_delay = 0;
					return;
				};
				pty_search_delay--;
			//	printf("pty=");debug_out_wx(pty_search_delay);printf("\n");
				if(!pty_search_delay)
				{
					search_ok = 0;
					search_dir = 1;
					is_autosearching = 1;
					autosrch_step = AUTOSRCH_STEP5;
				};
			}
			else
			{
			//	printf("kkk\n");
				pty_search_delay = 67;
			}
		}
	}
	CLI();
	if(rds_buffer0_flag&BD_WORD_UPDATE)
	{
		temp_buffer0_flag = rds_buffer0_flag;
		temp_buffer[0] = rds_buffer[0];
		temp_buffer[1] = rds_buffer[1];
		temp_buffer[2] = rds_buffer[2];
		temp_buffer[3] = rds_buffer[3];
		rds_buffer0_flag = 0;
	}
	else
	{
		SEI();
		return;
	};
	SEI();
	//printf("get_a_block=");debug_out_wx(temp_buffer[0]);printf("\n");
	rds_delay = 60;
	switch(rds_display_type)
	{
		case DIS_PS_NAME:
			//printf("DIS_PS_NAME\n");	
			if((high_byte(temp_buffer,1)&0xf0)==0)  //if((temp_buffer[1]&0xf000)==0)  //GROUP 0
			{
				rds_status = PS_NAME_EXIST;
					//printf("is 0 group\n");
				i = low_byte(temp_buffer,1)&0x03;//((unsigned char)temp_buffer[1])&0x03;
					//printf("temp_buffer[2]=");debug_out_wx(temp_buffer[2]);printf("\n");
					//printf("temp_buffer[4]=");debug_out_wx(temp_buffer[4]);printf("\n");
				i <<=1;
				rds_dis_buffer[i] = high_byte(temp_buffer,3);//(unsigned char) (temp_buffer[3]>>8);
				i++;
				rds_dis_buffer[i] = low_byte(temp_buffer,3);
				//if(i<2)
				rds_dis_control |=(1<<i);
				//else
					//rds_dis_control |=(1<<i);
					//printf("rds_display_contr=");debug_out_wx(rds_dis_control);printf("\n");	
				if((rds_dis_control==0xaa)&&(i>6))
				{
					
					for(i=0;i<8;i++)
					{
						rds_dis_string[i] = rds_dis_buffer[i];
					}
					rds_dis_string[8] = '\0';
					rds_dis_control = 0;	
						//printf(rds_dis_string);
				};
				
			}
			break;
		case DIS_PTY: //ALL_GROUP
			pty_dis_type = ((unsigned char)(temp_buffer[1]>>5))&0x1f;
			rds_status = PTY_EXIST;
			//pty_dis_type = temp_val&0x1f;
			break;
		case DIS_RT:
			if((high_byte(temp_buffer,1)&0xf0)==0x20) //GROUP 2 A/B
			{
			   
				rds_dis_buffer[0] = high_byte(temp_buffer,1)&0xf8;
				if(rds_dis_buffer[0]!=rds_dis_buffer[1])
				{
					rds_dis_buffer[1]=rds_dis_buffer[0];
					rds_dis_buffer[2] = 0;
					for(i = 0;i<65;i++)
						rds_dis_string[i] = 0x0d;
				};
				rds_status = RT_EXIST;
				i =(low_byte(temp_buffer,1)&0x0f);
				
				if(high_byte(temp_buffer,1)&0x08)  //B VERSION
				{
					i <<= 1;
					rds_dis_string[i]=high_byte(temp_buffer,3);
					i++;
					rds_dis_string[i]=low_byte(temp_buffer,3);
				}
				else   //A VERSION
				{
				    i <<= 2;
					rds_dis_string[i]=high_byte(temp_buffer,2);
					i++;
					rds_dis_string[i]=low_byte(temp_buffer,2);
					i++;
					rds_dis_string[i]=high_byte(temp_buffer,3);
					i++;
					rds_dis_string[i]=low_byte(temp_buffer,3);
		

				};
			};
			break;
		case DIS_CT:
			if((high_byte(temp_buffer,1)&0xf8)==0x40) //(temp_buffer[1]&0xf800)==0x4000 //GROUP 4A
			{
				if(temp_buffer0_flag&C_WORD_UPDATE)  //B\C\D
				{
					rds_status = CT_EXIST;
					rds_dis_buffer[1] = (unsigned char)((temp_buffer[3]&0x0fc0)>>6); //minute
					i = (high_byte(temp_buffer,3)&0x0f0)>>4;

					rds_dis_buffer[2] =((((low_byte(temp_buffer,2)&0x01)<<4)|i)<<1); // half hour
					//rds_dis_buffer[2] <<= 1; //half hour
					rds_dis_buffer[3] = (low_byte(temp_buffer,3)&0x1f); //local offer half hour
					if(low_byte(temp_buffer,3)&0x20)
					{
						if(rds_dis_buffer[2] >= rds_dis_buffer[3])
							rds_dis_buffer[2] -= rds_dis_buffer[3];
						else
							rds_dis_buffer[2] =((48+rds_dis_buffer[2])-rds_dis_buffer[3]);
					}
					else
					{
						rds_dis_buffer[2] += rds_dis_buffer[3];
					};
					rds_dis_string[0] = rds_dis_buffer[2] >>1;  //hour
					if(rds_dis_buffer[2]&0x01)
					  rds_dis_buffer[1] += 30;  //minute
					rds_dis_string[1] = rds_dis_buffer[1]%60;  //minute
					if(rds_dis_buffer[1] >= 60)
						rds_dis_string[0]++;  //hour+1;
					rds_dis_string[0] %= 24;
				}
			};
			break;
	};
	//
}