SyringePumpControlBoardCode.cpp

/*
  ============================================================================
  POSEIDON SYRINGE PUMP FIRMWARE — Octopus V1.1 / 8 x TMC2209 Expanded Port
  ============================================================================
  Targets a BigTreeTech Octopus V1.1 (STM32F446ZE) running up to EIGHT
  TMC2209 driver modules in STEP/DIR/ENABLE ("standalone") mode.

  The packet framing architecture scales the original 3-pump design to
  fully utilize MOTOR0 through MOTOR7 sockets.

  NOTE: Verify the pin table below against your board's schematic/silkscreen
  before flashing — a swapped enable pin or wrong polarity can damage a
  TMC2209 driver.
  ============================================================================
*/

#include <AccelStepper.h>

// ----------------------------------------------------------------------
// Motor / motion constants
// ----------------------------------------------------------------------
#define MOTOR_STEPS   200          // full steps/rev of the pump stepper motors
#define MICROSTEPS    16           // MUST match the physical MS1/MS2 jumpers
#define TOTAL_STEPS   (MOTOR_STEPS * MICROSTEPS)

#define DEFAULT_SPEED  1000.0      // default steps/sec
#define DEFAULT_ACCEL  5000.0      // default steps/sec^2

// ----------------------------------------------------------------------
// Octopus V1.1 MOTOR0 through MOTOR7 socket pins
// Confirmed against BigTreeTech pin definitions for STM32F446ZE
// (double-check against your own board revision before relying on this)
// ----------------------------------------------------------------------
#define M0_STEP_PIN   PF13
#define M0_DIR_PIN    PF12
#define M0_ENABLE_PIN PF14

#define M1_STEP_PIN   PG0
#define M1_DIR_PIN    PG1
#define M1_ENABLE_PIN PF15

#define M2_STEP_PIN   PF11
#define M2_DIR_PIN    PG3
#define M2_ENABLE_PIN PG5

#define M3_STEP_PIN   PG4
#define M3_DIR_PIN    PC1
#define M3_ENABLE_PIN PA0

#define M4_STEP_PIN   PF9
#define M4_DIR_PIN    PF10
#define M4_ENABLE_PIN PG2

#define M5_STEP_PIN   PC13
#define M5_DIR_PIN    PF0
#define M5_ENABLE_PIN PF1

#define M6_STEP_PIN   PE2
#define M6_DIR_PIN    PE3
#define M6_ENABLE_PIN PE4

#define M7_STEP_PIN   PE6
#define M7_DIR_PIN    PA14
#define M7_ENABLE_PIN PE5

// TMC2209 ENABLE pins are active-LOW
#define DRIVER_ENABLE_ACTIVE_LOW true

#define BAUD_RATE 230400   // USB-CDC ignores the baud value, but kept for protocol matching

// ----------------------------------------------------------------------
// AccelStepper instances — 8 independent axes
// ----------------------------------------------------------------------
AccelStepper stepper1(AccelStepper::DRIVER, M0_STEP_PIN, M0_DIR_PIN);
AccelStepper stepper2(AccelStepper::DRIVER, M1_STEP_PIN, M1_DIR_PIN);
AccelStepper stepper3(AccelStepper::DRIVER, M2_STEP_PIN, M2_DIR_PIN);
AccelStepper stepper4(AccelStepper::DRIVER, M3_STEP_PIN, M3_DIR_PIN);
AccelStepper stepper5(AccelStepper::DRIVER, M4_STEP_PIN, M4_DIR_PIN);
AccelStepper stepper6(AccelStepper::DRIVER, M5_STEP_PIN, M5_DIR_PIN);
AccelStepper stepper7(AccelStepper::DRIVER, M6_STEP_PIN, M6_DIR_PIN);
AccelStepper stepper8(AccelStepper::DRIVER, M7_STEP_PIN, M7_DIR_PIN);

AccelStepper steppers[8] = {stepper1, stepper2, stepper3, stepper4, stepper5, stepper6, stepper7, stepper8};
const int enablePins[8] = {M0_ENABLE_PIN, M1_ENABLE_PIN, M2_ENABLE_PIN, M3_ENABLE_PIN, M4_ENABLE_PIN, M5_ENABLE_PIN, M6_ENABLE_PIN, M7_ENABLE_PIN};

// ----------------------------------------------------------------------
// Serial packet parsing state (Expanded array flags for 8 channels)
// ----------------------------------------------------------------------
const byte buffSize = 128; // Increased buffer room for long optional string chains
char inputBuffer[buffSize];
const char startMarker = '<';
const char endMarker = '>';
byte bytesRecvd = 0;
boolean readInProgress = false;
boolean newDataFromPC = false;

char mode[buffSize] = {0};
char setting[buffSize] = {0};
char motorIDStr[buffSize] = {0};
int motors[8] = {0};

float value = 0.0;
char dir[buffSize] = {0};
float distances[8] = {0};

float oldDistanceLeft[8] = {0};
unsigned long curMillis;

// Forward Declarations
void getDataFromPC();
void parseData();
void executeThisFunction();
void replyToPC();
void sendDistanceToPC(int mIndex);
void updateSettings();
void runFew();
void stopAll();
int array_sum(int *array, int len);
void clearVariables();
bool parsePacketFields(); // returns false if the packet was malformed

// ============================================================================
void setup() {
  Serial.begin(BAUD_RATE);

  // Configure and actively enable all eight TMC2209 drivers.
  for (int i = 0; i < 8; i++) {
    pinMode(enablePins[i], OUTPUT);
    digitalWrite(enablePins[i], DRIVER_ENABLE_ACTIVE_LOW ? LOW : HIGH); // active low enable

    steppers[i].setMaxSpeed(DEFAULT_SPEED);
    steppers[i].setAcceleration(DEFAULT_ACCEL);
  }

#ifdef LED_BUILTIN
  pinMode(LED_BUILTIN, OUTPUT);
  digitalWrite(LED_BUILTIN, HIGH);
  delay(300);
  digitalWrite(LED_BUILTIN, LOW);
#endif

  Serial.println("<Arduino is ready>");
}

// ============================================================================
void loop() {
  curMillis = millis();
  getDataFromPC();

  // Real-time tracking loop feedback to PC if axes are running
  for (int i = 0; i < 8; i++) {
    if (steppers[i].distanceToGo() != 0) {
      sendDistanceToPC(i);
    }
  }
}

// ----------------------------------------------------------------------
// Read serial byte buffer streams enclosed between < and >
// ----------------------------------------------------------------------
void getDataFromPC() {
  if (Serial.available() > 0) {
    char x = Serial.read();

    if (x == endMarker) {
      readInProgress = false;
      newDataFromPC = true;
      inputBuffer[bytesRecvd] = 0;
      return parseData();
    }

    if (readInProgress) {
      inputBuffer[bytesRecvd] = x;
      bytesRecvd++;
      if (bytesRecvd == buffSize) {
        bytesRecvd = buffSize - 1;
      }
    }

    if (x == startMarker) {
      bytesRecvd = 0;
      readInProgress = true;
    }
  }
}

// ----------------------------------------------------------------------
/*
   Command format scaled for up to 8 motors:
   <Mode, Setting, MotorIDs, Value, Direction, p1_opt, p2_opt, ..., p8_opt>
*/
bool parsePacketFields() {
  char *strtokIndx;

  strtokIndx = strtok(inputBuffer, ",");
  if (strtokIndx == NULL) return false;
  strcpy(mode, strtokIndx);

  strtokIndx = strtok(NULL, ",");
  if (strtokIndx == NULL) return false;
  strcpy(setting, strtokIndx);

  strtokIndx = strtok(NULL, ",");
  if (strtokIndx == NULL) return false;
  String motorstr(strtokIndx);
  strcpy(motorIDStr, strtokIndx);

  // Clear out targeted flags
  for (int i = 0; i < 8; i++) motors[i] = 0;

  // Search through string identifier flags for motor mappings '1' through '8'
  for (int i = 0; i < 8; i++) {
    char searchTarget = '1' + i;
    if (motorstr.indexOf(searchTarget) >= 0) {
      motors[i] = 1;
    }
  }

  strtokIndx = strtok(NULL, ",");
  if (strtokIndx == NULL) return false;
  value = atof(strtokIndx);

  strtokIndx = strtok(NULL, ",");
  if (strtokIndx == NULL) return false;
  strcpy(dir, strtokIndx);

  // Parse trailing distinct positioning strings for all 8 pumps if provided
  for (int i = 0; i < 8; i++) {
    strtokIndx = strtok(NULL, ",");
    if (strtokIndx != NULL) {
      distances[i] = atof(strtokIndx);
    } else {
      distances[i] = value; // Fallback to uniform standard raw global parameter value
    }
  }

  return true;
}

void parseData() {
  if (!parsePacketFields()) {
    // Malformed packet (too few comma-separated fields) — ignore it instead
    // of dereferencing a NULL pointer.
    Serial.println("<ERROR: malformed packet>");
    return;
  }

  if (strcmp(setting, "RUN") == 0) {
    for (int i = 0; i < 8; i++) distances[i] = 999999.0;
  }

  newDataFromPC = true;
  replyToPC();
  return executeThisFunction();
}

void clearVariables() {
  // Protocol structural fidelity cleanup loop placeholder matching base implementation
  value = 0.0;
}

// ----------------------------------------------------------------------
void executeThisFunction() {
  if (strcmp(mode, "STOP") == 0) {
    return stopAll();
  } else if (strcmp(mode, "SETTING") == 0) {
    return updateSettings();
  } else if (strcmp(mode, "RUN") == 0) {
    if (strcmp(setting, "DIST") == 0) {
      return runFew();
    }
  }
}

// ----------------------------------------------------------------------
void replyToPC() {
  if (newDataFromPC) {
    newDataFromPC = false;
    Serial.print("<mode: ");
    Serial.print(mode);
    Serial.print(" ,setting: ");
    Serial.print(setting);
    Serial.print(" ,motorIDs: ");
    Serial.print(motorIDStr);
    Serial.print(" ,value: ");
    Serial.print(value);
    Serial.print(" ,direction: ");
    Serial.print(dir);
    Serial.println(">");
  }
}

void sendDistanceToPC(int mIndex) {
  if (steppers[mIndex].distanceToGo() != oldDistanceLeft[mIndex]) {
    Serial.print("<DISP");
    Serial.print(mIndex + 1); // convert array tracking offset to human indexing output
    Serial.print("|");
    Serial.print(steppers[mIndex].distanceToGo());
    Serial.print(">");
  }
  oldDistanceLeft[mIndex] = steppers[mIndex].distanceToGo();
}

// ----------------------------------------------------------------------
void updateSettings() {
  for (int i = 0; i < 8; i++) {
    if (motors[i] == 1) {
      steppers[i].setCurrentPosition(0);
      if (strcmp(setting, "SPEED") == 0) steppers[i].setMaxSpeed(value);
      else if (strcmp(setting, "ACCEL") == 0) steppers[i].setAcceleration(value);
    }
  }
  clearVariables();
}

// ----------------------------------------------------------------------
int array_sum(int *array, int len) {
  int s = 0;
  for (int i = 0; i < len; i++) s += array[i];
  return s;
}

void runFew() {
  int direction = 1;
  if (strcmp(dir, "B") == 0) direction = -1;

  for (int i = 0; i < 8; i++) {
    if (motors[i] == 1) {
      float toMove = direction * distances[i];
      steppers[i].move(toMove);
    }
  }

  int stepperStatus[8] = {0};

  // Keep execution loop active until targeted configurations report zero distance states
  while (array_sum(stepperStatus, 8) != array_sum(motors, 8)) {
    for (int i = 0; i < 8; i++) {
      if (motors[i] == 1) {
        if (stepperStatus[i] == 0) {
          steppers[i].run();
          // Stream live position feedback while the move is actually happening
          // (previously this only ran after the move finished, so the PC
          // never saw intermediate progress).
          sendDistanceToPC(i);
        }
        if (steppers[i].distanceToGo() == 0) {
          stepperStatus[i] = 1;
        }
      }
    }
    getDataFromPC(); // Monitor unexpected serial inputs during operations
  }
  clearVariables();
}

void stopAll() {
  for (int i = 0; i < 8; i++) {
    steppers[i].stop();
  }
}

/*
  ============================================================================
  TMC2209 Software UART control via TMCStepper library (Optional reference)
  ============================================================================
  If software-configured run currents or StealthChop overrides are desired,
  uncomment the TMCStepper includes below, add the hardware-mapped UART RX/TX pins,
  and call .begin() methods inside the main setup execution block.

  #include <TMCStepper.h>
  #define R_SENSE 0.11f // match exact sense resistors of driver layout
*/