/*
*
* 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 <stdexcept>
#include <algorithm>
#include <boost/algorithm/string.hpp>
#include "common/common.h"
namespace atom {
namespace control {
#define MAX_BUFFER_SIZE 5200000
// Intel HEX record types
#define INTELHEX_RT_DATA 0x00
#define INTELHEX_RT_END 0x01
Code::Code() : LOG("control::code"), data_(MAX_BUFFER_SIZE)
{
this->Reset();
}
Code::~Code()
{
}
void Code::Reset()
{
this->address_lower_ = MAX_BUFFER_SIZE;
this->address_upper_ = 0;
this->data_.SetSize(0);
this->data_.Fill(0xFF);
this->is_valid_ = false;
}
void Code::CalculateChecksum()
{
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;
}
void Code::AddByte(unsigned char byte)
{
this->data_.Append(byte);
this->address_lower_ = 0;
this->address_upper_ = this->data_.GetSize() - 1;
this->is_valid_ = true;
this->CalculateChecksum();
}
bool Code::LoadIntelHexFile(std::string filename)
{
std::ifstream file(filename.data());
if (!file.is_open())
{
return false;
}
std::string buffer = "";
std::string line;
while (!file.eof())
{
std::getline(file, line);
if (file.eof())
{
break;
}
buffer += line + "\n";
}
file.close();
return this->ParseIntelHex(buffer);
}
bool Code::ParseIntelHex(std::string data)
{
common::StringList lines;
boost::algorithm::split(lines, data, boost::is_any_of("\n"), boost::algorithm::token_compress_on);
this->Reset();
unsigned int byte_count;
unsigned int addess;
unsigned int record_type;
for (unsigned int n = 0; n < lines.size(); n++)
{
LOG.Debug("line[" + boost::lexical_cast<std::string>(n) + "]=" + lines[n]);
if (lines[n].length() >= 11 && lines[n][0] == ':')
{
//LOG.Debug("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("byte_count=" + boost::lexical_cast<std::string>(byte_count));
//LOG.Debug("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("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("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("Successfully parsed Intel HEX file.");
}
return this->is_valid_;
}
unsigned int Code::GetAddressLower()
{
return this->address_lower_;
}
unsigned int Code::GetAddressUpper()
{
return this->address_upper_;
}
unsigned char Code::GetByte(unsigned int address)
{
return this->data_[address];
}
unsigned int Code::GetChecksum()
{
return this->checksum_;
}
unsigned int Code::GetLength()
{
return this->address_upper_ - this->address_lower_ + 1;
}
bool Code::IsValid()
{
return this->is_valid_;
}
}; // namespace control
}; // namespace atom