Upload folder using huggingface_hub

.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);
+}

data/processed/striding/data.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c52b74a822f57953dbc97ca68a8f697a7fd756cd8da944b1977b0bb138474a73
+size 2337121286

data/processed/walking/data.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2a738719e7697a42803ddf3efd0481a3d23f81b11fe2aa9c41b7ab3868d028b6
+size 2337121286

model/lstm/model.py

@@ -0,0 +1,32 @@
+import torch
+import torch.nn as nn
+
+class STARM(nn.Module):
+    def __init__(self, num_classes, input_size, hidden_size, num_layers):
+        super().__init__()
+        self.num_classes = num_classes  # Output size
+        self.num_layers = num_layers  # Number of recurrent layers in the LSTM
+        self.input_size = input_size  # Input size
+        self.hidden_size = hidden_size  # Neurons in each LSTM layer
+
+        # LSTM model
+        self.lstm = nn.LSTM(input_size=input_size, hidden_size=hidden_size,
+                            num_layers=num_layers, batch_first=True, dropout=0)
+
+        self.fc_1 = nn.Linear(hidden_size, 128)  # Fully connected layer
+        self.fc_2 = nn.Linear(128, num_classes)  # Fully connected last layer
+        self.relu = nn.ReLU()  # ReLU activation
+
+    def forward(self, x):
+        # Initialize hidden and cell states
+        h_0 = torch.zeros(self.num_layers, x.size(0), self.hidden_size, device=x.device)
+        c_0 = torch.zeros(self.num_layers, x.size(0), self.hidden_size, device=x.device)
+
+        # Propagate input through LSTM
+        output, (hn, cn) = self.lstm(x)  # Shape: (batch_size, seq_length, hidden_size)
+
+        # Apply fully connected layers and ReLU for each time step
+        out = self.fc_1(output)  # Shape: (batch_size, seq_length, 128)
+        out = self.relu(out)     # Apply ReLU
+        out = self.fc_2(out)     # Shape: (batch_size, seq_length, num_classes)
+        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(), MinMaxScaler()
+thigh = pd.read_csv(f"../../data/unprocessed/{sys.argv[1]}/front.txt",delimiter=',',usecols =[i for i in range(13) if i != 0])
+shin = pd.read_csv(f"../../data/unprocessed/{sys.argv[1]}/back.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[s_columns_th]
+features = pd.concat([features,shin[s_columns_sh]],axis=1)
+
+labels = thigh[p_columns_th]
+labels = pd.concat([labels,shin[p_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_scaled,labels_scaled,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/test.py

@@ -0,0 +1,6 @@
+import numpy as np
+np.set_printoptions(suppress=True)
+data = np.load('../../data/processed/striding/data.npz')
+data_check = np.load('../../data/processed/striding/striding.npz')
+y = data['y']
+print(y[0])

model/train/train.py

@@ -0,0 +1,76 @@
+import numpy as np
+import torch
+import sys, os
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+from tqdm import tqdm
+from lstm.model import STARM
+np.set_printoptions(suppress=True)
+device = torch.device('cpu')
+torch.cuda.empty_cache()
+
+
+data = torch.load('../../data/processed/striding/data.pt')
+train_split = int(.85*54100)
+X = data['x']
+y = data['y']
+
+X_train  = X[:train_split] #, X_test = X[:train_split], X[train_split:]
+y_train  = y[:train_split] #, y_test = y[:train_split], y[train_split:]
+
+X_train = X_train.to(device)
+# X_test = X_test.to(device)
+y_train = y_train.to(device)
+# y_test = y_test.to(device)
+
+
+n_epoch = 1000
+lr = 0.001
+input_size = 12
+hidden_size = 2
+num_lstm = 1
+num_classes = 12
+
+lstm = STARM(
+    num_classes,
+    input_size,
+    hidden_size,
+    num_lstm
+).to(device)
+
+loss_fn = torch.nn.MSELoss() 
+optimiser = torch.optim.Adam(lstm.parameters(), lr=lr)
+
+
+def training_loop(n_epochs, lstm, optimiser, loss_fn, X_train, y_train, batch_size=541000):
+    dataset_size = X_train.size(0)
+    num_batches = (dataset_size + batch_size - 1) // batch_size  # Number of batches
+
+    for epoch in range(n_epochs):
+        lstm.train()
+        epoch_loss = 0.0  # To accumulate loss for the epoch
+
+        # Progress bar for each epoch
+        with tqdm(total=num_batches, desc=f"Epoch {epoch + 1}/{n_epochs}", unit="batch") as pbar:
+            for i in range(0, dataset_size, batch_size):
+                # Get batch
+                X_batch = X_train[i:i + batch_size]
+                y_batch = y_train[i:i + batch_size]
+
+                # Forward pass
+                outputs = lstm(X_batch)
+                optimiser.zero_grad()
+
+                # Compute loss
+                loss = loss_fn(outputs, y_batch)
+                loss.backward()
+                optimiser.step()
+
+                # Update progress bar and accumulate epoch loss
+                epoch_loss += loss.item()
+                pbar.set_postfix({"loss": loss.item()})
+                pbar.update(1)  # Increment progress bar by 1 batch
+
+        print(f"Epoch {epoch + 1} completed. Average loss: {epoch_loss / num_batches:.5f}")
+
+
+training_loop(n_epochs=n_epoch,lstm=lstm,optimiser=optimiser,loss_fn=loss_fn,X_train=X_train,y_train=y_train)

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