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(); }