core.cc

Go to the documentation of this file.

/*
 * Copyright (C) 2008 Jakub Filak <xfilak01@stud.fit.vutbr.cz>
 *
 * This file is part of rob08
 *
 * rob08 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 3 of the License, or
 * any later version.
 *
 * rob08 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 rob08.  If not, see <http://www.gnu.org/licenses/>.
 */

#include "config.h"
#include "core.h"
#include "world.h"
#include "trilobot.h"

// internal includes, alphabetically sorted
#include "scanner.h"
// ATTENTION: do not include "term.h" if possible

#ifndef BUILDING_DOX
// system includes, alphabetically sorted
#   include <string>
#   include <iostream>
#endif

class CoreExporter : public IExporter
{
  public:
    CoreExporter( ICanExportImport* const e, std::ostream* const output ) 
      : exp( e ), out( output )
    {}

    virtual void MakeExport();

    virtual ~CoreExporter() {}

  private:
    ICanExportImport* const exp;
    std::ostream* const out;
};
class Core: public ICore {
    public:
        Core(IWriter *);
        virtual ~Core();

        virtual bool hasError() const { return hasError_; }
        virtual bool dispatch(const Token &);
  virtual IEnviroment& GetEnviroment() { return m_world.Enviroment(); }
  virtual Trilobot& GetTrilobot() { return m_robot; }
  virtual void Export( std::ostream& output ) { this->m_robot.Serialize(output); output << std::endl; } 
  virtual void Import( std::istream& input ) { this->m_robot.Deserialize(input); }

    private:
        IWriter         *writer_;
        bool            hasError_;
        // TODO: implement
        // TODO: remove following garbage
        unsigned whiskMask;
        unsigned distance;

  World m_world;
  CoreExporter m_export;
  Trilobot m_robot;
};

// /////////////////////////////////////////////////////////////////////////////
// CoreExporter 
void CoreExporter::MakeExport() {
  if( !DEBUG_DONT_EXPORT ) {
    *out << "#BEGIN#" << std::endl;
    exp->Export( *out );
    *out << "#END#" << std::endl;
  }
}

// /////////////////////////////////////////////////////////////////////////////
// CoreFactory implementation
ICore* CoreFactory::createCore(IWriter *writer) {
    return new Core(writer);
}

// /////////////////////////////////////////////////////////////////////////////
// Core implementation
Core::Core(IWriter *writer):
    writer_(writer),
    hasError_(false),
    m_world( ),
    m_export( this, &std::cout ),
    m_robot( &m_world, &m_export )
{
    // TODO: implement
    // TODO: remove following garbage
    whiskMask = distance = 0;
}

Core::~Core() {
    // TODO: implement
    // ATTENTION: do not delete IWriter object in this module
}

bool Core::dispatch(const Token &t) {
    // TODO: implement
    // TODO: remove following garbage

    TokenCommand cmd( t );
    m_robot.Handle( cmd );

    if( cmd.Handled() )
    {
  m_robot.Position();
  if( 0 != this->writer_ ) {
    cmd.Answer()->Write( *this->writer_ );
  }
  return true;
    }

    static unsigned char swVersionMajor = 7;
    static unsigned char swVersionMinor = 0;
    switch (t.type) {
        case ET_GET_SW_VERSION:
            writer_->writeByte(swVersionMajor);
            writer_->writeByte(swVersionMinor);
            break;

        case ET_GET_WHISKER_STATUS:
            writer_->writeByte(++whiskMask);
            break;

        case ET_GET_COMPASS_HEADING:
            writer_->writeByte(-whiskMask);
            break;

        case ET_GET_TEMP:
            // 67 degrees of Celsius
            writer_->writeByte(0x99);
            break;

        case ET_GET_WATER:
            // no watter now
            writer_->writeByte(0);
            break;

        case ET_GET_PIR:
            // PIR activity detected
            writer_->writeByte(1);
            break;

        case ET_GET_SONAR:
            writer_->writeByte(distance);
            break;

        case ET_GET_TILT:
            writer_->writeByte(0x0A);
            break;

        case ET_GET_BATT_VOLTAGE:
            // 11.8V (or 11.08V ???)
            writer_->writeByte(11);
            writer_->writeByte(8);
            break;

        case ET_GET_BUTTONS:
            writer_->writeByte(0x77);
            break;

        case ET_GET_LIGHT_LEVEL:
            // 4 separate light level sensors
            writer_->writeByte(0x11);
            writer_->writeByte(0x22);
            writer_->writeByte(0x33);
            writer_->writeByte(0x44);
            break;

        case ET_GET_SOUND_LEVEL:
            writer_->writeByte(0x88);
            break;

        case ET_GET_ENCODER_COUNTS:
            writer_->writeWord(distance);
            break;

        case ET_CMD_PG:
        case ET_CMD_PH:
        case ET_CMD_PL:
        case ET_CMD_PN:
        case ET_CMD_PW:
            // dummy implementation
            writer_->writeAck();
            break;

        case ET_CMD_PS:
            // experimental end of simulation
            return false;

        case ET_CMD_PM:
            distance += t.args[1];
            writer_->writeAck();
            break;

        default:
            break;
    }
    return true;
}

---