#include "menu.h"
#include "debounce.h"
#include "actuation.h"
#include "rotary_encoder.h"

#define RE_CLK 13
#define RE_DT 12
#define RE_SW 9

RotaryEncoder rotary(RE_DT, RE_CLK);
Debounce btn;

void setup() {
  Serial.begin(9600);

  if(!displayBegin()) {
    Serial.println(F("SSD1306 allocation failed"));
    for(;;); // Don't proceed, loop forever
  }

  pinMode(RE_SW, INPUT_PULLUP);
  setupActuation();
}

bool processing = false;

void loop() {
	processing
    ? process()
	  : btn.debounce(&click, 50);

  rotary.decode(&cw, &ccw);
}

bool clicked = false;
unsigned int length;
unsigned int qty;

void click() {
	if (digitalRead(RE_SW) == LOW && !clicked) {
    clicked = true;

		if (cursor < parameter_length) {
      selected = !selected;
    } else {
      processing = !processing;
      length = values[0];
      qty = values[1];
    }

    displayUpdate();
  } else if (digitalRead(RE_SW) == HIGH && clicked) {
    clicked = false;
  }
}

void cw() {
  if (!selected && cursor == parameter_length)
		return;

	if (selected) {
    if (cursor == 1 && values[1] < 100) {
      values[1]++;
    } else if (cursor == 0 && values[0] < 250) {
      values[0]++;
    }
  } else {
    cursor++;
  }

  displayUpdate();
}

void ccw() {
  if (!selected && cursor == 0)
  // if (!selected && cursor == 1)
		return;

	if (selected) {
    if (cursor == 1 && values[1] > 1) {
      values[1]--;
    } else if (cursor == 0 && values[0] > 10) {
      values[0]--;
    }
  } else {
    cursor--;
  }

  displayUpdate();
}


sketch.ino

diagram.json

# Wokwi Library List
# See https://docs.wokwi.com/guides/libraries

Adafruit SSD1306
AccelStepper
Servo


libraries.txt

#ifndef ROTARY_ENCODER_H
#define ROTARY_ENCODER_H
#include <Arduino.h>

class RotaryEncoder {
  public:
    RotaryEncoder(byte dt, byte clk);
    void decode(void (*cw)(), void (*ccw)());
  private:
    byte _dt;
    byte _clk;
    byte _state;
    unsigned char process();
};

#endif


rotary_encoder.h

#include "rotary_encoder.h"

RotaryEncoder::RotaryEncoder(byte dt, byte clk) {
  _dt = dt;
  _clk = clk;
  _state = 0;

  pinMode(dt, INPUT_PULLUP);
  pinMode(clk, INPUT_PULLUP);
}

void RotaryEncoder::decode(void (*cw)(), void (*ccw)()) {
  unsigned char result = RotaryEncoder::process();

  // Clockwise rotation
  if (result == 16)
    cw();
  // Counter clockwise rotation
  else if (result == 32)
    ccw();
}

const unsigned char ttable[6][4] = {
  {3, 2, 1, 0},
  {3 | 32, 0, 1, 0},
  {3 | 16, 2, 0, 0},
  {3, 5, 4, 0},
  {3, 3, 4, 0 | 16},
  {3, 5, 3, 0 | 32},
};

unsigned char RotaryEncoder::process() {
  // Grab state of input pins.
  unsigned char pinstate = (digitalRead(_clk) << 1) | digitalRead(_dt);

  // Determine new state from the pins and state table.
  _state = ttable[_state & 0xf][pinstate];

  // Return emit bits, ie the generated event.
  return _state & 48;
}


rotary_encoder.cpp

#include "debounce.h"

unsigned long lastBounce = 0;

void Debounce::debounce(void (*callback)(), unsigned long time) {
  unsigned long now = millis();

  if ((now - lastBounce) < time)
    return;

  lastBounce = now;
  callback();
}

void Debounce::reset() {
  lastBounce = millis();
}


debounce.cpp

#ifndef DEBOUNCE_H
#define DEBOUNCE_H
#include <Arduino.h>

class Debounce {
  public:
    void debounce(void (*callback)(), unsigned long time);
    void reset();
  private:
    unsigned long lastBounce;
};

#endif


debounce.h

#ifndef MENU_H
#define MENU_H
#include <Arduino.h>
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

extern Adafruit_SSD1306 display;
extern bool selected;
extern byte cursor;
extern byte values[];
extern const byte parameter_length;

bool displayBegin();
void displayUpdate();
void drawIndicators();
void drawParameters();
void drawCta();
void printCtr(const String &buf, int16_t x, int16_t y);
void printRg(const String &buf, int16_t x, int16_t y);

#endif


menu.h

#include "menu.h"

#define SCREEN_I2C_ADDR 0x3C // or 0x3C
#define SCREEN_WIDTH 128     // OLED display width, in pixels
#define SCREEN_HEIGHT 64     // OLED display height, in pixels
#define OLED_RST_PIN -1      // Reset pin (-1 if not available)

Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RST_PIN);

byte cursor = 0;
// byte cursor = 1;

// const byte parameter_length = 5;
const byte parameter_length = 2;

const char *parameters[parameter_length] = {
	// "AWG",
	"Length",
	// "Lead 1",
	// "Lead 2",
	"Qty"
};

byte values[parameter_length] = {
	// 10,
	100,
	// 5,
	// 5,
	10
};

bool selected = false;

bool displayBegin() {
  // SSD1306_SWITCHCAPVCC = generate display voltage from 3.3V internally
  bool initialized = display.begin(SSD1306_SWITCHCAPVCC, SCREEN_I2C_ADDR);

  if (initialized) {
    display.setRotation(1);
    displayUpdate();
  }
    
  return initialized;
}

void displayUpdate() {
  display.clearDisplay();
	display.setTextColor(SSD1306_WHITE);
  
	drawIndicators();
	drawParameters();
	drawCta();

  display.display();
}

// 'illustration', 64x9px
const unsigned char bm_wire [] PROGMEM = {
	0x00, 0x0f, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x00, 0x00, 0x1f, 0xff, 0xff, 0xff, 0xff, 0xd8, 0x00, 
	0x00, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xb0, 0x00, 0x7f, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xa7, 0xff, 
	0xff, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xaf, 0xff, 0xff, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xa7, 0xfe, 
	0x00, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xb0, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0xd8, 0x00, 
	0x00, 0x0f, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x00
};
// 'lead-indicator', 11x3px
// const unsigned char bm_lead [] PROGMEM = {
// 	0x80, 0x20, 0xaa, 0xa0, 0x80, 0x20
// };
// 'length-indicator', 44x3px
const unsigned char bm_length [] PROGMEM = {
	0x80, 0x00, 0x00, 0x00, 0x00, 0x10, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xb0, 0x80, 0x00, 0x00, 0x00, 
	0x00, 0x10
};

void drawIndicators() {
	display.drawBitmap(0, 11, bm_wire, display.width(), 9, 1);

	// if (cursor == 1)
	if (cursor == 0) {
  	display.drawBitmap(10, 23, bm_length, 44, 3, 1);
		printCtr("mm", 0, 26);
	}

	// if (cursor == 2)
  // 	display.drawBitmap(0, 23, bm_lead, 11, 3, 1);

	// if (cursor == 3)
  // 	display.drawBitmap(53, 23, bm_lead, 11, 3, 1);
}

// #define OFFSET 29
#define OFFSET 50

void drawParameters() {
	for (int i = 0; i < parameter_length; i++) {
		int y = OFFSET + (i * 16);

		if (cursor == i) {
			if (selected) {
				display.fillRoundRect(0, y, display.width(), 15, 3, SSD1306_WHITE);
				display.setTextColor(SSD1306_BLACK);
			} else {
				display.drawRoundRect(0, y, display.width(), 15, 3, SSD1306_WHITE);
			}
		}

		display.setCursor(3, y + 4);
		display.print(parameters[i]);
		printRg(String(values[i]), 3, y + 4);

		if (selected)
			display.setTextColor(SSD1306_WHITE);
	}
}

extern bool processing;
extern unsigned int qty;

void drawCta() {
	display.fillRoundRect(0, 113, display.width(), 15, 3, SSD1306_WHITE);

	if (cursor == parameter_length)
			display.drawRoundRect(1, 114, display.width() - 2, 13, 3, SSD1306_BLACK);

  display.setTextColor(SSD1306_BLACK);

	if (processing) {
		String processed = String(values[1] - qty) + "/" + String(values[1]);
		printCtr(processed, 0, 117);
	} else {
		printCtr("Start", 0, 117);
	}

	display.setTextColor(SSD1306_WHITE);
}

void printCtr(const String &buf, int16_t x, int16_t y) {
	int16_t x1, y1;
	uint16_t w, h;
	display.getTextBounds(buf, x, y, &x1, &y1, &w, &h); //calc width of new string
	display.setCursor((x + (display.width() - w) / 2), y);
	display.print(buf);
}

void printRg(const String &buf, int16_t x, int16_t y) {
	int16_t x1, y1;
	uint16_t w, h;
	display.getTextBounds(buf, x, y, &x1, &y1, &w, &h); //calc width of new string
	display.setCursor((display.width() - x - w), y);
	display.print(buf);
}


menu.cpp

#ifndef ACTUATION_H
#define ACTUATION_H
#include <Arduino.h>
#include <AccelStepper.h>
#include <Servo.h>

void setupActuation();
void process();

void sequencer();
void initSequence();
void pull();
void servoDown();
void servoUp();
void resetSequence();

#endif


actuation.h

#include "debounce.h"
#include "menu.h"
#include "actuation.h"

#define ST_STEP 2
#define ST_DIR 5
#define ST_EN 8

#define MICROSTEP 16

AccelStepper stepper(1, ST_STEP, ST_DIR);

#define SV_SG 11

Servo servo;

void setupActuation() {
  stepper.setMaxSpeed(4000);
  stepper.setAcceleration(2500);
  stepper.setCurrentPosition(0);

  pinMode(ST_EN, OUTPUT);
  digitalWrite(ST_EN, LOW);

  servo.attach(SV_SG);
}

extern unsigned int qty;
extern unsigned int length;
unsigned int steps;

Debounce sequence;

byte sequenceCursor = 0;
const byte sequence_length = 3;
void (*sequences[sequence_length])() = { pull, servoDown, servoUp };
unsigned long durations[sequence_length] = { 1500, 500, 500 };
bool sequence_triggered[sequence_length] = { false, false, false };

bool sequenceInitialized = false;

void process() {
  initSequence();

  (*sequences[sequenceCursor])();

  if (!sequence_triggered[sequenceCursor])
    sequence_triggered[sequenceCursor] = true;

  sequence.debounce(&sequencer, durations[sequenceCursor]);
}

void initSequence() {
  if (sequenceInitialized)
    return;
    
  // Serial.print("Qty: ");
  // Serial.print(qty);
  // Serial.print(", length: ");
  // Serial.println(length);

  // Need calibration
  sequence.reset();
  sequenceInitialized = true;
  steps = length * 4 * MICROSTEP;
  durations[0] = sqrt(length)*275 + 500;
}

void sequencer() {
  sequenceCursor++;

  if (sequenceCursor >= sequence_length)
    resetSequence();
}

unsigned int pos = 0;

void pull() {
  if (!sequence_triggered[0])
    stepper.moveTo(steps);

  if (stepper.distanceToGo() != 0)
    stepper.run();
}

void servoDown() {
  if (sequence_triggered[1])
    return;

  servo.write(0);
}

void servoUp() {
  if (sequence_triggered[2])
    return;

  servo.write(90);
}

extern bool processing;

void resetSequence() {
  for (int i = 0; i < sequence_length; i++)
    sequence_triggered[i] = false;

  sequenceCursor = 0;
  stepper.setCurrentPosition(0);

  qty--;

  if (qty == 0) {
    processing = false;
    sequenceInitialized = false;
    // Serial.println("Done!");
  } else {
    // Serial.print("Remaining: ");
    // Serial.println(qty);
  }
  
  displayUpdate();
}
