data.c

有线电视系统前端设备复用器原代码。 用语接受卫星信号

/*------------------------------------------------------------------------------*/
/* Project Name: Multiplexer of MPEG-II                                         */
/* Module  Name: Data Process                                                   */
/* Purpose     :                                                                */
/* Author      : LingYiChuan                                                    */
/* Date        : 2000/9/20                                                      */
/* Version     : 1.0                                                            */
/* Copyright HignSun Dvision, All Right Reservered.                             */
/*------------------------------------------------------------------------------*/

#include "psos.h"
#include "icontrol\mpc8xx.h"
#include "constant.h"
#include "structure.h"
#include "command.h"
#include "tspack.h"

#include "sys_conf.h"

User_FIFO FIFO;

unsigned long TsCount=0;
extern void my_Delay(unsigned long int dly_ms);
extern unsigned char SystemState;
extern System_Data   SystemData;
unsigned char OldUserChannelType;

extern unsigned char UserChannelAlarm;

extern unsigned long ConfigRemapTable(void);


void UserDataLed(int H)
{
	 if(H)
		 M_PortBDataReg&=0xFFFFFFEF; 
	 else
		 M_PortBDataReg|=0x00000010;  
}

void TK_UserSend(void)
{

	unsigned char buf[256*4];
	UARTBLOCK     Uart;
	unsigned long ret;
	unsigned long rc;
	int           i;

	for(i=0;i<256*4;i++)
		buf[i]=i&0xFF;

	for(;;)
	{
		/* Uart.port=PORTRS232; */

		Uart.port=PORTRS422; 

		Uart.pData=(unsigned char *)buf;
		Uart.length=256*4;

		/* rc=de_write(DEV_RS232,&Uart,&ret); */

		rc=de_write(DEV_RS422,&Uart,&ret); 

		if(rc)
		{
			Display("de_write error, errno=0x%x \n",rc);
			my_Delay(20);/*by xu*/
			continue;
		}
		else
		{
			Display("User channel data send. \n");
		}

		my_Delay(20);/*by xu*/
	}
}

void TS_Send(TSPDAT_T Ts)
{
	int i;
	unsigned char *p;
	p=(unsigned char *)&Ts;

	for(i=0;i<188;i++)
		USER_DATA_WRITE_FIFO_REG=*p++;

	USER_DATA_FRAME_END_REG=0xFF;

	TsCount++;
}


void SetUserTimerPeriod(void)
{
	/*
	unsigned long   BaudList[10]={2400,4800,9600,19200,38400,57600,115200,230400,460800,921600};
	unsigned char pval;

	pval=BaudList[SystemData.UserChannel.BaudRate] / (100 * 1024);

	if(pval<=0) pval=1;

	USER_CHANNEL_TIMRER_REG=256/pval -1;

	*/
}


unsigned long FIFO_Get(unsigned char *Buf, unsigned char Len)
{
	int           i;
	unsigned long RetLen;

	if(FIFO.Lock)
		return -1;
	else
	{
		FIFO.Lock=1;

		if(FIFO.pGet<FIFO.pPut)
		{
			/*-----------------------------------------------*/
			/* FIFO 中有足够的数据                           */
			/*-----------------------------------------------*/
			if(Len<(FIFO.pPut - FIFO.pGet))
			{
				for(i=0;i<Len;i++)
					*(unsigned char *)(Buf + i)=FIFO.Buf[FIFO.pGet + i];

				FIFO.pGet   += Len;
				FIFO.Length -= Len;

				FIFO.Lock=0;

				return Len;
			}
			/*----------------------------------------------*/
			/* FIFO 中没有足够的数据                        */
			/*----------------------------------------------*/
			else
			{
				for(i=0;i<FIFO.pPut - FIFO.pGet;i++)
					*(unsigned char *)(Buf + i)=FIFO.Buf[FIFO.pGet + i];

				RetLen      =FIFO.pPut - FIFO.pGet;

				FIFO.pGet   = FIFO.pPut;
				FIFO.Length = 0;

				FIFO.Lock   = 0;

				return RetLen;
			}
		}
		else if(FIFO.pGet==FIFO.pPut)
		{

			if(FIFO.Length==0)
			{
				FIFO.Lock=0;
				return -1;
			}
			else
			{
				if(Len<=(FIFO_LENGTH - FIFO.pGet))
				{
					for(i=0;i<Len;i++)
						*(unsigned char *)(Buf + i)=FIFO.Buf[FIFO.pGet + i];

					FIFO.pGet   += Len;

					FIFO.Length -= Len;

					FIFO.Lock    =0;

					return Len;
				}
				/*------------------------------------------------------*/
				/*有一部分数据在FIFO的头部                              */
				/*------------------------------------------------------*/
				else
				{
					for(i=0;i<FIFO_LENGTH - FIFO.pGet;i++)
						*(unsigned char *)(Buf + i)=FIFO.Buf[FIFO.pGet + i];

					for(i=0;i<Len-(FIFO_LENGTH - FIFO.pGet);i++)
						*(unsigned char *)(Buf + FIFO_LENGTH - FIFO.pGet + i)=FIFO.Buf[i];

					FIFO.pGet=i;

					FIFO.Length -= Len;

					FIFO.Lock    =0;

					return Len;

				}
				
			}
		}
		else if(FIFO.pGet>FIFO.pPut)
		{
			/*---------------------------------------------------------*/
			/* FIFO中有足够的数据                                      */
			/*---------------------------------------------------------*/
			if(Len<=(FIFO_LENGTH - FIFO.pGet))
			{
				for(i=0;i<Len;i++)
					*(unsigned char *)(Buf + i)=FIFO.Buf[FIFO.pGet + i];

				FIFO.pGet   += Len;
				FIFO.Length -= Len;

				FIFO.Lock    =0;

				return Len;
			}
			/*--------------------------------------------------------*/
			/* FIFO中要取走的数据有部分在头部                         */
			/*--------------------------------------------------------*/
			else
			{

				for(i=0;i<FIFO_LENGTH - FIFO.pGet;i++)
					*(unsigned char *)(Buf + i)=FIFO.Buf[FIFO.pGet + i];

				/*----------------------------------------------------*/
				/* 可以取走的数据够Len                                */
				/*----------------------------------------------------*/
				if((FIFO_LENGTH - FIFO.pGet + FIFO.pPut)>=Len)
				{
					for(i=0;i<Len-(FIFO_LENGTH - FIFO.pGet);i++)
						*(unsigned char *)(Buf + FIFO_LENGTH - FIFO.pGet + i)=FIFO.Buf[i];

					FIFO.pGet    =i;
					FIFO.Length -= Len;

					FIFO.Lock    =0;

					return Len;
				}
				/*----------------------------------------------------*/
				/* 可以取走的数据不够Len                              */
				/*----------------------------------------------------*/
				else
				{
					for(i=0;i<FIFO.pPut;i++)
						*(unsigned char *)(Buf + FIFO_LENGTH - FIFO.pGet + i)=FIFO.Buf[i];

					FIFO.pGet    = i;
					FIFO.Length  = 0;

					FIFO.Lock    = 0;

					return FIFO_LENGTH - FIFO.pGet + FIFO.pPut;
				}
			}
		}
	}
}

unsigned long FIFO_Put(unsigned char *Data, unsigned short Len)
{
	int            i;
	unsigned long  FreeBufLen;

	if(FIFO.Lock)
		return -1;
	else
	{
		FIFO.Lock=1;

		if(FIFO.pPut>FIFO.pGet)
		{
			FreeBufLen=FIFO_LENGTH - FIFO.pPut + FIFO.pGet;

			/*---------------------------------------------------*/
			/* 没有足够的空间来放数据                            */
			/*---------------------------------------------------*/
			if(Len>FreeBufLen)
			{
				FIFO.Lock=0;
				return -1;
			}
			/*---------------------------------------------------*/
			/* 有足够的空间                                      */
			/*---------------------------------------------------*/
			else
			{
				/*------------------------------------------------*/
				/* 全部放在FIFO的后面就可以了                     */
				/*------------------------------------------------*/
				if(Len<=(FIFO_LENGTH - FIFO.pPut))
				{
					for(i=0;i<Len;i++)
						FIFO.Buf[FIFO.pPut + i]=*(unsigned char *)(Data + i);

					FIFO.pPut   +=Len;
					FIFO.Length +=Len;

				}
				/*------------------------------------------------*/
				/* 有一部分数据需要放在FIFO的头部                 */
				/*------------------------------------------------*/

				else
				{
					for(i=0;i<(FIFO_LENGTH - FIFO.pPut);i++)
						FIFO.Buf[FIFO.pPut + i]=*(unsigned char *)(Data + i);

					for(i=0;i<(Len-(FIFO_LENGTH - FIFO.pPut));i++)
						FIFO.Buf[i]=*(unsigned char *)(Data + (FIFO_LENGTH - FIFO.pPut) + i);
					
					FIFO.pPut    =i;
					FIFO.Length +=Len;

				}
				FIFO.Lock=0;
				return 0;
			}
		}
		else if(FIFO.pPut==FIFO.pGet)
		{
			/*----------------------------------------------------------------*/
			/* 数据已经被取空                                                 */
			/*----------------------------------------------------------------*/
			if(FIFO.Length==0)
			{
				FreeBufLen=FIFO_LENGTH;

				if(Len>FreeBufLen)
				{
					FIFO.Lock=0;
					return -1;
				}
				else
				{
					/*------------------------------------------------*/
					/* 全部放在FIFO的后面就可以了                     */
					/*------------------------------------------------*/
					if(Len<=(FIFO_LENGTH - FIFO.pPut))
					{
						for(i=0;i<Len;i++)
							FIFO.Buf[FIFO.pPut + i]=*(unsigned char *)(Data + i);

						FIFO.pPut   += Len;
						FIFO.Length += Len;

					}
					/*------------------------------------------------*/
					/* 有一部分数据需要放在FIFO的头部                 */
					/*------------------------------------------------*/
					else
					{
						for(i=0;i<(FIFO_LENGTH - FIFO.pPut);i++)
							FIFO.Buf[FIFO.pPut + i]=*(unsigned char *)(Data + i);

						for(i=0;i<(Len-(FIFO_LENGTH - FIFO.pPut));i++)
							FIFO.Buf[i]=*(unsigned char *)(Data + (FIFO_LENGTH - FIFO.pPut) + i);
						
						FIFO.pPut    = i;
						FIFO.Length += Len;

					}
					FIFO.Lock=0;
					return 0;
				}
			}
			/*-----------------------------------------------------------*/
			/* FIFO已经满了                                              */
			/*-----------------------------------------------------------*/
			else
			{
				FIFO.Lock=0;
				return -1;
			}
		}
		else if(FIFO.pPut<FIFO.pGet)
		{

			FreeBufLen=FIFO.pGet-FIFO.pPut;

			/*----------------------------------------------------------*/
			/* 剩下的空间不够存放数据                                   */
			/*----------------------------------------------------------*/