automobile_network.cc

/*
 * Source file for class automobile_network
 * Models outgoing and incoming messages
 * Determines if a message is received based on the computed bit error rate
 * Copyright 2013, Princeton Satellite Systems.
 */

#include "automobile_network.h"
#include <string.h>


automobile_network :: automobile_network(dsim_model_setup *setup) : dsim_model(setup)
{
}

void automobile_network :: initialize_data()
{
        dsim_model::initialize_data();
        
        ml_matrix tempN(0,0), temp2(2,1);
        
        int transmit        = 0;
        
        // Published Variables  
        
        message_incoming_dsim           =       create_output("message_incoming",   sd_type_matrix, &tempN,         0, 0, "", "Message incoming");      
        position_dsim                           =       create_output("position",           sd_type_matrix, &temp2,                     2, 1, "km", "Position of parent");
    
        message_outgoing_dsim           =       create_input("message_outgoing",    sd_type_matrix, &tempN,         0, 0, "", "Message outgoing");      
        transmit_dsim                           =       create_input("transmit",            sd_type_int,        &transmit,      1, 1, "", "Transmit Signal");
    
        message_incoming_dsim.mark_telemetry();
        message_outgoing_dsim.mark_command();
        transmit_dsim.mark_telemetry_and_command();
        position_dsim.mark_telemetry();
        
        configure_timestep(true, false, true);
        
    // Automobile network
    create_target("automobile_network_target","A target watched by this automobile_network sensor.",true);
        
}

void automobile_network :: initialization_complete()
{
    dsim_model::initialization_complete();
        
    std::vector<std::string> targets = target_destinations("automobile_network_target");
        
        dsim_model *p = parent();
        
        parent_position_dsim    = p->request_local_variable("position");
        parent_yaw_matrix_dsim  = p->request_local_variable("yaw_matrix");
        
}

void automobile_network :: initialize_timestep()
{
        dsim_model::initialize_timestep();
        
        // initialize incoming message
        message_incoming = ml_matrix(0,0);
}
        

void automobile_network :: pre_calculate()
{
        dsim_model::pre_calculate();    
        
    std::vector<std::string> targets = target_destinations("automobile_network_target");
        
        if ( targets.size() == 0 ) return;
        
        // Spacecraft states
        ml_matrix r = parent_position_dsim.value_as_matrix();
    
    position_dsim.set_value_as_matrix(r);

        
        ml_matrix dR;
        
    std::vector<std::string>::iterator i = targets.begin();     
        
    for (int k=1;i!=targets.end();i++,k++)
    {
        // request position from targets
                std::string varPath = (*i) + ":position";
        dsim_variable posVar = request_variable(varPath.c_str());               
                
                
                if (!posVar.valid() )
                {
                        warning("Target position not valid\n");
                }
                else
                {
                        
                        ml_matrix m(1,1);
                        ml_matrix pos = posVar.value_as_matrix();
                        
                        dR = pos - r;

                        if( transmit_dsim.value_as_int() )
                        {
                                m(1,1) = dR.vmag();
                        }
                        
                        ml_matrix message = message_outgoing_dsim.value_as_matrix();
                        
            if( !message.is_empty() )
                m.stack(message);
                        
                        std::string path = *i;
                        const char *cpath = path.c_str();
                        send_message(cpath,"automobile_network_message",m);
                }
    }
}

void automobile_network :: post_calculate()
{
    dsim_model::post_calculate();
}

dsim_value automobile_network :: handle_message(const std::string &sender_path,const std::string &message_name,const dsim_value &argument)
{
    if (message_name == "automobile_network_message")
    {
                ml_matrix temp  = argument.matrix_value();
        message_incoming.stack(temp);
        message_incoming_dsim.set_value_as_matrix(message_incoming);
                
                return dsim_value();
    }
        
    else return dsim_model::handle_message(sender_path,message_name,argument);
        
}

extern "C"
{
    dsim_model *AutomobileNetwork(void *setup);

        dsim_model *AutomobileNetwork(void *setup)
        {
                return new automobile_network((dsim_model_setup *)setup);
        }
}