rccn-gen 1.0.1__py3-none-any.whl → 1.0.3__py3-none-any.whl

rccn_gen/__init__.py

@@ -1,6 +1,5 @@
 from .systems import *
 from .utils import *
-from .telemetry import *
 
 __version__ = "0.1.0"
 

rccn_gen/systems.py

@@ -1,11 +1,10 @@
-from yamcs.pymdb import System, Subsystem, Command
+from yamcs.pymdb import System, Subsystem, Command, Container
 import shutil
 import difflib
 import datetime
+from caseconverter import *
 from importlib.resources import files
 from .utils import *
-from .telemetry import *
-
 
 class Application(Subsystem):
     """
@@ -47,12 +46,12 @@ class Application(Subsystem):
     
     def file_paths(self):
         paths = {
-            'main': os.path.join(self.export_file_path, 'rccn_usr_'+to_snake_case(self.name), 'src', 'main.rs'),
-            'main_generated_snapshot': os.path.join(self.snapshot_file_path, 'generated', 'rccn_usr_'+to_snake_case(self.name), 'src', 'main.rs'),
-            'main_user_snapshot': os.path.join(self.user_snapshot_path(), 'rccn_usr_'+to_snake_case(self.name), 'src', 'main.rs'),
-            'main_diff': os.path.join(self.diff_file_path, 'rccn_usr_'+to_snake_case(self.name), 'src', 'main.diff'),
+            'main': os.path.join(self.export_file_path, 'rccn_usr_'+snakecase(self.name), 'src', 'main.rs'),
+            'main_generated_snapshot': os.path.join(self.snapshot_file_path, 'generated', 'rccn_usr_'+snakecase(self.name), 'src', 'main.rs'),
+            'main_user_snapshot': os.path.join(self.user_snapshot_path(), 'rccn_usr_'+snakecase(self.name), 'src', 'main.rs'),
+            'main_diff': os.path.join(self.diff_file_path, 'rccn_usr_'+snakecase(self.name), 'src', 'main.diff'),
             'main_template': os.path.join(self.text_modules_main_path, 'main.txt'),
-            'cargo_toml': os.path.join(self.export_file_path, 'rccn_usr_'+to_snake_case(self.name), 'Cargo.toml'),
+            'cargo_toml': os.path.join(self.export_file_path, 'rccn_usr_'+snakecase(self.name), 'Cargo.toml'),
             'cargo_toml_template': os.path.join(self.text_modules_path, 'cargo_toml', 'cargo.txt'),
         }
         return paths
@@ -64,11 +63,11 @@ class Application(Subsystem):
         return [subsystem for subsystem in self.subsystems if isinstance(subsystem, Service)]
 
     def create_rccn_directories(self):
-        app_src_dir = os.path.join(self.export_file_path, 'rccn_usr_'+to_snake_case(self.name), 'src')
+        app_src_dir = os.path.join(self.export_file_path, 'rccn_usr_'+snakecase(self.name), 'src')
         if not os.path.exists(app_src_dir):
             os.makedirs(app_src_dir)
         for service in self.services():
-            service_dir = os.path.join(app_src_dir, to_snake_case(service.name))
+            service_dir = os.path.join(app_src_dir, snakecase(service.name))
             if not os.path.exists(service_dir):
                 os.makedirs(service_dir)
 
@@ -101,7 +100,7 @@ class Application(Subsystem):
         var_translation = {
             '<<VAR_APID>>':str(self.apid),
             '<<VAR_VCID>>':str(self.vcid),
-            '<<VAR_APP_NAME_SCASE>>':to_snake_case(self.name),
+            '<<VAR_APP_NAME_SCASE>>':snakecase(self.name),
         }
         var_keywords = get_var_keywords(text)
         for var_keyword in var_keywords:
@@ -128,7 +127,7 @@ class Application(Subsystem):
             if not os.path.exists(service.file_paths()['mod']):
                 service.generate_mod_file()
             service.generate_telemetry_file()
-            service.generate_rccn_command_file(os.path.join(self.export_file_path, 'rccn_usr_'+to_snake_case(self.name), 'src'), os.path.join(self.text_modules_path, 'command'))
+            service.generate_rccn_command_file(os.path.join(self.export_file_path, 'rccn_usr_'+snakecase(self.name), 'src'), os.path.join(self.text_modules_path, 'command'))
         self.delete_old_snapshots()
 
     def generate_snapshot(self, current_file_reference, snapshot_file_reference):
@@ -236,22 +235,22 @@ class Service(Subsystem):
     
     def file_paths(self):
         paths = {
-            'service': os.path.join(self.export_file_path, 'rccn_usr_'+to_snake_case(self.system.name), 'src', to_snake_case(self.name), 'service.rs'),
-            'service_generated_snapshot': os.path.join(self.snapshot_file_path, 'generated', 'rccn_usr_'+to_snake_case(self.system.name), 'src', to_snake_case(self.name), 'service.rs'),
-            'service_user_snapshot': os.path.join(self.snapshot_file_path, 'user', datetime.datetime.now().strftime("%Y-%m-%d_%H-%M-%S"), 'rccn_usr_'+to_snake_case(self.system.name), 'src', to_snake_case(self.name), 'service.rs'),
-            'service_diff': os.path.join(self.diff_file_path, 'rccn_usr_'+to_snake_case(self.system.name), 'src', to_snake_case(self.name), 'service.diff'),
+            'service': os.path.join(self.export_file_path, 'rccn_usr_'+snakecase(self.system.name), 'src', snakecase(self.name), 'service.rs'),
+            'service_generated_snapshot': os.path.join(self.snapshot_file_path, 'generated', 'rccn_usr_'+snakecase(self.system.name), 'src', snakecase(self.name), 'service.rs'),
+            'service_user_snapshot': os.path.join(self.snapshot_file_path, 'user', datetime.datetime.now().strftime("%Y-%m-%d_%H-%M-%S"), 'rccn_usr_'+snakecase(self.system.name), 'src', snakecase(self.name), 'service.rs'),
+            'service_diff': os.path.join(self.diff_file_path, 'rccn_usr_'+snakecase(self.system.name), 'src', snakecase(self.name), 'service.diff'),
             'service_template': os.path.join(self.text_modules_service_path, 'service.txt'),
-            'command': os.path.join(self.export_file_path, 'rccn_usr_'+to_snake_case(self.system.name), 'src', to_snake_case(self.name), 'command.rs'),
-            'command_generated_snapshot': os.path.join(self.snapshot_file_path, 'generated', 'rccn_usr_'+to_snake_case(self.system.name), 'src', to_snake_case(self.name), 'command.rs'),
-            'command_user_snapshot': os.path.join(self.snapshot_file_path, 'user', datetime.datetime.now().strftime("%Y-%m-%d_%H-%M-%S"), 'rccn_usr_'+to_snake_case(self.system.name), 'src', to_snake_case(self.name), 'command.rs'),
-            'command_diff': os.path.join(self.diff_file_path, 'rccn_usr_'+to_snake_case(self.system.name), 'src', to_snake_case(self.name), 'command.diff'),
+            'command': os.path.join(self.export_file_path, 'rccn_usr_'+snakecase(self.system.name), 'src', snakecase(self.name), 'command.rs'),
+            'command_generated_snapshot': os.path.join(self.snapshot_file_path, 'generated', 'rccn_usr_'+snakecase(self.system.name), 'src', snakecase(self.name), 'command.rs'),
+            'command_user_snapshot': os.path.join(self.snapshot_file_path, 'user', datetime.datetime.now().strftime("%Y-%m-%d_%H-%M-%S"), 'rccn_usr_'+snakecase(self.system.name), 'src', snakecase(self.name), 'command.rs'),
+            'command_diff': os.path.join(self.diff_file_path, 'rccn_usr_'+snakecase(self.system.name), 'src', snakecase(self.name), 'command.diff'),
             'command_template': os.path.join(self.text_modules_command_path, 'command.txt'),
-            'mod': os.path.join(self.export_file_path, 'rccn_usr_'+to_snake_case(self.system.name), 'src', to_snake_case(self.name), 'mod.rs'),
+            'mod': os.path.join(self.export_file_path, 'rccn_usr_'+snakecase(self.system.name), 'src', snakecase(self.name), 'mod.rs'),
             'mod_template': os.path.join(self.text_modules_path, 'mod', 'mod.txt'),
-            'telemetry': os.path.join(self.export_file_path, 'rccn_usr_'+to_snake_case(self.system.name), 'src', to_snake_case(self.name), 'telemetry.rs'),
-            'telemetry_generated_snapshot': os.path.join(self.snapshot_file_path, 'generated', 'rccn_usr_'+to_snake_case(self.system.name), 'src', to_snake_case(self.name), 'telemetry.rs'),
-            'telemetry_user_snapshot': os.path.join(self.snapshot_file_path, 'user', datetime.datetime.now().strftime("%Y-%m-%d_%H-%M-%S"), 'rccn_usr_'+to_snake_case(self.system.name), 'src', to_snake_case(self.name), 'command.rs'),
-            'telemetry_diff': os.path.join(self.diff_file_path, 'rccn_usr_'+to_snake_case(self.system.name), 'src', to_snake_case(self.name), 'telemetry.diff'),
+            'telemetry': os.path.join(self.export_file_path, 'rccn_usr_'+snakecase(self.system.name), 'src', snakecase(self.name), 'telemetry.rs'),
+            'telemetry_generated_snapshot': os.path.join(self.snapshot_file_path, 'generated', 'rccn_usr_'+snakecase(self.system.name), 'src', snakecase(self.name), 'telemetry.rs'),
+            'telemetry_user_snapshot': os.path.join(self.snapshot_file_path, 'user', datetime.datetime.now().strftime("%Y-%m-%d_%H-%M-%S"), 'rccn_usr_'+snakecase(self.system.name), 'src', snakecase(self.name), 'command.rs'),
+            'telemetry_diff': os.path.join(self.diff_file_path, 'rccn_usr_'+snakecase(self.system.name), 'src', snakecase(self.name), 'telemetry.diff'),
             'telemetry_template': os.path.join(self.text_modules_telemetry_path, 'telemetry.txt'),
         } 
         return paths
@@ -282,14 +281,14 @@ class Service(Subsystem):
         # Find and replace service variable keywords
         var_keywords = get_var_keywords(text)
         service_var_translation = {
-            '<<VAR_SERVICE_NAME>>': self.name,
-            '<<VAR_SERVICE_ID>>': str(self.service_id),
-            '<<VAR_SERVICE_NAME_UCASE>>': to_upper_camel_case(self.name),
-            '<<VAR_SERVICE_TELEMETRY>>': self.generate_rust_telemetry_definition(),
+            '<<VAR_SERVICE_NAME>>': lambda: self.name,
+            '<<VAR_SERVICE_ID>>': lambda: str(self.service_id),
+            '<<VAR_SERVICE_NAME_UCASE>>': lambda: pascalcase(self.name),
+            '<<VAR_SERVICE_TELEMETRY>>': lambda: self.generate_rust_telemetry_definition(),
         }
         for var_keyword in var_keywords:
             if var_keyword in service_var_translation.keys():
-                text = replace_with_indentation(text, var_keyword, service_var_translation[var_keyword])
+                text = replace_with_indentation(text, var_keyword, service_var_translation[var_keyword]())
         
         # Delete all command module keywords
         text = delete_all_command_module_keywords(text)
@@ -331,7 +330,7 @@ class Service(Subsystem):
         command_file_path = self.file_paths()['command_template']
         with open(command_file_path, 'r') as file:
             command_file_text = file.read()
-        command_export_file_path = os.path.join(export_file_dir, to_snake_case(self.name), 'command.rs')
+        command_export_file_path = os.path.join(export_file_dir, snakecase(self.name), 'command.rs')
         with open(command_export_file_path, 'w') as file:
             file.write(self.find_and_replace_keywords(command_file_text, text_modules_path))
         # Create snapshot of command.rs if instructed
@@ -384,7 +383,8 @@ class Service(Subsystem):
     def generate_rust_telemetry_definition(self):
         telemetry_definition_text = ''
         for container in self.containers:
-            container.__class__ = RCCNContainer
+            if not isinstance(container, RCCNContainer):
+                container.__class__ = RCCNContainer
             telemetry_definition_text += container.generate_rccn_telemetry()
         return telemetry_definition_text
 
@@ -430,14 +430,14 @@ class RCCNCommand(Command):
         # Find and replace command variable keywords
         command_var_keywords = get_var_keywords(text)
         command_var_translation = {
-            '<<VAR_COMMAND_NAME_UCASE>>': to_upper_camel_case(self.name),
-            '<<VAR_COMMAND_NAME>>': self.name,
-            '<<VAR_COMMAND_SUBTYPE>>': str(self.assignments['subtype']),
-            '<<VAR_COMMAND_STRUCT>>': self.struct_definition()
+            '<<VAR_COMMAND_NAME_UCASE>>': lambda: pascalcase(self.name),
+            '<<VAR_COMMAND_NAME>>': lambda: self.name,
+            '<<VAR_COMMAND_SUBTYPE>>': lambda: str(self.assignments['subtype']),
+            '<<VAR_COMMAND_STRUCT>>': lambda: self.struct_definition()
         }
         for command_var_keyword in command_var_keywords:
             if command_var_keyword in command_var_translation.keys():
-                text = replace_with_indentation(text, command_var_keyword, command_var_translation[command_var_keyword])
+                text = replace_with_indentation(text, command_var_keyword, command_var_translation[command_var_keyword]())
         return text
     
     def check_user_input(self):
@@ -450,12 +450,16 @@ class RCCNCommand(Command):
     def struct_definition(self):
         if len(self.arguments) == 0:
             return ''
-        struct_definition_text = "#[derive(BitStruct, Debug, PartialEq)]\npub struct "+to_upper_camel_case(self.name)+" {\n"
+        struct_definition_text = "#[derive(BitStruct, Debug, PartialEq)]\npub struct "+pascalcase(self.name)+" {\n"
+        ins = ""
+        append = ""
         for argument in self.arguments:
-            struct_definition_text += rust_type_definition(argument)[0]
+            arg_def = rust_type_definition(argument)
+            ins += arg_def[0]
+            append += arg_def[1]
+        struct_definition_text += ins
         struct_definition_text += "}\n"
-        for argument in self.arguments:
-            struct_definition_text += rust_type_definition(argument)[1]
+        struct_definition_text += append
         return struct_definition_text
 
 class RCCNContainer(Container):
@@ -474,11 +478,12 @@ class RCCNContainer(Container):
 
     def generate_rccn_telemetry(self):
         rccn_telemetry_text = "pub struct " + self.name + " {\n"
+        insert, append = ["",""]
         for parameter_entry in self.entries:
-            rccn_telemetry_text += rust_type_definition(parameter_entry.parameter)[0]
-            #rccn_telemetry_text += parameter_entry.generate_rccn_telemetry()[0]
+            par_def = rust_type_definition(parameter_entry.parameter)
+            insert += par_def[0]
+            append += par_def[1]
+        rccn_telemetry_text += insert
         rccn_telemetry_text += "}\n"
-        for parameter_entry in self.entries:
-            rccn_telemetry_text += rust_type_definition(parameter_entry.parameter)[1]
-        
+        rccn_telemetry_text += append        
         return rccn_telemetry_text

rccn_gen/utils.py

@@ -1,6 +1,7 @@
 import re
 import inflect
 import os
+from caseconverter import *
 from yamcs.pymdb import IntegerArgument, FloatArgument, BooleanArgument, EnumeratedArgument, StringArgument
 
 
@@ -130,8 +131,8 @@ def rust_type_definition(pymdb_data_instance, parent_name="MyStruct"):
             pymdb_data_instance.name = parent_name
         else:
             pymdb_data_instance.name = singular_name
-        print("RCCN-Gen: Information: An unnamed "+base_type+" has been named \""+to_upper_camel_case(pymdb_data_instance.name)+"\" in the generated RCCN code.")
-    sc_instance_name = to_snake_case(pymdb_data_instance.name)
+        print("RCCN-Gen: Information: An unnamed "+base_type+" has been named \""+pascalcase(pymdb_data_instance.name)+"\" in the generated RCCN code.")
+    sc_instance_name = snakecase(pymdb_data_instance.name)
 
     if data_type == 'IntegerDataType':
         if pymdb_data_instance.encoding is None or pymdb_data_instance.encoding.bits is None:
@@ -161,22 +162,24 @@ def rust_type_definition(pymdb_data_instance, parent_name="MyStruct"):
         definition_text[0] = definition_text[0].replace(': ', ': Vec<').replace(',\n', '>,\n')
     
     elif data_type == 'EnumeratedDataType':
-        definition_text = ["\tpub "+pymdb_data_instance.name+": "+to_upper_camel_case(pymdb_data_instance.name)+",\n"]
-        definition_text.append("pub enum "+to_upper_camel_case(pymdb_data_instance.name)+" {\n")
+        definition_text = ["\tpub "+pymdb_data_instance.name+": "+pascalcase(pymdb_data_instance.name)+",\n"]
+        definition_text.append("pub enum "+pascalcase(pymdb_data_instance.name)+" {\n")
         for choice in pymdb_data_instance.choices:
             definition_text[1] += "\t"+str(choice[1])+" = "+str(choice[0])+",\n"
         definition_text[1] += "}\n"
     
     elif data_type == 'AggregateDataType':
-        struct_name = to_upper_camel_case(pymdb_data_instance.name)
+        struct_name = pascalcase(pymdb_data_instance.name)
         definition_text = ["\tpub "+sc_instance_name+": "+struct_name+",\n"]
         definition_text.append("pub struct "+struct_name+" {\n")
+        insert, append = ["",""]
         for member in pymdb_data_instance.members:
-            definition_text[1] += rust_type_definition(member, parent_name=pymdb_data_instance.name)[0]
+            mem_def = rust_type_definition(member, parent_name=pymdb_data_instance.name)
+            insert += mem_def[0]
+            append += mem_def[1]
+        definition_text[1] += insert
         definition_text[1] += "}\n"
-        for member in pymdb_data_instance.members:
-            definition_text[1] += rust_type_definition(member, parent_name=pymdb_data_instance.name)[1]
-
+        definition_text[1] += append
     else:
         definition_text = ["\t// Please implement datatype "+data_type+" here.\n", ""]
     return definition_text

{rccn_gen-1.0.1.dist-info → rccn_gen-1.0.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rccn_gen
-Version: 1.0.1
+Version: 1.0.3
 Summary: A python based generator for RACCOON OS source files in Rust from yamcs-pymdb config files.
 Project-URL: Homepage, https://gitlab.com/rccn/pymdb_code_generation
 Project-URL: Issues, https://gitlab.com/rccn/pymdb_code_generation/issues
@@ -9,6 +9,8 @@ License-Expression: GPL-3.0
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Requires-Python: >=3.8
+Requires-Dist: case-converter>=1.2.0
+Requires-Dist: inflect>=7.5.0
 Requires-Dist: yamcs-pymdb>=0.1.0
 Description-Content-Type: text/markdown
 

{rccn_gen-1.0.1.dist-info → rccn_gen-1.0.3.dist-info}/RECORD

@@ -1,10 +1,7 @@
 rccn_gen/LICENSE,sha256=ixuiBLtpoK3iv89l7ylKkg9rs2GzF9ukPH7ynZYzK5s,35148
-rccn_gen/__init__.py,sha256=XVvKYcWw9K1P3J1BTbzbODY71Nc1FApCc0wf7ezd4Gc,193
-rccn_gen/application.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-rccn_gen/service.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-rccn_gen/systems.py,sha256=oLm0_jcxV0MZ3Bg7YsCraQ_zTj_yD_geoQpdJs_ATys,26898
-rccn_gen/telemetry.py,sha256=huVcqGs95IXlpETWdlIyR9lK4ctZUsq7czgJwvTYtBk,3855
-rccn_gen/utils.py,sha256=tBzL6ZCSpjYnz4vtV7vzIAT6lcemCtIqxrmWMtzPEZU,7302
+rccn_gen/__init__.py,sha256=rBnqIw3uQk-uBbRh9VnungoTRSr2V0Bqos32xFZ44Eo,168
+rccn_gen/systems.py,sha256=D_AqspMI3VTyHbV3cmi6uizlZSKgmOHq21ASXoG-9vk,26863
+rccn_gen/utils.py,sha256=FHNatrkeyjF1qxyw3_o5cvNjIX9SXrEWRD9ugj-qtSo,7292
 rccn_gen/text_modules/cargo_toml/cargo.txt,sha256=2e6xKomkml6-onfQ0QHNqvKnhGLYMUl8zYgbykmm83Y,292
 rccn_gen/text_modules/command/command.txt,sha256=8Y-uJilhFLoinftIbn7uKfia9LLMZno2LkoDJ-4Y-9M,345
 rccn_gen/text_modules/command/command_module_enum.txt,sha256=ApzRDQIs-BHJHtFA4ysfpYuWElGntXakkzZkgy57b74,94
@@ -17,6 +14,6 @@ rccn_gen/text_modules/mod/mod.txt,sha256=BF8LablBE4ddutdl5m0prvpvLdBRejueVOujkyr
 rccn_gen/text_modules/service/command_module_match_cmd.txt,sha256=eVGo6ltuerG37rVxpXtL-JYuLyLW4c0i6NXb5g1_U-A,89
 rccn_gen/text_modules/service/service.txt,sha256=0KwwrfrjXuY4e3VNpCdTTzgW8bmYRQ21i-Lvhkz3hVA,691
 rccn_gen/text_modules/telemetry/telemetry.txt,sha256=Re1d3BfpyXT_CEe7jJzLF3MARik0-J-K98K85iPOE40,193
-rccn_gen-1.0.1.dist-info/METADATA,sha256=dm4UtqPyzUKNv_hnmprPaSmQtRrjE-lCuU-X_O9wnHc,8193
-rccn_gen-1.0.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-rccn_gen-1.0.1.dist-info/RECORD,,
+rccn_gen-1.0.3.dist-info/METADATA,sha256=Z4LaK07eqhpSDcv-4rRO2hIerglzl6rUubE2CvtnVOs,8260
+rccn_gen-1.0.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+rccn_gen-1.0.3.dist-info/RECORD,,

rccn_gen/telemetry.py

@@ -1,83 +0,0 @@
-from yamcs.pymdb import Container, ParameterEntry, AggregateParameter, ArrayParameter, BinaryParameter, StringParameter, BooleanParameter, FloatParameter, IntegerParameter, StringMember, EnumeratedMember
-from .utils import *
-    
-
-def generate_rccn_parameter_telemetry(parameter):
-    sc_parameter_name = to_snake_case(parameter.name)
-
-    if isinstance(parameter, ArrayParameter):
-        struct_name = to_upper_camel_case(parameter.name)
-        telemetry = ["\tpub "+sc_parameter_name+": Vec<"+struct_name+">,\n"]
-        telemetry.append("pub struct "+struct_name+" {\n")
-        for member in parameter.data_type.members:
-            telemetry[1] += generate_rccn_member_telementry(member)[0]
-        telemetry[1] += "}\n"
-        for member in parameter.data_type.members:
-            telemetry[1] += generate_rccn_member_telementry(member)[1]
-
-    elif isinstance(parameter, BooleanParameter):
-        telemetry = ["\t#[bits(1)]\n\tpub "+sc_parameter_name+": bool,\n"]
-        telemetry.append("")
-
-    elif isinstance(parameter, IntegerParameter):
-        if parameter.encoding is None or parameter.encoding.bits is None:
-            raw_bit_number_str = '8'
-            print("Warning: No encoding for parameter "+parameter.name+" found. Using 8 as default for raw bit number.")
-        else:
-            raw_bit_number = parameter.encoding.bits
-            raw_bit_number_str = str(raw_bit_number)
-            eng_bit_number = engineering_bit_number(raw_bit_number)
-            eng_bit_number_str = str(eng_bit_number)
-        telemetry = ["\t#[bits("+raw_bit_number_str+")]\n"]
-        if parameter.signed:
-            telemetry[0] += ("\tpub "+sc_parameter_name+": i"+eng_bit_number_str+",\n")
-        else:
-            telemetry += ("\tpub "+sc_parameter_name+": u"+eng_bit_number_str+",\n")
-        telemetry.append("")
-
-    elif isinstance(parameter, StringParameter):
-        telemetry = ["#[null_terminated]\npub "+sc_parameter_name+": String,\n"]
-        telemetry.append("")
-
-    else:
-        telemetry = ["\t// Please implement datatype "+type(parameter).__name__+" here.\n", ""]
-    return telemetry
-
-def generate_rccn_member_telementry(member):
-    sc_member_name = to_snake_case(member.name)
-
-    if isinstance(member, StringMember):
-        member_telemetry = ["#[null_terminated]\n\tpub "+member.name+": String,\n"]
-        member_telemetry.append("")
-
-    elif isinstance(member, EnumeratedMember):
-        member_telemetry = ["\tpub "+member.name+": "+to_upper_camel_case(member.name)+",\n"]
-        member_telemetry.append("pub enum "+to_upper_camel_case(member.name)+" {\n")
-        for choice in member.choices:
-            member_telemetry[1] += "\t"+str(choice[1])+" = "+str(choice[0])+",\n"
-        member_telemetry[1] += "}\n"
-
-    elif isinstance(member, BooleanParameter):
-        telemetry = ["pub "+sc_member_name+": bool,\n"]
-        telemetry.append("")
-
-    elif isinstance(member, IntegerParameter):
-        if member.encoding is None or member.encoding.bits is None:
-            raw_bit_number = 8
-            print("Warning: No encoding for member "+member.name+" found. Using 8 as default for raw bit number.")
-        else:
-            raw_bit_number = member.encoding.bits
-        raw_bit_number_str = str(raw_bit_number)
-        eng_bit_number = engineering_bit_number(raw_bit_number)
-        eng_bit_number_str = str(eng_bit_number)
-        telemetry = ["\t#[bits("+raw_bit_number_str+")]\n"]
-        if member.signed:
-            telemetry[0] += ("\tpub "+sc_member_name+": i"+eng_bit_number_str+",\n")
-        else:
-            telemetry += ("\tpub "+sc_member_name+": u"+eng_bit_number_str+",\n")
-        telemetry.append("")
-    
-    else:
-        member_telemetry[0] += "\t// Please implement datatype "+type(member).__name__+" here.\n"
-        member_telemetry.append("")
-    return member_telemetry