How to copy buffer contents to another buffer which is defined in structure

Question

1.00/5 (1 vote)

See more:

I have created a buffer...

char buffer[8]="mindflow";

and i tried to copy this buffer contents into another buffer buffer_p.count which is defined in nested structure....

/* DMA callback function to handle the produce events for P to U transfers. */
void
CyFxSlFifoPtoUDmaCallback (
CyU3PDmaChannel *chHandle,
CyU3PDmaCbType_t type,
CyU3PDmaCBInput_t *input

)
{
CyU3PReturnStatus_t status = CY_U3P_SUCCESS;

if (type == CY_U3P_DMA_CB_PROD_EVENT)
{
/* This is a produce event notification to the CPU. This notification is
* received upon reception of every buffer. The buffer will not be sent
* out unless it is explicitly committed. The call shall fail if there
* is a bus reset / usb disconnect or if there is any application error. */
char buffer[9]= "MIND FLOW";

status = CyU3PDmaChannelCommitBuffer (chHandle, input->buffer_p.count, 0);

if (status != CY_U3P_SUCCESS)
{
CyU3PDebugPrint (4, "CyU3PDmaChannelCommitBuffer failed, Error code = %d\n", status);
}

/* Increment the counter. */
glDMATxCount++;
}
}

What I have tried:

/* DMA callback function to handle the produce events for P to U transfers. */
void
CyFxSlFifoPtoUDmaCallback (
        CyU3PDmaChannel   *chHandle,
        CyU3PDmaCbType_t  type,
        CyU3PDmaCBInput_t *input

        )
{
    CyU3PReturnStatus_t status = CY_U3P_SUCCESS;

    if (type == CY_U3P_DMA_CB_PROD_EVENT)
    {
        /* This is a produce event notification to the CPU. This notification is 
         * received upon reception of every buffer. The buffer will not be sent
         * out unless it is explicitly committed. The call shall fail if there
         * is a bus reset / usb disconnect or if there is any application error. */
    	char buffer[9]= "MIND FLOW";

        status = CyU3PDmaChannelCommitBuffer (chHandle, input->buffer_p.count, 0);

        if (status != CY_U3P_SUCCESS)
        {
            CyU3PDebugPrint (4, "CyU3PDmaChannelCommitBuffer failed, Error code = %d\n", status);
        }

        /* Increment the counter. */
        glDMATxCount++;
    }
}

Posted 29-Aug-17 1:06am

Veerendra-13142768

Updated 29-Aug-17 1:37am

Add a Solution

Comments

Mohibur Rashid 30-Aug-17 4:27am

You will have issue with this statement
char buffer[9]= "MIND FLOW";
Change it to
char buffer[10]= "MIND FLOW";

2 solutions

Add a Solution

Add your solution here

Treat my content as plain text, not as HTML

Preview 0

…

Existing Members

Sign in to your account

...or Join us

Download, Vote, Comment, Publish.

Your Email
Password
Forgot your password?

Your Email
This email is in use. Do you need your password?
Optional Password

I have read and agree to the Terms of Service and Privacy Policy
Please subscribe me to the CodeProject newsletters

When answering a question please:

Read the question carefully.
Understand that English isn't everyone's first language so be lenient of bad spelling and grammar.
If a question is poorly phrased then either ask for clarification, ignore it, or edit the question and fix the problem. Insults are not welcome.
Don't tell someone to read the manual. Chances are they have and don't get it. Provide an answer or move on to the next question.

Let's work to help developers, not make them feel stupid.

This content, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

CPallini · Answer 1 · 2017-08-29T01:29:00

Solution 1

You might use the memcpy[^] function for the purpose.

Please note you have first to allocate (possibly dynamic) memory for the destination buffer (and then you have to release the dynamically allocated memory).

Posted 29-Aug-17 1:29am

CPallini

v2

Jochen Arndt · Answer 2 · 2017-08-29T01:37:00

To answer that the declaration of input->buffer_p[.count] must be known and how many bytes should be copied from where to where. Note that I have put the .count into brackets because the name indicates that it is a count/size value and not a buffer.

Okay, I searched for it and found it at https://github.com/nickdademo/cypress-fx3-sdk-linux/blob/master/firmware/u3p_firmware/inc/cyu3dma.h[^]:

typedef struct CyU3PDmaBuffer_t
{
    uint8_t *buffer;    /**< Pointer to the data buffer. */
    uint16_t count;     /**< Byte count of valid data in buffer. */
    uint16_t size;      /**< Actual size of the buffer in bytes. Should be a multiple of 16. */
    uint16_t status;    /**< Buffer status. This is a four bit data field defined by 
                             CY_U3P_DMA_BUFFER_STATUS_MASK. This holds information like
                             whether the buffer is occupied, whether the buffer holds the
                             end of packet and whether the buffer encountered a DMA error. */
} CyU3PDmaBuffer_t;

/** \brief DMA channel callback input.
    **Description**\n
    This data structure is used to provide event specific information when a DMA callback
    is called. This structure is defined as a union to facilitate future updates to the
    DMA manager.
    **\see
    *\see CyU3PDmaBuffer_t
    *\see CyU3PDmaCallback_t
 */
typedef union CyU3PDmaCBInput_t
{
    CyU3PDmaBuffer_t buffer_p;  /**< Data about the DMA buffer that caused the callback to be called. */
} CyU3PDmaCBInput_t;

According to that you can copy the data to your buffer with

C++

memcpy(buffer, input->buffer_p.buffer, input->buffer_p.count);

provided that your buffer is large enough (size >= input->buffer_p.count).

To copy data to the input->buffer_p, copy in the reverse direction and set the other structure members accordingly (count, status) after checking for sufficient size.
[EDIT: Example]

C++

uint16_t bufSize = sizeof(buffer); // or whatever the actual size is
if (bufSize <= input->buffer_p.size)
{
    input->buffer_p.count = bufSize;
    input->buffer_p.status = theStatus; // 
    memcpy(input->buffer_p.buffer, buffer, bufSize);
}

But you have to comply with the specifications of the SDK
[/EDIT]

I'm not sure for which direction the callback is issued here. But you should know when doing such low level stuff.