Пример #1
0
 def setUp(self):
     self.od = canopen.import_od(EDS_PATH, 2)
Пример #2
0
 def test_load_nonexisting_file(self):
     with self.assertRaises(IOError):
         canopen.import_od('/path/to/wrong_file.eds')
Пример #3
0
 def test_load_file_object(self):
     od = canopen.import_od(open(EDS_PATH))
     self.assertTrue(len(od) > 0)
Пример #4
0
    def test_export_eds(self):
        import tempfile
        for doctype in {"eds", "dcf"}:
            with tempfile.NamedTemporaryFile(suffix="." + doctype,
                                             mode="w+") as tempeds:
                print("exporting %s to " % doctype + tempeds.name)
                canopen.export_od(self.od, tempeds, doc_type=doctype)
                tempeds.flush()
                exported_od = canopen.import_od(tempeds.name)

                for index in exported_od:
                    self.assertIn(exported_od[index].name, self.od)
                    self.assertIn(index, self.od)

                for index in self.od:
                    if index < 0x0008:
                        # ignore dummies
                        continue
                    self.assertIn(self.od[index].name, exported_od)
                    self.assertIn(index, exported_od)

                    actual_object = exported_od[index]
                    expected_object = self.od[index]
                    self.assertEqual(type(actual_object),
                                     type(expected_object))
                    self.assertEqual(actual_object.name, expected_object.name)

                    if type(actual_object
                            ) is canopen.objectdictionary.Variable:
                        expected_vars = [expected_object]
                        actual_vars = [actual_object]
                    else:
                        expected_vars = [
                            expected_object[idx] for idx in expected_object
                        ]
                        actual_vars = [
                            actual_object[idx] for idx in actual_object
                        ]

                    for prop in [
                            "allowed_baudrates",
                            "vendor_name",
                            "vendor_number",
                            "product_name",
                            "product_number",
                            "revision_number",
                            "order_code",
                            "simple_boot_up_master",
                            "simple_boot_up_slave",
                            "granularity",
                            "dynamic_channels_supported",
                            "group_messaging",
                            "nr_of_RXPDO",
                            "nr_of_TXPDO",
                            "LSS_supported",
                    ]:
                        self.assertEqual(
                            getattr(self.od.device_information, prop),
                            getattr(exported_od.device_information, prop),
                            f"prop {prop!r} mismatch on DeviceInfo")

                    for evar, avar in zip(expected_vars, actual_vars):
                        self.assertEqual(
                            getattr(avar, "data_type", None),
                            getattr(evar, "data_type",
                                    None), " mismatch on %04X:%X" %
                            (evar.index, evar.subindex))
                        self.assertEqual(
                            getattr(avar, "default_raw", None),
                            getattr(evar, "default_raw",
                                    None), " mismatch on %04X:%X" %
                            (evar.index, evar.subindex))
                        self.assertEqual(
                            getattr(avar, "min", None),
                            getattr(evar, "min",
                                    None), " mismatch on %04X:%X" %
                            (evar.index, evar.subindex))
                        self.assertEqual(
                            getattr(avar, "max", None),
                            getattr(evar, "max",
                                    None), " mismatch on %04X:%X" %
                            (evar.index, evar.subindex))
                        if doctype == "dcf":
                            self.assertEqual(
                                getattr(avar, "value", None),
                                getattr(evar, "value",
                                        None), " mismatch on %04X:%X" %
                                (evar.index, evar.subindex))

                        self.assertEqual(self.od.comments,
                                         exported_od.comments)