xlcandemo.c

汽车领can总线通讯程序

      g_xlChannelMask, g_xlPortHandle, g_xlPermissionMask, xlGetErrorString(xlStatus));
  }

  if ( (XL_SUCCESS == xlStatus) && (XL_INVALID_PORTHANDLE != g_xlPortHandle) ) {
    
    // ------------------------------------
    // if we have permission we set the
    // bus parameters (baudrate)
    // ------------------------------------
    if (g_xlPermissionMask) {
      
      xlStatus = xlCanSetChannelBitrate(g_xlPortHandle, g_xlChannelMask, g_BaudRate);
      printf("- SetChannelBitrate: baudr.=%u, %s\n",g_BaudRate, xlGetErrorString(xlStatus));
    }
  }
  
  
  if((XL_SUCCESS != xlStatus)  || (XL_INVALID_PORTHANDLE == g_xlPortHandle)) {
    xlClosePort(g_xlPortHandle);
    g_xlPortHandle = XL_INVALID_PORTHANDLE;
    xlStatus = XL_ERROR;
  }
  
  return xlStatus;
  
}                    

////////////////////////////////////////////////////////////////////////////

//! demoCleanUp()

//! close the port and the driver
//!
////////////////////////////////////////////////////////////////////////////

static XLstatus demoCleanUp(void)
{
  XLstatus xlStatus;
    
  if (g_xlPortHandle != XL_INVALID_PORTHANDLE) {
    xlStatus = xlClosePort(g_xlPortHandle);
    printf("- ClosePort        : PH(0x%x), %s\n", g_xlPortHandle, xlGetErrorString(xlStatus));
  }

  g_xlPortHandle = XL_INVALID_PORTHANDLE;
  xlCloseDriver();

  return XL_SUCCESS;    // No error handling
}

////////////////////////////////////////////////////////////////////////////

//! main

//! 
//!
////////////////////////////////////////////////////////////////////////////

int main(int argc, char *argv[])
{
  XLstatus      xlStatus;
  XLaccess      xlChanMaskTx = 0x0001;

  int           stop = 0;
  int           activated = 0;
  int           c;
  int           chanIndex = 0;
  unsigned int  txID = 0x01;
  int           outputMode = XL_OUTPUT_MODE_NORMAL;


  printf("----------------------------------------------------------\n");
  printf("- xlCANdemo - Test Application for XL Family Driver API  -\n");
  printf("-             Vector Informatik GmbH,  " __DATE__"       -\n");
  printf("----------------------------------------------------------\n");

  // ------------------------------------
  // commandline may specify application 
  // name and baudrate
  // ------------------------------------
  if (argc > 1) {
    g_BaudRate = atoi(argv[1]);
    if (g_BaudRate) {
      printf("Baudrate = %u\n", g_BaudRate);
      argc--;
      argv++;
    }
  }
  if (argc > 1) {
    strncpy(g_AppName, argv[1], XL_MAX_APPNAME);
    g_AppName[XL_MAX_APPNAME] = 0;
    printf("AppName = %s\n", g_AppName);
    argc--;
    argv++;
  }
  if (argc > 1) {
    sscanf (argv[1], "%lx", &txID ) ;
    if (txID) {
      printf("TX ID = %lx\n", txID);
    }
  }

  // ------------------------------------
  // initialize the driver structures 
  // for the application
  // ------------------------------------
  xlStatus = demoInitDriver();
  printf("- Init             : %s\n",  xlGetErrorString(xlStatus));
  
  if(XL_SUCCESS == xlStatus) {
    // ------------------------------------
    // create the RX thread to read the
    // messages
    // ------------------------------------
    xlStatus = demoCreateRxThread();
    printf("- Create RX thread : %s\n",  xlGetErrorString(xlStatus));
  }

  if(XL_SUCCESS == xlStatus) {
    // ------------------------------------
    // go with all selected channels on bus
    // ------------------------------------
    xlStatus = xlActivateChannel(g_xlPortHandle, g_xlChannelMask, XL_BUS_TYPE_CAN, XL_ACTIVATE_RESET_CLOCK);
    printf("- ActivateChannel  : CM=0x%I64x, %s\n\n", g_xlChannelMask, xlGetErrorString(xlStatus));
    if(xlStatus == XL_SUCCESS) activated = 1;
  }
  

  printf(": Press <h> for help\n");

  // ------------------------------------
  // parse the key - commands
  // ------------------------------------
  while (stop == 0) {

    unsigned long n;
    INPUT_RECORD ir;

    ReadConsoleInput(GetStdHandle(STD_INPUT_HANDLE), &ir, 1, &n);

    if ((n == 1) && (ir.EventType == KEY_EVENT)) {

      if (ir.Event.KeyEvent.bKeyDown) {

        c = ir.Event.KeyEvent.uChar.AsciiChar;
        switch (c) {

          case 'v':
            if (g_silent) { g_silent = 0; printf("- screen on\n"); }
            else {g_silent = 1; printf("- screen off\n"); }
            break;

          case 't': // transmit a message
            demoTransmit(txID, xlChanMaskTx);
            break;

          case 'b':  // transmit message burst 
            demoTransmitBurst(txID);
            break; 

          case 'm': // transmit a remote message
            demoTransmitRemote(txID, xlChanMaskTx);
            break;

          case '-': // channel selection
            chanIndex--;
            
            if (chanIndex < 0) chanIndex = g_xlDrvConfig.channelCount - 1;
        
            xlChanMaskTx = (unsigned long) g_xlDrvConfig.channel[chanIndex].channelMask;
            printf("- TX Channel set to channel: %02d, %s CM(0x%I64x)\n", 
              g_xlDrvConfig.channel[chanIndex].channelIndex, g_xlDrvConfig.channel[chanIndex].name, xlChanMaskTx);
            break;
            
          case '+': // channel selection   
            chanIndex++;
            if (chanIndex >= (int) g_xlDrvConfig.channelCount) chanIndex = 0;

            xlChanMaskTx = (unsigned long) g_xlDrvConfig.channel[chanIndex].channelMask;
            printf("- TX Channel set to channel: %02d, %s CM(0x%I64x)\n", 
              g_xlDrvConfig.channel[chanIndex].channelIndex, g_xlDrvConfig.channel[chanIndex].name, xlChanMaskTx);
            break;

          case 'x':
            txID ^= 0x80000000UL; // toggle ext/std
            printf("- Id set to %08X\n", txID);
            break;

          case 'I': // id selection
            txID--;
            printf("- Id set to 0x%08X\n", txID);
            break;

          case 'i':
            txID++; 
            printf("- Id set to 0x%08X\n", txID);
            break;

          case 'g':
            xlStatus = xlCanRequestChipState(g_xlPortHandle, g_xlChannelMask);
            printf("- RequestChipState : CM(0x%I64x), %s\n", g_xlChannelMask, xlGetErrorString(xlStatus));
            break;

          case 'a':
            if (g_TimerRate) g_TimerRate = 0; 
            else g_TimerRate = 20000;
 
            xlStatus = xlSetTimerRate(g_xlPortHandle, g_TimerRate);
            printf("- SetTimerRate     : %d, %s\n", g_TimerRate, xlGetErrorString(xlStatus));
            break;

          case 'o':
            switch(outputMode) {
            case XL_OUTPUT_MODE_NORMAL:
              outputMode = XL_OUTPUT_MODE_SILENT;
              break;
            case XL_OUTPUT_MODE_SILENT:
              outputMode = XL_OUTPUT_MODE_TX_OFF;
              break;
            case XL_OUTPUT_MODE_TX_OFF:
            default:
              outputMode = XL_OUTPUT_MODE_NORMAL;
              break;
            }
            
            demoSetOutput(outputMode, xlChanMaskTx);
            break;

          case 'r':
            xlStatus = xlResetClock(g_xlPortHandle);
            printf("- ResetClock       : %s\n", xlGetErrorString(xlStatus));
            break;

          case 's':
            if (activated) activated = 0;
            else activated = 1;
            demoStartStop(activated);
            break;

          case 'p':
            demoPrintConfig();
            break;

          case 27: // end application
            stop=1;
            break;

          case 'h':
            demoHelp();
            break;

          default:
            break;
                                                            // end switch
        }
      }
    }
  }                                                         // end while
  

  if((XL_SUCCESS != xlStatus) && activated) { 
    xlStatus = xlDeactivateChannel(g_xlPortHandle, g_xlChannelMask);
    printf("- DeactivateChannel: CM(0x%I64x), %s\n", g_xlChannelMask, xlGetErrorString(xlStatus));
  } 
  demoCleanUp();

  return(0);
}                                                  // end main()


////////////////////////////////////////////////////////////////////////////

//! TxThread

//! 
//!
////////////////////////////////////////////////////////////////////////////

DWORD WINAPI TxThread( LPVOID par ) 
{
  XLstatus      xlStatus = XL_SUCCESS;
  XLevent       xlEvent;
  unsigned int  n = 1;
  unsigned int  TxID = *(unsigned int*) par;

  memset(&xlEvent, 0, sizeof(xlEvent));

  xlEvent.tag                 = XL_TRANSMIT_MSG;
  xlEvent.tagData.msg.id      = TxID;
  xlEvent.tagData.msg.dlc     = 8;
  xlEvent.tagData.msg.flags   = 0;
  xlEvent.tagData.msg.data[0] = 1;
  xlEvent.tagData.msg.data[1] = 2;
  xlEvent.tagData.msg.data[2] = 3;
  xlEvent.tagData.msg.data[3] = 4;
  xlEvent.tagData.msg.data[4] = 5;
  xlEvent.tagData.msg.data[5] = 6;
  xlEvent.tagData.msg.data[6] = 7;
  xlEvent.tagData.msg.data[7] = 8;
  
  g_TXThreadRun = 1;

  while (g_TXThreadRun && XL_SUCCESS == xlStatus) { 
    ++xlEvent.tagData.msg.data[0];
    xlStatus = xlCanTransmit(g_xlPortHandle, g_xlChannelMask, &n, &xlEvent);
    
    Sleep(10);
 
  }

  if(XL_SUCCESS != xlStatus) {
    printf("Error xlCanTransmit:%s\n", xlGetErrorString(xlStatus));
  }
  return NO_ERROR; 

}

///////////////////////////////////////////////////////////////////////////

//! RxThread

//! thread to readout the message queue and parse the incoming messages
//!
////////////////////////////////////////////////////////////////////////////

DWORD WINAPI RxThread(LPVOID par) 
{
  XLstatus        xlStatus;
  
  unsigned int    msgsrx = RECEIVE_EVENT_SIZE;
  XLevent         xlEvent; 
  
  UNUSED_PARAM(par); 
  
  g_RXThreadRun = 1;

  while (g_RXThreadRun) { 
   
    WaitForSingleObject(g_hMsgEvent,10);

    xlStatus = XL_SUCCESS;
    
    while (!xlStatus) {
      
      msgsrx = RECEIVE_EVENT_SIZE;
      xlStatus = xlReceive(g_xlPortHandle, &msgsrx, &xlEvent);      
		
		
	  if ( xlStatus!=XL_ERR_QUEUE_IS_EMPTY ) {

        if (!g_silent) {
          printf("%s\n", xlGetEventString(&xlEvent));
        }

        //ResetEvent(g_hMsgEvent);
      }  
    }
          
  }
  return NO_ERROR; 
}