CanFestival: drivers/can_peak_win32/can_peak

00001 /*
-00002 This file is part of CanFestival, a library implementing CanOpen Stack. 
-00003 
-00004 Copyright (C): Edouard TISSERANT and Francis DUPIN
-00005 
-00006 See COPYING file for copyrights details.
-00007 
-00008 This library is free software; you can redistribute it and/or
-00009 modify it under the terms of the GNU Lesser General Public
-00010 License as published by the Free Software Foundation; either
-00011 version 2.1 of the License, or (at your option) any later version.
-00012 
-00013 This library is distributed in the hope that it will be useful,
-00014 but WITHOUT ANY WARRANTY; without even the implied warranty of
-00015 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-00016 Lesser General Public License for more details.
-00017 
-00018 You should have received a copy of the GNU Lesser General Public
-00019 License along with this library; if not, write to the Free Software
-00020 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-00021 */
-00022 
-00023 #if defined(WIN32) && !defined(__CYGWIN__)
-00024 #define usleep(micro) Sleep(micro%1000 ? (micro/1000) + 1 : (micro/1000))
-00025 #else
-00026 #include <stdio.h>
-00027 #include <string.h>
-00028 #include <errno.h>
-00029 #include <fcntl.h>
-00030 #endif
-00031 
-00032 #include "cancfg.h"
-00033 #include "can_driver.h"
-00034 
-00035 #ifndef extra_PCAN_init_params
-00036         #define extra_PCAN_init_params 
-00037 #else
-00038         #define extra_PCAN_init_params\
-00039                 ,getenv("PCANHwType") ? strtol(getenv("PCANHwType"),NULL,0):0\
-00040                 ,getenv("PCANIO_Port") ? strtol(getenv("PCANIO_Port"),NULL,0):0\
-00041                 ,getenv("PCANInterupt") ? strtol(getenv("PCANInterupt"),NULL,0):0
-00042 #endif
-00043 
-00044 static s_BOARD *first_board = NULL;
-00045 #ifdef PCAN2_HEADER_
-00046 static s_BOARD *second_board = NULL;
-00047 #endif
-00048 
-00049 //pthread_mutex_t PeakCan_mutex = PTHREAD_MUTEX_INITIALIZER;
-00050 
-00051 // Define for rtr CAN message
-00052 #define CAN_INIT_TYPE_ST_RTR MSGTYPE_STANDARD | MSGTYPE_RTR
-00053 
-00054 /***************************************************************************/
-00055 int TranslateBaudeRate(char* optarg){
-00056         if(!strcmp( optarg, "1M")) return CAN_BAUD_1M;
-00057         if(!strcmp( optarg, "500K")) return CAN_BAUD_500K;
-00058         if(!strcmp( optarg, "250K")) return CAN_BAUD_250K;
-00059         if(!strcmp( optarg, "125K")) return CAN_BAUD_125K;
-00060         if(!strcmp( optarg, "100K")) return CAN_BAUD_100K;
-00061         if(!strcmp( optarg, "50K")) return CAN_BAUD_50K;
-00062         if(!strcmp( optarg, "20K")) return CAN_BAUD_20K;
-00063         if(!strcmp( optarg, "10K")) return CAN_BAUD_10K;
-00064         if(!strcmp( optarg, "5K")) return CAN_BAUD_5K;
-00065         if(!strcmp( optarg, "none")) return 0;
-00066         return 0x0000;
-00067 }
-00068 
-00069 void
-00070 canInit (s_BOARD *board)
-00071 {
-00072         int baudrate;
-00073         
-00074 #ifdef PCAN2_HEADER_
-00075         // if not the first handler
-00076         if(second_board == (s_BOARD *)board)
-00077                 if(baudrate = TranslateBaudeRate(board->baudrate))
-00078                         CAN2_Init (baudrate,
-00079                           CAN_INIT_TYPE_ST extra_PCAN_init_params);
-00080 #endif
-00081         if(first_board == (s_BOARD *)board)
-00082                 if(baudrate = TranslateBaudeRate(board->baudrate))
-00083                         CAN_Init (baudrate,
-00084                           CAN_INIT_TYPE_ST extra_PCAN_init_params);
-00085 }
-00086 
-00087 /*********functions which permit to communicate with the board****************/
-00088 UNS8
-00089 canReceive_driver (CAN_HANDLE fd0, Message * m)
-00090 {
-00091         UNS8 data;
-00092         TPCANMsg peakMsg;
-00093 
-00094         DWORD Res;
-00095 
-00096         do{
-00097                 // We read the queue looking for messages.
-00098                 // 
-00099                 //pthread_mutex_lock (&PeakCan_mutex);
-00100 #ifdef PCAN2_HEADER_
-00101                 // if not the first handler
-00102                 if(second_board == (s_BOARD *)fd0)
-00103                         Res = CAN2_Read (&peakMsg);
-00104                 else
-00105 #endif
-00106                 if(first_board == (s_BOARD *)fd0)
-00107                         Res = CAN_Read (&peakMsg);
-00108                 else
-00109                         Res = CAN_ERR_BUSOFF;
-00110         
-00111                 // A message was received
-00112                 // We process the message(s)
-00113                 // 
-00114                 if (Res == CAN_ERR_OK)
-00115                 {
-00116                         // if something different that 11bit or rtr... problem
-00117                         if (peakMsg.MSGTYPE & ~(MSGTYPE_STANDARD | MSGTYPE_RTR))
-00118                         {
-00119                                 if (peakMsg.MSGTYPE == CAN_ERR_BUSOFF)
-00120                                 {
-00121                                         printf ("!!! Peak board read : re-init\n");
-00122                                         canInit((s_BOARD*) fd0);
-00123                                         usleep (10000);
-00124                                 }
-00125         
-00126                                 // If status, return status if 29bit, return overrun
-00127                                 //pthread_mutex_unlock (&PeakCan_mutex);
-00128                                 return peakMsg.MSGTYPE ==
-00129                                         MSGTYPE_STATUS ? peakMsg.DATA[2] : CAN_ERR_OVERRUN;
-00130                         }
-00131                         m->cob_id.w = peakMsg.ID;
-00132                         if (peakMsg.MSGTYPE == CAN_INIT_TYPE_ST)        /* bits of MSGTYPE_ */
-00133                                 m->rtr = 0;
-00134                         else
-00135                                 m->rtr = 1;
-00136                         m->len = peakMsg.LEN;   /* count of data bytes (0..8) */
-00137                         for (data = 0; data < peakMsg.LEN; data++)
-00138                                 m->data[data] = peakMsg.DATA[data];     /* data bytes, up to 8 */
-00139         
-00140                 }else{
-00141                 //pthread_mutex_unlock (&PeakCan_mutex);
-00142                 //if (Res != CAN_ERR_OK)
-00143                 //{
-00144                         if (!
-00145                                 (Res & CAN_ERR_QRCVEMPTY || Res & CAN_ERR_BUSLIGHT
-00146                                  || Res & CAN_ERR_BUSHEAVY))
-00147                         {
-00148                                 printf ("canReceive returned error (%d)\n", Res);
-00149                                 return 1;
-00150                         }
-00151                         usleep (1000);          
-00152                 }
-00153         }while(Res != CAN_ERR_OK);
-00154         return 0;
-00155 }
-00156 
-00157 /***************************************************************************/
-00158 UNS8
-00159 canSend_driver (CAN_HANDLE fd0, Message * m)
-00160 {
-00161         UNS8 data;
-00162         TPCANMsg peakMsg;
-00163         peakMsg.ID = m->cob_id.w;       /* 11/29 bit code */
-00164         if (m->rtr == 0)
-00165                 peakMsg.MSGTYPE = CAN_INIT_TYPE_ST;     /* bits of MSGTYPE_ */
-00166         else
-00167         {
-00168                 peakMsg.MSGTYPE = CAN_INIT_TYPE_ST_RTR; /* bits of MSGTYPE_ */
-00169         }
-00170         peakMsg.LEN = m->len;
-00171         /* count of data bytes (0..8) */
-00172         for (data = 0; data < m->len; data++)
-00173                 peakMsg.DATA[data] = m->data[data];     /* data bytes, up to 8 */
-00174         do
-00175         {
-00176 #ifdef PCAN2_HEADER_
-00177                 // if not the first handler
-00178                 if(second_board == (s_BOARD *)fd0)
-00179                         errno = CAN2_Write (&peakMsg);
-00180                 else 
-00181 #endif
-00182                 if(first_board == (s_BOARD *)fd0)
-00183                         errno = CAN_Write (&peakMsg);
-00184                 else 
-00185                         goto fail;
-00186                 if (errno)
-00187                 {
-00188                         if (errno == CAN_ERR_BUSOFF)
-00189                         {
-00190                                 printf ("!!! Peak board write : re-init\n");
-00191                                 canInit((s_BOARD*)fd0);
-00192                                 usleep (10000);
-00193                         }
-00194                         usleep (1000);
-00195                 }
-00196         }
-00197         while (errno != CAN_ERR_OK);
-00198         return 0;
-00199 fail:
-00200         return 1;
-00201 }
-00202 
-00203 /***************************************************************************/
-00204 CAN_HANDLE
-00205 canOpen_driver (s_BOARD * board)
-00206 {
-00207 #ifdef PCAN2_HEADER_
-00208         if(first_board != NULL && second_board != NULL)
-00209 #else
-00210         if(first_board != NULL)
-00211 #endif
-00212         {
-00213                 fprintf (stderr, "Open failed.\n");
-00214                 fprintf (stderr,
-00215                                  "can_peak_win32.c: no more can port available with this pcan library\n");
-00216                 fprintf (stderr,
-00217                                  "can_peak_win32.c: please link another executable with another pcan lib\n");
-00218                 return NULL;
-00219         }
-00220 
-00221 #ifdef PCAN2_HEADER_
-00222         if(first_board == NULL)
-00223                 first_board = board;
-00224         else
-00225                 second_board = board; 
-00226 #else
-00227         first_board = board;
-00228 #endif
-00229 
-00230         canInit(board);
-00231         
-00232         return (CAN_HANDLE)board;
-00233 }
-00234 
-00235 /***************************************************************************/
-00236 int
-00237 canClose_driver (CAN_HANDLE fd0)
-00238 {
-00239 #ifdef PCAN2_HEADER_
-00240         // if not the first handler
-00241         if(second_board == (s_BOARD *)fd0)
-00242         {
-00243                 CAN2_Close ();
-00244                 second_board = (s_BOARD *)NULL;
-00245         }else   
-00246 #endif
-00247         if(first_board == (s_BOARD *)fd0)
-00248         {
-00249                 CAN_Close ();
-00250                 first_board = (s_BOARD *)NULL;
-00251         }
-00252         return 0;
-00253 }
-