intermediate, untested: move channel handling out of main

lib/channel/GwChannel.cpp

@@ -52,10 +52,12 @@ class GwChannelMessageReceiver : public GwMessageFetcher{
 
 GwChannel::GwChannel(GwLog *logger,
     String name,
-    int sourceId){
+    int sourceId,
+    int maxSourceId){
     this->logger = logger;
     this->name=name;
     this->sourceId=sourceId;
+    this->maxSourceId=sourceId;
     this->countIn=new GwCounter<String>(String("count")+name+String("in"));
     this->countOut=new GwCounter<String>(String("count")+name+String("out"));
     this->impl=NULL;
@@ -206,8 +208,16 @@ void GwChannel::parseActisense(N2kHandler handler){
     }
 }
 
-void GwChannel::sendActisense(const tN2kMsg &msg){
+void GwChannel::sendActisense(const tN2kMsg &msg, int sourceId){
     if (!enabled || ! impl || ! writeActisense || ! channelStream) return;
+    //currently actisense only for channels with a single source id
+    //so we can check it here
+    if (isOwnSource(sourceId)) return;
     canSendOut(msg.PGN);
     msg.SendInActisenseFormat(channelStream);
 }
+
+bool GwChannel::isOwnSource(int id){
+    if (maxSourceId < 0) return id == sourceId;
+    else return (id >= sourceId && id <= maxSourceId);
+}

lib/channel/GwChannel.h

@@ -26,6 +26,7 @@ class GwChannel{
     GwCounter<String> *countOut=NULL;
     GwChannelInterface *impl;
     int sourceId=0;
+    int maxSourceId=-1;
     GwChannelMessageReceiver *receiver=NULL;
     tActisenseReader *actisenseReader=NULL;
     Stream *channelStream=NULL;
@@ -34,7 +35,8 @@ class GwChannel{
     GwChannel(
         GwLog *logger,
         String name,
-        int sourceId);
+        int sourceId,
+        int maxSourceId=-1);
     void begin(
         bool enabled,
         bool nmeaOut,
@@ -48,7 +50,7 @@ class GwChannel{
     );
 
     void setImpl(GwChannelInterface *impl);
-
+    bool isOwnSource(int id);
     void enable(bool enabled){
         this->enabled=enabled;
     }
@@ -70,6 +72,6 @@ class GwChannel{
     void sendToClients(const char *buffer, int sourceId);
     typedef std::function<void(const tN2kMsg &msg, int sourceId)> N2kHandler ;
     void parseActisense(N2kHandler handler);
-    void sendActisense(const tN2kMsg &msg);
+    void sendActisense(const tN2kMsg &msg, int sourceId);
 };
 

lib/channel/GwChannelList.cpp

@@ -0,0 +1,189 @@
+#include "GwChannelList.h"
+#include "GwApi.h"
+#include "GwHardware.h"
+#include "GwSocketServer.h"
+#include "GwSerial.h"
+#include "GwTcpClient.h"
+class GwSerialLog : public GwLogWriter{
+  static const size_t bufferSize=4096;
+  char *logBuffer=NULL;
+  int wp=0;
+  GwSerial *writer;
+  public:
+    GwSerialLog(GwSerial *writer){
+        this->writer=writer;
+      logBuffer=new char[bufferSize];
+      wp=0;
+    }
+    virtual ~GwSerialLog(){}
+    virtual void write(const char *data){
+      int len=strlen(data);
+      if ((wp+len) >= (bufferSize-1)) return;
+      strncpy(logBuffer+wp,data,len);
+      wp+=len;
+      logBuffer[wp]=0;
+    }
+    virtual void flush(){
+      size_t handled=0;
+      while (handled < wp){
+        writer->flush();
+        size_t rt=writer->sendToClients(logBuffer+handled,-1,true);
+        handled+=rt;
+        }
+      wp=0;
+      logBuffer[0]=0;
+    }
+
+};
+
+
+GwChannelList::GwChannelList(GwLog *logger, GwConfigHandler *config){
+    this->logger=logger;
+    this->config=config;
+}
+void GwChannelList::allChannels(ChannelAction action){
+    for (auto it=theChannels.begin();it != theChannels.end();it++){
+        action(*it);
+    }
+}
+void GwChannelList::begin(bool fallbackSerial){
+    LOG_DEBUG(GwLog::DEBUG,"GwChannelList::begin");
+    GwChannel *channel=NULL;
+    //usb
+    if (! fallbackSerial){
+        GwSerial *usb=new GwSerial(NULL,0,USB_CHANNEL_ID);
+        usb->setup(config->getInt(config->usbBaud),3,1);
+        logger->setWriter(new GwSerialLog(usb));
+        logger->prefix="GWSERIAL:";
+        channel=new GwChannel(logger,"USB",USB_CHANNEL_ID);
+        channel->begin(true,
+            config->getBool(config->sendUsb),
+            config->getBool(config->receiveUsb),
+            config->getString(config->usbReadFilter),
+            config->getString(config->usbWriteFilter),
+            false,
+            config->getBool(config->usbToN2k),
+            config->getBool(config->usbActisense),
+            config->getBool(config->usbActSend)
+        );
+        LOG_DEBUG(GwLog::LOG,"%s",channel->toString().c_str());
+    }
+    //TCP server
+    sockets=new GwSocketServer(config,logger,MIN_TCP_CHANNEL_ID);
+    sockets->begin();
+    channel=new GwChannel(logger,"TCP",MIN_TCP_CHANNEL_ID,MIN_TCP_CHANNEL_ID+10);
+    channel->setImpl(sockets);
+    channel->begin(
+        true,
+        config->getBool(config->sendTCP),
+        config->getBool(config->readTCP),
+        config->getString(config->tcpReadFilter),
+        config->getString(config->tcpWriteFilter),
+        config->getBool(config->sendSeasmart),
+        config->getBool(config->tcpToN2k),
+        false,
+        false
+    );
+    LOG_DEBUG(GwLog::LOG,"%s",channel->toString().c_str());
+    theChannels.push_back(channel);
+
+    //serial 1
+    bool serCanRead=false;
+    bool serCanWrite=false;
+    int serialrx=-1;
+    int serialtx=-1;
+    #ifdef GWSERIAL_MODE
+        #ifdef GWSERIAL_TX
+            serialtx=GWSERIAL_TX;
+        #endif
+        #ifdef GWSERIAL_RX
+            serialrx=GWSERIAL_RX;
+        #endif
+        if (serialrx != -1 && serialtx != -1){
+            serialMode=GWSERIAL_MODE;
+        }
+    #endif
+    //the serial direction is from the config (only valid for mode UNI)
+    String serialDirection=config->getString(config->serialDirection);
+    //we only consider the direction if mode is UNI
+    if (serialMode != String("UNI")){
+        serialDirection=String("");
+        //if mode is UNI it depends on the selection
+        serCanRead=config->getBool(config->receiveSerial);
+        serCanWrite=config->getBool(config->sendSerial);
+    }
+    if (serialDirection == "receive" || serialDirection == "off" || serialMode == "RX") serCanWrite=false;
+    if (serialDirection == "send" || serialDirection == "off" || serialMode == "TX") serCanRead=false;
+    LOG_DEBUG(GwLog::DEBUG,"serial set up: mode=%s,direction=%s,rx=%d,tx=%d",
+        serialMode.c_str(),serialDirection.c_str(),serialrx,serialtx
+        );
+    if (serialtx != -1 || serialrx != -1 ){
+        LOG_DEBUG(GwLog::LOG,"creating serial interface rx=%d, tx=%d",serialrx,serialtx);
+        GwSerial *serial=new GwSerial(logger,1,SERIAL1_CHANNEL_ID,serCanRead);
+        int rt=serial->setup(config->getInt(config->serialBaud,115200),serialrx,serialtx);
+        LOG_DEBUG(GwLog::LOG,"starting serial returns %d",rt);
+        channel=new GwChannel(logger,"SER",SERIAL1_CHANNEL_ID);
+        channel->setImpl(serial);
+        channel->begin(
+            serCanRead || serCanWrite,
+            serCanWrite,
+            serCanRead,
+            config->getString(config->serialReadF),
+            config->getString(config->serialWriteF),
+            false,
+            config->getBool(config->serialToN2k),
+            false,
+            false    
+        );
+        LOG_DEBUG(GwLog::LOG,"%s",channel->toString().c_str());
+        theChannels.push_back(channel);
+    }
+
+    //tcp client
+    channel=new GwChannel(logger,"TCPClient",TCP_CLIENT_CHANNEL_ID);
+    channel->begin(
+        config->getBool(config->tclEnabled),
+        config->getBool(config->sendTCL),
+        config->getBool(config->readTCL),
+        config->getString(config->tclReadFilter),
+        config->getString(config->tclReadFilter),
+        config->getBool(config->tclSeasmart),
+        config->getBool(config->tclToN2k),
+        false,
+        false
+        );
+    if (channel->isEnabled()){
+        client=new GwTcpClient(logger);
+        client->begin(TCP_CLIENT_CHANNEL_ID,
+            config->getString(config->remoteAddress),
+            config->getInt(config->remotePort),
+            channel->shouldRead()
+        );
+        channel->setImpl(client);
+    }
+    LOG_DEBUG(GwLog::LOG,"%s",channel->toString().c_str());  
+    logger->flush();
+}
+int GwChannelList::getJsonSize(){
+    int rt=0;
+    allChannels([&](GwChannel *c){
+        rt+=c->getJsonSize();
+    });
+    return rt+20;
+}
+void GwChannelList::toJson(GwJsonDocument &doc){
+    if (sockets) doc["numClients"]=sockets->numClients();
+    if (client){
+        doc["clientCon"]=client->isConnected();
+        doc["clientErr"]=client->getError();
+    }
+    allChannels([&](GwChannel *c){
+        c->toJson(doc);
+    });
+}
+GwChannel *GwChannelList::getChannelById(int sourceId){
+    for (auto it=theChannels.begin();it != theChannels.end();it++){
+        if ((*it)->isOwnSource(sourceId)) return *it;
+    }
+    return NULL;
+}

lib/channel/GwChannelList.h

@@ -0,0 +1,43 @@
+#pragma once
+#include <functional>
+#include <vector>
+#include <WString.h>
+#include "GwChannel.h"
+#include "GwLog.h"
+#include "GWConfig.h"
+#include "GwJsonDocument.h"
+
+//NMEA message channels
+#define N2K_CHANNEL_ID 0
+#define USB_CHANNEL_ID 1
+#define SERIAL1_CHANNEL_ID 2
+#define TCP_CLIENT_CHANNEL_ID 3
+#define MIN_TCP_CHANNEL_ID 4
+
+#define MIN_USER_TASK 200
+class GwSocketServer;
+class GwTcpClient;
+class GwChannelList{
+    private:
+        GwLog *logger;
+        GwConfigHandler *config;
+        typedef std::vector<GwChannel *> ChannelList;
+        ChannelList theChannels;
+        
+        GwSocketServer *sockets;
+        GwTcpClient *client;
+        String serialMode=F("NONE");
+    public:
+        GwChannelList(GwLog *logger, GwConfigHandler *config);
+        typedef std::function<void(GwChannel *)> ChannelAction;
+        void allChannels(ChannelAction action);
+        //initialize
+        void begin(bool fallbackSerial=false);
+        //status
+        int getJsonSize();
+        void toJson(GwJsonDocument &doc);
+        //single channel
+        GwChannel *getChannelById(int sourceId);
+
+
+};