Mity CPU Platforms » MityDSP-L138 (ARM9 Based Platforms)

Hello!

I have MityDSP OMAPL-138F, version linux kernel - 3.2, version dsplink 1.65 (from MDK-2012-03-2012), pc Ubuntu-14.04.05 LTS. ARM & DSP clock freq - 300MHz.

I want to establish a continuous exchange of data between two cores ARM and DSP. ARM core sends data to the DSP core and sends it back to the ARM core. Below are some small examples.
ARM core

#include <cstdio>
#include <cstdlib>

#include "dspapp.h" 
#include "ipc_inbound.h" 
#include "ipc_outbound.h" 

#include <string.h>
#include <signal.h>

using namespace MityDSP;

int handleInboundMessage(void *Buffer, uint16_t Length, void *UserArg);
void dsp_sender();
void signalHandler(int signum);

volatile bool gbDone = false;
volatile int sigStart = 1;
const int BUFF_SIZE_PC = 128;

// tcDspApp class for booting and loading the DSP
    tcDspApp*         lpDspApp = NULL;
    // Used to setup handling of inbound messages from DSP
    tcIPCInbound*     lpMessageInbound  = NULL;
    // Used to send messages to the DSP
    tcIPCOutbound*     lpMessageOutbound  = NULL;
    // Message to send to the DSP
    char            lpMessage[] = "Hello DSP";
    // Pointer to buffer obtained from dsplink
    char*            lpMessageBuffer = NULL;

int main(int argc, char* argv[])
{

    // Check application usage
    if (argc < 2)
    {
        printf("usage: arm_image dsp_image.out\n");
        return -1;
    }

    // Create the DspApp object
    lpDspApp = new tcDspApp();

    // Load the DSP.out file
    printf("Loading file %s\n", argv[1]);
    lpDspApp->LoadApp(argv[1]);

    printf("Starting application.\n");

    // Create the object to handle incoming messages from the DSP
    lpMessageInbound =  new tcIPCInbound((char*)"GPPMSGQ1");

    if (NULL != lpMessageInbound)
    {
        // Register the callback for handling messages from the DSP
        lpMessageInbound->Register(handleInboundMessage, (void*)NULL);

        // Intiailize the inbound controller to create the thread that handles the callbacks
        lpMessageInbound->Initialize();
    }

    // Create the object used to send messages to the DSP
    lpMessageOutbound = new tcIPCOutbound((char*)"DSPMSGQ0");

    // Wait for the DSP to finish initialization
    while(false == gbDone);

    // Reset bool in prep for next receive message from DSP
    gbDone = false;

    //test
    dsp_sender();

    printf("Exiting application.\n");

    // Stop the DSP application from running
    lpDspApp->StopApp();

    return 0;
}

int handleInboundMessage(void *apBuffer, uint16_t anLength, void *apUserArg)
{
    // printf("ARM received a message from the DSP:\n");

    printf("DSP Message = (%s).\n", ((char *)apBuffer));

    // Notify the main function that we have received a message from the DSP and are done
    gbDone = true;

    return 0;
}

void dsp_sender()
{
    const int N = 41;
    char tmp_buffer[N] = {0};

    int counter = 0;
    lpMessageBuffer = (char *)lpMessageOutbound->GetBuffer(BUFF_SIZE_PC);

    (void)signal(SIGINT, signalHandler);

    while (sigStart)
    {
        counter++;
        sprintf(tmp_buffer, "Test message #%d.\n", counter);        
        memcpy(lpMessageBuffer, tmp_buffer, BUFF_SIZE_PC);
        lpMessageOutbound->SendMessage(lpMessageBuffer);        
        // lpMessageOutbound->ReturnBuffer(lpMessageBuffer);

        usleep(5000);
    }

}

void signalHandler(int signum)
{
    sigStart = 0;
}

DSP core

#include <std.h>
#include <tsk.h>
#include <stdio.h>
#include <string.h>

#include "core/cl_ipc_inbound.h" 
#include "core/cl_ipc_outbound.h" 

using namespace MityDSP;

// Forward declarations
void init();
int handleInboundMessage(void *apBuffer, uint32_t anLength, void *apUserArg) ;

// Object for sending GPPMSGQ1 messages that the ARM will receive
tcCL_IPCOutbound*     gpOutbound;
// Object for receiving DSPMSGQ0 messages that the DSP will receive
tcCL_IPCInbound*     gpInbound;

const int BUFF_SIZE_PC = 128;
char* glpMessageBuffer = NULL;

int main(int argc, char* argv[])
{
    // initialize the DSPLink system
    tcCL_IPCInit::GetInstance();

    // Launch an initialization task
       TSK_Attrs* lpAttrs = new TSK_Attrs;
    *lpAttrs           = TSK_ATTRS;
    lpAttrs->name      = "Initialize";
    lpAttrs->stacksize = 8192*2;
    lpAttrs->priority  = 5;
       TSK_create((Fxn)init,lpAttrs);

    return 0;
}

void init()
{
    // Message to ARM core.
    char lpReturnMessage[] = "DSP Initialization finished.";

    // Create the inbound link for messages to the DSP
       gpInbound = new tcCL_IPCInbound();

       gpInbound->Open("DSPMSGQ0", 8);

    // Create the outbound controller for sending messages to the ARM
       gpOutbound = new tcCL_IPCOutbound("GPPMSGQ1");

    if (NULL != gpInbound)
    {
        // Register a callback function to handle messages from the ARM
           gpInbound->RegisterCallback(handleInboundMessage, (void*)NULL);
    }

    // Obtain a dsplink buffer for the return message
    glpMessageBuffer = (char*)gpOutbound->GetBuffer(BUFF_SIZE_PC);

    // Make sure we received a valid buffer
    if (NULL != glpMessageBuffer)
    {
        memcpy(glpMessageBuffer, lpReturnMessage, strlen(lpReturnMessage)+1);

        // Send the message back to the ARM
        gpOutbound->SendMessage(glpMessageBuffer);
    }
}

int handleInboundMessage(void* apBuffer, uint32_t anLength, void* apUserArg)
{
    int retval = 0;

    char *data = new char[BUFF_SIZE_PC]();
    memcpy(data, apBuffer, BUFF_SIZE_PC);
//    gpInbound->ReturnBuffer(apBuffer);

    memcpy(glpMessageBuffer, data, BUFF_SIZE_PC);

        // Send the message back to the ARM
    retval = gpOutbound->SendMessage(glpMessageBuffer) ? 0 : -1;

    delete []data;

    return retval;
}

They often fail. How to fix it?

Thanks!