Can.h File Reference

#include "stm32f7xx_hal.h"
#include <stdint.h>

Include dependency graph for Can.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	CAN_Signal_Template
struct	CAN_Signal
struct	CAN_Message_Template
struct	CAN_Message
struct	CAN_MessageList

Macros
#define	MAX_SIGNALS   8
#define	MAX_SIGNAL_NAME_LENGTH   32
#define	MAX_UNIT_NAME_LENGTH   32
#define	MAX_NODE_NAME_LENGTH   32
#define	MAX_MESSAGE_NAME_LENGTH   32
#define	MAX_BUS   2
#define	MAX_MESSAGES   128

Typedefs
typedef struct CAN_Signal_Template	CAN_Signal_Template
typedef struct CAN_Signal	CAN_Signal
typedef struct CAN_Message_Template	CAN_Message_Template
typedef struct CAN_Message	CAN_Message
typedef enum CANBus	CANBus
typedef enum CANProtocol	CANProtocol
typedef enum CANBaudrate	CANBaudrate
typedef struct CAN_MessageList	CAN_MessageList

Enumerations
enum	CANBus { CAN_1 = 0 , CAN_2 = 1 }
enum	CANProtocol { CAN_2A = 0 , CAN_2B = 1 }
enum	CANBaudrate {   CAN_100KBPS = 100000 , CAN_125KBPS = 125000 , CAN_250KBPS = 250000 , CAN_500KBPS = 500000 ,   CAN_1MBPS = 1000000 }

Functions
int	init_CANBus (CANBus bus)
	Initializes the CANBus struct. More...
int	load_dbc_file (CANBus bus, const unsigned char *filename)
	Loads a DBC file into the CAN database. Makes the messages and signals and stores them in the list. More...
int	add_message (CANBus bus, CAN_Message_Template message)
	Adds a message to the CAN message list. More...
int	add_message_lop (CANBus bus, int id, int dlc, int ide, int rtr, const char *name, const char *sender, int signal_count, CAN_Signal_Template *signals)
	Adds a message to the CAN message list by passing in the individual message parameters hence "LOP" (List of Parameters) More...
int	send_CAN_message (CANBus bus, CANProtocol protocol, uint32_t id, uint8_t *data, uint8_t len)
	Sends a CAN message. More...
void	receive_CAN_message (CAN_RxHeaderTypeDef *header, uint8_t *data, CANBus bus)
	Receives a CAN message. More...
void	parseMessage (CAN_MessageList *messages, CAN_Message *can_message)
	Parses a CAN message. More...
void	parseSignals (CAN_Message_Template *message, CAN_Message *can_message)
	Parses signals in a CAN message. More...
void	parseSignal (CAN_Signal_Template *signal, CAN_Signal *can_signal, CAN_Message *can_message)
	Parses a CAN signal. More...
void	print_CAN_Messages_Lists ()
	Prints the CAN message list. More...

Macro Definition Documentation

MAX_BUS

#define MAX_BUS   2

Definition at line 94 of file Can.h.

MAX_MESSAGE_NAME_LENGTH

#define MAX_MESSAGE_NAME_LENGTH   32

Definition at line 41 of file Can.h.

MAX_MESSAGES

#define MAX_MESSAGES   128

Definition at line 95 of file Can.h.

MAX_NODE_NAME_LENGTH

#define MAX_NODE_NAME_LENGTH   32

Definition at line 17 of file Can.h.

MAX_SIGNAL_NAME_LENGTH

#define MAX_SIGNAL_NAME_LENGTH   32

Definition at line 15 of file Can.h.

MAX_SIGNALS

#define MAX_SIGNALS   8

Definition at line 14 of file Can.h.

MAX_UNIT_NAME_LENGTH

#define MAX_UNIT_NAME_LENGTH   32

Definition at line 16 of file Can.h.

Typedef Documentation

CAN_Message

typedef struct CAN_Message CAN_Message

CAN_Message_Template

typedef struct CAN_Message_Template CAN_Message_Template

CAN_MessageList

typedef struct CAN_MessageList CAN_MessageList

CAN_Signal

typedef struct CAN_Signal CAN_Signal

CAN_Signal_Template

typedef struct CAN_Signal_Template CAN_Signal_Template

CANBaudrate

typedef enum CANBaudrate CANBaudrate

CANBus

typedef enum CANBus CANBus

CANProtocol

typedef enum CANProtocol CANProtocol

Enumeration Type Documentation

CANBaudrate

enum CANBaudrate

Enumerator
CAN_100KBPS
CAN_125KBPS
CAN_250KBPS
CAN_500KBPS
CAN_1MBPS

Definition at line 112 of file Can.h.

                         {
    CAN_100KBPS = 100000,
    CAN_125KBPS = 125000,
    CAN_250KBPS = 250000,
    CAN_500KBPS = 500000,
    CAN_1MBPS = 1000000,
} CANBaudrate;

CANBus

enum CANBus

Enumerator
CAN_1
CAN_2

Definition at line 98 of file Can.h.

                    {
    CAN_1 = 0,
    CAN_2 = 1
} CANBus;

CANProtocol

enum CANProtocol

Enumerator
CAN_2A
CAN_2B

Definition at line 104 of file Can.h.

                         {
    CAN_2A = 0, // Standard CAN w/ 11-bit ID
    CAN_2B = 1, // Standard CAN w/ 29-bit ID
    //CAN_FD = 2, // CAN FD w/ 11-bit ID
    //CAN_FD_BRS = 3, // CAN FD w/ 29-bit ID
} CANProtocol;

Function Documentation

add_message()

int add_message	(	CANBus	bus,
		CAN_Message_Template	message
	)

Adds a message to the CAN message list.

Parameters

bus	The CAN bus to add the message to
message	The message to add

Returns

int 0 if the message was added successfully, -1 if the bus is invalid

Definition at line 48 of file Can.c.

                                                          {
    // Add the message to the list
    can_messages[bus].messages[can_messages[bus].num_messages] = message;
    can_messages[bus].num_messages++;
    return 0;
}

Here is the caller graph for this function:

add_message_lop()

int add_message_lop	(	CANBus	bus,
		int	id,
		int	dlc,
		int	ide,
		int	rtr,
		const char *	name,
		const char *	sender,
		int	signal_count,
		CAN_Signal_Template *	signals
	)

Adds a message to the CAN message list by passing in the individual message parameters hence "LOP" (List of Parameters)

Parameters

bus	The CAN bus to add the message to
id	The ID of the message
dlc	The Data Length Code of the message
ide	The Identifier Extension of the message
rtr	The Remote Transmission Request of the message
name	The name of the message
sender	The sender of the message
signal_count	The number of signals in the message
signals	The signals in the message

Returns

int 0 if the message was added successfully, -1 if the bus is invalid

Definition at line 55 of file Can.c.

{
    // Create a CAN message template
    CAN_Message_Template message;
    message.id = id;
    message.dlc = dlc;
    message.ide = ide;
    message.rtr = rtr;
    strcpy(message.name, name);
    strcpy(message.sender, sender);
    message.signal_count = signal_count;
    message.payload_length = 0;
 
    // Copy the signals
    for (int i = 0; i < signal_count; i++) {
        message.signals[i] = signals[i];
        message.payload_length += signals[i].length;
    }
 
    // Add the message to the list
    return add_message(bus, message);
}

Here is the call graph for this function:

Here is the caller graph for this function:

init_CANBus()

int init_CANBus

(

CANBus

bus

)

Initializes the CANBus struct.

Parameters

bus	The CAN bus to initialize

Returns

int 0 if the CAN bus was initialized successfully, -1 if the bus is invalid

Definition at line 17 of file Can.c.

                            {
    // Initialize the CAN message list
    can_messages[bus].bus = bus;
    can_messages[bus].num_messages = 0;
 
    return 0;
}

Here is the caller graph for this function:

load_dbc_file()

int load_dbc_file	(	CANBus	bus,
		const unsigned char *	filename
	)

Loads a DBC file into the CAN database. Makes the messages and signals and stores them in the list.

Parameters

bus	The CAN bus to load the DBC file into
filename	The name of the DBC file to load

Returns

int 0 if the DBC file was loaded successfully, -1 if the file could not be opened

Definition at line 25 of file Can.c.

{
    // Load the DBC file
    #ifdef TEST_MODE
    // unsigned char* dbc_contents = fopen(filename, "w");
    #else
    unsigned char* dbc_contents = filename;
    #endif
//    printf("Loading DBC file: %c\r\r\n", filename[0]);
    
    #ifndef TEST_MODE
    // Parse the DBC file
    parseDbcFile(&can_messages[bus], dbc_contents);
    #endif
 
    #ifdef TEST_MODE
    // fclose(dbc_contents);
    #endif
 
    print_CAN_MessageList(&can_messages[bus]);
    return 0;
}

Here is the call graph for this function:

parseMessage()

void parseMessage	(	CAN_MessageList *	messages,
		CAN_Message *	can_message
	)

Parses a CAN message.

Parameters

messages	The CAN message list
can_message	The CAN message to parse

Definition at line 135 of file Can.c.

                                                                       {
    // Find the message in the list
    // TODO: Implement a hash table or map for faster lookup
    for (int i = 0; i < messages->num_messages; i++) {
        CAN_Message_Template* msg = &messages->messages[i];
        if (msg->id == can_message->header.StdId || msg->id == can_message->header.ExtId) {
            // Parse the signals of the message
            can_message->template = msg;
            parseSignals(msg, can_message);
            return;
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

parseSignal()

void parseSignal	(	CAN_Signal_Template *	signal,
		CAN_Signal *	can_signal,
		CAN_Message *	can_message
	)

Parses a CAN signal.

Parameters

signal	The CAN signal template
can_signal	The CAN signal to parse
can_message	The CAN message to parse

Definition at line 160 of file Can.c.

                                                                                                {
    can_signal->template = signal;
 
    // Extract the raw data from the message
    uint64_t raw_data = 0;
    for (int i = signal->start_bit; i < signal->start_bit + signal->length; i++) {
        raw_data |= ((can_message->data[i / 8] >> (i % 8)) & 1) << (i - signal->start_bit);
    }
 
    // Check if the signal is big endian
    if (signal->endian == 1) {
        // Reverse the bits
        uint64_t reversed_data = 0;
        for (int i = 0; i < signal->length; i++) {
            reversed_data |= ((raw_data >> i) & 1) << (signal->length - i - 1);
        }
        raw_data = reversed_data;
    }
 
    // Check if the signal is signed
    if (signal->isSigned) {
        // Sign extend the data
        raw_data = (raw_data << (64 - signal->length)) >> (64 - signal->length);
    }
 
    // Scale and offset the data
    can_signal->value = (raw_data * signal->scale) + signal->offset;
 
}

Here is the caller graph for this function:

parseSignals()

void parseSignals	(	CAN_Message_Template *	message,
		CAN_Message *	can_message
	)

Parses signals in a CAN message.

Parameters

message	The CAN message template
can_message	The CAN message to parse

Definition at line 150 of file Can.c.

                                                                           {
    // Find the signals in the message
    for (int i = 0; i < message->signal_count; i++) {
        CAN_Signal_Template* signal = &message->signals[i];
        // Parse the signal
        parseSignal(signal, &can_message->signals[i], can_message);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

print_CAN_Messages_Lists()

void print_CAN_Messages_Lists

(

)

Prints the CAN message list.

Definition at line 190 of file Can.c.

                                {
    for (int i = 0; i < MAX_BUS; i++) {
        printf("Printing CAN Message List for bus %d with %d messages\r\n", i, can_messages[i].num_messages);
        for (int j = 0; j < can_messages[i].num_messages; j++) {
            const CAN_Message_Template* msg = &can_messages[i].messages[j];
            printf(ANSI_COLOR_GREEN "Message" ANSI_COLOR_RESET ": %s (ID: %d, DLC: %d, Sender: %s, SIGs: %d)\r\n", msg->name, msg->id, msg->dlc, msg->sender, msg->signal_count);
            for (int k = 0; k < msg->signal_count; k++) {
                const CAN_Signal_Template* sig = &msg->signals[k];
                printf("\t" ANSI_COLOR_BLUE "Signal" ANSI_COLOR_RESET ": %s (Start bit: %d, Length: %d, Endain: %d, Signed: %c,\r\n\t\tScale: %f, Offset: %f, Min: %f, Max: %f, \r\n\t\tUnit: %s, Reciever: %s)\r\n", sig->name, sig->start_bit, sig->length, sig->endian, sig->isSigned, sig->scale, sig->offset, sig->min, sig->max, sig->unit, sig->reciever);
            }
            printf("\r\n");
        }
        if (can_messages[i].num_messages == 0) {
            printf("No messages on bus %d\r\n", i);
        }
    }
}

Here is the caller graph for this function:

receive_CAN_message()

void receive_CAN_message	(	CAN_RxHeaderTypeDef *	header,
		uint8_t *	data,
		CANBus	bus
	)

Receives a CAN message.

Parameters

RxHeader	The CAN Rx header
RxData	The CAN Rx data
bus	The CAN bus to receive the message on

Definition at line 112 of file Can.c.

                                                                                     {
    CAN_Message* can_message = malloc(sizeof(CAN_Message) + sizeof(CAN_Signal) * 8);
    can_message->header = *RxHeader;
        memcpy(can_message->data, RxData, 8);
 
        // Parse the message
        parseMessage(&can_messages[bus], can_message);
 
        // Print out the contents of the message
        printf(ANSI_COLOR_YELLOW "Received CAN Message" ANSI_COLOR_RESET ": %s (ID: %d, DLC: %d, Sender: %s)\r\n", can_message->template->name, can_message->header.StdId, can_message->header.DLC, can_message->template->sender);
 
        // Print the signals
        for (int i = 0; i < can_message->template->signal_count; i++) {
            CAN_Signal* signal = &can_message->signals[i];
            printf("\t" ANSI_COLOR_MAGENTA "Signal" ANSI_COLOR_RESET ": %s (Value: %u, Unit: %s)\r\n", signal->template->name, signal->value, signal->template->unit);
        }
        printf("\r\n");
 
        // Free the message
        free(can_message);
}

Here is the call graph for this function:

Here is the caller graph for this function:

send_CAN_message()

int send_CAN_message	(	CANBus	bus,
		CANProtocol	protocol,
		uint32_t	id,
		uint8_t *	data,
		uint8_t	len
	)

Sends a CAN message.

Parameters

bus	The CAN bus to send the message on
protocol	The CAN protocol to use
id	The ID of the message
data	The data to send
len	The length of the data

Returns

int 0 if the message was sent successfully, -1 if the bus is invalid

Definition at line 79 of file Can.c.

                                                                                                {
    CAN_TxHeaderTypeDef TxHeader;
    if (protocol == CAN_2A) {
        TxHeader.StdId = id;
        TxHeader.IDE = CAN_ID_STD;
    } else if (protocol == CAN_2B) {
        TxHeader.ExtId = id;
        TxHeader.IDE = CAN_ID_EXT;
    } else {
        printf("Invalid CAN protocol\r\n");
        return -1;
    }
 
    TxHeader.RTR = CAN_RTR_DATA;
    TxHeader.DLC = len;
 
    // Print the message
    printf(ANSI_COLOR_YELLOW "Sending CAN Message" ANSI_COLOR_RESET ": ID: %d, DLC: %d, Data: ", id, len);
    for (int i = 0; i < len; i++) {
        printf("%02X ", data[i]);
    }
    printf("\r\n");
 
    #ifndef TEST_MODE
    // Send the CAN message
    if (send_CAN_message_helper(bus, &TxHeader, data) != 0) {
        return -2;
    }
    #endif
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function: