main.c

参考周立功的basic模式的CAN通讯

//--------------------------------------------------------------------------
// FileName   : main.C
// Description: main function 
// DateTime   : 2005-07-06 Create
// Author     : jztx-liuweiming
// Version    : TxCmsPrj Ver1.0
//--------------------------------------------------------------------------
#include "main.h"
#include "string.h"
#include "PSD3200.H"
#include "My7132.H"
#include "MyCRC.H"
#include "SJA_PeliCan.h"

unsigned char  rcv_len;
unsigned char  bdata flag_init;
sbit rcv_flag = flag_init^0;
sbit err_flag = flag_init^2;
unsigned char data  send_data[20], rcv_data[20];

#define Version  0x0101   // Version 1.0

xdata PSD_REGS PSD3200_reg _at_ 0x7F00;
                          //PSD Self regiser Address

#define MAX_TEST_CNT 3000

unsigned short nTest_Cnt = 0;

void delay(unsigned int k)
{	
    unsigned	int	i, j;
	for(i=0;i<k;i++)
	{
	    for(j=0;j<100;j++);
	}
}

uchar Sja_1000_Init(void)
{
   //enter reset mode 
   while ( (REG_ModeControl & 0x01) == 0x00 )
   {
     REG_ModeControl = REG_ModeControl & 0x01;
   }

   //CanMode + CBP_Bit + DivBy2
   //REG_ClockDivide = 0x88;
   REG_ClockDivide = 0xC0;
   
   //
   REG_AcceptCode0 = 0x00;
   REG_AcceptCode1 = 0x00;
   REG_AcceptCode2 = 0x00;
   REG_AcceptCode3 = 0x00;

   REG_AcceptMask0 = 0xff;
   REG_AcceptMask1 = 0xff;
   REG_AcceptMask2 = 0xff;
   REG_AcceptMask3 = 0xff;

   //100Kbpi
   REG_BusTiming0 = 0x53;
   REG_BusTiming1 = 0x2F;

   //Tx1Float + Tx0PshPull + NormalMode
   //REG_OutControl = 0xaa; //0x02 | 0x18 | 0x00 ;
   REG_OutControl = 0x1a; //0x02 | 0x18 | 0x00 ;

   //
   REG_RxBufStartAdr = 0;

   do 
   {
     REG_ModeControl = 0x08;

   } while(REG_ModeControl & 0x08 != 0x08);

   //REG_ModeControl = 0x08;
  

   //enable Recv Interrupt
   REG_InterruptEn = 0x01;

   return  'o'; 
}
//--------------------------------------------------------------------------
// Function    : InitCPU
// Input  Para : void
// Output Para : void
// Retun Val   : void
// Call        : 
// call By     : main
// DateTime    : 2005-7-30
// Author      : [e-mail]
// Other info  : 
//--------------------------------------------------------------------------
void InitCPU(void)
{

    PCON   = 0x80;
    /******** COM2 ******/
    
    T2CON  = 0x04;
    PCON  |= 0x0C;
    RCAP2L = 0xb1;   //9600
    RCAP2H = 0xff;
    SCON2  = 0x50;   
    IEA    = 0x10;	 // ES1 = 1; IEA.4 
    TR2    = 1;
    ET2    = 1;
    /********** COM1 *******/
    SCON   = 0x50;
    TMOD   = 0x21;
	TH1    = 0xf3;
	TL1    = 0xf3;
	TH0    = 0xF8;   //(2^16 - x)*12*1/(晶振*10^6-1) = 时间*10^(-3)
	TL0    = 0x30;   //定时1ms
	TI     = 0;
	RI     = 0;

	TR1=1;
	
    TR0=1;
    ET0=1;
    IT1=1;

	EX0=1;
	EX1=1;
	ES=1;
    /*******************/
}

void SJA_isr(void) interrupt 0 using 1
{
	flag_init   = REG_Interrupt;
}

//--------------------------------------------------------------------------
// Function    : timer0_isr
// Input  Para : void
// Output Para : void
// Retun Val   : void
// Description : System Timer0 Interrupt
// Call        : 
// call By     : main
// DateTime    : 2005-7-30
// Author      : [e-mail]
// Other info  : 
//--------------------------------------------------------------------------
void timer0_isr(void) interrupt 1 using 2
{
    TR0   = 0;

    TH0   = 0xF8;
	TL0   = 0x30; 

    TR0   = 1;

    //Comm1 TimeoOut Cnt -> (Modbus) Comm1Recv Control
    if ( Comm1Recv_Flag == RECV_COUNT )
    {
        if ( nComm1Recv_Cnt++ >= MAX_RECV_CNT )
        {     
            nComm1Recv_End++;
            if ( nComm1Recv_End >= MAX_RECV_SUIT )
            {
                nComm1Recv_End = 0;
            }
            Comm1Recv[ nComm1Recv_End ].Len = 0;
            
            Comm1Recv_Flag = RECV_TIMEOUT;
        }
    }
    else
    {
        nComm1Recv_Cnt = 0;
    }

    //Comm2 TimeoOut Cnt -> (Modbus) Comm2Recv Control 
    if ( Comm2Recv_Flag == RECV_COUNT )
    {
        if ( nComm2Recv_Cnt++ >= MAX_RECV_CNT )
        {     
            nComm2Recv_End++;
            if ( nComm2Recv_End >= MAX_RECV_SUIT )
            {
                nComm2Recv_End = 0;
            }
            Comm2Recv[ nComm2Recv_End ].Len = 0;

            Comm2Recv_Flag = RECV_TIMEOUT;
        }
    }
    else
    {
        nComm2Recv_Cnt = 0;
    }

    //Comm1 TimeOut Cnt -> Comm1State Control
	if ( Comm1State == WAITING )
    {
        if ( nComm1Stat_Cnt++ >= MAX_STAT_CNT )
        {
		    Comm1State = TIMEOUT;
        }
    }
    else
    {
        nComm1Stat_Cnt = 0;
    }

	//Comm2 TimeOut Cnt -> Comm2State Control
	if ( Comm2State == WAITING )
    {
        if ( nComm2Stat_Cnt++ >= MAX_STAT_CNT )
        {
		    Comm2State = TIMEOUT;
        }
    }
    else
    {
        nComm2Stat_Cnt = 0;
    }

	nTest_Cnt++;
}
//--------------------------------------------------------------------------
// Function    : uPSD_uart1_isr
// Input  Para : void
// Output Para : void
// Retun Val   : void
// Description : System Uart1 Interrupt 
// Call        : 
// call By     : main
// DateTime    : 2005-7-30
// Author      : [e-mail]
// Other info  : 
//--------------------------------------------------------------------------
static void uPSD_uart1_isr (void) interrupt SIO1_VECTOR using 2		
{
/*------------------------------------------------
  comm2 Received data interrupt.
------------------------------------------------*/
    
    if ( (SCON2 & 0x01) != 0)
    {
  	    SCON2 &= 0xFE;			//RI = 0;
        
        Comm2Recv [nComm2Recv_End].Buff[ (Comm2Recv [nComm2Recv_End].Len)++ ] = SBUF2;
        if ( Comm2Recv [nComm2Recv_End].Len >= MAX_RECV_BUFF )
        {
            Comm2Recv [nComm2Recv_End].Len = 0;
        }

        Comm2Recv_Flag = RECV_ONEBYTE;
    }
    
/*------------------------------------------------
  comm2 Transmitted data interrupt.
------------------------------------------------*/

    if ( (SCON2 & 0x02)  != 0)                                                    
    {
  	    SCON2 &= 0xfd;		//TI = 0; 
        if ( nComm2Send_Idx < Comm2Send.Len )
        {
            SBUF2 = Comm2Send.Buff [ nComm2Send_Idx ];
            nComm2Send_Idx++;
        }
        else
		{
    		if ( Comm2Send.Buff[0] != 0x00 )
			{
		    	Comm2State = WAITING;
			}
		}
    }
}
//--------------------------------------------------------------------------
// Function    : uPSD_uart0_isr
// Input  Para : void
// Output Para : void
// Retun Val   : void
// Description : System Uart0 Interrupt 
// Call        : 
// call By     : main
// DateTime    : 2005-7-30
// Author      : [e-mail]
// Other info  : 
//--------------------------------------------------------------------------
static void uPSD_uart0_isr (void) interrupt SIO_VECTOR using 2
{
/*------------------------------------------------
  comm1 Received data interrupt.
------------------------------------------------*/ 
    if ( RI != 0 )
    {
        RI = 0;
     
        Comm1Recv [nComm1Recv_End].Buff[(Comm1Recv [nComm1Recv_End].Len)++] = SBUF;
        if ( Comm1Recv [nComm1Recv_End].Len >= MAX_RECV_BUFF )
        {
            Comm1Recv [nComm1Recv_End].Len = 0;
        }

        Comm1Recv_Flag = RECV_ONEBYTE;            
    }
    
/*------------------------------------------------
  comm1 Transmitted data interrupt.
------------------------------------------------*/
   
    if ( TI != 0 )
    {
        TI = 0;
        if ( nComm1Send_Idx < Comm1Send.Len )
        {
            SBUF = Comm1Send.Buff [ nComm1Send_Idx ];
            nComm1Send_Idx++;
        }
		else
		{
		    if ( Comm1Send.Buff[0] != 0x00 )
			{
        		Comm1State = WAITING;
			}
		}
    }
}
//--------------------------------------------------------------------------
// Function    : main
// Input  Para : void
// Output Para : void
// Retun Val   : void
// Description : main function 
// Call        : InitCPU, My7132Init, CRC, 
// call By     : Null
// DateTime    : 2005-7-30
// Author      : [e-mail]
// Other info  : 
//--------------------------------------------------------------------------
void main(void)
{
    unsigned short usCRC = 0xffff;
	unsigned short usLen = 0;
	unsigned char  status;
    unsigned char  i;

	unsigned char  sndidx = 0;
	unsigned char  rcvidx = 0;
	unsigned char  erridx = 0;

    WDKEY = 0x55; 
	EA = 0;
    delay(100);

	status = Sja_1000_Init();
	delay(100);
    InitCPU();
	My7132Init( ADDR_7132_ZERO );

	flag_init = 0x00; //initialize Sja1000

    PSD3200_reg.CONTROL_A   = 0xff;
    PSD3200_reg.DIRECTION_A = 0xff;

   	pComm1RecvCtrl = (struct tagRecvCtrl*)(p7132 + COMM1_RECV_CTRL);
	pComm2RecvCtrl = (struct tagRecvCtrl*)(p7132 + COMM2_RECV_CTRL);
	pComm1SendCtrl = (struct tagSendCtrl*)(p7132 + COMM1_SEND_CTRL);
    pComm2SendCtrl = (struct tagSendCtrl*)(p7132 + COMM2_SEND_CTRL);

	EA = 1;

	Comm1Send.Len =  8;
    Comm1Send.Buff[0] = 'C';
    Comm1Send.Buff[1] = 'A';
    Comm1Send.Buff[2] = 'N';
    Comm1Send.Buff[3] = status;
   	Comm1Send.Buff[4] = 'I';
    Comm1Send.Buff[5] = 'N';
    Comm1Send.Buff[6] = 'I';
    Comm1Send.Buff[7] = 'T';
  
    nComm1Send_Idx = 0;
    TI = 1;

    while ( 1 )
    {
        P1_5 = 0;
        P1_5 = 1;

        //Comm1Recv FLAG
        switch ( Comm1Recv_Flag )
	    {
	    case RECV_READY:
	        break;
	    case RECV_ONEBYTE:
	        nComm1Recv_Cnt = 0;
	        Comm1Recv_Flag = RECV_COUNT;
	        break;
	    case RECV_COUNT:
	        break;
	    case RECV_TIMEOUT:
	    default:
	        nComm1Recv_Cnt = 0;
	        Comm1Recv_Flag = RECV_READY;
	        break;
	    }
        //Comm2Recv FLAG
    	switch ( Comm2Recv_Flag )
	    {
	    case RECV_READY:
	        break;
	    case RECV_ONEBYTE:
	        nComm2Recv_Cnt = 0;
	        Comm2Recv_Flag = RECV_COUNT;
	        break;
	    case RECV_COUNT:
	        break;
	    case RECV_TIMEOUT:
	    default:
	        nComm2Recv_Cnt = 0;
	        Comm2Recv_Flag = RECV_READY;
	        break;
	    }
        
        if ( nTest_Cnt >= MAX_TEST_CNT )
		{
     		nTest_Cnt = 0;		   
			sndidx++;

			Comm1Send.Buff[0] = 'S';
            Comm1Send.Buff[1] = 'E';
            Comm1Send.Buff[2] = 'N';
		
			while( REG_Status & 0x08 == 1);  //正在接收
            while( REG_Status & 0x04 == 0);  //上次发送是否完成
			while( REG_Status & 0x02 == 0);  //缓冲区是否锁定

			REG_TxFramInfo = 0x86;
			REG_TxBuffer1  = 0xaa;
			REG_TxBuffer2  = 0xbb;
			REG_TxBuffer3  = 0xcc;
			REG_TxBuffer4  = 0xdd;
			REG_TxBuffer5  = '1';
			REG_TxBuffer6  = '2';
			REG_TxBuffer7  = '3';
			REG_TxBuffer8  = '4';
			REG_TxBuffer9  = '5';
			REG_TxBuffer10 = '6';
			//REG_TxBuffer11 = '7';
			//REG_TxBuffer12 = '8';

			REG_Command = 0x01;

			Comm1Send.Buff[3] = sndidx;
        	Comm1Send.Buff[4] = 'D';

			Comm1Send.Len  = 5;
			nComm1Send_Idx = 0;
            TI = 1;
	    }
       
        if ( nComm1Recv_Bgn != nComm1Recv_End )
        {
            Comm1Send.Len = Comm1Recv[nComm1Recv_Bgn].Len + 3;
            Comm1Send.Buff[0] = nComm1Recv_Bgn;
            Comm1Send.Buff[1] = nComm1Recv_End;
            Comm1Send.Buff[2] = Comm1Send.Len;

            memcpy((Comm1Send.Buff+3), Comm1Recv[nComm1Recv_Bgn].Buff, Comm1Recv[nComm1Recv_Bgn].Len);
            //Comm1Recv[nComm1Recv_Bgn].Len = 0;

            nComm1Recv_Bgn++;
            if (nComm1Recv_Bgn >= MAX_RECV_SUIT )
            {
               nComm1Recv_Bgn = 0;
            }
            
            nComm1Send_Idx = 0;
            TI = 1;
        }

        if ( nComm2Recv_Bgn != nComm2Recv_End )
        {            
            Comm2Send.Len = Comm2Recv[nComm2Recv_Bgn].Len + 3;
            Comm2Send.Buff[0] = nComm2Recv_Bgn;
            Comm2Send.Buff[1] = nComm2Recv_End;
            Comm2Send.Buff[2] = Comm2Send.Len;

            memcpy((Comm2Send.Buff+3), Comm2Recv[nComm2Recv_Bgn].Buff, Comm2Recv[nComm2Recv_Bgn].Len);
            //Comm2Recv[nComm2Recv_Bgn].Len = 0;

            nComm2Recv_Bgn++;
            if (nComm2Recv_Bgn >= MAX_RECV_SUIT )
            {
                nComm2Recv_Bgn = 0;
            }
                                
            nComm2Send_Idx = 0;
            SCON2 |= 0x02;		//TI2 = 1;
        }

		if ( rcv_flag )								//if there is receive interrupt
		{
			rcv_flag = 0;
			rcvidx++;

			if ( ( REG_Status & 0x01) == 0 )             //判断报文是否有效
            {
               rcv_len = 0;
            }

			Comm1Send.Buff[0] = 'R';
            Comm1Send.Buff[1] = 'C';
            Comm1Send.Buff[2] = 'V';
        	Comm1Send.Buff[3] = rcvidx;

            rcv_data[0] = REG_RxFramInfo;
            rcv_data[1] = REG_RxBuffer1;
            rcv_data[2] = REG_RxBuffer2;
            rcv_data[3] = REG_RxBuffer3;
            rcv_data[4] = REG_RxBuffer4;
            rcv_data[5] = REG_RxBuffer5;
            rcv_data[6] = REG_RxBuffer6;
            rcv_data[7] = REG_RxBuffer7;
            rcv_data[8] = REG_RxBuffer8;
            rcv_data[9] = REG_RxBuffer9;
            rcv_data[10] = REG_RxBuffer10;
            rcv_data[11] = REG_RxBuffer11;
            rcv_data[12] = REG_RxBuffer12;

			REG_Command = 0x04;

			Comm1Send.Len =  (rcv_data[0] & 0x0f) + 9;

		    for (i=0; i< (rcv_data[0] & 0x0f) + 5; i++)
			{
                Comm1Send.Buff[4+i] = rcv_data[i];
			}
  
            nComm1Send_Idx = 0;
            TI = 1;
		}
		
		if ( err_flag )
		{
			err_flag = 0;
			REG_Interrupt = REG_Interrupt & 0x00;

			erridx++;

			Comm1Send.Len =  7;
            Comm1Send.Buff[0] = 'C';
            Comm1Send.Buff[1] = 'A';
            Comm1Send.Buff[2] = 'N';
			Comm1Send.Buff[3] = erridx;
        	Comm1Send.Buff[4] = 'E';
            Comm1Send.Buff[5] = 'R';
            Comm1Send.Buff[6] = 'R';
          
            nComm1Send_Idx = 0;
            TI = 1;

			Sja_1000_Init();
		}
    }
}