working communication

src/DBO/Result.h

 
 typedef Result<bool> BResult;
 
-# include "DBO/Result.hxx"
+# include "Result.hxx"
 
 #endif //PDNS_SLAVE_RESULT_H

src/DataAccess/ArduinoSerial.cpp

     close();
 }
 
-int ArduinoSerial::open()
+BResult ArduinoSerial::open()
 {
     struct termios toptions;
 
     fd_ = ::open(port_.c_str(), O_RDWR | O_NONBLOCK);
 
     if (fd_ == -1)  {
-        perror("serialport_init: Unable to open port ");
-        return -1;
+        return BResult().error(strerror(errno));
     }
 
     //int iflags = TIOCM_DTR;
     //ioctl(fd, TIOCMBIC, &iflags);    // turn off DTR
 
     if (tcgetattr(fd_, &toptions) < 0) {
-        perror("serialport_init: Couldn't get term attributes");
-        return -1;
+        return BResult().error(strerror(errno));
     }
     speed_t brate;
     switch(bauderate_) {
 
     tcsetattr(fd_, TCSANOW, &toptions);
     if (tcsetattr(fd_, TCSAFLUSH, &toptions) < 0) {
-        perror("init_serialport: Couldn't set term attributes");
-        return -1;
+        return BResult().error(strerror(errno));
     }
 
-    return 0;
+    return BResult().ok(true);
 }
 
 void ArduinoSerial::close()
         ::close(fd_);
         fd_ = 0;
     }
-}
+}
+
+Result<std::pair<SERIAL_PACKET_TYPE, std::string>> ArduinoSerial::read()
+{
+    SERIAL_PACKET_TYPE packetType = 0;
+    auto res = readBytes((char*)&packetType, sizeof(packetType));
+    if (!res) {
+        return Result<std::pair<SERIAL_PACKET_TYPE, std::string>>().error(res.getError());
+    }
+
+
+    SERIAL_PACKET_LENGTH_TYPE length = 0;
+    res = readBytes((char*)&length, sizeof(length));
+    if (!res) {
+        return Result<std::pair<SERIAL_PACKET_TYPE, std::string>>().error(res.getError());
+    }
+
+    if (length > 0) {
+        char buff[length];
+
+        res = readBytes(buff, length);
+        if (!res) {
+            return Result<std::pair<SERIAL_PACKET_TYPE, std::string>>().error(res.getError());
+        }
+
+        std::pair<SERIAL_PACKET_TYPE, std::string> pair(packetType, std::string(buff,  length));
+
+        return Result<std::pair<SERIAL_PACKET_TYPE, std::string>>().ok(pair);
+    }
+
+    std::pair<SERIAL_PACKET_TYPE, std::string> pair(packetType, "");
+
+    return Result<std::pair<SERIAL_PACKET_TYPE, std::string>>().ok(pair);
+}
+
+BResult ArduinoSerial::readBytes(char* buffer, size_t length)
+{
+    ssize_t res = 0;
+    bool done = false;
+    size_t pos = 0;
+    while (!done)
+    {
+        res = ::read(fd_, buffer + pos, (size_t) length);
+        if (res < 0)
+        {
+            return BResult().error(strerror(errno));
+        }
+        if (res > 0) {
+            pos += res;
+            if (pos >= length) {
+                done = true;
+            }
+        }
+        else {
+            usleep(1);
+        }
+    }
+    return BResult().ok(true);
+}
+
+BResult ArduinoSerial::write(const char *data, SERIAL_PACKET_LENGTH_TYPE length)
+{
+    auto res = writeBytes((const char*)&length, sizeof(length));
+    if (!res) {
+        return res;
+    }
+    return writeBytes((const char*)&data, length);
+}
+
+BResult ArduinoSerial::writeBytes(const char *data, size_t length)
+{
+    auto res = ::write(fd_, data, length);
+    if (res < 0) {
+        return BResult().error(strerror(errno));
+    }
+    return BResult().ok(true);
+}

src/DataAccess/ArduinoSerial.h

 
 
 #include <string>
+#include "../DBO/Result.h"
+#include "../config.h"
 
 class ArduinoSerial
 {
     ArduinoSerial(std::string port, int baudrate);
     virtual ~ArduinoSerial();
 
-    int open();
+    BResult open();
     void close();
 
+    Result<std::pair<SERIAL_PACKET_TYPE, std::string>> read();
+
+    BResult write(const char* data, SERIAL_PACKET_LENGTH_TYPE length);
+
 protected:
+    BResult readBytes(char* buffer, size_t length);
+
+    BResult writeBytes(const char* data, size_t length);
+
     std::string port_;
     int bauderate_;
 

src/config.h

+//
+// Created by robin on 5/6/16.
+//
+
+#ifndef DIGICODE_HOST_CONFIG_H
+#define DIGICODE_HOST_CONFIG_H
+
+#define SERIAL_BAUDRATE 9600
+#define SERIAL_PACKET_TYPE unsigned char
+#define SERIAL_PACKET_LENGTH_TYPE unsigned char
+#define SERIAL_PACKET_TYPE_INT unsigned char
+
+
+#define ERROR_NONE 0
+#define ERROR_HOST_PROTOCOL 1
+#define ERROR_HOST_TIMEOUT 2
+
+#define PACKET_DEBUG 1
+#define PACKET_SELF_TEST 2
+#define PACKET_LOGIN 3
+
+#endif //DIGICODE_HOST_CONFIG_H

src/main.cpp

 #include <iostream>
-
+#include<signal.h>
 #include "DataAccess/ArduinoSerial.h"
 
+
+constexpr char hexmap[] = {'0', '1', '2', '3', '4', '5', '6', '7',
+                           '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
+
+std::string hexStr(std::string str)
+{
+    std::string s(str.size() * 2, ' ');
+    for (int i = 0; i < str.size(); ++i) {
+        s[2 * i]     = hexmap[(str[i] & 0xF0) >> 4];
+        s[2 * i + 1] = hexmap[str[i] & 0x0F];
+    }
+    return s;
+}
+
+int lastSignal = 0;
+
+void sig_handler(int signo)
+{
+    std::cout << "Signal catched " << signo << std::endl;
+    lastSignal = signo;
+}
+
 int main()
 {
-    ArduinoSerial arduinoSerial("/dev/ttyUSB0", 9600);
-    std::cout << arduinoSerial.open() << std::endl;
+    signal(SIGINT, sig_handler);
+    signal(SIGTERM, sig_handler);
+    signal(SIGKILL, sig_handler);
+
+    ArduinoSerial arduinoSerial("/dev/ttyUSB0", SERIAL_BAUDRATE);
+    auto res = arduinoSerial.open();
+    if (!res) {
+        res.print();
+        return 1;
+    }
+    while (lastSignal == 0)
+    {
+        auto data = arduinoSerial.read();
+        if (!data) {
+            data.print();
+            return 2;
+        }
+        std::cout << (int) data.getData().first << " " << hexStr(data.getData().second)
+        << " " << data.getData().second << std::endl;
+        if (data.getData().first == PACKET_SELF_TEST) {
+            SERIAL_PACKET_TYPE_INT status = 42;
+            arduinoSerial.write((const char*)&status, sizeof(status));
+        }
+    }
     return 0;
+
 }