Compatibility with ESP32S3

firmware/lucidgloves-firmware/ConfigUtils.h

@@ -44,6 +44,7 @@ class ordered_lock {
 //Comm
 #define COMM_SERIAL 0   
 #define COMM_BTSERIAL 1 
+#define COMM_BLESERIAL 2 
 
 //Encode
 #define ENCODE_LEGACY 0

firmware/lucidgloves-firmware/SerialBLECommunication.ino

@@ -0,0 +1,91 @@
+//only compiles if BLESerial is set because it won't compile for a non-compatible board
+#if COMMUNICATION == COMM_BLESERIAL
+#include <NimBLEDevice.h>
+#define   CONFIG_BT_NIMBLE_PINNED_TO_CORE   1 //Pins NimBLE to core 1
+static NimBLEServer* pServer;
+class BLESerialCommunication : public ICommunication {
+  private:
+    bool m_isOpen;
+
+  public:
+    BLESerialCommunication() {
+      m_isOpen = false;
+    }
+
+    class ServerCallbacks: public NimBLEServerCallbacks {
+      void onConnect(NimBLEServer* pServer) {
+          #ifdef NEOPIXEL
+          neopixelWrite(DEBUG_LED,0,RGB_BRIGHTNESS,0); // Green
+          #endif
+      };
+      void onDisconnect(NimBLEServer* pServer) {
+          #ifdef NEOPIXEL
+          neopixelWrite(DEBUG_LED,0,0,RGB_BRIGHTNESS); // Blue
+          #endif
+      };
+    };
+
+    bool isOpen(){
+      return m_isOpen;
+    }
+
+    void start(){
+      NimBLEDevice::init(BTSERIAL_DEVICE_NAME);
+
+      pServer = NimBLEDevice::createServer();
+      pServer->setCallbacks(new ServerCallbacks());
+      NimBLEService *pService = pServer->createService("6E400001-B5A3-F393-E0A9-E50E24DCCA9E"); //Main service
+      NimBLECharacteristic *rxCharacteristic = pService->createCharacteristic("6E400002-B5A3-F393-E0A9-E50E24DCCA9E",NIMBLE_PROPERTY::WRITE);
+      NimBLECharacteristic *txCharacteristic = pService->createCharacteristic("6E400003-B5A3-F393-E0A9-E50E24DCCA9E",NIMBLE_PROPERTY::READ | NIMBLE_PROPERTY::NOTIFY);
+      pService->start();
+
+      NimBLEAdvertising *pAdvertising = NimBLEDevice::getAdvertising(); // create advertising instance
+      pAdvertising->addServiceUUID(pService->getUUID()); // tell advertising the UUID of our service
+      pAdvertising->start(); // start advertising
+
+      #if BT_ECHO
+      Serial.begin(SERIAL_BAUD_RATE);
+      Serial.println("The device started, now you can pair it with bluetooth!");
+      #endif
+      #ifdef NEOPIXEL
+      neopixelWrite(DEBUG_LED,0,0,RGB_BRIGHTNESS); // Blue
+      #endif
+      m_isOpen = true;
+    }
+
+    void output(char* data){
+      if(pServer->getConnectedCount()) {
+        NimBLEService* pSvc = pServer->getServiceByUUID("6E400001-B5A3-F393-E0A9-E50E24DCCA9E");
+        if(pSvc) {
+            NimBLECharacteristic* qChr = pSvc->getCharacteristic("6E400003-B5A3-F393-E0A9-E50E24DCCA9E");
+            if(qChr) {
+                qChr->setValue(String(data));
+                qChr->notify();
+            }
+        }
+      }
+      //else
+      //vTaskDelay(1); //keep watchdog fed
+      #if BT_ECHO
+      Serial.print(data);
+      Serial.flush();
+      #endif
+    }
+
+    bool readData(char* input){
+      /*byte size = m_SerialBT.readBytesUntil('\n', input, 100);
+      input[size] = NULL;*/
+      if(pServer->getConnectedCount()) {
+        NimBLEService* pSvc = pServer->getServiceByUUID("6E400001-B5A3-F393-E0A9-E50E24DCCA9E");
+        if(pSvc) {
+          NimBLECharacteristic* qChr = pSvc->getCharacteristic("6E400002-B5A3-F393-E0A9-E50E24DCCA9E");
+          if(qChr) {
+            //String message = qChr->getValue();
+            strcpy(input, qChr->getValue().c_str());
+          }
+        }
+      }
+      return input != NULL && strlen(input) > 0;
+    }
+};
+#endif

firmware/lucidgloves-firmware/_main.ino

@@ -44,13 +44,21 @@ void getInputs(void* parameter){
 
 int loops = 0;
 void setup() {
+  #ifndef ESP32S3
   pinMode(32, INPUT_PULLUP);
+  #endif
   pinMode(DEBUG_LED, OUTPUT);
-  digitalWrite(DEBUG_LED, HIGH);
+  #ifdef NEOPIXEL 
+  neopixelWrite(DEBUG_LED,RGB_BRIGHTNESS,0,0); // Red 
+  #else   
+  digitalWrite(DEBUG_LED, HIGH); 
+  #endif 
   #if COMMUNICATION == COMM_SERIAL
     comm = new SerialCommunication();
   #elif COMMUNICATION == COMM_BTSERIAL
     comm = new BTSerialCommunication();
+  #elif COMMUNICATION == COMM_BLESERIAL
+    comm = new BLESerialCommunication();
   #endif  
   comm->start();
 

firmware/lucidgloves-firmware/haptics.ino

@@ -1,7 +1,7 @@
 #if USING_FORCE_FEEDBACK
 
 #if defined(ESP32)
-  #include "ESP32Servo.h"
+  #include <Servo.h>
 #else
   #include "Servo.h"
 #endif
@@ -49,11 +49,19 @@ void dynScaleLimits(int* hapticLimits, float* scaledLimits){
 void writeServoHaptics(int* hapticLimits){
   float scaledLimits[5];
   scaleLimits(hapticLimits, scaledLimits);
-  if(hapticLimits[0] >= 0) thumbServo.write(scaledLimits[0]);
-  if(hapticLimits[1] >= 0) indexServo.write(scaledLimits[1]);
-  if(hapticLimits[2] >= 0) middleServo.write(scaledLimits[2]);
-  if(hapticLimits[3] >= 0) ringServo.write(scaledLimits[3]);
-  if(hapticLimits[4] >= 0) pinkyServo.write(scaledLimits[4]);
+  #if defined(ESP32)
+    if(hapticLimits[0] >= 0) thumbServo.write(PIN_THUMB_MOTOR,scaledLimits[0]);
+    if(hapticLimits[1] >= 0) indexServo.write(PIN_INDEX_MOTOR,scaledLimits[1]);
+    if(hapticLimits[2] >= 0) middleServo.write(PIN_MIDDLE_MOTOR,scaledLimits[2]);
+    if(hapticLimits[3] >= 0) ringServo.write(PIN_RING_MOTOR,scaledLimits[3]);
+    if(hapticLimits[4] >= 0) pinkyServo.write(PIN_PINKY_MOTOR,scaledLimits[4]);
+  #else
+    if(hapticLimits[0] >= 0) thumbServo.write(scaledLimits[0]);
+    if(hapticLimits[1] >= 0) indexServo.write(scaledLimits[1]);
+    if(hapticLimits[2] >= 0) middleServo.write(ecaledLimits[2]);
+    if(hapticLimits[3] >= 0) ringServo.write(scaledLimits[3]);
+    if(hapticLimits[4] >= 0) pinkyServo.write(scaledLimits[4]);
+  #endif
 }
 
 #endif

firmware/lucidgloves-firmware/input.ino

@@ -1,5 +1,8 @@
 #include <esp_adc_cal.h>
-#include <EEPROM.h>
+#include <Preferences.h>
+//#include <EEPROM.h>
+
+Preferences prefs;
 
 // Requires RunningMedian library by Rob Tillaart
 #if (ENABLE_MEDIAN_FILTER || ((INTERFILTER_MODE != INTERFILTER_NONE) && (FLEXION_MIXING != MIXING_NONE)))
@@ -65,16 +68,16 @@ bool savedInter = false;
 bool savedTravel = false;
 
 void setupInputs(){
-
-  EEPROM.begin(0x78 + 1);
+  prefs.begin("LucidGloves");
+  //EPROM.begin(0x78 + 1);
   Serial.begin(115200); //DON'T FORGET TO REMOVE THISSSSS
   Serial.println("Setting up input!");
   if (isSavedLimits()){
     Serial.println("Is saved limits!");
     savedTravel = true;
     loadTravel();
   }
-  if (isSavedIntermediate()){
+  if (isSavedIntermediate() && FLEXION_MIXING != MIXING_NONE){ // Check to make sure we're even using mixing. If someone had the wrong mixing type set before, this will cause an issue!
     Serial.println("IsSavedIntermediate!");
     savedInter = true;
     loadIntermediate();
@@ -84,12 +87,6 @@ void setupInputs(){
   pinMode(PIN_A_BTN, INPUT_PULLUP);
   pinMode(PIN_B_BTN, INPUT_PULLUP);
 
-  pinMode(PIN_MENU_BTN, INPUT_PULLUP);
-
-  #if !TRIGGER_GESTURE
-  pinMode(PIN_TRIG_BTN, INPUT_PULLUP);
-  #endif
-
   #if !GRAB_GESTURE
   pinMode(PIN_GRAB_BTN, INPUT_PULLUP);
   #endif
@@ -120,7 +117,7 @@ int analogPinRead(int pin){
     return analogRead(pin);
   }
   #else
-   return analogRead(UNMUX(pin));
+   return analogRead(pin);
   #endif
 }
 
@@ -225,7 +222,7 @@ void getFingerPositions(bool calibrating, bool reset){
     }
   }
 
-  for (int i = 0; i<NUM_FINGERS; i++){
+  for (int i = 0; i < 2*NUM_FINGERS; i++){
   if (i == target){
     targetFlexionMin = minFingers[i];
     targetFlexionMax = maxFingers[i];
@@ -371,7 +368,9 @@ int sinCosMix(int sinPin, int cosPin, int i){
 
 void saveTravel()
 {
-  byte flags = EEPROM.read(0x00);
+  prefs.putBytes("maxTravel", (byte*)(&maxTravel), sizeof(maxTravel));
+
+  /*byte flags = EEPROM.read(0x00);
   flags |= 0x01;  // Set bit 0
   EEPROM.write(0x00, flags); // Save clamping saved limits flag
 
@@ -385,12 +384,17 @@ void saveTravel()
 
   EEPROM.commit(); // Ensure changes are written to EEPROM
 
-  loadTravel();
+  loadTravel();*/
 }
 
 void saveIntermediate()
 {
-  byte flags = EEPROM.read(0x00);
+  prefs.putBytes("sinMax", (byte*)(&sinMax), sizeof(sinMax));
+  prefs.putBytes("sinMin", (byte*)(&sinMin), sizeof(sinMin));
+  prefs.putBytes("cosMax", (byte*)(&cosMax), sizeof(cosMax));
+  prefs.putBytes("cosMin", (byte*)(&cosMin), sizeof(cosMin));
+
+  /*byte flags = EEPROM.read(0x00);
   flags |= 0x02;  // Set bit 1
   EEPROM.write(0x00, flags); // Save intermediate values saved flag
 
@@ -408,43 +412,60 @@ void saveIntermediate()
     address += sizeof(int);
   }
 
-  EEPROM.commit(); // Ensure changes are written to EEPROM
+  EEPROM.commit(); // Ensure changes are written to EEPROM*/
 }
 
 void clearFlags()
 {
-  EEPROM.write(0x00, 0x00); // Clear the flags
-  EEPROM.commit(); // Ensure the changes are written to EEPROM
+  prefs.clear();
+
+  /*EEPROM.write(0x00, 0x00); // Clear the flags
+  EEPROM.commit(); // Ensure the changes are written to EEPROM*/
 }
 
 bool isSavedLimits()
 {
-  byte flags = EEPROM.read(0x00);
-  return flags & 0x01;  // Check bit 0
+  return (prefs.getBytesLength("maxTravel") != 0);
+
+  /*byte flags = EEPROM.read(0x00);
+  return flags & 0x01;  // Check bit 0 */
 }
 
 bool isSavedIntermediate()
 {
-  byte flags = EEPROM.read(0x00);
-  return flags & 0x02;  // Check bit 1
+  return (prefs.getBytesLength("sinMax") > 0 && prefs.getBytesLength("sinMin") > 0 && prefs.getBytesLength("cosMax") > 0 && prefs.getBytesLength("cosMin") > 0);
+
+  /*byte flags = EEPROM.read(0x00);
+  return flags & 0x02;  // Check bit 1*/
 }
 
 void loadTravel()
 {
-  byte flags = EEPROM.read(0x00);
+  if(prefs.getBytesLength("maxTravel") == 0);
+    return; // If clamping saved limits is not stored, do nothing
+  prefs.getBytes("maxTravel", &maxTravel, sizeof(maxTravel));
+
+  /*byte flags = EEPROM.read(0x00);
   if (!(flags & 0x01)) return; // If clamping saved limits flag is not set, do nothing
 
   int addr = 0x01;  // Start address for flexion and splay values
 
   for (int i = 0; i < 2*NUM_FINGERS; i++) {
     EEPROM.get(addr, maxTravel[i]); // Load the max travel value from the EEPROM at the current address
     addr += sizeof(int); // Increment the address by 4 because we're storing int values
-  }
+  }*/
 }
 
 void loadIntermediate()
 {
-  byte flags = EEPROM.read(0x00);
+  if(prefs.getBytesLength("maxTravel") == 0 | prefs.getBytesLength("sinMin") == 0 | prefs.getBytesLength("cosMax") == 0 | prefs.getBytesLength("cosMin") == 0);
+    return; // If clamping saved limits is not stored, do nothing  
+  prefs.getBytes("sinMax", &sinMax, sizeof(sinMax));
+  prefs.getBytes("sinMin", &sinMin, sizeof(sinMin));
+  prefs.getBytes("cosMax", &cosMax, sizeof(cosMax));
+  prefs.getBytes("cosMin", &cosMin, sizeof(cosMin));
+
+  /*byte flags = EEPROM.read(0x00);
   if (!(flags & 0x02)) return; // If intermediate values saved flag is not set, do nothing
 
   int address = 0x29; // Start address for sin and cos values
@@ -462,7 +483,7 @@ void loadIntermediate()
 
     EEPROM.get(address, cosMin[i]);
     address += sizeof(int);
-  }
+  }*/
 }