cwDnsSd, dns_sd/ : Updates to integrate Arduino version with Linux version.

cwDnsSd.cpp

@@ -145,7 +145,7 @@ namespace cw
 
         if( dataByteCnt > 0 )
         {
-          p->fdr->receive( data, dataByteCnt );  
+          p->fdr->receive_from_eucon( data, dataByteCnt );  
         }
 
         time::spec_t t1;
@@ -166,6 +166,12 @@ namespace cw
         }
       }
 
+      // Called by 'fader' to send messages to change the state of the physical control.
+      void physControlCallback( void* arg, const uint8_t* buf, uint8_t bufByteN )
+      {
+      }
+
+
       void _pushTextRecdField( dnssd_t* p, const char* text )
       {
         text_t* t = mem::allocZ<text_t>();
@@ -234,7 +240,7 @@ namespace cw
         p->dnsSd = new dns_sd(udpSendCallback,p,print_callback);
         
         // create the Surface logic object
-        p->fdr   = new fader(print_callback, p->hostMac, hostAddr.sin_addr.s_addr, tcpSendCallback, p, p->ticksPerHeartBeat );
+        p->fdr   = new fader(print_callback, p->hostMac, hostAddr.sin_addr.s_addr, tcpSendCallback, p, physControlCallback, p, p->ticksPerHeartBeat );
   
         // Setup the internal dnsSd object
         p->dnsSd->setup( p->serviceName, p->serviceType, p->serviceDomain, p->hostName, hostAddr.sin_addr.s_addr, p->hostPort, formatStr );
@@ -255,6 +261,7 @@ cw::rc_t cw::net::dnssd::createV(  handle_t& hRef, const char* name, const char*
   rc_t        rc              = kOkRC;
   unsigned    udpRecvBufByteN = 4096;
   unsigned    udpTimeOutMs    = 50;
+  unsigned    tcpRecvBufByteN = 4096;
   unsigned    tcpTimeOutMs    = 50;
   
   if((rc = destroy(hRef)) != kOkRC )
@@ -287,6 +294,8 @@ cw::rc_t cw::net::dnssd::createV(  handle_t& hRef, const char* name, const char*
   if((rc = set_multicast_time_to_live( socketHandle(p->udpH), 255 )) != kOkRC )
     goto errLabel;
 
+  p->tcpRecvBufByteN = tcpRecvBufByteN;
+  
   // create the service TCP socket server
   if((rc = srv::create(
         p->tcpH,

dns_sd/dns_sd.cpp

@@ -7,7 +7,8 @@
 #endif
 
 #ifdef ARDUINO
-#include <utility/util.h>
+#include <Ethernet.h>
+#include <utility/w5100.h>
 #endif
 
 #include "rpt.h"

dns_sd/dns_sd_print.cpp

@@ -1,11 +1,13 @@
 #include <stdio.h>
 #include <stdint.h>
 #include <stdarg.h>
+
 #ifdef cwLINUX
 #include <arpa/inet.h>
 #endif
 #ifdef ARDUINO
-#include <utility/util.h>
+#include <Ethernet.h>
+#include <utility/w5100.h>
 #endif
 
 #include "rpt.h"

dns_sd/fader.cpp

@@ -11,33 +11,51 @@
 #endif
 
 #ifdef ARDUINO
-#include <utility/util.h>
+#include <Ethernet.h>
+#include <utility/w5100.h>
 #endif
 
 fader::msgRef_t fader::_msgRefA[] =
 {
- { 0x0a,   88 },
+ { 0x0a,   88 }, // initial handshake 
- { 0x0c,    6 },
+ { 0x0c,    4 }, // secondary handshake
- { 0x00,    8 },
+ { 0x00,    8 }, // 
- { 0x19, 1044 },
+ { 0x19, 1044 }, // 0x19 messages are variable length 
- { 0x04,    4 },
+ { 0x04,    4 }, // 
  { 0xff,    0 }  // end-of-list sentinel (both id and byteN are invalid)
 };
 
-fader::fader( printCallback_t printCbFunc, const unsigned char faderMac[6], uint32_t faderInetAddr, hostCallback_t hostCbFunc, void* hostCbArg, unsigned ticksPerHeartBeat, unsigned chN )
+fader::fader(
-  : _printCbFunc(printCbFunc), _inetAddr(faderInetAddr),_tickN(0),_chArray(nullptr),_hostCbFunc(hostCbFunc),_hostCbArg(hostCbArg),_protoState(kWaitForHandshake_0_Id),_ticksPerHeartBeat(ticksPerHeartBeat),_msgTypeId(0xff),_msgByteIdx(0),_msgByteN(0)
+  printCallback_t     printCbFunc,
+  const unsigned char faderMac[6],
+  uint32_t            faderInetAddr,
+  euConCbFunc_t       euconCbFunc,
+  void*               euconCbArg,
+  physCtlCbFunc_t     physCtlCbFunc,
+  void*               physCtlCbArg,
+  unsigned            ticksPerHeartBeat,
+  unsigned            chN )
+  : _printCbFunc(printCbFunc),
+    _inetAddr(faderInetAddr),
+    _tickN(0),
+    _chArray(nullptr),
+    _euconCbFunc(euconCbFunc),
+    _euconCbArg(euconCbArg),
+    _physCtlCbFunc(physCtlCbFunc),
+    _physCtlCbArg(physCtlCbArg),
+    _protoState(kWaitForHandshake_0_Id),
+    _ticksPerHeartBeat(ticksPerHeartBeat),
+    _msgTypeId(0xff),
+    _msgByteIdx(0),
+    _msgByteN(0),
+    _mbi(0)
 {
   memcpy(_mac,faderMac,6);
   
   _chArray = new ch_t[chN];
   _chN     = chN;
-  for(unsigned i=0; i<chN; ++i)
+
-  {
+  reset();
-    _chArray[i].position = 0;
-    _chArray[i].muteFl   = false;
-    _chArray[i].incrFl   = true;
-    _chArray[i].touchFl  = false;    
-  }
 }
 
 fader::~fader()
@@ -45,102 +63,120 @@ fader::~fader()
   delete[] _chArray;
 }
 
-
+void fader::reset()
-
-fader::rc_t fader::receive( const void* buf, unsigned bufByteN )
 {
+  _protoState = kWaitForHandshake_0_Id;
+  _msgTypeId  = 0xff;
+  _msgByteIdx = 0;
+  _msgByteN   = 0;
+  _mbi        = 0;
+  
+  for(unsigned i=0; i<_chN; ++i)
+  {
+    _chArray[i].position = 0;
+    _chArray[i].muteFl   = false;
+    _chArray[i].touchFl  = false;    
+  }
+  
+}
+
+fader::rc_t fader::receive_from_eucon( const void* buf, unsigned bufByteN )
+{
+  
   rc_t           rc   = kOkRC;  
   const uint8_t* b    = (const uint8_t*)buf; // current msg ptr
   const uint8_t* bend = b + bufByteN; // end of buffer ptr    
 
-  printf("RECV:%i\n",bufByteN);
-  
   while(b<bend)
   {
     // if this is the start of a new msg
     if( _msgByteN == 0 )
     {
-      // store the size and type of this message
+      // if this is an 0x19 msg which started on the previous packet
-      _msgTypeId  = b[0];
+      if( _msgTypeId == 0x19 )
-      _msgByteN   = _get_msg_byte_count( _msgTypeId );
+      {
-      _msgByteIdx = 0;
+        // if not already filled
+        for(int i=0; (_msgByteIdx+i < 8) && ((b+i)<bend); ++i)
+          _msg[_msgByteIdx+i] = b[i];
+
+        // get the count of bytes associated with this 0x19 msg
+        _msgByteN = _get_eucon_msg_byte_count( _msgTypeId, _msg, _msg+8 );
+
+        //rpt(_printCbFunc,"0x19 end: %i\n",_msgByteN);
+        
+      }
+      else
+      {
+        
+        _msgTypeId  = b[0];   // the first byte always contains the type of the msg
+        _msgByteIdx = 0;      // empty the _msg[] index
+        _msgByteN   = _get_eucon_msg_byte_count( _msgTypeId, b, bend  ); // get the length of this mesg
+
+        // if this is a type 0x19 msg then we have to wait 8 bytes for the msg byte count
+        if( _msgByteN == 0 && _msgTypeId == 0x19 )
+        {
+          //_printCbFunc("0x19 begin\n");
+          _msgByteIdx = bend - b; 
+          break;          
+        }        
       }
       
-    // if this is a channel message 
+      // store the size and type of this message
-    if( _msgTypeId == 0 )
+ 
+      if( _msgByteN == 0 && _msgTypeId != 0x19 )
       {
-      for(int i=0; _msgByteIdx < sizeof(_msg) && b+i<bend; ++i,++_msgByteIdx)
+        rpt(_printCbFunc,"Unk Type:0x%x %i\n",_msgTypeId,bufByteN);
-        _msg[_msgByteIdx] = b[i];
+        break;
+      }
+
+      //rpt(_printCbFunc,"T:0x%x %i\n",_msgTypeId,_msgByteN);
+    }
+
+    // if this is a channel message or the start of a 0x19 msg  ...
+    if( _msgTypeId == 0 || (_msgTypeId == 0x19 && _msgByteN==0) )
+    {
+      // copy it into _msg[]
+      for(int i=0; (_msgByteIdx+i < 8) && ((b+i)<bend); ++i)
+        _msg[_msgByteIdx+i] = b[i];
     }
 
     // if the end, (and possibly the beginning) of the current msg is fully contained in the buffer ...
-    if( (_msgByteN - _msgByteIdx) <= (bend-b) )
+    if( (_msgByteN - _msgByteIdx) <= (bend - b) )
     {
-      _on_msg_complete(_msgTypeId);
+      _on_eucon_recv_msg_complete(_msgTypeId);
       b          += _msgByteN - _msgByteIdx;    // then we have reached the end of the msg
       _msgByteN   = 0;
       _msgByteIdx = 0;
+      _msgTypeId  = 0xff;
     }
     else  // this msg overflows to the next TCP packet
     {
-      _msgByteIdx += bend-b;
+      //_printCbFunc("Ovr:\n");
+      _msgByteIdx += bend - b;
       b            = bend;
     }
   }
+  //rpt(_printCbFunc,"D:\n");
   return rc;
 }
 
 
-fader::rc_t fader::receive_old( const void* buf, unsigned bufByteN )
-{
-  rc_t rc = kOkRC;
-  const uint8_t* b = (const uint8_t*)buf;
-
-  switch( _protoState )
-  {
-    case kWaitForHandshake_0_Id:        // wait for [ 0x0a ... ]
-      if( bufByteN>0 && b[0] == 10 )
-      {
-        _printCbFunc("HS 0 ");
-        _send_response_0();             // send [ 0x0b ... ] 
-        _protoState = kWaitForHandshake_Tick_Id;
-      }
-      break;
-
-    case kWaitForHandshake_Tick_Id:     // wait for next tick() - send first heart-beat
-      break;
-      
-    case kWaitForHandshake_1_Id:        // wait for next message after heart-beat - send [ 0x0d, .... ]
-      _printCbFunc("HS 1 ");
-      _send_response_1();
-      _protoState = kWaitForHeartBeat_Id;
-      break;
-      
-    case kWaitForHeartBeat_Id:
-      break;
-  }
-  return rc;  
-}
 
 fader::rc_t   fader::tick()
 {
   rc_t rc = kOkRC;
+  
   switch( _protoState )
   {      
-    case kWaitForHandshake_0_Id:
-      break;
-      
     case kWaitForHandshake_Tick_Id:
-      _printCbFunc("HS Tick ");
+      //_printCbFunc("HS Tick ");
-      _send_heartbeat();
+      _send_heartbeat_to_eucon();
       _protoState = kWaitForHandshake_1_Id;
       break;
       
+    case kWaitForHandshake_0_Id:
     case kWaitForHandshake_1_Id:
-      break;
-      
     case kWaitForHeartBeat_Id:
-      //_auto_incr_fader(0);
       break;
   }
 
@@ -149,40 +185,63 @@ fader::rc_t   fader::tick()
   {
     _tickN = 0;
     if( _protoState == kWaitForHeartBeat_Id )
-      _send_heartbeat();
+      _send_heartbeat_to_eucon();
   }
   
   return rc;
 }
 
-fader::rc_t     fader::physical_fader_touched(  uint16_t chanIdx )
+
+void fader::physical_control_changed( const uint8_t msg[3] )
 {
-  (void)chanIdx;
+
-  return kOkRC;
+  // TODO: mask off invalid values (e.g. chan>7, value>0x3ff)
+  
+  uint8_t  type  = (msg[0] & 0x70) >> 4;
+  uint8_t  chan  = (msg[0] & 0x0f);
+  uint16_t value = msg[1];
+
+  value <<= 7;
+  value += msg[2];
+
+  rpt(_printCbFunc,"T:%i Ch:%i V:%x\n",type,chan,value);
+  
+  
+  switch( type )
+  {
+    case kPhysTouchTId:
+      _send_touch_to_eucon(chan,value != 0);
+      break;
+      
+    case kPhysFaderTId:
+      _send_fader_to_eucon(chan,value);
+      break;
+      
+    case kPhysMuteTId:
+      _send_mute_to_eucon(chan,value == 0);
+      break;
+
+    default:
+      rpt(_printCbFunc,"Unknown physical ctl id.");
+  }
+  
+    
 }
 
-fader::rc_t     fader::physical_fader_moved( uint16_t chanIdx, uint16_t value )
+void     fader::_send_to_eucon( const void* buf, unsigned bufByteN )
 {
-  (void)chanIdx;
+  return _euconCbFunc(_euconCbArg,buf,bufByteN);
-  (void)value;
-  return kOkRC;
 }
 
-fader::rc_t     fader::physical_mute_switched(  uint16_t chanIdx, uint16_t value )
-{
-  (void)chanIdx;
-  (void)value;
-  return kOkRC;
-}
   
-void     fader::_send_response_0()
+void     fader::_send_response_0_to_eucon()
 {
   unsigned char buf[] =
     { 0x0b,0x00,0x00,0x00,0x00,0x00,0x00,0x50,0x00,0x02,0x03,0xfc,0x01,0x05,
       0x06,0x00,
-      0x38,0xc9,0x86,0x37,0x44,0xe7,  // mac: offset 16
+      0x00,0x00,0x00,0x00,0x00,0x00,  // mac: offset 16
       0x01,0x00,
-      0xc0,0xa8,0x00,0x44,            // ip: offset 24
+      0x00,0x00,0x00,0x00,            // ip: offset 24
       0x00,0x00,
       0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
       0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
@@ -190,98 +249,69 @@ void     fader::_send_response_0()
       0x00,0x00
     };
 
+  // set the mac address
   memcpy(buf+16,_mac,6);
+
+  // set the 32 bit ip address
   memcpy((unsigned char *)(buf+24),(unsigned char*)&_inetAddr, 4);
 
-  _send(buf,sizeof(buf));  
+  _send_to_eucon(buf,sizeof(buf));  
 }
 
-void fader::_send_response_1()
+void fader::_send_response_1_to_eucon()
 {
   unsigned char buf[] = { 0x0d,0x00,0x00,0x00, 0x00,0x00,0x00,0x08 };
 
-  _send(buf,sizeof(buf));    
+  _send_to_eucon(buf,sizeof(buf));    
 }
 
 
-void     fader::_send_heartbeat()
+void     fader::_send_heartbeat_to_eucon()
 {
   const unsigned char buf[] = { 0x03, 0x00, 0x00, 0x00 };  
-  _send(buf,sizeof(buf));    
+  _send_to_eucon(buf,sizeof(buf));    
 }
 
-void     fader::_send( const void* buf, unsigned bufByteN )
+
+void     fader::_send_fader_to_eucon( uint16_t chIdx, uint16_t pos )
 {
-  return _hostCbFunc(_hostCbArg,buf,bufByteN);
+  _chArray[chIdx].position = pos;
+  if( _chArray[chIdx].touchFl )
+  {
+    uint16_t buf[] = { htons(chIdx),htons(0), 0, htons(pos) };
+    _send_to_eucon(buf,sizeof(buf));
+  }
 }
 
-void     fader::_on_fader_receive( uint16_t chanIdx, uint16_t value )
+void     fader::_send_touch_to_eucon( uint16_t chIdx, uint16_t touchFl )
-{
-  (void)chanIdx;
-  (void)value;  
-}
-
-void     fader::_on_mute_receive(  uint16_t chanIdx, bool value )
-{
-  (void)chanIdx;
-  (void)value;
-}
-
-void     fader::_send_fader( uint16_t chIdx )
-{
-  uint16_t buf[] = { htons(chIdx),htons(0), 0, htons(_chArray[chIdx].position) };
-  _send(buf,sizeof(buf));    
-}
-
-void     fader::_send_touch( uint16_t chIdx, bool touchFl )
 {
   _chArray[chIdx].touchFl = touchFl; 
   uint16_t buf[] = { htons(chIdx),htons(1),0, htons((uint16_t)touchFl) };
-  _send(buf,sizeof(buf));    
+  _send_to_eucon(buf,sizeof(buf));    
 }
 
-void    fader::_send_mute( uint16_t chIdx, bool muteFl )
+void    fader::_send_mute_to_eucon( uint16_t chIdx, uint16_t muteFl )
 {
   _chArray[chIdx].muteFl = muteFl; 
   uint16_t buf[] = { htons(chIdx),htons(0x200),0, htons((uint16_t)(!muteFl)) };
-  _send(buf,sizeof(buf));    
+  _send_to_eucon(buf,sizeof(buf));    
 }
 
-
+uint16_t fader::_get_eucon_msg_byte_count( uint8_t msgTypeId, const uint8_t* b, const uint8_t* bend   )
-void     fader::_auto_incr_fader( uint16_t chIdx )
 {
-  ch_t* ch = _chArray+chIdx;
+  if( msgTypeId == 0x19 )
-
-  if( ch->position == 0 && ch->touchFl==false )
   {
-    _send_touch(chIdx,true);
+    const uint16_t* u = (const uint16_t*)b;
+    if( bend < (const uint8_t*)(u+4) )
+    {
+      //_printCbFunc("0x19 short\n");
+      return 0;
     }
     
-  if( ch->position > 1023 )
+    uint16_t  v  =  u[3];
-  {
+    return ntohs(v);
-    ch->position = 1023;
-    ch->incrFl   = false;    
-  }
-  else
-  {
-    if( ch->position < 0 )
-    {
-      ch->position = 0;
-      ch->incrFl = true;
-      _send_touch( chIdx, !ch->touchFl );
-      _send_mute( chIdx,  !ch->touchFl  );
-    }
   }
   
-  if( ch->touchFl )
-    _send_fader(chIdx);
-
-  ch->position += ch->incrFl ? 5 : -5;
-  
-}
-
-uint8_t fader::_get_msg_byte_count( uint8_t msgTypeId )
-{
   for(int i=0; _msgRefA[i].byteN != 0; ++i)
     if( msgTypeId == _msgRefA[i].id )
       return _msgRefA[i].byteN;
@@ -289,12 +319,20 @@ uint8_t fader::_get_msg_byte_count( uint8_t msgTypeId )
   return 0;
 }
 
-void fader::_handleChMsg(const uint8_t* msg)
+void fader:: _send_to_phys_control( uint8_t ctlTypeId, uint8_t ch, uint16_t value )
 {
+  uint8_t msg[3];
+
+  msg[0] = 0x80 + (ctlTypeId << 4) + (ch);   // status byte always has high bit set
+  msg[1] = (uint8_t)((value & 0x3f80) >> 7); // get high 7 bits of value (high bit is always cleared)
+  msg[2] = (uint8_t)(value  & 0x007f);       // get low 7 bits of value (high bit is always cleared)
+
+  _physCtlCbFunc( _physCtlCbArg, msg, sizeof(msg) );
 }
 
+
 // called when a new msg is received, b[0] is the msg type id
-void fader::_on_msg_complete( const uint8_t typeId )
+void fader::_on_eucon_recv_msg_complete( const uint8_t typeId )
 {
   switch( typeId )
   {
@@ -302,21 +340,48 @@ void fader::_on_msg_complete( const uint8_t typeId )
       if( _protoState == kWaitForHandshake_0_Id )
       {
         _printCbFunc("HS 0 ");
-        _send_response_0();     // send [ 0x0b ... ] 
+        _send_response_0_to_eucon();     // send [ 0x0b ... ] 
         _protoState = kWaitForHandshake_Tick_Id;
       }
       break;
       
     case 0x0c:
+      //rpt(_printCbFunc,"HB\n");
       break;
       
     case 0x00:
+      {
+        const uint16_t* u = (const uint16_t*)_msg;
+        uint8_t ch = _msg[1];
+        if( ch < 8 )
+        {
+          switch( ntohs(u[1]) )
+          {
+            case 0:
+              _chArray[ch].position = ntohs(u[3]);     
+              //rpt(_printCbFunc,"F: %2i %4i \n",(int)_msg[1],ntohs(u[3]));
+              _send_to_phys_control(kPhysFaderTId,ch,ntohs(u[3]));
+              
+              break;
+              
+            case 0x201:
+              _chArray[ch].muteFl = ntohs(u[3]);
+              //rpt(_printCbFunc,"M: %2i %4i \n",(int)_msg[1],ntohs(u[3]));
+              _send_to_phys_control(kPhysMuteTId,ch,ntohs(u[3]));
+              break;
+
+          }            
+        }
+        
+      }
       break;
       
     case 0x04:
+      //rpt(_printCbFunc,"HB:\n");
       break;
       
     case 0x19:
+      //rpt(_printCbFunc,"Skip:\n");
       break;
       
     default:
@@ -327,8 +392,8 @@ void fader::_on_msg_complete( const uint8_t typeId )
   // kWaitForHandshake_1_Id to kWaitForHeartBeat_Id
   if( _protoState == kWaitForHandshake_1_Id )
   {
-    _printCbFunc("HS 1 ");
+    _printCbFunc("HS 1\n ");
-    _send_response_1(); //send [ 0x0d, .... ]
+    _send_response_1_to_eucon(); //send [ 0x0d, .... ]
     _protoState = kWaitForHeartBeat_Id;
   }
   

dns_sd/fader.h

@@ -2,17 +2,6 @@
 #define fader_h
 
 
-/*
-1. wait for 0x0a packet
-   send_response_0()
-   wait 50 ms
-   send_heart_beat()
-2. wait for next host packet
-   send_response_1()
-
- */
-
-
 class fader
 {
 public:
@@ -23,27 +12,39 @@ public:
    kUnknownMsgRC
   } rc_t;
 
-  // Function to send TCP messages to the host.
+  // Callback function to send TCP messages to the EuCon.
-  typedef void (*hostCallback_t)( void* arg, const void* buf, unsigned bufByteN );
+  typedef void (*euConCbFunc_t)(   void* arg, const void* buf, unsigned bufByteN );
+  
+  // Callback function to send virtual control change messages to the physical controls.
+  typedef void (*physCtlCbFunc_t)( void* arg, const uint8_t* buf, uint8_t bufByteN );
+  
+  fader(
+    printCallback_t     printCbFunc,
+    const unsigned char faderMac[6],
+    uint32_t            faderInetAddr,
+    euConCbFunc_t       euConCbFunc,
+    void*               euConCbArg,
+    physCtlCbFunc_t     physCtlCbFunc,
+    void*               physCtlCbArg,
+    unsigned            ticksPerHeartBeat,
+    unsigned            chN = 8 );
   
-  fader( printCallback_t printCbFunc, const unsigned char faderMac[6], uint32_t faderInetAddr, hostCallback_t hostCbFunc, void* cbArg, unsigned ticksPerHeartBeat, unsigned chN = 8 );
   virtual ~fader();
 
+  void reset();
+
   // Called by the TCP receive function to update the faders state
-  // based on host state changes.
+  // based on EuCon state changes.
   // Return kUnknownMsgRC if the received msg is not recognized.
-  rc_t   receive( const void* buf, unsigned bufByteN );  
+  rc_t   receive_from_eucon( const void* buf, unsigned bufByteN );  
-  rc_t   receive_old( const void* buf, unsigned bufByteN );  
 
   // Called by the application to drive time dependent functions.
   // Return kTimeOut if the protocol state machine has timed out.
   rc_t   tick();
 
-  // Call these function to generate messages to the host when 
+  // Call when a physical control changes value.
-  // the controls physical state changes.
+  void   physical_control_changed( const uint8_t msg[3] );
-  rc_t   physical_fader_touched( uint16_t chIdx );
+  
-  rc_t   physical_fader_moved(   uint16_t chIdx, uint16_t newPosition );  
-  rc_t   physical_mute_switched( uint16_t chIdx, uint16_t newMuteFl );
   
   rc_t   virtual_fader_moved(   uint16_t chIdx, uint16_t newPosition );  
   rc_t   virtual_mute_switched( uint16_t chIdx, uint16_t newMuteFl );
@@ -57,19 +58,26 @@ private:
    kWaitForHeartBeat_Id
   } protoState_t;
 
+  enum
+  {
+   kPhysTouchTId = 0,
+   kPhysFaderTId = 1,
+   kPhysMuteTId  = 2 
+  };
+  
+
   typedef struct
   {
     int16_t  position;    
-    bool     muteFl;
+    int16_t  muteFl;
-    bool     incrFl;
+    int16_t  touchFl;
-    bool     touchFl;
    
   } ch_t;
 
   typedef struct
   {
     uint16_t id;    // message prefix - identifies the type of message
-    uint16_t byteN; // length of the message in bytes
+    int      byteN; // length of the message in bytes
   } msgRef_t;
 
   static msgRef_t _msgRefA[];
@@ -80,32 +88,35 @@ private:
   unsigned        _tickN;
   ch_t*           _chArray;
   unsigned        _chN;
-  hostCallback_t _hostCbFunc;
+  euConCbFunc_t   _euconCbFunc;
-  void*          _hostCbArg;
+  void*           _euconCbArg;
+  physCtlCbFunc_t _physCtlCbFunc;
+  void*           _physCtlCbArg;
+  
   protoState_t   _protoState;
   unsigned char  _mac[6];
   unsigned       _ticksPerHeartBeat;
 
-  uint8_t       _msgTypeId;     //
+  uint8_t       _msgTypeId;     // first byte of the current TCP message
-  unsigned      _msgByteIdx;    // current index into the message being parsed.
+  int           _msgByteIdx;    // current index into the TCP message being parsed.
-  unsigned      _msgByteN;      // count of bytes in the message currently being parsed
+  int           _msgByteN;      // count of bytes in the message currently being parsed
-  unsigned char _msg[8];        //
+  unsigned      _mbi;
+  unsigned char _msg[8];        // hold the last 8 bytes of the current incoming TCP messages
+                                // (we need these bytes when waiting to determine the length of '0x19' type messages)
 
-  void     _send_response_0();
+  void     _send_to_eucon( const void* buf, unsigned bufByteN );
-  void     _send_response_1();
+  
-  void     _send_heartbeat();
+  void     _send_response_0_to_eucon();
-  void     _send( const void* buf, unsigned bufByteN );
+  void     _send_response_1_to_eucon();
-  void     _on_fader_receive( uint16_t chanIdx, uint16_t position );
+  void     _send_heartbeat_to_eucon();  
-  void     _on_mute_receive(  uint16_t chanIdx, bool     muteFl );
+  void     _send_fader_to_eucon( uint16_t chIdx, uint16_t position );
-  void     _send_fader( uint16_t chIdx );
+  void     _send_touch_to_eucon( uint16_t chIdx, uint16_t touchFl );
-  void     _send_touch( uint16_t chIdx, bool touchFl );
+  void     _send_mute_to_eucon( uint16_t chIdx, uint16_t muteFl );
-  void     _send_mute( uint16_t chIdx, bool muteFl );
-  void     _auto_incr_fader( uint16_t chIdx );
 
 
-  uint8_t _get_msg_byte_count( uint8_t msgTypeId );
+  uint16_t _get_eucon_msg_byte_count( uint8_t msgTypeId, const uint8_t* b, const uint8_t* bend );
-  void    _handleChMsg(const uint8_t* msg);
+  void     _send_to_phys_control( uint8_t ctlTypeId, uint8_t ch, uint16_t value );
-  void    _on_msg_complete( const uint8_t typeId );
+  void     _on_eucon_recv_msg_complete( const uint8_t typeId );
   
   
 };

dns_sd/rpt.cpp

@@ -3,15 +3,16 @@
 
 #include "rpt.h"
 
+#define RPT_BUF_N 64
+char RPT_BUF[ RPT_BUF_N ];
+
 void vrpt( printCallback_t printCbFunc, const char* fmt, va_list vl )
 {
   if( printCbFunc != nullptr )
   {
-    const int bufN = 32;
+    vsnprintf(RPT_BUF,RPT_BUF_N,fmt,vl);
-    char buf[bufN];
+    RPT_BUF[RPT_BUF_N-1] = '\0';
-    vsnprintf(buf,bufN,fmt,vl);
+    printCbFunc(RPT_BUF);
-    buf[bufN-1] = '\0';
-    printCbFunc(buf);
   }
 }