368 lines
9.4 KiB
Elixir
368 lines
9.4 KiB
Elixir
defmodule FarmbotFirmware.ParamTest do
|
|
use ExUnit.Case
|
|
alias FarmbotFirmware.Param
|
|
import ExUnit.CaptureLog
|
|
|
|
def t(p, v, expected) do
|
|
assert Param.to_human(p, v) == expected
|
|
end
|
|
|
|
test "to_human()" do
|
|
float_value = 1.23
|
|
seconds = "(seconds)"
|
|
steps = "(steps)"
|
|
steps_per_s = "(steps/s)"
|
|
steps_per_mm = "(steps/mm)"
|
|
|
|
t(:pin_guard_5_time_out, 12, {"pin guard 5 timeout", "(seconds)", "12"})
|
|
t(:pin_guard_5_pin_nr, 12, {"pin guard 5 pin number", nil, "12"})
|
|
t(:pin_guard_5_active_state, 0, {"pin guard 5 safe state", nil, "ON"})
|
|
t(:pin_guard_4_time_out, 12, {"pin guard 4 timeout", "(seconds)", "12"})
|
|
t(:pin_guard_4_pin_nr, 12, {"pin guard 4 pin number", nil, "12"})
|
|
t(:pin_guard_4_active_state, 0, {"pin guard 4 safe state", nil, "ON"})
|
|
t(:pin_guard_3_time_out, 1.0, {"pin guard 3 timeout", "(seconds)", "1"})
|
|
t(:pin_guard_3_pin_nr, 1.0, {"pin guard 3 pin number", nil, "1"})
|
|
t(:pin_guard_3_active_state, 0, {"pin guard 3 safe state", nil, "ON"})
|
|
t(:pin_guard_2_time_out, 1.0, {"pin guard 2 timeout", "(seconds)", "1"})
|
|
t(:pin_guard_2_pin_nr, 1.0, {"pin guard 2 pin number", nil, "1"})
|
|
t(:pin_guard_2_active_state, 0, {"pin guard 2 safe state", nil, "ON"})
|
|
t(:pin_guard_1_time_out, 1.0, {"pin guard 1 timeout", "(seconds)", "1"})
|
|
t(:pin_guard_1_pin_nr, 1.0, {"pin guard 1 pin number", nil, "1"})
|
|
t(:pin_guard_1_active_state, 0, {"pin guard 1 safe state", nil, "ON"})
|
|
t(:param_use_eeprom, 1, {"use eeprom", nil, true})
|
|
t(:param_test, 1, {"param_test", nil, true})
|
|
t(:param_mov_nr_retry, 1.0, {"max retries", nil, "1"})
|
|
t(:param_e_stop_on_mov_err, 1, {"e-stop on movement errors", nil, true})
|
|
t(:param_config_ok, 1, {"param_config_ok", nil, true})
|
|
t(:movement_stop_at_max_z, 1, {"stop at max, z-axis", nil, true})
|
|
t(:movement_stop_at_max_y, 1, {"stop at max, y-axis", nil, true})
|
|
t(:movement_stop_at_max_x, 1, {"stop at max, x-axis", nil, true})
|
|
t(:movement_stop_at_home_z, 1, {"stop at home, z-axis", nil, true})
|
|
t(:movement_stop_at_home_y, 1, {"stop at home, y-axis", nil, true})
|
|
t(:movement_stop_at_home_x, 1, {"stop at home, x-axis", nil, true})
|
|
t(:movement_secondary_motor_x, 1, {"enable 2nd x motor", nil, true})
|
|
t(:movement_secondary_motor_invert_x, 1, {"invert 2nd x motor", nil, true})
|
|
t(:movement_microsteps_z, float_value, {"microsteps, z-axis", nil, "1.2"})
|
|
t(:movement_microsteps_y, float_value, {"microsteps, y-axis", nil, "1.2"})
|
|
t(:movement_microsteps_x, float_value, {"microsteps, x-axis", nil, "1.2"})
|
|
t(:movement_keep_active_z, 1, {"always power motors, z-axis", nil, true})
|
|
t(:movement_keep_active_y, 1, {"always power motors, y-axis", nil, true})
|
|
t(:movement_keep_active_x, 1, {"always power motors, x-axis", nil, true})
|
|
t(:movement_invert_motor_z, 1, {"invert motor, z-axis", nil, true})
|
|
t(:movement_invert_motor_y, 1, {"invert motor, y-axis", nil, true})
|
|
t(:movement_invert_motor_x, 1, {"invert motor, x-axis", nil, true})
|
|
t(:movement_invert_endpoints_z, 1, {"swap endstops, z-axis", nil, true})
|
|
t(:movement_invert_endpoints_y, 1, {"swap endstops, y-axis", nil, true})
|
|
t(:movement_invert_endpoints_x, 1, {"swap endstops, x-axis", nil, true})
|
|
t(:movement_home_at_boot_z, 1, {"find home on boot, z-axis", nil, true})
|
|
t(:movement_home_at_boot_y, 1, {"find home on boot, y-axis", nil, true})
|
|
t(:movement_home_at_boot_x, 1, {"find home on boot, x-axis", nil, true})
|
|
t(:movement_enable_endpoints_z, 1, {"enable endstops, z-axis", nil, true})
|
|
t(:movement_enable_endpoints_y, 1, {"enable endstops, y-axis", nil, true})
|
|
t(:movement_enable_endpoints_x, 1, {"enable endstops, x-axis", nil, true})
|
|
t(:encoder_type_z, 1.2, {"encoder type, z-axis", nil, "1.2"})
|
|
t(:encoder_type_y, 1.2, {"encoder type, y-axis", nil, "1.2"})
|
|
t(:encoder_type_x, 1.2, {"encoder type, x-axis", nil, "1.2"})
|
|
t(:encoder_invert_z, 1, {"invert encoders, z-axis", nil, true})
|
|
t(:encoder_invert_y, 1, {"invert encoders, y-axis", nil, true})
|
|
t(:encoder_invert_x, 1, {"invert encoders, x-axis", nil, true})
|
|
|
|
t(
|
|
:movement_motor_current_x,
|
|
float_value,
|
|
{"motor current, x-axis", "(milliamps)", "1.2"}
|
|
)
|
|
|
|
t(
|
|
:movement_motor_current_y,
|
|
float_value,
|
|
{"motor current, y-axis", "(milliamps)", "1.2"}
|
|
)
|
|
|
|
t(
|
|
:movement_motor_current_z,
|
|
float_value,
|
|
{"motor current, z-axis", "(milliamps)", "1.2"}
|
|
)
|
|
|
|
t(
|
|
:movement_stall_sensitivity_x,
|
|
float_value,
|
|
{"stall sensitivity, x-axis", nil, "1.2"}
|
|
)
|
|
|
|
t(
|
|
:movement_stall_sensitivity_y,
|
|
float_value,
|
|
{"stall sensitivity, y-axis", nil, "1.2"}
|
|
)
|
|
|
|
t(
|
|
:movement_stall_sensitivity_z,
|
|
float_value,
|
|
{"stall sensitivity, z-axis", nil, "1.2"}
|
|
)
|
|
|
|
t(
|
|
:movement_timeout_x,
|
|
float_value,
|
|
{"timeout after, x-axis", seconds, "1.2"}
|
|
)
|
|
|
|
t(
|
|
:movement_timeout_y,
|
|
float_value,
|
|
{"timeout after, y-axis", seconds, "1.2"}
|
|
)
|
|
|
|
t(
|
|
:movement_timeout_z,
|
|
float_value,
|
|
{"timeout after, z-axis", seconds, "1.2"}
|
|
)
|
|
|
|
t(
|
|
:movement_step_per_mm_x,
|
|
float_value,
|
|
{"steps per mm, x-axis", steps_per_mm, "1.2"}
|
|
)
|
|
|
|
t(
|
|
:movement_step_per_mm_y,
|
|
float_value,
|
|
{"steps per mm, y-axis", steps_per_mm, "1.2"}
|
|
)
|
|
|
|
t(
|
|
:movement_step_per_mm_z,
|
|
float_value,
|
|
{"steps per mm, z-axis", steps_per_mm, "1.2"}
|
|
)
|
|
|
|
t(
|
|
:movement_min_spd_x,
|
|
float_value,
|
|
{"minimum speed, x-axis", steps_per_s, "1.2"}
|
|
)
|
|
|
|
t(
|
|
:movement_min_spd_y,
|
|
float_value,
|
|
{"minimum speed, y-axis", steps_per_s, "1.2"}
|
|
)
|
|
|
|
t(
|
|
:movement_min_spd_z,
|
|
float_value,
|
|
{"minimum speed, z-axis", steps_per_s, "1.2"}
|
|
)
|
|
|
|
t(
|
|
:movement_home_spd_x,
|
|
float_value,
|
|
{"homing speed, x-axis", steps_per_s, "1.2"}
|
|
)
|
|
|
|
t(
|
|
:movement_home_spd_y,
|
|
float_value,
|
|
{"homing speed, y-axis", steps_per_s, "1.2"}
|
|
)
|
|
|
|
t(
|
|
:movement_home_spd_z,
|
|
float_value,
|
|
{"homing speed, z-axis", steps_per_s, "1.2"}
|
|
)
|
|
|
|
t(
|
|
:movement_max_spd_x,
|
|
float_value,
|
|
{"max speed, x-axis", steps_per_s, "1.2"}
|
|
)
|
|
|
|
t(
|
|
:movement_max_spd_y,
|
|
float_value,
|
|
{"max speed, y-axis", steps_per_s, "1.2"}
|
|
)
|
|
|
|
t(
|
|
:movement_max_spd_z,
|
|
float_value,
|
|
{"max speed, z-axis", steps_per_s, "1.2"}
|
|
)
|
|
|
|
t(
|
|
:movement_invert_2_endpoints_x,
|
|
1,
|
|
{"invert endstops, x-axis", nil, true}
|
|
)
|
|
|
|
t(
|
|
:movement_invert_2_endpoints_y,
|
|
1,
|
|
{"invert endstops, y-axis", nil, true}
|
|
)
|
|
|
|
t(
|
|
:movement_invert_2_endpoints_z,
|
|
1,
|
|
{"invert endstops, z-axis", nil, true}
|
|
)
|
|
|
|
t(
|
|
:encoder_enabled_x,
|
|
1,
|
|
{"enable encoders / stall detection, x-axis", nil, true}
|
|
)
|
|
|
|
t(
|
|
:encoder_enabled_y,
|
|
1,
|
|
{"enable encoders / stall detection, y-axis", nil, true}
|
|
)
|
|
|
|
t(
|
|
:encoder_enabled_z,
|
|
1,
|
|
{"enable encoders / stall detection, z-axis", nil, true}
|
|
)
|
|
|
|
t(
|
|
:encoder_scaling_x,
|
|
float_value,
|
|
{"encoder scaling, x-axis", nil, "1.2"}
|
|
)
|
|
|
|
t(
|
|
:encoder_scaling_y,
|
|
float_value,
|
|
{"encoder scaling, y-axis", nil, "1.2"}
|
|
)
|
|
|
|
t(
|
|
:encoder_scaling_z,
|
|
float_value,
|
|
{"encoder scaling, z-axis", nil, "1.2"}
|
|
)
|
|
|
|
t(
|
|
:encoder_missed_steps_decay_x,
|
|
float_value,
|
|
{"missed step decay, x-axis", steps, "1.2"}
|
|
)
|
|
|
|
t(
|
|
:encoder_missed_steps_decay_y,
|
|
float_value,
|
|
{"missed step decay, y-axis", steps, "1.2"}
|
|
)
|
|
|
|
t(
|
|
:encoder_missed_steps_decay_z,
|
|
float_value,
|
|
{"missed step decay, z-axis", steps, "1.2"}
|
|
)
|
|
|
|
t(
|
|
:encoder_use_for_pos_x,
|
|
1,
|
|
{"use encoders for positioning, x-axis", nil, true}
|
|
)
|
|
|
|
t(
|
|
:encoder_use_for_pos_y,
|
|
1,
|
|
{"use encoders for positioning, y-axis", nil, true}
|
|
)
|
|
|
|
t(
|
|
:encoder_use_for_pos_z,
|
|
1,
|
|
{"use encoders for positioning, z-axis", nil, true}
|
|
)
|
|
|
|
t(
|
|
:movement_axis_nr_steps_z,
|
|
1.0,
|
|
{"axis length, z-axis", "(steps)", "1"}
|
|
)
|
|
|
|
t(
|
|
:movement_axis_nr_steps_y,
|
|
1.0,
|
|
{"axis length, y-axis", "(steps)", "1"}
|
|
)
|
|
|
|
t(
|
|
:movement_axis_nr_steps_x,
|
|
1.0,
|
|
{"axis length, x-axis", "(steps)", "1"}
|
|
)
|
|
|
|
t(
|
|
:movement_steps_acc_dec_x,
|
|
1.0,
|
|
{"accelerate for, x-axis", "(steps)", "1"}
|
|
)
|
|
|
|
t(
|
|
:movement_steps_acc_dec_y,
|
|
1.0,
|
|
{"accelerate for, y-axis", "(steps)", "1"}
|
|
)
|
|
|
|
t(
|
|
:movement_steps_acc_dec_z,
|
|
1.0,
|
|
{"accelerate for, z-axis", "(steps)", "1"}
|
|
)
|
|
|
|
t(
|
|
:movement_home_up_x,
|
|
1.0,
|
|
{"negative coordinates only, x-axis", nil, true}
|
|
)
|
|
|
|
t(
|
|
:movement_home_up_y,
|
|
1.0,
|
|
{"negative coordinates only, y-axis", nil, true}
|
|
)
|
|
|
|
t(
|
|
:movement_home_up_z,
|
|
1.0,
|
|
{"negative coordinates only, z-axis", nil, true}
|
|
)
|
|
|
|
t(
|
|
:encoder_missed_steps_max_x,
|
|
1.0,
|
|
{"max missed steps, x-axis", "(steps)", "1"}
|
|
)
|
|
|
|
t(
|
|
:encoder_missed_steps_max_y,
|
|
1.0,
|
|
{"max missed steps, y-axis", "(steps)", "1"}
|
|
)
|
|
|
|
t(
|
|
:encoder_missed_steps_max_z,
|
|
1.0,
|
|
{"max missed steps, z-axis", "(steps)", "1"}
|
|
)
|
|
end
|
|
|
|
test "Handling of uknown parameters" do
|
|
log =
|
|
capture_log(fn ->
|
|
assert :unknown_parameter == Param.decode(-999)
|
|
end)
|
|
|
|
assert log =~ "unknown firmware parameter: -999"
|
|
end
|
|
end
|