Merge branch 'main' of github.com:OpenCyphal/yukon

# Conflicts:
#	yukon/version.py

yukon/domain/avatar.py

@@ -272,6 +272,8 @@ def to_builtin(self) -> Any:
             software_version = getattr(info, "software_version")
             hardware_version = getattr(info, "hardware_version")
             software_vcs_revision_id = getattr(info, "software_vcs_revision_id")
+            if software_vcs_revision_id:
+                software_vcs_revision_id = hex(software_vcs_revision_id)
             software_major_version = getattr(software_version, "major", 0)
             software_minor_version = getattr(getattr(info, "software_version"), "minor", 0)
             hardware_major_version = getattr(hardware_version, "major", 0)
@@ -339,6 +341,16 @@ def to_builtin(self) -> Any:
             ^ hash(frozenset(self._ports.sub))
             ^ hash(frozenset(self._ports.cln))
             ^ hash(frozenset(self._ports.srv))
+            ^ hash(
+                json.dumps(
+                    {
+                        "vendor_specific_status_code": vendor_specific_status_code,
+                        "mode": mode_value,
+                        "health": health_value,
+                    },
+                    sort_keys=True,
+                )
+            )
             ^ hash(self._info.name.tobytes().decode() if self._info is not None else None)
             ^ hash(self.random_str_for_forced_update)  # This accounts for is_disappeared and is_being_queried
             ^ hash(self.disappeared_since)

yukon/services/utils.py

@@ -52,6 +52,7 @@ class Datatype:
     is_fixed_id: bool
     name: str
     class_reference: typing.Any
+    is_service: bool
 
     def __hash__(self) -> int:
         return hash(self.name)
@@ -115,6 +116,7 @@ def scan_package_look_for_classes(
                 break
             counter += 1
             module_or_class, previous_module_or_class = queue.get_nowait()
+            is_potentially_a_service = False
             # Get all modules and classes that are seen in the imported module
             elements = inspect.getmembers(module_or_class, lambda x: inspect.ismodule(x) or inspect.isclass(x))
             for element in elements:
@@ -133,7 +135,13 @@ def scan_package_look_for_classes(
                 except Exception:
                     logger.exception("Failed to get model for %s", _class)
                     continue
-                classes.append(Datatype(hasattr(_class, "_FIXED_PORT_ID_"), model.full_name, _class))
+                if _class.__name__ == "Request" or _class.__name__ == "Response":
+                    is_potentially_a_service = True
+                classes.append(
+                    Datatype(
+                        hasattr(_class, "_FIXED_PORT_ID_"), model.full_name, _class, is_service=is_potentially_a_service
+                    )
+                )
     except Empty:
         pass
     # logger.debug(f"Loop {loop_unique_id} took {time.time() - loop_start} seconds")
@@ -152,12 +160,14 @@ def get_datatype_return_dto(all_classes: typing.List[Datatype]) -> typing.Any:
                 return_object["fixed_id_messages"][str(datatype.class_reference._FIXED_PORT_ID_)] = {
                     "short_name": datatype.class_reference.__name__,
                     "name": datatype.name,
+                    "is_service": datatype.is_service,
                 }
             else:
                 return_object["variable_id_messages"].append(
                     {
                         "short_name": datatype.class_reference.__name__,
                         "name": datatype.name,
+                        "is_service": datatype.is_service,
                     }
                 )
         except Exception as e:

yukon/version.py

@@ -1 +1 @@
-__version__ = "2023.3.42"
+__version__ = "2023.3.44"

yukon/web/modules/context-menu.module.js

@@ -562,7 +562,7 @@ export function make_context_menus(yukon_state) {
                     },
                     click: async (e, elementOpenedOn) => {
                         const portNr = parseInt(elementOpenedOn.getAttribute("data-port"));
-                        const datatypes = await getDatatypesForPort(portNr, yukon_state);
+                        const datatypes = await getDatatypesForPort(portNr, "pub", yukon_state);
                         const response = await yukon_state.zubax_apij.make_simple_publisher_with_datatype_and_port_id(datatypes[0], portNr);
                         const portType = elementOpenedOn.getAttribute("data-port-type"); // sub or pub or cln or srv
                         if (response && response.success) {

yukon/web/modules/meanings.module.js

@@ -42,7 +42,7 @@ export function getLinkInfo(subject_id, node_id, yukon_state) {
     }
     return Array.from(new Set(infos));
 }
-export function getRelatedLinks(port, yukon_state) {
+export function getRelatedLinks(port, port_type, yukon_state) {
     let links = [];
     for (const avatar of yukon_state.current_avatars) {
         const registersKeys = Object.keys(avatar.registers_values);
@@ -56,11 +56,62 @@ export function getRelatedLinks(port, yukon_state) {
             const link_name = results[2];
             const value = avatar.registers_values[register_name];
             if (parseInt(value) === parseInt(port) && register_name.endsWith(".id")) {
+                if((port_type === "pub" || port_type === "sub") && (link_type === "cln" || link_type === "srv")) continue;
                 const datatype_key = registersKeys.find((a) => a.endsWith(link_name + ".type"));
                 const datatype = avatar.registers_values[datatype_key];
                 links.push({ name: link_name, node_id: avatar.node_id, "port": port, type: link_type, "register_name": register_name, "datatype": datatype });
             }
         }
     }
     return Array.from(new Set(links));
+}
+export function decodeTelegaVSSC(vssc) {
+    const high_number = vssc / 16;
+    const low_number = vssc % 16;
+    if (low_number !== 0) {
+        if(high_number === 0) {
+            return "Fault in Standby, fault code: " + low_number;
+        } else if (high_number == 1) {
+            // self test
+            return "Fault in Self test, fault code: " + low_number;
+        } else if (high_number == 2) {
+            return "Fault in Motor ID, fault code: " + low_number;
+        } else if (high_number == 5) {
+            // drive
+            if(low_number === 1) {
+                return "Torque control mode";
+            } else if(low_number === 2) {
+                return "Voltage control mode";
+            } else if(low_number === 3) {
+                return "Velocity control mode";
+            } else if(low_number === 9) {
+                // Ratiometric torque control mode
+                return "Ratiometric torque control mode";
+            } else if (low_number === 10) {
+                // Ratiometric voltage control mode
+                return "Ratiometric voltage control mode";
+            } else {
+                return "Fault in Drive, fault code: " + low_number;
+            }
+        } else if (high_number == 7) {
+            // servo
+            return "Fault in Servo, fault code: " + low_number;
+        }
+    } else {
+        if (high_number === 0) {
+            return "Standby";
+        } else if (high_number == 1) {
+            // self test
+            return "Self test";
+        } else if (high_number == 2) {
+            return "Motor ID";
+        } else if (high_number == 5) {
+            // drive
+            return "Drive";
+        } else if (high_number == 7) {
+            // servo
+            return "Servo";
+        }
+    }
+    return "Unknown code";
 }

yukon/web/modules/panels/monitor2/highlights.module.js

@@ -38,12 +38,12 @@ export function setPortStateAsUnhiglighted(portNr, yukon_state) {
 }
 export function highlightElement(element, color, settings, yukon_state) {
     if (element.classList.contains("arrowhead")) {
-        element.style.setProperty("border-top-color", color);
+        element.style.setProperty("border-top-color", color, "important");
     } else if (element.classList.contains("horizontal_line_label") && element.tagName === "LABEL") {
-        element.style.setProperty("background-color", settings.LinkLabelHighlightColor);
-        element.style.setProperty("color", settings.LinkLabelHighlightTextColor);
+        element.style.setProperty("background-color", settings.LinkLabelHighlightColor, "important");
+        element.style.setProperty("color", settings.LinkLabelHighlightTextColor, "important");
     } else if (element.classList.contains("horizontal_line") || element.classList.contains("line") || element.classList.contains("circle")) {
-        element.style.setProperty("background-color", color);
+        element.style.setProperty("background-color", color, "important");
     }
 }
 export function highlightElements(objects, settings, yukon_state) {