cmAudDsp.h/c, cmAudioSys.h/c, cmDspSys.h/c, cmDspNet.h : Added support for serial port.

cmAudDsp.c

 #include "cmApBuf.h"
 #include "cmMidi.h"
 #include "cmMidiPort.h"
+#include "cmSerialPort.h"
 #include "dsp/cmDspValue.h"
 #include "cmMsgProtocol.h"
 #include "cmThread.h"
   unsigned           msgsPerClientPoll;
   const cmChar_t*    dfltProgramLabel;
 
+  char*              serialDeviceStr;
+  unsigned           serialBaud;
+  unsigned           serialCfgFlags;
+  unsigned           serialPollPeriodMs;
+  cmSeH_t            serialPortH;
+
   cmAdAggDev_t*      aggDevArray;
   unsigned           aggDevCnt;
 
   cmJsonNode_t*   nrtDevArrNodePtr = NULL;
   cmJsonNode_t*   afpDevArrNodePtr = NULL;
   cmJsonNode_t*   audDspNodePtr    = NULL;
+  cmJsonNode_t*   serialNodePtr    = NULL;
   const cmChar_t* errLabelPtr      = NULL;
   unsigned        i;
   cmJsRC_t      jsRC = kOkJsRC;
         "aggDevArray",        kArrayTId  | kOptArgJsFl, &aggDevArrNodePtr,
         "nrtDevArray",        kArrayTId  | kOptArgJsFl, &nrtDevArrNodePtr,
         "afpDevArray",        kArrayTId  | kOptArgJsFl, &afpDevArrNodePtr,
+        "serial",             kObjectTId | kOptArgJsFl, &serialNodePtr,
         NULL )) != kOkJsRC )
   {
     rc = _cmAdParseMemberErr(p, jsRC, errLabelPtr, "aud_dsp" );
     goto errLabel;
   }
 
+  // parse the serial port cfg
+  if( serialNodePtr != NULL )
+  {
+    if(( jsRC      = cmJsonMemberValues( serialNodePtr, &errLabelPtr, 
+          "device",           kStringTId, &p->serialDeviceStr,
+          "baud",             kIntTId,    &p->serialBaud,
+          "flags",            kIntTId,    &p->serialCfgFlags,
+          "pollPeriodMs",     kIntTId,    &p->serialPollPeriodMs,
+          NULL )) != kOkJsRC )
+    {
+      rc = _cmAdParseMemberErr(p, jsRC, errLabelPtr, "serial" );
+      goto errLabel;
+    }
+  }
+
   // parse the aggregate device specifications into p->aggDevArray[].
   if( aggDevArrNodePtr != NULL && (p->aggDevCnt = cmJsonChildCount(aggDevArrNodePtr)) > 0)
   {
   return rc;
 }
 
+cmAdRC_t _cmAdCreateSerialPort( cmAd_t* p )
+{
+  cmAdRC_t rc = kOkAdRC;
+  
+  if( p->serialDeviceStr != NULL )
+  {
+    p->serialPortH = cmSeCreate( &p->ctx, &p->serialPortH, p->serialDeviceStr, p->serialBaud, p->serialCfgFlags, NULL, NULL, p->serialPollPeriodMs );
+    
+    if( !cmSeIsOpen(p->serialPortH) )
+    {
+      rc = cmErrMsg(&p->err,kSerialDevCreateFailAdRC,"The serial device '%s' creation failed.",cmStringNullGuard(p->serialDeviceStr));
+    }
+  }
+  return rc;
+}
+
 cmAdRC_t _cmAdCreateAggDevices( cmAd_t* p )
 {
   cmAdRC_t rc = kOkAdRC;
     goto errLabel;
   }
 
+  if( cmSeIsOpen(p->serialPortH) )
+  {    
+    if( cmSeDestroy(&p->serialPortH) != kOkSeRC )
+    {
+      rc = cmErrMsg(&p->err,kSerialPortFailAdRC,"Serial port finalize failed.");
+      goto errLabel;      
+    }
+  }
+  
   if( cmMpIsInitialized() )
     if( cmMpFinalize() != kOkMpRC )
     {
     goto errLabel;
   }
 
+  // create the serial port
+  if( _cmAdCreateSerialPort(p) != kOkAdRC )
+  {
+    rc = cmErrMsg(&p->err,kSerialPortFailAdRC,"The MIDI system initialization failed.");
+    goto errLabel;
+  }
+  
   // initialize the MIDI system
   if( cmMpInitialize(ctx,NULL,NULL,p->midiPortBufByteCnt,"app") != kOkMpRC )
   {
     goto errLabel;
 
   // initialize the DSP system
-  if( cmDspSysInitialize(ctx,&p->dsH,p->netH) )
+  if( cmDspSysInitialize(ctx,&p->dsH,p->netH,p->serialPortH) )
   {
     rc = cmErrMsg(&p->err,kDspSysFailAdRC,"The DSP system initialization failed.");
     goto errLabel;
       {
         // ... and allocate additional DSP systems when more than one sub-sys is 
         // defined in the audio system configuration
-        if( cmDspSysInitialize(&p->ctx,&dsH,p->netH) != kOkDspRC )
+        if( cmDspSysInitialize(&p->ctx,&dsH,p->netH,p->serialPortH) != kOkDspRC )
         {
           rc = cmErrMsg(&p->err,kDspSysFailAdRC,"Unable to initialize an additional DSP system.");
           goto errLabel;

cmAudDsp.h

     kAudioPortFailAdRC,
     kAudioSysFailAdRC,
     kMidiSysFailAdRC,
+    kSerialPortFailAdRC,
     kDspSysFailAdRC,
     kFileSysFailAdRC,
     kJsonFailAdRC,
     kNoPgmLoadedAdRC,
     kInvalidSubSysIdxAdRC,
     kUnknownMsgTypeAdRC,
+    kSerialDevCreateFailAdRC,
     kAggDevSysFailAdRC,
     kAggDevCreateFailAdRC,
     kNrtDevSysFailAdRC,

cmAudioSys.c

 #include "cmThread.h"
 #include "cmUdpPort.h"
 #include "cmUdpNet.h"
+#include "cmSerialPort.h"
 #include "cmAudioSysMsg.h"
 #include "cmAudioSys.h"
 #include "cmMidi.h"
   cmTsMp1cH_t        htdQueueH; // host-to-dsp thread safe msg queue
   cmThreadMutexH_t   engMutexH; // thread mutex and condition variable
   cmUdpNetH_t        netH;
+  cmSeH_t            serialPortH; 
   bool               enableFl;  // application controlled pause flag
   bool               runFl;     // false during finalization otherwise true
   bool               statusFl;  // true if regular status notifications should be sent
 
 }
 
+void _cmAudioSysSerialPortCallback( void* cbArg, const void* byteA, unsigned byteN )
+{
+  //_cmAsCfg_t* p (_cmAsCfg_t*)cbArg;
+  
+  // TODO: handle serial receive
+}
+
 cmAsRC_t cmAudioSysAllocate( cmAudioSysH_t* hp, cmRpt_t* rpt, const cmAudioSysCfg_t* cfg )
 {
   cmAsRC_t rc;
     cp->iMeterArray      = cmMemAllocZ( double, cp->status.iMeterCnt );
     cp->oMeterArray      = cmMemAllocZ( double, cp->status.oMeterCnt );
     cp->netH             = cfg->netH;
+    cp->serialPortH      = cfg->serialPortH;
 
     // create the audio System thread
     if((rc = cmThreadCreate( &cp->threadH, _cmAsThreadCallback, cp, ss->args.rpt )) != kOkThRC )
         goto errLabel;
       }
 
+    // install the serial port 
+    if( cmSeIsOpen(cp->serialPortH) )
+    {
+      if( cmSeSetCallback(cp->serialPortH, _cmAudioSysSerialPortCallback, cp ) != kOkSeRC )
+      {
+        rc = _cmAsError(p,kSerialPortFailAsRC,"Serial port callback installation failed.");
+        goto errLabel;        
+      }
+    }
+
     // setup the sub-system status notification 
     cp->statusUpdateSmpCnt = floor(cmApBufMeterMs() * cp->ss.args.srate / 1000.0 );
     cp->statusUpdateSmpIdx = 0;
       rc = _cmAsError(p,kThreadErrAsRC,"Thread start failed.");
       goto errLabel;
     }
+
+    if( cmSeIsOpen(cp->serialPortH) )
+    {
+      if( cmSeStart( cp->serialPortH ) != kOkSeRC )
+      {
+        rc = _cmAsError(p,kSerialPortFailAsRC,"Serial port start failed.");
+        goto errLabel;        
+      }
+      
+    }
   }
 
 

cmAudioSys.h

     kBufTooSmallAsRC,
     kNoMsgWaitingAsRC,
     kMidiSysFailAsRC,
+    kSerialPortFailAsRC,
     kMsgSerializeFailAsRC,
     kStateBufFailAsRC,
     kInvalidArgAsRC,
     cmTsQueueCb_t         clientCbFunc; // Called by  cmAudioSysReceiveMsg() to deliver internally generated msg's to the host. 
                                         //  Set to NULL if msg's will be directly returned by buffers passed to cmAudioSysReceiveMsg().
     cmUdpNetH_t           netH;
+    cmSeH_t               serialPortH;
   } cmAudioSysCfg_t;
 
   extern cmAudioSysH_t cmAudioSysNullHandle;

dsp/cmDspNet.h

     cmDspPresetMgr_t    pm;
     unsigned            nextInstId;
     unsigned            pgmIdx;
+    cmSeH_t             serialPortH;
 
 
     cmUdpNetH_t           netH;          //

dsp/cmDspSys.c

 #include "cmThread.h"
 #include "cmUdpPort.h"
 #include "cmUdpNet.h"
+#include "cmSerialPort.h"
 #include "cmAudioSys.h"
 #include "cmProcObj.h"
 #include "cmDspCtx.h"
   return rc;
 }
 
-cmDspRC_t cmDspSysInitialize( cmCtx_t* ctx, cmDspSysH_t* hp, cmUdpNetH_t netH )
+cmDspRC_t cmDspSysInitialize( cmCtx_t* ctx, cmDspSysH_t* hp, cmUdpNetH_t netH, cmSeH_t serialPortH )
 {
   unsigned        i;
   cmDspRC_t       rc     = kOkDspRC;
 
   cmErrSetup(&p->err,&ctx->rpt,"DSP System");
   //p->ctx.ctx   = asCtx;
-  p->cmCtx     = *ctx;
-  p->netH      = netH;
-  p->pgmIdx    = cmInvalidIdx;
+  p->cmCtx       = *ctx;
+  p->netH        = netH;
+  p->serialPortH = serialPortH;
+  p->pgmIdx      = cmInvalidIdx;
 
   // create the DSP class  linked heap
   if(cmLHeapIsValid( p->lhH = cmLHeapCreate(1024,ctx)) == false)
   return p->ctx.stH;  
 }
 
+cmSeH_t      cmDspSysSerialPort( cmDspSysH_t h )
+{
+  cmDsp_t* p = _cmDspHandleToPtr(h);
+  return p->serialPortH;
+}
+
+
 unsigned     cmDspSysRegisterStaticSymbol( cmDspSysH_t h, const cmChar_t* symLabel )
 { return cmSymTblRegisterStaticSymbol( cmDspSysSymbolTable(h), symLabel ); }
 

dsp/cmDspSys.h

   //  Control Functions
   //
 
-  cmDspRC_t cmDspSysInitialize( cmCtx_t* ctx, cmDspSysH_t* hp, cmUdpNetH_t netH );
+  cmDspRC_t cmDspSysInitialize( cmCtx_t* ctx, cmDspSysH_t* hp, cmUdpNetH_t netH, cmSeH_t serialPortH );
   cmDspRC_t cmDspSysFinalize(  cmDspSysH_t* hp );
   
   bool      cmDspSysIsValid(   cmDspSysH_t h );
   double          cmDspSysSampleRate( cmDspSysH_t h );
   cmJsonH_t       cmDspSysPgmRsrcHandle( cmDspSysH_t h );
   cmSymTblH_t     cmDspSysSymbolTable( cmDspSysH_t h );
+  cmSeH_t         cmDspSysSerialPort( cmDspSysH_t h );
 
   unsigned        cmDspSysRegisterStaticSymbol( cmDspSysH_t h, const cmChar_t* symLabel );
   unsigned        cmDspSysRegisterSymbol( cmDspSysH_t h, const cmChar_t* symLabel );