Initial commit

Lts/Proxies/TrainingAreaBaseOC/connection_handler_tcp_ttci.cpp

@@ -0,0 +1,212 @@
+/**
+  * Holen und Schreiben der XDR-Telegramme vom/an Can-Bus
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  */
+#include "connection_handler_tcp_ttci.h"
+
+#include <QCoreApplication>
+#include <QDataStream>
+#include <QTimer>
+#include <QTcpServer>
+
+#include <QTimer>
+
+using namespace NGL;
+
+namespace TrainingAreaBaseOC
+{
+ConnectionHandlerTcpTtci::ConnectionHandlerTcpTtci()
+  : m_messageDataStart(true)
+  , m_wirkfeldDataStart(true)
+  , m_wirkfeldMultiplex(0)
+  , m_sendingData(false)
+  , m_segmentToggle(0)
+  , m_canDevice(new Device(this))
+  , m_canChannel(new Channel(QLatin1Char('@'), true, this))
+  , m_logger(getLogger("TTCI"))
+{
+  connect(m_canChannel, &Channel::dataAvailable, this, &ConnectionHandlerTcpTtci::slotReadCanFrame);
+  connect(m_canChannel, &Channel::disconnectedFromEq, this, &ConnectionHandlerTcpTtci::disconnectedFromEq);
+}
+
+ConnectionHandlerTcpTtci::~ConnectionHandlerTcpTtci()
+{
+  delete m_canChannel;
+  delete m_canDevice;
+  qDeleteAll(m_sfmMessages);
+}
+
+bool ConnectionHandlerTcpTtci::init()
+{
+  initCanSocket();
+  return true;
+}
+
+
+void ConnectionHandlerTcpTtci::initCanSocket()
+{
+  ERROR_LOG(m_logger) << "InitCantSOcket";
+
+  m_canChannel->setDevice(m_canDevice);
+  m_canDevice->open();
+}
+
+
+bool ConnectionHandlerTcpTtci::findNextSyncByte(int &iCurReadPos) const
+{
+  if (iCurReadPos == m_buffer.size())
+  {
+    DEBUG_LOG(m_logger) << "No more data available";
+    return false;
+  }
+  DEBUG_LOG(m_logger) << "Searching for next sync byte, start at: " << iCurReadPos;
+  NGL::NGLLoggerHelper::hexDumpHelper(m_logger, NGL::LogLevel::Debug, m_buffer);
+
+  while (iCurReadPos < m_buffer.size())
+  {
+    static const unsigned char syncByte = 0xAA;
+    const unsigned char curByte = m_buffer.at(iCurReadPos);
+    if (curByte == syncByte)
+      break;
+    ++iCurReadPos;
+  }
+  // wir brauchen mind. 4 Bytes (Sync, Can Header1+2, CRC)
+  if (m_buffer.size() < 4 + iCurReadPos)
+  {
+    DEBUG_LOG(m_logger) << "Could not find sync byte in stream";
+    return false;
+  }
+  return true;
+}
+
+void ConnectionHandlerTcpTtci::slotReadCanFrame(const QByteArray &data)
+{
+  m_buffer += data;
+
+  int iCurReadPos = 0;
+  while (findNextSyncByte(iCurReadPos))
+  {
+    DEBUG_LOG(m_logger) << "Found Sync byte at " << iCurReadPos;
+
+    // die ersten 4 Bits sind die Datenlänge
+    unsigned int len = (m_buffer.at(iCurReadPos + 1) & 0xF0) >> 4;
+    DEBUG_LOG(m_logger) << "Payload size: " << len;
+
+    if (len > 8)
+    {
+      // spezielle Daten
+      switch (len)
+      {
+      case 9:
+        // Status-Informationen (3.3.1.2)
+        DEBUG_LOG(m_logger) << "Read status data - skipping ";
+        iCurReadPos += 4;
+        break;
+      case 11:
+        // Komm SFM - PAN (3.3.2)
+        DEBUG_LOG(m_logger) << "Read communication SFM - PAN - skipping ";
+        iCurReadPos += 5;
+        break;
+      case 12:
+        // Parameterabfrage (3.3.1.3)
+        DEBUG_LOG(m_logger) << "Read parameter request - skipping ";
+        iCurReadPos += 5;
+        break;
+      default:
+        // wahrscheinlich kein korrekter Sync
+        WARNING_LOG(m_logger) << "Invalid payload size (" << len << " - skipping";
+        ++iCurReadPos;
+        break;
+      }
+      continue;
+    }
+    // 1 Byte sync
+    // 2 Byte header
+    // len Byte nutzdaten
+    // 1 Byte crc
+    int neededBytes = 4 + len + iCurReadPos;
+    if (m_buffer.size() < neededBytes)
+    {
+      INFO_LOG(m_logger) << "To few bytes in buffer - waiting for more (want: "
+                         << neededBytes << " have: " << m_buffer.size() << ")";
+      // zu wenig Daten -> warten
+      break;
+    }
+
+    unsigned int id = (m_buffer.at(iCurReadPos + 1) & 0x07);
+    unsigned char id2 = m_buffer.at(iCurReadPos + 2);
+    id = ((id << 8) + id2);
+    bool rtr = ((m_buffer.at(iCurReadPos + 1) & 0x08) == 0x08);
+    DEBUG_LOG(m_logger) << "CAN ID: " << id << " rtr: " << rtr;
+
+    // calc crc (über alles bis zur CRC)
+    unsigned char crc = 0;
+    for (unsigned int i = 0; i < len + 3; ++i)
+      crc += m_buffer.at(iCurReadPos + i);
+    crc = ~crc;
+
+    unsigned char crcSent = m_buffer.at(iCurReadPos + len + 3);
+    if (crc != crcSent)
+    {
+      // CRC passt nicht - ggf. kein korrekter Sync
+      WARNING_LOG(m_logger) << "CRC checksum missmatch (is: " << crcSent
+                            << " - calculated: " <<  crc << ") - skipping";
+      iCurReadPos++;
+      continue;
+    }
+
+    QByteArray data2(m_buffer.data() + iCurReadPos + 3, len);
+    //LtsUtils::SfmMessage msg;
+    LtsUtils::SfmMessage msg;
+    msg.setId(id);
+    msg.setPayload(data2);
+    msg.setRtr(rtr);
+
+    emit received(msg);
+
+    // und weiter zum nächsten Paket
+    iCurReadPos += 4 + len;
+
+  }
+  m_buffer = m_buffer.mid(iCurReadPos);
+
+}
+
+bool ConnectionHandlerTcpTtci::isOpen()
+{
+  return m_canDevice->isOpen();
+}
+
+bool ConnectionHandlerTcpTtci::send(const LtsUtils::SfmMessage &message)
+{
+  if (message.payload().size() > 8)
+    return false;
+
+  INFO_LOG(m_logger) << "start write";
+  NGL::NGLLoggerHelper::hexDumpHelper(m_logger, NGL::LogLevel::Debug, message.payload());
+
+  QByteArray data(message.payload().size() + 4, Qt::Uninitialized);
+  data[0] = 0xAA;
+
+  data[1] = (message.payload().size() << 4) | ((message.rtr() & 0x1) << 3) | ((message.id() & 0x700) >> 8);
+  data[2] = (message.id() & 0xFF);
+
+  for (int i = 0; i < message.payload().size(); ++i)
+    data[i + 3] = message.payload().at(i);
+
+  unsigned char crc = 0;
+  for (int i = 0; i < data.size() - 1; ++i)
+    crc += data.at(i);
+  crc = ~crc;
+  data[message.payload().size() + 3] = crc;
+  INFO_LOG(m_logger) << "end  write ";
+
+  if (!m_canChannel->writeData(data))
+    ERROR_LOG(m_logger) << "Error writing data to can channel";
+
+  return true;
+}
+
+} // namespace TrainingAreaBaseOC