Feature/coretex m4 communication

.gitignore

@@ -75,6 +75,7 @@ Temporary Items
 
 .vscode/settings.json
 .vscode/c_cpp_properties.json
+.vscode/ipch/*
 .weights
 
 # Notebook checkpoints

rr_interface/CMakeLists.txt

@@ -0,0 +1,36 @@
+cmake_minimum_required(VERSION 2.8.3)
+project(rr_interface)
+
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
+
+set(CMAKE_BUILD_TYPE Release)
+
+find_package(
+  catkin REQUIRED COMPONENTS 
+  roscpp 
+  rospy 
+  std_msgs 
+  roslint
+  message_generation
+)
+
+add_message_files(
+  FILES
+  Transmitter.msg
+)
+
+generate_messages(
+  DEPENDENCIES 
+  std_msgs
+)
+
+catkin_package(
+  CATKIN_DEPENDS message_runtime
+)
+
+roslint_cpp()
+
+include_directories(include ${catkin_INCLUDE_DIRS})
+add_executable(rr_interface src/interface_main.cpp src/interface.cpp include/interface.hpp)
+add_dependencies(rr_interface rr_interface_generate_messages_cpp)
+target_link_libraries(rr_interface ${catkin_LIBRARIES}) 

rr_interface/include/interface.hpp

@@ -0,0 +1,84 @@
+/** @file laser_mapper.hpp
+ *  @author Andrew Jin (D29Jin)
+ *  @competition IARRC 2019
+ */
+
+#ifndef INTERFACE_H
+#define INTERFACE_H
+
+// ROS headers
+#include <ros/ros.h>
+
+#include <rr_interface/Transmitter.h>
+
+typedef struct  __attribute__ ((packed))
+{
+  int16_t jetson_ang;
+  int16_t  jetson_spd;
+  uint16_t jetson_flag;
+}jetson_data_t;
+
+typedef struct
+{
+   uint8_t        startByte;
+   jetson_data_t  data;
+   uint8_t        endByte;
+}jetson_packet_t;
+
+typedef union
+{
+  jetson_packet_t myFrame;
+  uint8_t         serializedArray[8];
+}jetson_union_t;
+
+/* 
+  This is a flag that is sent by the transmitter (Jetson -> Coretex M4)
+  It is designed to send specific commands to ensure that the robot does
+  not deviate during certain cases
+  All the values defined above are binary values and should always be the case
+*/ 
+enum class jetsonFlag : uint8_t {
+  ESTOP = 1
+  // Stuff
+};
+
+enum class coretexFlag : uint8_t {
+  ALIVE = 0,
+  STABLE = 1,
+  CONNECTED = 2
+};
+
+class Interface
+{
+  public:
+    Interface(ros::NodeHandle nh);
+    ~Interface();
+
+    /*
+    struct Transmitter {
+      int16_t steer_angle; // Degrees
+      uint16_t speed; // cm/s
+      uint16_t flag; // Flag enum
+      uint16_t padding;
+    };
+     */
+
+    struct Receiver {
+      coretexFlag flag; // Flag enum
+    };
+
+    std::vector<uint16_t> Serialize(std::vector<uint16_t> transmitter);
+    Receiver Deserialize(char* buffer);
+
+    jetson_union_t transmitter_;
+    Receiver receiver_;
+  private:
+
+    // Subscribers/Advertisers
+    ros::Subscriber transmitter_subscriber_;
+    ros::Publisher receiver_publisher_;
+
+    void TransmitterCallback(const rr_interface::Transmitter &msg);
+};
+
+#endif  // INTERFACE_H

rr_interface/launch/interface.launch

@@ -0,0 +1,8 @@
+<!--@file interface.launch
+ -  @author Andrew Jin
+ -  @competition IARRC 2019
+ -->
+<launch>    
+  <node pkg="rr_interface" name="rr_interface" type="rr_interface" output="screen">
+  </node> 
+</launch>

rr_interface/msg/Transmitter.msg

@@ -0,0 +1,10 @@
+# The message currently only receives a value from the coretex m4
+# This is mainly designed to help us figure out the current status of M4
+
+# Steering Angle (Degrees)
+int16 steer_angle
+
+# Speed (cm/s)
+int16 speed
+
+uint16 FLAG

rr_interface/package.xml

@@ -0,0 +1,25 @@
+<?xml version="1.0"?>
+<package>
+  <name>rr_interface</name>
+  <version>0.0.0</version>
+  <description>The robot racing interface package</description>
+  <maintainer email="robotracer@todo.todo">robotracer</maintainer>
+  <license>TODO</license>
+
+  <buildtool_depend>catkin</buildtool_depend>
+  <build_depend>std_msgs</build_depend> 
+  <build_depend>rospy</build_depend> 
+  <build_depend>roscpp</build_depend> 
+  <build_depend>roslint</build_depend>
+  <build_depend>boost</build_depend>
+  <build_depend>message_generation</build_depend>
+
+  <run_depend>std_msgs</run_depend> 
+  <run_depend>rospy</run_depend> 
+  <run_depend>roscpp</run_depend> 
+  <run_depend>boost</run_depend>
+  <run_depend>message_runtime</run_depend>
+
+  <export>
+  </export>
+</package>

rr_interface/serial_tests/serial_tests.ino

@@ -0,0 +1,58 @@
+//typedef struct Receiver {
+//  byte speed;
+//  byte steer;
+//  byte position;
+//};
+//
+//typedef struct Transmitter {
+//  byte payload;  
+//};
+//
+//union Uni {
+//  Transmitter frame;
+//  uint8_t serialized_array[512];  
+//};
+//
+//Receiver rx_byte;
+//union Uni payloadunion;
+//Transmitter tx_byte;
+
+int receivedByte;
+String input;
+unsigned char output = 'w';
+
+void setup() {
+  // Setup serial communication with a baud rate of 115200
+  // and 8 data bits, no parity bits, 1 stop bit (default if not specified)
+  Serial.begin(115200, SERIAL_8N1);
+}
+
+void read()
+{
+  if (Serial.available() > 0) 
+  {
+    receivedByte = Serial.read();
+    Serial.print("Received data: ");
+    Serial.print(receivedByte);
+    Serial.println();
+  }
+}
+
+void write()
+{
+  Serial.write(output);
+//  payloadunion.frame.payload = 1;
+//  tx_byte.payload = 1;
+//  Serial.write('P');
+//  Serial.write((uint8_t*)&tx_byte,sizeof(tx_byte));
+//  Serial.write('S');
+//  return;
+}
+
+void loop() {
+  write();
+  delay(10);
+  read();
+  //write();
+  //delay(500);
+}

rr_interface/src/interface.cpp

@@ -0,0 +1,50 @@
+/** @file interface.cpp
+ *  @author Andrew Jin (DongJunJin)
+ *  @competition IARRC 2019
+ */
+
+// Local
+#include "interface.hpp"
+
+/**
+ * @name Interface
+ * @brief initiliazes the Interface class
+ * @return NONE
+ */
+Interface::Interface(ros::NodeHandle nh) {
+    transmitter_subscriber_ = nh.subscribe("interface/transmitter", 0 , &Interface::TransmitterCallback, this);
+    memset(transmitter_.serializedArray, '\n', sizeof(transmitter_.serializedArray));
+}
+
+/**
+ * @name ~Interface
+ * @brief destructs the Interface class
+ * @return NONE
+ */
+Interface::~Interface() {
+}
+
+Interface::Receiver Interface::Deserialize(char* buffer)
+{
+    if (buffer)
+    {
+        Interface::Receiver rReceiver;
+
+        // Converts the data to the correct struct
+        Receiver *fromChar = (Receiver*)buffer;
+        return rReceiver;
+    }
+}
+
+void Interface::TransmitterCallback(const rr_interface::Transmitter &msg) {
+    /*
+    switch(msg.flag) {
+        case 0:
+            transmitter_.flag = jetsonFlag::ESTOP;
+        break;
+    }
+     */
+    transmitter_.myFrame.data.jetson_ang = msg.steer_angle;
+    transmitter_.myFrame.data.jetson_spd = msg.speed;
+    transmitter_.myFrame.data.jetson_flag = msg.FLAG;
+}