SNS: Serial Communication

arduino/main.ino

@@ -0,0 +1,49 @@
+#include <SoftwareSerial.h>
+#include <SerialProtocol.h>
+#include <StreamSerialProtocol.h>
+#include <ArduinoSerialProtocol.h>
+
+int IRSensor1 = 2;
+int IRSensor2 = 3;
+int IRSensor3 = 4;
+int IRSensor4 = 5;
+
+// The payload that will be sent to the other device
+struct Payload {
+    int16_t wheelEncoderA;
+    int16_t wheelEncoderB;
+    int16_t wheelEncoderC;
+    int16_t wheelEncoderD;
+} payload;
+
+ArduinoSerialProtocol protocol(&Serial, (uint8_t*)&payload, sizeof(payload));
+uint8_t receiveState;
+
+void setup() 
+{
+    Serial.begin(9600);
+
+    payload.wheelEncoderA = 0;
+    payload.wheelEncoderB = 0;
+    payload.wheelEncoderC = 0;
+    payload.wheelEncoderD = 0;
+}
+
+void loop()
+{
+    if(digitalRead(IRSensor1)){
+        ++payload.wheelEncoderA;
+    }
+    if(digitalRead(IRSensor2)){
+        ++payload.wheelEncoderB;
+    }
+    if(digitalRead(IRSensor3)){
+        ++payload.wheelEncoderC;
+    }
+    if(digitalRead(IRSensor4)){
+        ++payload.wheelEncoderD;
+    }
+
+    protocol.send();
+}
+

src/utils/io/serial.cpp

@@ -0,0 +1,119 @@
+#include "serial.hpp"
+
+#include <fcntl.h>
+#include <stdio.h>
+#include <time.h>
+#include <unistd.h>
+
+#include <iostream>
+#include <sstream>
+
+#include <utils/system.hpp>
+
+namespace hyped::utils::io {
+
+SerialProtocol::SerialProtocol(const std::string serial, const BaudRate baud_rate)
+    : serial_device_(serial),
+      baud_rate_(baud_rate),
+      log_(utils::Logger("SERIAL", utils::System::getSystem().config_.log_level))
+{
+  configureTermios();
+}
+
+SerialProtocol::~SerialProtocol()
+{
+  close(serial_);
+};
+
+bool SerialProtocol::serialAvailable()
+{
+  return serial_ > 0;
+}
+
+void SerialProtocol::configureTermios()
+{
+  serial_ = open(serial_device_.c_str(), O_RDWR | O_NOCTTY | O_NDELAY);
+
+  if (serial_ == -1) {
+    log_.error("Unable to open serial device: %s", serial_device_.c_str());
+    return;
+  }
+
+  struct termios options;
+  tcgetattr(serial_, &options);
+  options.c_cflag = CS8 | CLOCAL | CREAD;
+  options.c_iflag = IGNPAR;
+  options.c_oflag = 0;
+  options.c_lflag = 0;
+  switch (baud_rate_) {
+    case BaudRate::kB300:
+      cfsetispeed(&options, B300);
+      cfsetospeed(&options, B300);
+      break;
+    case BaudRate::kB600:
+      cfsetispeed(&options, B600);
+      cfsetospeed(&options, B600);
+      break;
+    case BaudRate::kB1200:
+      cfsetispeed(&options, B1200);
+      cfsetospeed(&options, B1200);
+      break;
+    case BaudRate::kB2400:
+      cfsetispeed(&options, B2400);
+      cfsetospeed(&options, B2400);
+      break;
+    case BaudRate::kB4800:
+      cfsetispeed(&options, B4800);
+      cfsetospeed(&options, B4800);
+      break;
+    case BaudRate::kB9600:
+      cfsetispeed(&options, B9600);
+      cfsetospeed(&options, B9600);
+      break;
+    case BaudRate::kB19200:
+      cfsetispeed(&options, B19200);
+      cfsetospeed(&options, B19200);
+      break;
+    default:
+      cfsetispeed(&options, B9600);
+      cfsetospeed(&options, B9600);
+      break;
+  }
+  tcflush(serial_, TCIFLUSH);
+  tcsetattr(serial_, TCSANOW, &options);
+}
+
+void SerialProtocol::readData(std::vector<uint8_t> &data)
+{
+  data.clear();
+  if (!serialAvailable()) {
+    log_.error("Serial device not available for read.");
+    return;
+  }
+
+  const size_t bytesRead = read(serial_, &readBuffer_[0], readBufferSize_B_);
+
+  if (bytesRead < 0) {
+    log_.error("Error reading from serial device.");
+    return;
+  }
+
+  std::copy(readBuffer_.begin(), readBuffer_.begin() + bytesRead, back_inserter(data));
+  return;
+}
+
+void SerialProtocol::writeData(const std::vector<uint8_t> &data)
+{
+  if (!serialAvailable()) {
+    log_.error("Serial device not available for write.");
+    return;
+  }
+
+  int write_result = write(serial_, data.data(), data.size());
+
+  if (write_result == -1) {
+    log_.error("Error writing to serial device.");
+    return;
+  }
+}
+}  // namespace hyped::utils::io

src/utils/io/serial.hpp

@@ -0,0 +1,35 @@
+#pragma once
+
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include <termios.h>
+
+#include <vector>
+
+#include <utils/logger.hpp>
+namespace hyped::utils::io {
+
+enum class BaudRate { kB300, kB600, kB1200, kB2400, kB4800, kB9600, kB14400, kB19200, kB28800 };
+class SerialProtocol {
+ public:
+  SerialProtocol(std::string serial, BaudRate baud_rate);
+  ~SerialProtocol();
+
+  void configureTermios();
+
+  bool serialAvailable();
+
+  void readData(std::vector<uint8_t> &buffer);
+  void writeData(const std::vector<uint8_t> &buffer);
+
+ private:
+  std::string serial_device_;
+  int serial_;
+  BaudRate baud_rate_;
+  utils::Logger log_;
+
+  std::vector<char> readBuffer_;
+  unsigned char readBufferSize_B_;
+};
+};  // namespace hyped::utils::io