App-lvgl-CANTest/main_app/Socket_can.c

344 lines
9.7 KiB
C
Raw Permalink Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

#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;
}