fztatCtrl.cpp

/*
  F-ZTAT 管理クラス
  Satofumi KAMIMURA
  $Id$
*/

#include "fztatCtrl.h"
#include <stdio.h>


FZTAT_Ctrl::FZTAT_Ctrl(const char* device, long writeBaudrate)
  : error_message("no error"), con(NULL), debug_level(0), view_callback(NULL),
    con_device(device), write_baudrate(writeBaudrate), mode(NotInitialized) {

  char* level = getenv("DEBUG_VIEW");
  if (level) {
    debug_level = atoi(level);
  }
}


FZTAT_Ctrl::~FZTAT_Ctrl(void) {
  disconnect();
}


const char* FZTAT_Ctrl::what(void) {
  return error_message.c_str();
}


int FZTAT_Ctrl::connect(long baudrate) {
  disconnect();

  con = new SerialDevice;
  int ret_value = con->connect(con_device, baudrate);
  if (!ret_value) {
    error_message = con->what();
  }
  return ret_value;
}


void FZTAT_Ctrl::disconnect(void) {
  delete con;
  con = NULL;
}


bool FZTAT_Ctrl::adjustBaudrate(void) {
  if (mode != NotInitialized) {
    error_message = "adjustBaudrate() must be called 1st.";
    return false;
  }
  mode = Invalid;
  if (debug_level >= 2) {
    mode = BaudrateAdjusted;
    return true;
  }

  // 初期ボーレート合わせ
  enum { FirstBaudrate = 9600, SendTimes = 64 };
  if (connect(FirstBaudrate) < 0) {
    return false;
  }

  int i;
  char send_ch = 0x00;
  for (i = 0; i < SendTimes; ++i) {
    for (int j = 0; j < 3; ++j) {
      con->send(&send_ch, 1);
    }
    unsigned char recv_ch = 0xff;
    if ((con->recv((char*)&recv_ch, 1, 1) > 0) && (recv_ch == 0x00)) {
      break;
    }
  }
  if (i == SendTimes) {
    error_message = "no reply! (expected 0x00)";
    return false;
  }
  con->flush();

  send_ch = 0x55;
  unsigned char recv_ch = 0xff;
  con->send(&send_ch, 1);
  int n = con->recv((char*)&recv_ch, 1, Timeout);
  if ((n > 0) && (recv_ch == 0xaa)) {
    mode = BaudrateAdjusted;
    return true;
  }

  error_message = "no reply! (expected 0xaa)";
  return false;
}


bool FZTAT_Ctrl::sendWriteProgram(char* code, int size) {
  if (mode != BaudrateAdjusted) {
    error_message = "sendWriteProgram() must be called 2nd.";
    return false;
  }
  mode = Invalid;
  if (debug_level >= 2) {
    mode = ProgramSended;
    return true;
  }

  // 書き込み制御プログラムのサイズを転送
  char size_array[] = { size >> 8, size & 0xff };
  con->send(size_array, 2);

  char recv_buffer[2];
  int n = con->recv(recv_buffer, 2, Timeout);
  if ((n < 2) || strncmp(size_array, recv_buffer, 2)) {
    error_message = "send program size: echo back fail!";
    return false;
  }

  // 書き込み制御プログラムの転送
  con->send(code, size);
  for (int i = 0; i < size; ++i) {
    char echoback_ch;
    con->recv(&echoback_ch, 1, Timeout);
  }

  if ((con->recv(recv_buffer, 1, Timeout) <= 0) ||
      (static_cast<unsigned char>(recv_buffer[0]) != 0xaa)) {
    error_message = "no reply! (expected 0xaa)";
    return false;
  }
  con->setBaudrate(write_baudrate);

  mode = ProgramSended;
  return true;
}


void FZTAT_Ctrl::setProgressCallback(progressView_t func) {
  view_callback = func;
}


bool FZTAT_Ctrl::isLF(const char ch) {
  return ((ch == '\r') || (ch == '\n')) ? true : false;
}


long FZTAT_Ctrl::setDataBuffer(char* buffer, SFormat_Ctrl::srec_t* srec) {

  // アドレス情報の配置
  long address = srec->address & 0xffffffe0;
  buffer[0] = static_cast<char>(address >> 24);
  buffer[1] = static_cast<char>(address >> 16);
  buffer[2] = static_cast<char>(address >> 8);
  buffer[3] = static_cast<char>(address);

  // データ情報の配置
  int offset = (srec->address & 0x00000010) ? 16 : 0;
  for (int i = 0; i < 16; ++i) {
    buffer[4 + offset + i] = srec->byte_data[i];
  }

  // チェックサムの生成
  char sum = 0;
  for (int i = 0; i < 4 + 32; ++i) {
    sum += buffer[i];
  }
  buffer[4 + 32] = sum;

  return address;
}


bool FZTAT_Ctrl::fillSendBuffer(int* sended,
                               char* buffer, const char* code, int left) {
  enum { InvalidAddress = -1 };
  long now_address = InvalidAddress;
  int index = 0;
  bool doSend = false;
  memset(buffer, 0, 4 + 32 + 1);

  for (int i = 0; (i < 2) && (index < left); ) {
    SFormat_Ctrl::srec_t srec;
    int n = SFormat_Ctrl::parseSFormat(&srec, &code[index]);
    if (n <= 0) {
      *sended = n;
      return doSend;
    }
    if (debug_level > 0) {
      for (int j = 0; j < n; ++j) {
        fprintf(stderr, "%c", code[index + j]);
      }
      fprintf(stderr, "\n");
    }

    if ((srec.type < 1) || (srec.type > 3)) {
      index += n;
      continue;
    }

    long set_address = srec.address & 0xffffffe0;
    if ((now_address != InvalidAddress) && (now_address != set_address)) {
      *sended = index;
      return doSend;
    }
    now_address = setDataBuffer(buffer, &srec);
    index += n;
    doSend = true;

    ++i;
  }
  *sended = index;
  return doSend;
}


bool FZTAT_Ctrl::writeRom(char* code, int size, long baudrate) {
  if (mode != ProgramSended) {
    error_message = "writeRom() must be called 3rd.";
    return false;
  }
  mode = Invalid;

  // 書き込み時のボーレートを設定
  char send_buffer[LineMax];
  sprintf(send_buffer, "S%ld\n", write_baudrate);
  int len = strlen(send_buffer);
  if (debug_level > 0) {
    fprintf(stderr, "%s", send_buffer);
  }

  char recv_buffer[LineMax];
  if (debug_level < 2) {
    con->send(send_buffer, len);
    con->setBaudrate(write_baudrate); //connect(write_baudrate);
    if ((con->recv(recv_buffer, 1, Timeout) <= 0) || (recv_buffer[0] != '0')) {
      error_message = "no reply! (expected '0')";
      return false;
    }
  }

  // 書き込みたいデータの転送
  int retry_times = 0;
  int sended = 0;
  do {
    retry_times = 0;

    int srec_size = 0;
    bool doSend = fillSendBuffer(&srec_size,
                                 send_buffer, &code[sended], size - sended);
    if (srec_size <= 0) {
      error_message = "S-Format file error!";
      return false;
    }
    if (doSend && (debug_level > 0)) {
      for (int i = 0; i < 4 + 32 + 1; ++i) {
        fprintf(stderr, "%02x", (unsigned char)send_buffer[i]);
      }
      fprintf(stderr, "\n");
    }
    sended += srec_size;
    if (view_callback) {
      view_callback(sended, size);
    }
    if (debug_level >= 2) {
      continue;
    }

    do {
      if (doSend) {
        con->send(send_buffer, 4 + 32 + 1);
      }
      int n = con->recv(recv_buffer, 1, Timeout);
      if (!doSend || ((n > 0) && (recv_buffer[0] == '0'))) {
        break;
      }
      if (n < 1) {
        error_message = "reply timeout!";
        return false;

      } else if (recv_buffer[0] == 'E') {
        error_message = "flush writing fail!";
        return false;
      }

    } while (retry_times++ < RetryMax);
    if (retry_times == RetryMax) {
      error_message = "retry times over";
      return false;
    }
  } while (sended < size);

  mode = Writed;
  return true;
}