Dimos CAN (#1084)

### Summary
Dimos should now broadcast CAN properly.

### Changelist 
- Main Window CAN broadcasting in time
- Mutex locking for CAN tables

### Testing Done
- DevIO console logging

### Resolved Issues

### Checklist
*Please change `[ ]` to `[x]` when you are ready.*
- [x] I have read and followed the code conventions detailed in
[README.md](../README.md) (*This will save time for both you and the
reviewer!*).
- [x] If this pull request is longer then **500** lines, I have provided
*explicit* justification in the summary above explaining why I *cannot*
break this up into multiple pull requests (*Small PR's are faster and
less painful for everyone involved!*).

---------

Co-authored-by: peterjinweigu <[email protected]>

can_bus/json/dimos/dimos_tx.json

@@ -1 +1,15 @@
-{}
+{
+	"CommitInfo": {
+		"msg_id": 819,
+		"cycle_time": 100,
+		"description": "Dimos Current Running Commit Info",
+		"signals": {
+			"Hash": {
+				"bits": 32
+			},
+			"Clean": {
+				"bits": 1
+			}
+		}
+	}
+}

software/dimos/cmake/qt.cmake

@@ -34,7 +34,7 @@ function(ADD_QT_EXECUTABLE EXECUTABLE_NAME PROJECT_SOURCES LIBRARIES)
             ${BUNDLE_ID_OPTION}
             MACOSX_BUNDLE_BUNDLE_VERSION ${PROJECT_VERSION}
             MACOSX_BUNDLE_SHORT_VERSION_STRING ${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}
-            MACOSX_BUNDLE TRUE
+            MACOSX_BUNDLE FALSE
             WIN32_EXECUTABLE TRUE
     )
 

software/dimos/src/dev_io/can.cpp

@@ -1,14 +1,22 @@
 #include "can.h"
+#include <iostream>
+#include <thread>
+#include <chrono>
 
+using std::cout, std::endl;
 
 Result<std::monostate, CanConnectionError> Can_Init() {
+	cout << "Can Initialized" << endl;
 	return std::monostate{};
 }
 
 Result<CanMsg, CanReadError> Can_Read() {
-	return CanMsg{};
+	std::this_thread::sleep_for(std::chrono::milliseconds(1000));
+	cout << "Can Read Requested" << endl;
+	return CanMsg{0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
 }
 
 Result<std::monostate, CanWriteError> Can_Write(const CanMsg *msg) {
+	cout << "Can with id " << msg->std_id << " Written" << endl;
 	return std::monostate{};
-}
+}

software/dimos/src/ui/main.cpp

@@ -6,9 +6,24 @@ extern "C"
 {
 #include "App_CanTx.h"
 #include "App_CanRx.h"
+#include "Io_CanRx.h"
+#include "Io_CanTx.h"
 }
 
+const bool GIT_COMMIT_HASH = true;
+const bool GIT_COMMIT_CLEAN = false;
+
 int main(int argc, char *argv[]) {
+	// IO init
+	Io_CanTx_Init(reinterpret_cast<void (*)(const CanMsg *)>(Can_Write));
+	Io_CanTx_EnableMode(CAN_MODE_DEFAULT, true);
+	// clear tables
+	App_CanTx_Init();
+	App_CanRx_Init();
+	// TODO commit hash
+	App_CanTx_dimos_Hash_Set(GIT_COMMIT_HASH);
+	App_CanTx_dimos_Clean_Set(GIT_COMMIT_CLEAN);
+
 	QApplication a(argc, argv);
 	MainWindow w;
 	w.show();

software/dimos/src/ui/mainwindow/mainwindow.cpp

@@ -1,13 +1,63 @@
-#include <iostream>
+#include <QThread>
+#include <chrono>
 
 #include "mainwindow.h"
 #include "ui_mainwindow.h"
+#include "can.h"
 
-using std::cout, std::endl;
+extern "C" {
+#include "Io_CanTx.h"
+#include "Io_CanRx.h"
+}
 
 MainWindow::MainWindow(QWidget *parent) : QMainWindow(parent), ui(new Ui::MainWindow) {
+	// CANTX TASK
+	tx100Hz.setInterval(10);
+	tx100Hz.setSingleShot(false);
+	QTimer::connect(&tx100Hz, &QTimer::timeout, Io_CanTx_Enqueue100HzMsgs);
+	tx100Hz.start();
+
+	tx1Hz.setInterval(1000);
+	tx1Hz.setSingleShot(false);
+	QTimer::connect(&tx1Hz, &QTimer::timeout, Io_CanTx_Enqueue1HzMsgs);
+	tx1Hz.start();
+
+	CanRxTaskThread = QThread::create(&MainWindow::CanRXTask);
+	CanTxPeriodicTaskThread = QThread::create(&MainWindow::CanPeriodicTXTask);
+	CanRxTaskThread->start();
+	CanTxPeriodicTaskThread->start();
+
 	ui->setupUi(this);
 }
 
-MainWindow::~MainWindow() = default;
+[[noreturn]] void MainWindow::CanRXTask() {
+	while (true) {
+		Result<CanMsg, CanReadError> res = Can_Read();
+		if (res.index() == 1) {
+			switch (get<CanReadError>(res)) {
+				case ReadInterfaceNotCreated:
+					break;
+				case SocketReadError:
+				case IncompleteCanFrame:
+					continue;
+			}
+			continue;
+		}
+
+		// success
+		CanMsg message = get<CanMsg>(res);
+		// acquire lock
+		Io_CanRx_UpdateRxTableWithMessage(&message);
+		// release lock
+	}
+}
+
+[[noreturn]] void MainWindow::CanPeriodicTXTask() {
+	using namespace std::chrono;
+	while (true) {
+		auto ms = duration_cast<milliseconds>(system_clock::now().time_since_epoch());
+		Io_CanTx_EnqueueOtherPeriodicMsgs(ms.count());
+	}
+}
 
+MainWindow::~MainWindow() = default;

software/dimos/src/ui/mainwindow/mainwindow.h

@@ -18,6 +18,15 @@ Q_OBJECT
 
 private:
 	std::unique_ptr<Ui::MainWindow> ui;
+
+	[[noreturn]] static void CanRXTask();
+
+	[[noreturn]] static void CanPeriodicTXTask();
+
+	QTimer tx100Hz{};
+	QTimer tx1Hz{};
+	QThread *CanRxTaskThread;
+	QThread *CanTxPeriodicTaskThread;
 };
 
 #endif // MAINWINDOW_H