void TemperatureControl::on_get_public_data(void *argument)
{
    PublicDataRequest *pdr = static_cast<PublicDataRequest *>(argument);

    if(!pdr->starts_with(temperature_control_checksum)) return;

    if(pdr->second_element_is(pool_index_checksum)) {
        // asking for our instance pointer if we have this pool_index
        if(pdr->third_element_is(this->pool_index)) {
            static void *return_data;
            return_data = this;
            pdr->set_data_ptr(&return_data);
            pdr->set_taken();
        }
        return;

    } else if(!pdr->second_element_is(this->name_checksum)) return;

    // ok this is targeted at us, so send back the requested data
    if(pdr->third_element_is(current_temperature_checksum)) {
        this->public_data_return.current_temperature = this->get_temperature();
        this->public_data_return.target_temperature = (target_temperature == UNDEFINED) ? 0 : this->target_temperature;
        this->public_data_return.pwm = this->o;
        this->public_data_return.designator= this->designator;
        pdr->set_data_ptr(&this->public_data_return);
        pdr->set_taken();
    }

}
Exemple #2
0
void Extruder::on_set_public_data(void *argument)
{
    PublicDataRequest *pdr = static_cast<PublicDataRequest *>(argument);

    if(!pdr->starts_with(extruder_checksum)) return;

    // handle extrude rates request from robot
    if(pdr->second_element_is(target_checksum)) {
        // disabled extruders do not reply NOTE only one enabled extruder supported
        if(!this->enabled) return;

        float *d = static_cast<float *>(pdr->get_data_ptr());
        float target = d[0]; // the E passed in on Gcode is in mm³ (maybe absolute or relative)
        float isecs = d[1]; // inverted secs

        // check against maximum speeds and return rate modifier
        d[1] = check_max_speeds(target, isecs);

        pdr->set_taken();
        return;
    }

    // save or restore state
    if(pdr->second_element_is(save_state_checksum)) {
        this->saved_current_position = this->current_position;
        this->saved_absolute_mode = this->absolute_mode;
        pdr->set_taken();
    } else if(pdr->second_element_is(restore_state_checksum)) {
        // NOTE this only gets called when the queue is empty so the milestones will be the same
        this->milestone_last_position= this->current_position = this->saved_current_position;
        this->milestone_absolute_mode= this->absolute_mode = this->saved_absolute_mode;
        pdr->set_taken();
    }
}
Exemple #3
0
void Robot::on_set_public_data(void *argument)
{
    PublicDataRequest *pdr = static_cast<PublicDataRequest *>(argument);

    if(!pdr->starts_with(robot_checksum)) return;

    if(pdr->second_element_is(speed_override_percent_checksum)) {
        // NOTE do not use this while printing!
        float t = *static_cast<float *>(pdr->get_data_ptr());
        // enforce minimum 10% speed
        if (t < 10.0F) t = 10.0F;

        this->seconds_per_minute = t / 0.6F; // t * 60 / 100
        pdr->set_taken();
    } else if(pdr->second_element_is(current_position_checksum)) {
        float *t = static_cast<float *>(pdr->get_data_ptr());
        for (int i = 0; i < 3; i++) {
            this->last_milestone[i] = this->to_millimeters(t[i]);
        }

        float actuator_pos[3];
        arm_solution->cartesian_to_actuator(last_milestone, actuator_pos);
        for (int i = 0; i < 3; i++)
            actuators[i]->change_last_milestone(actuator_pos[i]);

        pdr->set_taken();
    }
}
void ToolManager::on_get_public_data(void* argument)
{
    PublicDataRequest* pdr = static_cast<PublicDataRequest*>(argument);

    if(!pdr->starts_with(tool_manager_checksum)) return;

    if(pdr->second_element_is(is_active_tool_checksum)) {

        // check that we control the given tool
        bool managed = false;
        for(auto t : tools) {
            uint16_t n = t->get_name();
            if(pdr->third_element_is(n)) {
                managed = true;
                break;
            }
        }

        // we are not managing this tool so do not answer
        if(!managed) return;

        pdr->set_data_ptr(&this->current_tool_name);
        pdr->set_taken();

    }else if(pdr->second_element_is(get_active_tool_checksum)) {
        pdr->set_data_ptr(&this->active_tool);
        pdr->set_taken();
    }
}
void TemperatureControl::on_get_public_data(void *argument)
{
    PublicDataRequest *pdr = static_cast<PublicDataRequest *>(argument);

    if(!pdr->starts_with(temperature_control_checksum)) return;

    if(pdr->second_element_is(pool_index_checksum)) {
        // asking for our instance pointer if we have this pool_index
        if(pdr->third_element_is(this->pool_index)) {
            static void *return_data;
            return_data = this;
            pdr->set_data_ptr(&return_data);
            pdr->set_taken();
        }

    }else if(pdr->second_element_is(poll_controls_checksum)) {
        // polling for all temperature controls
        // add our data to the list which is passed in via the data_ptr

        std::vector<struct pad_temperature> *v= static_cast<std::vector<pad_temperature>*>(pdr->get_data_ptr());

        struct pad_temperature t;
        // setup data
        t.current_temperature = this->get_temperature();
        t.target_temperature = (target_temperature <= 0) ? 0 : this->target_temperature;
        t.pwm = this->o;
        t.designator= this->designator;
        t.id= this->name_checksum;
        v->push_back(t);
        pdr->set_taken();

    }else if(pdr->second_element_is(current_temperature_checksum)) {
        // if targeted at us
        if(pdr->third_element_is(this->name_checksum)) {
            // ok this is targeted at us, so set the requ3sted data in the pointer passed into us
            struct pad_temperature *t= static_cast<pad_temperature*>(pdr->get_data_ptr());
            t->current_temperature = this->get_temperature();
            t->target_temperature = (target_temperature <= 0) ? 0 : this->target_temperature;
            t->pwm = this->o;
            t->designator= this->designator;
            t->id= this->name_checksum;
            pdr->set_taken();
        }
    }

}
Exemple #6
0
void Player::on_set_public_data(void* argument) {
    PublicDataRequest* pdr = static_cast<PublicDataRequest*>(argument);

    if(!pdr->starts_with(player_checksum)) return;

    if(pdr->second_element_is(abort_play_checksum)) {
        abort_command("", &(StreamOutput::NullStream));
        pdr->set_taken();
    }
}
void TemperatureControl::on_set_public_data(void* argument){
    PublicDataRequest* pdr = static_cast<PublicDataRequest*>(argument);

    if(!pdr->starts_with(temperature_control_checksum)) return;

    if(!pdr->second_element_is(this->name_checksum)) return; // will be bed or hotend

    // ok this is targeted at us, so set the temp
    float t= *static_cast<float*>(pdr->get_data_ptr());
    this->set_desired_temperature(t);
    pdr->set_taken();
}
Exemple #8
0
void Robot::on_get_public_data(void* argument){
    PublicDataRequest* pdr = static_cast<PublicDataRequest*>(argument);

    if(!pdr->starts_with(robot_checksum)) return;

    if(pdr->second_element_is(speed_override_percent_checksum)) {
        static double return_data;
        return_data= 100*this->seconds_per_minute/60;
        pdr->set_data_ptr(&return_data);
        pdr->set_taken();

    }else if(pdr->second_element_is(current_position_checksum)) {
        static double return_data[3];
        return_data[0]= from_millimeters(this->current_position[0]);
        return_data[1]= from_millimeters(this->current_position[1]);
        return_data[2]= from_millimeters(this->current_position[2]);

        pdr->set_data_ptr(&return_data);
        pdr->set_taken();
    }
}
Exemple #9
0
void Player::on_get_public_data(void* argument) {
    PublicDataRequest* pdr = static_cast<PublicDataRequest*>(argument);

    if(!pdr->starts_with(player_checksum)) return;

    if(pdr->second_element_is(is_playing_checksum)) {
        static bool bool_data;
        bool_data= this->playing_file;
        pdr->set_data_ptr(&bool_data);
        pdr->set_taken();

    }else if(pdr->second_element_is(get_progress_checksum)) {
        static struct pad_progress p;
        if(file_size > 0 && playing_file) {
            p.elapsed_secs= this->elapsed_secs;
            p.percent_complete= (this->file_size - (this->file_size - this->played_cnt)) * 100 / this->file_size;
            p.filename= this->filename;
            pdr->set_data_ptr(&p);
            pdr->set_taken();
        }
    }
}
void TemperatureControl::on_set_public_data(void *argument)
{
    PublicDataRequest *pdr = static_cast<PublicDataRequest *>(argument);

    if(!pdr->starts_with(temperature_control_checksum)) return;

    if(!pdr->second_element_is(this->name_checksum)) return;

    // ok this is targeted at us, so set the temp
    // NOTE unlike the M code this will set the temp now not when the queue is empty
    float t = *static_cast<float *>(pdr->get_data_ptr());
    this->set_desired_temperature(t);
    pdr->set_taken();
}
Exemple #11
0
void Network::on_get_public_data(void* argument) {
    PublicDataRequest* pdr = static_cast<PublicDataRequest*>(argument);

    if(!pdr->starts_with(network_checksum)) return;

    if(pdr->second_element_is(get_ip_checksum)) {
        pdr->set_data_ptr(this->ipaddr);
        pdr->set_taken();

    }else if(pdr->second_element_is(get_ipconfig_checksum)) {
        // NOTE caller must free the returned string when done
        char buf[200];
        int n1= snprintf(buf,             sizeof(buf),         "IP Addr: %d.%d.%d.%d\n", ipaddr[0], ipaddr[1], ipaddr[2], ipaddr[3]);
        int n2= snprintf(&buf[n1],       sizeof(buf)-n1,       "IP GW: %d.%d.%d.%d\n", ipgw[0], ipgw[1], ipgw[2], ipgw[3]);
        int n3= snprintf(&buf[n1+n2],    sizeof(buf)-n1-n2,    "IP mask: %d.%d.%d.%d\n", ipmask[0], ipmask[1], ipmask[2], ipmask[3]);
        int n4= snprintf(&buf[n1+n2+n3], sizeof(buf)-n1-n2-n3, "MAC Address: %02X:%02X:%02X:%02X:%02X:%02X\n",
            mac_address[0], mac_address[1], mac_address[2], mac_address[3], mac_address[4], mac_address[5]);
        char *str = (char *)malloc(n1+n2+n3+n4+1);
        memcpy(str, buf, n1+n2+n3+n4);
        str[n1+n2+n3+n4]= '\0';
        pdr->set_data_ptr(str);
        pdr->set_taken();
    }
}
Exemple #12
0
void Panel::on_set_public_data(void *argument)
{
    PublicDataRequest *pdr = static_cast<PublicDataRequest *>(argument);

    if(!pdr->starts_with(panel_checksum)) return;

    if(!pdr->second_element_is(panel_display_message_checksum)) return;

    string *s = static_cast<string *>(pdr->get_data_ptr());
    if (s->size() > 20) {
        this->message = s->substr(0, 20);
    } else {
        this->message= *s;
    }
}
Exemple #13
0
void Robot::on_set_public_data(void* argument){
    PublicDataRequest* pdr = static_cast<PublicDataRequest*>(argument);

    if(!pdr->starts_with(robot_checksum)) return;

    if(pdr->second_element_is(speed_override_percent_checksum)) {
        // NOTE do not use this while printing!
        double t= *static_cast<double*>(pdr->get_data_ptr());
        // enforce minimum 10% speed
        if (t < 10.0) t= 10.0;

        this->seconds_per_minute= t * 0.6;
        pdr->set_taken();
    }
}
Exemple #14
0
void Switch::on_get_public_data(void *argument)
{
    PublicDataRequest *pdr = static_cast<PublicDataRequest *>(argument);

    if(!pdr->starts_with(switch_checksum)) return;

    if(!pdr->second_element_is(this->name_checksum)) return; // likely fan, but could be anything

    // ok this is targeted at us, so send back the requested data
    // this must be static as it will be accessed long after we have returned
    static struct pad_switch pad;
    pad.name = this->name_checksum;
    pad.state = this->switch_state;
    pad.value = this->switch_value;

    pdr->set_data_ptr(&pad);
    pdr->set_taken();
}
void TemperatureControl::on_get_public_data(void* argument){
    PublicDataRequest* pdr = static_cast<PublicDataRequest*>(argument);

    if(!pdr->starts_with(temperature_control_checksum)) return;

    if(!pdr->second_element_is(this->name_checksum)) return; // will be bed or hotend

    // ok this is targeted at us, so send back the requested data
    if(pdr->third_element_is(current_temperature_checksum)) {
        // this must be static as it will be accessed long after we have returned
        static struct pad_temperature temp_return;
        temp_return.current_temperature= this->get_temperature();
        temp_return.target_temperature= (target_temperature == UNDEFINED) ? 0 : this->target_temperature;
        temp_return.pwm= this->o;

        pdr->set_data_ptr(&temp_return);
        pdr->set_taken();
    }
}
Exemple #16
0
void Switch::on_set_public_data(void *argument)
{
    PublicDataRequest *pdr = static_cast<PublicDataRequest *>(argument);

    if(!pdr->starts_with(switch_checksum)) return;

    if(!pdr->second_element_is(this->name_checksum)) return; // likely fan, but could be anything

    // ok this is targeted at us, so set the value
    if(pdr->third_element_is(state_checksum)) {
        bool t = *static_cast<bool *>(pdr->get_data_ptr());
        this->switch_state = t;
        pdr->set_taken();
        this->switch_changed= true;

    } else if(pdr->third_element_is(value_checksum)) {
        float t = *static_cast<float *>(pdr->get_data_ptr());
        this->switch_value = t;
        pdr->set_taken();
    }
}