Revision 0:aeaa6d2120a3, committed 2018-12-27

Comitter:

ransu

Date:

Thu Dec 27 19:21:42 2018 +0000

Commit message:

Initial commit to public.

Changed in this revision

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/EthernetInterface.lib	Thu Dec 27 19:21:42 2018 +0000
@@ -0,0 +1,1 @@
+http://mbed.org/users/mbed_official/code/EthernetInterface/#183490eb1b4a

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/README.md	Thu Dec 27 19:21:42 2018 +0000
@@ -0,0 +1,3 @@
+# RMCIOS-MBED
+RMCIOS implementation for mbed
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/RMCIOS-Mbed-module.lib	Thu Dec 27 19:21:42 2018 +0000
@@ -0,0 +1,1 @@
+https://github.com/fkorhone/RMCIOS-Mbed-module.git/#c79fbb492c8eb0e742f4a4acde1eac2bd99a2ce0

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/RMCIOS-Mbed.cpp	Thu Dec 27 19:21:42 2018 +0000
@@ -0,0 +1,84 @@
+/* 
+RMCIOS - Reactive Multipurpose Control Input Output System
+Copyright (c) 2018 Frans Korhonen
+
+RMCIOS was originally developed at Institute for Atmospheric 
+and Earth System Research / Physics, Faculty of Science, 
+University of Helsinki, Finland
+
+Assistance, experience and feedback from following persons have been 
+critical for development of RMCIOS: Erkki Siivola, Juha Kangasluoma, 
+Lauri Ahonen, Ella Häkkinen, Pasi Aalto, Joonas Enroth, Runlong Cai, 
+Markku Kulmala and Tuukka Petäjä.
+
+This file is part of RMCIOS. This notice was encoded using utf-8.
+
+RMCIOS is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+RMCIOS is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public Licenses
+along with RMCIOS.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+/*
+ * Changelog: (date,who,description)
+ */
+#define VERSION_STR "Mbed" 
+ 
+#include "mbed.h"
+#include "RMCIOS-system.h"
+#include "std_channels.h"
+#include "base_channels.h"
+#include "mbed_channels.h"
+
+#include <stdio.h>
+
+LocalFileSystem local("local") ;
+// data_handle_name,MAX_CLASSES,MAX_CHANNELS
+CREATE_STATIC_CHANNEL_SYSTEM_DATA (ch_sys_dat, 80, 180);  
+
+int main (void)
+{
+   printf ("\nRMCIOS - Reactive Multipurpose Control Input Output Systen\r\n["
+           "] \r\n");
+   printf ("Copyright (c) 2018 Frans Korhonen\n");
+   printf ("\nInitializing system:\r\n");
+   ////////////////////////////////////////////////////////////////////////
+   // Init channel system
+   ////////////////////////////////////////////////////////////////////////
+   const struct context_rmcios *context;
+   // init channel api system
+   set_channel_system_data ((struct ch_system_data *) &ch_sys_dat);     
+   context = get_rmios_context();
+
+   // Init channel modules:
+   init_base_channels(context) ;
+   init_std_channels(context) ;
+   init_mbed_channels(context) ;
+   init_mbed_platform_channels(context) ; 
+   
+   write_str(context, context->control, 
+             "read as control file /local/conf.ini\n", 0);
+   
+   ///////////////////////////////////////////////////////////////////////
+   // initial configuration 
+   ///////////////////////////////////////////////////////////////////////
+   printf ("\r\nSystem initialized!\r\n");
+
+   /////////////////////////////////////////////////////////////////////////
+   // reception loop
+   /////////////////////////////////////////////////////////////////////////
+   while (1)
+   {
+        wait(1) ;
+   }
+}
+
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/RMCIOS-base-module.lib	Thu Dec 27 19:21:42 2018 +0000
@@ -0,0 +1,1 @@
+https://github.com/fkorhone/RMCIOS-base-module/#e60fe77be2f1b3f54616c08d4d85ed579ee444de

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/RMCIOS-interface.lib	Thu Dec 27 19:21:42 2018 +0000
@@ -0,0 +1,1 @@
+https://github.com/fkorhone/RMCIOS-interface/#7a801428d84a5ee680957fc887934f01453e7268

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/RMCIOS-std-module.lib	Thu Dec 27 19:21:42 2018 +0000
@@ -0,0 +1,1 @@
+https://github.com/fkorhone/RMCIOS-std-module.git/#eb3fb80ee018fa193d9fc29ad8540cc901d7602c

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/RMCIOS-system.lib	Thu Dec 27 19:21:42 2018 +0000
@@ -0,0 +1,1 @@
+https://github.com/fkorhone/RMCIOS-system/#95dcd41cdbc5eb4f1f67bd782bec5bd9abe02262

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/context.c	Thu Dec 27 19:21:42 2018 +0000
@@ -0,0 +1,109 @@
+/* 
+RMCIOS - Reactive Multipurpose Control Input Output System
+Copyright (c) 2018 Frans Korhonen
+
+RMCIOS was originally developed at Institute for Atmospheric 
+and Earth System Research / Physics, Faculty of Science, 
+University of Helsinki, Finland
+
+Assistance, experience and feedback from following persons have been 
+critical for development of RMCIOS: Erkki Siivola, Juha Kangasluoma, 
+Lauri Ahonen, Ella Häkkinen, Pasi Aalto, Joonas Enroth, Runlong Cai, 
+Markku Kulmala and Tuukka Petäjä.
+
+This file is part of RMCIOS. This notice was encoded using utf-8.
+
+RMCIOS is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+RMCIOS is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public Licenses
+along with RMCIOS.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "RMCIOS-functions.h"
+
+// Channel function for allocating and freeing memory
+void stdout_func (void *data,
+               const struct context_rmcios *context, int id,
+               enum function_rmcios function,
+               enum type_rmcios paramtype,
+               union param_rmcios returnv,
+               int num_params, const union param_rmcios param)
+{
+    
+}
+
+// Channel function for allocating and freeing memory
+void mem_func (void *data,
+               const struct context_rmcios *context, int id,
+               enum function_rmcios function,
+               enum type_rmcios paramtype,
+               union param_rmcios returnv,
+               int num_params, const union param_rmcios param)
+{
+   switch (function)
+   {
+   case help_rmcios:
+      // MEMORY INTERFACE: 
+      return_string (context, paramtype, returnv,
+                     " read mem \r\n "
+                     "   -read ammount of free memory\r\n"
+                     " write mem \r\n "
+                     "   -read memory allocation block size\r\n"
+                     " write mem n_bytes \r\n "
+                     "   -Allocate n bytes of memory\r\n"
+                     "   -Returns address of the allocated memory\r\n"
+                     "   -On n_bytes < 0 allocates complete allocation blocks\r\n"
+                     "   -returns 0 length on failure\r\n"
+                     " write mem (empty) addr(buffer/id)\r\n"
+                     "   -free memory pointed by addr in buffer\r\n"
+                     );
+      break;
+
+   case write_rmcios:
+      if (num_params == 0)
+      {
+      } // Read memory allocation block size
+      if (num_params == 1)      // Allocate n bytes of memory
+      {
+         void *ptr = malloc (param_to_integer (context, paramtype,
+                                               (const union param_rmcios)
+                                               param, 0));
+         //printf("allocated %x\n",ptr) ;
+         return_binary (context, paramtype, returnv, (char *) &ptr,
+                        sizeof (ptr));
+      }
+      if (num_params > 1)
+      {
+      } // Write data to memory by access id
+      if (num_params > 2)
+      {
+      } // +max size in bytes
+      if (num_params > 3)
+      {
+      } // +starting at offset
+      if (num_params == 2)      // Free 
+      {
+         if (param_to_integer
+             (context, paramtype, (const union param_rmcios) param, 0) == 0)
+         {
+            char *ptr = 0;
+            param_to_binary (context, paramtype, param, 1,
+                             sizeof (ptr), (char *) &ptr);
+            //printf("freeing: %x\n",ptr) ;
+            if (ptr != 0)
+               free (ptr);
+         }
+      }
+      break;
+   }
+}
+
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/mbed-rtos.lib	Thu Dec 27 19:21:42 2018 +0000
@@ -0,0 +1,1 @@
+http://mbed.org/users/mbed_official/code/mbed-rtos/#5713cbbdb706

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/mbed.bld	Thu Dec 27 19:21:42 2018 +0000
@@ -0,0 +1,1 @@
+https://os.mbed.com/users/mbed_official/code/mbed/builds/994bdf8177cb
\ No newline at end of file

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/mbed_ethernet_channels.cpp	Thu Dec 27 19:21:42 2018 +0000
@@ -0,0 +1,474 @@
+/* 
+RMCIOS - Reactive Multipurpose Control Input Output System
+Copyright (c) 2018 Frans Korhonen
+
+RMCIOS was originally developed at Institute for Atmospheric 
+and Earth System Research / Physics, Faculty of Science, 
+University of Helsinki, Finland
+
+Assistance, experience and feedback from following persons have been 
+critical for development of RMCIOS: Erkki Siivola, Juha Kangasluoma, 
+Lauri Ahonen, Ella Häkkinen, Pasi Aalto, Joonas Enroth, Runlong Cai, 
+Markku Kulmala and Tuukka Petäjä.
+
+This file is part of RMCIOS. This notice was encoded using utf-8.
+
+RMCIOS is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+RMCIOS is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public Licenses
+along with RMCIOS.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#if DEVICE_ETHERNET == 1
+
+#include "EthernetInterface.h"
+#include "RMCIOS-functions.h"
+
+extern const struct context_rmcios *module_context ; 
+
+//////////////////////////////////////////////////////////////////////
+// Ethernet interface channel
+//////////////////////////////////////////////////////////////////////
+EthernetInterface enet ;
+EthernetInterface *eth=&enet ;
+char eth_configured=0;
+
+void ethernet_class_func(const struct context_rmcios *context, 
+                         void *data, int id, int function,
+                         enum type_rmcios paramtype,
+                         union param_rmcios returnv, 
+                         int num_params,union param_rmcios param)
+{
+ int iplen ;
+ int masklen ;
+ int gwlen ;
+ switch(function) 
+ {
+    case help_rmcios:
+       return_string(context, paramtype,returnv,
+             "help for ethernet interface channel\r\n"
+             " setup eth # Configure ethernet with DHCP\r\n"
+             " setup eth ip_addr ipmask gateway # Manual configuration\r\n"
+             ) ;
+       break ;
+
+    case setup_rmcios :
+       // Allocate ethernet interface.
+       if(eth==NULL) eth = new EthernetInterface ;
+       if(eth==NULL) break ;
+       if(eth_configured==1) {
+          return_string(context, paramtype,returnv,
+                "Ethernet can only be configured once.") ;
+          break ;
+       }
+
+       if(num_params<3) {
+          return_string(context, paramtype,returnv,
+                "Configuring ethernet with DHCP:") ;
+          eth_configured=1;
+          eth->init() ; // dhcp config
+          eth->connect();
+
+          return_string(context, paramtype,returnv,
+                "Ethernet configuration:\r\n") ;
+          return_string(context, paramtype,returnv,"ip:");
+          return_string(context, paramtype,returnv,eth->getIPAddress());
+          return_string(context, paramtype,returnv,"\r\nipmask:");
+          return_string(context, paramtype,returnv,eth->getNetworkMask());
+          return_string(context, paramtype,returnv,"\r\ngateway:");
+          return_string(context, paramtype,returnv,eth->getGateway());
+          return_string(context, paramtype,returnv,"\r\n");
+          break ;
+       }
+
+       iplen = param_string_length(context, paramtype, param, 0)+1;
+       masklen = param_string_length(context, paramtype, param, 1)+1;
+       gwlen = param_string_length(context, paramtype, param, 2)+1;
+       {
+
+          char ip[iplen] ;
+          char ipmask[masklen] ;
+          char gateway[gwlen] ;
+          param_to_string(context, paramtype, param, 0, iplen, ip);
+          param_to_string(context, paramtype, param, 1, masklen, ipmask);
+          param_to_string(context, paramtype, param, 2, gwlen, gateway);
+
+          printf("setup manual ip: %s %s %s\r\n", ip, ipmask, gateway) ;
+          eth_configured=1;
+          eth->init(ip,ipmask,gateway) ; // manual ip config
+          eth->connect();
+
+          return_string(context, paramtype,returnv,
+                        "Ethernet configuration:\r\n") ;
+          return_string(context, paramtype, returnv, "ip:");
+          return_string(context, paramtype, returnv, eth->getIPAddress());
+          return_string(context, paramtype, returnv, "\r\nipmask:");
+          return_string(context, paramtype, returnv, eth->getNetworkMask());
+          return_string(context, paramtype, returnv, "\r\ngateway:");
+          return_string(context, paramtype, returnv, eth->getGateway());
+          return_string(context, paramtype, returnv, "\r\n");
+       }
+       break ;
+ }
+}
+
+////////////////////////////////////////////////////////////////////////
+// TCP Client channel:
+////////////////////////////////////////////////////////////////////////
+struct tcp_connection_data {
+    char host[50] ;
+    int port ;
+    TCPSocketConnection socket;
+    bool closed ;
+};
+
+void tcp_client_class_func(void* data,
+                           const struct context_rmcios *context,
+                           int id, 
+                           int function,
+                           enum type_rmcios paramtype,
+                           union param_rmcios returnv, 
+                           int num_params,
+                           union param_rmcios param)
+{
+    tcp_connection_data *p_data=(tcp_connection_data *)data ;
+    int plen ;
+    switch(function) {
+        case help_rmcios:
+           return_string(context, paramtype, returnv,
+           "help for tcp client channel\r\n"
+           " create tcp_client newname\r\n"
+           " setup newname ip port #Open connection\r\n"
+           " setup newname #Close connection\r\n"
+           " write newname #Flush all buffers\r\n"
+           " write newname data #Write data to the connection.\r\n"
+           "       Reconnect if needed\r\n"
+           " link newname channel # Link received data to channel\r\n"
+           ) ;
+            break ;
+        case create_rmcios :
+            if(num_params<1) break ;
+            if(eth==NULL) break ;
+            
+            // allocate new data
+            p_data= new struct tcp_connection_data; 
+
+            // default values
+            p_data->host[0]=0;
+            p_data->port=0;
+            p_data->closed=true ;
+
+            create_channel_param(context, paramtype, param, 0, 
+                                 (class_rmcios)tcp_client_class_func, p_data) ; 
+                                 
+            break ;
+        case setup_rmcios :
+            if(p_data==NULL) break ;
+            if(num_params<1) { // Close connection
+                Thread::wait(500);
+                if(p_data==NULL) break ;
+                if(p_data->socket.is_connected()) p_data->socket.close();
+                break ;
+            }
+            if(num_params<2) break ;
+            param_to_string(context, paramtype, param, 0, 
+                            sizeof(p_data->host),p_data->host) ;
+            p_data->port=param_to_int(context, paramtype,param,1) ;
+            p_data->closed=true ;
+            break ;
+
+        case write_rmcios :
+            if(p_data==NULL) break ;
+            if(num_params<1) { // Close connection
+                Thread::wait(500);
+                if(p_data==NULL) break ;
+                if(p_data->socket.is_connected()) p_data->socket.close();
+                break ;
+            }
+
+            /// If socket is not open. Try 3 times to open connection:
+            if(!p_data->socket.is_connected() || p_data->closed==true ) {
+                if(p_data->socket.connect(p_data->host,p_data->port)==0) {
+                   p_data->closed=false ;
+                }
+                else p_data->closed=false ;
+            }
+            if(!p_data->socket.is_connected() || p_data->closed==true ) {
+                Thread::wait(200);
+                if(p_data->socket.connect(p_data->host,p_data->port)==0) {
+                   p_data->closed=false ;
+                }
+                else p_data->closed=false ;
+            }
+            if(!p_data->socket.is_connected() || p_data->closed==true ) {
+                Thread::wait(200);
+                if(p_data->socket.connect(p_data->host,p_data->port)==0) {
+                   p_data->closed=false ;
+                }
+                else p_data->closed=false ;
+            }
+
+            plen=param_buffer_alloc_size(context, paramtype,param,0) ;
+            {
+                char buffer[plen] ;
+                int retry;
+                struct buffer_rmcios p ;
+                p=param_to_buffer(context, paramtype,param, 0, plen, buffer) ;
+                // retry 3 times
+                for(retry=0 ;
+                    retry<3 && p_data->socket.send(p.data, p.length )<0 ;
+                    retry++)
+                { 
+                    Thread::wait(200);
+                }
+                Thread::wait(100);
+            }
+            break ;
+    }
+}
+
+///////////////////////////////////////////////////////
+// TCP server channel
+////////////////////////////////////////////////////////
+struct tcpserver_data {
+    int port ;
+    TCPSocketServer socket ;
+    TCPSocketConnection connection;
+    int linked_channels ;
+    char buffer[512] ;
+    int id ;
+};
+
+//! Thread for handling udp reception.
+void tcpserver_thread(const void *param)
+{
+    printf("tcp server thread created!\r\n") ;
+    int n=0 ;
+    struct tcpserver_data *pthis=(struct tcpserver_data *) param ;
+    
+    while(pthis->port==0) ;
+    {
+        Thread::wait(200);
+    }
+    
+    pthis->socket.bind(pthis->port) ;
+    pthis->socket.listen();
+    
+    while(1) {
+        pthis->socket.accept( pthis->connection )  ;
+        printf("connection accepted!\r\n") ;
+        // receive command
+        while( pthis->connection.is_connected() ) {
+            n=pthis->connection.receive(pthis->buffer,sizeof( pthis->buffer)-1);
+            if(n>0) {
+                if( pthis->linked_channels!=0) {
+                   write_buffer(module_context, pthis->linked_channels,
+                                pthis->buffer,n,pthis->id) ;
+                } 
+           }
+        }
+    }
+}
+
+void tcp_server_class_func(struct tcpserver_data *pthis, 
+                           const struct context_rmcios *context,
+                           int id, 
+                           int function,
+                           enum type_rmcios paramtype,
+                           union param_rmcios returnv, 
+                           int num_params,
+                           union param_rmcios param)
+{
+    int plen;
+    switch(function) {
+        case help_rmcios:
+            return_string(context, paramtype, returnv, 
+                          "TCP server channel\r\n"
+                          "create tcpserver newname\r\n"
+                          "setup newname port\r\n"
+                          "write newname data\r\n"
+                          "link newname channel\r\n"
+                          );
+            break;
+
+        case create_rmcios :
+            if(num_params<1) break ;
+            pthis=  (struct tcpserver_data *) 
+                    malloc(sizeof( struct tcpserver_data)) ; 
+            
+            pthis->port=0 ;
+            pthis->buffer[0]=0;
+            pthis->socket=TCPSocketServer();
+            pthis->connection=TCPSocketConnection();
+            
+            pthis->id=create_channel_param(context, paramtype, param, 0,
+                                           (class_rmcios)tcp_server_class_func,
+                                           pthis); 
+            pthis->linked_channels=linked_channels(context, pthis->id) ;
+            break;
+
+        case setup_rmcios :
+            if(pthis==NULL) break ;
+            if(num_params<1) {
+                if( !pthis->connection.is_connected() ){
+                   pthis->connection.close() ;
+                }
+                break ;
+            }
+            pthis->port=param_to_integer(context, paramtype, param,0);
+            
+            // Start reception thread
+            new Thread(tcpserver_thread, pthis);
+            break;
+
+        case write_rmcios :
+            if(pthis==NULL) break ;
+            if(num_params<1) break ;
+            plen=param_buffer_alloc_size(context, paramtype, param, 0) ; 
+            {
+                char buffer[plen] ; 
+                struct buffer_rmcios pbuffer ; 
+                pbuffer = param_to_buffer(context, paramtype,param, 0, 
+                                          plen , buffer) ;
+                if(pthis->connection.send(pbuffer.data, pbuffer.length)<0){
+                    return_int(context, paramtype, returnv, -1) ;
+                    pthis->connection.close() ;
+                }
+            }
+            break;
+    }
+}
+
+///////////////////////////////////////////////////////
+// UDP server channel
+////////////////////////////////////////////////////////
+struct udp_server_data {
+    int id ;
+    int port ;
+    UDPSocket socket ;
+    Endpoint client ;
+    char txbuffer[100] ;
+    char buffer[100] ;
+    int linked_channel ;
+} ;
+
+//! Thread for handling udp reception.
+void udp_server_thread(const void *param)
+{
+    //printf("udp thread created!\r\n") ;
+    int n=0 ;
+    struct udp_server_data *p_data=(struct udp_server_data *) param ;
+    //printf("waiting for configuration:\r\n") ;
+    while(p_data->port==0) ;
+    {
+        p_data->socket.bind(p_data->port) ;
+        Thread::wait(200);
+    }
+    while(1) {
+        // receive command
+        n=p_data->socket.receiveFrom(p_data->client, p_data->buffer, 
+                                     sizeof(p_data->buffer)-1 ) ;
+        if(n>0) {
+            if(p_data->linked_channel!=0){
+               write_buffer(module_context, p_data->linked_channel, 
+                            p_data->buffer, n, p_data->id) ;
+            }
+        }
+    }
+}
+
+void udp_server_class_func(udp_server_data *p_data,  
+                           const struct context_rmcios *context,
+                           int id, 
+                           int function,
+                           enum type_rmcios paramtype,
+                           union param_rmcios returnv, 
+                           int num_params,union param_rmcios param)
+{
+ switch(function) 
+ {
+    case help_rmcios :
+       return_string(context, paramtype, returnv,
+             "help for udp server channel\r\n"
+             " create udp_server newname\r\n"
+             " setup newname port \r\n"
+             " write newname \r\n"
+             "        # flush tansmit buffer)\r\n"
+             " write newname data \r\n"
+             "        # write data to tansmit buffer.\r\n"
+             "        Flush buffer to ethernet when \\r encountered. \r\n"
+             " link newname channel \r\n"
+             "        # Link received data to channel\r\n"
+             ) ;
+
+       break ;
+    case create_rmcios :
+       if(num_params<1) break ;
+       if(eth==NULL) break ;
+       p_data= new struct udp_server_data ;
+       if(p_data==NULL) break ;
+
+       // Default values:
+       p_data->port=0;
+       p_data->buffer[0]=0;
+       p_data->txbuffer[0]=0 ;
+
+       // Create the channel
+       p_data->id=create_channel_param(context, paramtype, param, 0, 
+                                       (class_rmcios)udp_server_class_func, 
+                                       p_data) ;
+
+       p_data->linked_channel=linked_channels(context,p_data->id);
+       break ;
+    case setup_rmcios :
+
+       if(p_data==NULL) break ;
+       if(num_params<1) break ;
+       else {
+          p_data->port=param_to_int(context, paramtype, param, 0);
+          new Thread(udp_server_thread, p_data);
+       }
+       break ;
+
+    case write_rmcios :
+       if(p_data==NULL) break ;
+       if(num_params<1) { // flush buffer
+          p_data->socket.sendTo(p_data->client, p_data->txbuffer, 
+                                strlen(p_data->txbuffer));
+          p_data->txbuffer[0]=0 ;
+          break ;
+       }
+
+       // collect data to buffer
+       param_to_string(context, paramtype, param, 0, 
+                       sizeof(p_data->txbuffer)-strlen(p_data->txbuffer), 
+                       p_data->txbuffer+strlen(p_data->txbuffer)) ;
+       break ;
+ }
+}
+
+void init_mbed_ethernet_channels(const struct context_rmcios *context)
+{
+    module_context=context ;
+    create_channel_str(context, "eth",(class_rmcios)ethernet_class_func, NULL);
+    create_channel_str(context, "udp_server",
+                       (class_rmcios)udp_server_class_func, NULL ) ;
+
+    // TCP Not usable. (Memory consumption issues.)
+    // create_channel_str("tcp_client",(channel_func) tcp_client_class_func, 
+    //                    NULL ) ;
+    // create_channel_str("tcp_server",(channel_func) tcp_server_class_func, 
+    //                    NULL ) ;
+}
+
+#endif //if DEVICE_ETHERNET == 1
+
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/string-conversion.c	Thu Dec 27 19:21:42 2018 +0000
@@ -0,0 +1,43 @@
+#include "string-conversion.h"
+
+#include <stdlib.h>
+#include <stdio.h>
+
+/* String to float converter 
+ * @param str String to convert from
+ * returns the converted value. Returns 0 on failure. */
+int string_to_integer (const char *str)
+{
+   return strtol (str, NULL, 0);
+}
+
+/* String to float converter 
+ * @param str String to convert from
+ * returns the converted value. Returns 0 on failure. */
+double string_to_float (const char *str)
+{
+   return strtof (str, NULL);
+}
+
+/* Integer to string converter 
+ * @param buffer buffer to write to
+ * @param len size of buffer
+ * @param value number to convert
+ * @return number of characters the full string representation needs. */
+int integer_to_string (char *buffer, int len, int value)
+{
+   return snprintf (buffer, len, "%d", value);
+}
+
+/* Float to string converter 
+ * @param buffer buffer to write to
+ * @param len size of buffer
+ * @param value Number to convert
+ * @return number of characters the full string representation needs.*/
+int float_to_string (char *buffer, int len, double value)
+{
+   return snprintf (buffer, len, "%g", value);
+}
+
+
+