can_test.c

USE CAN Library in PIC30 to transmit and receive CAN Message．

// ***********************************************************************
// File : 		CAN_Test.C
// Purpose : 	USE Peripheral Library in C30 to initialize Timer1 & Timer3
//				USE CAN Library in C30 to transmit and receive CAN Message
//			
// ***********************************************************************


#include 	<timer.h>
#include 	<p30FXXXX.h>
#include 	<can.h>
#include	<adc10.h>
#include	"APP009V2_LCD.h"

#define	FCY			14745600			// Osc. configuration = XT, PLL * 8 and XT = 7.3728 Mhz

#define	LED13		LATDbits.LATD0 
#define	LED14		LATDbits.LATD1 
#define	DIR_LED13	TRISDbits.TRISD0 
#define	DIR_LED14	TRISDbits.TRISD1
#define	INPUT		1
#define	OUTPUT		0

#define	CAN1_TX		LATFbits.LATF1
#define	CAN1_RX		PORTFbits.RF0
#define	DIR_CAN1_TX	TRISFbits.TRISF1
#define	DIR_CAN1_RX	TRISFbits.TRISF0	

void	Timer3_Initial( void ) ;
void	Timer1_Initial( void ) ;
void	Initial_CAN( void ) ;
void	ADC10_Initial( void ) ;
void	uitoa( unsigned char *, unsigned int ) ;

struct
	{
		unsigned T3OV : 1 ;
		unsigned :15 ;

	} Flags ;
	
union
		{
			struct
				{
					unsigned char ByteL ;
					unsigned char ByteH ;	
				} ;
			int		ByteHL ;
	
		} IN_Value ;

int				CounterT3 ;
unsigned char	TxData[10] = {0,0,0,0,0,0,0,0,0,0} ;
unsigned char	RxData[10] ;
unsigned char	ASCII_Buf[10] ;
unsigned 		MyADC ;

int _EEDATA(32) fooArrayInDataEE[] = {0,1,2,3,4,5,6,7,8,9,0xA,0xB,0xC,0xD,0xE,0xF};

const char a1[10] __attribute__ ((space(prog))) ;

//---------------------------------------------------------------------------
// Configuration bits declaration
//---------------------------------------------------------------------------
   	_FOSC(CSW_FSCM_OFF & FRC_PLL4);   //XT with 8xPLL oscillator, Failsafe clock off
   	_FWDT(WDT_OFF);                  //Watchdog timer disabled
  	_FBORPOR(PBOR_OFF & MCLR_EN);    //Brown-out reset disabled, MCLR reset enabled
   	_FGS(CODE_PROT_OFF);             //Code protect disabled
	

// ---------------------------------------------------------------------
// 
// ---------------------------------------------------------------------
void _ISR _T3Interrupt(void)
{
	
	Flags.T3OV = 1 ;
	IFS0bits.T3IF = 0 ;
	
}

void _ISR _ADCInterrupt(void)
{

		IFS0bits.ADIF = 0 ;
		MyADC = ADCBUF0 ;

}

// ---------------------------------------------------------------------
// 
// ---------------------------------------------------------------------
void __attribute__((__interrupt__)) _T1Interrupt(void)
{

	LED13 = !LED13 ;
	IFS0bits.T1IF = 0 ;
	
}


int	main( void )

{

	Flags.T3OV = 0 ;

	Timer1_Initial( ) ;
	Timer3_Initial( ) ;
	OpenLCD( ) ;

		Initial_CAN( ) ;
		ADC10_Initial( ) ;
	
	CounterT3 = 0 ;

	DIR_LED13 = OUTPUT ;
	DIR_LED14 = OUTPUT ;

	DIR_CAN1_TX = OUTPUT ;
	DIR_CAN1_RX = INPUT ;

		putrsLCD(" dsPIC CAN Test ") ;
		setcurLCD(0,1) ;
		putrsLCD("AD:      IN:    ") ;

		TxData[0] = 0 ;
		TxData[1] = 0 ;
		TxData[2] = 0 ;
		TxData[3] = 0 ;
			TxData[4] = 0 ;
			TxData[5] = 0 ;
			TxData[6] = 0 ;
			TxData[7] = 0 ;

 while (1) 
	{
	
		if ( Flags.T3OV )
		{
			CounterT3 +=1 ;
			
			if ( CAN1IsRXReady(0)) 
			{
				CAN1ReceiveMessage( RxData,8,0 ) ;		// Receive 8 bytes from Buffer 0
				// You can use either way to clear RXFUL bits @ C1RX0CON
				// CAN1SetRXMode( (char) 0 , CAN_RXFUL_CLEAR & CAN_BUF0_DBLBUFFER_DIS ) ;
				C1RX0CONbits.RXFUL = 0 ;
				
					IN_Value.ByteL = RxData[4] ;
					IN_Value.ByteH = RxData[3] ;
					uitoa(ASCII_Buf,IN_Value.ByteHL) ;
					
						setcurLCD(12,1) ;
						putrsLCD("    ") ;
						setcurLCD(12,1) ;
						putsLCD(ASCII_Buf) ;	
					
			}

			if ( CounterT3 >=1000 )
			{
				LED14 = ! LED14 ;	
				CounterT3 = 0 ;
				TxData[3] = MyADC / 256 ;
				TxData[4] = MyADC % 256 ;
				
				uitoa(ASCII_Buf,MyADC) ;
					setcurLCD(3,1) ;
					putrsLCD("    ") ;
					setcurLCD(3,1) ;
					putsLCD(ASCII_Buf) ;

				CAN1SendMessage( 	( CAN_TX_SID(0x100)) & CAN_TX_EID_DIS & CAN_SUB_NOR_TX_REQ , 
									( CAN_TX_EID(0x00)) & CAN_NOR_TX_REQ , TxData , 8 , 0 ) ;

			}
				Flags.T3OV = 0 ;
		}
	}

}

void	Timer1_Initial( void )
{
		ConfigIntTimer1( T1_INT_PRIOR_7 & T1_INT_ON ) ;
		OpenTimer1( T1_ON & T1_IDLE_STOP & T1_GATE_OFF & T1_PS_1_64 & T1_SYNC_EXT_OFF & T1_SOURCE_INT ,
					((long)(FCY/ 1000 )* 200 / 64) ) ;
}

void	Timer3_Initial( void )
{

		ConfigIntTimer3( T3_INT_PRIOR_7 & T3_INT_ON ) ;
		OpenTimer3( T3_ON & T3_IDLE_STOP & T3_GATE_OFF & T3_PS_1_1 & T3_SOURCE_INT ,
					((long)(FCY/ 1000 )) -1  ) ;
}


void	Initial_CAN( void )
{
		CAN1SetOperationMode( 	CAN_IDLE_CON & CAN_MASTERCLOCK_1 & 
								CAN_REQ_OPERMODE_CONFIG ) ;

		while ( C1CTRLbits.OPMODE <= 3 );

			CAN1Initialize( CAN_SYNC_JUMP_WIDTH3 & CAN_BAUD_PRE_SCALE(9),
							CAN_WAKEUP_BY_FILTER_DIS &
							CAN_PHASE_SEG2_TQ(4) &
							CAN_PHASE_SEG1_TQ(6) &
							CAN_PROPAGATIONTIME_SEG_TQ(2) & 
							CAN_SEG2_FREE_PROG & CAN_SAMPLE1TIME ) ;

			CAN1SetFilter ( (char) 0 , CAN_FILTER_SID( 0x200 ) & CAN_RX_EID_DIS ,
							CAN_FILTER_EID( 0x00 )) ;
			CAN1SetFilter ( (char) 1 , CAN_FILTER_SID( 0x000 ) & CAN_RX_EID_DIS ,
							CAN_FILTER_EID( 0x00 )) ;

			CAN1SetMask ( 	(char)0 , CAN_MASK_SID ( 0x7ff ) & CAN_MATCH_FILTER_TYPE , 
							CAN_MASK_EID( 0x00) ) ; 

			CAN1SetTXMode( (char) 0 , CAN_TX_STOP_REQ & CAN_TX_PRIORITY_HIGH ) ;
			CAN1SetRXMode( (char) 0 , CAN_RXFUL_CLEAR & CAN_BUF0_DBLBUFFER_DIS ) ;

			CAN1SetOperationMode( 	CAN_IDLE_CON & CAN_CAPTURE_DIS & CAN_MASTERCLOCK_1 &
									CAN_REQ_OPERMODE_NOR ) ;							
}

void ADC10_Initial(void)
{

 	ADPCFG = 0xFF7F;				// AN7/RB7 is Analog , others are Digital;
 	ADCON1 = 0x0046;				// 0b0000 0000 0100 0110 
									// Auto convert using TMR3 as trigger source
									// A/D Sample Auto-Start
 	ADCON2 = 0x0000;				// ADCON2 = 0000 0000 0000 0000
									// Don't scan inputs , SMPi = 00 ( Interrupt for each sample/convert )
 	ADCSSL = 0x0000;				// no scan input selected .......
 	ADCON3 = 0x1F3F;				// TAD = 8 Tcy , SAMC = 15 TAD 
	ADCHS =  0x07 ;					// ADCHS = 0b 00000000 00000111

	IEC0bits.ADIE = 1 ;				// Enable AD interrupt
	IPC2bits.ADIP = 7 ;				// Set Priority to 7 	>> highest !!
 
 	ADCON1bits.ADON = 1;			// turn ADC ON
}

void	uitoa( unsigned char *ASCII_Buf , unsigned int IntegerValue )
{
	
	unsigned int TempValue ;
	unsigned char ZeroDisable ;
	unsigned int  BaseQty ;
	unsigned int  Loop ;

	ZeroDisable = 1 ;
	BaseQty = 10000 ;

	for ( Loop = 0 ; Loop < 4 ; Loop ++)
	{
		TempValue = IntegerValue / BaseQty ;

			if 	( TempValue > 0) 	
				{
					*ASCII_Buf++ = (unsigned char)TempValue + '0' ;
					ZeroDisable = 0 ;
				}
			else if	( ZeroDisable == 0 ) 
					*ASCII_Buf++ = '0' ;
		IntegerValue = IntegerValue - ( TempValue * BaseQty ) ;
		BaseQty = BaseQty / 10 ;

	}
		*ASCII_Buf++ = (unsigned char)IntegerValue + '0' ;
		*ASCII_Buf = (unsigned char) 0x00 ;
		
}