[prev in list] [next in list] [prev in thread] [next in thread] 

List:       orocos-announce
Subject:    [Orocos] :: mykernel.loadController problem ::
From:       xorocox () wp ! pl (Patrycjusz Szczepaniak)
Date:       2004-11-01 19:34:00
Message-ID: 41868031.8060609 () wp ! pl
[Download RAW message or body]

Hello,

I am trying to write a simple kernel to understand how Orocos works. I 
wrote my generator, sensor and cotroller. Everything would be ok, but 
when I am trying to load anything (controller, sensor...) to a kernel I 
have lots of errors.

1) Could you tell me what is wrong?
2) Could you have a look at the code and tell me is there anything that 
I should write in a different way?

I am using Orocos from SVN.

Patrycjusz Szczepaniak

P.S. INPUT is supposed to generate inputs for MySensor.

["firstkernel.cxx" (text/x-c++src)]

#include <corelib/TaskPreemptible.hpp>


#include <control_kernel/StandardControlKernel.hpp>
#include <control_kernel/BaseComponents.hpp>
#include <control_kernel/ExtensionComposition.hpp>

#include <os/main.h>
#include <control_kernel/DataServer.hpp>
#include <control_kernel/PortInterfaces.hpp>

#include <corelib/TaskPreemptible.hpp>

using namespace std;
using namespace ORO_CoreLib;
using namespace ORO_ControlKernel;

// Simulating sensor
class INPUTtype{
  double internalVal;
public:
  INPUTtype():internalVal(0){};
  void Get(double in){
    in=internalVal++;
  }
} INPUT;


//typedef StardardControlKernel<KernelBaseFunction> MyKernel;


// Structures
struct MG_InputData
  : public ServedTypes<double>
{ 
  MG_InputData() { 
    this->insert( make_pair(0, "Number")); 
  } 
};

struct MG_SetPointData
  : public ServedTypes<double>
{
  MG_SetPointData() { 
    this->insert( make_pair(0, "Number")); 
  } 
};


/**********************************
***           Generator         ***
***********************************/
typedef Generator<
  Expects<MG_InputData>,
  Expects<NoModel>,
  Expects<NoCommand>,
  Writes<MG_SetPointData>
  //  ,MakeAspect<KernelBaseFunction>::Result
>GenType;

class MyGenerator
  :GenType
{


  double input;
  double setpoint;

  DataObjectInterface<double>* input_dobj;
  DataObjectInterface<double>* setpoint_dobj;
  
public:
  bool componentLoaded(){
    // Early resolving of write data objects
    if(! GenType::SetPoint::dObj()->Get("Number",setpoint_dobj) ){
      return false;
    }
    return true;
  }

  bool componentStartup(){ 
    // Early resolving of read data objects;
    if ( !GenType::Input::dObj()->Get("Number", input_dobj)){
      return false; 
    } 
    return true; 
  }

  MyGenerator(const std::string& name="MyGeneratorName")
  :GenType(name){}

  void pull(){
    input_dobj->Get(input);
  }

  void calculate(){
    input++;
  }
  void push(){
    setpoint_dobj->Set(setpoint);
  }

};

/******************************************
 ****    Controller ***********************
 *****************************************/

typedef Controller<
  Expects<NoInput>,
  Expects<NoModel>,
  Expects<MG_SetPointData>,
  Writes<NoOutput>
> ConType;

class MyController:ConType{
 
  double setpoint;
  
  DataObjectInterface<double>* setpoint_dobj;

public:
  MyController(const std::string& name="MyController")
    :ConType(name){}

  bool componentLoaded(){
    return true;
  }

  bool componentStartup(){
    if ( !ConType::SetPoint::dObj()->Get("Number",setpoint_dobj)){
      return false;
    }
    return true;
  }

  void pull(){
    setpoint_dobj->Get(setpoint);
  }

  void calcuate(){}
  void push(){}
};


/******************************************
 **********     Sensor     ***************
 *****************************************/
typedef Sensor<
  Writes<MG_InputData>
// ,  MakeAspect<KernelBaseFunction>::Result
> SenType;

class MySensor:SenType
{
  double input;

  DataObjectInterface<double>* input_dobj;

public:
  MySensor(const std::string& name="MySensorName")
    :SenType(name){}

  bool componentLoaded(){
    if ( !SenType::Input::dObj()->Get("Number", input_dobj)){
      return false; 
    } 
    return true;     
  }

  bool componentStartup(){return true;}

  void pull(){
    INPUT.Get(input);
  }

  void calculate(){}

  void push(){
    input_dobj->Set(input);
  }
};

/******************************************
 ****    Main    **************************
 *****************************************/

typedef StandardControlKernel<> myKernelType;

int ORO_main(int argc, const char **argv){

  myKernelType my_kernel("MyKernel");

  MyGenerator my_gen;
  MyController my_con;
  MySensor my_sen;

  // my_kernel.loadGenerator(&my_gen);
  // my_kernel.loadController(&my_con);
  // my_kernel.loadSensor(&my_sen);

  return 0;
}



["Makefile" (text/plain)]

CC = g++
LD = ld

OROFLAGS=-Wall

all: firstkernel
	@echo -e "\nType make all-lxrt if you want to compile for lxrt.\n"

all-lxrt: firstkernel-lxrt

firstkernel.o: firstkernel.cxx  orocos/include
	${CC} ${OROFLAGS} -c $< -o $@ -I orocos/include

firstkernel: firstkernel.o orocos/lib/libtarget.a
	${CC} -o $@ $@.o -L orocos/lib -ltarget -lm -lxerces-c -lpthread -lboost_signals

clean:
	rm -f *.o
	rm -f cartkernel-lxrt cartkernel


[prev in list] [next in list] [prev in thread] [next in thread]