Category

Development Platform
Home > SourceCode/Document > Embeded-SCM Develop > SCM > View Code
xlLINFunctions.cpp
Package: xlLinExample.rar　[view]
Upload User: dfymccf
Upload Date: 2008-03-14
Package Size: 18k
Code Size: 18k
Category:

SCM

Development Platform:

Visual C++

xlLINFunctions.cpp：Code Content
  1. /*----------------------------------------------------------------------------
  2. | File        : LINFunctions.cpp
  3. | Project     : Vector LIN Example - manage the LIN access
  4. |
  5. | Description : 
  6. |-----------------------------------------------------------------------------
  7. | $Author: J鰎g $    $Locker: $   $Revision: 16 $
  8. | $Header: /VCANDRV/XLAPI/samples/xlLinExample/xlLINFunctions.cpp 16    14.11.05 10:54 J鰎g $
  9. |-----------------------------------------------------------------------------
  10. | Copyright (c) 2004 by Vector Informatik GmbH.  All rights reserved.
  11. |---------------------------------------------------------------------------*/
  13. #include "stdafx.h"
  14. #include "xlLINExample.h"
  15. #include "xlLINFunctions.h"
  16. #include "debug.h"
  18. #ifdef _DEBUG
  19. #undef THIS_FILE
  20. static char THIS_FILE[]=__FILE__;
  21. #define new DEBUG_NEW
  22. #endif
  24. // ---------------------------------------------------
  25. // globals
  26. BOOL      g_bThreadRun;
  27. TStruct   g_th;
  29. //////////////////////////////////////////////////////////////////////
  30. // Construction/Destruction
  31. //////////////////////////////////////////////////////////////////////
  33. CLINFunctions::CLINFunctions() {
  34.   m_xlPortHandle = XL_INVALID_PORTHANDLE;
  35.   m_xlChannelMask[MASTER] = m_xlChannelMask[SLAVE] = 0;
  36. }
  38. CLINFunctions::~CLINFunctions() 
  39. {
  40. }
  42. ////////////////////////////////////////////////////////////////////////////
  44. //! LINGetDevice
  46. //! readout the registry to get the hardware information. If there is no 
  47. //! application which is named "xlLINExample" a new one is generated. 
  48. //!
  49. //////////////////////////////////////////////////////////////////////////// 
  51. XLstatus CLINFunctions::LINGetDevice()
  52. {
  53.   XLstatus         xlStatus = XL_ERROR;
  54.   char            tmp[100];
  56.   xlStatus = xlOpenDriver();
  57.   sprintf(tmp, "xlOpenDriver, stat: %d", xlStatus);
  58.   DEBUG(DEBUG_ADV, tmp);
  59.   if (xlStatus != XL_SUCCESS) return xlStatus;
  61.   xlStatus = linGetChannelMask(MASTER);
  62.   xlStatus = linGetChannelMask(SLAVE);
  64.   if ( (m_xlChannelMask[MASTER] == 0) || (m_xlChannelMask[SLAVE] == 0) ) return XL_ERROR;
  65.   
  66.   return xlStatus;
  67. }
  69. ////////////////////////////////////////////////////////////////////////////
  71. //! LINInit
  73. //! LINExample use ONE port for master and slave which is opened. Also a 
  74. //! thread for all incoming messages is created.
  75. //!
  76. //////////////////////////////////////////////////////////////////////////// 
  78. XLstatus CLINFunctions::LINInit(int linID)
  79. {
  80.   XLstatus         xlStatus = XL_ERROR;
  81.   XLaccess         m_xlChannelMask_both;
  82.   XLaccess         xlPermissionMask;
  83.   char             tmp[100];
  85.   // ---------------------------------------
  86.   // Open ONE port for both channels master+slave
  87.   // ---------------------------------------
  89.   // calculate the channelMask for both channel 
  90.   m_xlChannelMask_both = m_xlChannelMask[MASTER] + m_xlChannelMask[SLAVE];
  91.   xlPermissionMask = m_xlChannelMask_both;
  93.   xlStatus = xlOpenPort(&m_xlPortHandle, "LIN Example", m_xlChannelMask_both, &xlPermissionMask, 256, XL_INTERFACE_VERSION, XL_BUS_TYPE_LIN); 
  94.   sprintf(tmp, "xlOpenPort: PortHandle: %d; Permissionmask: 0x%I64x; Status: %d", m_xlPortHandle, xlPermissionMask, xlStatus);
  95.   DEBUG(DEBUG_ADV, tmp);
  97.   m_pStatusBox->InsertString(-1,"xlOpenPort for both");
  98.   
  99.   if (m_xlPortHandle == XL_INVALID_PORTHANDLE) return XL_ERROR;
  100.   if (xlStatus == XL_ERR_INVALID_ACCESS) return xlStatus;
  103.   // ---------------------------------------
  104.   // Create ONE thread for both channels
  105.   // ---------------------------------------
  107.   linCreateRxThread();
  109.   // ---------------------------------------
  110.   // Init each channel (master+slave)
  111.   // ---------------------------------------
  113.   xlStatus = linInitMaster();
  114.   if (xlStatus) {
  115.     m_pStatusBox->InsertString(-1,"Init Master failed!");
  116.     return xlStatus;
  117.   }
  118.   m_pStatusBox->InsertString(-1,"Init Master");
  120.   xlStatus = linInitSlave(linID);
  121.   if (xlStatus) {
  122.     m_pStatusBox->InsertString(-1,"Init Slave failed!");
  123.     return xlStatus;
  124.   }
  125.   m_pStatusBox->InsertString(-1,"Init Slave");
  126.  
  127.   return xlStatus;
  128. }
  130. ///////////////////////////////////////////////////////////////////////////
  132. //! LINClose()
  134. //! Close the port
  135. //!
  136. ////////////////////////////////////////////////////////////////////////////
  138. XLstatus CLINFunctions::LINClose() {
  139.   XLstatus         xlStatus = XL_SUCCESS;
  140.   XLaccess         xlChannelMask_both = m_xlChannelMask[MASTER] | m_xlChannelMask[SLAVE];
  141.   char            tmp[100];
  142.  
  143.   g_bThreadRun = FALSE;
  145.   // Wait until the thread is done...
  146.   Sleep(100);
  148.   if(XL_INVALID_PORTHANDLE == m_xlPortHandle) {
  149.     return(xlStatus);
  150.   }
  151.  
  152.   if(xlChannelMask_both) {
  153.     xlStatus = xlDeactivateChannel(m_xlPortHandle, xlChannelMask_both);
  154.     sprintf(tmp, "xlDeactivateChannel, status: %d",  xlStatus);
  155.     DEBUG(DEBUG_ADV, tmp);
  156.     if(xlStatus) return xlStatus;
  157.   }
  159.   xlStatus = xlClosePort(m_xlPortHandle);
  160.   sprintf(tmp, "xlClosePort, status: %d",  xlStatus);
  161.   DEBUG(DEBUG_ADV, tmp);
  162.   if(xlStatus) return xlStatus;
  164.   m_xlPortHandle = XL_INVALID_PORTHANDLE;
  166.   xlStatus = xlCloseDriver();
  167.   sprintf(tmp, "xlCloseDriver, status: %d",  xlStatus);
  168.   DEBUG(DEBUG_ADV, tmp);
  169.   if(xlStatus) return xlStatus;
  171.   m_pStatusBox->InsertString(-1,"Close All");
  173.   return xlStatus;
  174. }
  176. ///////////////////////////////////////////////////////////////////////////
  178. //! LINSendMasterReq()
  180. //! Sends a master request to the LIN bus.
  181. //!
  182. ////////////////////////////////////////////////////////////////////////////
  184. XLstatus CLINFunctions::LINSendMasterReq(BYTE data, int linID)
  185. {
  186.   XLstatus        xlStatus = XL_ERROR;
  187.   char            tmp[100];
  188.   
  189.   // send the master request
  190.   xlStatus = xlLinSendRequest(m_xlPortHandle, m_xlChannelMask[MASTER], linID, 0);
  191.   sprintf(tmp, "SendRq CM: '%I64u', status: %d", m_xlChannelMask[MASTER], xlStatus);
  192.   DEBUG(DEBUG_ADV, tmp);
  194.   m_pStatusBox->InsertString(-1,"Master Request");
  196.   // setup the slave
  197.   xlStatus = linSetSlave(data);
  198.   
  199.   return xlStatus;
  200. }
  202. ////////////////////////////////////////////////////////////////////////////
  204. //! linGetChannelMask
  206. //! parse the registry to get the channelmask
  207. //!
  208. //////////////////////////////////////////////////////////////////////////// 
  210. XLstatus CLINFunctions::linGetChannelMask(int LINType)
  211. {
  212.   XLstatus        xlStatus = XL_ERROR;
  213.   char            tmp[100];
  215.   // default values
  216.   unsigned int  hwType    = XL_HWTYPE_CANCARDXL;
  217.   unsigned int  hwIndex   = 0;
  218.   unsigned int  hwChannel = LINType-1;   // because 0->CH1 should be MASTER, 1->CH2 should be SLAVE
  219.   unsigned int  busType   = XL_BUS_TYPE_LIN;   
  220.   unsigned int  i; 
  221.  
  222.   XLdriverConfig  xlDrvConfig;
  224.   xlStatus = xlGetApplConfig("xlLINExample", hwChannel, &hwType, &hwIndex, &hwChannel, busType);              
  225.   
  226.   // Set the params into registry (default values...!)
  227.   if (xlStatus) {
  228.     DEBUG(DEBUG_ADV,"set in registry");
  230.     //check for hardware:
  231.     xlStatus = xlGetDriverConfig(&xlDrvConfig);
  233.     for (i=0; i<xlDrvConfig.channelCount; i++) {
  235.       // check PC for hardware with LINCabs or LINPiggy's 
  236.       if ( xlDrvConfig.channel[i].channelBusCapabilities & XL_BUS_ACTIVE_CAP_LIN) {
  237.         hwType = xlDrvConfig.channel[i].hwType;
  238.         sprintf (tmp, "Found LIN hWType: %d;", hwType);
  239.         DEBUG(DEBUG_ADV,tmp);
  241.          xlStatus = xlSetApplConfig( // Registration of Application with default settings
  242.         "xlLINExample",          // Application Name
  243.         LINType-1,              // Application channel 0 or 1
  244.         hwType,                 // hwType  (CANcardXL...)    
  245.         hwIndex,                // Index of hardware (slot) (0,1,...)
  246.         hwChannel,              // Index of channel (connector) (0,1,...)
  247.         busType);               // the application is for LIN.
  248.       }
  249.     }
  251.   }
  252.   else DEBUG(DEBUG_ADV,"found in registry");
  253.   
  254.   // check for LINPiggy or LINCabs
  255.   xlStatus = xlGetDriverConfig(&xlDrvConfig);
  257.   for (i=0; i<xlDrvConfig.channelCount; i++) {
  259.     // check for LINCabs or LINPiggy's 
  260.     if ( xlDrvConfig.channel[i].channelBusCapabilities & XL_BUS_ACTIVE_CAP_LIN) {
  262.       // and check the right hardwaretype
  263.       if (xlDrvConfig.channel[i].hwType==hwType) {
  264.         m_xlChannelMask[LINType] = xlGetChannelMask(hwType, hwIndex, hwChannel);
  265.       }
  266.     }
  267.   }
  268.   sprintf (tmp, "Init LIN hWType: %d; hWIndex: %d; hwChannel: %d, channelMask: 0x%I64x for %d", hwType, hwIndex, hwChannel, m_xlChannelMask[LINType], LINType);
  269.   DEBUG(DEBUG_ADV,tmp);
  271.   return xlStatus;
  272. }
  274. ////////////////////////////////////////////////////////////////////////////
  276. //! linCreateRxThread
  278. //! set the notification and creates the thread.
  279. //!
  280. ////////////////////////////////////////////////////////////////////////////
  282. XLstatus CLINFunctions::linCreateRxThread()
  283. {
  284.   
  285.   XLstatus      xlStatus;
  286.   DWORD         ThreadId=0;
  287.   char          tmp[100];
  288.  
  289.   if (m_xlPortHandle!= XL_INVALID_PORTHANDLE) {
  291.     sprintf(tmp, "Found OpenPort: %d", m_xlPortHandle);
  292.     DEBUG(DEBUG_ADV, tmp);
  294.     // Send a event for each Msg!!!
  295.     xlStatus = xlSetNotification (m_xlPortHandle, &m_hMsgEvent, 1);
  296.     sprintf(tmp, "SetNotification '%d', xlStatus: %d", m_hMsgEvent, xlStatus);
  297.     DEBUG(DEBUG_ADV, tmp);
  299.     // for the RxThread
  300.     g_th.xlPortHandle = m_xlPortHandle;
  301.     g_th.hMsgEvent    = m_hMsgEvent; 
  302.     g_th.pListRX      = m_pRXBox;
  303.     g_th.pStatusBox   = m_pStatusBox;
  304.   
  305.     m_hThread = CreateThread(0, 0x1000, RxThread, (LPVOID) &g_th, 0, &ThreadId);
  306.     sprintf(tmp, "CreateThread %d", m_hThread);
  307.     DEBUG(DEBUG_ADV, tmp);
  308.     
  309.   }
  310.   return xlStatus;
  311. }
  314. ////////////////////////////////////////////////////////////////////////////
  316. //! linInitMaster
  318. //! initialize the LIN master, set the master DLC's, opens the 
  319. //! message filter and activate the LIN channel (-> bus on).
  320. //!
  321. //////////////////////////////////////////////////////////////////////////// 
  323. XLstatus CLINFunctions::linInitMaster()
  324. {
  325.   XLstatus        xlStatus = XL_ERROR;
  326.   char            tmp[100];
  327.  
  328.   // ---------------------------------------
  329.   // Setup the channel as a MASTER
  330.   // ---------------------------------------
  332.   XLlinStatPar     xlStatPar;
  334.   xlStatPar.LINMode    = XL_LIN_MASTER; 
  335.   xlStatPar.baudrate   = 9600;               // set the baudrate to 9k6
  336.   xlStatPar.LINVersion = XL_LIN_VERSION_1_3;    // use LIN 1.3
  338.   xlStatus = xlLinSetChannelParams(m_xlPortHandle, m_xlChannelMask[MASTER], xlStatPar);
  340.   sprintf(tmp, "Init Master PH: '%d', CM: '0x%I64x', status: %d", m_xlPortHandle, m_xlChannelMask[MASTER], xlStatus );
  341.   DEBUG(DEBUG_ADV, tmp);
  343.   // ---------------------------------------
  344.   // Setup the Master DLC's
  345.   // ---------------------------------------
  347.   unsigned char DLC[64];
  349.   // set the DLC for all ID's to 8
  350.   for (int i=0;i<64;i++) DLC[i] = 8;
  352.   xlStatus = xlLinSetDLC(m_xlPortHandle, m_xlChannelMask[MASTER], DLC);
  354.   // ---------------------------------------
  355.   // Activate the Master Channel
  356.   // ---------------------------------------
  358.   xlStatus = xlActivateChannel(m_xlPortHandle, m_xlChannelMask[MASTER], XL_BUS_TYPE_LIN, XL_ACTIVATE_RESET_CLOCK);
  359.   sprintf(tmp, "Activate Channel, CM: '0x%I64x', status: %d", m_xlChannelMask[MASTER], xlStatus);
  360.   DEBUG(DEBUG_ADV, tmp);
  362.   if (xlStatus != XL_SUCCESS) return xlStatus;
  363.   
  364.   xlStatus = xlFlushReceiveQueue(m_xlPortHandle);
  365.   sprintf(tmp, "FlushReceiveQueue stat: %d", xlStatus);
  366.   DEBUG(DEBUG_ADV, tmp);
  368.   return xlStatus;
  369. }
  372. ////////////////////////////////////////////////////////////////////////////
  374. //! linInitSlave
  376. //! initialize the LIN slave, define the slave (id, dlc, data), opens the 
  377. //! message filter and activate the LIN channel (-> bus on).
  378. //!
  379. //////////////////////////////////////////////////////////////////////////// 
  381. XLstatus CLINFunctions::linInitSlave(int linID)
  382. {
  383.   XLstatus        xlStatus = XL_ERROR;
  384.   char            tmp[100];
  385.  
  386.   // ---------------------------------------
  387.   // Setup the channel as a SLAVE
  388.   // ---------------------------------------
  390.   XLlinStatPar     xlStatPar;
  392.   xlStatPar.LINMode    = XL_LIN_SLAVE;
  393.   xlStatPar.baudrate   = 9600;                 // set the baudrate to 9k6
  394.   xlStatPar.LINVersion = XL_LIN_VERSION_1_3;   // use LIN 1.3
  396.   xlStatus = xlLinSetChannelParams(m_xlPortHandle, m_xlChannelMask[SLAVE], xlStatPar);
  398.   sprintf(tmp, "Init Slave PH: '%d', CM: '0x%I64x', status: %d", m_xlPortHandle, m_xlChannelMask[SLAVE], xlStatus );
  399.   DEBUG(DEBUG_ADV, tmp);
  401.   // ---------------------------------------
  402.   // Setup the SLAVE 
  403.   // ---------------------------------------
  405.   unsigned char            data[8];
  406.   unsigned char            id  = linID;
  407.   unsigned char            dlc = 8;
  409.   data[0] = 0x00;
  410.   data[1] = 0x00;
  411.   data[2] = 0x00;
  412.   data[3] = 0x00;
  413.   data[4] = 0x00;
  414.   data[5] = 0x00;
  415.   data[6] = 0x00;
  416.   data[7] = 0x00;
  418.   xlStatus = xlLinSetSlave(m_xlPortHandle, m_xlChannelMask[SLAVE], id, data, dlc, XL_LIN_CALC_CHECKSUM);
  419.   sprintf(tmp, "Set Slave ID CM: '0x%I64x', status: %d", m_xlChannelMask[SLAVE], xlStatus);
  420.   DEBUG(DEBUG_ADV, tmp);
  422.   // ---------------------------------------
  423.   // Activate the Slave Channel
  424.   // ---------------------------------------
  426.   xlStatus = xlActivateChannel(m_xlPortHandle, m_xlChannelMask[SLAVE], XL_BUS_TYPE_LIN, XL_ACTIVATE_RESET_CLOCK);
  427.   sprintf(tmp, "Activate Channel CM: '0x%I64x', status: %d", m_xlChannelMask[SLAVE], xlStatus);
  428.   DEBUG(DEBUG_ADV, tmp);
  430.   if (xlStatus != XL_SUCCESS) return xlStatus;
  431.   
  432.   xlStatus = xlFlushReceiveQueue(m_xlPortHandle);
  433.   sprintf(tmp, "FlushReceiveQueue stat: %d", xlStatus);
  434.   DEBUG(DEBUG_ADV, tmp);
  436.   return xlStatus;
  437. }
  439. ////////////////////////////////////////////////////////////////////////////
  441. //! linSetSlave
  443. //! change the slave
  444. //!
  445. //////////////////////////////////////////////////////////////////////////// 
  447. XLstatus CLINFunctions::linSetSlave(byte databyte)
  448. {
  449.   XLstatus        xlStatus = XL_ERROR;
  450.   char            tmp[100];
  452.   unsigned char            data[8];
  453.   unsigned char            id  = 0x04;
  454.   unsigned char            dlc = 8;
  456.   data[0] = databyte;
  457.   data[1] = 0x00;
  458.   data[2] = 0x00;
  459.   data[3] = 0x00;
  460.   data[4] = 0x00;
  461.   data[5] = 0x00;
  462.   data[6] = 0x00;
  463.   data[7] = 0x00;
  465.   xlStatus = xlLinSetSlave(m_xlPortHandle, m_xlChannelMask[SLAVE], id, data, dlc, XL_LIN_CALC_CHECKSUM);
  466.   sprintf(tmp, "Set Slave ID CM: '0x%I64x', status: %d", m_xlChannelMask[SLAVE], xlStatus);
  467.   DEBUG(DEBUG_ADV, tmp);
  469.   return xlStatus;
  470. }
  472. ///////////////////////////////////////////////////////////////////////////
  474. //! RxThread
  476. //! thread to readout the message queue and parse the incoming messages
  477. //!
  478. ////////////////////////////////////////////////////////////////////////////
  480. DWORD WINAPI RxThread(LPVOID par) 
  481. {
  483.   XLstatus        xlStatus;
  484.   
  485.   //char            tmp[100];
  486.   unsigned int    msgsrx = RECEIVE_EVENT_SIZE;
  487.   XLevent         xlEvent; 
  488.   char            tmp[100];
  489.   CString         str;
  490.   
  491.   g_bThreadRun = TRUE;
  493.   TStruct *g_th;
  495.   g_th = (TStruct*) par;  
  497.   sprintf(tmp, "thread: SetNotification '%d'", g_th->hMsgEvent);
  498.   DEBUG(DEBUG_ADV, tmp);
  500.   while (g_bThreadRun) { 
  501.    
  502.     WaitForSingleObject(g_th->hMsgEvent,10);
  504.     xlStatus = XL_SUCCESS;
  505.     
  506.    
  507.     while (!xlStatus) {
  508.       
  509.       
  510.       msgsrx = RECEIVE_EVENT_SIZE;
  511.       xlStatus = xlReceive(g_th->xlPortHandle, &msgsrx, &xlEvent);
  512.       
  513.       if ( xlStatus!=XL_ERR_QUEUE_IS_EMPTY ) {
  514.           
  515.         //sprintf(tmp, "thread: ReceiveEx tag: '%d'", vEvent2.tag);
  516.         //DEBUG(DEBUG_ADV, tmp);
  518.         switch (xlEvent.tag) {
  520.         // CAN events
  521.         case XL_SYNC_PULSE:
  522.             sprintf(tmp, "SYNC_PULSE: on Ch: '%d'", xlEvent.chanIndex);
  523.             DEBUG(DEBUG_ADV, tmp); 
  524.             g_th->pListRX->InsertString(-1,tmp);
  525.             break;
  527.         case XL_TRANSCEIVER:
  528.             sprintf(tmp, "TRANSCEIVER: on Ch: '%d'", xlEvent.chanIndex);
  529.             DEBUG(DEBUG_ADV, tmp); 
  530.             g_th->pListRX->InsertString(-1,tmp);
  531.             break;
  533.         // LIN events
  534.         
  535.           case XL_LIN_NOANS:
  536.             sprintf(tmp, "LIN NOANS ID: '0x%x' on Ch: '%d', time: %I64u", xlEvent.tagData.linMsgApi.linNoAns.id, xlEvent.chanIndex, xlEvent.timeStamp);
  537.             DEBUG(DEBUG_ADV, tmp); 
  538.             g_th->pListRX->InsertString(-1,tmp);
  539.             break;
  541.           case XL_LIN_MSG: {
  542.             CString         str1, sData;
  543.             str = "RX: ";
  544.             if (xlEvent.tagData.linMsgApi.linMsg.flags & XL_LIN_MSGFLAG_TX) str = "TX: ";
  546.             str1="";
  547.             for (int i=0; i<xlEvent.tagData.linMsgApi.linMsg.dlc;i++) {
  548.               str1.Format(_T("%02x"),xlEvent.tagData.linMsgApi.linMsg.data[i]);
  549.               sData = sData + str1;
  550.             }
  551.             
  552.             sprintf(tmp, "ID: 0x%02x, dlc: '%d', Data: 0x%s, time: %I64u, Ch: '%d'", xlEvent.tagData.linMsgApi.linMsg.id, xlEvent.tagData.linMsgApi.linMsg.dlc, sData, xlEvent.timeStamp, xlEvent.chanIndex);
  553.             DEBUG(DEBUG_ADV, tmp); 
  554.             g_th->pListRX->InsertString(-1, str + tmp);
  555.             break;
  556.           }
  558.           case XL_LIN_SLEEP:
  559.             sprintf(tmp, "LIN SLEEP flag: 0x%x, time: %I64u, Ch: '%d'", xlEvent.tagData.linMsgApi.linSleep.flag, xlEvent.timeStamp, xlEvent.chanIndex);
  560.             DEBUG(DEBUG_ADV, tmp); 
  561.             g_th->pListRX->InsertString(-1,tmp);
  562.             break;
  564.           case XL_LIN_ERRMSG:
  565.             sprintf(tmp, "LIN ERROR, Ch: '%d'", xlEvent.chanIndex);
  566.             DEBUG(DEBUG_ADV, tmp); 
  567.             g_th->pListRX->InsertString(-1,tmp);
  568.             break;
  570.           case XL_LIN_SYNCERR:
  571.             sprintf(tmp, "LIN SYNCERR on Ch: '%d'", xlEvent.chanIndex);
  572.             DEBUG(DEBUG_ADV, tmp); 
  573.             g_th->pListRX->InsertString(-1,tmp);
  574.             break;
  576.           case XL_LIN_WAKEUP:
  577.             sprintf(tmp, "LIN WAKEUP flags: 0x%x on Ch: '%d'", xlEvent.tagData.linMsgApi.linWakeUp.flag, xlEvent.chanIndex);
  578.             DEBUG(DEBUG_ADV, tmp); 
  579.             g_th->pListRX->InsertString(-1,tmp);
  580.             break;
  581.          }
  582.         ResetEvent(g_th->hMsgEvent);
  584.         //int nCount = pmyListBox->GetCount();
  585.         //if (nCount > 0)
  586.         g_th->pListRX->SetCurSel(g_th->pListRX->GetCount()-1);
  587.         g_th->pStatusBox->SetCurSel(g_th->pStatusBox->GetCount()-1);
  589.       }  
  590.     }
  591.           
  592.   }
  593.   return NO_ERROR; 
  594. }