精华内容
下载资源
问答
  • 0,CAN总线详解:这里不再赘述 https://blog.csdn.net/qq_31710263/article/details/97015748 ... 1,vivado工程,勾选EMIO扩展CAN0 2,添加约束 set_property PACKAGE_PIN...

    0,CAN总线详解:这里不再赘述

    https://blog.csdn.net/qq_31710263/article/details/97015748

    https://blog.csdn.net/liuligui5200/article/details/79030676

    1,vivado工程,勾选EMIO扩展CAN0

    2,添加约束

    set_property PACKAGE_PIN L15 [get_ports can_rx]
    set_property IOSTANDARD LVCMOS33 [get_ports can_rx]
    set_property PACKAGE_PIN L14 [get_ports can_tx]
    set_property IOSTANDARD LVCMOS33 [get_ports can_tx]

    3,导入sdk,新建empty空文件,新建can_zynq.h和can_zynq.c,代码如下:

    #ifndef SRC_CAN_ZYNQ_H_
    #define SRC_CAN_ZYNQ_H_
    #include "xparameters.h"
    #include "xcanps.h"
    #include "xscugic.h"
    #define XCANPS_MAX_FRAME_SIZE_IN_WORDS (XCANPS_MAX_FRAME_SIZE / sizeof(u32))
    #define CAN_DEVICE_ID    XPAR_XCANPS_0_DEVICE_ID
    #define CAN_INTR_VEC_ID        XPAR_XCANPS_0_INTR
    #define TEST_BTR_SYNCJUMPWIDTH        3
    #define TEST_BTR_SECOND_TIMESEGMENT    7
    #define TEST_BTR_FIRST_TIMESEGMENT    15
    #define TEST_BRPR_BAUD_PRESCALAR    4      //100M/(4+1) = 20M; 20/(1+1+2+1+15) = 1Mbps
    //#define TEST_BRPR_BAUD_PRESCALAR    9      //100M/(9+1) = 10M; 10/(1+1+2+1+15) = 500Kbps
    XCanPs Can;
    u32 RxFrame[XCANPS_MAX_FRAME_SIZE_IN_WORDS];
    enum can_baud_rate
    {
        rate_1000kbps,
        rate_800kbps,
        rate_500kbps,
        rate_250kbps,
        rate_125kbps,
        rate_100kbps,
        rate_50kbps,
        rate_20kbps
    };
    typedef struct
    {
      u16 id;    /**< frame's ID */
      u8 rtr;        /**< remote transmission request. (0 if not rtr frame, 1 if rtr frame) */
      u8 len;        /**< frame's length (0 to 8) */
      u8 data[8]; /**< frame's data */
    } can_frame;
    typedef struct
    {
      u8 BaudRate;
      u8 BaudRatePrescaler;
      u8 TimeSegment1;
      u8 TimeSegment2;
      u8 SyncJumpWidth;
    } can_bit_timing;
    int can_init(XCanPs *CanInstPtr, u16 DeviceId, u8 BaudRate);
    int Can_send(XCanPs *InstancePtr, can_frame *msg);
    int CanSetupIntrSystem(XScuGic *IntcInstancePtr, XCanPs *CanInstancePtr, u16 CanIntrId);
    void SendHandler(void *CallBackRef);
    void RecvHandler(void *CallBackRef);
    void ErrorHandler(void *CallBackRef, u32 ErrorMask);
    void EventHandler(void *CallBackRef, u32 Mask);
    #endif /* SRC_CAN_ZYNQ_H_ */

     

    can_zynq.c

    #include "can_zynq.h"
    #include "sys_intr.h"
    can_bit_timing can_bit_timing_config[]=
    {
        {rate_1000kbps, 1,  15, 2, 2},
        {rate_800kbps,  4,  6, 1, 1},
        {rate_500kbps,  4,  12, 1, 0},
        {rate_250kbps,  9, 12, 1, 0},
        {rate_125kbps,  19, 12, 1, 0},
        {rate_100kbps,  24, 12, 1, 0},
        {rate_50kbps,   49, 12, 1, 0},
        {rate_20kbps,   124, 12, 1, 0}
    };
    static int Config(XCanPs *InstancePtr ,u8 BaudRate)
    {
        int i;
        XCanPs_EnterMode(InstancePtr, XCANPS_MODE_CONFIG);
        while(XCanPs_GetMode(InstancePtr) != XCANPS_MODE_CONFIG);
        for(i=0; i<(sizeof(can_bit_timing_config)/sizeof(can_bit_timing)); i++)
        {
            if(can_bit_timing_config[i].BaudRate == BaudRate)
            {
                XCanPs_SetBaudRatePrescaler(InstancePtr, can_bit_timing_config[i].BaudRatePrescaler);
                XCanPs_SetBitTiming(InstancePtr,  can_bit_timing_config[i].SyncJumpWidth,
                        can_bit_timing_config[i].TimeSegment2,can_bit_timing_config[i].TimeSegment1);
                break;
            }
            if(i == ((sizeof(can_bit_timing_config)/sizeof(can_bit_timing)) - 1))
            {
                xil_printf("Baud rate not found!\r\n");
                return XST_FAILURE;
            }
        }

    }
    int can_init(XCanPs *CanInstPtr, u16 DeviceId, u8 BaudRate)
    {

        XCanPs_Config *ConfigPtr;
        int Status;
        int i;
        ConfigPtr = XCanPs_LookupConfig(DeviceId);
        if (CanInstPtr == NULL)
            {
            return XST_FAILURE;
         }
        Status = XCanPs_CfgInitialize(CanInstPtr,ConfigPtr,ConfigPtr->BaseAddr);
        if (Status != XST_SUCCESS)
        {
            return XST_FAILURE;
        }
        Status = XCanPs_SelfTest(CanInstPtr);
        if (Status != XST_SUCCESS)
           {
            return XST_FAILURE;
        }
        Config(CanInstPtr,BaudRate);
        XCanPs_SetHandler(CanInstPtr, XCANPS_HANDLER_SEND,(void *)SendHandler, (void *)CanInstPtr);
        XCanPs_SetHandler(CanInstPtr, XCANPS_HANDLER_RECV,(void *)RecvHandler, (void *)CanInstPtr);
        XCanPs_SetHandler(CanInstPtr, XCANPS_HANDLER_ERROR,(void *)ErrorHandler, (void *)CanInstPtr);
        XCanPs_SetHandler(CanInstPtr, XCANPS_HANDLER_EVENT,(void *)EventHandler, (void *)CanInstPtr);
        Status =  CanSetupIntrSystem(&Intc, CanInstPtr, CAN_INTR_VEC_ID);
        if (Status != XST_SUCCESS)
           {
            return XST_FAILURE;
        }
        XCanPs_EnterMode(CanInstPtr, XCANPS_MODE_NORMAL);
        while(XCanPs_GetMode(CanInstPtr) != XCANPS_MODE_NORMAL);
        return XST_SUCCESS;
    }

    int Can_send(XCanPs *InstancePtr, can_frame *msg)
    {
        int Status;
        u32 TxFrame[XCANPS_MAX_FRAME_SIZE_IN_WORDS] = {0};
        TxFrame[0] = (u32)XCanPs_CreateIdValue((u32)msg->id, (u32)msg->rtr, 0, 0, 0);
        TxFrame[1] = (u32)XCanPs_CreateDlcValue((u32)msg->len);
        TxFrame[2] = (u32)(((u32)msg->data[3] << 24) | ((u32)msg->data[2] << 16) | ((u32)msg->data[1] << 8) | ((u32)msg->data[0]));
        TxFrame[3] = (u32)(((u32)msg->data[7] << 24) | ((u32)msg->data[6] << 16) | ((u32)msg->data[5] << 8) | ((u32)msg->data[4]));
        while (XCanPs_IsTxFifoFull(InstancePtr) == TRUE);
        Status = XCanPs_Send(InstancePtr, TxFrame);
        if (Status != XST_SUCCESS)
            {
            xil_printf("Can send failed\r\n");
        }
        return Status;
    }

    int CanSetupIntrSystem(XScuGic *IntcInstancePtr,XCanPs *CanInstancePtr,u16 CanIntrId)
    {
        int Status;
        Status = XScuGic_Connect(IntcInstancePtr, CanIntrId,(Xil_InterruptHandler)XCanPs_IntrHandler,(void *)CanInstancePtr);
        if (Status != XST_SUCCESS)
        {
            return Status;
         }
        XScuGic_Enable(IntcInstancePtr, CanIntrId);
        XCanPs_IntrEnable(CanInstancePtr, XCANPS_IXR_ALL);
        return XST_SUCCESS;
    }
    void SendHandler(void *CallBackRef)
    {
        xil_printf("Can send done\r\n");
    }

    void RecvHandler(void *CallBackRef)
    {
        XCanPs *CanPtr = (XCanPs *)CallBackRef;
        int Status;
        int i;
        can_frame msg = {0};
        u8 *FramePtr;

        xil_printf("Can receive done\r\n");

        Status = XCanPs_Recv(CanPtr, RxFrame);

        if (Status != XST_SUCCESS) {
            xil_printf("Can receive failed\r\n");
            return;
        }
        msg.id = (u16)((RxFrame[0] & XCANPS_IDR_ID1_MASK )>> XCANPS_IDR_ID1_SHIFT);
        msg.rtr = (u8)((RxFrame[0] & XCANPS_IDR_SRR_MASK) >> XCANPS_IDR_SRR_SHIFT);
        msg.len = (u8)((RxFrame[1] & XCANPS_DLCR_DLC_MASK) >> XCANPS_DLCR_DLC_SHIFT);
        FramePtr = (u8 *)(&RxFrame[2]);
        for(i=0; i<8; i++)
        {
            msg.data[i] = *FramePtr++;
        }
        xil_printf("frame ID: %d\r\n", msg.id);
        xil_printf("frame type: %s\r\n", msg.rtr ? "remote request frame" : "data frame");
        xil_printf("frame length: %d\r\n", msg.len);
        if(!msg.rtr)
        {
            for(i=0; i<msg.len; i++)
            {
                xil_printf("data %d is: 0x%02x\r\n", i+1, msg.data[i]);
            }
        }
    }
    void ErrorHandler(void *CallBackRef, u32 ErrorMask)
    {
        xil_printf("Can error happen\r\n");

    }
    void EventHandler(void *CallBackRef, u32 IntrMask)
    {
        XCanPs *CanPtr = (XCanPs *)CallBackRef;
        xil_printf("Can event happen\r\n");
        if (IntrMask & XCANPS_IXR_BSOFF_MASK)
        {
            XCanPs_Reset(CanPtr);
            Config(CanPtr,rate_500kbps);
            return;
         }
    }

    主函数main.c

    #include "can_zynq.h"
    #include "sys_intr.h"
    #include "sleep.h"
    int main(void)
    {
        can_frame msg;
        int i;
        xil_printf("Can start\r\n");

        Init_Intr_System(&Intc);
        can_init(&Can, CAN_DEVICE_ID, rate_500kbps);
        Setup_Intr_Exception(&Intc);

        msg.id = 1;
        msg.rtr = 0;
        msg.len = 8;
        for(i=0; i<msg.len; i++)
         {
            msg.data[i] = i;
         }
        while(1)
        {
            Can_send(&Can, &msg);
            msg.data[0]++;
            sleep(5);
        }
    }

    可以外接如下模块和can分析仪下载运行,打开canpro查看数据:先测试一下CAN通信是否正常

    4,将*.hdf硬件复制到虚拟机

    petalinux-create --type project --template zynq --name can_test

    petalinux-config --get-hw-description ../linux_base.sdk

    5,在devicetree中需要增加can的配置信息,如下:

    can@e0008000 {
                                compatible= "xlnx,zynq-can-1.0";
                                status= "okay";
                                clocks= <0x1 0x13 0x1 0x24>;
                                clock-names= "ref_clk", "aper_clk";
                                reg = <0xe00080000x1000>;
                                interrupts= <0x0 0x1c 0x4>;
                                interrupt-parent= <0x3>;
                                tx-fifo-depth= <0x40>;
                                rx-fifo-depth= <0x40>;
    };

    6,添加CAN总线驱动,在kernel中需要增加can驱动的支持:petalinux-config -c kernel

    7,ifconfig  -a可以查看到如下信息:

    设置can0的波特率,这里设置的是100k:ip link set can0 type can bitrate100000

    启用can0:ip link set can0 up

    显示can0状态信息:ip -d -s link show can0

    8,按sdk时候的连接,测试can收发数据

    9,linux下的can总线应用程序示范:test_can.c

    #include <stdio.h>
    #include <string.h>
    #include <sys/socket.h>
    #include <linux/sockios.h>
    #include <linux/if.h>
    #include <pthread.h>
    #include "can.h"
    #define PF_CAN 29
    #define AF_CAN PF_CAN
    #define SIOCSCANBAUDRATE        (SIOCDEVPRIVATE+0)
    #define SIOCGCANBAUDRATE        (SIOCDEVPRIVATE+1)
    #define SOL_CAN_RAW (SOL_CAN_BASE + CAN_RAW)
    #define CAN_RAW_FILTER  1
    #define CAN_RAW_RECV_OWN_MSGS 0x4
    typedef __u32 can_baudrate_t;
    struct ifreq ifr;
    int init_can(char* can)
    {
        int sock;
        struct sockaddr_can addr;
        sock = socket(PF_CAN, SOCK_RAW, CAN_RAW);
        if(sock < 0)
        {
            printf("error\n");
            return -1;
        }
        addr.can_family = AF_CAN;
        strcpy(ifr.ifr_name, can );
        int ret;
        ret = ioctl(sock, SIOCGIFINDEX, &ifr);  //get index
        if(ret && ifr.ifr_ifindex == 0)
        {
            printf("Can't get interface index for can0, code= %d, can0 ifr_ifindex value: %d, name: %s\n", ret, ifr.ifr_ifindex, ifr.ifr_name);
            close(sock);
            return -1;
        }

        printf("%s can_ifindex = %x\n",ifr.ifr_name,ifr.ifr_ifindex);
        addr.can_ifindex = ifr.ifr_ifindex;    
        int recv_own_msgs = 0;//set loop back:  1 enable 0 disable
        setsockopt(sock, SOL_CAN_RAW, CAN_RAW_RECV_OWN_MSGS,&recv_own_msgs, sizeof(recv_own_msgs));
        if (bind(sock,(struct sockaddr*)&addr,sizeof(addr))<0)
        {
            printf("bind error\n");
            close(sock);
            return -1;
        }
        return sock;
    }

    void Can_Read_thread(void* psock)
    {
        int sock = *(int *)psock;
        int i = 0;
        struct can_frame frame;
        while(1)
        {
            memset(&frame,0,sizeof(struct can_frame));
            read(sock,&frame,sizeof(struct can_frame));
            if(frame.can_dlc)
            {
                printf("\n%s DLC:%d Data:", ifr.ifr_name, frame.can_dlc);        
                for(i = 0; i < frame.can_dlc; i++)
                {
                    printf("%#x ",frame.data[i]);
                }
                printf("\n");
            }
        }    
    }

    int Write_Can_Data(int sock,char* str,int len)
    {
        struct can_frame frame;
        int i;
        int nbytes = 0;
        frame.can_id = 0x0; //can device id
        while(len)
        {
            if(len > sizeof(frame.data))
            {
                memset(&frame.data,0,sizeof(frame.data));
                memcpy(&frame.data,str,sizeof(frame.data));
                //printf("%d,(%s)\r\n",sizeof(frame.data),frame.data);
                frame.can_dlc = sizeof(frame.data);
                str += sizeof(frame.data);
                len -= sizeof(frame.data);
            }
            else {
                memset(&frame.data,0,sizeof(frame.data));
                memcpy(&frame.data,str,len);
                //printf("%d,(%s)\r\n",len,frame.data);
                frame.can_dlc = len;
                str = NULL;
                len = 0;
            }
            write(sock, &frame, sizeof(struct can_frame));
            usleep(100);
        }
    }

    int main(int argc ,char** argv)
    {
        int sock;
        int nbytes;
        pthread_t canthreadid;
        int ret;
        char str[4096];
        if(argc < 2)
        {
            printf("Usage: %s <device>(can0/can1)\n", argv[0]);
            return 0;
        }
        sock = init_can(argv[1]);
        if(sock < 0)
        {
            return 0;
        }
        ret=pthread_create(&canthreadid,NULL,(void*)Can_Read_thread,&sock);
        while(1)
        {
            printf("Please Input string to send to %s\n:",argv[1]);
            scanf("%s", str);
            if(strlen(str)>0)
                Write_Can_Data(sock,str,strlen(str));
        }
    //    struct can_frame frame;
    //    char    buf[20];
    //    frame.can_id = 0x0; //can device id
    //    int i;
    //    for(i=0;i<20;i++)
    //    {
            //nbytes = sendto(sock,&frame,sizeof(struct can_frame),0,(struct sockaddr*)&addr,sizeof(addr));
    //        memset(&buf,0,sizeof(buf));    
    //        sprintf(buf,"%s%d","hello",i);
    //        strcpy((char *)frame.data,buf);
    //        frame.can_dlc = strlen(frame.data);
    //        nbytes = write(sock, &frame, sizeof(struct can_frame));
    //        printf("%d. %ld bytes has been sent\n", i, nbytes);
    //        sleep(1);
    //    }
        close(sock);
        printf("ok\n");    
        return 0;
    }

     

    展开全文
  • ARM芯片扩展CAN总线

    2009-12-29 08:42:18
    ARM芯片扩展CAN总线方法简单.网络上基本上是用PHILP拓展的.我的是直接拓展的.里面有应用程序.资源5分.我觉的值 .做工业控制的人绝对有帮助.
  • CAN通讯协议是一个载波侦听、基于报文优先级碰撞检测和仲裁(CSMA/CD+AMP)的多路访问协议。CSMA的意思是总线上的每一个节点在企图发送报文前,必须要监听总线,当总线处于空闲时,才可发送。CD+AMP的意思是通过预定...

    CAN通讯协议是一个载波侦听、基于报文优先级碰撞检测和仲裁(CSMA/CD+AMP)的多路访问协议。CSMA的意思是总线上的每一个节点在企图发送报文前,必须要监听总线,当总线处于空闲时,才可发送。CD+AMP的意思是通过预定编程好的报文优先级逐位仲裁来解决碰撞,报文优先级位于每个报文的标识域。更高级别优先级标识的报文总是能获得总线访问权,即:标识符中最后保持逻辑高电平的会继续传输,因为它具有更高优先级。
    在这里插入图片描述

    ISO-11898:2003标准,带有11位标识符,提供的最高信号速率从125Kbps到1Mbps。更迟一些的修订标准使用了扩展的29位标识符。

    标准CAN

    标准CAN只有11位标识符,每帧的数据长度为51+(064)=(51117)位。

    标准CAN---11位标识符

    · SOF - 帧起始。显性(逻辑0)表示报文的开始,并用于同步总线上的节点。

    · 标识符 - 标准CAN具有11位标识符,用来确定报文的优先级。

    此域的数值越小,优先级越高。

    · RTR - 远程发送请求位。

    当需要从另一个节点请求信息时,此位为显性(逻辑0)。

    所有节点都能接收这个请求,但是帧标识符确定被指定的节点。

    响应数据帧同样被所有节点接收,可以被有兴趣的节点使用。

    · IDE - 标识符扩展位,为显性时表示这是一个标准CAN格式,为隐形表示这是扩展CAN格式。

    · r0 - 保留位(可能将来标准修订会使用)。

    · DLC - 4位数据长度代码表示传输数据的字节数目,一帧CAN最多传输8字节用户数据。

    · 数据0~8 – 最多可以传输8字节用户数据。

    · CRC - 16位(包括1位定界符)CRC校验码,用来校验用户数据区之前的(包含数据区)传输数据段。

    · ACK - 2位,包含应答位和应答界定符。

    发送节点的报文帧中,ACK两位是隐性位,当接收器正确地接收到有效的报文,接收器会在应答位期间向发送节点发送一个显性位,表示应答。

    如果接收器发现这帧数据有错误,则不向发送节点发送ACK应答,发送节点会稍后重传这帧数据。

    · EOF – 7位帧结束标志位,全部为隐性位。

    如果这7位出现显性位,则会引起填充错误。

    · IFS – 7位帧间隔标志位,CAN控制器将接收到的帧正确的放入消息缓冲区是需要一定时间的,帧间隔可以提供这个时间。

    扩展CAN

    扩展CAN具有29位标识符,每帧数据长度为71+(064)=(71135)位。

    注:不计位填充。

    扩展CAN---29位标识符

    扩展CAN消息相对于标准CAN消息增加的内容如下:

    · SRR – 代替远程请求位,为隐性。所以当标准帧与扩展帧发送相互冲突并且扩展帧的基本标识符与标准帧的标识符相同时,标准帧优先级高于扩展帧。

    · IDE – 为隐性位表示标志位扩展帧,18位扩展标识符紧跟着IDE位。

    · r1 – 保留

    展开全文
  • 介绍了西门子S7-300 PLC控制器在采煤机上的应用,针对目前煤矿自动化的要求提出了基于PLC系统的CAN总线扩展。详细介绍了CAN网关模块的硬件和软件,介绍了CAN总线在采煤机PLC控制系统上的实现方法。
  • LPCI-252通用型PCI接口CAN卡,具有2路 CAN通道和一路PCI接口,插到电脑的PCI卡槽上,快速扩展出2路CAN通道。CAN接口采用金升阳电源模块和信号隔离芯片实现2500V DC电气隔离,USB接口ESD静电防护;具有优秀的EMC性能...

    LPCI-252通用型PCI接口CAN卡,具有2路 CAN通道和一路PCI接口,插到电脑的PCI卡槽上,快速扩展出2路CAN通道。CAN接口采用金升阳电源模块和信号隔离芯片实现2500V DC电气隔离,USB接口ESD静电防护;具有优秀的EMC性能,可靠性测试项目:ESD接触放电8KV、浪涌±1KV、脉冲群±2KV。
    在这里插入图片描述
    配套测试软件LCANTest使用,接收、发送、分析、记录、回放CAN报文;配套丰富驱动;配套包含库函数、库函数调用说明和丰富例程的二次开发资料包;提供全程专家指导服务。
    产品特性
    ﹂ 33M PCI数据总线,符合PCI 2.2 标准
    ﹂ 2路CAN通道
    ﹂ CAN波特率支持5Kbps~1Mbps
    ﹂ 符合CAN 2.0A/2.0B规范
    ﹂ 符合ISO/DIS 11898-1/2/3标准
    ﹂ 单通道最高帧流量高达14000帧/s
    ﹂ CAN接口电气隔离高达2500VDC,每路CAN通道独立隔离
    ﹂ 提供Windows、Linux/Ubuntu等的驱动和二次开发资料包
    ﹂ 提供支持主流开发环境的丰富例程
    ﹂ 工作温度:-40℃至+85℃
    ﹂ 接口防浪涌、防脉冲群、ESD保护设计
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • 以往,在升级至或扩展CAN FD功能时,设计师不得不在其设计中整合多个分立的组件或彻底修改微控制器,不仅耗时,而且成本高昂。为此,TI公司推出了新款汽车系统基础芯片(SB...
        

    640?wx_fmt=jpeg


    以往,在升级至或扩展CAN FD功能时,设计师不得不在其设计中整合多个分立的组件或彻底修改微控制器,不仅耗时,而且成本高昂。为此,TI公司推出了新款汽车系统基础芯片(SBC)TCAN4550-Q1。它集成了使用灵活数据速率控制器局域网(CAN FD)的控制器和收发器,采用了几乎所有微控制器的串行外围接口(SPI)总线来部署CAN FD接口,或提高系统中CAN FD总线端口的数量,同时对硬件进行最少的改动。


    有了这款芯片,设计师能够保有汽车电子和照明、高级驾驶员辅助系统(ADAS)及汽车网关设计的基于微控制器的现有架构,简化CAN FD的升级或扩展。来听听TI公司接口产品部门产品线经理Charles (Chuck) Sanna的详细解读吧!


    640?wx_fmt=png

    什么是SBC?

    系统基础芯片(SBC)是纯粹的集成电路,它将控制器局域网络(CAN)或本地互联网络(LIN)收发器与内部/外部“功率器件”集成在一起。该功率器件可以是低压差线性稳压器(LDO)、DC/DC转换器或两者兼有。当设计师需要更多输出功率,或者需要离散式解决方案的布局选项并且该方案需要收发器和离散式LDO或DC/DC转换器时,SBC无疑是理想的选择。


    对市场来说,SBC并非新生事物,但是,近期在集成和性能方面的创新大大拓展了这些设备的使用。对汽车设计师而言,其高水平的集成和更高的可靠性可以使其实现质量更轻和成本更低的设计。从经典CAN向灵活数据速率CAN(CAN FD)的转型,要求解决方案能够弥补CAN FD控制器和处理器可用性之间的差距。 

    什么是CAN FD?

    CAN FD通信协议是基于原始CAN总线标准(又称为“经典CAN”)而设计的,有助于确保多种车载网络数据传输率和吞吐量在继续演进的同时,汽车微控制器和连接的系统能够以各种速率高效通信。CAN FD协议支持高达5 Mbps的数据传输率和高达64字节的有效负荷,有效提升了设计师的能力,使其能够在其下一代汽车应用中更快速地移动数据。

    TCAN4550-Q1有哪些优势?

    (1)轻松升级和扩展CAN FD总线

    如果微控制器的CAN FD端口数量有限,设计师可以使用这款芯片经由汽车系统中现有的SPI端口添加更多的CAN FD总线。通常来讲,此类总线扩展需要重新设计系统,而使用TCAN4550-Q1则可以轻松便捷地实现CAN FD总线的升级和扩展。


    (2)提高最大数据传输率

    全新SBC支持汽车在组装期间能够基于8 Mbps最高数据传输率来更快速地编写汽车软件程序,超越了CAN FD协议的5 Mbps最高数据传输率。 


    (3)小封装尺寸减少板载空间

    凭借集成式125 mA低压差(LDO)线性稳压器,TCAN4550-Q1不仅可以为自己供电,还能为传感器或其他组件供应70 mA的外部输出。由于减少了对外部电源组件的需要,因此缩小了电源设计所占的空间。


    (4)提高设计灵活性

    设计师依托高度集成的TCAN4550-Q1可以简化设计,包括集成式±58-VDC总线故障保护、看门狗计时器及故障切换模式。此外,TCAN4550-Q1还能够交叉兼容经典CAN协议。 

    TI为基础技术注入新的生命力

    如果你熟悉CAN或LIN收发器,就一定知道,这些收发器提供其相应技术的输入和输出。一旦它们收到数据包,这些收发器就会将数据传送给微控制器或微处理器进行进一步的操作。反之,它们会从同一处理器接收信息,经由相关总线进行出站通信。


    尽管CAN和LIN收发器在本质上看是相当基础的技术,但供应商在持续为其添加更多功能,在力求增加保护功能的同时,削减设计的复杂性、空间和成本。这些功能通常包括总线故障保护和静电释放保护,以及通过1.8 ~3.3V 或 1.8~5V输入/输出(也称为VIO)与处理器往返数据的能力。


    除了TCAN4550-Q1之外,TI还有很多其他产品,包括车规级的CAN收发器、车规级的LIN收发器(LIN是单线低速率接口)、3.3V工业级CAN收发器、5V CAN收发器(传统汽车电瓶车12V,商用型汽车电瓶是24V,但有时会震荡到50~60V,TI 5V CAN 收发器最高支持70V耐压,可以支持商用车),以及隔离式CAN收发器(主要针对新能源汽车,其电轨既有400V,也有低压轨12V、24V,它们之间需要进行隔离)。TI希望借助这些丰富的产品来助力产业的快速发展。

    640?

    640?wx_fmt=png

    1.魏少军:外国供应商曾问我,如果中国不买芯片了,他们怎么办?!

    2.谁先扛不住?英特尔美光恢复供货华为

    3.谷歌和 Facebook 是如何给工程师定职级和薪水的?

    4.587所大学90个一流学科榜:电子专业哪家强?

    5.树莓派 4 发布!新 OS 基于 Debian 10 Buster

    6.基于STM32的多种printf用法,你都知道吗?

    640?wx_fmt=gif


    展开全文
  • 本文介绍了一种基于ARM920T现场总线的控制系统,详细说明了其上扩展CAN总线的两种方式,并给出具体的CAN模块在实时操作系统eCos上驱动程序开发的步骤,最后对两种扩展进行了简要的比较。
  • CAN总线扩展数据帧介绍

    千次阅读 2018-03-27 08:22:02
    扩展CAN 数据帧中,紧随SOF 位的是32 位的仲裁字段。仲裁字段的前11 位为29 位标识符的最高有效位(Most Significant bit,MSb)(基本lD) 。紧随这11 位的是替代远程请求(Substitute Remote Request, SRR)位...
  • 这是一个NodeJS SocketCAN扩展。 SocketCAN是用于Linux系统的CANbus协议的基于套接字的实现。 通过此扩展,可以使用简单的Javascript函数发送和接收CAN消息(扩展的远程传输)。 用法 基本的CAN示例: var can = ...
  • 如何扩展MCU的CAN接口

    2021-01-19 21:23:13
     当应用 CAN 总线时,我们可能会面临以下问题:主控制器没有支持 CAN 控制器或者 CAN 路数不够。具体问题表现:早期产品通信使用的是 RS485 或 RS232 通信,现阶段需要将产品升级到能支持到 CAN 通信;受制于成本...
  • 如果要实现通信距离远、通信速率高、总线节点数量多CAN总线系统,实现CAN总线的扩展,就需要一个CAN网关进行桥接,把CAN总线划分为几个子网,增加CAN总线通信节点,延长CAN总线的传输距离,提高CAN总线的传输速率。...
  • 摘要 随着数字信号处理器TMS320F2812的广泛应用,扩展TMS320F2812的CAN总线接口成为一种趋势。针对本公司某测试设备的整体设计要求,利用具有SPI接口的独立CAN控制器MCP2515通过TMS320F2812的SPI接口,实现TMS320F...
  • CAN扩展帧详解

    千次阅读 2020-08-12 16:27:36
    寻址方式
  • CAN通信标准帧和扩展

    万次阅读 2018-08-09 11:40:16
    CAN接口兼容规范2.0A和2.0B(主动),位速率高达1兆位/秒。它可以接收和发送11位标识符的标准帧,也可以接收和发送29位标识符的扩展帧。 扩展帧的仲裁域有29位,可以出现2^29中报文,且在数据链路上是有间隙的(对操作...
  • 本文详细介绍了基于PIC单片机的CAN总线扩展技术,给出了CAN网关的硬件设计原理及软件设计框图,通过CAN网关增加了CAN总线的容量、提高了CAN总线的通信速率、扩展CAN总线的传输距离。
  • CAN扩展帧和标准帧格式对比分析.docx
  • Xilinx AXI CAN

    2021-03-02 22:54:15
    2.MicroBlaze扩展CAN接口 3.IP获取方式 1.AXI CAN框图 2.MicroBlaze扩展CAN接口 通过AXI接口,可以通过FPGA扩展出多个CAN节点,相当灵活。 3.IP获取方式 关注【一个早起的程序员】。 ...
  • CAN 扩展帧和标准帧的适用范围

    千次阅读 2018-12-22 11:07:43
    今天弄懂了CAN的标准帧和扩展帧的使用场合,故此做一下笔记。 首先,得知道为什么会有这两种不同的帧。 其实原因和IPV4和IPV6的区别一样,IPV6的出现,是为了解决IPV4的地址不够用的尴尬。同样,CAN扩展帧,是...
  • CAN总线的标准帧和扩展

    千次阅读 2020-07-29 18:10:26
    CAN总线的标准帧和扩展帧主要决定帧ID的长度, 标准帧的帧ID长度是11位,帧ID的范围是000-7FF。 扩展帧的帧ID长度是29位,帧ID的范围是0000 0000-1FFF FFFF。CANopen帧ID最多是11位的,因此是标准帧;而SAE 1939...
  • 为什么CAN需要扩展ID,

    千次阅读 2017-12-04 11:20:48
    一张图诠释CAN标准帧和扩展帧的区别-太阳能电动汽车网 http://www.tyncar.com/News/hy/20160828_23101.html 目的就是构造29位的CAN ID,可以实现更加庞大的ID群,妈妈再也不用担心ID不够用了!
  • 基于CompactPCI总线的CAN总线扩展模块设计
  • 在分析磨加工主动量仪的结构特点与工作原理的基础上,针对现有磨加工主动量仪测量通道数少、迫切需要一机配多测量装置的问题,提出了一种基于CAN总线的磨加工主动量仪多通道扩展方法,构建了多通道扩展系统方案,...
  • 如果将原来由11个标识符位定义的地址范围扩大,则可以更方便地使用can实现这些应用程序。因此,引入了第二种消息格式(“扩展格式”),其提供由29位定义的更大的地址范围。   The acceptance and introduction of...
  • 文件扩展名大全,CANbus总线介绍.自己在工作中的需求
  • 该NXP CAN-FD Shield扩展板提供了CAN/CAN-FD双收发器,可与支持CAN的LPCXpresso V3风格的电路板一起使用。此电路板具有NXP TJA1059双收发器以及RS232C收发器。从Shield扩展板兼容所有LPCXpresso546xx电路板(虽然...
  • 飞思卡尔MC9S12XS128芯片,CAN报文发送程序,本例程是扩展帧报文发送程序,供有需要的朋友参考。
  • 摘要 随着数字信号处理器TMS320F2812的广泛应用,扩展TMS320F2812的CAN总线接口成为一种趋势。针对本公司某测试设备的整体设计要求,利用具有SPI接口的独立CAN控制器MCP2515通过TMS320F2812的SPI接口,实现TMS320F...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,028
精华内容 1,211
关键字:

扩展can