本文介绍如何在Nvidia Jetson Xavier与树莓派之间建立CAN通讯，包括硬件连接、寄存器配置、驱动加载及CAN转UDP程序实现。通过详细步骤和源代码分享，帮助读者掌握跨平台CAN通讯技术。
Nvidia Jetson Xavier与树莓派3b+进行can通讯
开启Nvidia Jetson Xavier与树莓派can
两硬件开启方式类似，选取的方式每次开机都需要进行配置，之后会写成一个脚本开机自启动。
Jetson Xavier
在Jetson Xavier上打开一个终端并按照以下步骤操作：
- 安装busybox以更改寄存器值
sudo apt-get install busybox
- 重新配置与CAN控制器引脚对应的四个寄存器值，如下:
sudo busybox devmem 0x0c303000 32 0x0000C400
sudo busybox devmem 0x0c303008 32 0x0000C458
sudo busybox devmem 0x0c303010 32 0x0000C400
sudo busybox devmem 0x0c303018 32 0x0000C458
- 然后使用modprobe命令安装CAN控制器并加载驱动程序
sudo modprobe can
sudo modprobe can_raw
sudo modprobe mttcan
- 下面启动can0，目前只需要一路can，下面的例子是CAN比特率(Bitrate)设置为500 Kbps
sudo ip link set can0 up type can bitrate 500000
- 使用ifconfig命令以检查CAN是否成功启用。应该能看到can0网络设备，如下图:
- 关闭can0
candump can0
硬件连接
树莓派上插入微雪CAN拓展板，拓展板上带有can收发器，引出can高低两根线，由于Jetson Xavier没有can收发器，所以自己买了个can的收发器与Xavier相连接，最重要的是两边连接时can高与can低之间要并联一个120欧姆电阻，才可以接收到信号。
can转udp程序
可能需要自己安装boost库（C++标准库）
#include <linux/can.h>
#include <sys/socket.h>
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <utility>
#include <sys/ioctl.h>
#include <sys/types.h>
#include <linux/can/raw.h>
#include <net/if.h>
#include <boost/thread.hpp>
#include <vector>
#include <sstream>
#include <boost/filesystem.hpp>
#include <netinet/in.h>
#include <time.h>
#include <arpa/inet.h>
#define can_id_recvAcc 0x520
#define can_id_recvBrk 0x510
#define can_id_recvSteer 0x500
#define sendAcc 0x421
#define sendBrk 0x411
#define sendSteer 0x401
#define SERV_PORT 33332
#define CANPORT "can0"
int Steering = 100;
int dAcc = 0;
int dBrk = 0;
int last_acc = 0;
int acc = 100;
int last_brk = 0;
int brake = 0;
char a = 0;
char b = 0;
char c = 0;
clock_t start = clock();
float dt = 0;
//接收油门底层执行器反馈
void RecvAcc()
{
int socket_fd;
unsigned long nbytes;
struct sockaddr_can addr;
struct ifreq ifrr;
socket_fd = socket(PF_CAN,SOCK_RAW,CAN_RAW);
strcpy(ifrr.ifr_name,CANPORT);
ioctl(socket_fd,SIOCGIFINDEX,&ifrr);
addr.can_family = AF_CAN;
addr.can_ifindex = ifrr.ifr_ifindex;
bind(socket_fd, (struct sockaddr *)&addr, sizeof(addr));
while(1)
{
struct can_frame can_read_Acc;
nbytes = read(socket_fd, &can_read_Acc, sizeof(can_read_Acc));
if (can_read_Acc.can_id == can_id_recvAcc)
{
std::string mode = std::to_string(can_read_Acc.data[0]);
std::string dir = std::to_string(can_read_Acc.data[1]);
std::string depth = std::to_string(can_read_Acc.data[2]);
std::string forth = std::to_string(can_read_Acc.data[3]);
std::cout<<"Receive Acc successfully!"<<std::endl;
int acc_dir = std::atoi(dir.c_str());
dAcc = std::atoi(depth.c_str());
//send acc
if (acc_dir == 1)
{
acc = dAcc/940*100 + last_acc;
}
else
{
acc = -dAcc/940*100 - last_acc;
}
last_acc = acc;
}
}
}
//油门量发给底层执行器踏板
void SendAcc()
{
int socket_fd;
unsigned long nbytes;
struct sockaddr_can addr;
struct ifreq ifrr;
socket_fd = socket(PF_CAN,SOCK_RAW,CAN_RAW);
strcpy(ifrr.ifr_name,CANPORT);
ioctl(socket_fd,SIOCGIFINDEX,&ifrr);
addr.can_family = AF_CAN;
addr.can_ifindex = ifrr.ifr_ifindex;
bind(socket_fd, (struct sockaddr *)&addr, sizeof(addr));
while(1)
{
struct can_frame can_send_Acc;
can_send_Acc.can_id = sendAcc;
can_send_Acc.can_dlc = 8;
can_send_Acc.data[0] = 1;
can_send_Acc.data[1] = 0;
can_send_Acc.data[2] = 1;
can_send_Acc.data[3] = 0;
can_send_Acc.data[4] = 0;
can_send_Acc.data[5] = 0;
can_send_Acc.data[6] = 0;
can_send_Acc.data[7] = 0;
nbytes = write(socket_fd, &can_send_Acc, sizeof(can_send_Acc));
}
}
void RecvSteer()
{
int socket_fd;
unsigned long nbytes;
struct sockaddr_can addr;
struct ifreq ifrr;
socket_fd = socket(PF_CAN,SOCK_RAW,CAN_RAW);
strcpy(ifrr.ifr_name,CANPORT);
ioctl(socket_fd,SIOCGIFINDEX,&ifrr);
addr.can_family = AF_CAN;
addr.can_ifindex = ifrr.ifr_ifindex;
bind(socket_fd, (struct sockaddr *)&addr, sizeof(addr));
while(1)
{
struct can_frame can_read_Steer;
nbytes = read(socket_fd, &can_read_Steer, sizeof(can_read_Steer));
if (can_read_Steer.can_id == can_id_recvSteer)
{
std::string mode = std::to_string(can_read_Steer.data[0]);
std::string steer = std::to_string(can_read_Steer.data[3]*256 + can_read_Steer.data[4]-1024);
//send steering
Steering = std::atoi(steer.c_str());
}
}
}
void SendSteer()
{
int socket_fd;
unsigned long nbytes;
struct sockaddr_can addr;
struct ifreq ifrr;
socket_fd = socket(PF_CAN,SOCK_RAW,CAN_RAW);
strcpy(ifrr.ifr_name,CANPORT);
ioctl(socket_fd,SIOCGIFINDEX,&ifrr);
addr.can_family = AF_CAN;
addr.can_ifindex = ifrr.ifr_ifindex;
bind(socket_fd, (struct sockaddr *)&addr, sizeof(addr));
while(1)
{
struct can_frame can_send_Steer;
can_send_Steer.can_id = sendSteer;
can_send_Steer.can_dlc = 8;
can_send_Steer.data[0] = 0x20;
can_send_Steer.data[1] = 0;
can_send_Steer.data[2] = 0;
can_send_Steer.data[3] = 0;
can_send_Steer.data[4] = 0;
can_send_Steer.data[5] = 0;
can_send_Steer.data[6] = 0;
can_send_Steer.data[7] = (can_send_Steer.data[0] ^ can_send_Steer.data[1] ^ can_send_Steer.data[2] ^ can_send_Steer.data[3] ^can_send_Steer.data[4] ^can_send_Steer.data[5] ^can_send_Steer.data[6]);
nbytes = write(socket_fd, &can_send_Steer, sizeof(can_send_Steer));
}
}
void RecvBrk()
{
int socket_fd;
unsigned long nbytes;
struct sockaddr_can addr;
struct ifreq ifrr;
socket_fd = socket(PF_CAN,SOCK_RAW,CAN_RAW);
strcpy(ifrr.ifr_name,CANPORT);
ioctl(socket_fd,SIOCGIFINDEX,&ifrr);
addr.can_family = AF_CAN;
addr.can_ifindex = ifrr.ifr_ifindex;
bind(socket_fd, (struct sockaddr *)&addr, sizeof(addr));
while(1)
{
struct can_frame can_read_Brk;
nbytes = read(socket_fd, &can_read_Brk, sizeof(can_read_Brk));
if (can_read_Brk.can_id == can_id_recvBrk)
{
std::string mode = std::to_string(can_read_Brk.data[0]);
std::string dir = std::to_string(can_read_Brk.data[1]);
std::string depth = std::to_string(can_read_Brk.data[2]);
std::string forth = std::to_string(can_read_Brk.data[3]);
int brk_dir = std::atoi(dir.c_str());
dBrk = std::atoi(forth.c_str());
//send brk
if (brk_dir == 1)
{
brake = dBrk/1800*100 + last_brk;
}
else
{
brake = -dBrk/1800*100 - last_brk;
}
last_brk = brake;
}
}
}
void SendBrk()
{
int socket_fd;
unsigned long nbytes;
struct sockaddr_can addr;
struct ifreq ifrr;
socket_fd = socket(PF_CAN,SOCK_RAW,CAN_RAW);
strcpy(ifrr.ifr_name,CANPORT);
ioctl(socket_fd,SIOCGIFINDEX,&ifrr);
addr.can_family = AF_CAN;
addr.can_ifindex = ifrr.ifr_ifindex;
bind(socket_fd, (struct sockaddr *)&addr, sizeof(addr));
while(1)
{
struct can_frame can_send_Brk;
can_send_Brk.can_id = sendBrk;
can_send_Brk.can_dlc = 8;
can_send_Brk.data[0] = 1;
can_send_Brk.data[1] = 0;
can_send_Brk.data[2] = 0;
can_send_Brk.data[3] = 0;
can_send_Brk.data[4] = 0;
can_send_Brk.data[5] = 0;
can_send_Brk.data[6] = 0;
can_send_Brk.data[7] = 0;
nbytes = write(socket_fd, &can_send_Brk, sizeof(can_send_Brk));
}
}
//整形转四个字节函数
void IntToByte(int data_int,char* byte)
{
char* pchar = (char*)&data_int;
for (int i = 0;i < sizeof(int);i++)
{
*byte = *pchar;
pchar++;
byte++;
}
}
void udpSend()
{
int sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
struct sockaddr_in addr_serv;
int len;
memset(&addr_serv, 0, sizeof(struct sockaddr_in));
addr_serv.sin_family = AF_INET;
addr_serv.sin_port = htons(SERV_PORT);
addr_serv.sin_addr.s_addr = inet_addr("192.168.1.100");
len = sizeof(addr_serv);
char send_buf[12] = {0};
struct sockaddr_in addr_client;
char acc_t[4] = {0};
char brk_t[4] = {0};
char steer_t[4] = {0};
while(1)
{
memcpy(acc_t,&acc,4);
memcpy(brk_t,&brake,4);
memcpy(steer_t,&Steering,4);
clock_t end = clock();
dt = (end - start)*1000;
//100msudp发送一次
if (dt > 100)
{
sprintf(send_buf,"%c%c%c%c%c%c%c%c%c%c%c%c",acc_t[3],acc_t[2],acc_t[1],acc_t[0],brk_t[3],brk_t[2],brk_t[1],brk_t[0],steer_t[3],steer_t[2],steer_t[1],steer_t[0]);
std::cout<<sizeof(float)<<std::endl;
sendto(sock_fd, send_buf, 12, 0, (struct sockaddr *)&addr_serv, len);
std::cout<<"successfully"<<std::endl;
start = end;
}
}
close(sock_fd);
}
int main()
{
boost::thread recvAcc_thrd(RecvAcc);
boost::thread recvBrk_thrd(RecvBrk);
boost::thread recvSteer_thrd(RecvSteer);
recvAcc_thrd.join();
recvBrk_thrd.join();
recvSteer_thrd.join();
boost::thread udp_Send(udpSend);
udp_Send.join();
return 0;
}
编译
g++ can.cpp -lpthread -lboost_thread -o can
扫一扫
2136
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
