transmitest.cpp

CAN 驱动编程

//****************************************************************************
// Copyright (C) 2001,2002, 2003  PEAK System-Technik GmbH
//
// [e-mail] 
// www.peak-system.com
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
//
// Maintainer(s): Klaus Hitschler ([e-mail])
//****************************************************************************

//****************************************************************************
//
// transmitest.cpp - a simple program to test CAN transmits
//
// $Log: transmitest.cpp,v $
// Revision 1.5  2003/03/02 10:58:08  klaus
// merged USB thread into main path
//
// Revision 1.4.2.3  2003/02/23 17:50:42  klaus
// adapted to gcc 3.2
//
// Revision 1.4.2.2  2003/01/29 21:57:58  klaus
// modified to use with USB
//
// Revision 1.4.2.1  2003/01/29 21:57:58  klaus
// modified to use with USB
//
// Revision 1.4  2002/02/16 16:38:10  klaus
// cosmetical changes
//
// Revision 1.3  2002/01/30 20:54:27  klaus
// simple source file header change
//
// Revision 1.2  2002/01/13 18:26:42  klaus
// first release
//
// Revision 1.1  2002/01/07 21:25:12  klaus
// moved from transmittest.cpp
//
//****************************************************************************

//----------------------------------------------------------------------------
// set here current release for this program
#define CURRENT_RELEASE "Release_20020206_a"  

//****************************************************************************
// INCLUDES
#include <cstdio>
#include <cstdlib>
#include <cerrno>
#include <ctype.h>
#include <unistd.h>   // exit
#include <signal.h>
#include <string.h>

#include <libpcan.h>
#include <src/common.h>
#include <src/parser.h>

//****************************************************************************
// DEFINES

//****************************************************************************
// GLOBALS
HANDLE h = NULL;
char *current_release;

//****************************************************************************
// LOCALS

//****************************************************************************
// CODE 
static void hlpMsg(void)
{
  printf("transmitest - a small test program which sends CAN messages.\n");
  printf("usage:   transmitest filename [-t=type] [-p=port [-i=irq]] [-b=BTR0BTR1] [-e] [-?]\n");
  printf("options: filename - mandatory name of message description file.\n");
  printf("         -t - type of interface, e.g. 'pci', 'sp', 'epp' ,'isa' or 'usb' (default: pci).\n");
  printf("         -p - port in hex notation if applicable, e.g. 0x378 (default: 1st port of type).\n");
  printf("         -i - irq in dec notation if applicable, e.g. 7 (default: irq of 1st port).\n");
  printf("         -b - BTR0BTR1 code in hex, e.g. 0x001C (default: 500 kbit).\n");
  printf("         -e - accept extended frames. (default: standard frames)\n");
  printf("         -? or --help - this help\n");
  printf("\n");
}
  
//----------------------------------------------------------------------------
// centralized entry point for all exits 
static void my_private_exit(int error)
{
  if (h)
  {
    print_diag("transmitest");
    CAN_Close(h); 
  }
  printf("transmitest: finished (%d).\n\n", error);
  exit(error);
}

//----------------------------------------------------------------------------
// handles CTRL-C user interrupt
static void signal_handler(int signal)
{
  my_private_exit(0);
} 

//----------------------------------------------------------------------------
// all is done here
int main(int argc, char *argv[])
{ 
  char *ptr;
  int i;
  int nType = HW_PCI;
  __u32 dwPort = 0;
  __u16 wIrq = 0;
  __u16 wBTR0BTR1 = 0;
  int   nExtended = CAN_INIT_TYPE_ST;
  char  *filename = NULL;
  int   counter = 0;
  parser MyParser;
  std::list<TPCANMsg> *List;
  
  errno = 0;
  
  current_release = CURRENT_RELEASE;
  disclaimer("transmitest");

  // decode command line arguments
  for (i = 1; i < argc; i++)
  {
    char c;
    
    ptr = argv[i];
    
    if (*ptr == '-')
    {
      while (*ptr == '-')
        ptr++;
	
      c = *ptr;
      ptr++;

      if (*ptr == '=')
      ptr++;

      switch(tolower(c))
      {
        case 't':
          nType = getTypeOfInterface(ptr);
	        if (!nType)
	        {
		        errno = EINVAL;
		        printf("transmitest: unknown type of interface");
		        my_private_exit(errno);
	        }
          break;
        case 'p':
	        dwPort = strtoul(ptr, NULL, 16);
	        break;
        case 'i':
	        wIrq   = (__u16)strtoul(ptr, NULL, 10);
	        break;
        case 'e':
	        nExtended = CAN_INIT_TYPE_EX;
	        break;
        case '?': 
        case 'h':
          hlpMsg();
	        my_private_exit(0);
	        break;
        case 'b':
	        wBTR0BTR1 = (__u16)strtoul(ptr, NULL, 16);
	        break;
        default:
	        errno = EINVAL;
	        printf("transmitest: unknown command line argument");
	        my_private_exit(errno);
	        break;
      }
    }
    else
      filename = ptr;            
  }

  // test for filename
  if (filename == NULL)
  {
    errno = EINVAL;
    perror("transmitest: no filename given");
    my_private_exit(errno);
  }

  // give the filename to my parser
  MyParser.setFileName(filename);
    
  // tell some information to user
  printf("transmitest: type=%s", getNameOfInterface(nType));
  if (nType == HW_USB)
  {
    printf(", Serial Number=default, Device Number=%d\n", wIrq); 
  }
  else
  {
    if (dwPort)
    {
      if (nType == HW_PCI)
        printf(", %d. PCI device", dwPort);
      else
        printf(", port=0x%08x", dwPort);
    }
    else
      printf(", port=default");
    if ((wIrq) && !(nType == HW_PCI))
      printf(" irq=0x%04x\n", wIrq);
    else
      printf(", irq=default\n");
  }
    
  if (nExtended == CAN_INIT_TYPE_EX)
    printf("             Extended frames are sent");
  else
    printf("             Only standard frames are sent");
  if (wBTR0BTR1)
    printf(", init with BTR0BTR1=0x%04x\n", wBTR0BTR1);
  else
    printf(", init with 500 kbit/sec.\n");
    
  printf("             Data will be read from \"%s\".\n", filename);
    
  
  // install signal handler for manual break
  signal(SIGINT, signal_handler);
  
  // get the list of data from parser
  List = MyParser.Messages();
  if (!List)
  {
    errno = MyParser.nGetLastError();
    perror("transmitest: error at file read");
    my_private_exit(errno);    
  }
 
  // open the CAN port
  // please use what is appropriate  
  // HW_DONGLE_SJA 
  // HW_DONGLE_SJA_EPP 
  // HW_ISA_SJA 
  // HW_PCI 
  h = CAN_Open(nType, dwPort, wIrq);
  
  if (h)
  {
    char txt[VERSIONSTRING_LEN];
    int  err;
    
    // clear status
    CAN_Status(h);
   
    // get version info
    errno = CAN_VersionInfo(h, txt);
    if (!errno)
      printf("transmitest: driver version = %s\n", txt);
    else
    {
      perror("transmitest: CAN_VersionInfo()");
      my_private_exit(errno);
    }
      
    // init to a user defined bit rate
    if (wBTR0BTR1)
    {
      errno = CAN_Init(h, wBTR0BTR1, nExtended);
      if (errno)
      {
        perror("transmitest: CAN_Init()");
	      my_private_exit(errno);
	    }
	  }
	  
	  printf("transmitest: writing data to CAN ... (press Ctrl-C to exit)\n");
      
    // write out endless loop until Ctrl-C
    while (1)
    {
      std::list<TPCANMsg>::iterator iter;
      int i;
    
      for (iter = List->begin(); iter != List->end(); iter++)
      {  
        // test for standard frames only
        if ((nExtended == CAN_INIT_TYPE_EX) || !(iter->MSGTYPE & MSGTYPE_EXTENDED))
	      {  
	        // send the message
          if ((errno = CAN_Write(h, &(*iter))))
          {
            perror("transmitest: CAN_Write()");
	          my_private_exit(errno);
	        }
	      }
		  }    
    }
  }
  else
  {
    errno = nGetLastError();
    perror("transmitest: CAN_Open()");
    my_private_exit(errno);
  }
    
  return errno;
}