AnaCanScan.cpp

Go to the documentation of this file.

#include "AnaCanScan.h"

#include <time.h>
#include <string.h>
#include <map>
#include <LogIt.h>
#include <sstream>
#include <iostream>
#include <boost/thread/thread.hpp>

#include "CanModuleUtils.h"

#ifdef _WIN32

#define DLLEXPORTFLAG __declspec(dllexport)

#else

#include <sys/time.h>

#define DLLEXPORTFLAG  
#define WINAPI  

#endif


using namespace CanModule;
using namespace std;

boost::mutex anagateReconnectMutex;

/* static */ bool AnaCanScan::s_isCanHandleInUseArray[256];
/* static */ AnaInt32 AnaCanScan::s_canHandleArray[256];
/* static */ Log::LogComponentHandle AnaCanScan::st_logItHandleAnagate = 0;
/* static */ std::map<string,bool> AnaCanScan::reconnectInProgress_map;

#define MLOGANA(LEVEL,THIS) LOG(Log::LEVEL, AnaCanScan::st_logItHandleAnagate) << __FUNCTION__ << " " << " anagate bus= " << THIS->getBusName() << " "

std::map<AnaInt32, AnaCanScan*> g_AnaCanScanPointerMap;

AnaCanScan::AnaCanScan():
                                m_canPortNumber(0),
                                m_canIPAddress( (char *) string("192.168.1.2").c_str()),
                                m_baudRate(0),
                                m_idCanScanThread(0),
                                m_canCloseDevice(false),
                                m_busName(""),
                                m_busParameters(""),
                                m_UcanHandle(0),
                                m_timeout ( 12000 )
{
        m_statistics.beginNewRun();
}

AnaCanScan::~AnaCanScan()
{
        stopBus();
}

void AnaCanScan::stopBus ()
{
        MLOGANA(TRC,this) << __FUNCTION__ << " m_busName= " <<  m_busName << " m_canPortNumber= " << m_canPortNumber;
        CANSetCallback(m_UcanHandle, 0);
        CANCloseDevice(m_UcanHandle);

//      setCanHandleInUse(m_canPortNumber,false);
        eraseReceptionHandlerFromMap( m_UcanHandle );

#ifdef _WIN32
#else
        MLOGANA(TRC, this ) << " imposing a delay of 7 seconds before continuing";
        boost::this_thread::sleep_for(boost::chrono::milliseconds( 7000 ));
#endif
        MLOGANA(TRC,this) << " finished";
}


/* static */ void AnaCanScan::setIpReconnectInProgress( string ip, bool flag ){
        // only called inside the locked mutex
        std::map<string,bool>::iterator it = AnaCanScan::reconnectInProgress_map.find( ip );

        if ( flag ){
                // mark as in progress if not yet exists/marked
                if ( it == AnaCanScan::reconnectInProgress_map.end() ) {
                        AnaCanScan::reconnectInProgress_map.insert ( std::pair<string,bool>( ip, true ) );
                }
        } else {
                // erase existing if still exists/marked
                if ( it != AnaCanScan::reconnectInProgress_map.end() ) {
                        AnaCanScan::reconnectInProgress_map.erase( it );
                }
        }
}

/* static */ bool AnaCanScan::isIpReconnectInProgress( string ip ){
        // only called inside the locked mutex
        std::map<string,bool>::iterator it = AnaCanScan::reconnectInProgress_map.find( ip );
        if ( it == AnaCanScan::reconnectInProgress_map.end() )
                return( false );
        else
                return( true );
}


extern "C" DLLEXPORTFLAG CCanAccess *getCanBusAccess()
{
        CCanAccess *canAccess = new AnaCanScan;
        return canAccess;
}


void WINAPI InternalCallback(AnaUInt32 nIdentifier, const char * pcBuffer, AnaInt32 nBufferLen, AnaInt32 nFlags, AnaInt32 hHandle, AnaInt32 nSeconds, AnaInt32 nMicroseconds)
{
        CanMessage canMsgCopy;
        if (nFlags == 2) return;
        canMsgCopy.c_id = nIdentifier;
        canMsgCopy.c_dlc = nBufferLen;
        canMsgCopy.c_ff = nFlags;
        for (int i = 0; i < nBufferLen; i++)
                canMsgCopy.c_data[i] = pcBuffer[i];

        canMsgCopy.c_time = convertTimepointToTimeval(currentTimeTimeval());

        //cout << __FILE__ << " " << __LINE__ << " " << __FUNCTION__
        //              << " anagate message reception hHandle= " << hHandle
        //              << " nIdentifier= " << nIdentifier
        //              << endl;
        MLOGANA(TRC, g_AnaCanScanPointerMap[hHandle] ) << "read(): " << AnaCanScan::canMessageToString(canMsgCopy);
        //MLOGANA(TRC, this) << __FUNCTION__ << " CanModule anagate " << AnaCanScan::canMessageToString(canMsgCopy);
        g_AnaCanScanPointerMap[hHandle]->callbackOnRecieve(canMsgCopy);
        g_AnaCanScanPointerMap[hHandle]->statisticsOnRecieve( nBufferLen );
}

/* static */ std::string AnaCanScan::canMessageToString(CanMessage &f)
{
        std::string result;
        result =  "[id=0x"+CanModuleUtils::toHexString(f.c_id, 3, '0')+" ";
        if (f.c_id & f.c_rtr)
                result += "RTR ";
        result+="dlc=" + CanModuleUtils::toString(int(f.c_dlc)) + " data=[";

        for (int i=0; i<f.c_dlc; i++)
                result+= CanModuleUtils::toHexString((unsigned int)f.c_data[i], 2, '0')+" ";
        result += "]]";

        return result;
}

void AnaCanScan::statisticsOnRecieve(int bytes)
{
        m_statistics.onReceive( bytes );
}

void AnaCanScan::callbackOnRecieve(CanMessage& msg)
{
        canMessageCame( msg );
}

bool AnaCanScan::createBus(const string name,const string parameters)
{       
        m_busName = name;
        m_busParameters = parameters;

        // calling base class to get the instance from there
        Log::LogComponentHandle myHandle;
        LogItInstance* logItInstance = CCanAccess::getLogItInstance(); // actually calling instance method, not class
        // std::cout << __FILE__ << " " << __LINE__ << " " << __FUNCTION__ << " ptr= 0x" << logItInstance << std::endl;

        // register anagate component for logging
        if ( !LogItInstance::setInstance(logItInstance))
                std::cout << __FILE__ << " " << __LINE__ << " " << __FUNCTION__
                << " could not set LogIt instance" << std::endl;


        if (!logItInstance->getComponentHandle(CanModule::LogItComponentName, myHandle))
                std::cout << __FILE__ << " " << __LINE__ << " " << __FUNCTION__
                << " could not get LogIt component handle for " << LogItComponentName << std::endl;

        //LOG(Log::TRC, myHandle) << __FUNCTION__ << " " __FILE__ << " " << __LINE__;
        AnaCanScan::st_logItHandleAnagate = myHandle;
        int returnCode = configureCanBoard(name, parameters);
        if ( returnCode < 0 ) {
                return false;
        }
        MLOGANA(DBG,this) << " OK, Bus created with name= " << name << " parameters= " << parameters;
        return true;
}


int AnaCanScan::configureCanBoard(const string name,const string parameters)
{
        MLOGANA(DBG, this) << "(user supplied) name= " << name << " parameters= " << parameters;
        vector<string> stringVector;
        stringVector = parseNameAndParameters(name, parameters);

        // we should decode 3 elements from this:0="an" for anagate library, 1=can port, 2=ip number
        // like  "an:0:128.141.159.194"
        if ( stringVector.size() != 3 ){
                MLOGANA(ERR, this) << " need exactly 3 elements delimited by \":\" like \"an:0:128.141.159.194\", got "
                                << stringVector.size();
                for ( unsigned i = 0; i < stringVector.size(); i++ ){
                        MLOGANA(ERR, this) << " stringVector[" << i << "]= " << stringVector[ i ];
                }
                return(-1);
        } else {
                for ( unsigned i = 0; i < stringVector.size(); i++ ){
                        MLOGANA(TRC, this) << "(cleaned up) stringVector[" << i << "]= " << stringVector[ i ];
                }
                m_canPortNumber = atoi(stringVector[1].c_str());
                m_canIPAddress = (char *) stringVector[2].c_str();
        }
        MLOGANA(TRC, this) << "(cleaned up) canPortNumber= " << m_canPortNumber << " ip= " << m_canIPAddress;

        // handle up to 5 parameter, assume defaults if needed
        m_baudRate = 125000L;

        if (strcmp(parameters.c_str(), "Unspecified") != 0) {

                MLOGANA(TRC, this) << "m_CanParameters.m_iNumberOfDetectedParameters" << m_CanParameters.m_iNumberOfDetectedParameters;

                if ( m_CanParameters.m_iNumberOfDetectedParameters >= 1 )       {
                        m_baudRate = m_CanParameters.m_lBaudRate;

                        MLOGANA(TRC, this) << "m_lBaudRate= " << m_CanParameters.m_lBaudRate;
                        MLOGANA(TRC, this) << "m_iOperationMode= " << m_CanParameters.m_iOperationMode;
                        MLOGANA(TRC, this) << "m_iTermination= " << m_CanParameters.m_iTermination;
                        MLOGANA(TRC, this) << "m_iHighSpeed= " << m_CanParameters.m_iHighSpeed;
                        MLOGANA(TRC, this) << "m_iTimeStamp= " << m_CanParameters.m_iTimeStamp;

                        // any other parameters are already set, either to 0 by init,
                        // or by decoding. They are always used.
                } else {
                        MLOGANA(ERR, this) << "Error while parsing parameters: this syntax is incorrect: [" << parameters << "]";
                        MLOGANA(ERR, this) << "you need up to 5 numbers separated by whitespaces, i.e. \"125000 0 0 0 0\" \"p0 p1 p2 p3 p4\"";
                        MLOGANA(ERR, this) << "  p0 = baud rate, 125000 or whatever the module supports";
                        MLOGANA(ERR, this) << "  p1 = operation mode";
                        MLOGANA(ERR, this) << "  p2 = termination";
                        MLOGANA(ERR, this) << "  p3 = high speed";
                        MLOGANA(ERR, this) << "  p4 = time stamp";
                        return -1;
                }
        } else  {
                MLOGANA(INF, this) << "Unspecified parameters, default values will be used.";
        }
        return openCanPort();
}

int AnaCanScan::openCanPort()
{
        AnaInt32 anaCallReturn;
        AnaInt32 canModuleHandle;

        // check if USB-CANmodul already is initialized
        //if (isCanHandleInUse(m_canPortNumber)) {
        //      //if it is, we get the handle
        //      canModuleHandle = getCanHandleFromPort(m_canPortNumber);
        //} else {
                //Otherwise we create it.
                MLOGANA(DBG, this) << "Will call CANOpenDevice with parameters m_canHandleNumber:[" << m_canPortNumber << "], m_canIPAddress:[" << m_canIPAddress << "]";
                anaCallReturn = CANOpenDevice(&canModuleHandle, FALSE, TRUE, m_canPortNumber, m_canIPAddress.c_str(), m_timeout);
                if (anaCallReturn != 0) {
                        // fill out initialisation struct
                        MLOGANA(ERR,this) << "Error in CANOpenDevice, return code = [" << anaCallReturn << "]";
                        return -1;
                }
//      }

//      setCanHandleInUse(m_canPortNumber,true);

        // initialize CAN interface
        MLOGANA(TRC,this) << "calling CANSetGlobals with m_lBaudRate= "
                        << m_CanParameters.m_lBaudRate
                        << " m_iOperationMode= " << m_CanParameters.m_iOperationMode
                        << " m_iTermination= " << m_CanParameters.m_iTermination
                        << " m_iHighSpeed= " << m_CanParameters.m_iHighSpeed
                        << " m_iTimeStamp= " << m_CanParameters.m_iTimeStamp;

        anaCallReturn = CANSetGlobals(canModuleHandle, m_CanParameters.m_lBaudRate, m_CanParameters.m_iOperationMode,
                        m_CanParameters.m_iTermination, m_CanParameters.m_iHighSpeed, m_CanParameters.m_iTimeStamp);
        switch ( anaCallReturn ){
        case 0:{ break; }
        case 0x30000: {
                MLOGANA(ERR,this) << "Connection to TCP/IP partner can't be established or is disconnected. Lost TCP/IP: 0x" << hex << anaCallReturn << dec;
                return -1;
        }
        case 0x40000: {
                MLOGANA(ERR,this) << "No  answer  was  received  from   TCP/IP partner within the defined timeout. Lost TCP/IP: 0x" << hex << anaCallReturn << dec;
                return -1;
        }
        case 0x900000: {
                MLOGANA(ERR,this) << "Invalid device handle. Lost TCP/IP: 0x" << hex << anaCallReturn << dec;
                return -1;
        }
        default : {
                MLOGANA(ERR,this) << "Other Error in CANSetGlobals: 0x" << hex << anaCallReturn << dec;
                return -1;
        }
        }
        // set handler for managing incoming messages
        anaCallReturn = CANSetCallbackEx(canModuleHandle, InternalCallback);
        if (anaCallReturn != 0) {
                MLOGANA(ERR,this) << "Error in CANSetCallbackEx, return code = [" << anaCallReturn << "]";
                return -1;
        } else {
                MLOGANA(TRC,this) << "OK CANSetCallbackEx, return code = [" << anaCallReturn << "]";
        }

//      setCanHandleOfPort(m_canPortNumber, canModuleHandle);
        g_AnaCanScanPointerMap[canModuleHandle] = this;

        // We associate in the global map the handle with the instance of the AnaCanScan object,
        // so it can later be identified by the callback InternalCallback in a speedy way
        m_UcanHandle = canModuleHandle;

        MLOGANA(TRC,this) << "handles: ";
        AnaCanScan::objectMapSize();
        return 0;
}

bool AnaCanScan::sendErrorCode(AnaInt32 status)
{
        char errorMessage[120];
        timeval ftTimeStamp; 
        if (status != 0) {
                auto now = std::chrono::system_clock::now();
                auto nMicrosecs =
                                duration_cast<std::chrono::microseconds>(
                                                now.time_since_epoch()
                                );
                ftTimeStamp.tv_sec = nMicrosecs.count() / 1000000L;
                ftTimeStamp.tv_usec = (nMicrosecs.count() % 1000000L) ;

                if (!errorCodeToString(status, errorMessage))
                        canMessageError(status, errorMessage, ftTimeStamp);
        }
        return true;
}

bool AnaCanScan::sendMessage(short cobID, unsigned char len, unsigned char *message, bool rtr)
{
        MLOGANA(DBG,this) << "Sending message: [" << ( message == 0  ? "" : (const char *) message) << "], cobID: [" << cobID << "], Message Length: [" << static_cast<int>(len) << "]";
        AnaInt32 anaCallReturn;
        unsigned char *messageToBeSent[8];
        AnaInt32 flags = 0x0;
        if (rtr) {
                flags = 2; // Bit 1: If set, the telegram is marked as remote frame.
        }
        int  messageLengthToBeProcessed;

        //If there is more than 8 characters to process, we process 8 of them in this iteration of the loop
        if (len > 8) {
                messageLengthToBeProcessed = 8;
                MLOGANA(DBG, this) << "The length is more than 8 bytes, ignoring overhead, no extended CAN msg yet " << len;
        } else {
                messageLengthToBeProcessed = len;
        }
        // MLOG(TRC, this) << "Going to memcopy " << messageToBeSent << ";" << message << ";" << messageLengthToBeProcessed;
        memcpy(messageToBeSent, message, messageLengthToBeProcessed);
        MLOGANA(TRC, this) << " m_canPortNumber= " << m_canPortNumber
                        << " cobID= " << cobID
                        << " length = " << messageLengthToBeProcessed
                        << " flags= " << flags << " m_UcanHandle= " << m_UcanHandle;
        anaCallReturn = CANWrite(m_UcanHandle, cobID, reinterpret_cast<char*>(messageToBeSent), messageLengthToBeProcessed, flags);
        if (anaCallReturn != 0) {
                MLOGANA(ERR, this) << "There was a problem when sending a message with CANWrite: 0x" << hex << anaCallReturn << dec;
                m_canCloseDevice = false;

                AnaInt32 anaCallReturn0 = AnaCanScan::reconnectAllPorts( m_canIPAddress );
                while ( anaCallReturn0 < 0 ){
                        MLOGANA(WRN, this) << "failed to reconnect all module CAN ports once, keep on trying to reconnect. ip= " << m_canIPAddress;
                        anaCallReturn0 = AnaCanScan::reconnectAllPorts( m_canIPAddress );
                }
                objectMapSize();
        } else {
                m_statistics.onTransmit(messageLengthToBeProcessed);
        }
        return sendErrorCode(anaCallReturn);
}

/* static */ void AnaCanScan::objectMapSize(){
        uint32_t size = g_AnaCanScanPointerMap.size();
        LOG(Log::TRC, AnaCanScan::st_logItHandleAnagate  ) << __FUNCTION__ << " RECEIVE obj. map size= " << size << " : ";
        for (std::map<AnaInt32, AnaCanScan*>::iterator it=g_AnaCanScanPointerMap.begin(); it!=g_AnaCanScanPointerMap.end(); it++){
                LOG(Log::TRC, AnaCanScan::st_logItHandleAnagate ) << __FUNCTION__ << " obj. map "
                                << " key= " << it->first
                                << " ip= " << it->second->ipAdress()
                                << " CAN port= " << it->second->canPortNumber()
                                << " handle= " << it->second->handle()
                                << " (used?= " << it->second->isCanHandleInUse(it->second->handle()) << ")"
                                << " ptr= 0x" << hex << (unsigned long) (it->second) << dec;

        }
}

/* static */ AnaInt32 AnaCanScan::reconnectAllPorts( string ip ){

        // protect against several calls on the same ip.
        // We need a mutex to force serialize this.
        {
                anagateReconnectMutex.lock();
                if ( AnaCanScan::isIpReconnectInProgress( ip ) ) {
                        LOG(Log::WRN, AnaCanScan::st_logItHandleAnagate ) << "reconnecting all ports for ip= " << ip
                                        << " is already in progress, skipping.";

                        int us = 10000000;
                        boost::this_thread::sleep(boost::posix_time::microseconds( us ));
                        anagateReconnectMutex.unlock();

                        return(1);
                }
                AnaCanScan::setIpReconnectInProgress( ip, true );
                LOG(Log::TRC, AnaCanScan::st_logItHandleAnagate ) << "reconnecting all ports for ip= " << ip
                                << " is now in progress.";
                anagateReconnectMutex.unlock();
        }

        int ret = 0;
        AnaInt32 anaRet = 0;

        // re-open the can port and get a new handle, but do NOT yet put the new object (this, again) into
        // the global map. Keep the reception disconnected still.
        int nbCANportsOnModule = 0;
        bool reconnectFailed = false;
        for (std::map<AnaInt32, AnaCanScan*>::iterator it=g_AnaCanScanPointerMap.begin(); it!=g_AnaCanScanPointerMap.end(); it++){
                if ( ip == it->second->ipAdress() ){
                        LOG(Log::TRC, AnaCanScan::st_logItHandleAnagate ) << __FUNCTION__
                                        << " key= " << it->first
                                        << " found ip= " << ip
                                        << " for CAN port= " << it->second->canPortNumber()
                                        << " reconnecting...";

                        ret = it->second->reconnect();
                        if ( ret ){
                                LOG(Log::WRN, AnaCanScan::st_logItHandleAnagate) << __FUNCTION__
                                                << " key= " << it->first
                                                << " found ip= " << ip
                                                << " for CAN port= " << it->second->canPortNumber()
                                                << " failed to reconnect";
                                reconnectFailed = true;
                        }
                        nbCANportsOnModule++;
                }
        }
        LOG(Log::TRC, AnaCanScan::st_logItHandleAnagate) << " CAN bridge at ip= " << ip << " uses  nbCANportsOnModule= " << nbCANportsOnModule;

        if ( reconnectFailed ) {
                LOG(Log::WRN, AnaCanScan::st_logItHandleAnagate ) << " Problem reconnecting CAN ports for ip= " << ip
                                << " last ret= " << ret << ". Just abandoning and trying again in 10 secs, module might not be ready yet.";
                int us = 10000000;
                boost::this_thread::sleep(boost::posix_time::microseconds( us ));

                AnaCanScan::setIpReconnectInProgress( ip, false );
                LOG(Log::TRC, AnaCanScan::st_logItHandleAnagate ) << "reconnecting all ports for ip= " << ip
                                << " cancel.";
                return(-1);
        }

        // register the new handler with the obj. map and connect the reception handler. Cleanup the stale handlers
        std::map<AnaInt32, AnaCanScan*> lmap = g_AnaCanScanPointerMap; // use a local copy of the map, in order
        // not to change the map we are iterating on

        LOG(Log::TRC, AnaCanScan::st_logItHandleAnagate) << __FUNCTION__ << " " __FILE__ << " " << __LINE__
                        << " receive handler map map before reconnect for ip= " << ip;
        AnaCanScan::objectMapSize();

        for (std::map<AnaInt32, AnaCanScan*>::iterator it=lmap.begin(); it!=lmap.end(); it++){
                if ( ip == it->second->ipAdress() ){
                        anaRet = it->second->connectReceptionHandler();
                        if ( anaRet != 0 ){
                                LOG(Log::ERR, AnaCanScan::st_logItHandleAnagate) << __FUNCTION__ << " " __FILE__ << " " << __LINE__
                                                << " failed to reconnect reception handler for ip= " << ip
                                                << " handle= " << it->second->handle()
                                                << " port= " << it->second->canPortNumber()
                                                << " anaRet= " << anaRet;
                        } else {
                                LOG(Log::TRC, AnaCanScan::st_logItHandleAnagate ) << __FUNCTION__ << " " __FILE__ << " " << __LINE__
                                                << " reconnect reception handler for ip= " << ip
                                                << " handle= " << it->second->handle()
                                                << " looking good= " << anaRet;
                        }

                        if ( it->first != it->second->handle()){
                                LOG(Log::TRC, AnaCanScan::st_logItHandleAnagate) << __FUNCTION__ << " " __FILE__ << " " << __LINE__
                                                << " erasing stale handler " << it->first
                                                << " for object handle= " << it->second->handle() << " from obj. map";
                                g_AnaCanScanPointerMap.erase( it->first );
                        }
                        AnaCanScan::setIpReconnectInProgress( ip, false ); // all done, may fail another time
                        LOG(Log::TRC, AnaCanScan::st_logItHandleAnagate ) << "reconnecting all ports for ip= " << ip
                                        << " is done and OK.";
                }
        }
        LOG(Log::TRC, AnaCanScan::st_logItHandleAnagate) << __FUNCTION__ << " " __FILE__ << " " << __LINE__
                        << " receive handler map after reconnect for ip= " << ip;
        AnaCanScan::objectMapSize();

        // be easy on the switch, can maybe suppress this later
        int us = 100000;
        boost::this_thread::sleep(boost::posix_time::microseconds( us ));
        return( anaRet );
}

AnaInt32 AnaCanScan::connectReceptionHandler(){
        AnaInt32 anaCallReturn;

        // this is needed otherwise the bridge hangs in a bad state
        anaCallReturn = CANSetGlobals(m_UcanHandle, m_CanParameters.m_lBaudRate, m_CanParameters.m_iOperationMode,
                        m_CanParameters.m_iTermination, m_CanParameters.m_iHighSpeed, m_CanParameters.m_iTimeStamp);
        switch ( anaCallReturn ){
        case 0:{ break; }
        case 0x30000: {
                MLOGANA(ERR,this) << "Connection to TCP/IP partner can't be established or is disconnected. Lost TCP/IP: 0x" << hex << anaCallReturn << dec;
                return -1;
        }
        case 0x40000: {
                MLOGANA(ERR,this) << "No  answer  was  received  from   TCP/IP partner within the defined timeout. Lost TCP/IP: 0x" << hex << anaCallReturn << dec;
                return -1;
        }
        case 0x900000: {
                MLOGANA(ERR,this) << "Invalid device handle. Lost TCP/IP: 0x" << hex << anaCallReturn << dec;
                return -1;
        }
        default : {
                MLOGANA(ERR,this) << "Other Error in CANSetGlobals: 0x" << hex << anaCallReturn << dec;
                return -1;
        }
        }

        MLOGANA(WRN,this) << "connecting RECEIVE canModuleHandle= " << m_UcanHandle
                        << " ip= " << m_canIPAddress;
        anaCallReturn = CANSetCallbackEx(m_UcanHandle, InternalCallback);
        if (anaCallReturn != 0) {
                MLOGANA(ERR,this) << "failed CANSetCallbackEx, return code = [" << anaCallReturn << "]"
                                << " canModuleHandle= " << m_UcanHandle
                                << " in a reconnect! Can't fix this, maybe hardware/firmware problem.";
                // that is very schlecht, need a good idea (~check keepalive and sending fake messages)
                // to detect and possibly recuperate from that. Does this case happen actually?
        }
        MLOGANA(DBG,this) << "adding RECEIVE handler, handle= " << m_UcanHandle
                        << " CAN port= " << m_canPortNumber
                        << " ip= " << m_canIPAddress << " to obj.map.";
        g_AnaCanScanPointerMap[ m_UcanHandle ] = this;
        setCanHandleInUse( m_UcanHandle, true );

        MLOGANA(DBG,this) << "RECEIVE handler looks good, handle= " << m_UcanHandle
                        << " CAN port= " << m_canPortNumber
                        << " ip= " << m_canIPAddress << " Congratulations.";
        return( anaCallReturn );
}


void AnaCanScan::eraseReceptionHandlerFromMap( AnaInt32 h ){
        std::map<AnaInt32, AnaCanScan *>::iterator it = g_AnaCanScanPointerMap.find( h );
        if (it != g_AnaCanScanPointerMap.end()) {
                g_AnaCanScanPointerMap.erase ( it );
                m_busName = "nobus";
        } else {
                MLOGANA(DBG,this) << " handler " << h << " not found in map, not erased";
        }
}

int AnaCanScan::reconnect(){
        AnaInt32 anaCallReturn;
        AnaInt32 canModuleHandle;
        // we are not too fast. sleep to wait for network and don't hammer the switch
        int us = 100000;

        MLOGANA(WRN, this) << "try to reconnect ip= " << m_canIPAddress
                        << " m_canPortNumber= " << m_canPortNumber
                        << " m_UcanHandle= " << m_UcanHandle;

        int state = CANDeviceConnectState( m_UcanHandle );
        MLOGANA(TRC, this) << "CANDeviceConnectState: device connect state= 0x" << hex << state << dec;
        switch ( state ){
        case 2: {
                MLOGANA(INF,this) << "device is in state CONNECTING, don't try to reconnect for now, skip.";
                break;
        }

        case 3: {
                MLOGANA(INF,this) << "device is in state CONNECTED, don't try to reconnect, just skip.";
                break;
        }
        default:
        case 1:
        case 4:
        case 5:{
                if ( !m_canCloseDevice ) {
                        anaCallReturn = CANCloseDevice( m_UcanHandle );
                        MLOGANA(WRN, this) << "closed device m_UcanHandle= " << m_UcanHandle
                                        << " anaCallReturn= 0x" << hex << anaCallReturn << dec;
                        if ( anaCallReturn != 0 ) {
                                MLOGANA(WRN, this) << "could not close device m_UcanHandle= " << m_UcanHandle
                                                << " anaCallReturn= 0x" << hex << anaCallReturn << dec;
                                // return(-3);
                        }
                        m_canCloseDevice = true;
                        MLOGANA(TRC, this) << "device is closed. stale handle= " << m_UcanHandle;
                } else {
                        MLOGANA(WRN, this) << "device is already closed, try reopen. stale handle= " << m_UcanHandle;
                }
                setCanHandleInUse( m_UcanHandle, false );

                MLOGANA(TRC,this) << "try CANOpenDevice m_canPortNumber= " << m_canPortNumber
                                << " m_UcanHandle= " << m_UcanHandle
                                << " ip= " << m_canIPAddress << " timeout= " << m_timeout;
                anaCallReturn = CANOpenDevice(&canModuleHandle, FALSE, TRUE, m_canPortNumber, m_canIPAddress.c_str(), m_timeout);
                if (anaCallReturn != 0) {
                        MLOGANA(ERR,this) << "CANOpenDevice failed: 0x" << hex << anaCallReturn << dec;
                        m_canCloseDevice = false;
                        return(-1);
                }
                MLOGANA(DBG,this) << "CANOpenDevice m_canPortNumber= " << m_canPortNumber
                                << " canModuleHandle= " << canModuleHandle
                                << " ip= " << m_canIPAddress << " timeout= " << m_timeout << " reconnect for SEND looks good";

                setCanHandleInUse( m_canPortNumber, true );
                setCanHandleOfPort( m_canPortNumber, canModuleHandle );

                m_UcanHandle = canModuleHandle;
                m_canCloseDevice = false;
                break;
        }
        }
        boost::this_thread::sleep(boost::posix_time::microseconds( us ));
        return( 0 ); // OK
}

void AnaCanScan::setConnectWaitTime( int timeout_ms ){
        m_timeout = timeout_ms;
        MLOGANA(WRN,this) << "reconnect CANOpenDevice m_UcanHandle= " << m_UcanHandle << " to apply new timeout= " << m_timeout;
        reconnect();
}

void AnaCanScan::startAlive( int aliveTime_sec ){
        AnaInt32 anaCallReturn = CANStartAlive( m_UcanHandle, aliveTime_sec );
        if ( anaCallReturn != 0 ){
                MLOGANA(ERR,this) << "could not start alive mechanism, error=  0x" << hex << anaCallReturn << dec;
        } else {
                MLOGANA(DBG,this) << "started alive mechanism on handle= " << m_UcanHandle;
        }
}

bool AnaCanScan::sendMessage(CanMessage *canm)
{
        return sendMessage(short(canm->c_id), canm->c_dlc, canm->c_data, canm->c_rtr);
}

bool AnaCanScan::sendRemoteRequest(short cobID)
{
        AnaInt32 anaCallReturn;
        AnaInt32 flags = 2;// Bit 1: If set, the telegram is marked as remote frame.

        anaCallReturn = CANWrite(m_UcanHandle,cobID,NULL, 0, flags);
        if (anaCallReturn != 0) {
                MLOGANA(ERR,this) << "There was a problem when sending a message with CANWrite";
        }
        return sendErrorCode(anaCallReturn);
}

bool AnaCanScan::errorCodeToString(long error, char message[])
{
        char tmp[300] = "Error";
        // canGetErrorText((canStatus)error, tmp, sizeof(tmp));
        // *message = new char[strlen(tmp)+1];
        //    message[0] = 0;
        strcpy(message,tmp);
        return true;
}

void AnaCanScan::getStatistics( CanStatistics & result )
{
        m_statistics.computeDerived (m_baudRate);
        result = m_statistics;  // copy whole structure
        m_statistics.beginNewRun();
}