canapi.h

Go to the documentation of this file.

/*============================================================================*
 * FILE:                      canapi.c
 *============================================================================*
 *
 *                      COPYRIGHT (C) 2006  BY
 *          CONDOR ENGINEERING, INC., SANTA BARBARA, CALIFORNIA
 *          ALL RIGHTS RESERVED.
 *
 *          THIS SOFTWARE IS FURNISHED UNDER A LICENSE AND MAY BE USED AND
 *          COPIED ONLY IN ACCORDANCE WITH THE TERMS OF SUCH LICENSE AND WITH
 *          THE INCLUSION OF THE ABOVE COPYRIGHT NOTICE.  THIS SOFTWARE OR ANY
 *          OTHER COPIES THEREOF MAY NOT BE PROVIDED OR OTHERWISE MADE
 *          AVAILABLE TO ANY OTHER PERSON.  NO TITLE TO AND OWNERSHIP OF THE
 *          SOFTWARE IS HEREBY TRANSFERRED.
 *
 *          THE INFORMATION IN THIS SOFTWARE IS SUBJECT TO CHANGE WITHOUT
 *          NOTICE AND SHOULD NOT BE CONSTRUED AS A COMMITMENT BY CONDOR
 *          ENGINEERING.
 *
 *============================================================================*
 *
 * FUNCTION:    Public include file for the CAN api library
 *
 * Author:      Christopher McKenzie
 * 
 * MAINTENANCE NOTES:
 * 
 *============================================================================*/
#ifndef _CACEBOEING_H_
#define _CACEBOEING_H_

typedef unsigned char   uchar;
typedef unsigned int    uint;
typedef unsigned short  ushort;
typedef unsigned long   ulong;

typedef struct can20bframe
{       uchar sof;      
        
        struct
        {       ushort  identifier11bit;        
                uchar   srr,    
                                ide;    
                ulong   identifier18bit;        
                uchar   rtr;    
        }arbitration;   

        struct
        {       ushort  r1,     
                                r0,     
                                dlc;    
        }control;       
        
        uchar data[8];  

        struct
        {       uint    sequence;       
                uchar   delimeter;      
        }crc;   

        struct
        {       uchar   slot,   
                                delimeter;      
        }ack;   

        uchar eof;      
        
        struct
        {       struct
                {       unsigned __int64
                                ts_sec,         
                                ts_nsec;        
                }ts;    
                uchar
                        msgtype;        

                ushort
                        isfake;         

                ulong
                        txid;           
        }oob;   
} can_frame;

typedef struct _as_ts
{       unsigned __int64
                        can_ts_sec,             
                        can_ts_nsec,    

                        irig_ts_sec,    
                        irig_ts_nsec;   
} as_ts;

enum
{       //
        // This is CAN 2.0 A/B link level info
        //
        S_TYPE_ERROR    =0x8001,        
        S_TYPE_OVER             =0x8002,        
        S_TYPE_REMOTE   =0x8004,        
        S_TYPE_WAKEUP   =0x8008,        
        
        S_TYPE_SYNC             =0x8010,        
        
        S_ERR_OVERRUN   =0x8020,        
        S_ERR_LINE              =0x8040,        
        S_ERR_VOLTAGE   =0x8080,        
        S_COMPLETE              =0x8100,        
        S_QUEUED                =0x8200,        

        S_BOARD_OFF             =0x01,  
        S_BOARD_PASSIVE =0x02,  
        S_BOARD_WARNING =0x04,  
        S_BOARD_ACTIVE  =0x08,  

        S_MSG_TRANSMIT,         
        S_MSG_REMOTE,           
        S_MSG_ERROR             
};

enum
{       S_SUCCESS=0,    
        S_PENDING,      

        S_ERR_QUEUE_IS_EMPTY,   
        S_ERR_QUEUE_IS_FULL,    
        S_ERR_TX_NOT_POSSIBLE,  
        S_ERR_TWICE_REGISTER,   
        S_ERR_INVALID_CHAN_INDEX,
        S_ERR_INVALID_ACCESS,   
        S_ERR_PORT_IS_OFFLINE,  
        S_ERR_CHAN_IS_ONLINE,   
        S_ERR_INVALID_PORT,             
        S_ERR_HW_NOT_READY,             
        S_ERR_CMD_TIMEOUT,              
        S_ERR_HW_NOT_PRESENT,   
        S_ERR_NOTIFY_ALREADY_ACTIVE,    
        S_ERR_NO_RESOURCES,             
        S_ERR_CANNOT_OPEN_DRIVER,       
        S_ERR_NOT_IMPLEMENTED,  
        S_ERR_INV_HANDLE,       
        S_ERR_INVARG1,  
        S_ERR_INVARG2,  
        S_ERR_INVARG3,  
        S_ERR_INVARGS,  
        S_ERR_OOB,      
        S_ERR_UNKNOWN,  

        S__MAX
};

enum
{       FAKED_SOF       =0x0001,        
        FAKED_ID        =0x0002,        
        FAKED_SRR       =0x0004,        
        FAKED_IDE       =0x0008,        
        FAKED_EXT       =0x0010,        
        FAKED_RTR       =0x0020,        
        FAKED_RES       =0x0040,        
        FAKED_DLC       =0x0080,        
        FAKED_DATA      =0x0100,        
        FAKED_CRC       =0x0200,        
        FAKED_ACK       =0x0400,        
        FAKED_EOF       =0x0800,        

        //
        // get/set options can do the following
        //
        C_TXERROR=0,    //Set/read TXError counter
        C_RXERROR,              //Set/read RXError counter
        C_BAUDRATE,             //Set/read baudrate of channel
        C_MASK,                 //Set/read filter for channel
        C_CODE,
        C_RXQUEUE,              //Flush, get length of receive queue
        C_TXQUEUE,              //Flush, get length of transmit queue
        C_HIDEERRORS,   //Hid errors
        C_HIDECHIP,             //Hide Chip Status
        C_BLOCKTIMEOUT, //Block R/W
        C_BOARDSTATE,   //Active/passive/warning/off
        C__MAX
};
#define CAN_MAXCHANNELS         1024    
#define CAN_MAXBUFFER           256     


typedef char can_list[CAN_MAXCHANNELS][CAN_MAXBUFFER];
#ifdef __cplusplus
   extern "C" {
#endif

int can_probebus (can_list list, char*errbuf);




int can_openchannel (char*device, char*errbuf);




int can_readchannel (int handle, can_frame*frame);




int can_writechannel (int handle, can_frame*frame);




int can_closechannel (int handle);




int can_setchanneloptions (int handle, int option, int status);




int can_getchanneloptions (int handle, int option, int*status);




int can_can2raw (can_frame*frame, uchar*raw);




int can_raw2can (uchar*raw, can_frame*frame);




int can_getlasterror (int handle, char*errbuf);




int can_getlastassoc (int handle, as_ts*timestamp);

//***************************************************//
//
// Really, this is just for Boeing...
// But I don't want to add another abstraction layer
//
enum
{       B_CAN_GATEWAY,  
        B_CAN_GROUP,    
        B_CAN_MESSAGE,  
        B_CAN_STATUS    
};
int can_getfield (can_frame*frame,int type,int*ret);
//
//
//**************************************************//

#ifdef __cplusplus
}
#endif

#endif

---