SDO client download example about canopennode

[Ashenoneq]

Hello! Our device has a high requirement for real-time performance and cannot be blocked for too long, so I have the same concern. Currently, my approach is to have the caller poll this function multiple times until it returns either success or failure before exiting.

extern SdoAbortCode writeSdoClientNoBlock(uint8_t nodeId, uint16_t index, \         
                                          uint8_t subIndex, uint8_t* data,\         
                                          size_t dataSize)                          
{                                                                                   
    static uint8_t  first_entry = 0;                                                
                                                                                    
    static bool_t bufferPartial = false;                                            
                                                                                    
    CO_SDO_return_t SDO_ret;                                                        
    CO_SDOclient_t* SDO_C = CO->SDOclient;                                          
                                                                                    
    if (first_entry == 0)                                                           
    {                                                                               
        first_entry = 1;                                                            
                                                                                    
        // setup client (this can be skipped, if remote device is the same)         
        SDO_ret = CO_SDOclient_setup(SDO_C,                                         
                                     CO_CAN_ID_SDO_CLI + nodeId,                    
                                     CO_CAN_ID_SDO_SRV + nodeId,                    
                                     nodeId);                                       
        if (SDO_ret != CO_SDO_RT_ok_communicationEnd)                               
        {                                                                           
            return USER_ERR_CODE;                                                   
        }                                                                           
                                                                                    
        // initiate download                                                        
        SDO_ret = CO_SDOclientDownloadInitiate(SDO_C, index, subIndex,              
                                               dataSize, 1000, false);              
        if (SDO_ret != CO_SDO_RT_ok_communicationEnd)                               
        {                                                                           
            return USER_ERR_CODE;                                                   
        }                                                                           
                                                                                    
        // fill data                                                                
        size_t nWritten = CO_SDOclientDownloadBufWrite(SDO_C, data, dataSize);      
        if (nWritten < dataSize)                                                    
        {                                                                           
            bufferPartial = true;                                                   
            // If SDO Fifo buffer is too small, data can be refilled in the loop.   
        }                                                                           
    }                                                                               
                                                                                    
    //download data                                                                 
    CO_SDO_abortCode_t abortCode = CO_SDO_AB_NONE;                                  
    uint32_t timeDifference_us = 1000;                                              
    SDO_ret = CO_SDOclientDownload(SDO_C,                                           
                                   timeDifference_us,                               
                                   false,                                           
                                   bufferPartial,                                   
                                   &abortCode,                                      
                                   NULL, NULL);                                     
                                                                                    
    if (SDO_ret == 0) //success                                                     
    {                                                                               
        first_entry = 0;                                                            
        bufferPartial = false;                                                      
        return REDEF_CO_SDO_AB_NONE;                                                
    }                                                                               
    else if (SDO_ret > 0)                                                           
    {                                                                               
        return SDO_NO_BLOCK_WAIT_CODE;//Self-defined return values                  
    }                                                                               
    else                                                                            
    {                                                                               
        first_entry = 0;                                                            
        bufferPartial = false;                                                      
        return (SdoAbortCode)abortCode;                                             
    }                                                                               
}

[CANopenNode]

SDO client is quite complex and has to be implemented properly and well integrated into OS. In CANopenLinux it works really fast, no delays, very reliable. See there and also CANopenDemo.