def test_reliability_003(dcm, mem, motion, motion_wake_up, parameters,
direction):
"""
Test : bumper detects step.
Return True if bumper detects obstacles and robot stops
Return False if bumper detects obstacle but robot moves again
@dcm : proxy to DCM (object)
@mem : proxy to ALMemory (object)
@motion : proxy to ALMotion (object)
@motion_wake_up : robot does it wakeUp
@parameters : dictionnary {"parameter":value} from config file
(dictionnary)
@directions : dictionnary {"direction":value} (dictionnary)
"""
# Objects creation
right_bumper = subdevice.Bumper(dcm, mem, "FrontRight")
left_bumper = subdevice.Bumper(dcm, mem, "FrontLeft")
back_bumper = subdevice.Bumper(dcm, mem, "Back")
wheelfr_speed_act = subdevice.WheelSpeedActuator(dcm, mem, "WheelFR")
wheelfl_speed_act = subdevice.WheelSpeedActuator(dcm, mem, "WheelFL")
log = Log(dcm, mem, direction + "-" + parameters["Speed"][0])
log.start()
print "Go move"
move(
motion, float(parameters["Speed"][0]),
qha_tools.read_section("reliability_003.cfg", "Direction" + direction))
print "Move finish"
flag = 0
while flag < int(parameters["Nbcycles"][0]):
if right_bumper.value or left_bumper.value or back_bumper.value:
print "Bumper"
time.sleep(3) # Time to wait wheel actuators reaction...
if wheelfr_speed_act.value == 0 and wheelfl_speed_act.value == 0:
print "Stop OK"
flag += 1
time.sleep(5) # Robot forget mapping
moveto(
motion, float(parameters["MoveBackDistance"][0]),
qha_tools.read_section("reliability_003.cfg",
"Direction" + direction))
print "Move back OK"
time.sleep(2)
move(
motion, float(parameters["Speed"][0]),
qha_tools.read_section("reliability_003.cfg",
"Direction" + direction))
print "Move"
else:
print flag
break
log.stop()
assert flag == int(parameters["Nbcycles"][0])
def test_sensors_env_004(robot_ip, dcm, mem, motion, session, motion_wake_up,
parameters, direction, speed):
"""
Docstring
"""
expected = {"ALMotion/MoveFailed": 1}
module_name = "EventChecker_{}_".format(uuid.uuid4())
movefailed = EventModule(mem)
module_id = session.registerService(module_name, movefailed)
movefailed.subscribe(module_name, expected)
flag_test = False
# Sensors
sensors_list = qha_tools.read_section("sensors.cfg", "Sensors")
ir_right = subdevice.InfraredSpot(dcm, mem, "Right")
ir_left = subdevice.InfraredSpot(dcm, mem, "Left")
log = multi_logger.Logger(
robot_ip, "multi_logger.cfg", 0.1,
"Direction" + str(direction) + " - " + str(speed) + ".csv")
log.log()
# Movement
move(motion, speed,
qha_tools.read_section("env_004.cfg", "Direction" + direction))
time.sleep(1)
while not movefailed.flag and not flag_test:
for sensor in sensors_list:
if mem.getData(sensor) < float(parameters["distance"][0]):
print(sensor)
motion.stopMove()
flag_test = True
# if ir_right.value == 1:
# print("IR_Right")
# motion.stopMove()
# flag_test = True
# if ir_left.value == 1:
# print("IR_Left")
# motion.stopMove()
# flag_test = True
log.stop()
session.unregisterService(module_id)
assert flag_test
def allowed_temperature_emergencies():
"""
Reads allowed temperature emergencies from configuration file.
It returns a dictionnary with allowed temperature emergency for each joint.
"""
print "reading allowed temperature emergencies..."
return qha_tools.read_section(CONFIG_FILE, "AllowedTemperatureEmergencies")
def test_parameters_dico(request, motion, offset_protection):
"""
@returns : Dictionary of motion parameters
@rtype : dictionary
It returns as many dictionaries as arguments in params [len(params)]
"""
dico = qha_tools.read_section(CONFIG_FILE, request.param)
return dico
def hippitch_cycling(dcm, mem, max_joint_temperature):
""" HipPitch cycling"""
# Objects creation
kneepitch_position_actuator = subdevice.JointPositionActuator(
dcm, mem, "KneePitch")
kneepitch_position_sensor = subdevice.JointPositionSensor(
dcm, mem, "KneePitch")
kneepitch_hardness_actuator = subdevice.JointHardnessActuator(
dcm, mem, "KneePitch")
hippitch_position_actuator = subdevice.JointPositionActuator(
dcm, mem, "HipPitch")
hippitch_temperature = subdevice.JointTemperature(
dcm, mem, "HipPitch")
hiproll_position_actuator = subdevice.JointPositionActuator(
dcm, mem, "HipRoll")
parameters = qha_tools.read_section("test_pod.cfg", "DynamicCycling")
# Initial position
kneepitch_position_actuator.qvalue = (0.,
int(parameters["time_go_initial_position"][0]) * 1000)
hiproll_position_actuator.qvalue = (0.,
int(parameters["time_go_initial_position"][0]) * 1000)
qha_tools.wait(dcm, int(parameters["time_go_initial_position"][0]) * 1000)
kneepitch_hardness_actuator.qqvalue = 0.
while hippitch_temperature.value < max_joint_temperature:
hippitch_position_actuator.qvalue = (
float(parameters["amplitude_hippitch"][0]),
int(parameters["time_movement_hippitch"][0]) * 1000
)
qha_tools.wait(dcm, int(parameters["time_movement_hippitch"][0]) * 1000)
hippitch_position_actuator.qvalue = (
-float(parameters["amplitude_hippitch"][0]),
int(parameters["time_movement_hippitch"][0]) * 1000
)
qha_tools.wait(dcm, int(parameters["time_movement_hippitch"][0]) * 1000)
print(str(hippitch_temperature.value))
if abs(kneepitch_position_sensor.value) > \
float(parameters["angle_slipping"][0]):
print "KneePitch slip"
kneepitch_hardness_actuator.qqvalue = 1.
kneepitch_position_actuator.qvalue = (0.,
int(parameters["time_after_slipping"][0]) * 1000)
hippitch_position_actuator.qvalue = (0.,
int(parameters["time_after_slipping"][0]) * 1000)
qha_tools.wait(dcm, int(parameters["time_after_slipping"][0]) * 1000)
kneepitch_hardness_actuator.qqvalue = 0.
hippitch_position_actuator.qvalue = (0.,
int(parameters["time_go_initial_position"][0]) * 1000)
qha_tools.wait(dcm, int(parameters["time_go_initial_position"][0]) * 1000)
kneepitch_hardness_actuator.qqvalue = 1.
def sa_objects():
"""
Returns a dictionnary of sliding average objects with the correct number
of points for each joint.
It reads the test configuration file.
"""
sa_nb_points = qha_tools.read_section(CONFIG_FILE,
"SlidingAverageNbPoints")
dico_object = dict()
for joint, nb_points in sa_nb_points.items():
dico_object[joint] = qha_tools.SlidingAverage(int(nb_points[0]))
return dico_object
def test_sensors_safety_001(robot_ip, dcm, mem, motion, session,
motion_wake_up, direction, speed):
"""
Docstring
"""
expected = {"ALMotion/MoveFailed": 1}
module_name = "EventChecker_{}_".format(uuid.uuid4())
obstacledetected = EventModule(mem)
module_id = session.registerService(module_name, obstacledetected)
obstacledetected.subscribe(module_name, expected)
# Objects creation
wheelb_speed_act = subdevice.WheelSpeedActuator(dcm, mem, "WheelB")
wheelfr_speed_act = subdevice.WheelSpeedActuator(dcm, mem, "WheelFR")
wheelfl_speed_act = subdevice.WheelSpeedActuator(dcm, mem, "WheelFL")
flag_test = True
log = multi_logger.Logger(
robot_ip,
"multi_logger.cfg",
0.1,
"Direction" + direction + " - " + str(speed) + ".csv")
log.log()
# Movement
move(motion, speed,
qha_tools.read_section("safety_001.cfg", "Direction" + direction)
)
time.sleep(1)
while not obstacledetected.flag:
if wheelb_speed_act.value == 0 and \
wheelfr_speed_act.value == 0 and \
wheelfl_speed_act.value == 0:
flag_test = False
log.stop()
session.unregisterService(module_id)
assert flag_test
def set_position(dcm, mem, motion, section):
"""
Put robot in initial position.
No return.
@dcm : proxy to DCM (object)
@mem : proxy to ALMemory (object)
@motion : proxy to ALMotion (object)
@section : name of section to read in config file (string)
"""
datas = qha_tools.read_section("touch_detection.cfg", section)
for name, value in datas.items():
if value[0] == "max":
sub = subdevice.SubDevice(dcm, mem, name + "/Position/Actuator")
angle = float(sub.maximum)
elif value[0] == "min":
sub = subdevice.SubDevice(dcm, mem, name + "/Position/Actuator")
angle = float(sub.minimum)
else:
angle = float(value[0])
move_joint(name, angle, 0.1, motion)
def __init__(self, dcm, mem):
"""
Initialisation de la class
"""
self.dcm = dcm
self.mem = mem
self.parameters = qha_tools.read_section("test_config.cfg",
"DockCyclingParameters")
self.wheel_motion = subdevice.WheelsMotion(
self.dcm, self.mem, float(self.parameters["speed"][0]))
self.robot_on_charging_station = subdevice.ChargingStationSensor(
self.dcm, self.mem)
self.back_bumper_sensor = subdevice.Bumper(dcm, mem, "Back")
self.nb_cycles = self.parameters["nb_cycles"][0]
self.log_file = open(self.parameters["cycling_cvs_name"][0], 'w')
self.check_temperature_thread = threading.Thread(
target=self._check_temperature_thread, args=())
self.check_bumper_thread = threading.Thread(
target=self._check_bumper_thread, args=())
self.check_bumper = True
self.check_bumper_pause = True
self.check_temperature = None
self.wheel_hot = None
self.bumper_state = None
def parameters():
return qha_tools.read_section("perf_001.cfg", "TestParameters")
def test_pod_damage(dcm, mem, wake_up_pos, kill_motion, stiff_robot,
unstiff_parts):
"""
Test robot moving in the pod to check damages
"""
# Objects creation
robot_on_charging_station = subdevice.ChargingStationSensor(dcm, mem)
kneepitch_temperature = subdevice.JointTemperature(
dcm, mem, "KneePitch")
hippitch_temperature = subdevice.JointTemperature(
dcm, mem, "HipPitch")
hiproll_temperature = subdevice.JointTemperature(
dcm, mem, "HipRoll")
# Test parameters
parameters = qha_tools.read_section("test_pod.cfg", "DynamicTestParameters")
motion = subdevice.WheelsMotion(dcm, mem, 0.15)
motion.stiff_wheels(
["WheelFR", "WheelFL", "WheelB"],
int(parameters["stiffness_wheels_value"][0])
)
cycling_flag = 0
cycling_step = 0
# Going to initial position
subdevice.multiple_set(dcm, mem, wake_up_pos, wait=True)
# Flag initialization
flag = True
# Use plot class
plot_log = Plot(dcm, mem, parameters["easy_plot_csv_name"][0])
plot_log.start()
timer = qha_tools.Timer(dcm, int(parameters["test_time"][0]) * 1000)
# Use detection during movement class
log_during_movement = DetectionDuringMovement(
dcm, mem, timer,
parameters["log_during_movement_csv_name"][0],
parameters["lost_detection_csv_name"][0]
)
log_during_movement.start()
if robot_on_charging_station.value == 0:
print "Put the robot on the robot.\nVerify detection.\n"
flag = False
while timer.is_time_not_out() and flag == True:
# Verify if robot moves
if cycling_step == 3:
log_during_movement.set_cycling_stop_flag_true()
if cycling_flag == 0:
if kneepitch_temperature.value < \
int(parameters["max_joint_temperature"][0]):
print "KneePitch cycling"
cycling_step = 0
log_during_movement.set_cycling_stop_flag_false()
kneepitch_cycling(dcm, mem,
int(parameters["max_joint_temperature"][0]))
else:
cycling_step += 1
cycling_flag = 1
elif cycling_flag == 1:
if hippitch_temperature.value < \
int(parameters["max_joint_temperature"][0]):
print "HipPitch cycling"
cycling_step = 0
log_during_movement.set_cycling_stop_flag_false()
hippitch_cycling(
dcm, mem,
int(parameters["max_joint_temperature"][0])
)
else:
cycling_step += 1
cycling_flag = 2
else:
if hiproll_temperature.value < \
int(parameters["max_joint_temperature"][0]):
print "HipRoll cycling"
cycling_step = 0
log_during_movement.set_cycling_stop_flag_false()
hiproll_cycling(
dcm, mem,
int(parameters["max_joint_temperature"][0])
)
else:
cycling_step += 1
cycling_flag = 0
plot_log.stop()
log_during_movement.stop()
assert flag
def main():
"""Main function"""
parser = argparse.ArgumentParser(description="Log datas from ALMemory")
parser.add_argument(dest="robot_ip", help="Robot IP or name")
args = parser.parse_args()
general = qha_tools.read_section("slip.cfg", "general")
robot_ip = args.robot_ip
result_folder = general["resultsFolder"][0]
# Create result folder if not existing
try:
os.mkdir(result_folder)
except OSError:
pass
dcm = ALProxy("DCM", robot_ip, 9559)
mem = ALProxy("ALMemory", robot_ip, 9559)
# Get Body ID
body_id = mem.getData("Device/DeviceList/ChestBoard/BodyId")
# Kill motion (if not already done)
try:
mot = ALProxy("ALMotion", robot_ip, 9559)
mot.exit()
except RuntimeError:
pass
print "[I] ALMotion is now killed"
# Ask the operator to write his name
name = raw_input("Please enter your name and press Enter : ")
while name == "":
name = raw_input("Please enter your name and press Enter : ")
nb_of_trials = int(general["numberOfTrials"][0])
stiffness_on = qha_tools.read_section("slip.cfg",
"stiffnessOnWithoutWheels")
stiffness_off = qha_tools.read_section("slip.cfg", "stiffnessOff")
rest_pos = qha_tools.read_section("slip.cfg", "restPosition")
force_list = []
for i in range(nb_of_trials):
# Set Stiffness on
subdevice.multiple_set(dcm, mem, stiffness_on)
# Go to rest position
subdevice.multiple_set(dcm, mem, rest_pos, wait=True)
time.sleep(1)
# Set Stiffness off
subdevice.multiple_set(dcm, mem, stiffness_off)
if (nb_of_trials - i - 1) <= 1:
trial_string = "trial"
else:
trial_string = "trials"
force = raw_input("Please push the robot, write the force (in Newton) "
"and press Enter. (" + str(nb_of_trials - i - 1) +
" " + trial_string + " left) : ")
while not is_number(force):
force = raw_input("Please push the robot, write the force"
"(in Newton) and press Enter. (" +
str(nb_of_trials - i - 1) + " " + trial_string +
" left) : ")
force_list.append(force)
print("Thank you !")
# At the end of the test, put the robot in initial position
# Set Stiffness on
subdevice.multiple_set(dcm, mem, stiffness_on)
# Go to rest position
subdevice.multiple_set(dcm, mem, rest_pos, wait=True)
time.sleep(1)
# Set Stiffness off
subdevice.multiple_set(dcm, mem, stiffness_off)
# Write results file
file_path = result_folder + "/" + body_id + ".dat"
my_file = open(file_path, 'a')
string_to_print = name + " " + " ".join(force_list) + "\n"
my_file.write(string_to_print)
def parameters():
"""
Return parameters (config file).
"""
return qha_tools.read_section("reliability_003.cfg", "TestParameters")
def parameters():
"""
Return parameters (config file).
"""
return qha_tools.read_section("pod_perf_009.cfg", "TestParameters")
def parameters():
"""
Return parameters (config file).
"""
return qha_tools.read_section("env_004.cfg", "TestParameters")
def test_sensors_env_005(robot_ip, dcm, mem, motion, session, motion_wake_up,
parameters, speed):
"""
Docstring
"""
expected = {"ALMotion/MoveFailed": 1}
module_name = "EventChecker_{}_".format(uuid.uuid4())
movefailed = EventModule(mem)
module_id = session.registerService(module_name, movefailed)
movefailed.subscribe(module_name, expected)
flag_test = False
# Sensors
sensors_list = qha_tools.read_section("sensors.cfg", "Sensors")
# ir_right = subdevice.InfraredSpot(dcm, mem, "Right")
# ir_left = subdevice.InfraredSpot(dcm, mem, "Left")
log = multi_logger.Logger(robot_ip, "multi_logger.cfg", 0.1,
parameters["log_file_name"][0])
log.log()
log_file = open("ObstacleDetection.csv", 'w')
line_to_write = ",".join(["Time", "Sensor", "Distance"]) + "\n"
log_file.write(line_to_write)
log_file.flush()
# Movement
motion.move(0, 0, speed)
time.sleep(1)
time_init = time.time()
while True:
elapsed_time = time.time() - time_init
try:
for sensor in sensors_list:
if mem.getData(sensor) < float(parameters["distance2"][0]):
print(parameters["distance2"][0])
print(sensor)
line_to_write = ",".join(
[str(elapsed_time), sensor,
str(mem.getData(sensor))]) + "\n"
log_file.write(line_to_write)
log_file.flush()
flag_test = True
elif mem.getData(sensor) < float(parameters["distance1"][0]):
print(parameters["distance1"][0])
print(sensor)
line_to_write = ",".join(
[str(elapsed_time), sensor,
str(mem.getData(sensor))]) + "\n"
log_file.write(line_to_write)
log_file.flush()
flag_test = True
else:
line_to_write = ",".join(
[str(elapsed_time), "None", "None"]) + "\n"
log_file.write(line_to_write)
log_file.flush()
# if ir_right.value == 1:
# print("IR_Right")
# flag_test = True
# if ir_left.value == 1:
# print("IR_Left")
# flag_test = True
time.sleep(0.1)
motion.move(0, 0, 0.3)
except KeyboardInterrupt:
break
log.stop()
session.unregisterService(module_id)
assert flag_test
def parameters():
return qha_tools.read_section("touch_detection.cfg", "TestParameters")
def wake_up_pos():
"""
Fixture which retrieves wakeUp joints position from a configuration file.
"""
return qha_tools.read_section(PATH + "/global_test_configuration/"
"juliette_positions.cfg", "wakeUp")
def test_damage(dcm, mem, kill_motion):
"""
Test robot docking/undocking to check damages
"""
time.sleep(10)
# Test parameters
parameters = qha_tools.read_section("test_pod.cfg",
"DockCyclingParameters")
# Objects creation
motion = subdevice.WheelsMotion(dcm, mem, float(parameters["speed"][0]))
robot_on_charging_station = subdevice.ChargingStationSensor(dcm, mem)
wheelfr_temperature_sensor = subdevice.WheelTemperatureSensor(
dcm, mem, "WheelFR")
wheelfl_temperature_sensor = subdevice.WheelTemperatureSensor(
dcm, mem, "WheelFL")
back_bumper_sensor = subdevice.Bumper(dcm, mem, "Back")
# Internal flags
cycles_done = 0
cycles_with_bumper_ok = 0
list_bumper_nok = []
unlock_bumper_status = 0
bumper_blocked_flag = False
detection = 1
loose_connexion_flag = 0
stop_cycling_flag = False
# Flag initialization
flag_detection = True
flag_bumper = True
flag_keep_connexion = True
timer = qha_tools.Timer(dcm, 10)
log_file = open(parameters["cycling_cvs_name"][0], 'w')
log_file.write(
"CyclesDone,CyclesDoneWithBumperOk," +
"Detection,LooseConnection,UnlockBumperStatus,LockBumperStatus\n")
plot_log = Plot(dcm, mem, parameters["easy_plot_csv_name"][0])
plot_log.start()
# Cyclage
# If the robot is not on the pod or bumper not activated, test don't start
if robot_on_charging_station.value == 0:
print "Put the robot on the pod\n"
stop_cycling_flag = True
flag_detection = False
flag_bumper = False
flag_keep_connexion = False
while stop_cycling_flag == False:
# Robot moves front
cycles_done += 1
motion.move_x(float(parameters["distance_front"][0]))
qha_tools.wait(dcm, int(parameters["time_wait_out_the_pod"][0]) * 1000)
unlock_bumper_status = back_bumper_sensor.value
# Verification of bumper
if back_bumper_sensor.value == 1:
bumper_blocked_flag = True
else:
bumper_blocked_flag = False
# Robot moves back
motion.move_x(float(parameters["distance_back"][0]))
motion.stiff_wheels(["WheelFR", "WheelFL", "WheelB"],
float(parameters["stiffness_wheels_value"][0]))
qha_tools.wait(
dcm,
float(parameters["time_wait_before_verify_detection"][0]) * 1000)
# Verification of connexion
t_init = timer.dcm_time()
test_time = 0
while robot_on_charging_station.value == 1 and\
test_time < int(parameters["time_wait_on_the_pod"][0]) * 1000:
detection = 1
loose_connexion_flag = 0
test_time = timer.dcm_time() - t_init
# If no detection
if test_time == 0:
detection = 0
# If connexion is lost
elif test_time < int(parameters["time_wait_on_the_pod"][0]) * 1000:
loose_connexion_flag = 1
flag_keep_connexion = False
# Verification of bumper
if back_bumper_sensor.value == 1 and bumper_blocked_flag == False:
cycles_with_bumper_ok += 1
else:
list_bumper_nok.append(cycles_done)
# Log data
line_to_write = ",".join([
str(cycles_done),
str(cycles_with_bumper_ok),
str(detection),
str(loose_connexion_flag),
str(unlock_bumper_status),
str(back_bumper_sensor.value)
])
line_to_write += "\n"
log_file.write(line_to_write)
log_file.flush()
# Wait if temperature of wheels too hot
while wheelfr_temperature_sensor.value > \
int(parameters["wheels_temperature_limit"][0]) or\
wheelfl_temperature_sensor.value > \
int(parameters["wheels_temperature_limit"][0]):
qha_tools.wait(dcm, int(parameters["time_wait_wheels cooled"][0]))
# End if nb_cycles is reached
if cycles_done == int(parameters["nb_cycles"][0]):
stop_cycling_flag = True
if len(list_bumper_nok) > cycles_done / 100:
flag_bumper = False
log_file.close()
plot_log.stop()
print("Cycles done = " + str(cycles_done))
print("Cycles done with bumper ok = " + str(cycles_with_bumper_ok))
assert flag_detection
assert flag_bumper
assert flag_keep_connexion
def test_fuseboard_temperature(self, dcm, mem, fuse, wheel_objects,
multi_fuseboard_ambiant_tmp,
multi_fuseboard_total_current, test_time,
joint_limit_extension, result_base_folder,
plot, plot_server):
"""
If on a fuse max temperature is reached, HAL is supposed to cut the
stiffness on all the joints behind the considered fuse.
To add in /media/internal/DeviveInternalHeadGeode.xml before the test:
<Preference name="Key15"
memoryName="RobotConfig/Head/MinMaxChangeAllowed" description=""
value="1" type="string" />
"""
# logger initialization
log = logging.getLogger('MULTIFUSEBOARD_PERF_HW_01')
# erasing real time curves
if plot:
plot_server.curves_erase()
# flag initialization
flag_loop = True
flag_key = True
fuse_state = True
flag_ambiant_temperature = True
flag_fuse_status = True
flag_first_overshoot = False
flag_protection_on = False
# flags
(flag1, flag2, flag3) = (False, False, False)
# objects creation
fuse_temperature = fuse["FuseTemperature"]
fuse_current = fuse["FuseCurrent"]
fuse_voltage = fuse["FuseVoltage"]
fuse_resistor = fuse["FuseResistor"]
battery = subdevice.BatteryChargeSensor(dcm, mem)
log.info("")
log.info("***********************************************")
log.info("Testing fuse : " + str(fuse_temperature.part))
log.info("***********************************************")
log.info("")
# checking that ALMemory key MinMaxChange Allowed = 1
if int(mem.getData("RobotConfig/Head/MinMaxChangeAllowed")) != 1:
flag_loop = False
flag_key = False
log.error("MinMaxChangeAllowed ALMemory key missing")
# setting fuse temperature min and max
fuse_temperature_max = fuse_temperature.maximum
fuse_temperature_min = fuse_temperature.minimum
fuse_temperature_mid = (fuse_temperature_max +
fuse_temperature_min) / 2.
# setting fuse temperature min and max for hysteresis
fuse_temperature_max_hyst = fuse_temperature_max - 10
log.debug("fuse_temperature_max_hyst = " +
str(fuse_temperature_max_hyst))
fuse_temperature_min_hyst = fuse_temperature_min - 10
log.debug("fuse_temperature_min_hyst = " +
str(fuse_temperature_min_hyst))
fuse_temperature_mid_hyst = fuse_temperature_mid - 10
log.debug("fuse_temperature_mid_hyst = " +
str(fuse_temperature_mid_hyst))
# position dictionnary creation with normal min or max
state = \
qha_tools.read_section(
"multifuse_scenario4.cfg", fuse_temperature.part)
# creating joint list
joint_list = state.keys()
log.info("Joints to use are : " + str(joint_list))
# max stiffness is set on all joints except for LegFuse
if fuse_temperature.part == "LegFuse":
# stiff joints
qha_tools.stiff_joints_proportion(dcm, mem, joint_list, 1.0)
# stiff wheels
for wheel in wheel_objects:
wheel.stiffness.qqvalue = 1.0
wheel.speed.actuator.qvalue = \
(wheel.speed.actuator.maximum, 5000)
else:
qha_tools.stiff_joints_proportion(dcm, mem, joint_list, 1.0)
# defining increment in radians
increment = math.radians(joint_limit_extension)
# modifying max or min position and put the joint in that position
# it makes current rise a lot
for joint, value in state.items():
joint_object = subdevice.JointPositionActuator(dcm, mem, joint)
if value[0] == 'max':
new_maximum_angle = joint_object.maximum + increment
else:
new_maximum_angle = joint_object.minimum - increment
joint_object.maximum = [[[new_maximum_angle,
dcm.getTime(0)]], "Merge"]
joint_object.qvalue = (new_maximum_angle, 10000)
# logger creation
logger = qha_tools.Logger()
# list object creation
joint_hardness_list = \
[subdevice.JointHardnessActuator(dcm, mem, x) for x in joint_list]
joint_current_list = \
[subdevice.JointCurrentSensor(dcm, mem, joint)
for joint in joint_list]
# loop timer creation
timer = qha_tools.Timer(dcm, test_time)
# test loop
while flag_loop and timer.is_time_not_out():
try:
loop_time = timer.dcm_time() / 1000.
fuse_temperature_status = fuse_temperature.status
fuse_temperature_value = fuse_temperature.value
fuse_current_value = fuse_current.value
fuse_voltage_value = fuse_voltage.value
fuse_resistor_value = fuse_resistor.value
fuse_resistor_calculated = fuse_voltage_value / \
fuse_current_value
battery_total_voltage = battery.total_voltage
multifuseboard_ambiant_tmp = \
multi_fuseboard_ambiant_tmp.value
multifuseboard_total_current = \
multi_fuseboard_total_current.value
stiffness_decrease = mem.getData(
"Device/SubDeviceList/FuseProtection/"+\
"StiffnessDecrease/Value")
stiffness_decrease_immediate = mem.getData(
"Device/SubDeviceList/FuseProtection/"+\
"StiffnessDecreaseImmediate/Value")
listeofparams = [("Time", loop_time),
("MultifuseBoardAmbiantTemperature",
multifuseboard_ambiant_tmp),
("MultifuseBoardTotalCurrent",
multifuseboard_total_current),
("FuseTemperature", fuse_temperature_value),
("FuseCurrent", fuse_current_value),
("FuseVoltage", fuse_voltage_value),
("FuseResistor", fuse_resistor_value),
("FuseResistorCalculated",
fuse_resistor_calculated),
("BatteryVoltage", battery_total_voltage),
("Status", fuse_temperature_status),
("StiffnessDecrease", stiffness_decrease),
("StiffnessDecreaseImmediate",
stiffness_decrease_immediate),
("FuseTemperatureMin", fuse_temperature_min),
("FuseTemperatureMid", fuse_temperature_mid),
("FuseTemperatureMax", fuse_temperature_max)]
for joint_hardness in joint_hardness_list:
new_tuple = \
(joint_hardness.header_name, joint_hardness.value)
listeofparams.append(new_tuple)
for joint_current in joint_current_list:
new_tuple = (joint_current.header_name,
joint_current.value)
listeofparams.append(new_tuple)
for wheel in wheel_objects:
new_tuple = (wheel.short_name + "_Current",
wheel.current.value)
listeofparams.append(new_tuple)
# Logging informations
logger.log_from_list(listeofparams)
# for real time plot
if plot:
plot_server.add_point("MultifuseBoardAmbiantTemperature",
loop_time,
multifuseboard_ambiant_tmp)
plot_server.add_point("MultifuseBoardTotalCurrent",
loop_time,
multifuseboard_total_current)
plot_server.add_point("FuseTemperature", loop_time,
fuse_temperature_value)
plot_server.add_point("FuseCurrent", loop_time,
fuse_current_value)
plot_server.add_point("FuseVoltage", loop_time,
fuse_voltage_value)
plot_server.add_point("FuseResistor", loop_time,
fuse_resistor_value)
plot_server.add_point("FuseResistorCalculated", loop_time,
fuse_resistor_calculated)
plot_server.add_point("BatteryVoltage", loop_time,
battery_total_voltage)
plot_server.add_point("Status", loop_time,
fuse_temperature_status)
plot_server.add_point("StiffnessDecrease", loop_time,
stiffness_decrease)
plot_server.add_point("StiffnessDecreaseImmediate",
loop_time,
stiffness_decrease_immediate)
# Checking REQ_FUSE_TEMPERATURE_002
if fuse_temperature_value < multifuseboard_ambiant_tmp:
flag_ambiant_temperature = False
log.info("Fuse temperature is lower than MultiFuseBoard" +\
"ambiant temperature")
# Checking REQ_FUSE_PERF_003
# Fuse status evolves correctly with its estimated temperature
# Hysteresis works correctly too
if fuse_temperature_value >= fuse_temperature_min:
flag1 = True
if fuse_temperature_mid < fuse_temperature_value <=\
fuse_temperature_max:
flag2 = True
if fuse_temperature_value >= fuse_temperature_max:
flag3 = True
if (flag1, flag2, flag3) == (False, False, False):
theorical_status = 0
elif (flag1, flag2, flag3) == (True, False, False):
theorical_status = 1
elif (flag1, flag2, flag3) == (True, True, False):
theorical_status = 2
elif (flag1, flag2, flag3) == (True, True, True):
theorical_status = 3
if theorical_status == 3 and fuse_temperature_value <=\
fuse_temperature_max_hyst:
theorical_status = 2
flag3 = False
if theorical_status == 2 and fuse_temperature_value <=\
fuse_temperature_mid_hyst:
theorical_status = 1
flag2 = False
if theorical_status == 1 and fuse_temperature_value <=\
fuse_temperature_min_hyst:
theorical_status = 0
flag1 = False
if fuse_temperature_status != theorical_status:
log.warning("!!! Fuse status problem !!!")
log.info("fuse temperature = " +\
str(fuse_temperature_value))
log.info("fuse status = " + str(fuse_temperature_status))
log.info("fuse theorical status = " +
str(theorical_status))
flag_fuse_status = False
# Indicating fuse first max temperature overshoot
if fuse_temperature_value >= fuse_temperature_max and not\
flag_first_overshoot:
flag_first_overshoot = True
log.info("First temperature overshoot")
timer_overshoot = qha_tools.Timer(dcm, 200)
# Indicating that protection worked
# Set stiffness actuator to 0 to let fuse cool down
if flag_first_overshoot and timer_overshoot.is_time_out()\
and not flag_protection_on and\
(stiffness_decrease_immediate == 0 or\
stiffness_decrease == 0):
log.info("Flag protection ON")
flag_protection_on = True
log.info("Concerned joints pluggin activated")
qha_tools.unstiff_joints(dcm, mem, joint_list)
# Checking REQ_FUSE_PERF_004
if flag_first_overshoot and\
timer_overshoot.is_time_out() and not\
flag_protection_on:
if fuse_temperature.part == "LegFuse":
if stiffness_decrease_immediate != 0:
fuse_state = False
log.warning("LegFuse protection NOK")
else:
if stiffness_decrease != 0:
fuse_state = False
log.warning(fuse_temperature.part +\
" protection NOK")
if flag_protection_on and fuse_temperature_value < 80.0:
flag_loop = False
log.info("End of test, fuse is cold enough")
except KeyboardInterrupt:
flag_loop = False # out of test loop
log.info("KeyboardInterrupt from user")
log.info("!!!! OUT OF TEST LOOP !!!!")
file_name = "_".join([str(fuse_temperature.part), str(fuse_state)])
result_file_path = "/".join([result_base_folder, file_name]) + ".csv"
logger.log_file_write(result_file_path)
# setting original min and max
log.info("Setting orininal min and max position actuator values...")
for joint, value in state.items():
joint_object = subdevice.JointPositionActuator(dcm, mem, joint)
if value[0] > 0:
joint_object.maximum = value[0]
joint_object.qvalue = (joint_object.maximum, 500)
else:
joint_object.minimum = value[0]
joint_object.qvalue = (joint_object.minimum, 500)
qha_tools.wait(dcm, 200)
log.info("Unstiff concerned joints")
qha_tools.unstiff_joints(dcm, mem, joint_list)
if fuse_temperature.part == "LegFuse":
for wheel in wheel_objects:
wheel.speed.actuator.qvalue = (0.0, 3000)
time.sleep(3.0)
wheel.stiffness.qqvalue = 0.0
assert flag_key
assert fuse_state
assert flag_fuse_status
assert flag_ambiant_temperature
def stiffness_off():
return qha_tools.read_section(PATH + "/global_test_configuration/"
"juliette_configuration.cfg", "stiffnessOff")
def zero_pos():
"""
Fixture which retrieves zero joints position from a configuration file.
"""
return qha_tools.read_section(PATH + "/global_test_configuration/"
"juliette_positions.cfg", "zero")
