344 lines
9.7 KiB
C
344 lines
9.7 KiB
C
#include <stdio.h>
|
||
#include <stdint.h>
|
||
#include <string.h>
|
||
#include <stdlib.h>
|
||
#include <unistd.h>
|
||
#include <net/if.h>
|
||
#include <sys/ioctl.h>
|
||
#include <sys/socket.h>
|
||
#include <linux/can.h>
|
||
#include <linux/can/raw.h>
|
||
#include <fcntl.h>
|
||
#include "Socket_can.h"
|
||
#include <assert.h>
|
||
#include <sys/time.h>
|
||
|
||
|
||
int sockfd_can0;
|
||
// 全局变量,用于线程间通信
|
||
static int can_sockfd = -1;
|
||
static pthread_t can_thread;
|
||
static volatile int can_thread_running = 1; // 线程运行标志
|
||
|
||
|
||
Socket_can_t can0_dev;
|
||
Socket_can_t can1_dev;
|
||
|
||
int socket_can_init(char* can_dev)
|
||
{
|
||
int sockfd_can;
|
||
struct ifreq ifr;
|
||
struct sockaddr_can addr;
|
||
|
||
sockfd_can = socket(PF_CAN, SOCK_RAW, CAN_RAW);
|
||
if (sockfd_can < 0) {
|
||
perror("Error while opening socket");
|
||
return -1;
|
||
}
|
||
|
||
strcpy(ifr.ifr_name, can_dev);
|
||
ioctl(sockfd_can, SIOCGIFINDEX, &ifr);
|
||
|
||
// 绑定 CAN 套接字到接口
|
||
addr.can_family = AF_CAN;
|
||
addr.can_ifindex = ifr.ifr_ifindex;
|
||
if (bind(sockfd_can, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
|
||
perror("Error in socket bind");
|
||
return -2;
|
||
}
|
||
|
||
// 根据 can_dev 判断是 can0 还是 can1
|
||
if (strcmp(can_dev, "can0") == 0) {
|
||
printf("初始化 can0 成功。\n");
|
||
can0_dev.sockfd = sockfd_can;
|
||
can0_dev.data_buff = malloc(1024 * 128 * sizeof(char));
|
||
if (can0_dev.data_buff == NULL) {
|
||
fprintf(stderr, "内存分配失败!\n");
|
||
exit(EXIT_FAILURE);
|
||
}
|
||
can0_dev.datalist = malloc(1024 * 128 *sizeof(can_data_t));
|
||
can0_dev.index_read = can0_dev.index_write = 0;
|
||
can0_dev.index_max = 1024 * 128 * sizeof(char);
|
||
} else if (strcmp(can_dev, "can1") == 0) {
|
||
printf("初始化 can1 成功。\n");
|
||
can1_dev.sockfd = sockfd_can;
|
||
can1_dev.data_buff = malloc(1024 * 128 * sizeof(char));
|
||
if (can1_dev.data_buff == NULL) {
|
||
fprintf(stderr, "内存分配失败!\n");
|
||
exit(EXIT_FAILURE);
|
||
}
|
||
can1_dev.datalist = malloc(1024 * 128 *sizeof(can_data_t));
|
||
can1_dev.index_read = can1_dev.index_write = 0;
|
||
can1_dev.index_max = 1024 * 128 * sizeof(char);
|
||
} else {
|
||
fprintf(stderr, "错误:不支持的 CAN 接口名称:%s\n", can_dev);
|
||
return -1;
|
||
}
|
||
|
||
|
||
return sockfd_can;
|
||
}
|
||
|
||
int socket_can_send(int sockfd,uint32_t can_id,uint8_t data[8])
|
||
{
|
||
struct can_frame frame;
|
||
// 准备发送的 CAN 帧
|
||
frame.can_id = can_id; // 11位标准帧ID
|
||
frame.can_dlc = 8; // 数据长度为8字节
|
||
|
||
// 使用循环赋值 CAN 数据帧
|
||
for (int i = 0; i < frame.can_dlc; i++)
|
||
{
|
||
frame.data[i] = data[i]; // 将数据从0x01到0x08依次赋值
|
||
}
|
||
|
||
if (write(sockfd, &frame, sizeof(struct can_frame)) != sizeof(struct can_frame)) {
|
||
perror("Write error");
|
||
return -3;
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
/**
|
||
* 从 CAN 套接字中读取数据
|
||
* @param sockfd CAN 套接字文件描述符
|
||
* @param data 存储接收到的 CAN 数据
|
||
* @return 成功返回读取的字节数,失败返回 -1
|
||
*/
|
||
int socket_can_receive(int sockfd, uint8_t *data) {
|
||
struct can_frame frame;
|
||
int nbytes;
|
||
|
||
// 读取 CAN 数据帧
|
||
nbytes = read(sockfd, &frame, sizeof(struct can_frame));
|
||
if (nbytes < 0) {
|
||
perror("Error reading from CAN socket");
|
||
return -1;
|
||
}
|
||
|
||
// 检查读取的字节数是否正确
|
||
if (nbytes != sizeof(struct can_frame)) {
|
||
fprintf(stderr, "Incomplete CAN frame read\n");
|
||
return -1;
|
||
}
|
||
|
||
// 将 CAN 数据帧的内容复制到输出缓冲区
|
||
memcpy(data, frame.data, frame.can_dlc); // frame.can_dlc 是数据长度
|
||
return frame.can_dlc; // 返回实际读取的数据长度
|
||
}
|
||
int socket_can_close(int sockfd)
|
||
{
|
||
// 关闭套接字
|
||
close(sockfd);
|
||
if(sockfd == can0_dev.sockfd)
|
||
{
|
||
free(can0_dev.data_buff);
|
||
}else if(sockfd == can1_dev.sockfd)
|
||
{
|
||
free(can1_dev.data_buff);
|
||
}
|
||
return -1;
|
||
}
|
||
|
||
|
||
#include <sys/select.h> // 添加 select 头文件
|
||
|
||
void *can_receive_task(void *arg) {
|
||
int sockfd = *(int *)arg; // 从参数中获取 sockfd
|
||
struct can_frame frame;
|
||
fd_set read_fds;
|
||
|
||
while (can_thread_running) {
|
||
// 初始化 fd_set
|
||
FD_ZERO(&read_fds);
|
||
FD_SET(sockfd, &read_fds);
|
||
|
||
// 设置超时时间(100ms)
|
||
struct timeval timeout;
|
||
timeout.tv_sec = 0;
|
||
timeout.tv_usec = 100000;
|
||
|
||
// 等待 CAN 数据
|
||
int ret = select(sockfd + 1, &read_fds, NULL, NULL, &timeout);
|
||
if (ret < 0) {
|
||
perror("Error in select");
|
||
break;
|
||
} else if (ret == 0) {
|
||
// 超时,继续循环
|
||
continue;
|
||
}
|
||
|
||
// 检查是否有数据可读
|
||
if (FD_ISSET(sockfd, &read_fds)) {
|
||
int nbytes = read(sockfd, &frame, sizeof(struct can_frame));
|
||
if (nbytes < 0) {
|
||
perror("Error reading from CAN socket");
|
||
break;
|
||
}
|
||
|
||
// 检查读取的字节数是否正确
|
||
if (nbytes != sizeof(struct can_frame)) {
|
||
fprintf(stderr, "Incomplete CAN frame read\n");
|
||
continue;
|
||
}
|
||
if(sockfd == can0_dev.sockfd)
|
||
{
|
||
// assert(socket_can_fill_data(&can0_dev, frame.data, frame.can_dlc) == 0);
|
||
memcpy(&can0_dev.datalist[can0_dev.index_write].frame,&frame,sizeof(struct can_frame));
|
||
gettimeofday(&can0_dev.datalist[can0_dev.index_write].tv, NULL);
|
||
can0_dev.index_write+=1;
|
||
}else{
|
||
assert(socket_can_fill_data(&can1_dev, frame.data, frame.can_dlc) == 0);
|
||
}
|
||
// 打印接收到的 CAN 数据
|
||
// printf("Received CAN frame: ID=0x%X, Data=", frame.can_id);
|
||
// for (int i = 0; i < frame.can_dlc; i++) {
|
||
// printf("%02X ", frame.data[i]);
|
||
// }
|
||
// printf("\n:%d\r\n",can1_dev.index_write);
|
||
// struct timeval tv;
|
||
// gettimeofday(&tv, NULL);
|
||
// printf("当前时间戳(秒 + 微秒):%ld.%06ld\n", tv.tv_sec, tv.tv_usec);
|
||
|
||
}
|
||
}
|
||
|
||
// 线程退出
|
||
printf("CAN receive task stopped.\n");
|
||
return NULL;
|
||
}
|
||
|
||
int start_can_receive_task(int sockfd) {
|
||
|
||
if(sockfd > 0)
|
||
{
|
||
can_thread_running = 1;
|
||
}
|
||
// 创建线程
|
||
if (pthread_create(&can_thread, NULL, can_receive_task, &sockfd) != 0) {
|
||
perror("Error creating CAN receive thread");
|
||
return -1;
|
||
}
|
||
|
||
printf("CAN receive task started.\n");
|
||
return 0;
|
||
}
|
||
|
||
/**
|
||
* 停止 CAN 数据读取任务
|
||
*/
|
||
void stop_can_receive_task() {
|
||
// 设置线程运行标志为 0
|
||
can_thread_running = 0;
|
||
|
||
// 等待线程退出
|
||
pthread_join(can_thread, NULL);
|
||
printf("CAN receive task stopped.\n");
|
||
}
|
||
|
||
|
||
/**
|
||
* 向环形缓冲区 data_buff 中填充数据
|
||
* @param can 指向 Socket_can_t 结构体的指针
|
||
* @param data 要写入的数据
|
||
* @param size 数据大小(字节数)
|
||
* @return 成功返回 0,失败返回 -1
|
||
*/
|
||
int socket_can_fill_data(Socket_can_t *can, const void *data, uint32_t size) {
|
||
if (can == NULL || data == NULL || can->data_buff == NULL) {
|
||
fprintf(stderr, "错误:参数不能为空。\n");
|
||
return -1;
|
||
}
|
||
|
||
if (size == 0) {
|
||
return 0; // 空数据直接返回
|
||
}
|
||
|
||
// 计算可用空间(保留一个位置避免歧义)
|
||
uint32_t available_space;
|
||
if (can->index_write >= can->index_read) {
|
||
available_space = can->index_max - can->index_write + can->index_read;
|
||
} else {
|
||
available_space = can->index_read - can->index_write;
|
||
}
|
||
|
||
// 可用空间需要减 1 以区分满和空状态
|
||
available_space--;
|
||
|
||
if (size > available_space) {
|
||
fprintf(stderr, "错误:缓冲区空间不足(需要 %u,剩余 %u)。\n", size, available_space);
|
||
return -1;
|
||
}
|
||
|
||
// 计算从 index_write 到缓冲区末尾的剩余空间
|
||
uint32_t space_to_end = can->index_max - can->index_write;
|
||
|
||
// 分两种情况写入数据
|
||
if (space_to_end >= size) {
|
||
// 情况 1:剩余空间足够,直接写入
|
||
memcpy((char *)can->data_buff + can->index_write, data, size);
|
||
} else {
|
||
// 情况 2:分两次写入(尾部 + 头部)
|
||
memcpy((char *)can->data_buff + can->index_write, data, space_to_end);
|
||
memcpy((char *)can->data_buff, (char *)data + space_to_end, size - space_to_end);
|
||
}
|
||
|
||
// 更新 index_write(环形逻辑)
|
||
can->index_write = (can->index_write + size) % can->index_max;
|
||
|
||
return 0;
|
||
}
|
||
|
||
|
||
|
||
int test() {
|
||
int sockfd;
|
||
struct sockaddr_can addr;
|
||
struct ifreq ifr;
|
||
struct can_frame frame;
|
||
|
||
// 创建 CAN 套接字
|
||
sockfd = socket(PF_CAN, SOCK_RAW, CAN_RAW);
|
||
if (sockfd < 0) {
|
||
perror("Error while opening socket");
|
||
return -1;
|
||
}
|
||
|
||
// 指定 CAN 接口(假设为 can0)
|
||
strcpy(ifr.ifr_name, "can0");
|
||
ioctl(sockfd, SIOCGIFINDEX, &ifr);
|
||
|
||
// 绑定 CAN 套接字到接口
|
||
addr.can_family = AF_CAN;
|
||
addr.can_ifindex = ifr.ifr_ifindex;
|
||
if (bind(sockfd, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
|
||
perror("Error in socket bind");
|
||
return -2;
|
||
}
|
||
|
||
// 准备发送的 CAN 帧
|
||
frame.can_id = 0x123; // 11位标准帧ID
|
||
frame.can_dlc = 8; // 数据长度为8字节
|
||
// 使用循环赋值 CAN 数据帧
|
||
for (int i = 0; i < frame.can_dlc; i++)
|
||
{
|
||
frame.data[i] = i + 1; // 将数据从0x01到0x08依次赋值
|
||
}
|
||
|
||
|
||
// 发送 CAN 帧
|
||
for(int i=0;i<3;i++)
|
||
{
|
||
if (write(sockfd, &frame, sizeof(struct can_frame)) != sizeof(struct can_frame)) {
|
||
perror("Write error");
|
||
return -3;
|
||
}
|
||
|
||
}
|
||
|
||
printf("CAN message sent on can0\n");
|
||
// 关闭套接字
|
||
close(sockfd);
|
||
|
||
return 0;
|
||
} |