/*
*
* Copyright (C) 2010 Mattias Runge
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*
*/
#include "Code.h"
#include <fstream>
#include <string>
#include <streambuf>
#include <stdexcept>
#include <algorithm>
#include <boost/algorithm/string.hpp>
#include "common/common.h"
#include "common/log.h"
namespace atom {
namespace control {
#define MAX_BUFFER_SIZE 5200000
// Intel HEX record types
#define INTELHEX_RT_DATA 0x00
#define INTELHEX_RT_END 0x01
static const std::string log_module_ = "control::code";
Code::Code()
{
LOG_DEBUG_ENTER;
this->Reset(false);
//this->data_.insert(this->data_.begin(), 0xFF, MAX_BUFFER_SIZE);
LOG_DEBUG_EXIT;
}
Code::~Code()
{
LOG_DEBUG_ENTER;
LOG_DEBUG_EXIT;
}
void Code::Reset(bool fill)
{
LOG_DEBUG_ENTER;
this->address_lower_ = MAX_BUFFER_SIZE;
this->address_upper_ = 0;
this->is_valid_ = false;
common::Byteset empty_vector;
this->data_.swap(empty_vector);
if (fill)
{
this->data_.reserve(MAX_BUFFER_SIZE);
std::fill(this->data_.begin(), this->data_.begin() + MAX_BUFFER_SIZE, 0xFF);
}
LOG_DEBUG_EXIT;
}
void Code::CalculateChecksum()
{
LOG_DEBUG_ENTER;
this->checksum_ = 0;
for (unsigned int n = this->address_lower_; n <= this->address_upper_; n++)
{
this->checksum_ ^= this->data_[n];
for (unsigned int c = 0; c < 8; c++)
{
if ((this->checksum_ & 1) != 0)
{
this->checksum_ = (this->checksum_ >> 1) ^ 0xA001;
}
else
{
this->checksum_ = (this->checksum_ >> 1);
}
}
}
this->checksum_ &= 0xFFFF;
LOG_DEBUG_EXIT;
}
void Code::AddByte(unsigned char byte)
{
LOG_DEBUG_ENTER;
this->data_.push_back(byte);
this->address_lower_ = 0;
this->address_upper_ = this->data_.size();
this->is_valid_ = true;
this->CalculateChecksum();
LOG_DEBUG_EXIT;
}
bool Code::LoadIntelHexFile(std::string filename)
{
LOG_DEBUG_ENTER;
std::ifstream file(filename.data());
if (!file.is_open())
{
return false;
}
std::string buffer((std::istreambuf_iterator<char>(file)), std::istreambuf_iterator<char>());
file.close();
bool result = this->ParseIntelHex(buffer);
LOG_DEBUG_EXIT;
return result;
}
bool Code::ParseIntelHex(std::string data)
{
LOG_DEBUG_ENTER;
common::StringList lines;
boost::algorithm::split(lines, data, boost::is_any_of("\n"), boost::algorithm::token_compress_on);
this->Reset(true);
unsigned int byte_count;
unsigned int addess;
unsigned int record_type;
for (unsigned int n = 0; n < lines.size(); n++)
{
log::Debug(log_module_, "line[" + boost::lexical_cast<std::string> (n) + "]=" + lines[n]);
if (lines[n].length() >= 11 && lines[n][0] == ':')
{
//log::Debug(log_module_, "A:" + lines[n].substr(1, 2));
byte_count = boost::lexical_cast<common::HexTo<unsigned int> >("0x" + lines[n].substr(1, 2)); //common::FromHex(lines[n].substr(1, 2));
log::Debug(log_module_, "byte_count=" + boost::lexical_cast<std::string>(byte_count));
//log::Debug(log_module_, "B:" + lines[n].substr(3, 4));
addess = boost::lexical_cast<common::HexTo<unsigned int> >("0x" + lines[n].substr(3, 4)) & 0xFFFF; //common::FromHex(lines[n].substr(3, 4)) & 0xFFFF;
log::Debug(log_module_, "addess=" + boost::lexical_cast<std::string> (addess));
record_type = boost::lexical_cast<common::HexTo<unsigned int> >("0x" + lines[n].substr(7, 2)); //common::FromHex(lines[n].substr(7, 2));
switch (record_type)
{
case INTELHEX_RT_DATA:
{
this->address_lower_ = std::min(this->address_lower_, addess);
this->address_upper_ = std::max(this->address_upper_, addess + byte_count - 1);
for (unsigned int c = 0; c < byte_count; c++)
{
//log::Debug(log_module_, "D:" + lines[n].substr(c * 2 + 9, 2));
this->data_[addess + c] = boost::lexical_cast<common::HexTo<unsigned int> >("0x" + lines[n].substr(c * 2 + 9, 2));
//this->data[addess + c] = (unsigned char)common::FromHex(lines[n].substr(c * 2 + 9, 2));
}
break;
}
case INTELHEX_RT_END:
{
this->is_valid_ = true;
break;
}
}
}
}
if (this->is_valid_)
{
this->CalculateChecksum();
log::Info(log_module_, "Successfully parsed Intel HEX file.");
}
LOG_DEBUG_EXIT;
return this->is_valid_;
}
unsigned int Code::GetAddressLower()
{
LOG_DEBUG_ENTER;
LOG_DEBUG_EXIT;
return this->address_lower_;
}
unsigned int Code::GetAddressUpper()
{
LOG_DEBUG_ENTER;
LOG_DEBUG_EXIT;
return this->address_upper_;
}
unsigned char Code::GetByte(unsigned int address)
{
LOG_DEBUG_ENTER;
LOG_DEBUG_EXIT;
return this->data_[address];
}
unsigned int Code::GetChecksum()
{
LOG_DEBUG_ENTER;
LOG_DEBUG_EXIT;
return this->checksum_;
}
unsigned int Code::GetLength()
{
LOG_DEBUG_ENTER;
LOG_DEBUG_EXIT;
return this->address_upper_ - this->address_lower_ + 1;
}
bool Code::IsValid()
{
LOG_DEBUG_ENTER;
LOG_DEBUG_EXIT;
return this->is_valid_;
}
}; // namespace control
}; // namespace atom