examples/robot/Properties/AssemblyInfo.cs

+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("RobotCtrl")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("RobotCtrl")]
+[assembly: AssemblyCopyright("Copyright ©  2013")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("bd5ee6d6-1dff-4043-8ca9-b56a29116e61")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Build and Revision Numbers 
+// by using the '*' as shown below:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]

examples/robot/RobotCtrl.csproj

+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProjectGuid>{F0051A25-4FFF-4421-A5CB-01B512D6CEC5}</ProjectGuid>
+    <OutputType>Exe</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>RobotCtrl</RootNamespace>
+    <AssemblyName>RobotCtrl</AssemblyName>
+    <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <PlatformTarget>AnyCPU</PlatformTarget>
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <PlatformTarget>AnyCPU</PlatformTarget>
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="System" />
+    <Reference Include="System.Core" />
+    <Reference Include="System.Xml.Linq" />
+    <Reference Include="System.Data.DataSetExtensions" />
+    <Reference Include="Microsoft.CSharp" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="LCRobot.cs" />
+    <Compile Include="Specification.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="App.config" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\..\lib\csharp\LabComm.csproj">
+      <Project>{755cd5a6-c48e-4d35-b0be-8ec0fde1a2a1}</Project>
+      <Name>LabComm</Name>
+    </ProjectReference>
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+</Project>

examples/robot/RobotCtrl.sln

+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 2012
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "RobotCtrl", "RobotCtrl.csproj", "{F0051A25-4FFF-4421-A5CB-01B512D6CEC5}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "LabComm", "..\..\lib\csharp\LabComm.csproj", "{755CD5A6-C48E-4D35-B0BE-8EC0FDE1A2A1}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{F0051A25-4FFF-4421-A5CB-01B512D6CEC5}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{F0051A25-4FFF-4421-A5CB-01B512D6CEC5}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{F0051A25-4FFF-4421-A5CB-01B512D6CEC5}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{F0051A25-4FFF-4421-A5CB-01B512D6CEC5}.Release|Any CPU.Build.0 = Release|Any CPU
+		{755CD5A6-C48E-4D35-B0BE-8EC0FDE1A2A1}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{755CD5A6-C48E-4D35-B0BE-8EC0FDE1A2A1}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{755CD5A6-C48E-4D35-B0BE-8EC0FDE1A2A1}.Release|Any CPU.ActiveCfg = Debug|Any CPU
+		{755CD5A6-C48E-4D35-B0BE-8EC0FDE1A2A1}.Release|Any CPU.Build.0 = Debug|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal

examples/simple/.gitignore

+encoded_data
+encoded_data06
+example_decoder
+example_decoder06
+example_encoder
+example_encoder06
+gen
+gen06

examples/simple/Decoder.java

+import java.io.File;
+import java.io.FileInputStream;
+import java.io.InputStream;
+
+import se.lth.control.labcomm2014.DecoderChannel;
+
+public class Decoder
+  implements theTwoInts.Handler, anotherTwoInts.Handler, IntString.Handler, TwoArrays.Handler, TwoFixedArrays.Handler, doavoid.Handler
+
+{
+
+  DecoderChannel decoder;
+
+  public Decoder(InputStream in) 
+    throws Exception 
+  {
+    decoder = new DecoderChannel(in);
+    theTwoInts.register(decoder, this);
+    anotherTwoInts.register(decoder, this);
+    IntString.register(decoder, this);
+    TwoArrays.register(decoder, this);
+    TwoFixedArrays.register(decoder, this);
+    doavoid.register(decoder, this);
+
+    try {
+      System.out.println("Running decoder.");
+      decoder.run();
+    } catch (java.io.EOFException e) {
+	System.out.println("Decoder reached end of file.");
+    }
+  }
+
+  public void printTwoInts(TwoInts d) throws java.io.IOException {
+    System.out.println("a="+d.a+", b="+d.b);
+  }
+
+  public void handle_theTwoInts(TwoInts d) throws java.io.IOException {
+    System.out.print("Got theTwoInts: ");
+    printTwoInts(d);
+  }
+
+  public void handle_anotherTwoInts(TwoInts d) throws java.io.IOException {
+    System.out.print("Got anotherheTwoInts: ");
+    printTwoInts(d);
+  }
+
+  public void handle_IntString(IntString d) throws java.io.IOException {
+    System.out.println("Got IntString, x="+d.x+", s="+d.s);
+  }
+
+  public void handle_TwoArrays(TwoArrays d) throws java.io.IOException {
+    System.out.println("Got TwoArrays:");
+    for(int i=0; i<d.fixed.length; i++) {
+	System.out.print(d.fixed[i]+" ");
+    }
+    System.out.println();
+    for(int i=0; i<d.variable[0].length; i++) {
+	System.out.print(d.variable[0][i]+" ");
+	System.out.print(d.variable[1][i]+" ");
+    }
+    System.out.println();
+  }
+
+  public void handle_TwoFixedArrays(TwoFixedArrays d) throws java.io.IOException {
+    System.out.println("Got TwoFixedArrays:");
+    for(int i=0; i<d.a.length; i++) {
+	System.out.print(d.a[i]+" ");
+    }
+    System.out.println();
+    for(int i=0; i<d.b[0].length; i++) {
+	System.out.print(d.b[0][i]+" ");
+	System.out.print(d.b[1][i]+" ");
+    }
+    System.out.println();
+  }
+  public void handle_doavoid() throws java.io.IOException {
+    System.out.println("Got doavoid");
+  }
+
+
+
+  public static void main(String[] arg) throws Exception {
+    Decoder example = new Decoder(
+      new FileInputStream(new File(arg[0]))
+    );
+  }
+}
+

examples/simple/Encoder.java

+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.OutputStream;
+
+import se.lth.control.labcomm2014.EncoderChannel;
+
+/**
+ * Simple encoder 
+ */
+public class Encoder 
+{
+
+  EncoderChannel encoder;
+
+  public Encoder(OutputStream out) 
+    throws Exception 
+  {
+    encoder = new EncoderChannel(out);
+    doavoid.register(encoder);
+    theTwoInts.register(encoder);
+    IntString.register(encoder);
+    TwoArrays.register(encoder);
+  }
+
+  public void doEncode() throws java.io.IOException {
+
+    TwoInts x = new TwoInts();
+    x.a = 17;
+    x.b = 42;
+
+    IntString y = new IntString();
+    y.x = 37;
+    y.s = "Testing, testing";
+
+    TwoArrays ta = new TwoArrays();
+    ta.fixed = new int[] {14, 25};
+//    ta.variable = new int[][] {{1,2},{0x11,0x12},{0x21,0x22},{0x31,0x32}};
+    ta.variable = new int[][] {{1,2, 3, 4},{0x21,0x22,0x23,0x24}};
+
+    System.out.println("Encoding doavoid");
+    doavoid.encode(encoder);
+
+    System.out.println("Encoding theTwoInts, a="+x.a+", b="+x.b);
+    theTwoInts.encode(encoder, x);
+
+    System.out.println("Encoding IntString, x="+y.x+", s="+y.s);
+    IntString.encode(encoder, y);
+
+    System.out.println("Encoding TwoArrays");
+    for(int i = 0; i < ta.variable.length; i++) {
+	for(int j=0; j < ta.variable[0].length; j++)
+		System.out.println(ta.variable[i][j]);
+	System.out.println("---");
+    }
+    TwoArrays.encode(encoder, ta);
+  }
+
+
+  public static void main(String[] arg) throws Exception {
+    FileOutputStream fos = new FileOutputStream(arg[0]);
+    Encoder example = new Encoder(fos);
+    example.doEncode();
+    fos.close();
+  }
+
+}
+

examples/simple/EncoderIS.java

+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.OutputStream;
+
+import se.lth.control.labcomm2014.EncoderChannel;
+
+/**
+ * Simple encoder 
+ */
+public class EncoderIS 
+{
+
+  EncoderChannel encoder;
+
+  public EncoderIS(OutputStream out) 
+    throws Exception 
+  {
+    encoder = new EncoderChannel(out);
+//    doavoid.register(encoder);
+//    theTwoInts.register(encoder);
+    IntString.register(encoder);
+//    TwoArrays.register(encoder);
+  }
+
+  public void doEncodeIS() throws java.io.IOException {
+    IntString a = new IntString();
+    a.x = 17;
+    a.s = "A string";
+
+    IntString b = new IntString();
+    b.x = 9;
+    b.s = "Hej";
+
+    IntString c = new IntString();
+    c.x = 133742;
+    c.s = "Thirteenthirtysevenfourtytwo";
+
+    System.out.println("Encoding IntStrings");
+    IntString.encode(encoder, a);
+    IntString.encode(encoder, b);
+    IntString.encode(encoder, c);
+  }
+
+
+  public static void main(String[] arg) throws Exception {
+    FileOutputStream fos = new FileOutputStream(arg[0]);
+    EncoderIS example = new EncoderIS(fos);
+    example.doEncodeIS();
+    fos.close();
+  }
+
+}
+

examples/simple/Makefile

+all:
+
+clean:
+
+distclean:
+	rm -rf gen
+	rm -f *.class
+	rm -f example_encoder
+	rm -f example_decoder
+	rm -f encoded_data

examples/simple/README

+This is a very simple example with one labcomm file (simple.lc) defining two samples.
+Example source code: Encoders and decoders written in Java and C.
+	Encoder.java
+	Decoder.java
+        example_encoder.c
+        example_decoder.c
+And simple scripts
+	compile.sh 	- first runs the LabComm compiler and then compiles Encoder and Decoder
+	run.sh 		- runs, as expected Encoder and then Decoder
+
+the datagram directory contains the same example, but over datagram (UDP and raw etherne )protocols.
+
+When running compile.sh, Java and C files for the two samples defined in simple.lc will
+be generated in the gen directory.
+
+run.sh will then run first the encoder, writing to encoded_data, and then a
+decoder, reading from the previously written encoded_data written (in Java and
+C, respectively).
+
+NB! Before trying to build and run examples, make sure you have built the LabComm compiler
+by running "ant jar" in the compiler directory (../../compiler seen from here) and compiled 
+the labcomm descriptions needed. The compile.sh script does this.
+

examples/simple/compile.sh

+#!/bin/sh
+set -x
+set -e
+### Example compile script, showing the steps required to build a labcomm application
+### (including compiler and libs). Also illustrates how versions 2013 and 2006 coexist
+
+# For current version (2013)
+(cd ../..; make all)
+
+mkdir -p gen
+java -jar ../../compiler/labcomm2014_compiler.jar --java=gen --c=gen/simple.c --h=gen/simple.h  --python=gen/simple.py simple.lc 
+
+javac -cp ../../lib/java/labcomm2014.jar:. gen/*.java Encoder.java Decoder.java
+
+gcc -Wall -Werror -Wno-unused-function \
+    -I. -I../../lib/c/2014 -L../../lib/c \
+    -o example_encoder example_encoder.c gen/simple.c \
+    -llabcomm2014 
+gcc -Wall -Werror -I . -I ../../lib/c/2014 -L../../lib/c \
+    -o example_decoder example_decoder.c gen/simple.c \
+    -llabcomm2014 
+

examples/simple/datagram/README

+The simple labcomm example over a datagram channel
+
+files:
+
+udp_encoder.c : the same as the simple encoder, but over an UDP writer
+udp_decoder.c : d:o
+
+thr_example.c : the samei over a raw ethernet datagram protocol, in one file,and parameterized 
+		to take the ethernet interface to use and the destination to send to as 
+		command line parameters
+
+thr_example2.c: similar, but bidirectional. The "server" opens a new channel and responds when receiving TwoInts

examples/simple/datagram/thr_compile.sh

+#(cd ../../../lib/c; make)
+(cd ..; sh compile.sh)
+
+gcc -o thr_example -L ../../../lib/c -I . -I .. -I ../../../lib/c -I ../../../lib/c/experimental thr_example.c ../gen/simple.c  -llabcomm
+gcc -o thr_example2 -L ../../../lib/c -I . -I .. -I ../../../lib/c -I ../../../lib/c/experimental thr_example2.c ../gen/simple.c  -llabcomm

examples/simple/datagram/thr_example.c

+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <labcomm_thr_reader_writer.h>
+#include "gen/simple.h"
+#include "ThrottleDrv/throttle_drv.h"
+
+
+static int encode(int argc, char *argv[]) {
+  struct thr_chn_t *p_thr_chn = NULL;
+  struct labcomm_encoder *encoder;
+  int i, j;
+  struct ether_addr dest_mac;
+  unsigned char chn_id = 0x01;
+  unsigned short frag_size = 60;
+  unsigned short freq = 1000;  /* milliseconds */
+
+  char *ifname = argv[1];
+  char *dest_mac_str = argv[2];
+
+  if(parse_MAC_address(dest_mac_str, &dest_mac)) {
+	printf("failed to parse dest MAC address\n");
+	return 1;
+  }
+  
+  if (-1 == thr_init(ifname))
+  {
+     printf("Throttle Init failure.");
+  }
+  else
+  {
+    p_thr_chn = thr_open_chn(&dest_mac, chn_id, frag_size, freq, NULL);
+    encoder = labcomm_encoder_new(labcomm_thr_writer, p_thr_chn);
+    labcomm_encoder_register_simple_TwoInts(encoder);
+    labcomm_encoder_register_simple_IntString(encoder);
+    simple_IntString is;
+    is.x = 24;
+    is.s = "Hello, LabComm!";
+    printf("Encoding IntString, x=%d, s=%s\n", is.x, is.s);
+    labcomm_encode_simple_IntString(encoder, &is);
+
+    simple_TwoInts ti;
+    ti.a = 13;
+    ti.b = 37;
+    printf("Encoding TwoInts, a=%d, b=%d\n", ti.a, ti.b);
+    labcomm_encode_simple_TwoInts(encoder, &ti);
+
+    //client_exit(fd);
+ }
+}
+
+static void handle_simple_TwoInts(simple_TwoInts *v,void *context) {
+  printf("Got TwoInts. a=%d, b=%d\n", v->a, v->b);
+}
+
+static void handle_simple_IntString(simple_IntString *v,void *context) {
+  printf("Got IntString. x=%d, s=%s\n", v->x, v->s);
+}
+
+static int decode(int argc, char *argv[]) {
+  struct thr_chn_t *p_thr_chn = NULL;
+  struct labcomm_decoder *decoder;
+  void  *context = NULL;
+  struct ether_addr dest_mac;
+  int ret = 0;
+  unsigned char chn_id = 0x01;
+  unsigned short frag_size = 60;
+  unsigned short freq = 1000;  /* milliseconds */
+  unsigned char data[200];
+
+  char *ifname = argv[1];
+  if (-1 == thr_init(ifname))
+  {
+     printf("Throttle Init failure.");
+  }
+  else
+  {
+    p_thr_chn = thr_open_chn(&dest_mac, chn_id, frag_size, freq, (thr_msg_handler_t)labcomm_decoder_decode_one);
+    decoder = labcomm_decoder_new(labcomm_thr_reader, p_thr_chn);
+    if (!decoder)
+    {
+      printf("Failed to allocate decoder %s:%d\n", __FUNCTION__, __LINE__);
+      return 1;
+    }
+    labcomm_decoder_register_simple_TwoInts(decoder, handle_simple_TwoInts, context);
+    labcomm_decoder_register_simple_IntString(decoder, handle_simple_IntString, context);
+
+    printf("Decoding:\n");
+    do {
+    ret = thr_receive(p_thr_chn, data, decoder);
+    } while(-1 != ret);
+    {
+      printf("Throttle Send receive failure.");
+    }
+    printf("--- End Of File ---:\n");
+    labcomm_decoder_free(decoder);
+
+    //server_exit(fd);
+  }
+}
+
+int main(int argc, char *argv[]) {
+	if(argc == 2) {
+		return decode(argc, argv);
+	} else if(argc == 3) {
+		return encode(argc, argv);
+	} else {
+		printf("Usage: For encoding ethN xx:xx:xx:xx:xx:xx\n       For decoding ethN\n       where ethN is the ethernet interface to use\n       and xx:xx:...:xx is the destination MAC address"); 
+		return 1;
+	}
+}

examples/simple/datagram/thr_example2.c

+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <labcomm_thr_reader_writer.h>
+#include "gen/simple.h"
+#include "ThrottleDrv/throttle_drv.h"
+
+
+
+static void handle_simple_TwoInts_foo(simple_TwoInts *v,void *context) {
+  struct ether_addr *src = get_sender_addr((struct thr_chn_t *)context); 
+  printf("Got TwoInts. a=%d, b=%d\n", v->a, v->b);
+  printf("... src addr: %x:%x:%x:%x:%x:%x\n", src->ether_addr_octet[0],  src->ether_addr_octet[1], src->ether_addr_octet[2], src->ether_addr_octet[3], src->ether_addr_octet[4], src->ether_addr_octet[5]);
+}
+
+static int encode(int argc, char *argv[]) {
+  struct thr_chn_t *p_thr_chn = NULL;
+  struct labcomm_encoder *encoder;
+  struct labcomm_decoder *decoder;
+  int i, j;
+  struct ether_addr dest_mac;
+  unsigned char chn_id = 0x01;
+  unsigned short frag_size = 60;
+  unsigned short freq = 1000;  /* milliseconds */
+
+  char *ifname = argv[1];
+  char *dest_mac_str = argv[2];
+
+  if(parse_MAC_address(dest_mac_str, &dest_mac)) {
+	printf("failed to parse dest MAC address\n");
+	return 1;
+  }
+  
+  if (-1 == thr_init(ifname))
+  {
+     printf("Throttle Init failure.");
+  }
+  else
+  {
+    p_thr_chn = thr_open_chn(&dest_mac, chn_id, frag_size, freq,(thr_msg_handler_t)labcomm_decoder_decode_one);
+    encoder = labcomm_encoder_new(labcomm_thr_writer, p_thr_chn);
+    labcomm_encoder_register_simple_TwoInts(encoder);
+    labcomm_encoder_register_simple_IntString(encoder);
+    decoder = labcomm_decoder_new(labcomm_thr_reader, p_thr_chn);
+    if (!decoder)
+    {
+      printf("Failed to allocate decoder %s:%d\n", __FUNCTION__, __LINE__);
+      return 1;
+    }
+    labcomm_decoder_register_simple_TwoInts(decoder, handle_simple_TwoInts_foo, p_thr_chn);
+
+    int ret;
+    unsigned char data[200];
+    simple_IntString is;
+    is.x = 24;
+    is.s = "Hello, LabComm!";
+    printf("Encoding IntString, x=%d, s=%s\n", is.x, is.s);
+    labcomm_encode_simple_IntString(encoder, &is);
+
+    simple_TwoInts ti;
+    ti.a = 13;
+    ti.b = 37;
+    printf("Encoding TwoInts, a=%d, b=%d\n", ti.a, ti.b);
+    labcomm_encode_simple_TwoInts(encoder, &ti);
+    printf("Decoding:\n");
+    thr_receive(p_thr_chn, data, decoder);
+    thr_receive(p_thr_chn, data, decoder);
+
+    labcomm_encoder_free(encoder);
+    labcomm_decoder_free(decoder);
+    thr_close_chn(p_thr_chn);
+    //client_exit(fd);
+ }
+}
+
+static void handle_simple_TwoInts(simple_TwoInts *v,void *context) {
+  struct ether_addr *src = get_sender_addr((struct thr_chn_t *)context); 
+  unsigned char ch_id = get_channel((struct thr_chn_t *)context); 
+  printf("Got TwoInts. a=%d, b=%d\n", v->a, v->b);
+  printf("... src addr: %x:%x:%x:%x:%x:%x\n", src->ether_addr_octet[0],  src->ether_addr_octet[1], src->ether_addr_octet[2], src->ether_addr_octet[3], src->ether_addr_octet[4], src->ether_addr_octet[5]);
+  struct thr_chn_t *ch = thr_open_chn(src, ch_id, (unsigned short)50, (unsigned short)100, NULL);
+  struct labcomm_encoder *enc = labcomm_encoder_new(labcomm_thr_writer, ch);
+  labcomm_encoder_register_simple_TwoInts(enc);
+  v->a *= 2;
+  v->b *= 3;
+  labcomm_encode_simple_TwoInts(enc, v);
+  labcomm_encoder_free(enc);
+  thr_close_chn(ch);
+}
+
+static void handle_simple_IntString(simple_IntString *v,void *context) {
+  printf("Got IntString. x=%d, s=%s\n", v->x, v->s);
+  struct ether_addr *src = get_sender_addr((struct thr_chn_t *)context); 
+  printf("... src addr: %x:%x:%x:%x:%x:%x\n", src->ether_addr_octet[0],  src->ether_addr_octet[1], src->ether_addr_octet[2], src->ether_addr_octet[3], src->ether_addr_octet[4], src->ether_addr_octet[5]);
+}
+
+static int decode(int argc, char *argv[]) {
+  struct thr_chn_t *p_thr_chn = NULL;
+  struct labcomm_decoder *decoder;
+  struct ether_addr dest_mac; 	// Not used in this simple decoder example.
+				// The return channel is opened in the handler
+  int ret = 0;
+  unsigned char chn_id = 0x01;
+  unsigned short frag_size = 60;
+  unsigned short freq = 1000;  /* milliseconds */
+  unsigned char data[200];
+
+  char *ifname = argv[1];
+  if (-1 == thr_init(ifname))
+  {
+     printf("Throttle Init failure.");
+  }
+  else
+  {
+    p_thr_chn = thr_open_chn(&dest_mac, chn_id, frag_size, freq, (thr_msg_handler_t)labcomm_decoder_decode_one);
+    decoder = labcomm_decoder_new(labcomm_thr_reader, p_thr_chn);
+    if (!decoder)
+    {
+      printf("Failed to allocate decoder %s:%d\n", __FUNCTION__, __LINE__);
+      return 1;
+    }
+    labcomm_decoder_register_simple_TwoInts(decoder, handle_simple_TwoInts, p_thr_chn);
+    labcomm_decoder_register_simple_IntString(decoder, handle_simple_IntString, p_thr_chn);
+
+    printf("Decoding:\n");
+    do {
+    ret = thr_receive(p_thr_chn, data, decoder);
+    } while(-1 != ret);
+    {
+      printf("Throttle Send receive failure.");
+    }
+    printf("--- End Of File ---:\n");
+    labcomm_decoder_free(decoder);
+
+    //server_exit(fd);
+  }
+}
+
+int main(int argc, char *argv[]) {
+	if(argc == 2) {
+		return decode(argc, argv);
+	} else if(argc == 3) {
+		return encode(argc, argv);
+	} else {
+		printf("Usage: For encoding ethN xx:xx:xx:xx:xx:xx\n       For decoding ethN\n       where ethN is the ethernet interface to use\n       and xx:xx:...:xx is the destination MAC address"); 
+		return 1;
+	}
+}

examples/simple/datagram/udp_compile.sh

+#(cd ../../../lib/c; make)
+
+(cd ..; sh compile.sh)
+
+gcc -g -o udp_encoder -L ../../../lib/c -I . -I .. -I ../../../lib/c -I ../../../lib/c/experimental udp_encoder.c ../gen/simple.c -llabcomm
+
+gcc -g -o udp_decoder -L ../../../lib/c -I . -I .. -I ../../../lib/c -I ../../../lib/c/experimental udp_decoder.c ../gen/simple.c -llabcomm

examples/simple/datagram/udp_decoder.c

+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <labcomm_udp_reader_writer.h>
+#include "gen/simple.h"
+//#include "/home/sven/slask/UDP/udp_hack.h"
+#include "udp_hack.h"
+
+static void handle_simple_TwoInts(simple_TwoInts *v,void *context) {
+  printf("Got TwoInts. a=%d, b=%d\n", v->a, v->b);
+}
+
+static void handle_simple_IntString(simple_IntString *v,void *context) {
+  printf("Got IntString. x=%d, s=%s\n", v->x, v->s);
+}
+
+int main(int argc, char *argv[]) {
+  server_context_t *fd;
+  struct labcomm_decoder *decoder;
+  void  *context = NULL;
+  int i, j;
+
+  char *filename = argv[1];
+  fd = server_init();
+  decoder = labcomm_decoder_new(labcomm_udp_reader, fd);
+  if (!decoder) { 
+    printf("Failed to allocate decoder %s:%d\n", __FUNCTION__, __LINE__);
+    return 1;
+  }
+
+  labcomm_decoder_register_simple_TwoInts(decoder, handle_simple_TwoInts, context);
+  labcomm_decoder_register_simple_IntString(decoder, handle_simple_IntString, context);
+
+  printf("Decoding:\n");
+  labcomm_decoder_run(decoder);
+  printf("--- End Of File ---:\n");
+  labcomm_decoder_free(decoder);
+  server_exit(fd);
+}

examples/simple/datagram/udp_encoder.c

+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <labcomm_udp_reader_writer.h>
+#include "gen/simple.h"
+//#include "/home/sven/slask/UDP/udp_hack.h"
+#include "udp_hack.h"
+
+int main(int argc, char *argv[]) {
+  server_context_t *fd;
+  struct labcomm_encoder *encoder;
+  int i, j;
+
+  char *filename = argv[1];
+  fd = client_init();
+  encoder = labcomm_encoder_new(labcomm_udp_writer, fd);
+  labcomm_encoder_register_simple_TwoInts(encoder);
+  labcomm_encoder_register_simple_IntString(encoder);
+  simple_IntString is;
+  is.x = 24;
+  is.s = "Hello, LabComm!";
+  printf("Encoding IntString, x=%d, s=%s\n", is.x, is.s);
+  labcomm_encode_simple_IntString(encoder, &is);
+
+  simple_TwoInts ti;
+  ti.a = 13;
+  ti.b = 37;
+  printf("Encoding TwoInts, a=%d, b=%d\n", ti.a, ti.b);
+  labcomm_encode_simple_TwoInts(encoder, &ti);
+
+  client_exit(fd);
+}

examples/simple/example_decoder.c

+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <labcomm2014_fd_reader.h>
+#include <labcomm2014_default_error_handler.h>
+#include <labcomm2014_default_memory.h>
+#include <labcomm2014_default_scheduler.h>
+#include "gen/simple.h"
+#include <stdio.h>
+
+static void handle_simple_doavoid(simple_doavoid *v, void *context) {
+  printf("Got a void.\n");
+}
+
+static void handle_simple_theTwoInts(simple_TwoInts *v,void *context) {
+  printf("Got theTwoInts. a=%d, b=%d\n", v->a, v->b);
+}
+
+static void handle_simple_anotherTwoInts(simple_TwoInts *v,void *context) {
+  printf("Got anotherTwoInts. a=%d, b=%d\n", v->a, v->b);
+}
+
+static void handle_simple_IntString(simple_IntString *v,void *context) {
+  printf("Got IntString. x=%d, s=%s\n", v->x, v->s);
+}
+
+static void handle_simple_TwoArrays(simple_TwoArrays *d,void *context) {
+  printf("Got TwoArrays:");
+  int i,j;
+    for(i=0; i<2; i++) {
+        printf("%d ",d->fixed.a[i]);
+    }
+    printf("\n");
+    for(i=0; i<2; i++) {
+      for(j=0; j<d->variable.n_1; j++) {
+	printf("%d ",d->variable.a[i *d->variable.n_1 + j]);
+      }
+      printf("\n");
+    }
+    printf("\n");
+}
+
+static void handle_simple_TwoFixedArrays(simple_TwoFixedArrays *d,void *context) {
+  printf("Got TwoFixedArrays:");
+  int i,j;
+    for(i=0; i<2; i++) {
+        printf("%d ",d->a.a[i]);
+    }
+    printf("\n");
+    for(i=0; i<2; i++) {
+      for(j=0; j<3; j++) {
+	printf("%d ",d->b.a[i][j]);
+      }
+      printf("\n");
+    }
+}
+
+int main(int argc, char *argv[]) {
+  int fd;
+  struct labcomm2014_decoder *decoder;
+  void  *context = NULL;
+
+  char *filename = argv[1];
+  printf("C decoder reading from %s\n", filename);
+  fd = open(filename, O_RDONLY);
+  decoder = labcomm2014_decoder_new(labcomm2014_fd_reader_new(
+				  labcomm2014_default_memory, fd, 1), 
+				labcomm2014_default_error_handler, 
+				labcomm2014_default_memory,
+				labcomm2014_default_scheduler);
+  if (!decoder) { 
+    printf("Failed to allocate decoder %s:%d\n", __FUNCTION__, __LINE__);
+    return 1;
+  }
+
+  labcomm2014_decoder_register_simple_doavoid(decoder, handle_simple_doavoid, context);
+  labcomm2014_decoder_register_simple_theTwoInts(decoder, handle_simple_theTwoInts, context);
+  labcomm2014_decoder_register_simple_anotherTwoInts(decoder, handle_simple_anotherTwoInts, context);
+  labcomm2014_decoder_register_simple_IntString(decoder, handle_simple_IntString, context);
+  labcomm2014_decoder_register_simple_TwoArrays(decoder, handle_simple_TwoArrays, context);
+  labcomm2014_decoder_register_simple_TwoFixedArrays(decoder, handle_simple_TwoFixedArrays, context);
+
+  printf("Decoding:\n");
+  labcomm2014_decoder_run(decoder);
+  printf("--- End Of File ---:\n");
+  labcomm2014_decoder_free(decoder);
+
+  return 0;
+}

examples/simple/example_encoder.c

+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <labcomm2014_fd_writer.h>
+#include <labcomm2014_default_error_handler.h>
+#include <labcomm2014_default_memory.h>
+#include <labcomm2014_default_scheduler.h>
+#include "gen/simple.h"
+#include <stdio.h>
+
+int main(int argc, char *argv[]) {
+  int fd;
+  struct labcomm2014_encoder *encoder;
+
+  char *filename = argv[1];
+  printf("C encoder writing to %s\n", filename);
+  fd = open(filename, O_WRONLY|O_CREAT|O_TRUNC, 0644);
+  encoder = labcomm2014_encoder_new(labcomm2014_fd_writer_new(
+				  labcomm2014_default_memory, fd, 1), 
+				labcomm2014_default_error_handler, 
+				labcomm2014_default_memory,
+				labcomm2014_default_scheduler);
+  labcomm2014_encoder_register_simple_doavoid(encoder);
+  labcomm2014_encoder_register_simple_theTwoInts(encoder);
+  labcomm2014_encoder_register_simple_anotherTwoInts(encoder);
+  labcomm2014_encoder_register_simple_IntString(encoder);
+
+  labcomm2014_encode_simple_doavoid(encoder);
+
+  simple_IntString is;
+  is.x = 24;
+  is.s = "Hello, LabComm!";
+  printf("Encoding IntString, x=%d, s=%s\n", is.x, is.s);
+  labcomm2014_encode_simple_IntString(encoder, &is);
+
+  simple_theTwoInts ti;
+  ti.a = 13;
+  ti.b = 37;
+  printf("Encoding theTwoInts, a=%d, b=%d\n", ti.a, ti.b);
+  labcomm2014_encode_simple_theTwoInts(encoder, &ti);
+
+  simple_anotherTwoInts ati;
+  ati.a = 23;
+  ati.b = 47;
+  printf("Encoding anotherTwoInts, a=%d, b=%d\n", ati.a, ati.b);
+  labcomm2014_encode_simple_anotherTwoInts(encoder, &ati);
+
+  int foo[20];
+
+  labcomm2014_encoder_register_simple_TwoArrays(encoder);
+
+  simple_TwoArrays ta;
+  ta.fixed.a[0] = 17;
+  ta.fixed.a[1] = 42;
+  ta.variable.n_1 = 10;
+  ta.variable.a = foo;
+  
+  int k;
+  for(k=0; k<20; k++) {
+	foo[k] = k;
+  }
+
+  printf("Encoding TwoArrays...\n");
+  labcomm2014_encode_simple_TwoArrays(encoder, &ta);
+
+  ti.a = 23;
+  ti.b = 47;
+  printf("Encoding theTwoInts, a=%d, b=%d\n", ti.a, ti.b);
+  labcomm2014_encode_simple_theTwoInts(encoder, &ti);
+
+
+  simple_TwoFixedArrays tfa;
+
+  tfa.a.a[0] = 41;
+  tfa.a.a[1] = 42;
+
+  tfa.b.a[0][0] = 51;
+  tfa.b.a[0][1] = 52;
+  tfa.b.a[0][2] = 53;
+  tfa.b.a[1][0] = 61;
+  tfa.b.a[1][1] = 62;
+  tfa.b.a[1][2] = 63;
+
+  printf("Encoding TwoFixedArrays...\n");
+  labcomm2014_encoder_register_simple_TwoFixedArrays(encoder);
+  labcomm2014_encode_simple_TwoFixedArrays(encoder, &tfa);
+
+  return 0;
+}

examples/simple/example_encoder.py

+#!/usr/bin/python
+
+import labcomm2014
+import sys
+import simple
+
+if __name__ == '__main__':
+    version = sys.argv[2] if len(sys.argv) == 3 else "LabComm2014"
+    encoder = labcomm2014.Encoder(labcomm2014.StreamWriter(open(sys.argv[1], 'w')), version)
+    encoder.add_decl(simple.theTwoInts.signature)
+    encoder.add_decl(simple.IntString.signature)
+    foo = simple.theTwoInts()
+    foo.a = 13
+    foo.b = 37
+    encoder.encode(foo, simple.theTwoInts.signature)
+
+    bar = simple.IntString()
+    bar.x = 1742
+    bar.s = "A string from Python"
+    encoder.encode(bar, simple.IntString.signature)