//------------------------------------------------------------------------------
tOplkError dllucal_issueRequest(tDllReqServiceId service_p,
                                UINT nodeId_p,
                                UINT8 soaFlag1_p)
{
    tOplkError          ret;
    tEvent              event;
    tDllCalIssueRequest issueReq;

    // add node to appropriate request queue
    switch (service_p)
    {
        case kDllReqServiceIdent:
        case kDllReqServiceStatus:
            issueReq.service = service_p;
            issueReq.nodeId = nodeId_p;
            issueReq.soaFlag1 = soaFlag1_p;

            event.eventSink = kEventSinkDllkCal;
            event.eventType = kEventTypeDllkIssueReq;
            event.eventArg.pEventArg = &issueReq;
            event.eventArgSize = sizeof(issueReq);

            ret = eventu_postEvent(&event);
            break;

        default:
            ret = kErrorDllInvalidParam;
            goto Exit;
    }

Exit:
    return ret;
}
//------------------------------------------------------------------------------
tOplkError eventu_postError(tEventSource eventSource_p,
                            tOplkError error_p,
                            UINT argSize_p,
                            const void* pArg_p)
{
    tOplkError  ret;
    tEventError eventError;
    tEvent      event;

    // Check parameter validity
    ASSERT((argSize_p == 0) ||
           (pArg_p != NULL));

    // create argument
    eventError.eventSource = eventSource_p;
    eventError.oplkError = error_p;
    argSize_p = (UINT)min((size_t)argSize_p, sizeof(eventError.errorArg));
    OPLK_MEMCPY(&eventError.errorArg, pArg_p, argSize_p);

    // create event
    event.eventType = kEventTypeError;
    event.eventSink = kEventSinkApi;
    OPLK_MEMSET(&event.netTime, 0x00, sizeof(event.netTime));
    event.eventArgSize = offsetof(tEventError, errorArg) + argSize_p;
    event.eventArg.pEventArg = &eventError;

    ret = eventu_postEvent(&event);

    return ret;
}
//------------------------------------------------------------------------------
tOplkError sdotestcom_conCb(tSdoSeqConHdl sdoSeqConHdl_p,
                            tAsySdoConState sdoConState_p)
{
    tOplkError           ret = kErrorOk;
    tSdoTestComCon*      pCmdCon;
    tEvent               Event;

    // Ignore unused parameter
    (void)sdoSeqConHdl_p;

    ret     = kErrorOk;
    pCmdCon = &sdoTestComInst.tCmdCon;

    switch (sdoConState_p)
    {
        case kAsySdoConStateConnected:

            pCmdCon->tState = kOplkTestSdoComStateConnected;

            // Trigger frame send event
            OPLK_MEMSET(&Event.netTime, 0x00, sizeof(Event.netTime));
            Event.eventType    = kEventTypeSdoAsySend;
            Event.pEventArg    = pCmdCon;
            Event.eventArgSize = sizeof(*pCmdCon);
            Event.eventSink    = kEventSinkSdoTest;

            ret = eventu_postEvent(&Event);
            break;

        case kAsySdoConStateAckReceived:
        case kAsySdoConStateFrameSent:

            // These events are not forwarded to the app, and don't require any
            // handling here, so just do nothing in this case
            break;

        default:
        case kAsySdoConStateInitError:
        case kAsySdoConStateConClosed:
        case kAsySdoConStateTimeout:
        case kAsySdoConStateTransferAbort:

            // Close connection
            pCmdCon->tState = kOplkTestSdoComStateIdle;
            break;
    }

    return ret;
}
示例#4
0
//------------------------------------------------------------------------------
tOplkError nmtu_postNmtEvent(tNmtEvent nmtEvent_p)
{
    tOplkError  ret;
    tEvent      event;

    event.eventSink = kEventSinkNmtk;
    event.netTime.nsec = 0;
    event.netTime.sec = 0;
    event.eventType = kEventTypeNmtEvent;
    event.pEventArg = &nmtEvent_p;
    event.eventArgSize = sizeof(nmtEvent_p);

    ret = eventu_postEvent(&event);

    return ret;
}
//------------------------------------------------------------------------------
tOplkError dllucal_deleteNode(const tDllNodeOpParam* pNodeOpParam_p)
{
    tOplkError  ret;
    tEvent      event;

    // Check parameter validity
    ASSERT(pNodeOpParam_p != NULL);

    event.eventSink = kEventSinkDllkCal;
    event.eventType = kEventTypeDllkDelNode;
    event.eventArg.pEventArg = (void*)pNodeOpParam_p;
    event.eventArgSize = sizeof(*pNodeOpParam_p);

    ret = eventu_postEvent(&event);

    return ret;
}
//------------------------------------------------------------------------------
tOplkError dllucal_setIdentity(const tDllIdentParam* pDllIdentParam_p)
{
    tOplkError  ret;
    tEvent      event;

    // Check parameter validity
    ASSERT(pDllIdentParam_p != NULL);

    event.eventSink = kEventSinkDllkCal;
    event.eventType = kEventTypeDllkIdentity;
    event.eventArg.pEventArg = (void*)pDllIdentParam_p;
    event.eventArgSize = sizeof(*pDllIdentParam_p);

    ret = eventu_postEvent(&event);

    return ret;
}
//------------------------------------------------------------------------------
tOplkError timeru_process(void)
{
    tTimerEntry*        pTimerEntry;
    UINT32              timeoutInMs;
    tEvent              event;
    tTimerEventArg      timerEventArg;
    tOplkError          ret = kErrorOk;

    enterCriticalSection(TIMERU_TIMER_LIST);
    // calculate elapsed time since start time
    timeoutInMs = getTickCount() - timeruInstance_l.startTimeInMs;

    // observe first timer entry in timer list
    pTimerEntry = timeruInstance_l.pTimerListFirst;
    if (pTimerEntry != NULL)
    {
        if (timeoutInMs >= pTimerEntry->timeoutInMs)
        {   // timeout elapsed - remove entry from timer list
            timeruInstance_l.pTimerListFirst = pTimerEntry->pNext;
            // adjust start time
            timeruInstance_l.startTimeInMs += pTimerEntry->timeoutInMs;
        }
        else
        {
            pTimerEntry = NULL;
        }
    }
    leaveCriticalSection(TIMERU_TIMER_LIST);

    if (pTimerEntry != NULL)
    {
        // call event function
        timerEventArg.timerHdl = (tTimerHdl)pTimerEntry;
        OPLK_MEMCPY(&timerEventArg.argument, &pTimerEntry->timerArg.argument, sizeof(timerEventArg.argument));

        event.eventSink = pTimerEntry->timerArg.eventSink;
        event.eventType = kEventTypeTimer;
        OPLK_MEMSET(&event.netTime, 0x00, sizeof(tNetTime));
        event.pEventArg = &timerEventArg;
        event.eventArgSize = sizeof(timerEventArg);

        ret = eventu_postEvent(&event);
    }

    return ret;
}
//------------------------------------------------------------------------------
static void cbTimer(const tTimeruData* pData_p)
{
    tOplkError      ret;
    tEvent          event;
    tTimerEventArg  timerEventArg;

    // call event function
    timerEventArg.timerHdl.handle = (tTimerHdl)pData_p;
    OPLK_MEMCPY(&timerEventArg.argument, &pData_p->timerArg.argument, sizeof(timerEventArg.argument));

    event.eventSink = pData_p->timerArg.eventSink;
    event.eventType = kEventTypeTimer;
    OPLK_MEMSET(&event.netTime, 0x00, sizeof(tNetTime));
    event.eventArg.pEventArg = &timerEventArg;
    event.eventArgSize = sizeof(timerEventArg);

    ret = eventu_postEvent(&event);
}
//------------------------------------------------------------------------------
static tOplkError setAsndServiceIdFilter(tDllAsndServiceId serviceId_p,
                                         tDllAsndFilter filter_p)
{
    tOplkError                  ret;
    tEvent                      event;
    tDllCalAsndServiceIdFilter  servFilter;

    servFilter.serviceId = serviceId_p;
    servFilter.filter = filter_p;

    event.eventSink = kEventSinkDllkCal;
    event.eventType = kEventTypeDllkServFilter;
    event.eventArg.pEventArg = &servFilter;
    event.eventArgSize = sizeof(servFilter);

    ret = eventu_postEvent(&event);

    return ret;
}
//------------------------------------------------------------------------------
static void cbTimer(ULONG parameter_p)
{
    tTimeruData*        pData;
    tEvent              event;
    tTimerEventArg      timerEventArg;

    pData = (tTimeruData*)parameter_p;

    // call event function
    timerEventArg.timerHdl = (tTimerHdl)pData;
    OPLK_MEMCPY(&timerEventArg.argument, &pData->timerArgument.argument,
                sizeof(timerEventArg.argument));

    event.eventSink = pData->timerArgument.eventSink;
    event.eventType = kEventTypeTimer;
    OPLK_MEMSET(&event.netTime, 0x00, sizeof(tNetTime));
    event.pEventArg = &timerEventArg;
    event.eventArgSize = sizeof(timerEventArg);

    eventu_postEvent(&event);
}
//------------------------------------------------------------------------------
static void cbTimer(ULONG parameter_p)
{
    tOplkError          ret = kErrorOk;
    tTimeruData*        pData;
    tEvent              event;
    tTimerEventArg      timerEventArg;

    pData = (tTimeruData*)parameter_p;

    // call event function
    timerEventArg.timerHdl.handle = (tTimerHdl)pData;
    OPLK_MEMCPY(&timerEventArg.argument, &pData->timerArgument.argument, sizeof(timerEventArg.argument));

    event.eventSink = pData->timerArgument.eventSink;
    event.eventType = kEventTypeTimer;
    OPLK_MEMSET(&event.netTime, 0x00, sizeof(tNetTime));
    event.eventArg.pEventArg = &timerEventArg;
    event.eventArgSize = sizeof(timerEventArg);

    ret = eventu_postEvent(&event);
    // d.k. do not free memory, user has to call timeru_deleteTimer()
}
//------------------------------------------------------------------------------
static tOplkError handleRxAsyncFrameInfo(tFrameInfo* pFrameInfo_p)
{
    tOplkError  ret;
    tEvent      event;
    tPlkFrame*  pKernelBuffer = pFrameInfo_p->frame.pBuffer;
    tPlkFrame*  pAcqBuffer;

    // Get Rx buffer from kernel layer
    pAcqBuffer = (tPlkFrame*)memmap_mapKernelBuffer(pKernelBuffer, pFrameInfo_p->frameSize);
    if (pAcqBuffer == NULL)
    {
        DEBUG_LVL_ERROR_TRACE("%s Getting the Rx buffer from kernel failed!\n", __func__);
        return kErrorDllOutOfMemory; //jz Use other error code?
    }

    // Set reference to kernel buffer for processing
    pFrameInfo_p->frame.pBuffer = pAcqBuffer;

    // Now handle the async frame
    ret = handleRxAsyncFrame(pFrameInfo_p);

    // Free the acquired kernel buffer
    memmap_unmapKernelBuffer(pAcqBuffer);

    // Restore frame info for releasing Rx frame
    pFrameInfo_p->frame.pBuffer = pKernelBuffer;

    // call free function for Asnd frame
    event.eventSink = kEventSinkDllkCal;
    event.eventType = kEventTypeReleaseRxFrame;
    event.eventArgSize = sizeof(tFrameInfo);
    event.eventArg.pEventArg = (void*)pFrameInfo_p;

    eventu_postEvent(&event);

    // Return handleRxAsyncFrameInfo() return value (ignore others)
    return ret;
}
//------------------------------------------------------------------------------
tOplkError dllucal_sendAsyncFrame(const tFrameInfo* pFrameInfo_p,
                                  tDllAsyncReqPriority priority_p)
{
    tOplkError  ret;
    tEvent      event;

    // Check parameter validity
    ASSERT(pFrameInfo_p != NULL);

    switch (priority_p)
    {
        case kDllAsyncReqPrioNmt:
            ret = instance_l.pTxNmtFuncs->pfnInsertDataBlock(
                                              instance_l.dllCalQueueTxNmt,
                                              (const UINT8*)pFrameInfo_p->frame.pBuffer,
                                              pFrameInfo_p->frameSize);
            break;

        default:
            ret = sendGenericAsyncFrame(pFrameInfo_p);
            break;
    }

    if (ret != kErrorOk)
        goto Exit;

    // post event to DLL
    event.eventSink = kEventSinkDllk;
    event.eventType = kEventTypeDllkFillTx;
    OPLK_MEMSET(&event.netTime, 0x00, sizeof(event.netTime));
    event.eventArg.pEventArg = &priority_p;
    event.eventArgSize = sizeof(priority_p);

    ret = eventu_postEvent(&event);

Exit:
    return ret;
}
//------------------------------------------------------------------------------
tOplkError sdotestcom_sendFrame(UINT nodeId_p, tSdoType sdoType_p,
                                tAsySdoCom* pSdoCom_p, size_t sdoSize_p)
{
    tOplkError              ret;
    tSdoTestComCon*         pCmdCon;
    tEvent                  Event;
    tCircBufError           CbError;
    tPlkFrame*              pFrame;
    tAsySdoCom*             pSdoCom_Dst;
    size_t                  FrameSize;

    ret       = kErrorOk;
    pCmdCon   = &sdoTestComInst.tCmdCon;
    FrameSize = PLK_FRAME_OFFSET_SDO_COMU + sdoSize_p;

    // Check if parameters are valid
    if (FrameSize > C_DLL_MAX_ASYNC_MTU)
    {
        return kErrorInvalidOperation;
    }

    if (kOplkTestSdoComStateIdle != pCmdCon->tState)
    {
        // If the connection is already in use, node ID and SDO type have to match
        if ((pCmdCon->nodeId != nodeId_p) ||
           (pCmdCon->tSdoType != sdoType_p))
        {
            return kErrorInvalidOperation;
        }
    }

    // Get frame buffer
    pFrame = (tPlkFrame *)OPLK_MALLOC(FrameSize);
    if (pFrame == NULL)
    {
        ret = kErrorNoResource;
    }

    // Generate frame
    pSdoCom_Dst = &pFrame->data.asnd.payload.sdoSequenceFrame.sdoSeqPayload;

    OPLK_MEMSET(pFrame, 0, FrameSize);
    OPLK_MEMCPY(pSdoCom_Dst, pSdoCom_p, sdoSize_p);

    // Save frame in shared buffer
    CbError = circbuf_writeData(pCmdCon->pCbBufInst,
                                pFrame, FrameSize);

    OPLK_FREE(pFrame);

    if (kCircBufOk != CbError)
    {
        ret = kErrorInvalidOperation;
    }
    else
    {
        // Sequence layer handling
        // Either create a new connection, or reuse existing one
        switch (pCmdCon->tState)
        {
            case kOplkTestSdoComStateIdle:

                // Get new sequence layer connection
                // When the connection is ready, the callback will trigger sending
                ret = sdoseq_initCon(&pCmdCon->tSeqHdl, nodeId_p, sdoType_p);

                pCmdCon->tState   = kOplkTestSdoComStateWaitInit;
                pCmdCon->tSdoType = sdoType_p;
                pCmdCon->nodeId   = nodeId_p;
                break;

            case kOplkTestSdoComStateWaitInit:

                // Connection setup is already in progress
                // Nothing left to do
                break;

            case kOplkTestSdoComStateConnected:

                // Connection is already up and running,
                // just trigger frame send event
                OPLK_MEMSET(&Event.netTime, 0x00, sizeof(Event.netTime));
                Event.eventType    = kEventTypeSdoAsySend;
                Event.pEventArg    = pCmdCon;
                Event.eventArgSize = sizeof(*pCmdCon);
                Event.eventSink    = kEventSinkSdoTest;
                ret = eventu_postEvent(&Event);
                break;

            default:

                // Reject unknown states
                ret = kErrorInvalidOperation;

                break;
        }
    }

    return ret;
}