linux socket can测试

1. Overview / What is Socket CAN

--------------------------------

The socketcan package is an implementation of CAN protocols (Controller Area Network) for Linux.  CAN is a networking technology which has widespread use in automation, embedded devices, and automotive fields.  While there have been other CAN implementations for Linux based on character devices, Socket CAN uses the Berkeley socket API, the Linux network stack and implements the CAN device drivers as network interfaces.  The CAN socket API has been designed as similar as possible to the TCP/IP protocols to allow programmers, familiar with network programming, to easily learn how to use CAN sockets.

2. Motivation / Why using the socket API

----------------------------------------

There have been CAN implementations for Linux before Socket CAN so the question arises, why we have started another project.  Most existing implementations come as a device driver for some CAN hardware, they are based on character devices and provide comparatively little functionality.  Usually, there is only a hardware-specific device driver which provides a character device interface to send and receive raw CAN frames, directly to/from the controller hardware. Queueing of frames and higher-level transport protocols like ISO-TP have to be implemented in user space applications.  Also, most character-device implementations support only one single process to open the device at a time, similar to a serial interface.  Exchanging the CAN controller requires employment of another device driver and often the need for adaption of large parts of the application to the new driver‘s API.

Socket CAN was designed to overcome all of these limitations.  A new protocol family has been implemented which provides a socket interface to user space applications and which builds upon the Linux network layer, so to use all of the provided queueing functionality.  A device driver for CAN controller hardware registers itself with the Linux network layer as a network device, so that CAN frames from the controller can be passed up to the network layer and on to the CAN protocol family module and also vice-versa.  Also, the protocol family module provides an API for transport protocol modules to register, so that any number of transport protocols can be loaded or unloaded dynamically.  In fact, the can core module alone does not provide any protocol and cannot be used without loading at least one additional protocol module.  Multiple sockets can be opened at the same time, on different or the same protocol module and they can listen/send frames on different or the same CAN IDs.  Several sockets listening on the same interface for frames with the same CAN ID are all passed the same received matching CAN frames.  An application wishing to communicate using a specific transport protocol, e.g. ISO-TP, just selects that protocol when opening the socket, and then can read and write application data byte streams, without having to deal with CAN-IDs, frames, etc.

Similar functionality visible from user-space could be provided by a character device, too, but this would lead to a technically inelegant solution for a couple of reasons:

* Intricate usage.  Instead of passing a protocol argument to socket(2) and using bind(2) to select a CAN interface and CAN ID, an application would have to do all these operations using ioctl(2)s.

* Code duplication.  A character device cannot make use of the Linux network queueing code, so all that code would have to be duplicated

for CAN networking.

* Abstraction.  In most existing character-device implementations, the hardware-specific device driver for a CAN controller directly

provides the character device for the application to work with.

This is at least very unusual in Unix systems for both, char and

block devices.  For example you don‘t have a character device for a certain UART of a serial interface, a certain sound chip in your computer, a SCSI or IDE controller providing access to your hard

disk or tape streamer device.  Instead, you have abstraction layers which provide a unified character or block device interface to the application on the one hand, and a interface for hardware-specific device drivers on the other hand.  These abstractions are provided

by subsystems like the tty layer, the audio subsystem or the SCSI

and IDE subsystems for the devices mentioned above.

The easiest way to implement a CAN device driver is as a character device without such a (complete) abstraction layer, as is done by most existing drivers.  The right way, however, would be to add such a

layer with all the functionality like registering for certain CAN

IDs, supporting several open file descriptors and (de)multiplexing

CAN frames between them, (sophisticated) queueing of CAN frames, and providing an API for device drivers to register with.  However, then

it would be no more difficult, or may be even easier, to use the networking framework provided by the Linux kernel, and this is what Socket CAN does.

The use of the networking framework of the Linux kernel is just the natural and most appropriate way to implement CAN for Linux.

 参照http://archive.cnblogs.com/a/1916143/,交叉编译了can-utils 4.0.6的几个重要工具。busybox的文件系统还要移植ip命令。

1、

首先配置can0

ip link set can0 type can tq 125 prop-seg 6  phase-seg1 7 phase-seg2 2 sjw 1

这时dmesg可以看到sja1000_fpga_pci 0000:07:04.0: setting BTR0=0x01 BTR1=0x1c

周立功的usbcan-2a测试模块里,波特率250kbs时就是BTR0=0x01 BTR1=0x1c

2、

ip -details link show can0 查看一下

can0: <NOARP,UP,LOWER_UP,ECHO> mtu 16 qdisc pfifo_fast state UNKNOWN qlen 10

link/can

can state ERROR-ACTIVE (berr-counter tx 0 rx 0) restart-ms 0

bitrate 500000 sample-point 0.875

tq 125 prop-seg 6 phase-seg1 7 phase-seg2 2 sjw 1

sja1000: tseg1 1..16 tseg2 1..8 sjw 1..4 brp 1..64 brp-inc 1

clock 16000000

3、接收测试,接收测试软件发送的帧:

# ./candump can0

interface = can0, family = 29, type = 3, proto = 1

<0x00000002> [8] 70 01 02 03 04 05 06 07

<0x00000002> [8] 70 01 02 03 04 05 06 07

<0x00000002> [8] 70 01 02 03 04 05 06 07

<0x00000002> [8] 70 01 02 03 04 05 06 07

<0x00000002> [8] 70 01 02 03 04 05 06 07

<0x00000002> [8] 70 01 02 03 04 05 06 07

<0x00000002> [8] 70 01 02 03 04 05 06 07

<0x00000002> [8] 70 01 02 03 04 05 06 07

<0x00000002> [8] 70 01 02 03 04 05 06 07

4、发送测试

./cansend can0 -e 0x11 0x22 0x33 0x44 0x55 0x66 0x77 0x88

interface = can0, family = 29, type = 3, proto = 1

测试软件上能看到接收的帧

5、重启

使用内核文档说的ip link set can0 type can restart-ms 100 会报

RTNETLINK answers: Device or resource busy

使用ifconfig can0 down ;ip link set can0 up type can

即可

4种常见波特率:

250kbps:

ip link set can0 type can tq 125 prop-seg 6  phase-seg1 7 phase-seg2 2 sjw 1

125kbps:

ip link set can0 type can tq 250 prop-seg 6  phase-seg1 7 phase-seg2 2 sjw 1

500kbps:

ip link set can0 type can tq 75 prop-seg 6  phase-seg1 7 phase-seg2 2 sjw 1

1000kbps:

ip link set can0 up type can bitrate 2000000

常见用法:

ip -details link show can0

ifconfig can0 down ;ip link set can0 up type can

./candump can0

./cansend   can0 -e 0x11 0x22 0x33 0x44 0x55 0x66 0x77 0x88

时间: 2024-10-02 15:04:08

linux socket can测试的相关文章

windows 与 Linux SOCKET通讯

? 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 windows client 端口 // Def_win_client_socket_test.cpp :

Linux Socket基础介绍

Linux Socket函数库是从Berkeley大学开发的BSD UNIX系统中移植过来的.BSD Socket接口是众多Unix系统中被广泛支持的TCP/IP通信接口,Linux下的Socket程序设计,除了微小的差别之外,也适用于大多数其它Unix系统. Socket接口是TCP/IP网络的API,Socket接口定义了许多函数或例程,程序员可以用它们来开发TCP/IP网络上的应用程序.网络的Socket数据传输是一种特殊的I/O,Socket也是一种文件描述符. Socket的使用和文件

Linux Socket - 基本socket链接

0x0000 Linux Socket 函数 bind listen connect accept send recv read write 0x0001 Server绑不上ip 报错位置在bind函数 [[email protected] 01]# ./server 191.168.80.151 1588 191.168.80.151 : 1588 Bind: Cannot assign requested address port已被占用 报错位置在bind函数 [[email protec

OpenFastPath(2):原生态Linux Socket应用如何移植到OpenFastPath上?

版本信息: ODP(Open Data Plane): 1.19.0.2 OFP(Open Fast Path): 3.0.0 1.存在的问题 OpenFastPath作为一个开源的用户态TCP/IP协议栈,其对用户提供的Socket API,无论是宏定义.数据结构还是函数,均以OFP_开头.如下图所示: 1 int ofp_socket(int, int, int); 2 int ofp_socket_vrf(int, int, int, int); 3 int ofp_accept(int,

Java Socket编程以及与Linux Socket API关系

Socket 编程(基于Linux) Socket独立于具体协议的网络编程接口,在ISO模型中,主要位于会话层和传输层之间:在通用的计算机网络五层模型中,主要位于应用层和传输层之间. Linux Socket 基本上就是BSD Socket 需要使用的头文件 数据类型:#include <sys/types.h> 函数定义:#include <sys/socket.h> Socket类型 套接字是一种通信机制,通信两方的一种约定,用套接字中的相关函数来完成通信过程.根据传输内容分为

Kali Linux Web 渗透测试— 第十二课-websploit

Kali Linux Web 渗透测试— 第十二课-websploit 文/玄魂 目录 Kali Linux Web 渗透测试— 第十二课-websploit............................................... 1 Websploit 简介........................................................................................... 2 主要功能...........

shellKali Linux Web 渗透测试— 初级教程(第三课)

shellKali Linux Web 渗透测试— 初级教程(第三课) 文/玄魂 目录 shellKali Linux Web 渗透测试—初级教程(第三课)... 1 课程目录... 1 通过google hack寻找测试目标... 2 一个asp站点的sql注入... 3 一个php站点的sql注入... 4  课程地址:点击 课程目录 两个基本案例,以sql注入入手,目标为熟悉基本的思路,关注细节信息. 关于google hack,web 扫描,sql注入更详细和复杂的内容后续教程会专门讲解

Android Jni层 创建 linux socket 出错问题解决

问题: 想在Jni层创建 udp socket 与服务端通信,但是没有成功,最后发现竟然是创建socket失败(代码如下) // create socket g_sd = socket(AF_INET, SOCK_DGRAM, 0); if (-1 == g_sd) { perror("socket()"); goto err_socket; } 解决办法: 在 AndroidManifest.xml 文件中,添加访问网络的权限: <uses-permission android

使用Linux命令行测试网速

使用Linux命令行测试网速http://www.linuxde.net/2014/01/15561.html 当发现上网速度变慢时,人们通常会先首先测试自己的电脑到网络服务提供商(通常被称为"最后一公里")的网络连接速度.在可用于测试宽带速度的网站中,Speedtest.net也许是使用最广泛的. Speedtest.net的工作原理并不复杂:它在你的浏览器中加载JavaScript代码并自动检测离你最近的Speedtest.net服务器,然后向服务器发送HTTP GET and P