コード例 #1
0
//------------------------------------------------------------------------------
static tOplkError cbProcessRpdo(tFrameInfo* pFrameInfo_p)
{
    tOplkError      ret = kErrorOk;
    tEvent          event;

    event.eventSink = kEventSinkPdokCal;
    event.eventType = kEventTypePdoRx;
#if CONFIG_DLL_DEFERRED_RXFRAME_RELEASE_SYNC != FALSE
    event.eventArgSize   = sizeof(tFrameInfo);
    event.pEventArg      = pFrameInfo_p;
#else
    // limit copied data to size of PDO (because from some CNs the frame is larger than necessary)
    event.eventArgSize = ami_getUint16Le(&pFrameInfo_p->pFrame->data.pres.sizeLe) +
                                         PLK_FRAME_OFFSET_PDO_PAYLOAD; // pFrameInfo_p->frameSize;
    event.pEventArg = pFrameInfo_p->pFrame;
#endif
    ret = eventk_postEvent(&event);
#if CONFIG_DLL_DEFERRED_RXFRAME_RELEASE_SYNC != FALSE
    if (ret == kErrorOk)
    {
        ret = kErrorReject; // Reject release of rx buffer
    }
#endif

    return ret;
}
コード例 #2
0
ファイル: cfmu.c プロジェクト: Questio/openPOWERLINK_V2
//------------------------------------------------------------------------------
static tOplkError downloadObject(tCfmNodeInfo* pNodeInfo_p)
{
    tOplkError          ret = kErrorOk;

    // forward data pointer for last transfer
    pNodeInfo_p->pDataConciseDcf += pNodeInfo_p->curDataSize;
    pNodeInfo_p->bytesRemaining -= pNodeInfo_p->curDataSize;

    if (pNodeInfo_p->entriesRemaining > 0)
    {
        if (pNodeInfo_p->bytesRemaining < CDC_OFFSET_DATA)
        {
            // not enough bytes left in ConciseDCF
            pNodeInfo_p->eventCnProgress.error = kErrorCfmInvalidDcf;
            if ((ret = callCbProgress(pNodeInfo_p)) != kErrorOk)
                return ret;
            return finishConfig(pNodeInfo_p, kNmtNodeCommandConfErr);
        }

        // fetch next item from ConciseDCF
        pNodeInfo_p->eventCnProgress.objectIndex = ami_getUint16Le(&pNodeInfo_p->pDataConciseDcf[CDC_OFFSET_INDEX]);
        pNodeInfo_p->eventCnProgress.objectSubIndex = ami_getUint8Le(&pNodeInfo_p->pDataConciseDcf[CDC_OFFSET_SUBINDEX]);
        pNodeInfo_p->curDataSize = (UINT)ami_getUint32Le(&pNodeInfo_p->pDataConciseDcf[CDC_OFFSET_SIZE]);
        pNodeInfo_p->pDataConciseDcf += CDC_OFFSET_DATA;
        pNodeInfo_p->bytesRemaining -= CDC_OFFSET_DATA;
        pNodeInfo_p->eventCnProgress.bytesDownloaded += CDC_OFFSET_DATA;

        if ((pNodeInfo_p->bytesRemaining < pNodeInfo_p->curDataSize) ||
            (pNodeInfo_p->curDataSize == 0))
        {
            // not enough bytes left in ConciseDCF
            pNodeInfo_p->eventCnProgress.error = kErrorCfmInvalidDcf;
            if ((ret = callCbProgress(pNodeInfo_p)) != kErrorOk)
                return ret;
            return finishConfig(pNodeInfo_p, kNmtNodeCommandConfErr);
        }

        pNodeInfo_p->entriesRemaining--;
        ret = sdoWriteObject(pNodeInfo_p, pNodeInfo_p->pDataConciseDcf, pNodeInfo_p->curDataSize);
        if (ret != kErrorOk)
            return ret;
    }
    else
    {   // download finished
#if defined(CONFIG_INCLUDE_NMT_RMN)
        ret = downloadNetConf(pNodeInfo_p);
#else
        ret = finishDownload(pNodeInfo_p);
#endif
        if (ret != kErrorOk)
            return ret;
    }

    return ret;
}
コード例 #3
0
//------------------------------------------------------------------------------
static tOplkError processCdc(tObdCdcInfo* pCdcInfo_p)
{
    tOplkError      ret = kErrorOk;
    UINT32          entriesRemaining;
    UINT            objectIndex;
    UINT            objectSubIndex;
    size_t          curDataSize;

    if ((ret = loadNextBuffer(pCdcInfo_p, sizeof(UINT32))) != kErrorOk)
        return ret;

    entriesRemaining = ami_getUint32Le(pCdcInfo_p->pCurBuffer);

    if (entriesRemaining == 0)
    {
        ret = eventu_postError(kEventSourceObdu, kErrorObdNoConfigData, 0, NULL);
        return ret;
    }

    for (; entriesRemaining != 0; entriesRemaining--)
    {
        if ((ret = loadNextBuffer(pCdcInfo_p, CDC_OFFSET_DATA))  != kErrorOk)
            return ret;

        objectIndex = ami_getUint16Le(&pCdcInfo_p->pCurBuffer[CDC_OFFSET_INDEX]);
        objectSubIndex = ami_getUint8Le(&pCdcInfo_p->pCurBuffer[CDC_OFFSET_SUBINDEX]);
        curDataSize = (size_t)ami_getUint32Le(&pCdcInfo_p->pCurBuffer[CDC_OFFSET_SIZE]);

        DEBUG_LVL_OBD_TRACE("%s: Reading object 0x%04X/%u with size %u from CDC\n",
                             __func__, objectIndex, objectSubIndex, curDataSize);
        if ((ret = loadNextBuffer(pCdcInfo_p, curDataSize)) != kErrorOk)
        {
            DEBUG_LVL_OBD_TRACE("%s: Reading the corresponding data from CDC failed with 0x%02X\n", __func__, ret);
            return ret;
        }

        ret = obd_writeEntryFromLe(objectIndex, objectSubIndex, pCdcInfo_p->pCurBuffer,
                                   (tObdSize)curDataSize);
        if (ret != kErrorOk)
        {
            tEventObdError          obdError;

            obdError.index = objectIndex;
            obdError.subIndex = objectSubIndex;

            DEBUG_LVL_OBD_TRACE("%s: Writing object 0x%04X/%u to local OBD failed with 0x%02X\n",
                                 __func__, objectIndex, objectSubIndex, ret);
            ret = eventu_postError(kEventSourceObdu, ret, sizeof(tEventObdError), &obdError);
            if (ret != kErrorOk)
                return ret;
        }
    }

    return ret;
}
コード例 #4
0
//------------------------------------------------------------------------------
void ami_getTimeOfDay (void* pAddr_p, tTimeOfDay* pTimeOfDay_p)
{
    pTimeOfDay_p->msec = ami_getUint32Le(((UINT8*)pAddr_p)) & 0x0FFFFFFF;
    pTimeOfDay_p->days = ami_getUint16Le(((UINT8*)pAddr_p) + 4);
}