Rapid Iron-On User Interfaces:
Hands-on Fabrication of Interactive Textile Prototypes

/* Rapid Iron-on User Interfaces: Hands-on Fabrication of Interactive Textile Prototypes
   - Konstantin Klamka, Raimund Dachselt & Jürgen Steimle -

   Sketch for controlling the cutting blade:
   If a user hits the push button, a short
   motor motion sequence is initiated that
   moves the blade forth and back.

   created 2019 by
   Konstantin Klamka
   Interactive Media Lab Dresden, Germany

   This example code is in the public domain.

   Project website:
   http://www.imld.de/rio/

*/

// Includes
#include <nRF5x_BLE_API.h>
#include <SparkFun_External_EEPROM.h>

 // EEPROM
ExternalEEPROM myMem;

// Device Name
#define DEVICE_NAME       "RIO_Motor_Control"
#define DEVICE_NAME_SHORT "RIO"

// GATT Service and Characteristic Addresses
#define BLE_GATT_RIO_CONTROL_SERVICE       0x713D
#define BLE_GATT_CHAR_ADDR_MOTOR_CONTROL   0x703A
#define BLE_GATT_CHAR_ADDR_MOTOR_SPEED     0x703B
#define BLE_GATT_CHAR_ADDR_CUT_TIME_OUT    0x703C
#define BLE_GATT_CHAR_ADDR_CUT_TIME_IN     0x703D
#define BLE_GATT_CHAR_ADDR_BLADE_TRIGGER   0x703E
#define BLE_GATT_CHAR_ADDR_MOTOR_DIRECTION 0x703F
#define TXRX_BUF_LEN                       20

// Pin Mapping
const int buttonPin1 = 0;
const int buttonPin2 = 1;
const int motorPwmPin = 4;
const int motorDirPin = 5;
const int ledPin = 13;

// Global State Varaibles
int16_t cuttingTimeOut = 2200;
int16_t cuttingTimeIn = 2200;
int16_t motorSpeed = 255;
int16_t motorDirectionOut = 255;
int16_t motorDirectionIn = 0;
int16_t motorDirection = 0;

int currentButtonState = 0;  // current state of the button
int lastButtonState = 1;     // previous state of the button
Ticker buttonCheckerTicker;

// BLE
BLE ble;
GattCharacteristic characteristicMotorControl(BLE_GATT_CHAR_ADDR_MOTOR_CONTROL, 0, 1, TXRX_BUF_LEN, GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_WRITE |  GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_READ| GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_WRITE_WITHOUT_RESPONSE);
GattCharacteristic characteristicMotorSpeed(BLE_GATT_CHAR_ADDR_MOTOR_SPEED, 0, 1, TXRX_BUF_LEN, GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_WRITE | GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_READ| GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_WRITE_WITHOUT_RESPONSE);
GattCharacteristic characteristicCuttingTimeOut(BLE_GATT_CHAR_ADDR_CUT_TIME_OUT, 0, 1, TXRX_BUF_LEN, GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_WRITE | GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_READ| GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_WRITE_WITHOUT_RESPONSE);
GattCharacteristic characteristicCuttingTimeIn(BLE_GATT_CHAR_ADDR_CUT_TIME_IN, 0, 1, TXRX_BUF_LEN, GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_WRITE | GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_READ| GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_WRITE_WITHOUT_RESPONSE);
GattCharacteristic characteristicBladeTrigger(BLE_GATT_CHAR_ADDR_BLADE_TRIGGER, 0, 1, TXRX_BUF_LEN, GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_WRITE | GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_READ| GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_WRITE_WITHOUT_RESPONSE);
GattCharacteristic characteristicMotorDirection(BLE_GATT_CHAR_ADDR_MOTOR_DIRECTION, 0, 1, TXRX_BUF_LEN, GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_WRITE | GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_READ| GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_WRITE_WITHOUT_RESPONSE);
GattCharacteristic *uartChars[] = {&characteristicMotorControl, &characteristicMotorSpeed, &characteristicCuttingTimeOut, &characteristicCuttingTimeIn, &characteristicBladeTrigger, &characteristicMotorDirection};
GattService        uartService(BLE_GATT_RIO_CONTROL_SERVICE, uartChars, sizeof(uartChars) / sizeof(GattCharacteristic *));

// Setup
void setup() {

  // Pin configuration
  pinMode(buttonPin1, INPUT_PULLUP);
  pinMode(buttonPin2, OUTPUT);
  pinMode(ledPin, OUTPUT);
  analogWrite(motorPwmPin, 0);
  digitalWrite(buttonPin2, LOW);

  // BLE
  ble.init();
  ble.onDataWritten(gattServerWriteCallBack);
  ble.onDisconnection(disconnectionCallBack);
  setAdvertisement();
  ble.setAdvertisingType(GapAdvertisingParams::ADV_CONNECTABLE_UNDIRECTED);
  ble.addService(uartService);
  ble.setDeviceName((const uint8_t *)DEVICE_NAME);
  ble.setTxPower(4);
  ble.setAdvertisingInterval(160);
  ble.setAdvertisingTimeout(0);
  ble.startAdvertising();
 
  if (motorDirection == 0) {
      motorDirectionOut = 255;
      motorDirectionIn = 0;
    }
    else{
      motorDirectionOut = 0;
      motorDirectionIn = 255;
    }

  // Attach ticker for checking the trigger button state...
  buttonCheckerTicker.attach(checkTriggerButtonState, 0.1);
  
  Wire.begin();
  myMem.begin();
  if (myMem.begin()){loadCalibrationDataFromEEPROM();}
  delay(100);
  updateAllFromCurrentStateBLECharacteristic();
}

// Loop
void loop() {
  ble.waitForEvent();
}

void checkTriggerButtonState(void) {
  currentButtonState = digitalRead(buttonPin1);
  if (currentButtonState != lastButtonState) {
    if (currentButtonState == HIGH) {executeCut();}
    delay(50);
  }
  lastButtonState = currentButtonState;
}

void executeCut() {
  digitalWrite(ledPin, HIGH);
  analogWrite(motorDirPin, motorDirectionOut);
  analogWrite(motorPwmPin, motorSpeed);
  delay(cuttingTimeOut);
  analogWrite(motorDirPin, motorDirectionIn);
  delay(cuttingTimeIn);
  analogWrite(motorPwmPin, 0);
  digitalWrite(ledPin, LOW);
}

void gattServerWriteCallBack(const GattWriteCallbackParams *Handler) {

  // Live Motor Control
  // ---------------
  if (Handler->handle == characteristicMotorControl.getValueAttribute().getHandle()) {
    int characteristicIntValue = getCharacteristicValue(Handler);

    digitalWrite(ledPin, HIGH);
    if (characteristicIntValue > 0) {
      analogWrite(motorDirPin, motorDirectionOut);
      analogWrite(motorPwmPin, motorSpeed);
      delay(characteristicIntValue);
    }
    else
    {
      analogWrite(motorDirPin, motorDirectionIn);
      analogWrite(motorPwmPin, motorSpeed);
      delay(abs(characteristicIntValue));
    }
    analogWrite(motorPwmPin, 0);
    digitalWrite(ledPin, LOW);
  }
  
  // Motor Speed
  // ---------------
  else if (Handler->handle == characteristicMotorSpeed.getValueAttribute().getHandle()) {
    int characteristicIntValue = getCharacteristicValue(Handler);
    if (characteristicIntValue >= 255) {motorSpeed = 255;}
    else if (characteristicIntValue <= 0) {motorSpeed = 0;}
    else {motorSpeed = characteristicIntValue;}
    static uint8_t value_buffer[20];
    sprintf((char*)value_buffer, "%u", motorSpeed);
    ble.updateCharacteristicValue(characteristicMotorSpeed.getValueAttribute().getHandle(), (const uint8_t*)value_buffer, strlen((const char*)value_buffer));

  }
  
  
  // Cutting Time Out
  // ---------------
  else if (Handler->handle == characteristicCuttingTimeOut.getValueAttribute().getHandle()) {
    int characteristicIntValue = getCharacteristicValue(Handler);
    if (characteristicIntValue <= 0) {cuttingTimeOut = 0;}
    else {cuttingTimeOut = characteristicIntValue;}
    static uint8_t value_buffer[20];
    sprintf((char*)value_buffer, "%u", cuttingTimeOut);
    ble.updateCharacteristicValue(characteristicCuttingTimeOut.getValueAttribute().getHandle(), (const uint8_t*)value_buffer, strlen((const char*)value_buffer));
  }

  // Cutting Time In
  // ---------------
  else if (Handler->handle == characteristicCuttingTimeIn.getValueAttribute().getHandle()) {
    int characteristicIntValue = getCharacteristicValue(Handler);
    if (characteristicIntValue <= 0) {cuttingTimeIn = 0;}
    else {cuttingTimeIn = characteristicIntValue;}
    static uint8_t value_buffer[20];
    sprintf((char*)value_buffer, "%u", cuttingTimeIn);
    ble.updateCharacteristicValue(characteristicCuttingTimeIn.getValueAttribute().getHandle(), (const uint8_t*)value_buffer, strlen((const char*)value_buffer));
  }

  // Cutting Trigger
  // ---------------
  else if (Handler->handle == characteristicBladeTrigger.getValueAttribute().getHandle()) {
    if (getCharacteristicValue(Handler) == 1) {executeCut();}
  }

  // Motor Direction
  // ---------------
  else if (Handler->handle == characteristicMotorDirection.getValueAttribute().getHandle()) {
    if (getCharacteristicValue(Handler) == 0) {
      motorDirection = 0;
      motorDirectionOut = 255;
      motorDirectionIn = 0;
      static uint8_t value_buffer[20];
      sprintf((char*)value_buffer, "%u", motorDirection);
      ble.updateCharacteristicValue(characteristicMotorDirection.getValueAttribute().getHandle(), (const uint8_t*)value_buffer, strlen((const char*)value_buffer));
    }
    else{
      motorDirection = 1;
      motorDirectionOut = 0;
      motorDirectionIn = 255;
      static uint8_t value_buffer[20];
      sprintf((char*)value_buffer, "%u", motorDirection);
      ble.updateCharacteristicValue(characteristicMotorDirection.getValueAttribute().getHandle(), (const uint8_t*)value_buffer, strlen((const char*)value_buffer));

    }
  }

  saveAllCalibrationData();
}

void setAdvertisement(void) {
  ble.accumulateAdvertisingPayload(GapAdvertisingData::BREDR_NOT_SUPPORTED | GapAdvertisingData::LE_GENERAL_DISCOVERABLE);
  ble.accumulateAdvertisingPayload(GapAdvertisingData::SHORTENED_LOCAL_NAME, (const uint8_t *)DEVICE_NAME_SHORT, sizeof(DEVICE_NAME_SHORT) - 1);
  ble.accumulateScanResponse(GapAdvertisingData::COMPLETE_LOCAL_NAME, (const uint8_t *)DEVICE_NAME, sizeof(DEVICE_NAME) - 1);
}

void disconnectionCallBack(const Gap::DisconnectionCallbackParams_t *params) {
  ble.startAdvertising();
}

int getCharacteristicValue(const GattWriteCallbackParams *Handler) {
  String characteristicStringValue;
  for (int index = 0; index < Handler->len; index++) {
    characteristicStringValue.concat((char)Handler->data[index]);
  }
  return characteristicStringValue.toInt();
}

void saveAllCalibrationData(){

// cuttingTimeOut
myMem.write(0, highByte(cuttingTimeOut));
myMem.write(1, lowByte(cuttingTimeOut));  

// cuttingTimeIn
myMem.write(2, highByte(cuttingTimeIn));
myMem.write(3, lowByte(cuttingTimeIn)); 

// motorSpeed
myMem.write(4, highByte(motorSpeed));
myMem.write(5, lowByte(motorSpeed)); 

// motorDirection
myMem.write(6, highByte(motorDirection));
myMem.write(7, lowByte(motorDirection)); 
  
}

void loadCalibrationDataFromEEPROM(){
  cuttingTimeOut = ((byte)myMem.read(0) << 8) + myMem.read(1);
  cuttingTimeIn = ((byte)myMem.read(2) << 8) + myMem.read(3);
  motorSpeed = ((byte)myMem.read(4) << 8) + myMem.read(5);
  motorDirection = ((byte)myMem.read(6) << 8) + myMem.read(7);
}
 void updateAllFromCurrentStateBLECharacteristic(){
    static uint8_t value_buffer[20];
    sprintf((char*)value_buffer, "%u", motorSpeed);
    ble.updateCharacteristicValue(characteristicMotorSpeed.getValueAttribute().getHandle(), (const uint8_t*)value_buffer, strlen((const char*)value_buffer));
    sprintf((char*)value_buffer, "%u", cuttingTimeOut);
    ble.updateCharacteristicValue(characteristicCuttingTimeOut.getValueAttribute().getHandle(), (const uint8_t*)value_buffer, strlen((const char*)value_buffer));
    sprintf((char*)value_buffer, "%u", cuttingTimeIn);
    ble.updateCharacteristicValue(characteristicCuttingTimeIn.getValueAttribute().getHandle(), (const uint8_t*)value_buffer, strlen((const char*)value_buffer));
    sprintf((char*)value_buffer, "%u", motorDirection);
    ble.updateCharacteristicValue(characteristicMotorDirection.getValueAttribute().getHandle(), (const uint8_t*)value_buffer, strlen((const char*)value_buffer));
}