232tocan.c

RS232/CAN转换器 硬件电路需自己设计(电路很简单)

/*-----------------预编译--------------------*/
#include<math.h>
#include<ctype.h>
#include<absacc.h>
#include<intrins.h>
#include<string.h>
#include<reg52.h>
#include"232toCAN.h"
/*-----------------函数声明-----------------*/
void Dog(void);
void Dl1s(void);
void Delay(uchar t_a);
void Write_reg(uchar tcode);
void Write_byte(uint address, uchar Data);
void Can_send_data(void);
/******************程序模块******************/
void Sum_data(uchar *p, uchar num)
{
    uchar t_a;
    
    Add.crc = 0;
    
    for (t_a = 0; t_a < num; t_a++)
    {
        Add.crc += (*p);
        p++;
    }
}
//CAN接收中断处理
void CanRec_prg(void)
{
    uchar form;
    uchar count;
    union
    {
        uchar t[2];
        uint crc;
    }var;
    
    //数据接收是否有效
    while ((PBYTE[2] & 0x01) != 0)
    {
        //BasicCAN
        if (Can_mode == 0)
        {
            form = BASIC_RX_ID2;
           
            //远程帧
            if ((form & 0x10) != 0)
            {
                var.t[0] = BASIC_RX_ID1;
                var.t[1] = BASIC_RX_ID2;
                
                var.crc >>= 5;
                
                Can_rxbuf[0] = var.t[0];
                Can_rxbuf[1] = var.t[1];
                Can_rxcount = 2;
            }
            //数据帧
            else
            {
                count = form & 0x0f;
                
                var.t[0] = BASIC_RX_ID1;
                var.t[1] = BASIC_RX_ID2;
                
                var.crc >>= 5;
                
                Can_rxbuf[0] = var.t[0];
                Can_rxbuf[1] = var.t[1];
                 
                while (count > 0)
                {
                    Can_rxbuf[2 + Can_rxcount] = PBYTE[22 + Can_rxcount];
                    Can_rxcount++;
                    count--;
                }       
                Can_rxcount += 2;
            }
        }
        //PeliCAN
        else
        {
            form = RX_FRAME_INFO;
           
            //远程帧
            if ((form & 0x40) != 0)
            {
                //扩展帧
                if ((form & 0x80) != 0)
                {
                    Can_rxbuf[0] = RX_FRAME_INFO;
                    Can_rxbuf[1] = PELI_RX_ID1;
                    Can_rxbuf[2] = PELI_RX_ID2;
                    Can_rxbuf[3] = PELI_RX_ID3;
                    Can_rxbuf[4] = PELI_RX_ID4;
                    Can_rxcount = 5;
                }
                //标准帧
                else
                {
                    Can_rxbuf[0] = RX_FRAME_INFO;
                    var.t[0] = PELI_RX_ID1;
                    var.t[1] = PELI_RX_ID2;
                
                    var.crc >>= 5;
                    Can_rxbuf[1] = var.t[0];
                    Can_rxbuf[2] = var.t[1];
                    
                    Can_rxcount = 3;
                }
            }
            //数据帧
            else
            {
                count = form & 0x0f;
                
                //扩展帧
                if ((form & 0x80) != 0)
                {
                    Can_rxbuf[0] = RX_FRAME_INFO;
                    Can_rxbuf[1] = PELI_RX_ID1;
                    Can_rxbuf[2] = PELI_RX_ID2;
                    Can_rxbuf[3] = PELI_RX_ID3;
                    Can_rxbuf[4] = PELI_RX_ID4;
                    
                    while (count > 0)
                    {
                        Can_rxbuf[5 + Can_rxcount] = PBYTE[21 + Can_rxcount];
                        Can_rxcount++;
                        count--;
                    }
                
                    Can_rxcount += 5;
                }
                //标准帧
                else
                {
                    Can_rxbuf[0] = RX_FRAME_INFO;
                    
                    var.t[0] = PELI_RX_ID1;
                    var.t[1] = PELI_RX_ID2;
                
                    var.crc >>= 5;
                    Can_rxbuf[1] = var.t[0];
                    Can_rxbuf[2] = var.t[1];
                    
                    while (count > 0)
                    {
                        Can_rxbuf[3 + Can_rxcount] = PBYTE[19 + Can_rxcount];
                        Can_rxcount++;
                        count--;
                    }
                    Can_rxcount += 3;
                }
            }
        }
        //准备启动串口发送
        Com_send_ready = 1;
        //释放接收缓冲区
        PBYTE[1] = RRB_CMD;
    }
}
//SJA1000初始化配置
void Can_config(void)
{
    union
    {
        uchar t[2];
        uint  crc;
    }var;
    
    EX1 = 0;   
    CAN_CS = 0;
    
    //BasicCAN
    if (Can_mode == 0)
    {
        //硬件产生复位信号
        RST = 0;
    
        while ((BASIC_MODE_REG & 0x01) != 0x01)
        {    
            BASIC_MODE_REG |= 0x01;//软件复位       
        }
        //关闭复位信号
        RST = 1;
        
        BASIC_OUTPUT_CONTROL_REG = 0x0a;     //输出模式
        
        while (BASIC_CLK_DIV_REG != 0x48)    //
        {
            BASIC_CLK_DIV_REG = 0x48;        //时钟分频设置
        }
        
        BASIC_BTR0_REG = Bitrate[CanBaud][0];//通讯速率设置
        BASIC_BTR1_REG = Bitrate[CanBaud][1];
        
        var.crc = Acr_data;        
        BASIC_ACCEPT_CODE_REG = var.t[0];   //验收码
        
        var.crc = Amr_data;       
        BASIC_ACCEPT_MASK_REG = var.t[0];   //屏蔽码
         
        while ((BASIC_MODE_REG & 0x01) != 0)//退出复位，进入正常工作模式
        {
            BASIC_MODE_REG &= 0xfe;
        }
        
        BASIC_MODE_REG |= 0x1a;              //中断使能
    }
    //PeliCAN
    else
    {
        //硬件产生复位信号
        RST = 0;
    
        while ((PELI_MODE_REG & 0x01) != 0x01)
        {    
            PELI_MODE_REG |= 0x01;//软件复位       
        }
        //关闭复位信号
        RST = 1;
        
        PELI_OUTPUT_CONTROL_REG = 0x0a;     //输出模式
        
        while (PELI_CLK_DIV_REG != 0xc8)    //0xc8
        {
            PELI_CLK_DIV_REG = 0xc8;        //时钟分频设置
        }
        
        PELI_BTR0_REG = Bitrate[CanBaud][0];//通讯速率设置
        PELI_BTR1_REG = Bitrate[CanBaud][1];
        
        var.crc = Acr_data;
         
        PELI_ACCEPT_CODE0_REG = var.t[0];   //验收码
        PELI_ACCEPT_CODE1_REG = var.t[1];   
        PELI_ACCEPT_CODE2_REG = var.t[0];
        PELI_ACCEPT_CODE3_REG = var.t[1];
        
        var.crc = Amr_data;
        
        PELI_ACCEPT_MASK0_REG = var.t[0];   //屏蔽码
        PELI_ACCEPT_MASK1_REG = var.t[1];
        PELI_ACCEPT_MASK2_REG = var.t[0];
        PELI_ACCEPT_MASK3_REG = var.t[1];
        
        ERR_WARN_REG = 255;             //错误警告次数限制
        RX_ERR_REG = 0;                 //接收出错次数计数
        TX_ERR_REG = 0;                 //发送出错次数计数
        RX_BUFFER_START = 0;            //接收缓冲区起始地址
        
        //PELI_MODE_REG = 0x04;
        
        while ((PELI_MODE_REG & 0x01) != 0)//退出复位，进入正常工作模式
        {
            PELI_MODE_REG &= 0xfe;
        }
              
        //PELI_MODE_REG = 0x10;

        INTERRUPT_EN_REG = 0x0d;        //中断使能
    }
    
    Com_send_ready = 0;
    Can_rxcount = 0;
    Can_send_ready = 0;
    EX1 = 1;
}
//--------------初始化波特率-------------
void Baudrate(uchar Baud)
{
	SCON  = 0x70;	
	T2CON = 0x34;
	
	switch (Baud)
	{
		case 0://1200 bps
			RCAP2H = BAUD1200H;
			RCAP2L = BAUD1200L;
		break;

		case 1://2400 bps
			RCAP2H = BAUD2400H;
			RCAP2L = BAUD2400L;
		break;

		case 2://4800 bps
			RCAP2H = BAUD4800H;
			RCAP2L = BAUD4800L;
		break;

		case 3://9600 bps
			RCAP2H = BAUD9600H;
			RCAP2L = BAUD9600L;
		break;

		case 4://19200 bps
			RCAP2H = BAUD19200H;
			RCAP2L = BAUD19200L;
		break;
		
		case 5://38400 bps
			RCAP2H = BAUD38400H;
			RCAP2L = BAUD38400L;
		break;
		
		case 6://57600 bps
			RCAP2H = BAUD57600H;
			RCAP2L = BAUD57600L;
		break;
		
		case 7://115200 bps
			RCAP2H = BAUD115200H;
			RCAP2L = BAUD115200L;
		break;
	}
}
//初始化MCU各寄存器参数
void Mcu_init(void)
{
	TMOD = 0x21;	
	TH0  = TIMER50ms_TH0;
	TL0  = TIMER50ms_TL0;	
    IE   = 0x96;
   	IP   = 0x10;
   	TCON = 0x10;
   	Baudrate(3);     //初始化波特率9600bps 
}
/*------------------------延时1ms子程序--------------------------*/
void Delay(uchar t_a)
{
    uchar t_b;
    uchar t_c;
       
    for (t_c=0; t_c<t_a; t_c++)
    {
        for (t_b=0; t_b<240; t_b++)
		{
			_nop_();
			_nop_();
			_nop_();
		}
		Dog();
    }
}
//喂狗
void Dog(void)
{
	SPI_CS = 1;	
	SPI_CS = 0;
	_nop_();
	_nop_();	
	SPI_CS = 1;
}
//Write one byte 
void W_byte(uchar Data)
{
	uchar i;

	SPI_SI = 1;
	SCLK   = 0;
	_nop_();
	_nop_();
	
	for (i=0; i<8; i++)
	{   	
	    SPI_SI = (bit)(Data&0x80);
		SCLK   = 1;
		_nop_();
		_nop_();
		Data   <<= 1;
		SCLK   = 0;
		_nop_();
		_nop_();
	}
}
uchar R_byte(void)
{
	uchar i;
	uchar result;

	result = 0;
	SPI_SO = 1;
	
	for (i=0; i<8; i++)
	{
		SCLK = 1;
		
		result <<= 1;
		
		if (SPI_SO)
		{
			result |= 0x01;
		}
		
		SCLK = 0;
		_nop_();
		_nop_();
	}
	
	return result;
}
//----------------------------------------------------------------
void Write_status(uchar status)
{
	SPI_CS = 0;
	W_byte(status);	
	SPI_CS = 1;
}
//----------------------------------------------------------------
void Write_reg(uchar tcode)	//	write status register
{
	WP     = 1;
	Write_status(WREN);
	
	SPI_CS = 0;	
	W_byte(WRSR);
	W_byte(tcode);

	SPI_CS = 1;
	
	Delay(10);	
	
	WP     = 0;
}
//----------------------------------------------------------------
uchar Read_byte(uint address)	//read one byte from x5045
{
	uchar result;

	SPI_CS = 0;
	
	if (address>255)
	{
		W_byte(READ|0x08);
	}
	else
	{
		W_byte(READ);
	}

	W_byte((uchar)(address & 0xff));
	result = R_byte();
		
	SPI_CS = 1;
	
	return (result);
}
//往X5045具体单元中写入一个字节的数据----------------------------------------------------------------
void Write_byte(uint address, uchar Data)		//write one byte to x5045
{
	WP = 1;
	Write_status(WREN);	

	SPI_CS = 0;
	
	if (address>255)
	{
		W_byte(WRITE|0x08);
	}