canapi.c

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:    Source file for the highest level of the CAN api
 *
 * Author:      Christopher McKenzie
 * 
 * MAINTENANCE NOTES:
 * 
 *============================================================================*/
#include"..\interfaces\interfaces.h"
#include"..\includes\defines.h"
#include"..\includes\canapi.h"
#include<string.h>
#include<stdio.h>
#include<windows.h>

extern int _offsets[B__MAX];
extern int if_channel_count;
extern int _bit_width[B__MAX];
extern struct _s_interface*interfaces;
extern struct _if_channel       channel[CAN_MAXCHANNELS];
extern unsigned char*_errors[S__MAX];
extern unsigned char*_errframe[10];
extern int if_board_count;
FILE*tracefile;
int api_channel_count=0;

int _get_offsets()
{       static int      done=0,
                                acc=0,
                                ix=0;
        if(done==1)
                return 1;
        _offsets[0]=0;
        for(ix=1;ix<B__MAX;ix++)
        {       _offsets[ix]=           //current offset
                        _offsets[ix-1]+ //place of last offset
                        _bit_width[ix-1];       //size of last data structure
        }
        done=1;
        return 1;
}

int seterror(char*buffer,int toset)
{       strcpy(buffer,_errors[toset]);
        return 1;
}

int isinvalid(int handle)
{       if(handle>if_channel_count|| handle<0)
        {       return S_ERR_INV_HANDLE;
        }
        if(!channel[handle].isopen)
        {       channel[handle].error.last=S_ERR_INV_HANDLE;
                return S_ERR_INV_HANDLE;
        }
        return 0;
}

//
// This takes a can 2.0 B frame and converts it to a
// bit packed raw frame
//
// look in doc/CAN20b_rawformat.txt for reference
//
int can_can2raw(can_frame*frame,unsigned char*raw)      //TESTTEST
{       int offset=_GETBYTE(_bit_width[B_DAT])-frame->control.dlc;

        if(!frame)
        {       return S_ERR_INVARG1;
        }
        if(!raw)
        {       return S_ERR_INVARG2;
        }
        //Otherwise, we assume everything is awesome
        _get_offsets();

        setatbit(raw,(unsigned char*)frame->sof,                                                _offsets[B_SOF],_bit_width[B_SOF]); //SOF
        setatbit(raw,(unsigned char*)frame->arbitration.identifier11bit,_offsets[B_ID], _bit_width[B_ID]); //ID
        setatbit(raw,(unsigned char*)frame->arbitration.srr,                    _offsets[B_SRR],_bit_width[B_SRR]); //SRR
        setatbit(raw,(unsigned char*)frame->arbitration.ide,                    _offsets[B_IDE],_bit_width[B_IDE]); //IDE
        setatbit(raw,(unsigned char*)frame->arbitration.identifier18bit,_offsets[B_EXT],_bit_width[B_EXT]); //EXT
        setatbit(raw,(unsigned char*)frame->arbitration.rtr,                    _offsets[B_RTR],_bit_width[B_RTR]); //RTR
        setatbit(raw,(unsigned char*)frame->control.r0,                                 _offsets[B_RES],_bit_width[B_RES]); //RES
        setatbit(raw,(unsigned char*)frame->control.dlc,                                _offsets[B_DLC],_bit_width[B_DLC]); //DLC

        //Things get trickier
        setatbit(raw,(unsigned char*)frame->data,                       _offsets[B_DAT],frame->control.dlc); //DAT
        setatbit(raw,(unsigned char*)frame->crc.sequence,       _offsets[B_CRC],_bit_width[B_CRC]-offset); //CRC
        setatbit(raw,(unsigned char*)frame->ack.slot,           _offsets[B_ACK],_bit_width[B_ACK]-offset); //ACK
        setatbit(raw,(unsigned char*)frame->eof,                        _offsets[B_EOF],_bit_width[B_EOF]-offset); //EOF

        return S_SUCCESS;
}

int can_raw2can(unsigned char*raw,can_frame*frame)      //FIXME
{       return 1;
}

int can_setchanneloptions(int handle,int option,int status)
{       if(!isinvalid(handle))
        {       if(option<C__MAX&&option>0)
                        return boardchangestatus(handle,option,status);
                SETERROR(S_ERR_INVARG2);
                return S_ERR_INVARG2;
        }
        return S_ERR_INV_HANDLE;
}

int can_getchanneloptions(int handle, int option, int*status)
{       if(!isinvalid(handle))
        {       boardupdatestatus(handle);      //might as well
                switch(option)
                {       case C_TXERROR:
                                (*status)=channel[handle].txerror;
                                break;
                        case C_RXERROR:
                                (*status)=channel[handle].rxerror;
                                break;
                        case C_BAUDRATE:
                                (*status)=channel[handle].baudrate;
                                break;
                        case C_MASK:
                                (*status)=channel[handle].filter.mask;
                                break;
                        case C_CODE:
                                (*status)=channel[handle].filter.code;
                                break;
                        case C_RXQUEUE:
                                (*status)=channel[handle].rxqueue;
                                break;
                        case C_TXQUEUE:
                                (*status)=channel[handle].txqueue;
                                break;
                        case C_HIDEERRORS:
                                (*status)=channel[handle].baudrate;
                                break;
                        case C_HIDECHIP:
                                (*status)=channel[handle].baudrate;
                                break;
                        case C_BLOCKTIMEOUT:
                                (*status)=channel[handle].blocktimeout;
                                break;
                        case C_BOARDSTATE:
                                (*status)=channel[handle].board->status;
                                break;
                        default:
                                SETERROR(S_ERR_INVARG2);
                                return S_ERR_INVARG2;
                                break;
                }
                return S_SUCCESS;
        }
        return S_ERR_INV_HANDLE;
}

int can_probebus(can_list list,char*errbuf)
{       int ix;
                
        if(list)
        {       memset(list,0,CAN_MAXCHANNELS*CAN_MAXBUFFER);
                if_channel_count=0;
                if_board_count=0;
                if(!boardprobe())
                {       seterror(errbuf,S_ERR_UNKNOWN);
                        return -1;
                }
                for(ix=0;ix<if_channel_count;ix++)
                {       strcpy(list[ix],channel[ix].name);
                }
        }else
                seterror(errbuf,S_ERR_INVARG1);
        return if_channel_count;
}

int can_openchannel(char*device,char*errbuf)
{       int ix;
        for(ix=0;ix<if_channel_count;ix++)
        {       if(!strcmp(device,channel[ix].name))
                {       boardopenchannel(ix);
                        return ix;
                }
        }
        seterror(errbuf,S_ERR_HW_NOT_PRESENT);
        return -1;
}

int can_readchannel(int handle,can_frame*frame)
{       if(!isinvalid(handle))
        {       if(frame)
                        return boardread(handle,frame);
                SETERROR(S_ERR_INVARG2);
                return S_ERR_INVARG2;
        }
        return S_ERR_INV_HANDLE;
}

int can_writechannel(int handle,can_frame*frame)
{       if(!isinvalid(handle))
        {       if(frame)
                        return boardwrite(handle,frame);
                SETERROR(S_ERR_INVARG2);
                return S_ERR_INVARG2;
        }
        return S_ERR_INV_HANDLE;
}

int can_closechannel(int handle)
{       if(!isinvalid(handle))
                return boardshutdown(handle);
        return S_ERR_INV_HANDLE;
}

int can_getlasterror(int handle,char*errbuf)
{       if(!isinvalid(handle))
        {       errbuf[0]=0;
                if(channel[handle].error.last&0x8000)
                {       int ix=0,mask=1,err=channel[handle].error.last;
                        do
                        {       if(err&mask)
                                        sprintf(errbuf,"%s %s",errbuf,_errframe[ix]);
                                mask=mask<<1;
                                ix++;
                        }while(_errframe[ix]);
                        return S_SUCCESS;
                }
                strcpy(errbuf,_errors[channel[handle].error.last]);
                channel[handle].error.last=0;
                return S_SUCCESS;
        }
        return S_ERR_INV_HANDLE;
}

int can_getlastassoc (int handle, as_ts*timestamp)
{       if(!isinvalid(handle))
        {       timestamp->can_ts_nsec=channel[handle].lastsync.can_ts_nsec;
                timestamp->can_ts_sec=channel[handle].lastsync.can_ts_sec;
                timestamp->irig_ts_nsec=channel[handle].lastsync.irig_ts_nsec;
                timestamp->irig_ts_sec=channel[handle].lastsync.irig_ts_sec;
                return S_SUCCESS;
        }
        return S_ERR_INV_HANDLE;
}

int __stdcall DllMain(HANDLE hmodule, DWORD dwReason, PVOID pvReserved)
{       
        switch (dwReason)
    {
    case DLL_PROCESS_ATTACH:
                tracefile=fopen("trace.txt","w");
        break;
    case DLL_THREAD_ATTACH:
                break;
    case DLL_PROCESS_DETACH:
                fclose(tracefile);
        break;
    case DLL_THREAD_DETACH:
                break;
    default:
//        Bug("DllMain() called with unrecognized dwReason.");
        return FALSE;
    }
        return 1;
}

int b_can_bitsizes[]=
{       1,      //gateway
        8,      //group
        12,     //message
        8       //status
};

int can_getfield (can_frame*frame,int type,int*ret)
{       static int      offsetdone=0,
                                offsets[sizeof(b_can_bitsizes)];
        
        unsigned int    smashed=0;

        unsigned char buffer[4];
        
        if(!ret)
        {       
                return S_ERR_INVARG3;
        }

        if(!offsetdone)
        {       int ix;
                //calculate offsets
                offsets[0]=0;
                for(ix=1;ix<sizeof(b_can_bitsizes);ix++)
                {       offsets[ix]=offsets[ix-1]+b_can_bitsizes[ix-1];//TESTTEST
                }
                offsetdone=1;   //only once though
        }
        //
        // smash together base and extended
        //

        //
        // First we throw in the 11 bit identifier
        //
        smashed=frame->arbitration.identifier11bit;
        
        //
        // Bitshift it 18 left
        //
        smashed<<=18;
        
        //
        // or it with the 18 bit identifier
        //
        smashed|=frame->arbitration.identifier18bit;

        //
        // Now pretend its a char* cause we can use our awesome function
        //
        getatbit(
                (unsigned char*)&smashed,
                (unsigned char*)&buffer,
                offsets[type],
                b_can_bitsizes[type]);

        //
        // so now buffer has the field data - do some black magic to
        // make it an int
        //
        *ret=(int)buffer;

        //
        // and ya' know, return success...
        //
        return S_SUCCESS;
}

---