void handle_request_temperature_reading_order()
{
if (parameter_length < 2)
{
send_insufficient_bytes_error_response(2);
return;
}
if ((parameter_length & 1) == 1)
{
send_app_error_response(PARAM_APP_ERROR_TYPE_BAD_PARAMETER_FORMAT, 0);
return;
}
generate_response_start(RSP_OK,parameter_length*2);
for (int i = 0; i < parameter_length; i+=2)
{
const uint8_t device_type = parameter_value[i];
const uint8_t device_number = parameter_value[i+1];
float ftemp;
int16_t temp;
switch(device_type)
{
case PM_DEVICE_TYPE_HEATER:
{
if (!Device_Heater::IsInUse(device_number))
{
send_app_error_at_offset_response(PARAM_APP_ERROR_TYPE_INVALID_DEVICE_NUMBER, i+1);
return;
}
ftemp = Device_Heater::ReadCurrentTemperature(device_number);
break;
}
case PM_DEVICE_TYPE_TEMP_SENSOR:
{
if (!Device_TemperatureSensor::IsInUse(device_number))
{
send_app_error_at_offset_response(PARAM_APP_ERROR_TYPE_INVALID_DEVICE_NUMBER, i+1);
return;
}
ftemp = Device_TemperatureSensor::ReadCurrentTemperature(device_number);
break;
}
default:
send_app_error_at_offset_response(PARAM_APP_ERROR_TYPE_INVALID_DEVICE_TYPE, i);
return;
}
if (ftemp != SENSOR_TEMPERATURE_INVALID)
temp = ftemp * 10.0;
else
temp = PM_TEMPERATURE_INVALID;
generate_response_data_addbyte(highByte(temp));
generate_response_data_addbyte(lowByte(temp));
}
generate_response_send();
}
void handle_firmware_configuration_value_properties(const char *name)
{
ConfigurationTree tree;
if (name[0] == '\0')
{
send_app_error_response(PARAM_APP_ERROR_TYPE_BAD_PARAMETER_FORMAT,
PMSG(ERR_MSG_CONFIG_NODE_NOT_FOUND));
return;
}
ConfigurationTreeNode *node = tree.FindNode(name);
if (node == 0)
{
send_app_error_response(PARAM_APP_ERROR_TYPE_BAD_PARAMETER_VALUE,
PMSG(ERR_MSG_CONFIG_NODE_NOT_FOUND), name);
return;
}
if (!node->IsLeafNode())
{
send_app_error_response(PARAM_APP_ERROR_TYPE_BAD_PARAMETER_VALUE,
PMSG(ERR_MSG_CONFIG_NODE_NOT_COMPLETE), name);
return;
}
generate_response_start(RSP_OK, 2);
generate_response_data_addbyte(node->GetLeafClass());
generate_response_data_addbyte(node->GetLeafOperations());
// determine default value status here where necessary.
// determine whether configuration node is associated with a device
// (we search for a parent instance node where the device type has been set)
uint8_t device_type = PM_DEVICE_TYPE_INVALID;
uint8_t device_number = 0;
while ((node = tree.GetParentNode(node)) != 0)
{
if (node->IsInstanceNode()
&& node->GetLeafSetDataType() != PM_DEVICE_TYPE_INVALID)
{
device_type = node->GetLeafSetDataType();
device_number = node->GetInstanceId();
}
}
generate_response_data_addbyte(device_type);
generate_response_data_addbyte(device_number);
generate_response_send();
}
void send_enqueue_error(uint8_t error_type, uint8_t block_index, uint8_t error_code)
{
uint16_t remaining_slots;
uint16_t current_command_count;
uint16_t total_command_count;
CommandQueue::GetQueueInfo(remaining_slots, current_command_count, total_command_count);
generate_response_data_addbyte(error_type);
generate_response_data_addbyte(block_index);
generate_response_data_add(remaining_slots);
generate_response_data_add(current_command_count);
generate_response_data_add(total_command_count);
generate_response_data_addbyte(error_code);
generate_response_send();
}
bool set_float_value(uint8_t node_type, uint8_t parent_instance_id, uint8_t instance_id, float value)
{
uint8_t retval;
switch (node_type)
{
case NODE_TYPE_CONFIG_LEAF_HEATER_PID_KP:
retval = Device_Heater::SetPidDefaultKp(parent_instance_id, value);
break;
case NODE_TYPE_CONFIG_LEAF_HEATER_PID_KI:
retval = Device_Heater::SetPidDefaultKi(parent_instance_id, value);
break;
case NODE_TYPE_CONFIG_LEAF_HEATER_PID_KD:
retval = Device_Heater::SetPidDefaultKd(parent_instance_id, value);
break;
default:
send_app_error_response(PARAM_APP_ERROR_TYPE_FIRMWARE_ERROR,
PMSG(MSG_ERR_CANNOT_HANDLE_FIRMWARE_CONFIG_REQUEST), __LINE__);
return false;
}
if (retval == APP_ERROR_TYPE_SUCCESS)
return true;
generate_response_data_addbyte(retval);
generate_response_send();
return false;
}
bool set_int16_value(uint8_t node_type, uint8_t parent_instance_id, uint8_t instance_id, int16_t value)
{
uint8_t retval;
switch (node_type)
{
case NODE_TYPE_CONFIG_LEAF_HEATER_MAX_TEMP:
retval = Device_Heater::SetMaxTemperature(parent_instance_id, value);
break;
case NODE_TYPE_CONFIG_LEAF_TEMP_SENSOR_TYPE:
retval = Device_TemperatureSensor::SetType(parent_instance_id, value);
break;
default:
send_app_error_response(PARAM_APP_ERROR_TYPE_FIRMWARE_ERROR,
PMSG(MSG_ERR_CANNOT_HANDLE_FIRMWARE_CONFIG_REQUEST), __LINE__);
return false;
}
if (retval == APP_ERROR_TYPE_SUCCESS)
return true;
generate_response_data_addbyte(retval);
generate_response_send();
return false;
}
void handle_set_heater_target_temperature_order()
{
if (parameter_length < 3)
{
send_insufficient_bytes_error_response(3);
return;
}
const uint8_t heater_number = parameter_value[0];
const int16_t temp = (parameter_value[1] << 8) | parameter_value[2];
const float ftemp = (float)temp / 10;
generate_response_start(RSP_APPLICATION_ERROR, 1);
uint8_t retval = Device_Heater::ValidateTargetTemperature(heater_number, ftemp);
if (retval != APP_ERROR_TYPE_SUCCESS)
{
generate_response_data_addbyte(retval);
generate_response_send();
return;
}
if (is_stopped && ftemp != SENSOR_TEMPERATURE_INVALID)
{
send_app_error_response(PARAM_APP_ERROR_TYPE_DEVICE_UNAVAILABLE,
PMSG(MSG_ERR_CANNOT_ACTIVATE_DEVICE_WHEN_STOPPED));
return;
}
Device_Heater::SetTargetTemperature(heater_number, ftemp);
send_OK_response();
}
bool set_bool_value(uint8_t node_type, uint8_t parent_instance_id, uint8_t instance_id, bool value)
{
uint8_t retval;
switch (node_type)
{
case NODE_TYPE_CONFIG_LEAF_INPUT_SWITCH_TRIGGER_LEVEL:
retval = Device_InputSwitch::SetTriggerLevel(parent_instance_id, value);
break;
case NODE_TYPE_CONFIG_LEAF_INPUT_SWITCH_ENABLE_PULLUP:
retval = Device_InputSwitch::SetEnablePullup(parent_instance_id, value);
break;
case NODE_TYPE_CONFIG_LEAF_PWM_OUTPUT_USE_SOFT_PWM:
retval = Device_PwmOutput::EnableSoftPwm(parent_instance_id, value);
break;
case NODE_TYPE_CONFIG_LEAF_HEATER_USE_SOFT_PWM:
retval = Device_Heater::EnableSoftPwm(parent_instance_id, value);
break;
case NODE_TYPE_CONFIG_LEAF_HEATER_USE_BANG_BANG:
if (value)
retval = Device_Heater::SetControlMode(parent_instance_id, HEATER_CONTROL_MODE_BANG_BANG);
else
retval = APP_ERROR_TYPE_SUCCESS;
break;
case NODE_TYPE_CONFIG_LEAF_HEATER_USE_PID:
if (value)
retval = Device_Heater::SetControlMode(parent_instance_id, HEATER_CONTROL_MODE_PID);
else
retval = APP_ERROR_TYPE_SUCCESS;
break;
case NODE_TYPE_CONFIG_LEAF_STEPPER_ENABLE_INVERT:
retval = Device_Stepper::SetEnableInvert(parent_instance_id, value);
break;
case NODE_TYPE_CONFIG_LEAF_STEPPER_DIRECTION_INVERT:
retval = Device_Stepper::SetDirectionInvert(parent_instance_id, value);
break;
case NODE_TYPE_CONFIG_LEAF_STEPPER_STEP_INVERT:
retval = Device_Stepper::SetStepInvert(parent_instance_id, value);
break;
default:
send_app_error_response(PARAM_APP_ERROR_TYPE_FIRMWARE_ERROR,
PMSG(MSG_ERR_CANNOT_HANDLE_FIRMWARE_CONFIG_REQUEST), __LINE__);
return false;
}
if (retval == APP_ERROR_TYPE_SUCCESS)
return true;
generate_response_data_addbyte(retval);
generate_response_send();
return false;
}
bool setPin(uint8_t node_type, uint8_t device_number, uint8_t pin)
{
uint8_t retval = false;
switch (node_type)
{
case NODE_TYPE_CONFIG_LEAF_INPUT_SWITCH_PIN:
retval = Device_InputSwitch::SetPin(device_number, pin);
break;
case NODE_TYPE_CONFIG_LEAF_OUTPUT_SWITCH_PIN:
retval = Device_OutputSwitch::SetPin(device_number, pin);
break;
case NODE_TYPE_CONFIG_LEAF_PWM_OUTPUT_PIN:
retval = Device_PwmOutput::SetPin(device_number, pin);
break;
case NODE_TYPE_CONFIG_LEAF_BUZZER_PIN:
retval = Device_Buzzer::SetPin(device_number, pin);
break;
case NODE_TYPE_CONFIG_LEAF_TEMP_SENSOR_PIN:
retval = Device_TemperatureSensor::SetPin(device_number, pin);
break;
case NODE_TYPE_CONFIG_LEAF_HEATER_PIN:
retval = Device_Heater::SetHeaterPin(device_number, pin);
break;
case NODE_TYPE_CONFIG_LEAF_STEPPER_ENABLE_PIN:
retval = Device_Stepper::SetEnablePin(device_number, pin);
break;
case NODE_TYPE_CONFIG_LEAF_STEPPER_DIRECTION_PIN:
retval = Device_Stepper::SetDirectionPin(device_number, pin);
break;
case NODE_TYPE_CONFIG_LEAF_STEPPER_STEP_PIN:
retval = Device_Stepper::SetStepPin(device_number, pin);
break;
default:
send_app_error_response(PARAM_APP_ERROR_TYPE_FIRMWARE_ERROR,
PMSG(MSG_ERR_CANNOT_HANDLE_FIRMWARE_CONFIG_REQUEST), __LINE__);
return false;
}
if (retval == APP_ERROR_TYPE_SUCCESS)
return true;
generate_response_data_addbyte(retval);
generate_response_msg_addPGM(PMSG(ERR_MSG_INVALID_PIN_NUMBER));
generate_response_send();
return false;
}
void handle_get_heater_configuration_order()
{
if (parameter_length < 1)
{
send_insufficient_bytes_error_response(1);
return;
}
const uint8_t heater_number = parameter_value[0];
if (Device_Heater::GetHeaterPin(heater_number) == 0xFF)
{
send_app_error_response(PARAM_APP_ERROR_TYPE_INVALID_DEVICE_NUMBER,0);
return;
}
generate_response_start(RSP_OK);
generate_response_data_addbyte(PARAM_HEATER_CONFIG_HOST_SENSOR_CONFIG);
generate_response_data_addbyte(Device_Heater::GetTempSensor(heater_number));
generate_response_send();
}
void handle_get_input_switch_state_order()
{
uint8_t device_type, device_number;
if (parameter_length < 2)
{
send_insufficient_bytes_error_response(2);
return;
}
if ((parameter_length & 1) == 1)
{
send_app_error_response(PARAM_APP_ERROR_TYPE_BAD_PARAMETER_FORMAT, 0);
return;
}
generate_response_start(RSP_OK,parameter_length/2);
for (int i = 0; i < parameter_length; i+=2)
{
device_type = parameter_value[i];
device_number = parameter_value[i+1];
switch(device_type)
{
case PM_DEVICE_TYPE_SWITCH_INPUT:
{
if (!Device_InputSwitch::IsInUse(device_number))
{
send_app_error_at_offset_response(PARAM_APP_ERROR_TYPE_INVALID_DEVICE_NUMBER, i+1);
return;
}
generate_response_data_addbyte(Device_InputSwitch::ReadState(device_number));
break;
}
default:
send_app_error_at_offset_response(PARAM_APP_ERROR_TYPE_INVALID_DEVICE_TYPE, i);
return;
}
}
generate_response_send();
}
void handle_device_count_order()
{
if (parameter_length < 1)
{
send_insufficient_bytes_error_response(1);
return;
}
const uint8_t device_type = parameter_value[0];
uint8_t num_devices = get_num_devices(device_type);
if (num_devices < 0)
{
send_app_error_response(PARAM_APP_ERROR_TYPE_INVALID_DEVICE_TYPE,0);
return;
}
generate_response_start(RSP_OK,1);
generate_response_data_addbyte(num_devices);
generate_response_send();
}
void handle_configure_heater_order()
{
if (parameter_length < 2)
{
send_insufficient_bytes_error_response(2);
return;
}
const uint8_t heater_number = parameter_value[0];
const uint8_t temp_sensor = parameter_value[1];
const uint8_t current_temp_sensor = Device_Heater::GetTempSensor(heater_number);
if (current_temp_sensor != 0xFF)
{
if (current_temp_sensor != temp_sensor)
{
// Don't allow Pacemaker order to override internal configuration
send_app_error_response(PARAM_APP_ERROR_TYPE_FAILED,
PMSG(MSG_ERR_ALREADY_INITIALIZED));
}
else
{
send_OK_response();
}
return;
}
generate_response_start(RSP_APPLICATION_ERROR, 1);
uint8_t retval = Device_Heater::SetTempSensor(heater_number, temp_sensor);
if (retval != APP_ERROR_TYPE_SUCCESS)
{
generate_response_data_addbyte(retval);
generate_response_send();
}
else
{
send_OK_response();
}
}
bool set_string_value(uint8_t node_type, uint8_t parent_instance_id, uint8_t instance_id, const char *value)
{
uint8_t retval;
generate_response_start(RSP_APPLICATION_ERROR, 1);
switch (node_type)
{
case NODE_TYPE_CONFIG_LEAF_INPUT_SWITCH_FRIENDLY_NAME:
retval = NVConfigStore::SetDeviceName(PM_DEVICE_TYPE_SWITCH_INPUT, parent_instance_id, value);
break;
case NODE_TYPE_CONFIG_LEAF_OUTPUT_SWITCH_FRIENDLY_NAME:
retval = NVConfigStore::SetDeviceName(PM_DEVICE_TYPE_SWITCH_OUTPUT, parent_instance_id, value);
break;
case NODE_TYPE_CONFIG_LEAF_PWM_OUTPUT_FRIENDLY_NAME:
retval = NVConfigStore::SetDeviceName(PM_DEVICE_TYPE_PWM_OUTPUT, parent_instance_id, value);
break;
case NODE_TYPE_CONFIG_LEAF_BUZZER_FRIENDLY_NAME:
retval = NVConfigStore::SetDeviceName(PM_DEVICE_TYPE_BUZZER, parent_instance_id, value);
break;
case NODE_TYPE_CONFIG_LEAF_TEMP_SENSOR_FRIENDLY_NAME:
retval = NVConfigStore::SetDeviceName(PM_DEVICE_TYPE_TEMP_SENSOR, parent_instance_id, value);
break;
case NODE_TYPE_CONFIG_LEAF_HEATER_FRIENDLY_NAME:
retval = NVConfigStore::SetDeviceName(PM_DEVICE_TYPE_HEATER, parent_instance_id, value);
break;
case NODE_TYPE_CONFIG_LEAF_STEPPER_FRIENDLY_NAME:
retval = NVConfigStore::SetDeviceName(PM_DEVICE_TYPE_STEPPER, parent_instance_id, value);
break;
case NODE_TYPE_CONFIG_LEAF_OUTPUT_SWITCH_INITIAL_STATE:
{
uint8_t pin_state;
if (!parse_initial_pin_state_value(value, &pin_state))
{
generate_response_data_addbyte(PARAM_APP_ERROR_TYPE_BAD_PARAMETER_VALUE);
generate_response_msg_addPGM(PMSG(MSG_ERR_UNKNOWN_VALUE));
generate_response_send();
return false;
}
retval = Device_OutputSwitch::SetInitialState(parent_instance_id, pin_state);
break;
}
case NODE_TYPE_CONFIG_LEAF_SYSTEM_HARDWARE_NAME:
retval = NVConfigStore::SetHardwareName(value);
break;
case NODE_TYPE_CONFIG_LEAF_SYSTEM_BOARD_IDENTITY:
retval = NVConfigStore::SetBoardIdentity(value);
break;
case NODE_TYPE_CONFIG_LEAF_SYSTEM_BOARD_SERIAL_NUM:
retval = NVConfigStore::SetBoardSerialNumber(value);
break;
case NODE_TYPE_CONFIG_LEAF_HEATER_PID_DO_AUTOTUNE:
{
char *end;
long temp, cycles;
if ((temp = strtol(value, &end, 10)) == 0 || *end != ',' ||
(cycles = strtol(end+1, &end, 10)) == 0 || *end != '\0')
{
generate_response_data_addbyte(PARAM_APP_ERROR_TYPE_BAD_PARAMETER_FORMAT);
generate_response_msg_addPGM(PMSG(MSG_EXPECTING));
generate_response_msg_addPGM(PMSG(ERR_MSG_BAD_PID_AUTOTUNE_FORMAT));
generate_response_send();
return false;
}
if (!Device_Heater::IsInUse(parent_instance_id)
|| !Device_TemperatureSensor::IsInUse(Device_Heater::GetTempSensor(parent_instance_id)))
{
send_app_error_response(PARAM_APP_ERROR_TYPE_INVALID_DEVICE_NUMBER,
PMSG(ERR_MSG_DEVICE_NOT_IN_USE));
return false;
}
send_OK_response(); // send response now as it takes a while to complete
Device_Heater::DoPidAutotune(parent_instance_id, temp, cycles);
return false;
}
case NODE_TYPE_OPERATION_LEAF_RESET_EEPROM:
NVConfigStore::WriteDefaults(true);
retval = APP_ERROR_TYPE_SUCCESS;
break;
default:
send_app_error_response(PARAM_APP_ERROR_TYPE_FIRMWARE_ERROR,
PMSG(MSG_ERR_CANNOT_HANDLE_FIRMWARE_CONFIG_REQUEST), __LINE__);
return false;
}
if (retval == APP_ERROR_TYPE_SUCCESS)
return true;
generate_response_data_addbyte(retval);
generate_response_send();
return false;
}
bool set_uint8_value(uint8_t node_type, uint8_t parent_instance_id, uint8_t instance_id, uint8_t value)
{
uint8_t retval;
switch (node_type)
{
case NODE_TYPE_CONFIG_LEAF_INPUT_SWITCH_PIN:
case NODE_TYPE_CONFIG_LEAF_OUTPUT_SWITCH_PIN:
case NODE_TYPE_CONFIG_LEAF_PWM_OUTPUT_PIN:
case NODE_TYPE_CONFIG_LEAF_BUZZER_PIN:
case NODE_TYPE_CONFIG_LEAF_TEMP_SENSOR_PIN:
case NODE_TYPE_CONFIG_LEAF_HEATER_PIN:
case NODE_TYPE_CONFIG_LEAF_STEPPER_ENABLE_PIN:
case NODE_TYPE_CONFIG_LEAF_STEPPER_DIRECTION_PIN:
case NODE_TYPE_CONFIG_LEAF_STEPPER_STEP_PIN:
return setPin(node_type, parent_instance_id, value);
case NODE_TYPE_CONFIG_LEAF_SYSTEM_HARDWARE_TYPE:
retval = NVConfigStore::SetHardwareType(value);
break;
case NODE_TYPE_CONFIG_LEAF_SYSTEM_HARDWARE_REV:
retval = NVConfigStore::SetHardwareRevision(value);
break;
case NODE_TYPE_CONFIG_LEAF_SYSTEM_NUM_INPUT_SWITCHES:
retval = Device_InputSwitch::Init(value);
break;
case NODE_TYPE_CONFIG_LEAF_SYSTEM_NUM_OUTPUT_SWITCHES:
retval = Device_OutputSwitch::Init(value);
break;
case NODE_TYPE_CONFIG_LEAF_SYSTEM_NUM_PWM_OUTPUTS:
retval = Device_PwmOutput::Init(value);
break;
case NODE_TYPE_CONFIG_LEAF_SYSTEM_NUM_BUZZERS:
retval = Device_Buzzer::Init(value);
break;
case NODE_TYPE_CONFIG_LEAF_SYSTEM_NUM_TEMP_SENSORS:
retval = Device_TemperatureSensor::Init(value);
break;
case NODE_TYPE_CONFIG_LEAF_SYSTEM_NUM_HEATERS:
retval = Device_Heater::Init(value);
break;
case NODE_TYPE_CONFIG_LEAF_SYSTEM_NUM_STEPPERS:
retval = Device_Stepper::Init(value);
break;
case NODE_TYPE_CONFIG_LEAF_OUTPUT_SWITCH_INITIAL_STATE:
retval = Device_OutputSwitch::SetInitialState(parent_instance_id, value);
break;
case NODE_TYPE_CONFIG_LEAF_HEATER_TEMP_SENSOR:
retval = Device_Heater::SetTempSensor(parent_instance_id, value);
break;
case NODE_TYPE_CONFIG_LEAF_HEATER_POWER_ON_LEVEL:
retval = Device_Heater::SetPowerOnLevel(parent_instance_id, value);
break;
case NODE_TYPE_CONFIG_LEAF_HEATER_BANG_BANG_HYSTERESIS:
retval = Device_Heater::SetBangBangHysteresis(parent_instance_id, value);
break;
case NODE_TYPE_CONFIG_LEAF_HEATER_PID_FUNCTIONAL_RANGE:
retval = Device_Heater::SetPidFunctionalRange(parent_instance_id, value);
break;
default:
send_app_error_response(PARAM_APP_ERROR_TYPE_FIRMWARE_ERROR,
PMSG(MSG_ERR_CANNOT_HANDLE_FIRMWARE_CONFIG_REQUEST), __LINE__);
return false;
}
if (retval == APP_ERROR_TYPE_SUCCESS)
return true;
generate_response_data_addbyte(retval);
generate_response_send();
return false;
}
void handle_device_status_order()
{
if (parameter_length < 2)
{
send_insufficient_bytes_error_response(2);
return;
}
const uint8_t device_type = parameter_value[0];
const uint8_t device_number = parameter_value[1];
uint8_t num_devices = get_num_devices(device_type);
if (device_number >= num_devices)
{
if (num_devices < 0)
send_app_error_response(PARAM_APP_ERROR_TYPE_INVALID_DEVICE_TYPE,0);
else
send_app_error_response(PARAM_APP_ERROR_TYPE_INVALID_DEVICE_NUMBER,0);
return;
}
generate_response_start(RSP_OK, 1);
switch(device_type)
{
case PM_DEVICE_TYPE_SWITCH_INPUT:
if (!Device_InputSwitch::IsInUse(device_number))
generate_response_data_addbyte(DEVICE_STATUS_CONFIG_ERROR);
else
generate_response_data_addbyte(DEVICE_STATUS_ACTIVE);
break;
case PM_DEVICE_TYPE_SWITCH_OUTPUT:
if (!Device_OutputSwitch::IsInUse(device_number))
generate_response_data_addbyte(DEVICE_STATUS_CONFIG_ERROR);
else if (!Device_OutputSwitch::GetEnableState(device_number))
generate_response_data_addbyte(DEVICE_STATUS_DISABLED);
// TODO handle inactive state
else
generate_response_data_addbyte(DEVICE_STATUS_ACTIVE);
break;
case PM_DEVICE_TYPE_PWM_OUTPUT:
if (!Device_PwmOutput::IsInUse(device_number))
generate_response_data_addbyte(DEVICE_STATUS_CONFIG_ERROR);
else if (!Device_PwmOutput::GetActiveState(device_number))
generate_response_data_addbyte(DEVICE_STATUS_INACTIVE);
else
generate_response_data_addbyte(DEVICE_STATUS_ACTIVE);
break;
case PM_DEVICE_TYPE_STEPPER:
if (!AxisInfo::IsInUse(device_number))
generate_response_data_addbyte(DEVICE_STATUS_CONFIG_ERROR);
else if (is_stopped)
generate_response_data_addbyte(DEVICE_STATUS_STOPPED);
else if (!AxisInfo::GetStepperEnableState(device_number))
generate_response_data_addbyte(DEVICE_STATUS_INACTIVE);
else
generate_response_data_addbyte(DEVICE_STATUS_ACTIVE);
break;
case PM_DEVICE_TYPE_HEATER:
if (!Device_Heater::ValidateTargetTemperature(device_number, 0))
generate_response_data_addbyte(DEVICE_STATUS_CONFIG_ERROR);
else if (is_stopped)
generate_response_data_addbyte(DEVICE_STATUS_STOPPED);
else if (Device_Heater::GetTargetTemperature(device_number) == 0)
generate_response_data_addbyte(DEVICE_STATUS_INACTIVE);
else
generate_response_data_addbyte(DEVICE_STATUS_ACTIVE);
break;
case PM_DEVICE_TYPE_TEMP_SENSOR:
if (!Device_TemperatureSensor::IsInUse(device_number))
generate_response_data_addbyte(DEVICE_STATUS_CONFIG_ERROR);
else
generate_response_data_addbyte(DEVICE_STATUS_ACTIVE);
break;
case PM_DEVICE_TYPE_BUZZER:
if (!Device_Buzzer::IsInUse(device_number))
generate_response_data_addbyte(DEVICE_STATUS_CONFIG_ERROR);
else if (Device_Buzzer::GetActiveState(device_number) == 0)
generate_response_data_addbyte(DEVICE_STATUS_INACTIVE);
else
generate_response_data_addbyte(DEVICE_STATUS_ACTIVE);
break;
default:
send_app_error_response(PARAM_APP_ERROR_TYPE_INVALID_DEVICE_TYPE,0);
return;
}
generate_response_send();
}
void generate_value(uint8_t node_type, uint8_t parent_instance_id, uint8_t instance_id)
{
generate_response_start(RSP_OK);
char *response_data_buf = (char *)generate_response_data_ptr();
uint8_t response_data_buf_len = generate_response_data_len();
int8_t length;
uint8_t value;
switch(node_type)
{
case NODE_TYPE_CONFIG_LEAF_INPUT_SWITCH_FRIENDLY_NAME:
if ((length = NVConfigStore::GetDeviceName(PM_DEVICE_TYPE_SWITCH_INPUT, parent_instance_id, response_data_buf, response_data_buf_len)) > 0)
generate_response_data_addlen(length);
break;
case NODE_TYPE_CONFIG_LEAF_INPUT_SWITCH_PIN:
utoa(Device_InputSwitch::GetPin(parent_instance_id), response_data_buf, 10);
generate_response_data_addlen(strlen(response_data_buf));
break;
case NODE_TYPE_CONFIG_LEAF_INPUT_SWITCH_TRIGGER_LEVEL:
generate_response_data_addbyte(Device_InputSwitch::GetTriggerLevel(parent_instance_id) ? '1' : '0');
break;
case NODE_TYPE_CONFIG_LEAF_INPUT_SWITCH_ENABLE_PULLUP:
generate_response_data_addbyte(Device_InputSwitch::GetEnablePullup(parent_instance_id) ? '1' : '0');
break;
case NODE_TYPE_CONFIG_LEAF_OUTPUT_SWITCH_FRIENDLY_NAME:
if ((length = NVConfigStore::GetDeviceName(PM_DEVICE_TYPE_SWITCH_OUTPUT, instance_id, response_data_buf, response_data_buf_len)) > 0)
generate_response_data_addlen(length);
break;
case NODE_TYPE_CONFIG_LEAF_OUTPUT_SWITCH_PIN:
utoa(Device_OutputSwitch::GetPin(parent_instance_id), response_data_buf, 10);
generate_response_data_addlen(strlen(response_data_buf));
break;
case NODE_TYPE_CONFIG_LEAF_OUTPUT_SWITCH_INITIAL_STATE:
value = Device_OutputSwitch::GetInitialState(instance_id);
strncpy_P(response_data_buf, stringify_initial_pin_state_value(value), response_data_buf_len);
generate_response_data_addlen(strlen(response_data_buf));
break;
case NODE_TYPE_CONFIG_LEAF_PWM_OUTPUT_FRIENDLY_NAME:
if ((length = NVConfigStore::GetDeviceName(PM_DEVICE_TYPE_PWM_OUTPUT, instance_id, response_data_buf, response_data_buf_len)) > 0)
generate_response_data_addlen(length);
break;
case NODE_TYPE_CONFIG_LEAF_PWM_OUTPUT_PIN:
utoa(Device_PwmOutput::GetPin(parent_instance_id), response_data_buf, 10);
generate_response_data_addlen(strlen(response_data_buf));
break;
case NODE_TYPE_CONFIG_LEAF_PWM_OUTPUT_USE_SOFT_PWM:
generate_response_data_addbyte(Device_PwmOutput::GetSoftPwmState(parent_instance_id) ? '1' : '0');
break;
case NODE_TYPE_CONFIG_LEAF_BUZZER_FRIENDLY_NAME:
if ((length = NVConfigStore::GetDeviceName(PM_DEVICE_TYPE_BUZZER, instance_id, response_data_buf, response_data_buf_len)) > 0)
generate_response_data_addlen(length);
break;
case NODE_TYPE_CONFIG_LEAF_BUZZER_PIN:
utoa(Device_Buzzer::GetPin(parent_instance_id), response_data_buf, 10);
generate_response_data_addlen(strlen(response_data_buf));
break;
case NODE_TYPE_CONFIG_LEAF_HEATER_FRIENDLY_NAME:
if ((length = NVConfigStore::GetDeviceName(PM_DEVICE_TYPE_HEATER, instance_id, response_data_buf, response_data_buf_len)) > 0)
generate_response_data_addlen(length);
break;
case NODE_TYPE_CONFIG_LEAF_HEATER_PIN:
utoa(Device_Heater::GetHeaterPin(parent_instance_id), response_data_buf, 10);
generate_response_data_addlen(strlen(response_data_buf));
break;
case NODE_TYPE_CONFIG_LEAF_HEATER_USE_SOFT_PWM:
generate_response_data_addbyte(Device_Heater::GetSoftPwmState(parent_instance_id) ? '1' : '0');
break;
case NODE_TYPE_CONFIG_LEAF_HEATER_USE_BANG_BANG:
generate_response_data_addbyte(
(Device_Heater::GetControlMode(parent_instance_id) == HEATER_CONTROL_MODE_BANG_BANG) ? '1' : '0');
break;
case NODE_TYPE_CONFIG_LEAF_HEATER_USE_PID:
generate_response_data_addbyte(
(Device_Heater::GetControlMode(parent_instance_id) == HEATER_CONTROL_MODE_PID) ? '1' : '0');
break;
case NODE_TYPE_CONFIG_LEAF_HEATER_BANG_BANG_HYSTERESIS:
if (Device_Heater::GetControlMode(parent_instance_id) == HEATER_CONTROL_MODE_BANG_BANG)
generate_response_data_addbyte(Device_Heater::GetBangBangHysteresis(parent_instance_id));
break;
case NODE_TYPE_CONFIG_LEAF_HEATER_PID_FUNCTIONAL_RANGE:
if (Device_Heater::GetControlMode(parent_instance_id) == HEATER_CONTROL_MODE_PID)
generate_response_data_addbyte(Device_Heater::GetPidFunctionalRange(parent_instance_id));
break;
// TODO add other heater config
// Statistics Related
case NODE_TYPE_STATS_LEAF_RX_PACKET_COUNT:
{
extern uint32_t recv_count;
ultoa(recv_count, response_data_buf, 10);
generate_response_data_addlen(strlen(response_data_buf));
break;
}
case NODE_TYPE_STATS_LEAF_RX_ERROR_COUNT:
{
extern uint16_t recv_errors;
utoa(recv_errors, response_data_buf, 10);
generate_response_data_addlen(strlen(response_data_buf));
break;
}
case NODE_TYPE_STATS_LEAF_QUEUE_MEMORY:
{
utoa(CommandQueue::GetQueueBufferLength(), response_data_buf, 10);
generate_response_data_addlen(strlen(response_data_buf));
break;
}
case NODE_TYPE_DEBUG_LEAF_STACK_MEMORY:
{
extern uint8_t *startOfStack();
uint8_t you_are_here;;
ultoa((unsigned long)&you_are_here - (unsigned long)startOfStack(), response_data_buf, 10);
generate_response_data_addlen(strlen(response_data_buf));
break;
}
case NODE_TYPE_DEBUG_LEAF_STACK_LOW_WATER_MARK:
{
extern uint16_t countStackLowWatermark();
utoa(countStackLowWatermark(), response_data_buf, 10);
generate_response_data_addlen(strlen(response_data_buf));
break;
}
default:
send_app_error_response(PARAM_APP_ERROR_TYPE_FIRMWARE_ERROR,
PMSG(MSG_ERR_CANNOT_HANDLE_FIRMWARE_CONFIG_REQUEST), __LINE__);
return;
}
generate_response_send();
}
void handle_request_information_order()
{
if (parameter_length < 1)
{
send_insufficient_bytes_error_response(1);
return;
}
const uint8_t request_type = parameter_value[0];
generate_response_start(RSP_OK);
char *response_data_buf = (char *)generate_response_data_ptr();
uint8_t response_data_buf_len = generate_response_data_len();
int8_t length;
uint8_t value;
switch(request_type)
{
case PARAM_REQUEST_INFO_FIRMWARE_NAME:
generate_response_data_addPGM(PSTR(MINNOW_FIRMWARE_NAME));
break;
case PARAM_REQUEST_INFO_BOARD_SERIAL_NUMBER:
if ((length = NVConfigStore::GetBoardSerialNumber(response_data_buf, response_data_buf_len)) > 0)
generate_response_data_addlen(length);
break;
case PARAM_REQUEST_INFO_BOARD_NAME:
if ((length = NVConfigStore::GetHardwareName(response_data_buf, response_data_buf_len)) > 0)
generate_response_data_addlen(length);
break;
case PARAM_REQUEST_INFO_GIVEN_NAME:
if ((length = NVConfigStore::GetBoardIdentity(response_data_buf, response_data_buf_len)) > 0)
generate_response_data_addlen(length);
break;
case PARAM_REQUEST_INFO_PROTO_VERSION_MAJOR:
generate_response_data_addbyte(PM_PROTCOL_VERSION_MAJOR);
break;
case PARAM_REQUEST_INFO_PROTO_VERSION_MINOR:
generate_response_data_addbyte(PM_PROTCOL_VERSION_MINOR);
break;
case PARAM_REQUEST_INFO_SUPPORTED_EXTENSIONS:
generate_response_data_addbyte(PM_EXTENSION_STEPPER_CONTROL);
generate_response_data_addbyte(PM_EXTENSION_QUEUED_CMD);
generate_response_data_addbyte(PM_EXTENSION_BASIC_MOVE);
break;
case PARAM_REQUEST_INFO_FIRMWARE_TYPE:
generate_response_data_addbyte(PM_FIRMWARE_TYPE_MINNOW);
break;
case PARAM_REQUEST_INFO_FIRMWARE_VERSION_MAJOR:
generate_response_data_addbyte(MINNOW_FIRMWARE_VERSION_MAJOR);
break;
case PARAM_REQUEST_INFO_FIRMWARE_VERSION_MINOR:
generate_response_data_addbyte(MINNOW_FIRMWARE_VERSION_MINOR);
break;
case PARAM_REQUEST_INFO_HARDWARE_TYPE:
generate_response_data_addbyte(NVConfigStore::GetHardwareType());
break;
case PARAM_REQUEST_INFO_HARDWARE_REVISION:
if ((value = NVConfigStore::GetHardwareRevision()) != 0xFF)
generate_response_data_addbyte(value);
break;
case PARAM_REQUEST_INFO_MAXIMUM_STEP_RATE:
generate_response_data_add(MAX_STEP_FREQUENCY);
break;
case PARAM_REQUEST_INFO_HOST_TIMEOUT:
generate_response_data_addbyte(HOST_TIMEOUT_SECS);
break;
default:
send_app_error_response(PARAM_APP_ERROR_TYPE_BAD_PARAMETER_VALUE,0);
return;
}
generate_response_send();
}
