VxWorks下CAN设备驱动设计和应用编程

概述
#

VxWorks是一种高性能的实时操作系统（RTOS），广泛应用于需要高可靠性和实时性的嵌入式系统中。控制器局域网络（CAN）是工业控制和汽车电子领域常见的通信协议。将CAN编程与VxWorks结合，可以实现高效的通信和控制系统。本文将介绍在VxWorks下进行CAN编程的基本步骤和关键点。

硬件准备
#

在开始编程之前，需确保以下硬件准备就绪：

CAN控制器：如SJA1000等支持CAN总线的硬件控制器。
VxWorks支持的硬件平台：通常是基于PC/104或其他嵌入式系统的硬件。

驱动程序设计
#

开发CAN驱动程序在VxWorks下通常涉及以下几个关键步骤：

硬件理解

了解CAN控制器：如SJA1000、MCP2515等，知道其寄存器布局，中断机制，以及如何通过软件控制这些硬件。
地址映射：确认CAN控制器在系统中的地址范围，确保能正确进行内存读写操作。

驱动程序框架

初始化驱动：
- 分配并初始化CAN设备结构体。
- 注册驱动到VxWorks的I/O系统中（通常通过设备驱动表iosDrvTbl）。
实现基本I/O函数：
- create：创建CAN设备，设置初始参数如波特率。
- delete：删除设备，释放资源。
- open：打开设备，初始化设备相关的资源。
- close：关闭设备，释放相关资源。
- read：从CAN总线读取数据。
- write：向CAN总线发送数据。
- ioctl：处理各种控制命令，如设置波特率、过滤器等。

中断处理

中断服务程序（ISR）：处理CAN接收或发送完成的中断，适时更新设备状态或进行数据处理。

数据包处理

发送数据包：当调用write时，将数据包准备好发送到CAN控制器。
接收数据包：中断驱动数据包的接收，存储到一个缓冲区供read使用。

错误处理

实现错误检测和报告机制，处理CAN总线错误，如总线关闭、数据包丢失等。

代码示例

以下是简化的CAN驱动程序框架：

#include <vxWorks.h>
#include <drv/can/canDrv.h> //假设的头文件
#include <intLib.h> // 中断处理

// CAN设备结构体
typedef struct {
    UINT32 baseAddr; // 硬件基地址
    SEM_ID sem; // 用于同步的信号量
    // 其他成员变量如缓冲区、状态标志等
} CAN_DEV;

// 设备驱动接口
LOCAL STATUS canDrvCreate();
LOCAL STATUS canDrvDelete();
LOCAL STATUS canDrvOpen();
LOCAL STATUS canDrvClose();
LOCAL STATUS canDrvRead();
LOCAL STATUS canDrvWrite();
LOCAL STATUS canDrvIoctl();

// 中断处理函数
LOCAL void canIsr();

// 初始化驱动
void canDrvInit() {
    /* 注册驱动到VxWorks I/O系统 */
    iosDrvInstall(canDrvCreate, canDrvDelete, 
                  canDrvOpen, canDrvClose, 
                  canDrvRead, canDrvWrite, 
                  canDrvIoctl);
}

// 创建CAN设备
LOCAL STATUS canDrvCreate() {
    CAN_DEV *pCan = (CAN_DEV *)calloc(sizeof(CAN_DEV), 1);
    if (pCan == NULL) return ERROR;

    // 初始化设备参数
    pCan->baseAddr = CAN_BASE_ADDRESS; // 假设的硬件地址
    pCan->sem = semBCreate(SEM_Q_FIFO, SEM_EMPTY); // 创建信号量

    // 硬件初始化
    // ...

    return (STATUS)pCan; // 返回设备指针作为设备ID
}

// 删除设备
LOCAL STATUS canDrvDelete(CAN_DEV *pCan) {
    // 释放资源
    semDelete(pCan->sem);
    free(pCan);
    return OK;
}

// 打开设备
LOCAL STATUS canDrvOpen(CAN_DEV *pCan) {
    // 进一步初始化或状态检查
    return OK;
}

// 关闭设备
LOCAL STATUS canDrvClose(CAN_DEV *pCan) {
    // 清理操作
    return OK;
}

// 读取CAN消息
LOCAL STATUS canDrvRead(CAN_DEV *pCan, CAN_MSG *pMsg) {
    // 阻塞等待或轮询接收中断信号
    semTake(pCan->sem, WAIT_FOREVER);
    // 从接收缓冲区读取消息
    // ...
    return OK;
}

// 发送CAN消息
LOCAL STATUS canDrvWrite(CAN_DEV *pCan, CAN_MSG *pMsg) {
    // 发送数据到CAN控制器的发送缓冲区
    // ...
    return OK;
}

// IO控制
LOCAL STATUS canDrvIoctl(CAN_DEV *pCan, int cmd, int arg) {
    switch (cmd) {
        case CAN_SET_BAUDRATE:
            // 设置波特率
            break;
        // 其他控制命令
        default:
            return ERROR;
    }
    return OK;
}

// 中断服务程序
LOCAL void canIsr() {
    CAN_DEV *pCan = (CAN_DEV *)intContextGet(); // 获取中断上下文中的设备信息
    // 处理中断，比如读取接收缓冲区、更新状态
    semGive(pCan->sem); // 放信号量，告知有新数据可以读取
}

测试与调试

使用VxWorks自带的调试工具，如Wind River Workbench，调试驱动程序。
编写测试程序，通过发送和接收CAN消息来验证驱动程序的功能。

注意事项

驱动程序需要考虑多任务环境下的同步问题。
性能优化，如减少中断的频率，提高数据传输效率。
错误处理和日志记录对于调试和维护非常重要。

此示例为概念性代码，实际开发时需要根据具体的CAN控制器和VxWorks版本来调整和完善。

应用编程
#

以下是CAN编程在VxWorks下的具体步骤：

初始化CAN控制器：

设置CAN总线速度、模式等基本参数。
初始化相关的寄存器，确保CAN控制器处于正确的工作状态。

数据包的发送和接收：

发送：通过write函数将数据发送到CAN总线上。
接收：使用read函数或通过中断来获取CAN总线上的数据。

错误处理和诊断：

实现错误检测机制，如CAN总线错误、丢帧等。
提供诊断功能，以监控CAN总线的健康状态。

多通道管理：

如果设备支持多个CAN通道，需要为每个通道设置不同的处理方式和错误处理机制。

示例代码
#

这里是关于在VxWorks下进行CAN编程的一个简化代码示例。请注意，这部分代码是概念性的，实际实现可能需要根据具体的硬件和VxWorks版本进行调整。

#include <vxWorks.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <taskLib.h>
#include <drv/can/canDrv.h>  // 假设存在这样的CAN驱动头文件

#define CAN_BUS_SPEED 500000 /* 500 kbps */
#define CAN_MESSAGE_ID 0x123 /* 示例消息ID */

/* CAN驱动初始化函数 */
void canInit() {
    CAN_HANDLE hCan;
    
    /* 初始化CAN驱动，这里假设有一个全局的CAN初始化函数 */
    if ((hCan = canDrvInit()) == NULL) {
        printf("CAN driver initialization failed!\n");
        return;
    }

    /* 设置CAN总线速度 */
    if (canIoctl(hCan, CAN_SET_BAUDRATE, CAN_BUS_SPEED) != OK) {
        printf("Failed to set CAN bus speed\n");
    }

    printf("CAN bus initialized successfully\n");
}

/* CAN发送数据函数 */
STATUS canSendMessage(CAN_HANDLE hCan, UINT32 msgId, UCHAR *data, UINT8 len) {
    CAN_MSG msg;
    STATUS status;

    /* 填充消息结构体 */
    msg.id = msgId;
    msg.len = len;
    memcpy(msg.data, data, len);

    /* 发送消息 */
    status = canWrite(hCan, &msg);
    if (status != OK) {
        printf("Failed to send CAN message\n");
        return ERROR;
    }

    printf("Message sent successfully\n");
    return OK;
}

/* CAN接收数据函数 */
void canReceiveTask(CAN_HANDLE hCan) {
    CAN_MSG rxMsg;
    STATUS status;

    while (1) {
        status = canRead(hCan, &rxMsg);
        if (status == OK) {
            printf("Received CAN message with ID: 0x%X, Data: ", rxMsg.id);
            for (int i = 0; i < rxMsg.len; i++) {
                printf("%02X ", rxMsg.data[i]);
            }
            printf("\n");
        } else if (status == ERROR) {
            printf("Error in reading CAN message\n");
        }
        /* 等待新的消息 */
        taskDelay(10);  // 延迟一小段时间，避免CPU占用过高
    }
}

/* 主函数或初始化任务 */
void canMain() {
    CAN_HANDLE hCan;

    canInit();

    /* 假设我们已经有了初始化好的CAN句柄 */
    hCan = canOpen(0);  // 打开第一个CAN通道

    if (hCan == NULL) {
        printf("Failed to open CAN channel\n");
        return;
    }

    /* 发送一个示例消息 */
    UCHAR dataToSend[] = {0x01, 0x02, 0x03, 0x04};
    canSendMessage(hCan, CAN_MESSAGE_ID, dataToSend, sizeof(dataToSend));

    /* 创建一个接收任务 */
    taskSpawn("tCanRx", 100, 0, 4096, (FUNCPTR)canReceiveTask, (int)hCan, 0, 0, 0, 0, 0, 0, 0, 0, 0);

    /* 主任务在这里可以做其他事情或者等待任务结束 */
}

int main() {
    canMain();
    return 0;
}