Upload folder using huggingface_hub

.gitattributes

@@ -33,3 +33,17 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+*.DS_Store filter=lfs diff=lfs merge=lfs -text
+*.gitignore filter=lfs diff=lfs merge=lfs -text
+*.md filter=lfs diff=lfs merge=lfs -text
+*.ino filter=lfs diff=lfs merge=lfs -text
+*.py filter=lfs diff=lfs merge=lfs -text
+*.txt filter=lfs diff=lfs merge=lfs -text
+*.csv filter=lfs diff=lfs merge=lfs -text
+*.log filter=lfs diff=lfs merge=lfs -text
+*.pyc filter=lfs diff=lfs merge=lfs -text
+*.sh filter=lfs diff=lfs merge=lfs -text
+/sensor_calibration_data filter=lfs diff=lfs merge=lfs -text
+*.yaml filter=lfs diff=lfs merge=lfs -text
+*.json filter=lfs diff=lfs merge=lfs -text
+*.wandb filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1 @@
+.idea/

Data_Collection_Scripts/README.md

@@ -0,0 +1,3 @@
+Each leg requires one Arduino to be flashed as master, and one as slave.
+
+The master Arduino should be connected to the Jetson.

Data_Collection_Scripts/arduino_master.ino

@@ -0,0 +1,130 @@
+#include <Wire.h>
+extern TwoWire Wire1; // Declare Wire1 for secondary I²C bus
+#include <SPI.h>
+#include <Adafruit_LSM6DSOX.h>
+
+#define CS_PIN 10 // Chip select pin for SPI
+
+#define BUFFER_SIZE 48 // 12 floats * 4 bytes per float
+
+// Sensor instances and addresses
+Adafruit_LSM6DSOX sensor1;
+uint8_t sensor1_addr = 0x6A; // Sensor 1 I2C address
+Adafruit_LSM6DSOX sensor2;
+uint8_t sensor2_addr = 0x6B; // Sensor 2 I2C address
+
+// Arrays to hold sensor data
+float masterData[12]; // Master's sensor data
+float slaveData[12];  // Slave's sensor data
+
+uint8_t slaveStorage[BUFFER_SIZE]; // Buffer to hold incoming data from slave
+
+// Buffer to hold combined data for I2C transmission
+#define TOTAL_DATA_SIZE 96        // 24 floats * 4 bytes per float
+uint8_t i2cData[TOTAL_DATA_SIZE]; // Holds both masterData and slaveData
+
+// Variables for I2C chunked transmission
+volatile uint8_t requestedChunk = 0;                                   // Chunk index requested by the master
+#define CHUNK_SIZE 32                                                  // Number of bytes per I2C chunk
+#define TOTAL_CHUNKS ((TOTAL_DATA_SIZE + CHUNK_SIZE - 1) / CHUNK_SIZE) // Total number of chunks
+
+void setup()
+{
+  Serial.begin(115200); // Initialize Serial for debugging
+
+  // Initialize SPI communication
+  pinMode(CS_PIN, OUTPUT);
+  digitalWrite(CS_PIN, HIGH); // Deselect the slave
+  SPI.begin();
+  SPI.beginTransaction(SPISettings(21000000, MSBFIRST, SPI_MODE0));
+
+  // Initialize sensors on default I2C bus (Wire)
+  Wire.begin(); // Initialize default I2C bus as master
+  while (!sensor1.begin_I2C(sensor1_addr, &Wire))
+  {
+    Serial.println("Failed to initialize sensor1!");
+    delay(10);
+  }
+
+  while (!sensor2.begin_I2C(sensor2_addr, &Wire))
+  {
+    Serial.println("Failed to initialize sensor2!");
+    delay(10);
+  }
+
+  sensor1.setAccelDataRate(LSM6DS_RATE_416_HZ);
+  sensor2.setAccelDataRate(LSM6DS_RATE_416_HZ);
+
+  // Initialize I2C as a slave on the secondary I2C bus (Wire1)
+  Wire1.begin(0x08);             // Join the I2C bus with address #8
+  Wire1.onReceive(receiveEvent); // Register the receive event handler
+  Wire1.onRequest(requestEvent); // Register the request event handler
+}
+
+void loop()
+{
+  // Read master's sensor data
+  updateMasterSensorData();
+
+  // Transfer data byte by byte (sending dummy data)
+  digitalWrite(CS_PIN, LOW); // Select the slave
+  for (size_t i = 0; i < BUFFER_SIZE; i++)
+  {
+    slaveStorage[i] = SPI.transfer(0x00); // Send dummy byte and receive data
+  }
+  digitalWrite(CS_PIN, HIGH); // Deselect the slave
+
+  // Reconstruct floats received from slave
+  memcpy(slaveData, slaveStorage, sizeof(slaveData));
+
+  // Prepare data for I2C transmission
+
+  Serial.println(slaveData[0]);
+  prepareI2CData();
+}
+
+// Function to read master's sensor data
+void updateMasterSensorData()
+{
+
+  // Read sensor1 data
+  sensor1.readAcceleration(masterData[0], masterData[1], masterData[2]);
+  sensor1.readGyroscope(masterData[3], masterData[4], masterData[5]);
+
+  // Read sensor2 data
+  sensor2.readAcceleration(masterData[6], masterData[7], masterData[8]);
+  sensor2.readGyroscope(masterData[9], masterData[10], masterData[11]);
+}
+
+// Function to prepare data for I2C transmission
+void prepareI2CData()
+{
+  // Combine masterData and slaveData into i2cData buffer
+  memcpy(i2cData, masterData, sizeof(masterData));                    // Copy masterData
+  memcpy(i2cData + sizeof(masterData), slaveData, sizeof(slaveData)); // Copy slaveData
+}
+
+// I2C receive event handler
+void receiveEvent(int numBytes)
+{
+  if (numBytes >= 1)
+  {
+    requestedChunk = Wire1.read(); // Read the requested chunk index
+    // Read additional bytes if needed (not in this case)
+  }
+}
+
+// I2C request event handler
+void requestEvent()
+{
+  // Send data in chunks of CHUNK_SIZE bytes based on requestedChunk
+  uint16_t offset = requestedChunk * CHUNK_SIZE;
+  uint8_t bytesToSend = CHUNK_SIZE;
+
+  if (offset + CHUNK_SIZE > TOTAL_DATA_SIZE)
+  {
+    bytesToSend = TOTAL_DATA_SIZE - offset;
+  }
+
+  Wire1.write(i2cData + offset, bytesToSend);
+}

Data_Collection_Scripts/arduino_slave.ino

@@ -0,0 +1,118 @@
+#include <SPI.h>
+#include <Adafruit_LSM6DSOX.h>
+#include <stdint.h>
+
+#define BUFFER_SIZE 48  // 12 floats * 4 bytes per float
+#define SS_PIN 10
+
+// Sensor instances and addresses
+Adafruit_LSM6DSOX sensor1;
+uint8_t sensor1_addr = 0x6A;
+Adafruit_LSM6DSOX sensor2;
+uint8_t sensor2_addr = 0x6B;
+
+// Variables to hold sensor data
+float sensorData[12];  // Array to hold sensor data
+
+volatile uint8_t pos = 0;
+volatile bool dataReady = false;
+volatile bool transferComplete = false;
+
+uint8_t sendStorage[BUFFER_SIZE];    // Buffer to store bytes to send to master
+
+// SPI interrupt number for the SAM3X8E chip:
+#define SPI0_INTERRUPT_NUMBER (IRQn_Type)24
+
+void setup() {
+  Serial.begin(115200);
+  slaveBegin(SS_PIN);  // Initialize SPI as slave on pin 10
+}
+
+void loop() {
+  if (transferComplete) {
+    transferComplete = false;  // Reset flag
+
+    // Update sensor data
+    updateSensorData();
+
+    // Prepare data to send in next SPI transaction
+    memcpy(sendStorage, sensorData, sizeof(sensorData));
+
+
+    // Serial.println(sensorData[11]);
+    // Preload TDR with the first byte to send
+    REG_SPI0_TDR = sendStorage[0];
+    pos = 1;  // Reset position for next transfer
+  }
+}
+
+void slaveBegin(uint8_t _pin) {
+  // Setup the SPI Interrupt registers
+  NVIC_ClearPendingIRQ(SPI0_INTERRUPT_NUMBER);
+  NVIC_EnableIRQ(SPI0_INTERRUPT_NUMBER);
+
+  // Initialize the SPI device with Arduino default values
+  SPI.begin(_pin);
+  REG_SPI0_CR = SPI_CR_SWRST;     // Reset SPI
+
+  // Setup interrupt
+  REG_SPI0_IDR = SPI_IDR_TDRE | SPI_IDR_MODF | SPI_IDR_OVRES |
+                 SPI_IDR_NSSR | SPI_IDR_TXEMPTY | SPI_IDR_UNDES;
+  REG_SPI0_IER = SPI_IER_RDRF;
+
+  // Setup the SPI registers
+  REG_SPI0_CR = SPI_CR_SPIEN;     // Enable SPI
+  REG_SPI0_MR = SPI_MR_MODFDIS;   // Slave and no modefault
+  REG_SPI0_CSR = SPI_MODE0;       // DLYBCT=0, DLYBS=0, SCBR=0, 8-bit transfer
+
+  // Initialize sensors
+  while (!sensor1.begin_I2C(sensor1_addr)) {
+    Serial.println("Failed to initialize sensor1!");
+    delay(10);
+  }
+
+  while (!sensor2.begin_I2C(sensor2_addr)) {
+    Serial.println("Failed to initialize sensor2!");
+    delay(10);
+  }
+
+  sensor1.setAccelDataRate(LSM6DS_RATE_416_HZ);
+  sensor2.setAccelDataRate(LSM6DS_RATE_416_HZ);
+
+  // Update sensor data for the first transfer
+  updateSensorData();
+  memcpy(sendStorage, sensorData, sizeof(sensorData));
+
+  // Preload TDR with the first byte to send
+  REG_SPI0_TDR = sendStorage[0];
+  pos = 1;  // Start position at 1 since first byte is already loaded
+}
+
+void updateSensorData() {
+  // Read sensor1 data
+  sensor1.readAcceleration(sensorData[0], sensorData[1], sensorData[2]);
+  sensor1.readGyroscope(sensorData[3], sensorData[4], sensorData[5]);
+
+  // Read sensor2 data
+  sensor2.readAcceleration(sensorData[6], sensorData[7], sensorData[8]);
+  sensor2.readGyroscope(sensorData[9], sensorData[10], sensorData[11]);
+}
+
+void SPI0_Handler(void) {
+  uint32_t status = REG_SPI0_SR;
+
+  // Check if data has been received
+  if (status & SPI_SR_RDRF) {
+    // Read byte from SPI data register
+    uint8_t received_byte = REG_SPI0_RDR & 0xFF;
+
+    // Load next byte to transmit
+    if (pos < BUFFER_SIZE) {
+      REG_SPI0_TDR = sendStorage[pos++];
+    } else {
+      // All bytes have been sent
+      transferComplete = true;
+      pos = 0;  // Reset position for the next transfer
+    }
+  }
+}

Data_Collection_Scripts/left.py

@@ -0,0 +1,56 @@
+from smbus2 import SMBus
+import time
+import struct
+
+I2C_BUS_NUMBER = 1
+
+# I2C address of the Arduino
+ARDUINO_I2C_ADDRESS = 0x08
+
+# Total number of bytes to read (24 floats * 4 bytes per float)
+TOTAL_BYTES = 96
+
+# Maximum bytes per I2C transaction (due to limitations)
+CHUNK_SIZE = 32
+
+OUTPUT_FILE = "left_data.txt"
+
+
+def read_i2c_data(bus, addr, total_bytes, chunk_size):
+    data = []
+    chunks = (total_bytes + chunk_size - 1) // chunk_size
+    for chunk_index in range(chunks):
+        # Use read_i2c_block_data which sends a command byte before reading data
+        to_read = min(chunk_size, total_bytes - (chunk_index * chunk_size))
+        chunk_data = bus.read_i2c_block_data(addr, chunk_index, to_read)
+        data.extend(chunk_data)
+    return data
+
+
+
+with SMBus(I2C_BUS_NUMBER) as bus, open(OUTPUT_FILE,'w') as f:  # Use the correct I2C bus number
+    while True:
+        try:
+            # Read data in chunks
+            data = read_i2c_data(bus, ARDUINO_I2C_ADDRESS, TOTAL_BYTES, CHUNK_SIZE)
+
+            # Convert byte data to floats
+            floats = []
+            for i in range(0, TOTAL_BYTES, 4):
+                # Combine 4 bytes into a float
+                float_bytes = bytes(data[i:i+4])
+                value = struct.unpack('<f', float_bytes)[0]  # '<f' for little-endian float
+                floats.append(value)
+
+            # Split into master and slave data
+            masterData = floats[:12]
+            slaveData = floats[12:]
+
+            # Print the data
+            f.write(f"{time.time()}\nM: {masterData}\nS:{slaveData}")
+            # print(f"{time.time()}\nM: {masterData}\nS:{slaveData}")
+
+        except Exception as e:
+            f.write(f"Error: {e}")
+            # print((f"Error: {e}"))
+

Data_Collection_Scripts/requirements.txt

@@ -0,0 +1 @@
+smbus2==0.5.0

Data_Collection_Scripts/right.py

@@ -0,0 +1,57 @@
+from smbus2 import SMBus
+import time
+import struct
+
+
+I2C_BUS_NUMBER = 7
+
+# I2C address of the Arduino
+ARDUINO_I2C_ADDRESS = 0x08
+
+# Total number of bytes to read (24 floats * 4 bytes per float)
+TOTAL_BYTES = 96
+
+# Maximum bytes per I2C transaction (due to limitations)
+CHUNK_SIZE = 32
+
+OUTPUT_FILE = "right_data.txt"
+
+
+def read_i2c_data(bus, addr, total_bytes, chunk_size):
+    data = []
+    chunks = (total_bytes + chunk_size - 1) // chunk_size
+    for chunk_index in range(chunks):
+        # Use read_i2c_block_data which sends a command byte before reading data
+        to_read = min(chunk_size, total_bytes - (chunk_index * chunk_size))
+        chunk_data = bus.read_i2c_block_data(addr, chunk_index, to_read)
+        data.extend(chunk_data)
+    return data
+
+
+
+with SMBus(I2C_BUS_NUMBER) as bus, open(OUTPUT_FILE,'w') as f:  # Use the correct I2C bus number
+    while True:
+        try:
+            # Read data in chunks
+            data = read_i2c_data(bus, ARDUINO_I2C_ADDRESS, TOTAL_BYTES, CHUNK_SIZE)
+
+            # Convert byte data to floats
+            floats = []
+            for i in range(0, TOTAL_BYTES, 4):
+                # Combine 4 bytes into a float
+                float_bytes = bytes(data[i:i+4])
+                value = struct.unpack('<f', float_bytes)[0]  # '<f' for little-endian float
+                floats.append(value)
+
+            # Split into master and slave data
+            masterData = floats[:12]
+            slaveData = floats[12:]
+
+            # Print the data
+            f.write(f"{time.time()}\nM: {masterData}\nS:{slaveData}")
+            # print(f"{time.time()}\nM: {masterData}\nS:{slaveData}")
+
+        except Exception as e:
+            f.write(f"Error: {e}")
+            # print((f"Error: {e}"))
+

Data_Collection_Scripts/run_legs.py

@@ -0,0 +1,24 @@
+""""
+This file just runs both leg collections at once.
+The 3 second delay between scripts is because we experienced some I2C errors when trying to
+instantaneously access both I2C busses on the Jetson. 
+"""
+
+import subprocess
+import time
+
+DELAY_SECONDS = 3
+
+right = 'right.py'
+left = 'left.py'
+
+print(f"Running {right}")
+subprocess.run(["python",right])
+
+print(f"Waiting {DELAY_SECONDS} seconds...")
+time.sleep(DELAY_SECONDS)
+
+print(f"Running {left}")
+subprocess.run(["python",left])
+
+print("Run complete.")

NewAccelMaster/NewAccelMaster.ino

@@ -0,0 +1,90 @@
+/*
+  Arduino LSM6DSOX - Simple Accelerometer
+
+  This example reads the acceleration values from the LSM6DSOX
+  sensor and continuously prints them to the Serial Monitor
+  or Serial Plotter.
+
+  The circuit:
+  - Arduino Nano RP2040 Connect
+
+  created 10 May 2021
+  by Arturo Guadalupi
+
+  This example code is in the public domain.
+*/
+
+#include <Adafruit_LSM6DSOX.h>
+#include <string>
+#include <TimeLib.h>
+Adafruit_LSM6DSOX sensor1;
+uint8_t sensor1_addr = 0x6A;
+Adafruit_LSM6DSOX sensor2;
+uint8_t sensor2_addr = 0x6B;
+String comma = ",";
+String colon = ":";
+float ax1, ay1, az1, ax2, gx1, gy1, gz1, ay2, az2, gx2, gy2, gz2;
+uint32_t count;
+
+void setup() {
+  pinMode(2, OUTPUT);
+  pinMode(3, OUTPUT);
+  pinMode(4, OUTPUT);
+
+  Serial.begin(115200);
+  while (!Serial);
+
+  while (!sensor1.begin_I2C(sensor1_addr)) {
+    Serial.println("Failed to initialize 0x6A!");
+    delay(10);
+  }
+
+  sensor1.setAccelDataRate(LSM6DS_RATE_6_66K_HZ);
+  Serial.print("Accelerometer sample rate = ");
+  Serial.print(sensor1.accelerationSampleRate());
+  Serial.println(" Hz");
+  Serial.println();
+  Serial.println("Acceleration in g's");
+  Serial.println("X\tY\tZ");
+
+  while (!sensor2.begin_I2C(sensor2_addr)) {
+    Serial.println("Failed to initialize 0x6B!");
+    delay(10);
+  }
+  sensor2.setAccelDataRate(LSM6DS_RATE_6_66K_HZ);
+
+  count = 0;
+
+  while(!Serial.available());  // Wait for serial input
+
+  digitalWrite(2, HIGH); 
+  digitalWrite(2, LOW); 
+
+  digitalWrite(3, HIGH);  // Send signal pulse to others to sync counts
+  digitalWrite(3, LOW); 
+
+  digitalWrite(4, HIGH);
+  digitalWrite(4, LOW); 
+
+}
+
+void loop() {
+
+  digitalWrite(2, HIGH); 
+  digitalWrite(2, LOW); 
+
+  digitalWrite(3, HIGH);  // Send signal pulse to others to process
+  digitalWrite(3, LOW); 
+
+  digitalWrite(4, HIGH);
+  digitalWrite(4, LOW); 
+
+  sensor1.readAcceleration(ax1, ay1, az1);
+  sensor1.readGyroscope(gx1, gy1, gz1);
+  sensor2.readAcceleration(ax2, ay2, az2);  // Read in sensor data
+  sensor2.readGyroscope(gx2, gy2, gz2);
+    
+  Serial.print(count++ + colon + ax1 + comma + ay1 + comma + az1 + comma + ax2 + comma + ay2 + comma + az2 + comma);
+  Serial.println(gx1 + comma + gy1 + comma + gz1 + comma + gx2 + comma + gy2 + comma + gz2);
+
+}

NewAccelerometer/NewAccelerometer.ino

@@ -0,0 +1,70 @@
+/*
+  Arduino LSM6DSOX - Simple Accelerometer
+
+  This example reads the acceleration values from the LSM6DSOX
+  sensor and continuously prints them to the Serial Monitor
+  or Serial Plotter.
+
+  The circuit:
+  - Arduino Nano RP2040 Connect
+
+  created 10 May 2021
+  by Arturo Guadalupi
+
+  This example code is in the public domain.
+*/
+
+#include <Adafruit_LSM6DSOX.h>
+#include <string>
+#include <TimeLib.h>
+Adafruit_LSM6DSOX sensor1;
+uint8_t sensor1_addr = 0x6A;
+Adafruit_LSM6DSOX sensor2;
+uint8_t sensor2_addr = 0x6B;
+String comma = ",";
+String colon = ":";
+float ax1, ay1, az1, ax2, gx1, gy1, gz1, ay2, az2, gx2, gy2, gz2;
+uint32_t count;
+
+void setup() {
+  pinMode(2, INPUT);
+
+  Serial.begin(115200);
+  while (!Serial);
+
+  while (!sensor1.begin_I2C(sensor1_addr)) {
+    Serial.println("Failed to initialize 0x6A!");
+    delay(10);
+  }
+
+  sensor1.setAccelDataRate(LSM6DS_RATE_6_66K_HZ);
+  Serial.print("Accelerometer sample rate = ");
+  Serial.print(sensor1.accelerationSampleRate());
+  Serial.println(" Hz");
+  Serial.println();
+  Serial.println("Acceleration in g's");
+  Serial.println("X\tY\tZ");
+
+  while (!sensor2.begin_I2C(sensor2_addr)) {
+    Serial.println("Failed to initialize 0x6B!");
+    delay(10);
+  }
+  sensor2.setAccelDataRate(LSM6DS_RATE_6_66K_HZ);
+
+  while(!digitalRead(2));  // Wait for signal to start
+  count = 0;
+}
+
+void loop() {
+
+  while(!digitalRead(2));  // Wait for signal to proceed
+
+  sensor1.readAcceleration(ax1, ay1, az1);
+  sensor1.readGyroscope(gx1, gy1, gz1);
+  sensor2.readAcceleration(ax2, ay2, az2);  // Read in sensor data
+  sensor2.readGyroscope(gx2, gy2, gz2);
+
+  Serial.print(count++ + colon + ax1 + comma + ay1 + comma + az1 + comma + gx1 + comma + gy1 + comma + gz1);
+  Serial.println(ax2 + comma + ay2 + comma + az2 + comma + gx2 + comma + gy2 + comma + gz2);
+  
+}

README.md

@@ -0,0 +1 @@
+#starx

SimpleAccelMaster/SimpleAccelMaster.ino

@@ -0,0 +1,78 @@
+/*
+  Arduino LSM6DSOX - Simple Accelerometer
+
+  This example reads the acceleration values from the LSM6DSOX
+  sensor and continuously prints them to the Serial Monitor
+  or Serial Plotter.
+
+  The circuit:
+  - Arduino Nano RP2040 Connect
+
+  created 10 May 2021
+  by Arturo Guadalupi
+
+  This example code is in the public domain.
+*/
+
+#include <Adafruit_LSM6DSOX.h>
+#include <string>
+#include <TimeLib.h>
+Adafruit_LSM6DSOX sensor1;
+uint8_t sensor1_addr = 0x6A;
+Adafruit_LSM6DSOX sensor2;
+uint8_t sensor2_addr = 0x6B;
+String comma = ",";
+float ax1, ay1, az1, ax2, gx1, gy1, gz1, ay2, az2, gx2, gy2, gz2;
+uint32_t time_start;
+
+void setup() {
+  pinMode(2, OUTPUT);
+  pinMode(3, OUTPUT);
+  pinMode(4, OUTPUT);
+
+  Serial.begin(115200);
+  while (!Serial);
+
+  while (!sensor1.begin_I2C(sensor1_addr)) {
+    Serial.println("Failed to initialize 0x6A!");
+    delay(10);
+  }
+
+  sensor1.setAccelDataRate(LSM6DS_RATE_416_HZ);
+  Serial.print("Accelerometer sample rate = ");
+  Serial.print(sensor1.accelerationSampleRate());
+  Serial.println(" Hz");
+  Serial.println();
+  Serial.println("Acceleration in g's");
+  Serial.println("X\tY\tZ");
+
+  while (!sensor2.begin_I2C(sensor2_addr)) {
+    Serial.println("Failed to initialize 0x6B!");
+    delay(10);
+  }
+  sensor2.setAccelDataRate(LSM6DS_RATE_416_HZ);
+
+  digitalWrite(2, HIGH);
+  digitalWrite(3, HIGH);
+  digitalWrite(4, HIGH);
+
+  time_start = millis();
+}
+
+void loop() {
+  if (sensor1.accelerationAvailable())
+      sensor1.readAcceleration(ax1, ay1, az1);
+
+  if (sensor1.gyroscopeAvailable())
+      sensor1.readGyroscope(gx1, gy1, gz1);
+
+  if (sensor2.accelerationAvailable())
+      sensor2.readAcceleration(ax2, ay2, az2);
+
+  if (sensor2.gyroscopeAvailable())
+      sensor2.readGyroscope(gx2, gy2, gz2);
+    
+  Serial.print((millis() - time_start) + comma + ax1 + comma + ay1 + comma + az1 + comma + ax2 + comma + ay2 + comma + az2 + comma);
+  Serial.println(gx1 + comma + gy1 + comma + gz1 + comma + gx2 + comma + gy2 + comma + gz2);
+  
+}

SimpleAccelerometer/SimpleAccelerometer.ino

@@ -0,0 +1,74 @@
+/*
+  Arduino LSM6DSOX - Simple Accelerometer
+
+  This example reads the acceleration values from the LSM6DSOX
+  sensor and continuously prints them to the Serial Monitor
+  or Serial Plotter.
+
+  The circuit:
+  - Arduino Nano RP2040 Connect
+
+  created 10 May 2021
+  by Arturo Guadalupi
+
+  This example code is in the public domain.
+*/
+
+#include <Adafruit_LSM6DSOX.h>
+#include <string>
+#include <TimeLib.h>
+Adafruit_LSM6DSOX sensor1;
+uint8_t sensor1_addr = 0x6A;
+Adafruit_LSM6DSOX sensor2;
+uint8_t sensor2_addr = 0x6B;
+String comma = ",";
+float ax1, ay1, az1, ax2, gx1, gy1, gz1, ay2, az2, gx2, gy2, gz2;
+uint32_t time_start;
+
+void setup() {
+  pinMode(2, INPUT);
+
+  Serial.begin(115200);
+  while (!Serial);
+
+  while (!sensor1.begin_I2C(sensor1_addr)) {
+    Serial.println("Failed to initialize 0x6A!");
+    delay(10);
+  }
+
+  sensor1.setAccelDataRate(LSM6DS_RATE_416_HZ);
+  Serial.print("Accelerometer sample rate = ");
+  Serial.print(sensor1.accelerationSampleRate());
+  Serial.println(" Hz");
+  Serial.println();
+  Serial.println("Acceleration in g's");
+  Serial.println("X\tY\tZ");
+
+  while (!sensor2.begin_I2C(sensor2_addr)) {
+    Serial.println("Failed to initialize 0x6B!");
+    delay(10);
+  }
+  sensor2.setAccelDataRate(LSM6DS_RATE_416_HZ);
+  
+  while(!digitalRead(2));
+
+  time_start = millis();
+}
+
+void loop() {
+
+  if (sensor1.accelerationAvailable())
+      sensor1.readAcceleration(ax1, ay1, az1);
+
+  if (sensor1.gyroscopeAvailable())
+      sensor1.readGyroscope(gx1, gy1, gz1);
+
+  if (sensor2.accelerationAvailable())
+      sensor2.readAcceleration(ax2, ay2, az2);
+
+  if (sensor2.gyroscopeAvailable())
+      sensor2.readGyroscope(gx2, gy2, gz2);
+    
+  Serial.print((millis() - time_start) + comma + ax1 + comma + ay1 + comma + az1 + comma + gx1 + comma + gy1 + comma + gz1);
+  Serial.println(ax2 + comma + ay2 + comma + az2 + comma + gx2 + comma + gy2 + comma + gz2);
+}

model/lstm/model.py

@@ -0,0 +1,15 @@
+import torch.nn as nn
+
+class LSTMModel(nn.Module):
+    def __init__(self, input_size=12, hidden_size=100, output_size=12, num_layers=2):
+        super(LSTMModel, self).__init__()
+        self.lstm = nn.LSTM(input_size=input_size,
+                            hidden_size=hidden_size,
+                            num_layers=num_layers,
+                            batch_first=True)
+        self.fc = nn.Linear(hidden_size, output_size)
+        
+    def forward(self, x):
+        out, _ = self.lstm(x)
+        out = self.fc(out)
+        return out

model/preprocess/preprocess.py

@@ -0,0 +1,65 @@
+import numpy as np
+import pandas as pd
+import torch
+import sys
+import os
+from sklearn.preprocessing import StandardScaler,MinMaxScaler
+np.set_printoptions(suppress=True)
+
+ss,mm = StandardScaler(), StandardScaler()
+thigh = pd.read_csv(f"../../data/unprocessed/{sys.argv[1]}/front_{sys.argv[1]}.txt",delimiter=',',usecols =[i for i in range(13) if i != 0])
+shin = pd.read_csv(f"../../data/unprocessed/{sys.argv[1]}/back_{sys.argv[1]}.txt",delimiter=',',usecols =[i for i in range(13) if i != 0])
+thigh,shin = thigh.dropna(),shin.dropna()
+delta = len(thigh) - len(shin)
+
+thigh = thigh[delta:]
+thigh.reset_index(inplace=True)
+thigh,shin = thigh[:55000],shin[:55000]
+
+for col in thigh.columns:
+    thigh.rename(columns={col:col+"_th"},inplace=True)
+    shin.rename(columns={col:col+"_sh"},inplace=True)
+
+
+p_columns_th = [col for col in thigh.columns if col.startswith('p')]
+s_columns_th = [col for col in thigh.columns if col.startswith('s')]
+p_columns_sh = [col for col in shin.columns if col.startswith('p')]
+s_columns_sh = [col for col in shin.columns if col.startswith('s')]
+
+
+
+features = thigh[p_columns_th]
+features = pd.concat([features,shin[p_columns_sh]],axis=1)
+
+labels = thigh[s_columns_th]
+labels = pd.concat([labels,shin[s_columns_sh]],axis=1)
+
+features_scaled = pd.DataFrame(ss.fit_transform(features), columns=features.columns)
+labels_scaled = pd.DataFrame(mm.fit_transform(labels), columns=labels.columns)
+
+os.makedirs(f"../../data/processed/{sys.argv[1]}",exist_ok=True)
+features.to_csv(f"../../data/processed/{sys.argv[1]}/features.csv")
+labels.to_csv(f"../../data/processed/{sys.argv[1]}/labels.csv")
+
+def preprocess_data(features_df, labels_df, lookback_window, predict_window, output_file):
+    lookback_window *= 150
+    predict_window *= 150
+
+    total_samples = len(features_df) - lookback_window - predict_window
+
+    x_data = torch.zeros((total_samples, lookback_window, features_df.shape[1]))
+    y_data = torch.zeros((total_samples, predict_window, labels_df.shape[1]))
+
+    for idx, i in enumerate(range(lookback_window, len(features_df) - predict_window)):
+        if idx % 1000 == 0:  
+            print(f"Processing sample {idx}/{total_samples}...")
+
+        x_data[idx] = torch.tensor(features_df.iloc[i - lookback_window:i].values, dtype=torch.float32)
+        y_data[idx] = torch.tensor(labels_df.iloc[i:i + predict_window].values, dtype=torch.float32)
+
+    torch.save({"x": x_data, "y": y_data}, output_file)
+    print(f"Preprocessed data saved to {output_file}")
+
+preprocess_data(features,labels,3,3,f"../../data/processed/{sys.argv[1]}/data.pt")
+
+

model/preprocess/run.sh

@@ -0,0 +1,2 @@
+python preprocess.py striding
+python preprocess.py walking

model/train/model.py

@@ -0,0 +1,48 @@
+import torch.nn as nn
+
+
+class LSTMModel(nn.Module):
+    def __init__(self, input_size=12, hidden_size=64, output_size=12, num_layers=2):
+        super(LSTMModel, self).__init__()
+        self.lstm = nn.LSTM(input_size=input_size,
+                            hidden_size=hidden_size,
+                            num_layers=num_layers,
+                            batch_first=True)
+        self.fc = nn.Linear(hidden_size, output_size)
+        
+    def forward(self, x):
+        out, _ = self.lstm(x)
+        out = self.fc(out)
+        return out
+
+from transformers import PreTrainedModel, PretrainedConfig
+import torch.nn as nn
+
+# Define a custom configuration class
+class LSTMConfig(PretrainedConfig):
+    model_type = "lstm_model"
+
+    def __init__(self, input_size=12, hidden_size=100, output_size=12, num_layers=2, **kwargs):
+        super().__init__(**kwargs)
+        self.input_size = input_size
+        self.hidden_size = hidden_size
+        self.output_size = output_size
+        self.num_layers = num_layers
+
+
+# Define the Hugging Face-compatible model
+class HuggingFaceLSTM(PreTrainedModel):
+    config_class = LSTMConfig
+
+    def __init__(self, config):
+        super().__init__(config)
+        self.lstm_model = LSTMModel(
+            input_size=config.input_size,
+            hidden_size=config.hidden_size,
+            output_size=config.output_size,
+            num_layers=config.num_layers,
+        )
+
+    def forward(self, x, **kwargs):
+        return self.lstm_model(x)
+    

model/train/test.py

@@ -0,0 +1,120 @@
+import torch
+import numpy as np
+import random
+import os
+from torch.utils.data import DataLoader, TensorDataset
+from torch.utils.data.dataloader import default_collate
+import torch.optim.lr_scheduler as lr_scheduler
+
+from tqdm import tqdm
+import matplotlib.pyplot as plt
+os.environ["PYTORCH_CUDA_ALLOC_CONF"] = "expandable_segments:True"
+
+def set_seed(seed):
+    np.random.seed(seed)
+    random.seed(seed)
+    torch.manual_seed(seed)
+    torch.cuda.manual_seed_all(seed)
+    torch.backends.cudnn.deterministic = True
+    torch.backends.cudnn.benchmark = False
+
+set_seed(42)
+
+from model import HuggingFaceLSTM
+from model import LSTMConfig
+
+def setup_model(device):
+    config = LSTMConfig(
+        input_size=12, 
+        hidden_size=100,
+        output_size=12, 
+        num_layers=2
+    )
+
+    model = HuggingFaceLSTM(config)
+
+    model.to(device)
+
+    return model
+
+
+def setup_data(data,batch_size):
+    train_split = int(0.85 * 54100)
+    X = data['x']
+    y = data['y']
+
+    X_train = X[:train_split]
+    y_train = y[:train_split]
+
+    def normalize_dataset(data):
+        data_min = data.amin(dim=(0, 1), keepdim=True) 
+        data_max = data.amax(dim=(0, 1), keepdim=True)  
+        normalized_data = (data - data_min) / (data_max - data_min + 1e-8)  
+        return normalized_data
+
+    X_norm = normalize_dataset(X_train)
+    y_norm = normalize_dataset(y_train)
+
+    train_dataset = TensorDataset(X_norm,y_norm)
+    train_loader = DataLoader(
+        train_dataset, 
+        batch_size=batch_size, 
+        shuffle=True,
+        collate_fn=lambda x: tuple(x_.to(device) for x_ in default_collate(x))
+        )
+    
+    return train_loader
+    
+def train(n_epochs, model, opt,scheduler, loss_fn, batched_data):
+    model.train()
+    for epoch in range(n_epochs):
+        epoch_loss = 0.0  
+        n_batch = len(batched_data)
+
+        with tqdm(total=n_batch, desc=f"Epoch {epoch+1}/{n_epochs}", unit="batch") as bar:
+            for i, (inputs, targets) in enumerate(batched_data):
+
+                outputs = model(inputs)
+                loss = loss_fn(outputs, targets)
+                opt.zero_grad()
+                loss.backward()
+                opt.step()
+                
+                epoch_loss += loss.item()
+                if epoch % 1 == 0:
+                    plt.plot(outputs[0,:,0].detach().squeeze().cpu(),label="Prediction")
+                    plt.plot(targets[0,:,0].detach().squeeze().cpu(),label="Actual")
+                    plt.title("s_a_x_th")
+                    plt.legend()
+                    plt.savefig(f"im_{epoch}.png")
+                    plt.clf()
+                scheduler.step()
+                bar.set_description(f"Epoch {epoch+1}/{n_epochs} | Loss: {epoch_loss / (i+1):.6f}")
+                bar.update(1) 
+
+            print(f"Epoch {epoch+1}/{n_epochs} completed. Average Loss: {epoch_loss / n_batch:.6f}")
+
+
+
+if __name__ == "__main__":
+
+    device = torch.device('cuda:1')
+    raw_data = torch.load('../../data/processed/striding/data.pt')
+    model = setup_model(device)
+    train_data = setup_data(data=raw_data,batch_size=2048)
+    try:
+        lr = 0.001
+        adam = torch.optim.Adam(model.parameters(),lr=lr)
+        linear_scheduler = lr_scheduler.LinearLR(adam, start_factor=1.0, end_factor=0.5, total_iters=30)
+        train(
+            n_epochs=1000,
+            model=model,
+            opt=adam,
+            scheduler=linear_scheduler,
+            loss_fn=torch.nn.HuberLoss(),
+            batched_data=train_data
+        )
+    except Exception as e:
+        print(e)
+        model.save_pretrained("./lstm_model_with_lr")
+    model.save_pretrained("./lstm_model_with_lr")

model/train/tran.py

@@ -0,0 +1,208 @@
+import torch.nn as nn
+import torch
+import matplotlib.pyplot as plt 
+from tqdm import tqdm
+from torch.utils.data import DataLoader,TensorDataset,default_collate
+device = torch.device('cuda:1')
+from torch.optim import lr_scheduler
+class TransformerModel(nn.Module):
+    def __init__(self, input_size=12, hidden_size=64, output_size=12, num_layers=2, nhead=4, seq_length=450):
+        super(TransformerModel, self).__init__()
+        self.input_size = input_size
+        self.hidden_size = hidden_size
+        self.output_size = output_size
+        self.seq_length = seq_length
+
+        # Input embedding layer to project input to hidden size
+        self.embedding = nn.Linear(input_size, hidden_size)
+        
+        # Positional encoding for sequence information
+        self.positional_encoding = nn.Parameter(torch.zeros(1, seq_length, hidden_size))
+        
+        # Transformer encoder
+        encoder_layer = nn.TransformerEncoderLayer(d_model=hidden_size, nhead=nhead,dropout=0.3)
+        self.transformer = nn.TransformerEncoder(encoder_layer, num_layers=num_layers)
+        
+        # Output projection layer
+        self.fc = nn.Linear(hidden_size, output_size)
+
+    def forward(self, x):
+        # x: (batch_size, seq_length, input_size)
+        
+        # Apply input embedding
+        x = self.embedding(x)  # (batch_size, seq_length, hidden_size)
+        
+        # Add positional encoding
+        x = x + self.positional_encoding  # (batch_size, seq_length, hidden_size)
+        
+        # Pass through transformer
+        x = self.transformer(x.permute(1, 0, 2))  # Transformer expects (seq_length, batch_size, hidden_size)
+        
+        # Project back to output size
+        x = self.fc(x.permute(1, 0, 2))  # (batch_size, seq_length, output_size)
+        return x
+
+
+from transformers import PreTrainedModel, PretrainedConfig
+
+class TransformerConfig(PretrainedConfig):
+    model_type = "transformer_model"
+
+    def __init__(self, input_size=12, hidden_size=64, output_size=12, num_layers=2, nhead=4, seq_length=450, **kwargs):
+        super().__init__(**kwargs)
+        self.input_size = input_size
+        self.hidden_size = hidden_size
+        self.output_size = output_size
+        self.num_layers = num_layers
+        self.nhead = nhead
+        self.seq_length = seq_length
+
+class HuggingFaceTransformer(PreTrainedModel):
+    config_class = TransformerConfig
+
+    def __init__(self, config):
+        super().__init__(config)
+        self.transformer_model = TransformerModel(
+            input_size=config.input_size,
+            hidden_size=config.hidden_size,
+            output_size=config.output_size,
+            num_layers=config.num_layers,
+            nhead=config.nhead,
+            seq_length=config.seq_length,
+        )
+
+    def forward(self, x, **kwargs):
+        return self.transformer_model(x)
+
+
+config = TransformerConfig(
+    input_size=12,
+    hidden_size=64,
+    output_size=12,
+    num_layers=2,
+    nhead=4,
+    seq_length=450,
+)
+
+model = HuggingFaceTransformer(config)
+
+def train(
+    n_epochs, 
+    model, 
+    opt, 
+    scheduler, 
+    loss_fn, 
+    train_loader, 
+    save_path="./model_checkpoint.pt"
+):
+    best_val_loss = float("inf")
+    training_history = {"train_loss": [], "val_loss": []}
+    
+    for epoch in range(n_epochs):
+        model.train()  # Set model to training mode
+        train_loss = 0.0  
+        n_train_batch = len(train_loader)
+
+        # Training Loop
+        with tqdm(total=n_train_batch, desc=f"Epoch {epoch+1}/{n_epochs}", unit="batch") as bar:
+            for i, (inputs, targets) in enumerate(train_loader):
+                inputs, targets = inputs.to(next(model.parameters()).device), targets.to(next(model.parameters()).device)
+
+                # Forward pass
+                outputs = model(inputs)
+                loss = loss_fn(outputs, targets)
+
+                # Backward pass
+                opt.zero_grad()
+                loss.backward()
+                opt.step()
+
+                train_loss += loss.item()
+
+                # Update the progress bar
+                avg_train_loss = train_loss / (i + 1)
+                bar.set_postfix({"Train Loss": avg_train_loss})
+                bar.update(1)
+
+        # Step the scheduler after the epoch
+        scheduler.step()
+
+        # Log training loss
+        training_history["train_loss"].append(train_loss / n_train_batch)
+
+
+        # Plot Predictions Every Epoch
+        if epoch % 1 == 0:
+            plt.figure(figsize=(10, 6))
+            plt.plot(outputs[0, :, 0].detach().cpu(), label="Prediction")
+            plt.plot(targets[0, :, 0].detach().cpu(), label="Actual")
+            plt.title(f"Epoch {epoch+1} Predictions")
+            plt.legend()
+            plt.savefig(f"predictions_epoch_{epoch+1}.png")
+            plt.close()
+
+        print(f"Epoch {epoch+1}/{n_epochs} Completed. Train Loss: {avg_train_loss:.6f}")
+
+    # Return the training history for analysis
+    return training_history
+
+
+
+def setup_data(data, batch_size):
+    train_split = int(0.85 * len(data['x']))
+    X = data['x']
+    y = data['y']
+
+    X_train = X[:train_split]
+    y_train = y[:train_split]
+    X_val = X[train_split:]
+    y_val = y[train_split:]
+
+    def normalize_dataset(data):
+        data_min = data.amin(dim=(0, 1), keepdim=True)
+        data_max = data.amax(dim=(0, 1), keepdim=True)
+        normalized_data = (data - data_min) / (data_max - data_min + 1e-8)
+        return normalized_data
+
+    X_train_norm = normalize_dataset(X_train)
+    y_train_norm = normalize_dataset(y_train)
+    X_val_norm = normalize_dataset(X_val)
+    y_val_norm = normalize_dataset(y_val)
+
+    train_dataset = TensorDataset(X_train_norm, y_train_norm)
+    val_dataset = TensorDataset(X_val_norm, y_val_norm)
+
+    train_loader = DataLoader(
+        train_dataset,
+        batch_size=batch_size,
+        shuffle=True,
+        collate_fn=lambda x: tuple(x_.to(device) for x_ in default_collate(x)),
+    )
+    return train_loader
+
+
+if __name__ == "__main__":
+    device = torch.device('cuda:1')
+    raw_data = torch.load('../../data/processed/striding/data.pt')
+
+    train_loader = setup_data(data=raw_data, batch_size=2048)
+
+    lr = 0.001
+    adam = torch.optim.Adam(model.parameters(), lr=lr)
+    linear_scheduler = lr_scheduler.LinearLR(adam, start_factor=1.0, end_factor=0.5, total_iters=30)
+
+    history = train(
+        n_epochs=100,
+        model=model,
+        opt=adam,
+        scheduler=linear_scheduler,
+        loss_fn=torch.nn.HuberLoss(),
+        train_loader=train_loader,
+        save_path="./best_model.pt"
+    )
+
+    # Save final model
+    torch.save(model.state_dict(), "./final_model.pt")
+
+
+

sensor_calibration_data

@@ -0,0 +1,38 @@
+1
+0.0136, -0.008133, 0.0043
+
+2
+0.0049, 0.0006, -0.0086
+0.0006, 0.0037, -0.0122
+0.0055, 0.0012, -0.0098
+
+3
+0.0086, -0.0012, 0.0031
+0.0086, 0.0000, 0.0031
+0.0086, 0.0000, 0.0024
+
+4
+0.0000, -0.0031, 0.0061
+0.0000, -0.0037, 0.0061
+0.0000, -0.0037, 0.0061
+
+5
+0.0073, -0.0079, 0.0024
+0.0067, -0.0079, 0.0024
+0.0073, -0.0079, 0.0024
+
+7
+-0.0012, -0.0049, -0.0159
+-0.0012, -0.0049, -0.0147
+-0.0012, -0.0049, -0.0153
+
+9
+0.0018, -0.0061, 0.0000
+0.0012, -0.0061, 0.0000
+0.0018, -0.0061, -0.0006
+
+10
+0.0086, -0.0079, -0.0006
+
+11
+-0.0073, -0.0073, -0.0012