#bacoding

[bad-arduino-with-the-wellspring]

Updated Peeper Code 1

#include <Servo.h>

// -----------------------

// Servo objects

// -----------------------

Servo servoLF;

Servo servoRF;

Servo servoLB;

Servo servoRB;

// -----------------------

// Pins

// -----------------------

const int pinLF = 11;

const int pinRF = 10;

const int pinLB = 9;

const int pinRB = 8;

const int LED_PIN = 4;

// -----------------------

// Calibration directions

// -----------------------

int dirLF = +1;

int dirRF = -1;

int dirLB = -1;

int dirRB = +1;

// -----------------------

// Motion parameters

// -----------------------

const int neutralPos = 90;

const int moveOffset = 30;  

// Smooth movement parameters (50% faster)

const int smoothSteps = 25;

const int smoothDelay = 5;    // was 10 → now 50% faster

// -----------------------

// LED blink timing

// -----------------------

unsigned long lastBlink = 0;

unsigned long blinkInterval = 0;

bool ledBlinking = false;

unsigned long blinkPhaseStart = 0;

// -----------------------

// RUNTIME SETTINGS

// -----------------------

const unsigned long TOTAL_RUNTIME = 600000UL; // 10 min

unsigned long startTime;

// walking for 10s – 90s

unsigned long minWalk = 10000;

unsigned long maxWalk = 90000;

// break for 10s – 30s

unsigned long minBreak = 10000;

unsigned long maxBreak = 30000;

// -----------------------

// Smooth movement function

// -----------------------

void moveSmooth(Servo &s, int start, int end) {

  float inc = float(end - start) / smoothSteps;

  for (int i = 0; i <= smoothSteps; i++) {

    s.write(start + inc * i);

    delay(smoothDelay);

  }

}

// -----------------------

// LED behavior

// -----------------------

void updateLed() {

  unsigned long now = millis();

  if (!ledBlinking) {

    if (now - lastBlink >= blinkInterval) {

      ledBlinking = true;

      blinkPhaseStart = now;

      digitalWrite(LED_PIN, LOW);

    }

  }

  else {

    if (now - blinkPhaseStart >= 500 && now - blinkPhaseStart < 1000) {

      digitalWrite(LED_PIN, HIGH);

    }

    else if (now - blinkPhaseStart >= 1000) {

      ledBlinking = false;

      lastBlink = now;

      blinkInterval = random(5000, 10000);

      digitalWrite(LED_PIN, HIGH);

    }

  }

}

// -----------------------

// One walking step cycle

// -----------------------

void performStep(bool forwardPhase) {

  int LFtarget = neutralPos + dirLF * (forwardPhase ? moveOffset : -moveOffset);

  int RFtarget = neutralPos + dirRF * (forwardPhase ? -moveOffset : moveOffset);

  int LBtarget = neutralPos + dirLB * (forwardPhase ? -moveOffset : moveOffset);

  int RBtarget = neutralPos + dirRB * (forwardPhase ? moveOffset : -moveOffset);

  moveSmooth(servoLF, servoLF.read(), LFtarget);

  moveSmooth(servoRF, servoRF.read(), RFtarget);

  moveSmooth(servoLB, servoLB.read(), LBtarget);

  moveSmooth(servoRB, servoRB.read(), RBtarget);

}

// -----------------------

// NEUTRAL pose

// -----------------------

void goNeutral() {

  moveSmooth(servoLF, servoLF.read(), neutralPos);

  moveSmooth(servoRF, servoRF.read(), neutralPos);

  moveSmooth(servoLB, servoLB.read(), neutralPos);

  moveSmooth(servoRB, servoRB.read(), neutralPos);

}

// -----------------------

// Setup

// -----------------------

void setup() {

  servoLF.attach(pinLF);

  servoRF.attach(pinRF);

  servoLB.attach(pinLB);

  servoRB.attach(pinRB);

  pinMode(LED_PIN, OUTPUT);

  digitalWrite(LED_PIN, HIGH);

  blinkInterval = random(5000, 10000);

  goNeutral();

  delay(500);

  startTime = millis();  // Start 10-minute timer

}

// -----------------------

// Main Loop

// -----------------------

void loop() {

  updateLed();

  unsigned long now = millis();

  if (now - startTime >= TOTAL_RUNTIME) {

    goNeutral();

    return; // stop completely after 10 minutes

  }

  // -------- WALK PHASE --------

  unsigned long walkTime = random(minWalk, maxWalk);

  unsigned long walkEnd = millis() + walkTime;

  while (millis() < walkEnd && millis() - startTime < TOTAL_RUNTIME) {

    updateLed();

    performStep(true);

    performStep(false);

  }

  // -------- BREAK PHASE --------

  goNeutral();

  unsigned long breakTime = random(minBreak, maxBreak);

  unsigned long breakEnd = millis() + breakTime;

  while (millis() < breakEnd && millis() - startTime < TOTAL_RUNTIME) {

    updateLed();

    // remain still

  }

}

[bad-arduino-with-the-wellspring]

UPDATED Inkvine Code 1

#include <AccelStepper.h>

// --------------------

// A4988 MICROSTEPPING

// --------------------

const int MS1 = 7;  

const int MS2 = 6;  

const int MS3 = 5;  

// Stepper pins

const int dirPin  = 2;

const int stepPin = 3;

#define motorInterfaceType 1

AccelStepper stepper(motorInterfaceType, stepPin, dirPin);

// 1/16 microstepping: 200 * 16 = 3200 steps/rev

const long stepsPerRevolution = 3200;

// 1.5 rotations

const long stepsToMove = stepsPerRevolution * 1.5;

// --------------------

// LED DEFINITIONS

// --------------------

int ledPins[5] = {12, 11, 10, 9, 8};

unsigned long ledNextBlink[5];

unsigned long ledBlinkEnd[5];

bool ledBlinking[5];

// --------------------

// PHOTORESISTOR

// --------------------

const int photoPin = A0;

int photoValue = 0;

// --------------------

// STATE MACHINE

// --------------------

enum MotionState { FORWARD, WAITING, REVERSE };

MotionState currentState = FORWARD;

unsigned long waitStart = 0;

unsigned long lastPhotoPrint = 0;   // NEW: timer for printing

void setup() {

  Serial.begin(9600);   // <— ENABLE SERIAL MONITOR OUTPUT

  // Microstep selection pins

  pinMode(MS1, OUTPUT);

  pinMode(MS2, OUTPUT);

  pinMode(MS3, OUTPUT);

  // Set 1/16 microstepping

  digitalWrite(MS1, HIGH);

  digitalWrite(MS2, HIGH);

  digitalWrite(MS3, HIGH);

  // Stepper settings

  stepper.setMaxSpeed(300);

  stepper.setAcceleration(100);

  // Reset motor position on startup

  stepper.setCurrentPosition(0);

  // Begin motion

  stepper.moveTo(stepsToMove);

  // LED setup

  for (int i = 0; i < 5; i++) {

    pinMode(ledPins[i], OUTPUT);

    digitalWrite(ledPins[i], HIGH);

    ledBlinking[i] = false;

    ledNextBlink[i] = millis() + random(2000, 8000);

  }

  randomSeed(analogRead(0));

  pinMode(photoPin, INPUT);

}

void loop() {

  // --- Read photoresistor ---

  photoValue = analogRead(photoPin);

  // --- Print to Serial Monitor every 200 ms ---

  if (millis() - lastPhotoPrint >= 200) {

    Serial.print("Photoresistor value: ");

    Serial.println(photoValue);

    lastPhotoPrint = millis();

  }

  stepper.run();

  handleLEDs();

  handleStepperState();

}

// --------------------

// MOTOR STATE MACHINE

// --------------------

void handleStepperState() {

  switch (currentState) {

    case FORWARD:

      if (stepper.distanceToGo() == 0) {

        waitStart = millis();

        currentState = WAITING;

      }

      break;

    case WAITING:

      if (millis() - waitStart >= 5000) {  

        stepper.moveTo(-stepsToMove);

        currentState = REVERSE;

      }

      break;

    case REVERSE:

      if (stepper.distanceToGo() == 0) {

        delay(5000);

        stepper.moveTo(stepsToMove);

        currentState = FORWARD;

      }

      break;

  }

}

// --------------------

// RANDOM LED BLINKING

// --------------------

void handleLEDs() {

  unsigned long currentTime = millis();

  for (int i = 0; i < 5; i++) {

    if (!ledBlinking[i]) {

      if (currentTime >= ledNextBlink[i]) {

        ledBlinking[i] = true;

        digitalWrite(ledPins[i], LOW);

        ledBlinkEnd[i] = currentTime + 1000;

      }

    } else {

      if (currentTime >= ledBlinkEnd[i]) {

        ledBlinking[i] = false;

        digitalWrite(ledPins[i], HIGH);

        ledNextBlink[i] = currentTime + random(3000, 10000);

      }

    }

  }

}

[bad-arduino-with-the-wellspring]

Here is also the original Inkvine code for the demo

// --- Motor pins --- const int ENA = 9; // PWM speed control pin const int IN1 = 8; // Direction control const int IN2 = 7;

// --- Encoder pins --- const int ENCODER_A = 2; // Interrupt pin volatile long pulseCount = 0; const int PULSES_PER_REV = 500; // adjust this to your motor's encoder specs

void setup() { pinMode(ENA, OUTPUT); pinMode(IN1, OUTPUT); pinMode(IN2, OUTPUT); pinMode(ENCODER_A, INPUT_PULLUP);

attachInterrupt(digitalPinToInterrupt(ENCODER_A), countPulse, RISING); Serial.begin(9600); }

void loop() { // --- Forward 5 rotations --- rotateMotor(true, 255, 5); // (direction, speed, rotations)

// --- Pause for 10 seconds --- stopMotor(); delay(10000);

// --- Backward 5 rotations (slower) --- rotateMotor(false, 120, 5);

// Stop permanently stopMotor(); while (true); }

void countPulse() { pulseCount++; }

void rotateMotor(bool forward, int speed, int rotations) { pulseCount = 0; long targetPulses = rotations * PULSES_PER_REV;

if (forward) { digitalWrite(IN1, HIGH); digitalWrite(IN2, LOW); } else { digitalWrite(IN1, LOW); digitalWrite(IN2, HIGH); }

analogWrite(ENA, speed);

while (pulseCount < targetPulses) { // Wait until desired rotations reached }

stopMotor(); }

void stopMotor() { digitalWrite(IN1, LOW); digitalWrite(IN2, LOW); analogWrite(ENA, 0); }

[bad-arduino-with-the-wellspring]

This is the basic walk-cycle I have been using for the Peepers thus far.

#include <Servo.h>

// Create servo objects Servo servoLF; Servo servoRF; Servo servoLB; Servo servoRB;

// Define servo pins const int pinLF = 11; const int pinRF = 10; const int pinLB = 9; const int pinRB = 8;

// Define movement parameters const int neutralPos = 90; const int moveOffset = 30; // degrees forward/backward const int delayTime = 250; // ms between moves (fast) const int repetitions = 20; // number of cycles

void setup() { // Attach servos servoLF.attach(pinLF); servoRF.attach(pinRF); servoLB.attach(pinLB); servoRB.attach(pinRB);

// --- INITIAL NEUTRAL POSITION --- servoLF.write(neutralPos); servoRF.write(neutralPos); servoLB.write(neutralPos); servoRB.write(neutralPos); delay(1000); // let them settle

// --- MOVE LOOP --- for (int i = 0; i < repetitions; i++) { // Step 1: forward phase servoLF.write(neutralPos + moveOffset); // forward servoRF.write(neutralPos - moveOffset); // inverse (backward) servoLB.write(neutralPos - moveOffset); // inverse (backward) servoRB.write(neutralPos + moveOffset); // forward delay(delayTime);// Step 2: backward phase servoLF.write(neutralPos - moveOffset); // backward servoRF.write(neutralPos + moveOffset); // inverse (forward) servoLB.write(neutralPos + moveOffset); // inverse (forward) servoRB.write(neutralPos - moveOffset); // backward delay(delayTime);

}

// --- FINAL NEUTRAL POSITION --- servoLF.write(neutralPos); servoRF.write(neutralPos); servoLB.write(neutralPos); servoRB.write(neutralPos); delay(1000); // optional: hold briefly at neutral }

void loop() { // Nothing here — motion happens once }

[bad-arduino-with-the-wellspring]

Welcome to the bad Arduino Blog by the Wellspring.

This is an open resource project, meaning that I will be using open resources found online and am trying to pay that forwards by providing the work I have been doing for replication and free use by anyone.

Credit should be given If my work is used and ideally should be altered or iterated on.

If you do choose to use anything on this blog, I would love to see it!

Questions are also welcome!

Here are some of the tags I will be using for organization: