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_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(); } }
// // Top level enqueue command handler // void enqueue_command() { uint8_t *ptr = parameter_value; uint8_t index = 0; if (CommandQueue::GetQueueBufferLength() == 0) { if (!allocate_command_queue_memory()) { send_app_error_response(PARAM_APP_ERROR_TYPE_FIRMWARE_ERROR, PMSG(MSG_ERR_INSUFFICIENT_MEMORY)); return; } } generate_response_start(RSP_ORDER_SPECIFIC_ERROR, QUEUE_ERROR_MSG_OFFSET); while (ptr < parameter_value + parameter_length) { const uint8_t length = *ptr++; const uint8_t cmd = ptr[0]; if (length < 1 || ptr + length > parameter_value + parameter_length || (cmd == QUEUE_COMMAND_ORDER_WRAPPER && length < 2)) { generate_response_msg_addPGM(PMSG(ERR_MSG_INSUFFICENT_BYTES)); generate_response_msg_add_ascii_number(length); send_enqueue_error(QUEUE_COMMAND_ERROR_TYPE_MALFORMED_BLOCK, index); return; } uint8_t retval; switch (cmd) { case QUEUE_COMMAND_LINEAR_MOVE: retval = enqueue_linear_move_command(ptr+1, length-1); break; case QUEUE_COMMAND_MOVEMENT_CHECKPOINT: retval = enqueue_move_checkpoint_command(ptr+1, length-1); break; case QUEUE_COMMAND_DELAY: retval = enqueue_delay_command(ptr+1, length-1); break; case QUEUE_COMMAND_ORDER_WRAPPER: switch (ptr[1]) { case ORDER_SET_OUTPUT_SWITCH_STATE: retval = enqueue_set_output_switch_state_command(ptr+2, length-2); break; case ORDER_SET_PWM_OUTPUT_STATE: retval = enqueue_set_pwm_output_state_command(ptr+2, length-2); break; case ORDER_SET_OUTPUT_TONE: retval = enqueue_set_output_tone_command(ptr+2, length-2); break; case ORDER_SET_HEATER_TARGET_TEMP: retval = enqueue_set_heater_target_temperature_command(ptr+2, length-2); break; case ORDER_ENABLE_DISABLE_STEPPERS: retval = enqueue_set_stepper_enable_state_command(ptr+2, length-2); break; case ORDER_ENABLE_DISABLE_ENDSTOPS: retval = enqueue_set_endstop_enable_state_command(ptr+2, length-2); break; default: generate_response_msg_addPGM(PMSG(ERR_MSG_QUEUE_ORDER_NOT_PERMITTED)); generate_response_msg_add_ascii_number(ptr[1]); send_enqueue_error(QUEUE_COMMAND_ERROR_TYPE_ERROR_IN_COMMAND_BLOCK, index, PARAM_APP_ERROR_TYPE_UNKNOWN_ORDER); return; } break; default: send_enqueue_error(QUEUE_COMMAND_ERROR_TYPE_UNKNOWN_COMMAND_BLOCK, index); return; } if (retval != ENQUEUE_SUCCESS) { send_enqueue_error(QUEUE_COMMAND_ERROR_TYPE_ERROR_IN_COMMAND_BLOCK, index, retval); return; } ptr += length; index += 1; } 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_start(RSP_OK); generate_response_data_add(remaining_slots); generate_response_data_add(current_command_count); generate_response_data_add(total_command_count); generate_response_send(); }
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 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_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 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(); }
void loop() { // quickly scan through baudrates until we receive a valid packet within timeout period #if 0 // the baud rate change still isn't working for some reason. if (autodetect_baudrates_index != 0xFF) { if (millis() - first_rcvd_time > MAX_FRAME_COMPLETION_DELAY_MS * 1.5) // make sure its not a multiple of 100ms { PSERIAL.end(); PSERIAL.flush(); autodetect_baudrates_index += 1; if (autodetect_baudrates_index >= NUM_ARRAY_ELEMENTS(autodetect_baudrates)) autodetect_baudrates_index = 0; PSERIAL.begin(pgm_read_dword(&autodetect_baudrates[autodetect_baudrates_index])); recv_buf_len = 0; first_rcvd_time = millis(); } } #endif if (get_command()) { autodetect_baudrates_index = 0xFF; last_order_time = millis(); is_host_active = true; order_code = recv_buf[PM_ORDER_BYTE_OFFSET]; control_byte = recv_buf[PM_CONTROL_BYTE_OFFSET]; parameter_length = recv_buf[PM_LENGTH_BYTE_OFFSET]-2; #if TRACE_ORDER DEBUGPGM("\nOrder("); DEBUG_F(order_code, HEX); DEBUGPGM(", plen="); DEBUG_F(parameter_length, DEC); DEBUGPGM(", cb="); DEBUG_F(control_byte, HEX); DEBUGPGM("):"); for (uint8_t i = 0; i < parameter_length; i++) { DEBUG_CH(' '); DEBUG_F(recv_buf[i], HEX); } DEBUG_EOL(); #endif // does this match the sequence number of the last reply if ((control_byte & CONTROL_BYTE_SEQUENCE_NUMBER_MASK) == (reply_control_byte & CONTROL_BYTE_SEQUENCE_NUMBER_MASK) && (control_byte & CONTROL_BYTE_ORDER_HOST_RESET_BIT) == 0 && reply_control_byte != 0xFF) { if (!reply_started) { // resend last response reply_started = true; generate_response_send(); } else { // this is an unexpected error case (matching sequence number but nothing to send) generate_response_transport_error_start(PARAM_FRAME_RECEIPT_ERROR_TYPE_UNABLE_TO_ACCEPT, control_byte); generate_response_msg_addPGM(PMSG(MSG_ERR_NO_RESPONSE_TO_SEND)); generate_response_send(); } } else { reply_sent = false; process_command(); if (!reply_sent) { send_app_error_response(PARAM_APP_ERROR_TYPE_FIRMWARE_ERROR, PMSG(MSG_ERR_NO_RESPONSE_GENERATED)); } } recv_buf_len = 0; } // Idle loop activities // Check if heaters need to be updated? if (temp_meas_ready) { Device_TemperatureSensor::UpdateTemperatureSensors(); Device_Heater::UpdateHeaters(); } // Now check low-priority stuff uint32_t now = millis(); if (now - last_idle_check > 1000) // checked every second { #if !DEBUG_DISABLE_HOST_TIMEOUT // have we heard from the host within the timeout? if (now - last_order_time > (HOST_TIMEOUT_SECS * 1000) && is_host_active) { is_host_active = false; if (!is_stopped) { emergency_stop(PARAM_STOPPED_CAUSE_HOST_TIMEOUT); } } #endif #if TRACE_MOVEMENT print_movement_ISR_state(); #endif last_idle_check = now; } }
FORCE_INLINE static bool get_command() { uint8_t serial_char; if (recv_buf_len > 0 && millis() - first_rcvd_time > MAX_FRAME_COMPLETION_DELAY_MS) { // timeout waiting for frame completion if (recv_buf_len >= PM_HEADER_SIZE) { generate_response_transport_error_start(PARAM_FRAME_RECEIPT_ERROR_TYPE_BAD_FRAME, recv_buf[PM_CONTROL_BYTE_OFFSET]); generate_response_send(); recv_errors += 1; } recv_buf_len = 0; } while(PSERIAL.available() > 0) { serial_char = PSERIAL.read(); if (recv_buf_len == 0) { // ignore non-sync characters at the start if (serial_char == SYNC_BYTE_ORDER_VALUE) { first_rcvd_time = millis(); recv_buf[0] = SYNC_BYTE_ORDER_VALUE; recv_buf_len = 1; } continue; } // still need more bytes? else if (recv_buf_len < PM_HEADER_SIZE || recv_buf_len - 2 < recv_buf[PM_LENGTH_BYTE_OFFSET]) { if (recv_buf_len == sizeof(recv_buf)) // should only occur due to reduced buffer size { generate_response_transport_error_start(PARAM_FRAME_RECEIPT_ERROR_TYPE_BAD_FRAME, recv_buf[PM_CONTROL_BYTE_OFFSET]); generate_response_send(); recv_buf_len = 0; return false; } recv_buf[recv_buf_len++] = serial_char; continue; } else if (recv_buf[PM_LENGTH_BYTE_OFFSET] < 2) { generate_response_transport_error_start(PARAM_FRAME_RECEIPT_ERROR_TYPE_BAD_FRAME, recv_buf[PM_CONTROL_BYTE_OFFSET]); generate_response_send(); recv_buf_len = 0; return false; } // we have enough bytes - check the crc else if (serial_char != crc8(&recv_buf[PM_LENGTH_BYTE_OFFSET],recv_buf_len-1)) { #if !DEBUG_DONT_CHECK_CRC8_VALUE generate_response_transport_error_start(PARAM_FRAME_RECEIPT_ERROR_TYPE_BAD_CHECK_CODE, recv_buf[PM_CONTROL_BYTE_OFFSET]); generate_response_send(); recv_buf_len = 0; recv_errors += 1; continue; #endif } // we have a packet recv_buf[recv_buf_len] = '\0'; // null-terminate buffer recv_count += 1; return true; } return false; }