polypacket 1.1.21__py3-none-any.whl

polypacket/examples/example.py

@@ -0,0 +1,83 @@
+#!/usr/bin/env python3
+
+from polypacket.protocol import *
+from polypacket.polyservice import *
+import signal
+import argparse
+import os
+import time
+
+args = None
+parser = None
+SERVICE : PolyService = None
+
+def exit_handler(signum,frame):
+    print("Quit application. ")
+
+    if(SERVICE) :
+        SERVICE.close()
+    exit(0)
+
+# Initialize the argument parser
+def init_args():
+    global parser
+    parser = argparse.ArgumentParser("PolyPacket example in python")
+    parser.add_argument('-c', '--connection', type=str, help='Connection string', default="tcp:localhost:8020")
+    parser.add_argument('-f', '--file', type=str, help='protocol file', default="sample_protocol.yml")
+
+
+def main():
+    global parser
+    global args
+    global SERVICE
+
+
+    #set up exit handler for ctrl+c
+    signal.signal(signal.SIGINT, exit_handler)
+
+    #Get arguments
+    init_args()
+    args = parser.parse_args() 
+
+    inputFile = args.file
+
+    #parse input file
+    if os.path.isfile(inputFile):
+        SERVICE = PolyService(inputFile)
+    else :
+        print("Unable to read input file: " + inputFile)
+        return 1
+
+    #set handler for 'Data' type packets 
+    SERVICE.handlers['Data'] = data_handler
+
+    #set service prints to go to terminal 
+    SERVICE.print = print 
+
+    #attempt connection
+    SERVICE.connect(args.connection)
+
+    while not SERVICE.isConnected():
+        time.sleep(1)
+        timeout -=1
+        if timeout <= 0:
+            print("Connection Timedout, check connection string")
+            exit(1)
+    
+    #Send a packet 
+    SERVICE.sendPacket("SendCmd", {"src" : 0x01, "dst": 0x02, "cmd": "led_ON"})
+    
+
+
+
+
+def data_handler(service : PolyService, req : PolyPacket, resp : PolyPacket):
+
+    #get field data
+    sensorName = req.getField('sensorName')
+
+    print( "Message from {0}: {1}".format(sensorName, req.toJSON))
+
+
+if __name__ == '__main__':
+    main()

polypacket/examples/sample_protocol.xml

@@ -0,0 +1,47 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Protocol name="Sample" namespace="sp"
+  desc="This is a sample protocol made up to demonstrate features of the PolyPacket code generation tool. The idea
+  is to have a tool that can automatically create parseable/serializable messaging for embedded systems.">
+  <!--First we declare all Field descriptors-->
+  <Fields>
+
+    <!--Common -->
+    <Field name="cmd" type="enum" format="hex" desc="command byte for controlling node" >
+      <Val name="led_ON" desc="turns on led" />
+      <Val name="led_OFF" desc="turns off led" />
+      <Val name="reset" desc="resets the device" />
+    </Field>
+
+    <!-- SensorData -->
+    <Field name="sensorA" type="int16" format="dec" desc="Value of Sensor A"/>
+    <Field name="sensorB" type="int" format="dec" desc="Value of Sensor B" />
+    <Field name="sensorName" type="string[32]" format="ascii" desc="Name of sensor"/>
+
+  </Fields>
+
+  <!--Declare all Packet Types-->
+  <Packets>
+    <Packet name="SendCmd" desc="Message to send command to node" >
+      <Field name="cmd" req="true"/>
+    </Packet>
+
+    <Packet name="GetData" desc="Message to get data from node" response="Data"/>
+
+    <Packet name="Data" desc="Message containing data from sensor" >
+      <Field name="sensorA"/>
+      <Field name="sensorB"/>
+      <!-- Adding a description here will overwrite the description in documentation for this packet type -->
+      <Field name="sensorName" desc="Name of sensor responding to message "/>
+    </Packet>
+
+  </Packets>
+
+  <Structs>
+    <Struct name="node" desc="struct for modeling node">
+      <Field name="sensorA"/>
+      <Field name="sensorB"/>
+      <Field name="sensorName" desc="Name of sensor responding to message "/>
+    </Struct>
+  </Structs>
+  
+</Protocol>

polypacket/examples/sample_protocol.yml

@@ -0,0 +1,118 @@
+---
+name: sample
+namespace: sp  #this defines the namespace used for functions and types in the code. This allows multiple protocols to be used in a project
+desc: This is a sample protocol made up to demonstrate features of the PolyPacket
+  code generation tool. The idea is to have a tool that can automatically create parseable/serializable
+  messaging for embedded systems
+
+###########################################################################################################
+#                                   FIELDS                                                                #
+###########################################################################################################
+
+fields:
+
+  #Fields can be nested into a 'Field Group' for convenience. They will be put in the packet just like regular fields
+  - header:
+      - src: {type: uint16, desc: Address of node sending message }
+      - dst: {type: uint16, desc: Address of node to receive message }
+
+  - sensorA: { type: int16 ,desc: Value of Sensor A}  #Simple Fields can be defined as inline dictionares to save space
+
+  - sensorB:
+      type: int
+      desc: Value of Sensor B
+
+  - sensorName:
+      type: string
+      desc: Name of sensor
+
+  - cmd:
+      type: enum
+      format: hex
+      desc: command byte for controlling node
+      vals:
+        - led_ON: { desc: turns on led}
+        - led_OFF: { desc: turns off led}
+        - reset: { desc: resets device }
+
+###########################################################################################################
+#                                   Packets                                                               #
+###########################################################################################################
+packets:
+  - SendCmd:
+      desc: Message to send command to node
+      fields:
+        - header
+        - cmd
+
+  - GetData:
+      desc: Message tp get data from node
+      response: Data          #A response packet can be specified
+      fields:
+        - header
+
+  - SetData:
+      desc: contains data from a sensor
+      fields:
+        - header
+        - sensorA
+        - sensorB
+        - sensorName : {desc: Name of sensor sending data }   #Field descriptions can be overriden for different packets
+
+  - Data:
+      desc: contains data from a sensor
+      fields:
+        - header
+        - sensorA
+        - sensorB
+        - sensorName : {desc: Name of sensor sending data }   #Field descriptions can be overriden for different packets
+###########################################################################################################
+#                                   Structs                                                                #
+###########################################################################################################
+
+structs:
+  - Node:
+      desc: struct for modeling node
+      fields:
+        - sensorA
+        - sensorB
+        - sensorName
+
+###########################################################################################################
+#                                   Agents                                                                #
+###########################################################################################################
+agents:
+  # This creates an agent named 'node' to load it, add '-a node' when running poly packet
+  # naming a sim 'default' will cause it to load 
+  - node: 
+      # init signature is init(service):
+      # There is a global dicst named DataStore that can be used to store variables
+      init: |
+        DataStore['node'] = service.newStruct('Node')
+        DataStore['node'].setField('sensorName', 'node01')
+        DataStore['node'].setField('sensorA', 25)
+        DataStore['node'].setField('sensorB', 65)
+        node = DataStore['node']
+        service.print('\nCreating Sensor node:\n   name: {0}\n   sensorA: {1}\n   sensorB: {2}\n'.format(node.getField('sensorName'),node.getField('sensorA'),node.getField('sensorB') ))
+
+
+      #handlers fill out a function with the signature <name>_handler(service, req, resp):
+      # you can print out to the console with service.print(text)
+      handlers: 
+          
+        #Use packets/nodes can be copied to eachother. All shared fields that are present in the source will get copied to the destination
+        - SetData: |
+            req.copyTo(DataStore['node'])
+
+        - GetData: |
+            DataStore['node'].copyTo(resp)
+
+      #You can add custom commands to a sim that will be loaded in for autocomplete and help menus in the CLI
+      commands:
+        - rename: 
+            desc: renames the node
+            args:
+              - name: {desc: new name for node, default: 'node01'}
+            handler: |
+              DataStore['node'].setField('sensorName', args['name'])
+              service.print('\nRenaming Sensor node:\n   name: {0}\n'.format(name))

polypacket/plugins/ota.yml

@@ -0,0 +1,3 @@
+---
+
+redirect:  https://gitlab.com/mrt-public/modules/Utilities/OTA/-/raw/main/poly/ota-protocol.yml

polypacket/templates/app_template.c

@@ -0,0 +1,223 @@
+/**
+  *@file app_${proto.name.lower()}.c
+  *@brief generated protocol source code
+  *@author make_protocol.py
+  *@date ${proto.genTime}
+  */
+
+/***********************************************************
+        Application Layer
+***********************************************************/
+
+#include "app_${proto.name.lower()}.h"
+%if proto.genUtility:
+#include "platforms/linux/linux_uart.h"
+#include "platforms/linux/linux_udp.h"
+
+int ifaceMode;
+udp_stream udp;
+int fd;
+
+#define ${proto.namespace.upper()}_PRINT(packet) fp_print_json((packet),printBuf); printf("%s",printBuf)
+%else:
+mrt_uart_handle_t ifac0;
+%endif
+static uint8_t iface0_rx_buf[512];
+static char printBuf[512];
+
+static inline HandlerStatus_e iface0_write(uint8_t* data, int len)
+{
+  /* Place code for writing bytes on interface 0 here */
+%if proto.genUtility:
+  switch (ifaceMode)
+  {
+    case UART_MODE:
+      uart_write(fd,data,len);
+      break;
+    case UDP_MODE:
+      udp_send(&udp,data,len);
+      break;
+  }
+%else:
+  MRT_UART_TX(ifac0, data, len, 10);
+%endif
+
+  return PACKET_SENT;
+}
+
+
+static inline void iface0_read()
+{
+  int len =0;
+  /* Place code for reading bytes from interface 0 here */
+%if proto.genUtility:
+  switch (ifaceMode)
+  {
+    case UART_MODE:
+      len = uart_read(fd,iface0_rx_buf, 32);
+      break;
+    case UDP_MODE:
+      len = udp_recv(&udp,iface0_rx_buf,512);
+      break;
+  }
+
+%else:
+  //TODO read bytes from interface to iface0_rx_buf
+  len = MRT_UART_RX(ifac0, iface0_rx_buf, 32, 5);  //read 32 bytes at a time
+%endif
+
+  ${proto.namespace}_service_feed(0,iface0_rx_buf, len);
+}
+
+/*******************************************************************************
+  App Init/end
+*******************************************************************************/
+%if proto.genUtility:
+void app_${proto.name.lower()}_init(const char* connectionStr, int mode)
+{
+  /* initialize peripheral for iface_0 */
+  ifaceMode = mode;
+
+  switch(ifaceMode)
+  {
+    case UART_MODE:
+    if(uart_init(&fd, connectionStr))
+      printf("successfully opened port: %s\n",connectionStr);
+    else
+      printf("Could not open port: %s",connectionStr);
+    break;
+    case UDP_MODE:
+      udp_init(&udp,connectionStr);
+      break;
+  }
+
+%else:
+void app_${proto.name.lower()}_init(mrt_uart_handle_t uart_handle)
+{
+  /* Set ifac0 to uart handle, this can use any peripheral, but uart is the most common case */
+  ifac0 = uart_handle; //set interface to uart handle
+%endif
+
+  //initialize service
+  ${proto.namespace}_service_init(1,16);
+
+  ${proto.namespace}_service_register_bytes_tx(0, iface0_write);
+
+}
+
+void app_${proto.name.lower()}_end()
+{
+%if proto.genUtility:
+  switch(ifaceMode)
+  {
+    case UART_MODE:
+      uart_close(fd);
+      break;
+    case UDP_MODE:
+      udp_close(&udp);
+      break;
+  }
+%endif
+}
+
+/*******************************************************************************
+  App Process
+*******************************************************************************/
+
+void app_${proto.name.lower()}_process()
+{
+  /* read in new data from iface 0*/
+  iface0_read();
+
+  /* process the actual service */
+  ${proto.namespace}_service_process();
+
+}
+
+
+/*******************************************************************************
+  Packet handlers
+*******************************************************************************/
+% for packet in proto.packets:
+%if not packet.standard:
+%if not packet.hasResponse:
+/**
+  *@brief Handler for receiving ${packet.name} packets
+  *@param ${packet.name} incoming ${packet.name} packet
+  *@return handling ${proto.namespace}_status
+  */
+HandlerStatus_e ${proto.namespace}_${packet.camel()}_handler(${proto.namespace}_packet_t* ${proto.namespace}_${packet.name})
+%else:
+/**
+  *@brief Handler for receiving ${packet.name} packets
+  *@param ${packet.name} incoming ${packet.name} packet
+  *@param ${packet.response.name} ${packet.response.name} packet to respond with
+  *@return handling ${proto.namespace}_status
+  */
+HandlerStatus_e ${proto.namespace}_${packet.camel()}_handler(${proto.namespace}_packet_t* ${proto.namespace}_${packet.name}, ${proto.namespace}_packet_t* ${proto.namespace}_${packet.response.name})
+%endif
+{
+  /*  Get Required Fields in packet */
+% for field in packet.fields:
+  ${field.getDeclaration()};  //${field.desc}
+%endfor
+
+% for field in packet.fields:
+  %if field.isArray:
+  ${proto.namespace}_get${field.camel()}(${proto.namespace}_${packet.name}, ${field.name});
+  %else:
+  ${field.name} = ${proto.namespace}_get${field.camel()}(${proto.namespace}_${packet.name});
+  %endif
+% endfor
+
+% for field in packet.fields:
+% if field.isEnum:
+  switch(${field.name})
+  {
+  % for val in field.vals:
+    case ${proto.namespace.upper()+"_"+field.name.upper() + "_" + val.name.upper()}:    // ${val.desc}
+      break;
+  % endfor
+    default:
+      break;
+  }
+
+%endif
+% endfor
+% for field in packet.fields:
+% if field.isMask:
+  % for val in field.vals:
+  if(${field.name} & ${proto.namespace.upper()+"_"+field.name.upper() + "_" + val.name.upper()})    // ${val.desc}
+  {
+  }
+  %endfor
+
+%endif
+% endfor
+%if packet.hasResponse:
+  /*    Set required Fields in response  */
+% for field in packet.response.fields:
+  //${proto.namespace}_set${field.camel()}(${proto.namespace}_${packet.response.name}, value );  //${field.desc}
+%endfor
+%endif
+
+
+
+  return PACKET_NOT_HANDLED;
+}
+
+%endif
+% endfor
+
+/**
+  *@brief catch-all handler for any packet not handled by its default handler
+  *@param metaPacket ptr to ${proto.namespace}_packet_t containing packet
+  *@param ${proto.namespace}_response ptr to response
+  *@return handling ${proto.namespace}_status
+  */
+HandlerStatus_e ${proto.namespace}_default_handler( ${proto.namespace}_packet_t * ${proto.namespace}_packet, ${proto.namespace}_packet_t * ${proto.namespace}_response)
+{
+
+
+  return PACKET_NOT_HANDLED;
+}

polypacket/templates/app_template.h

@@ -0,0 +1,35 @@
+/**
+  *@file app_${proto.name.lower()}.h
+  *@brief generated protocol source code
+  *@author make_protocol.py
+  *@date ${proto.genTime}
+  */
+
+#include "${proto.fileName}.h"
+%if not proto.genUtility:
+#include "platforms/common/mrt_platform.h"
+%endif
+
+
+/**
+  *@brief Initialize the packet service
+  */
+%if proto.genUtility:
+
+#define UART_MODE 0
+#define UDP_MODE 1
+
+void app_${proto.name.lower()}_init(const char* connectionStr, int mode);
+%else:
+void app_${proto.name.lower()}_init(mrt_uart_handle_t uart_handle);
+%endif
+
+/**
+  *@brief ends service
+  */
+void app_${proto.name.lower()}_end();
+
+/**
+  *@brief process the data for the packet service
+  */
+void app_${proto.name.lower()}_process();