can

can通信源码

{
bit Flag;
RST=0; 
Delay(200);
Delay(200);
RST=1;    
LCD_init(); 
LCD_Clear(); 

    SJA_RST = 0; //复位引脚
	Delay(100);
    SJA_RST = 1;//CAN总线复位管脚
 	Delay(100);
	Delay(100);
	Delay(100);
    SJA_CS = 0;//CAN总线片选有效
    	Delay(100);
    SJA_CS = 1;//CAN总线片选无效,保证数据线上的变化不会影响SJA1000
//CPU初始化

    CAN_init(); //SJA1000初始化，对 SJA1000寄存器的读写是采用外部寄存器寻址方式，所以不需要程序单独控制片选有效无效
    _nop_();
    _nop_();
	Delay(200);
TMOD |=0x01;//定时器设置 0.1ms in 12M crystal
TH0=(65536-100)/256; 
TL0=(65536-100)%256;//定时0.1mS 
IE= 0x82;  //打开中断
TR0=1;
xsg();
CYCLE = 10;// 时间可以调整 这个是10调整 8位PWM就是256步

    while(1)
{

while(qieh)
{
CAN_RXD();
  anjian();
while(!Flag)
  {
   Delay(5000); //延时时间，从一个亮度到下一个亮度的间隔时间，速度快就能看到连续效果

   PWM_ON++;     //这个使用较长延时，以便能看清楚变化过程
   anjian();
   if(PWM_ON == CYCLE)
      {           //这个里可以添加其他程序 如到最亮时候控制设备
      Flag=1;
	  }
  }
if(p14==0)
{
 Delay(5000);
 if(p14==0)
{
 qieh=0;
 while(!p14);
}
}
Delay(6000);
CAN_RXD();
 while(Flag)     //亮度递减 同上，是个相反的过程
  {
   Delay(5000);

   PWM_ON--;
  anjian();
CAN_RXD();
   if(PWM_ON == 0)
      {
      Flag=0;
	  }
  }
if(p14==0)
{
 Delay(5000);
 if(p14==0)
{
 qieh=0;
 while(!p14);
}
}
}
while(!qieh)
{
     CAN_RXD();   

    if(PWM_Num>=5)
         PWM_Num=0;
         switch(PWM_Num)
        {
       case 4:PWM_ON=0;break;//高电平时长 
       case 3:PWM_ON=4;break;
       case 2:PWM_ON=6;break;
       case 1:PWM_ON=8;break;
       case 0:PWM_ON=10;break;
       default:break;
        }
     
if(p13==0)
  {
   Delay(3000);
   if(p13==0)
     {
      while(!p13);
      PWM_Num++;
	  if(PWM_Num>=5)
         PWM_Num=0;
         qh=0;
      xsg();  
       }
       }
 
if(p14==0)
{
 Delay(3000);
 if(p14==0)
  {
  qieh=1;
  }
}
CAN_RXD();
anjian();
}
}
}

void CAN_init( void )
{
   
    uchar ACRR[4];
    uchar AMRR[4];
    ACRR[0] = 0x00;
    ACRR[1] = 0x01;
    ACRR[2] = 0x02;
    ACRR[3] = 0x03;//接收代码寄存器，节点1
    AMRR[0] = 0xff;
    AMRR[1] = 0xff;
    AMRR[2] = 0xff;
    AMRR[3] = 0xff;//接收屏蔽寄存器。 只接收主机发送的信息
    //  .0=1---reset MODRe,进入复位模式，以便设置相应的寄存器
    	 //防止未进入复位模式，重复写入;
    MODR   = 0x09;

    CDR  = 0x88;//时钟分频； CDR.3=1--时钟关闭, CDR.7=0---basic CAN, CDR.7=1---Peli CAN

    BTR0 = 0x03;
    BTR1 = 0x1c;//16M晶振，波特率125Kbps

    IER  = 0x01;// .0=1--接收中断使能；  .1=0--关闭发送中断使能
    OCR  = 0xaa;// 配置输出控制寄存器
    CMR  = 0x04;//命令寄存器；释放接收缓冲器

    ACR  = ACRR[0];
    ACR1 = ACRR[1];
    ACR2 = ACRR[2];
    ACR3 = ACRR[3];//初始化标示码

    AMR  = AMRR[0];
    AMR1 = AMRR[1];
    AMR2 = AMRR[2];
    AMR3 = AMRR[3];//初始化掩码


	MODR   = 0x08;

}
void CAN_TXD( void )
{                    
				 uchar data qushu;
				    uchar data TX_buffer[ N_can ] ;
                       CMR=0x04;
			
					    TX_buffer[0] = 0x88;//TX.7=1扩展帧；TX.6=0数据帧; .3=1数据长度
					    TX_buffer[1] = 0x11;//本节点地址
					    TX_buffer[2] = 0x22;//
					    TX_buffer[3] = 0x33;//
					    TX_buffer[4] = 0x44;//
																		
						    TX_buffer[5]  = PWM_Num;
						    TX_buffer[6]  = 0xef;
						    TX_buffer[7]  = 0xee;
						    TX_buffer[8]  = 0x44;//
						    TX_buffer[9]  = 0x55;//
						    TX_buffer[10] = 0x66;//
						    TX_buffer[11] = 0x55;//
						    TX_buffer[12] = 0xc0;//
					   do{
    qushu=SR;
   	Delay(100);
	Delay(100);

      }while(qushu&0x20);
     do{
        qushu=SR;
           	Delay(100);
       }while(qushu&0x10);


	   		        TBSR   = TX_buffer[0];
				    TBSR1  = TX_buffer[1];
				    TBSR2  = TX_buffer[2];
				    TBSR3  = TX_buffer[3];
				    TBSR4  = TX_buffer[4];
				    TBSR5  = TX_buffer[5];
				    TBSR6  = TX_buffer[6];
				    TBSR7  = TX_buffer[7];
				    TBSR8  = TX_buffer[8];
				    TBSR9  = TX_buffer[9];
				    TBSR10 = TX_buffer[10];
				    TBSR11 = TX_buffer[11];
				    TBSR12  = TX_buffer[12];
					CMR = 0x01;	
Delay(100);
	Delay(100);

				 
}
		/////////delay程序////////////////
		void Delay(uint delay_time)
		{//延时程序
		    while(delay_time--)
		    {}
		}
void CAN_RXD( void )
{//接收数据函数，在中断服务程序中调用

    uchar data Judge;
    Judge=SR;

if(!(Judge&0x20))
{
 if(!(Judge&0x10))
  {     
if(Judge&0x01)
{
        RX_buffer[0] =  RBSR;
        RX_buffer[1] =  RBSR1;
        RX_buffer[2] =  RBSR2;
        RX_buffer[3] =  RBSR3;
        RX_buffer[4] =  RBSR4;
        RX_buffer[5] =  RBSR5;
        RX_buffer[6] =  RBSR6;
        RX_buffer[7] =  RBSR7;
        RX_buffer[8] =  RBSR8;
        RX_buffer[9] =  RBSR9;
        RX_buffer[10] =  RBSR10;
        RX_buffer[11] =  RBSR11;
        RX_buffer[12] =  RBSR12;
        CMR=0x04;	//释放接收缓冲器
        Judge = ALC;//释放仲裁随时捕捉寄存器
        Judge = ECC;//释放错误代码捕捉寄存器
if(RX_buffer[4]==2)
{
qh=1;
xswsd();
}    
if(RX_buffer[4]==0)
{
qieh=0;
PWM_Num=RX_buffer[11];
 qh=0;
xsg();      
}
if(RX_buffer[4]==1)
{
qieh=0;
PWM_Num=RX_buffer[12];
qh=0;
xsg();
}

      
}
}  
}  
}
/********************************/
/*      定时中断                */
/********************************/
void tim(void) interrupt 1 using 1
{
static unsigned char count; //
TH0=(65536-100)/256; 
TL0=(65536-100)%256;//定时0.1mS 

if (count==PWM_ON)
    {
     p10=0; //灯灭 
    }
  count++;
if(count == CYCLE)
    {
    count=0;
	if(PWM_ON!=0) //如果左右时间是0 保持原来状态
	   p10=1;//灯亮

    }
}
void xsg(void)
{
  if(qh==0)  //液晶显示光照等级
 {
LCD_Clear(); 
LCD_Write_Chinese(0,0,4); 
LCD_Write_Chinese(2,0,5); 
LCD_Write_Chinese(4,0,6); 
LCD_Write_Chinese(6,0,7); 
LCD_Write_Chinese(8,0,8); 
LCD_Write_Charater(4,2,PWM_Num);
 }
}
void xswsd(void)
{
 if(qh==1)
{
LCD_Clear(); 
LCD_Write_Chinese(0,0,0); 
LCD_Write_Chinese(2,0,1); 
LCD_Write_Charater(4,0,10);
LCD_Write_Chinese(0,2,2); 
LCD_Write_Chinese(2,2,3); 
LCD_Write_Charater(4,2,10);
LCD_Write_Charater(6,2,RX_buffer[5]);
LCD_Write_Charater(7,2,RX_buffer[6]);
LCD_Write_Charater(8,2,RX_buffer[7]);
LCD_Write_Charater(6,0,RX_buffer[8]);
LCD_Write_Charater(7,0,RX_buffer[9]);
LCD_Write_Charater(8,0,RX_buffer[10]);
}

}