ls_serial.ino

/******************************** ls_serial: LinnStrument Serial **********************************
This work is licensed under the Creative Commons Attribution-ShareAlike 3.0 Unported License.
To view a copy of this license, visit http://creativecommons.org/licenses/by-sa/3.0/
or send a letter to Creative Commons, PO Box 1866, Mountain View, CA 94042, USA.
***************************************************************************************************

**************************************************************************************************/

// Handshake codes for settings transfer
const char* countDownCode = "5, 4, 3, 2, 1 ...\n";
const byte countDownLength = 18;
const char* linnGoCode = "LinnStruments are go!\n"; 
const char* ackCode = "ACK\n";
const char* linnStrumentControlCode = "LC\n";
const byte linnStrumentControlLength = 3;

boolean waitingForCommands = false;

enum linnCommands {
  ACK = 'a',
  CRCCheck = 'c',
  CRCWrong = 'w',
  CRCOk = 'o',
  LightLed = 'l',
  SendSingleProject = 'j',
  SendProjects = 'p',
  RestoreProject = 'q',
  RestoreSettings = 'r',
  SendSettings = 's'
};

byte codePos = 0;
uint32_t lastSerialMoment = 0;

static PROGMEM prog_uint32_t crc_table[16] = {
    0x00000000, 0x1db71064, 0x3b6e20c8, 0x26d930ac,
    0x76dc4190, 0x6b6b51f4, 0x4db26158, 0x5005713c,
    0xedb88320, 0xf00f9344, 0xd6d6a3e8, 0xcb61b38c,
    0x9b64c2b0, 0x86d3d2d4, 0xa00ae278, 0xbdbdf21c
};

uint32_t crc_update(uint32_t crc, uint8_t data) {
    uint8_t tbl_idx;
    tbl_idx = crc ^ (data >> (0 * 4));
    crc = pgm_read_dword_near(crc_table + (tbl_idx & 0x0f)) ^ (crc >> 4);
    tbl_idx = crc ^ (data >> (1 * 4));
    crc = pgm_read_dword_near(crc_table + (tbl_idx & 0x0f)) ^ (crc >> 4);
    return crc;
}

uint32_t crc_byte_array(uint8_t* s, uint8_t size) {
  uint32_t crc = ~0L;
  for (uint8_t i = 0; i < size; ++i) {
    crc = crc_update(crc, *s++);
  }
  crc = ~crc;
  return crc;
}

void handleSerialIO() {
  // if no serial data is available, return
  if (Serial.available() <= 0) {
    return;
  }

  // get the next byte from the serial bus
  byte d = Serial.read();

  // check for a recognized command
  if (waitingForCommands) {
    switch (d) {
      case SendSettings:
      {
        serialSendSettings();
        break;
      }

      case RestoreSettings:
      {
        serialRestoreSettings();
        break;
      }

      case LightLed:
      {
        serialLightLed();
        break;
      }

      case SendSingleProject:
      {
        serialSendSingleProject();
        break;
      }

      case SendProjects:
      {
        serialSendProjects();
        break;
      }

      case RestoreProject:
      {
        serialRestoreProject();
        break;
      }

      default:
      {
        waitingForCommands = false;
        break;
      }
    }
  }
  // handle readyness countdown state
  else {
    if (d == countDownCode[codePos]) {
      codePos++;
      if (codePos == countDownLength) {
        codePos = 0;
        waitingForCommands = true;
        Serial.write(linnGoCode);
      }
    }
    else if (d == linnStrumentControlCode[codePos]) {
      codePos++;
      if (codePos == linnStrumentControlLength) {
        codePos = 0;
        waitingForCommands = true;
        controlModeActive = true;
        clearDisplay();
        updateDisplay();
        Serial.write(ackCode);
      }
    }
    else {
      codePos = 0;
    }
  }
}

boolean waitForSerialAck() {
  if (!serialWaitForMaximumTwoSeconds()) return false;
  char ack = Serial.read();
  lastSerialMoment = millis();
  if (ack != ACK) return false;
  return true;
}

boolean waitForSerialCheck() {
  if (!serialWaitForMaximumTwoSeconds()) return false;
  char ack = Serial.read();
  lastSerialMoment = millis();
  if (ack != CRCCheck) return false;
  return true;
}

char waitForSerialCRC() {
  if (!serialWaitForMaximumTwoSeconds()) return 0;
  char ack = Serial.read();
  lastSerialMoment = millis();
  return ack;
}

int negotiateOutgoingCRC(byte* buffer, uint8_t size) {
  uint32_t crc = crc_byte_array(buffer, size);
  Serial.write((byte*)&crc, sizeof(uint32_t));

  char crcresponse = waitForSerialCRC();
  if (crcresponse == 0) return -1;
  if (crcresponse == CRCWrong) return 0;
  return 1;
}

int negotiateIncomingCRC(byte* buffer, uint8_t size) {
  Serial.write(CRCCheck);

  byte buff_crc[sizeof(uint32_t)];
  for (byte k = 0; k < sizeof(uint32_t); ++k) {
    if (!serialWaitForMaximumTwoSeconds()) return -1;
    buff_crc[k] = Serial.read();
    lastSerialMoment = millis();
  }
  uint32_t remote_crc;
  memcpy(&remote_crc, buff_crc, sizeof(uint32_t));

  uint32_t local_crc = crc_byte_array(buffer, size);
  if (local_crc != remote_crc) {
    Serial.write(CRCWrong);
    return 0;
  }

  Serial.write(CRCOk);
  return 1;
}

void serialSendSettings() {
  Serial.write(ackCode);

  clearDisplayImmediately();
  delayUsec(1000);

  int32_t confSize = sizeof(Configuration);

  // send the size of the settings
  Serial.write((byte*)&confSize, sizeof(int32_t));

  // send the actual settings
  const uint8_t batchsize = 96;
  byte* src = (byte*)&config;
  lastSerialMoment = millis();
  while (confSize > 0) {
    int actual = min(confSize, batchsize);
    Serial.write(src, actual);

    if (!waitForSerialCheck()) return;

    int crc = negotiateOutgoingCRC(src, actual);
    if (crc == -1)      return;
    else if (crc == 0)  continue;

    confSize -= actual;
    src += actual;
  }

  Serial.write(ackCode);
}

boolean serialWaitForMaximumTwoSeconds() {
  // retry if there's no data available
  while (Serial.available() <= 0) {
    // timeout after 2s if no data is coming in anymore
    if (calcTimeDelta(millis(), lastSerialMoment) > 2000) {
      waitingForCommands = false;
      return false;
    }
  }

  return true;
}

void serialRestoreSettings() {
  Serial.write(ackCode);

  clearDisplayImmediately();
  delayUsec(1000);

  // retrieve the size of the settings
  lastSerialMoment = millis();

  byte buff1[sizeof(int32_t)];
  for (byte i = 0; i < sizeof(int32_t); ++i) {
    if (!serialWaitForMaximumTwoSeconds()) return;
    buff1[i] = Serial.read();
    lastSerialMoment = millis();
  }
  int32_t settingsSize;
  memcpy(&settingsSize, buff1, sizeof(int32_t));

  Serial.write(ackCode);

  // restore the actual settings
  uint32_t projectOffset = SETTINGS_OFFSET;
  const uint8_t batchsize = 96;
  byte buff2[batchsize];
  lastSerialMoment = millis();
  int32_t remaining = settingsSize;
  while (remaining > 0) {
    int actual = min(remaining, batchsize);
    for (byte k = 0; k < actual; ++k) {
      if (!serialWaitForMaximumTwoSeconds()) return;
      buff2[k] = Serial.read();
      lastSerialMoment = millis();
    }

    int crc = negotiateIncomingCRC(buff2, actual);
    if (crc == -1)      return;
    else if (crc == 0)  continue;

    dueFlashStorage.write(projectOffset, buff2, actual);

    remaining -= actual;
    projectOffset += actual;
  }

  boolean settingsApplied = upgradeConfigurationSettings(settingsSize, dueFlashStorage.readAddress(SETTINGS_OFFSET));

  // activate the retrieved settings
  if (settingsApplied) {
    applyConfiguration();
  }

  // send the acknowledgement of success
  Serial.write(ackCode);
  delayUsec(1000000);

  // Turn off OS upgrade mode
  switchSerialMode(false);

  // Enable normal playing mode and ensure calibration is fully turned off
  if (settingsApplied && Device.calibrated) {
    setDisplayMode(displayNormal);
    clearLed(0, GLOBAL_SETTINGS_ROW);

    storeSettings();
  }
  // turn on calibration instead if no new settings were applied and default settings are used
  else {
    setDisplayMode(displayCalibration);
    controlButton = GLOBAL_SETTINGS_ROW;
    lightLed(0, GLOBAL_SETTINGS_ROW);
  }

  updateDisplay();
  waitingForCommands = false;
}

void serialLightLed() {
  lastSerialMoment = millis();

  byte buff[3];
  for (byte i = 0; i < 3; ++i) {
    if (!serialWaitForMaximumTwoSeconds()) return;

    // read the next byte of the configuration size
    buff[i] = Serial.read();
    lastSerialMoment = millis();
  }

  setLed(buff[0], buff[1], buff[2], cellOn);

  updateDisplay();
}

int32_t serialSendProjectSize() {
  // send the size of a project
  int32_t projectSize = sizeof(SequencerProject);
  Serial.write((byte*)&projectSize, sizeof(int32_t));
  lastSerialMoment = millis();
  return projectSize;
}

void serialSendProjectRaw(int32_t projectSize, byte projectNumber) {
  byte marker = dueFlashStorage.read(PROJECTS_OFFSET);

  // send the actual settings
  const uint8_t batchsize = 96;

  byte prjIndex = dueFlashStorage.read(PROJECT_INDEX_OFFSET(marker, projectNumber));
  uint32_t projectOffset = PROJECTS_OFFSET + PROJECTS_MARKERS_SIZE + prjIndex * SINGLE_PROJECT_SIZE;
  int32_t remaining = projectSize;

  byte* src = (byte*)dueFlashStorage.readAddress(projectOffset);
  while (remaining > 0) {
    int actual = min(remaining, batchsize);
    Serial.write(src, actual);

    if (!waitForSerialCheck()) return;

    int crc = negotiateOutgoingCRC(src, actual);
    if (crc == -1)      return;
    else if (crc == 0)  continue;

    remaining -= actual;
    src += actual;
  }
}

void serialSendSingleProject() {
  Serial.write(ackCode);

  clearDisplayImmediately();
  delayUsec(1000);

  lastSerialMoment = millis();

  if (!serialWaitForMaximumTwoSeconds()) return;
  
  uint8_t projectNumber = Serial.read();
  Serial.write(ackCode);

  Serial.write(Device.version);

  int32_t projectSize = serialSendProjectSize();
  serialSendProjectRaw(projectSize, projectNumber);

  Serial.write(ackCode);
}

void serialSendProjects() {
  Serial.write(ackCode);

  clearDisplayImmediately();
  delayUsec(1000);

  // send the count of projects
  Serial.write((byte)MAX_PROJECTS);

  int32_t projectSize = serialSendProjectSize();

  for (byte p = 0; p < MAX_PROJECTS; ++p) {
    serialSendProjectRaw(projectSize, p);
  }

  Serial.write(ackCode);
}


void serialRestoreProject() {
  Serial.write(ackCode);

  clearDisplayImmediately();
  delayUsec(1000);

  lastSerialMoment = millis();

  if (!serialWaitForMaximumTwoSeconds()) return;
  uint8_t version = Serial.read();
  if (version < 9) return;
  Serial.write(ackCode);
  lastSerialMoment = millis();

  // retrieve the size of a project
  byte buff1[sizeof(int32_t)];
  for (byte i = 0; i < 4; ++i) {
    if (!serialWaitForMaximumTwoSeconds()) return;

    // read the next byte of the project size
    buff1[i] = Serial.read();
    lastSerialMoment = millis();
  }

  int32_t projectSize;
  memcpy(&projectSize, buff1, sizeof(int32_t));

  if (projectSize != sizeof(SequencerProject)) return;

  Serial.write(ackCode);

  if (!serialWaitForMaximumTwoSeconds()) return;

  uint8_t p = Serial.read();
  Serial.write(ackCode);

  // write the actual project
  byte marker = dueFlashStorage.read(PROJECTS_OFFSET);
  byte prjIndex = dueFlashStorage.read(PROJECT_INDEX_OFFSET(marker, p));
  uint32_t projectOffset = PROJECTS_OFFSET + PROJECTS_MARKERS_SIZE + prjIndex * SINGLE_PROJECT_SIZE;

  const uint8_t batchsize = 96;
  byte buff2[batchsize];
  lastSerialMoment = millis();
  int32_t remaining = projectSize;
  while (remaining > 0) {
    int actual = min(remaining, batchsize);
    for (byte k = 0; k < actual; ++k) {
      if (!serialWaitForMaximumTwoSeconds()) return;
      buff2[k] = Serial.read();
      lastSerialMoment = millis();
    }

    int crc = negotiateIncomingCRC(buff2, actual);
    if (crc == -1)      return;
    else if (crc == 0)  continue;

    dueFlashStorage.write(projectOffset, buff2, actual);

    remaining -= actual;
    projectOffset += actual;
  }

  // finished
  Serial.write(ackCode);
  delayUsec(500000);
}