Connect two SIMHUB devices using I2C.

.vscode/settings.json

@@ -0,0 +1,37 @@
+{
+    "files.associations": {
+        "array": "cpp",
+        "string": "cpp",
+        "string_view": "cpp",
+        "ranges": "cpp",
+        "deque": "cpp",
+        "list": "cpp",
+        "unordered_map": "cpp",
+        "vector": "cpp",
+        "initializer_list": "cpp",
+        "regex": "cpp",
+        "*.tcc": "cpp",
+        "optional": "cpp",
+        "istream": "cpp",
+        "ostream": "cpp",
+        "system_error": "cpp",
+        "functional": "cpp",
+        "tuple": "cpp",
+        "type_traits": "cpp",
+        "utility": "cpp",
+        "bitset": "cpp",
+        "sstream": "cpp",
+        "stdexcept": "cpp",
+        "typeinfo": "cpp",
+        "random": "cpp",
+        "algorithm": "cpp",
+        "iterator": "cpp",
+        "map": "cpp",
+        "memory": "cpp",
+        "memory_resource": "cpp",
+        "numeric": "cpp",
+        "set": "cpp",
+        "cstddef": "cpp"
+    },
+    "cmake.configureOnOpen": false
+}

lib/AnalogAxisSimulator/AnalogAxis.cpp

@@ -0,0 +1,54 @@
+#include "AnalogAxis.h"
+
+int pot = -1;
+bool AnalogAxisSimulator::read(int samplingRate){
+
+
+        if(millis()-lastGeneratedReading>300){
+            pot=analogReadXXbit(samplingRate);
+            lastGeneratedReading=millis();
+        }
+
+         if (lastAxisValue != pot) { 
+            Serial.println("\nAnalogAxisSimulator::setAnalogReading");
+            Serial.println(pot);
+		 	lastAxisValue = pot;
+
+		 	int mapped = map(pot, minimumInputValue, maximumInputValue, 0, 1024);
+            Serial.print("\nMapped:");
+            Serial.print(mapped);
+		 	float mapped2 = min((float)1, max((float)0,(float) ((float)mapped / (float)1024)));
+            Serial.print("\nMapped2:");
+            Serial.print(mapped2);
+
+		 	if (exponentialFactor != 1) {
+		 		mapped2 = pow(mapped2, 1.0 / (float)exponentialFactor);
+		 	}
+
+		 	mapped2 = mapped2 * 1024;
+            Serial.print("\nMapped2 Powed:");
+            Serial.print(mapped2);
+		 	if(this->shAxisChangedCallback!=nullptr){
+                Serial.println("\nCallback defined");
+		 		shAxisChangedCallback(axisIdx,mapped2);
+		 	}
+		 }
+    return false;
+
+}
+
+	float AnalogAxisSimulator::analogReadXXbit(byte bits_of_precision)
+	{
+		uint8_t n = bits_of_precision - 10;
+		unsigned long oversample_num = 1 << (2 * n);
+		uint8_t divisor = 1 << n;
+		unsigned long reading_sum = 0;
+		unsigned long inner_sum = 0;
+		for (unsigned long j = 0; j < oversample_num; j++)
+		{
+			inner_sum +=random(-1024,1024);
+		}
+		unsigned int reading = (inner_sum + (unsigned long)divisor / 2UL) >> n;
+		reading_sum += reading;
+		return  (float)reading_sum;
+	}

lib/AnalogAxisSimulator/AnalogAxis.h

@@ -0,0 +1,25 @@
+#include <Arduino.h>
+typedef void(*SHAxisChanged) (int, int);
+
+class AnalogAxisSimulator{
+    int axisIdx=1;
+    int lastAxisValue = -1;
+    int minimumInputValue=0;
+	int maximumInputValue=1024;
+	int samplingRate=10;
+    float  exponentialFactor=1;
+    unsigned long lastGeneratedReading=millis();
+    SHAxisChanged shAxisChangedCallback=nullptr;
+    public:
+
+    AnalogAxisSimulator(int axisIdx){
+        this->axisIdx=axisIdx;
+    }
+    bool read(int samplingRate);
+
+    void setCallBack(SHAxisChanged callback){
+		shAxisChangedCallback=callback;
+	}
+
+    float analogReadXXbit(byte bits_of_precision);
+};

lib/I2CSerialBridge/I2CManager.h

@@ -0,0 +1,69 @@
+#pragma once
+#include "I2CTransportMaster.h"
+#include "I2CTransportSlave.h"
+
+/***
+ * "This Manager is responsible for configuring the behavior based on the master-slave role for I2C communication."
+*/
+class I2CTransportManager  {
+    public:
+    #if I2C_BYPASS_MASTER
+       static I2CTransportMaster tm;
+    #endif
+       static I2CTransportSlave ts;
+
+    static void setup(FullLoopbackStream *outgoingStream){
+        #if I2C_BYPASS_MASTER
+            #if I2C_SERIAL_BYPASS_DEBUG
+                Serial.print("\nSetup as Master\n");
+                Serial.flush();
+            #endif
+        tm.setup(outgoingStream);
+        #endif
+
+        #if I2C_BYPASS_SLAVE
+        Serial.print("Setup as Slave");
+        Serial.flush();
+        ts.setup(outgoingStream);
+        #endif
+    }
+    static void loop(){
+        #if I2C_BYPASS_MASTER
+        tm.loop();
+        #endif
+
+        #if I2C_BYPASS_SLAVE
+        ts.loop();
+        #endif
+    }
+
+    static void flush(){
+        #if I2C_BYPASS_MASTER
+            tm.flush();
+        #endif
+
+        #if I2C_BYPASS_SLAVE
+            ts.flush();
+        #endif
+    }
+};
+
+#if I2C_BYPASS_MASTER
+#define StreamRead outgoingStream.read
+#define StreamAvailable outgoingStream.available
+#define FlowSerialFlush Serial.flush
+#define StreamFlush I2CTransportManager::flush
+#define StreamWrite outgoingStream.write
+//#define StreamWrite WIRE.write
+#define StreamPrint outgoingStream.print
+/** SETUP SERIAL BYPASS I2C SLAVE, USE WHEN THIS DEVICE IS CONNECTED TO SIMHUB*/
+#define FlowSerialBegin [](unsigned long baud) { Serial.print("Hola mundo");}
+#endif
+ #if I2C_BYPASS_SLAVE
+ #define StreamRead Serial.read
+ #define StreamFlush Serial.flush
+ #define StreamWrite Serial.write
+ #define StreamPrint Serial.print
+ #define StreamAvailable Serial.available
+ #define FlowSerialBegin [](unsigned long baud) { Serial.begin(baud);}
+ #endif

lib/I2CSerialBridge/I2CSerialBridge.h

@@ -0,0 +1,149 @@
+
+#include <FullLoopbackStream.h>
+#include <Wire.h>
+
+#ifndef WIRE
+#error WIRE must be settled to have a correct custom wire config in your MASTER config.
+#endif
+
+class    I2CSerialBridge{
+      FullLoopbackStream *outgoingStream;
+      uint8_t address;
+    public:
+
+        I2CSerialBridge(uint8_t address) {
+            this->address=address;
+            // CONFIG AS MASTER OR SLAVE WITH ADDRESS
+        }
+
+        void setup(FullLoopbackStream *outgoingStream){
+            this->outgoingStream = outgoingStream;
+        }
+
+        void loop() {
+        #if I2C_SERIAL_BYPASS_DEBUG
+          //  Serial.print("\n I2CSerialBridge - loop");
+          //  Serial.flush();
+        #endif
+        // put your main code here, to run repeatedly
+        check_status();
+        this->flush();
+    }
+
+    void flush() {
+    // if there is data available in the stream, it's meant
+    //  to go from Serial port to the slave
+    size_t availableLength = this->outgoingStream->available();
+    if (availableLength)
+    {
+        #if I2C_SERIAL_BYPASS_DEBUG
+            Serial.println("\n I2CSerialBridge - flush");
+            Serial.print("\nflushing with this much data:");
+            Serial.print(availableLength);
+        #endif
+
+
+      // read the available data from the stream, and put in in the buffer
+      char sbuf[availableLength];
+      this->outgoingStream->readBytes(sbuf, availableLength);
+
+        // send data to client
+        WIRE.beginTransmission(address);
+        size_t total = WIRE.write(sbuf, availableLength);
+        WIRE.endTransmission();
+        //endWireTransmission(false);
+        // DEBUG OUTPUT STREAM
+        for (int i=0;i<availableLength;i++){
+            Serial.write(sbuf[i]);
+        }
+            Serial.flush();
+        /// END DEBUG OUTPUT STREAM
+
+        #if I2C_SERIAL_BYPASS_DEBUG
+ //           Serial.println("\n I2CSerialBridge - flush");
+//            Serial.printf("\n ---> data sent to client %s: %d bytes \n", I2C_ADDRESS, total);
+            // Serial.printf("%d %d\n",sbuf[0], sbuf[1]);
+        #endif
+      }
+    }
+
+
+     /** SETUP SERIAL BYPASS I2C MASTER, USE WHEN THIS DEVICE COMMAND THE SENDING WORKFLOW*/
+    void i2cSetupMaster(){
+        #if I2C_SERIAL_BYPASS_DEBUG
+            Serial.print("WIRE.BEGIN(), initializing....");
+        #endif
+        WIRE.begin();
+          #if I2C_SERIAL_BYPASS_DEBUG
+            Serial.print("WIRE CONFIGURING TIMEOUT 300 ms .... ");
+        #endif
+        WIRE.setTimeout(300);
+
+        while(!isSlaveAvailable()){
+                #if I2C_SERIAL_BYPASS_DEBUG
+                    Serial.print("\n Slave device not available, retrying 1 sec later");
+                #endif
+                delay(1000);
+        };
+    }
+
+    private:
+        /** TODO CONTROL THAT TRANSPORT LAYER IS READY AND CONNECTED*/
+        void check_status(){
+        #if I2C_SERIAL_BYPASS_DEBUG
+          //  Serial.println("\n I2CSerialBridge - check_status");
+          //  Serial.flush();
+        #endif
+        }
+
+
+
+
+uint8_t endWireTransmission(bool stop){
+	uint8_t error=WIRE.endTransmission(stop);
+	if(error==0){
+		Serial.print("\n Correct wire close \n");
+	}
+	if(error==1){
+		Serial.print("\n Wire buffer exausted \n");
+	}
+	if(error==2){
+		Serial.print("\n received NACK on transmit of address.\n");
+	}
+	if(error==3){
+		Serial.print("received NACK on transmit of data.");
+	}
+	if(error==4){
+		Serial.print(" other error.");
+	}
+	if(error==5){
+		Serial.print("timeout");
+	}
+    Serial.print("\n Error code is ");
+    Serial.print(error);
+    Serial.println();
+	Serial.flush();
+	return error;
+
+}
+
+bool isSlaveAvailable(){
+     #if I2C_SERIAL_BYPASS_DEBUG
+            Serial.print("\n Testing slave availability -> Beging transmission to  ");
+            Serial.print(I2C_ADDRESS);
+            Serial.println("\n");
+     #endif
+	WIRE.beginTransmission(I2C_ADDRESS);
+    uint8_t error = endWireTransmission(true);
+
+	if(error==0){
+		Serial.print("\n Slave device detected at address ");
+        Serial.print(I2C_ADDRESS);
+        Serial.print("\n");
+		return true;
+	}
+	return false;
+}
+
+
+};

lib/I2CSerialBridge/I2CTransport.h

@@ -0,0 +1,12 @@
+#pragma once
+#include <Wire.h>
+
+#include <FullLoopbackStream.h>
+
+class I2CTransport {
+	public:
+	I2CTransport(){}
+	virtual void loop() = 0 ;
+	virtual void flush() = 0;
+	virtual void setup(Stream *) = 0;
+};