myvtm/DevAdapter/keba/Gpio.keba.1.1/KEBA_DevCtrl.cpp

/**
@file
@brief		SIU设备接口实现文件
@author		chenjl
@version	1.0.0.0
@date		2016/05/10

- 2016/05/10 1.0.0.0 chenjl 初始文件
*/
//#include <fcntl.h>
//#include <stdio.h>
//#include <unistd.h>
//#include <errno.h>
//#include <sys/time.h>
//#include <sys/stat.h>
//#include <alsa/asoundlib.h>

#include "stdafx.h"
//#include "KEBA_DevCtrl.h"

#ifdef MY_CSINGLELOCK
//#include "csinglelock.h"
#endif
#ifndef DEVICE_SIMULATOR

#else
#include "SetupMutex.h"
#endif

//CKEBA_DevCtrl* g_pCKEBA_DevCtrl = NULL;
extern int retry_time;

CKEBA_DevCtrl::CKEBA_DevCtrl()
{
    CKEBA_DevCtrl_Common();
}

VOID CKEBA_DevCtrl::CKEBA_DevCtrl_Common()
{
#ifndef DEVICE_SIMULATOR
    outport_value = 0;
    inport_value = 0;
    inoutport_value = 0;
#else
    m_iFd = -1;
    memset(inBuffer, 0, INOUTBUFFERSIZE);
    memset(outBuffer, 0, INOUTBUFFERSIZE);
    memset(outWriteBuffer, 0, INOUTBUFFERSIZE / 2);
#endif
    m_bInitFinished = false;
    m_bConnected = false;
#ifdef MY_CSINGLELOCK
    pthread_mutexattr_t mtxAttr;
    INT s;
    s = pthread_mutexattr_init(&mtxAttr);
    s = pthread_mutexattr_settype(&mtxAttr, PTHREAD_MUTEX_RECURSIVE);
    s = pthread_mutex_init(&m_mtxHardware, &mtxAttr);
    s = pthread_mutex_init(&m_mtxStatus, &mtxAttr);
    s = pthread_mutex_init(&m_mtxFlashStatus, &mtxAttr);
    s = pthread_mutex_init(&m_mtxAudio, &mtxAttr);
    s = pthread_mutexattr_destroy(&mtxAttr);
#endif
    m_bFlashStop = true;
    //Q_UNUSED(s)
}
CKEBA_DevCtrl::~CKEBA_DevCtrl()
{
    if(m_bConnected)
    {
        CloseDevice();
#ifndef DEVICE_SIMULATOR
//        portio_close();
#else
        close(m_iFd);
#endif
    }
}

BOOL CKEBA_DevCtrl::InitDevice()
{
    BOOL iRet = FALSE;
    Init();
    if(m_bInitFinished)
    {
        iRet = TRUE;
    }
    return iRet;
}

/**
复位
该函数应立即返回相关信息
@return 操作结果
*/
BOOL CKEBA_DevCtrl::Reset()
{
#ifndef MY_CSINGLELOCK
    CSetupMutex lock(MUTEX_SIU_FLASHINFO);
#else
    CSingleLock lock(&m_mtxFlashStatus, true);
#endif
    return OutputSetForCloseAll();
}

BOOL CKEBA_DevCtrl::CloseDevice()
{
    if(!m_bInitFinished)
    {
        return TRUE;
    }
    OutputSetForCloseAll();

    if(m_bConnected)
    {
#ifndef DEVICE_SIMULATOR
        portio_close();
#else
        close(m_iFd);
        m_iFd = -1;
#endif
        m_bConnected = false;
    }

    m_bInitFinished = false;
    return TRUE;
}

BOOL CKEBA_DevCtrl::SetGuidLight(WORD iChannel[], bool bIsOn[], WORD wSize)
{
    USHORT usStatus = 0;
    int i = 0;
    BOOL h = FALSE;

#ifndef MY_CSINGLELOCK
    CSetupMutex lock(MUTEX_SIU_FLASHINFO);
#else
    CSingleLock lock(&m_mtxFlashStatus, true);
#endif

//    outport_value = 0;
    for (i = 0; i < wSize; i++)
    {
        usStatus = bIsOn[i] ? 1 : 0;
        h = ChannelWriteToBuffer(iChannel[i], usStatus);
        if(h != TRUE)
        {
            return FALSE;
        }
    }

#if (DEBUG & SUPER_DEBUG)
     printf(">>Enter mutex SetGuidLight\n");
#endif
            /** Driver function*/
    if(portio_out(outport_value) == -1)
    {
        //Log
        //Trace.TraceInFormat(TRM_OUTPUT, TRM_LV_ERROR, "portio_out(%d) error:%d", outport_value, -1);
#if (DEBUG & SUPER_DEBUG)
        printf("<<Leaver mutex SetGuidLight\n");
#endif
        return FALSE;
    }
#if (DEBUG & SUPER_DEBUG)
    printf("<<Leaver mutex SetGuidLight\n");
#endif

    return TRUE;
}

BOOL CKEBA_DevCtrl::getChannelStatus(BOOL bOut, WORD iChannel, WORD& wStatus)
{
    CSingleLock lock(&m_mtxHardware, true);
#if (DEBUG & SUPER_DEBUG)
    printf(">>Enter mutex InputChannel\n");
#endif
    UINT32 value = 0;
    //usleep(5000 * 1000);
    if (bOut)
    {
        UINT32 value = portio_inout();
        inoutport_value = value;
        //Log
        //Trace.TraceInFormat(TRM_INPUT, TRM_LV_COMMN, "portio_in:0x%x", inport_value);
    }
    else
    {
        UINT32 value = portio_in();
        inport_value = value;
        //Log
        //Trace.TraceInFormat(TRM_INPUT, TRM_LV_COMMN, "portio_in:0x%x", inport_value);
    }

    if(value == (UINT32)-1)
    {
        //Log
        //Trace.TraceInFormat(TRM_INPUT, TRM_LV_ERROR, "portio_in error:%d", value);
#if (DEBUG & SUPER_DEBUG)
        printf("<<Leave mutex InputChannel\n");
#endif
        return FALSE;
    }

    BOOL bRet = ChannelReadFromInBuffer(bOut, iChannel, wStatus);
    if (bRet == FALSE)
    {
        //Log
        return FALSE;
    }

    return TRUE;
}


/** 关闭所有灯 */
BOOL CKEBA_DevCtrl::OutputSetForCloseAll()
{
#ifndef MY_CSINGLELOCK
    CSetupMutex lock(MUTEX_SIU_HARDWARE);
#else
    CSingleLock lock(&m_mtxHardware, true);
#endif
    /** Driver function*/
    if(portio_out(0) == -1)
    {
       //Log
       // Trace.TraceInFormat(TRM_OUTPUT, TRM_LV_ERROR, "portio_out(%d) error:%d", outport_value, -1);
        return FALSE;
    }
    outport_value = 0;
    return TRUE;
}

/*
BOOL CKEBA_DevCtrl::InputChannel()
{
    CSingleLock lock(&m_mtxHardware, true);
#if (DEBUG & SUPER_DEBUG)
    printf(">>Enter mutex InputChannel\n");
#endif
    UINT32 value = portio_in();
    if(value == (UINT32)-1)
    {
        //Log
        //Trace.TraceInFormat(TRM_INPUT, TRM_LV_ERROR, "portio_in error:%d", value);
#if (DEBUG & SUPER_DEBUG)
        printf("<<Leave mutex InputChannel\n");
#endif
        return FALSE;
    }
    else
    {
        inport_value = value;
        //Log
        // Trace.TraceInFormat(TRM_INPUT, TRM_LV_COMMN, "portio_in:0x%x", inport_value);
    }

    bool bStatusChanged = false;
    USHORT usState;
    for(iter = m_DevConfig.mapDoorsSettings.begin(); iter != m_DevConfig.mapDoorsSettings.end(); ++iter)
    {
        if(TRUE != ChannelReadFromInBuffer(iter->first, usState))
        {
            continue;
        }
        ChannelValues[iter->first] = usState;
        CHANNEL_XFS_MAP::const_iterator iterValue = iter->second.m_Value.find(usState);
        WORD iXFS = 0;
        if(iterValue != iter->second.m_Value.end())
        {
            iXFS = iterValue->second;
        }
        else
        {
            //need log
        }
        PORT_STATUS::const_iterator iterDoor = m_xfsDoorStatus.find(iter->second.m_xfsPortIndex);
        if(iterDoor == m_xfsDoorStatus.end() || iterDoor->second != iXFS)
        {
#ifndef MY_CSINGLELOCK
            CSetupMutex lock(MUTEX_SIU_XFS);
#else
            CSingleLock lock(&m_mtxStatus, true);
#endif
            m_xfsDoorStatus[iter->second.m_xfsPortIndex] = iXFS;
            if(iterDoor != m_xfsDoorStatus.end())
            {
                bStatusChanged = true;
            }
        }
    }

    for(iter = m_DevConfig.mapSensorsSettings.begin(); iter != m_DevConfig.mapSensorsSettings.end(); ++iter)
    {
        iterGotten = ChannelValues.find(iter->first);
        if(iterGotten != ChannelValues.end())
        {
            usState = iterGotten->second;
        }
        else if(TRUE != ChannelReadFromInBuffer(iter->first, usState))
        {
            continue;
        }
        ChannelValues[iter->first] = usState;
        std::map<WORD,WORD>::const_iterator iterValue = iter->second.m_Value.find(usState);
        WORD iXFS = 0;
        if(iterValue != iter->second.m_Value.end())
        {
            iXFS = iterValue->second;
        }
        else
        {
            //need log
        }
        PORT_STATUS::const_iterator iterSensor = m_xfsSensorStatus.find(iter->second.m_xfsPortIndex);
        if(iterSensor == m_xfsSensorStatus.end() || iterSensor->second != iXFS)
        {
#ifndef MY_CSINGLELOCK
            CSetupMutex lock(MUTEX_SIU_XFS);
#else
            CSingleLock lock(&m_mtxStatus, true);
#endif
            m_xfsSensorStatus[iter->second.m_xfsPortIndex] = iXFS;
            if(iterSensor != m_xfsSensorStatus.end())
            {
                bStatusChanged = true;
            }
        }
    }
    if(bStatusChanged)
        CDBusSender::PostMessage(&m_stDBusNames, SIU_INTERNAL_MSG_STATUS_CHANGED, 0, 0);
#if (DEBUG & SUPER_DEBUG)
    printf("<<Leave mutex InputChannel\n");
#endif
    return TRUE;
}
*/


BOOL CKEBA_DevCtrl::DrvConnect()
{
#ifndef MY_CSINGLELOCK
    CSetupMutex lock(MUTEX_SIU_HARDWARE);
#else
    CSingleLock lock(&m_mtxHardware, true);
#endif
#ifndef DEVICE_SIMULATOR
    portio_close();
    INT iRet = portio_open();
    if(0 != iRet)
    {
        //Log
        //Trace.TraceInFormat(TRM_RCV, TRM_LV_ERROR, "portio_open error:%d", iRet);
        return FALSE;
    }
    return TRUE;
#else
    m_iFd = open(m_cDeviceFile, O_RDWR, S_IRUSR | S_IWUSR);
    if(m_iFd == -1)
    {
        m_log.LogFormatPrint("OpenDevice Error!(%d)", errno);
        return FALSE;
    }
    else
    {
        m_log.LogPrint("OpenDevice Success!");
        return TRUE;
    }
#endif
}
#ifdef DEVICE_SIMULATOR
int CKEBA_DevCtrl::ioctl(int fd, int request, ...)
{
    Q_UNUSED(fd)
    if(request == PDD_DIO_READ)
    {
        if(m_bConnected)
        {
            lseek(m_iFd, 0, SEEK_SET);
            ssize_t size = read(m_iFd, outBuffer, INOUTBUFFERSIZE);
            Q_UNUSED(size);
            return true;
        }
    }
    else if(request == PDD_DIO_WRITE_INT)
    {
        if(m_bConnected)
        {
            lseek(m_iFd, 0, SEEK_SET);
            ssize_t size = read(m_iFd, outBuffer, INOUTBUFFERSIZE);
            memcpy(outWriteBuffer, inBuffer + 4, 4);
            unsigned long long ll = *(unsigned long long*)outBuffer;
            unsigned int ulOriginal = ll >> 32;
            unsigned int ulWrite = *(unsigned int*)outWriteBuffer;
            memcpy(outWriteBuffer, inBuffer, 4);
            unsigned int ulMask = *(unsigned int*)outWriteBuffer;
            ulOriginal |= ulWrite & ulMask;
            ulOriginal &= ulWrite | ~ulMask;
            memcpy(outWriteBuffer, &ulOriginal, 4);
            lseek(m_iFd, 4, SEEK_SET);
            size = write(m_iFd, outWriteBuffer, INOUTBUFFERSIZE / 2);
            size = write(m_iFd, inBuffer, INOUTBUFFERSIZE);
            Q_UNUSED(size);
            return true;
        }
    }
    return false;
}

//for test
void CKEBA_DevCtrl::GetOutBufferFromFile()
{
    if(m_bConnected)
    {
        lseek(m_iFd, 0, SEEK_SET);
        ssize_t size = read(m_iFd, outBuffer, INOUTBUFFERSIZE);
        Q_UNUSED(size);
    }
}
#endif

BOOL CKEBA_DevCtrl::Init()
{
    if(m_bInitFinished)
    {
        return TRUE;
    }

    m_bConnected = DrvConnect();
    if(!m_bConnected)
    {
        return FALSE;
    }
    BOOL bRet = OutputSetForCloseAll();
    if (bRet == FALSE)
    {
        return FALSE;
    }

    if(m_bConnected)
    {
        m_bInitFinished = true;
        return TRUE;
    }
    return FALSE;
}


BOOL CKEBA_DevCtrl::ChannelReadForStatusCheck(WORD iChannel, WORD& usState)
{
#ifndef MY_CSINGLELOCK
    CSetupMutex lock(MUTEX_SIU_HARDWARE);
#else
    CSingleLock lock(&m_mtxHardware, true);
#endif
#if (DEBUG & SUPER_DEBUG)
    printf(">>Enter mutex StatCheck\n");
#endif
    inoutport_value = portio_inout();
    if(inoutport_value == (UINT32)-1)   //usb cut
    {
        //Log
        //Trace.TraceInFormat(TRM_INPUT, TRM_LV_ERROR, "portio_inout error:%d", -1);
        m_bConnected = false;
        INT iRet = portio_open();
        if(iRet != 0)
        {
            //Log
           // Trace.TraceInFormat(TRM_RCV, TRM_LV_ERROR, "portio_open error:%d", iRet);
#if (DEBUG & SUPER_DEBUG)
            printf("<<Leave mutex StatCheck\n");
#endif
            return FALSE;
        }
        if(!m_bInitFinished)
        {
            Init();
        }
    }
    else
    {
        m_bConnected = true;
        if(iChannel < 32)
        {
            if(inoutport_value & 1 << iChannel)
            {
                usState = 1;
            }
            else
            {
                usState = 0;
            }
#if (DEBUG & SUPER_DEBUG)
            printf("<<Leave mutex StatCheck\n");
#endif
            return TRUE;
        }
        else
        {
            //need log
#if (DEBUG & SUPER_DEBUG)
            printf("<<Leave mutex StatCheck\n");
#endif
            return FALSE;
        }
    }
#if (DEBUG & SUPER_DEBUG)
    printf("<<Leave mutex StatCheck\n");
#endif
    return TRUE;
}
/** 读输入通道 */
BOOL CKEBA_DevCtrl::ChannelReadFromInBuffer(BOOL bOut, WORD iChannel, WORD& usState)
{
    unsigned int iValue = 0;

    if(!m_bConnected)
    {
        return FALSE;
    }
#ifndef DEVICE_SIMULATOR
    if(iChannel < 32)
    {
        if (bOut)
        {
            iValue = inoutport_value;
        }
        else
        {
            iValue = inport_value;
        }

         if(iValue & 1 << iChannel)
        {
            usState = 1;
        }
        else
        {
            usState = 0;
        }
    }
    else
    {
        return FALSE;
    }
#else
    if(!ioctl(m_iFd, PDD_DIO_READ))
    {
        m_log.LogFormatPrint("ioctl read error!(%d)", errno);
        return DEV_ERR_HARDWARE_ERROR;
    }
    else
    {
        m_log.LogPrint("Read OK!");
    }
    int iInputNo;
    iInputNo = iChannel;
    if(outBuffer[iInputNo / 8] & 1 << (iInputNo % 8))
    {
        usState = 1;
    }
    else
    {
        usState = 0;
    }
#endif
    return TRUE;
}

BOOL CKEBA_DevCtrl::ChannelReadFromInoutBuffer(WORD iChannel, WORD &usState)
{
    if(!m_bConnected)
    {
        return FALSE;
    }
    if(iChannel < 32)
    {
        if(inoutport_value & 1 << iChannel)
        {
            usState = 1;
        }
        else
        {
            usState = 0;
        }
    }
    else
    {
        return FALSE;
    }
    return TRUE;
}

/**
设置缓冲区对应通道的值
@return 操作结果
*/
BOOL CKEBA_DevCtrl::ChannelWriteToBuffer(WORD iChannel, WORD usState)
{
#ifndef DEVICE_SIMULATOR
    if (usState){
        outport_value |= 1 << iChannel;
    }
    else {
        outport_value &= ~(1 << iChannel);
    }
#else
    int iOutputsNo = 0;   //PinNo need change status, will put into buffer[0]~[3]
    int iOutputs = 0;     //PinStatus need change to, will put into buffer[4]~[7]

    int iOutputNo = iChannel % 100;
    iOutputsNo |= (1 << iOutputNo);
    if(iOutputNo == 6)
    {
        m_log.LogPrint("iOutputNo==6");
        //red
        if(usState & (1 << (iChannel - 1)))
            iOutputs &= 0xfffffebf; //pin6&pin8 set as 0,
        else
            iOutputs |= 0x00000040; //pin6 set as 1, others set as 0
    }
    else
    {
        if(usState)
        {
            iOutputs |= (1 << iOutputNo);
        }
    }
    intToByte(iOutputsNo, inBuffer, 0);
    intToByte(iOutputs, inBuffer, 4);

    if(!ioctl(m_iFd, PDD_DIO_WRITE_INT))
    {
        m_log.LogFormatPrint("octl write error!(%d)", errno);
        return DEV_ERR_HARDWARE_ERROR;
    }
    else
    {
        m_log.LogPrint("Write OK!");
    }
#endif
    return TRUE;
}

#ifdef DEVICE_SIMULATOR
//for test
BOOL CKEBA_DevCtrl::SetInput(int iChannel, USHORT usState)
{
#ifndef MY_CSINGLELOCK
    CSetupMutex lock(MUTEX_SIU_HARDWARE);
#else
    CSingleLock lock(&m_mtxHardware);
#endif
    if(!m_bConnected)
    {
        return DEV_ERR_DEV_NOT_READY;
    }
    int iOutputsNo = 0;   //PinNo need change status, will put into buffer[0]~[3]
    int iOutputs = 0;     //PinStatus need change to, will put into buffer[4]~[7]

    int iOutputNo = iChannel % 100;
    iOutputsNo |= (1 << iOutputNo);
    if(iOutputNo == 6)
    {
        //red
        if(usState & (1 << (iChannel - 1)))
            iOutputs &= 0xfffffebf; //pin6&pin8 set as 0,
        else
            iOutputs |= 0x00000040; //pin6 set as 1, others set as 0
    }
    else
    {
        if(usState)
        {
            iOutputs |= (1 << iOutputNo);
        }
    }
    intToByte(iOutputsNo, outWriteBuffer, 0);
    if(m_bConnected)
    {
        lseek(m_iFd, 0, SEEK_SET);
        unsigned long l = *(unsigned long*)outBuffer;
        l |= *(unsigned long*)outWriteBuffer;
        memcpy(outWriteBuffer, &l, 4);
        ssize_t size = write(m_iFd, outWriteBuffer, INOUTBUFFERSIZE / 2);
        Q_UNUSED(size);
    }
    return DEV_SUCCESS;
}
void CKEBA_DevCtrl::intToByte(int i, BYTE* buf, UINT uOffset)//not used
{
    buf[0 + uOffset] = (BYTE) (0xff & i);
    buf[1 + uOffset] = (BYTE) ((0xff00 & i) >> 8);
    buf[2 + uOffset] = (BYTE) ((0xff0000 & i) >> 16);
    buf[3 + uOffset] = (BYTE) ((0xff000000 & i) >> 24);
}
#endif