#!/usr/bin/python # -*- coding: utf-8 -*- import json import sys import os import argparse import glob #import cStringIO from sys import version_info if version_info.major == 3: import importlib importlib.reload(sys) elif version_info.major == 2: reload(sys) sys.setdefaultencoding("utf-8") try: import simplejson as json except: import json # {"version":"1.0","properties":[{"id":"light_switch","name":"电灯开关","desc":"控制电灯开灭","required":true,"mode":"rw","define":{"type":"bool","mapping":{"0":"关","1":"开"}}},{"id":"color","name":"颜色","desc":"灯光颜色","mode":"rw","define":{"type":"enum","mapping":{"0":"Red","1":"Green","2":"Blue"}}},{"id":"brightness","name":"颜色","desc":"灯光颜色","mode":"rw","define":{"type":"int","unit":"%","unitDesc":"亮度百分比","min":"0","max":"100"}},{"id":"name","name":"灯位置名称","desc":"灯位置名称：书房、客厅等","mode":"rw","required":true,"define":{"type":"string","min":"0","max":"64"}}]} class TEMPLATE_CONSTANTS: VERSION = "version" TYPE = "type" NAME = "name" ID = "id" MIN = "min" MAX = "max" DEFINE = "define" PROPERTIES = "properties" EVENTS = "events" MAPPING = "mapping" UNIT = "unit" UNITDESC = "unitDesc" REQUIRED = "required" MODE = "mode" class iot_enum: def __init__(self, parent, name, index): self.parent = parent self.id = name self.index = index def get_c_macro_name(self): return "e_{}_{}".format(self.parent.upper(), self.id.upper()) def get_define_str(self): return "#define {} {}".format(self.get_c_macro_name(), self.index) class iot_field: def __init__(self, prefix, id, name, index, field_obj): self.default_value = "" self.enums = [] self.index = index self.id = id self.prefix = prefix self.name = name self.type_name = field_obj["define"]["type"] if self.type_name == "bool": self.type_define = "TYPE_DEF_TEMPLATE_BOOL" self.type_id = "TYPE_TEMPLATE_BOOL" self.default_value = "0" elif self.type_name == "enum": self.type_define = "TYPE_DEF_TEMPLATE_ENUM" self.type_id = "TYPE_TEMPLATE_ENUM" if TEMPLATE_CONSTANTS.DEFINE not in field_obj: raise ValueError("错误：{} 字段定义中未找到枚举定义{} 字段".format(name, TEMPLATE_CONSTANTS.DEFINE)) enum_defs = field_obj["define"]["mapping"] for enum_id in enum_defs: enum_name = enum_defs[enum_id] current_enum = iot_enum(self.id, enum_name, enum_id) self.enums.append(current_enum) if self.default_value == "": self.default_value = enum_id if self.default_value == "": raise ValueError("错误：{} 字段默认值 {} 非法".format(name, field_obj["default"])) elif self.type_name == "float": self.type_define = "TYPE_DEF_TEMPLATE_FLOAT" self.type_id = "TYPE_TEMPLATE_FLOAT" self.min_value = field_obj["define"]["min"] self.max_value = field_obj["define"]["max"] self.default_value = field_obj["define"]["start"] if float(self.default_value) < float(self.min_value) or float(self.default_value) > float(self.max_value): raise ValueError("错误：{} 字段 default 指定的默认值超出 min~max 取值范围".format(name)) elif self.type_name == "int": self.type_define = "TYPE_DEF_TEMPLATE_INT" self.type_id = "TYPE_TEMPLATE_INT" self.min_value = field_obj["define"]["min"] self.max_value = field_obj["define"]["max"] self.default_value = field_obj["define"]["start"] if int(self.default_value) < int(self.min_value) or int(self.default_value) > int(self.max_value): raise ValueError("错误：{} 字段 default 指定的默认值超出 min~max 取值范围".format(name)) elif self.type_name == "string": self.type_define = "TYPE_DEF_TEMPLATE_STRING" self.type_id = "TYPE_TEMPLATE_STRING" self.min_value = field_obj["define"]["min"] self.max_value = field_obj["define"]["max"] self.default_value = "{'\\0'}" elif self.type_name == "timestamp": self.type_define = "TYPE_DEF_TEMPLATE_TIME" self.type_id = "TYPE_TEMPLATE_TIME" self.default_value = 0 else: raise ValueError('{} 字段 数据类型 type={} 取值非法，有效值应为：bool,enum,int,float,string'.format(name, field_obj["type"])) def get_id_c_macro_name(self): return "TC_IOT_PROP_{}".format(self.id) def get_id_c_member_name(self): return "m_{}".format(self.id) def get_id_default_value(self): return "{}".format(self.default_value) def get_id_define_str(self): return "#define {} {}".format(self.get_id_c_macro_name(), self.index) def get_struct_field_declare(self): if self.type_id == "TYPE_TEMPLATE_STRING": return "TYPE_DEF_TEMPLATE_STRING m_{}[{}+1];".format(self.id, str(self.max_value)) else: return "{} m_{};".format(self.type_define, self.id) def get_global_field_declare(self): if self.type_id == "TYPE_TEMPLATE_STRING": return "TYPE_DEF_TEMPLATE_STRING sg_{}{}[{}+1]={};".format(self.prefix, self.id, str(self.max_value),"{0}") else: return "{} sg_{}{} = {};".format(self.type_define, self.prefix, self.id, self.default_value) def get_meta_define_str(self, var_name): return '{{ "{}", &{}.{}, {} }},' \ .format(self.id, var_name, self.get_id_c_member_name(), self.type_id) class iot_event: def __init__(self,id, name, index, event): self.index = index self.id = id self.name = name self.event_type = event["type"] self.desc = event["desc"] self.event_properties = [] self.event_property_count = 0 self.prefix = self.id + "_" for property in event["params"]: self.event_properties.append(iot_field(self.prefix, property["id"], property["name"], self.event_property_count, property)) self.event_property_count += 1 def get_sigle_event_info(self): event_info = "" event_info += "\n id:{} name:\"{}\" type:\"{}\"\n".format(self.id, self.name, self.event_type) event_info += " property_count:{} \n params:[".format(self.event_property_count) for field in self.event_properties: event_info += "\n para:{} type:{}".format(field.id, field.type_id) event_info += "\n ]" return event_info def gen_sigle_event_info(self): result = "" event_para_info = "" event_property_info = "" event_var_info = "" for field in self.event_properties: event_para_info += "static {}\n".format(field.get_global_field_declare()) event_property_info += "\n {" if field.type_id == "TYPE_TEMPLATE_STRING": event_property_info += ".key = \"{}\", .data = sg_{}, .type = {}".format(field.id, self.prefix + field.id, field.type_id) else: event_property_info += ".key = \"{}\", .data = &sg_{}, .type = {}".format(field.id, self.prefix + field.id, field.type_id) event_property_info += "}," event_var_info += "static DeviceProperty g_propertyEvent_{}[] = ".format(self.id) result += event_para_info + event_var_info + "{\n"+event_property_info + "\n};\n" return result class iot_action: def __init__(self,id, name, index, action): self.index = index self.id = id self.name = name self.desc = action["desc"] self.action_input = [] self.action_input_count = 0 self.action_input_prefix = self.id + "_in_" self.action_output = [] self.action_output_count = 0 self.action_output_prefix = self.id + "_out_" for input in action["input"]: self.action_input.append(iot_field(self.action_input_prefix, input["id"], input["name"], self.action_input_count, input)) self.action_input_count += 1 for output in action["output"]: self.action_output.append(iot_field(self.action_output_prefix, output["id"], output["name"], self.action_output_count, output)) self.action_output_count += 1 def get_single_action_info(self): action_info = "" action_info += "\n id:{} name:\"{}\"\n".format(self.id, self.name) action_info += " action_input_count:{} \n inputs:[".format(self.action_input_count) for field in self.action_input: action_info += "\n para:{} type:{}".format(field.id, field.type_id) action_info += "\n ]" action_info += " action_output_count:{} \n output:[".format(self.action_output_count) for field in self.action_output: action_info += "\n para:{} type:{}".format(field.id, field.type_id) action_info += "\n ]" return action_info def gen_single_action_info(self): result = "" action_para_info = "" action_input_info = "" action_input_var_info = "" for field in self.action_input: action_para_info += "static {}\n".format(field.get_global_field_declare()) action_input_info += "\n {" if field.type_id == "TYPE_TEMPLATE_STRING": action_input_info += ".key = \"{}\", .data = sg_{}, .type = {}".format(field.id, self.action_input_prefix + field.id, field.type_id) else: action_input_info += ".key = \"{}\", .data = &sg_{}, .type = {}".format(field.id, self.action_input_prefix + field.id, field.type_id) action_input_info += "}," action_input_var_info += "static DeviceProperty g_actionInput_{}[] = ".format(self.id) result += action_para_info + action_input_var_info + "{\n"+action_input_info + "\n};\n" action_para_info = "" action_input_info = "" action_input_var_info = "" for field in self.action_output: action_para_info += "static {}\n".format(field.get_global_field_declare()) action_input_info += "\n {" if field.type_id == "TYPE_TEMPLATE_STRING": action_input_info += ".key = \"{}\", .data = sg_{}, .type = {}".format(field.id, self.action_output_prefix + field.id, field.type_id) else: action_input_info += ".key = \"{}\", .data = &sg_{}, .type = {}".format(field.id, self.action_output_prefix + field.id, field.type_id) action_input_info += "}," action_input_var_info += "static DeviceProperty g_actionOutput_{}[] = ".format(self.id) result += action_para_info + action_input_var_info + "{\n"+action_input_info + "\n};\n" return result class iot_struct: def __init__(self, model): self.version = model["version"] self.fields = [] self.field_id = 0 self.events = [] self.event_id = 0 self.actions = [] self.action_id = 0 if "properties" in model : for field_define in model["properties"]: if TEMPLATE_CONSTANTS.NAME not in field_define: raise ValueError("错误：字段定义中未找到 Name 字段") self.fields.append(iot_field("", field_define["id"], field_define["name"], self.field_id, field_define)) self.field_id += 1 if "events" in model : for event in model["events"]: if TEMPLATE_CONSTANTS.NAME not in event: raise ValueError("错误：字段定义中未找到 Name 字段") self.events.append(iot_event(event["id"], event["name"], self.event_id, event)) self.event_id += 1 if "actions" in model : for action in model["actions"]: if TEMPLATE_CONSTANTS.NAME not in action: raise ValueError("错误：字段定义中未找到 Name 字段") self.actions.append(iot_action(action["id"], action["name"], self.action_id, action)) self.action_id += 1 def dump_data_info(self): print("dump iot struct,counts:{}".format(self.field_id)) for temp_field in self.fields: if temp_field.type_name == "enum": print("{} {} {} {} ".format(temp_field.id, temp_field.type_name, temp_field.default_value, temp_field.type_define)) print("enums:{") for enum in temp_field.enums: print("{} ".format(enum.get_c_macro_name())) print("}") else: print("{} {} {} {}\n".format(temp_field.id, temp_field.type_name, temp_field.default_value, temp_field.type_define)) def dump_event_info(self): count = 0 event_str = "" event_str += ("#define EVENT_COUNTS ({})\n").format(self.event_id) for event_d in self.events: event_str += "{}\n".format(event_d.gen_sigle_event_info()) count += 1 return event_str def data_config_macro_define(self, struct_Template="sDataPoint",var_gTemplate="sg_DataTemplate"): define_str = "" define_str += "/*-----------------data config start -------------------*/ \n\n" define_str += "#define TOTAL_PROPERTY_COUNT {}\n\n".format(self.field_id) define_str += "static {} {}[TOTAL_PROPERTY_COUNT];\n\n".format(struct_Template, var_gTemplate) return define_str def declare_product_data_struct(self, struct_name="ProductDataDefine", var_gname="sg_ProductData"): result = "" result += "typedef struct _" + struct_name + " {\n" for field in self.fields: result += " {}\n".format(field.get_struct_field_declare()) result += "} " + struct_name + ";\n\n" result += "static " + struct_name + " "+var_gname + ";\n\n" return result def property_data_initializer(self, struct_name="ProductDataDefine", var_gProduct="sg_ProductData", var_gTemplate="sg_DataTemplate"): count = 0 init_str = "" init_str += "static void _init_data_template(void)\n{\n" #init_str += " memset((void *) & {}, 0, sizeof({}));\n".format(var_gProduct, struct_name) for field in self.fields: if field.type_define == "TYPE_DEF_TEMPLATE_STRING": init_str += " {}.{}[0] = {};\n".format(var_gProduct, field.get_id_c_member_name(), "'\\0'") init_str += " {}[{}].data_property.data = {}.{};\n".format(var_gTemplate, count, var_gProduct, field.get_id_c_member_name()) init_str += " {}[{}].data_property.data_buff_len = sizeof({}.{})/sizeof({}.{}[{}]);\n".format(var_gTemplate, count, var_gProduct, field.get_id_c_member_name(),var_gProduct, field.get_id_c_member_name(), count) else: init_str += " {}.{} = {};\n".format(var_gProduct, field.get_id_c_member_name(),field.get_id_default_value()) init_str += " {}[{}].data_property.data = &{}.{};\n".format(var_gTemplate, count, var_gProduct, field.get_id_c_member_name()) init_str += " {}[{}].data_property.key = \"{}\";\n".format(var_gTemplate, count, field.id) init_str += " {}[{}].data_property.type = {};\n".format(var_gTemplate, count, field.type_id) init_str += " {}[{}].state = eCHANGED;\n\n".format(var_gTemplate, count) count += 1 init_str += "};\n" return init_str def gen_data_config(self): data_config = "" data_config +="{}".format(self.data_config_macro_define()) data_config +="{}".format(self.declare_product_data_struct()) data_config += "{}".format(self.property_data_initializer()) return data_config def gen_event_config(self): resault = "" event_config = "" events_var = "" event_str = "" event_config += ("\n#define EVENT_COUNTS ({})\n\n").format(self.event_id) events_var += "\nstatic sEvent g_events[]={\n" for event_d in self.events: event_config += "{}\n".format(event_d.gen_sigle_event_info()) event_str += "\n {" event_str += "\n .event_name = \"{}\",".format(event_d.id) event_str += "\n .type = \"{}\",".format(event_d.event_type) event_str += "\n .timestamp = 0," event_str += "\n .eventDataNum = sizeof(g_propertyEvent_{})/sizeof(g_propertyEvent_{}[0]),".format(event_d.id, event_d.id) event_str += "\n .pEventData = g_propertyEvent_{},".format(event_d.id) event_str +="\n }," resault += event_config + events_var + event_str + "\n};\n" return resault def gen_action_config(self): resault = "" action_config = "" actions_var = "" action_str = "" action_config += ("\n#define TOTAL_ACTION_COUNTS ({})\n\n").format(self.action_id) actions_var += "\nstatic DeviceAction g_actions[]={\n" for action_d in self.actions: action_config += "{}\n".format(action_d.gen_single_action_info()) action_str += "\n {" action_str += "\n .pActionId = \"{}\",".format(action_d.id) action_str += "\n .timestamp = 0," action_str += "\n .input_num = sizeof(g_actionInput_{})/sizeof(g_actionInput_{}[0]),".format(action_d.id, action_d.id) action_str += "\n .output_num = sizeof(g_actionOutput_{})/sizeof(g_actionOutput_{}[0]),".format(action_d.id, action_d.id) action_str += "\n .pInput = g_actionInput_{},".format(action_d.id) action_str += "\n .pOutput = g_actionOutput_{},".format(action_d.id) action_str +="\n }," resault += action_config + actions_var + action_str + "\n};\n" return resault def main(): parser = argparse.ArgumentParser(description='Iothub datatemplate and events config code generator.', usage='use "./codegen.py -c xx/config.json" gen config code') parser.add_argument('-c','--config', dest='config',metavar='xxx.json', required=False,default='xxx.json', help='copy the generated file (data_config.c and events_config.c) to datatemplate_sample dir ' 'or your own code dir with datatemplate. ' '\nconfig file can be download from tencent iot-hub platfrom. https://console.cloud.tencent.com/iotcloud') parser.add_argument('-d','--dest', dest='dest', required=False,default='.', help='Dest directory for generated code files, no / at the end.') args = parser.parse_args() config_path = args.config if not os.path.exists(config_path): print(u"错误：配置文件不存在，请重新指定数据模板配置文件路径,请参考用法 ./codegen.py -c xx/data_template.json".format(config_path)) return 1 config_dir = os.path.dirname(config_path) if config_dir: config_dir += "/" f = open(config_path, "r") try: thingmodel = json.load(f) if 'properties' not in thingmodel: thingmodel.properties = [] if 'events' not in thingmodel: thingmodel.events = [] print(u"加载 {} 文件成功".format(config_path)) except ValueError as e: print(u"错误：文件格式非法，请检查 {} 文件是否是 JSON 格式。".format(config_path)) return 1 if TEMPLATE_CONSTANTS.PROPERTIES not in thingmodel: print(u"错误：{} 文件中未发现 DataTemplate 属性字段，请检查文件格式是否合法。".format(config_path)) return 1 try: snippet = iot_struct(thingmodel) if snippet.field_id != 0 : output_data_config_file_name = args.dest + "/data_config.c" output_file = open(output_data_config_file_name, "w") output_file.write("{}".format(snippet.gen_data_config())) output_file.close() print(u"文件 {} 生成成功".format(output_data_config_file_name)) if snippet.event_id != 0 : output_event_config_file_name = args.dest + "/events_config.c" output_file = open(output_event_config_file_name, "w") output_file.write("#ifdef EVENT_POST_ENABLED\n{}\n#endif\n".format(snippet.gen_event_config())) output_file.close() print(u"文件 {} 生成成功".format(output_event_config_file_name)) if snippet.action_id != 0 : output_action_config_file_name = args.dest + "/action_config.c" output_file = open(output_action_config_file_name, "w") output_file.write("#ifdef ACTION_ENABLED\n{}\n#endif\n".format(snippet.gen_action_config())) output_file.close() print(u"文件 {} 生成成功".format(output_action_config_file_name)) return 0 except ValueError as e: print(e) return 1 if __name__ == '__main__': sys.exit(main())