File content as of revision 14:e05e0e5177e7:

#ifndef TELEMETRY
#define TELEMETRY

//#define DEBUG

#include "mbed.h"
#include "EthernetInterface.h"

/* Ethernet Interface for send/receive Datastructs over udp 
 
  By Sebastian Donner
 
  Permission is hereby granted, free of charge, to any person
  obtaining a copy of this software and associated documentation
  files (the "Software"), to deal in the Software without
  restriction, including without limitation the rights to use,
  copy, modify, merge, publish, distribute, sublicense, and/or sell
  copies of the Software, and to permit persons to whom the
  Software is furnished to do so, subject to the following
  conditions:
 
  The above copyright notice and this permission notice shall be
  included in all copies or substantial portions of the Software.
  
  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
  OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
  HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
  WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  OTHER DEALINGS IN THE SOFTWARE.
 
  @code
  #include "mbed.h"
  #include "Telemetry.h"
 
  Telemetry Network(p21,p22);

  Serial debug(USBTX, USBRX);
  uint8_t buffer[255];
  int     SELF_PORT        = 8889;

  typedef struct struct_test
  {
  struct_test()
  :length(9), ID(0)
  {}
  uint8_t  length              ;//1
  uint8_t  ID                  ;//2
  uint8_t  flag_bit0      : 1  ;//3.0
  uint8_t  flag_bit1      : 1  ;//3.1
  uint8_t  flagbyte_2          ;//4
  uint16_t word                ;//6
  int16_t counter             ;//8
  uint8_t  cs                  ;//9
  } Tstruct_test;
 
 
  struct_test  test;
 
  uint8_t* struct_id[5];
 
  main()
  {
   debug.baud(115200);
   Network.InitEthernetConnection();
   Network.ConnectSocket_UDP_Client();
   Network.ConnectSocket_UDP_Server(SELF_PORT);
 
   struct_id[0]=&test.length;
 
   debug.printf("%s",Network.ip_self);
   while(1)
   {
    Network.Rec_Data_UDP_Server((char*)buffer, 255);
    if (Network.Rec_Struct(buffer))                  // receive and CS check
    {
     uint8_t* b_pointer;
 
     b_pointer = struct_id[buffer[1]];     // Pointer to received Struct
 
     for(int i = 0; i < (buffer[0]); i++)  // Copy buffer to Struct
     {
       b_pointer = buffer[i];
       b_pointer++;
     }
 
     b_pointer = struct_id[buffer[1]];     // Pointer to received Struct
 
     Network.Send_Struct_UDP_Client(Network.input_Server, b_pointer); // Send received Struct back to sender
    }
 
    wait(1);
   }
  }
 @endcode
 */ 



class Telemetry
{
    public:
        //! Create Ethernet Interface
        Telemetry(PinName ora, PinName gre);
        
        DigitalOut orange;
        DigitalOut green;
        
        //! IP Address of mbed Interface
        char* ip_self;

        //! IP Addess and Port of databank Server
        Endpoint db_server;

        //! IP Addess and Port of control Server
        Endpoint controller;

        //! IP Addess and Port of MSG on Server Port
        Endpoint input_Server;
        
        //! IP Addess and Port of MSG on Client Port
        Endpoint input_Client;

        
        #ifdef DEBUG
        void InitUSBSerialConnection();
        #endif

        //! init with DHCP
        bool InitEthernetConnection();

        //! init with Static IP
        bool InitEthernetConnection(const char* IPAdress, const char* SubNetMask, const char* GateWay);


        //! Close Connection
        void CloseEthernetConnection();

        
        //! Connect Port TCP 
        void ConnectSocket_TCP(Endpoint Host);
        
        //! Connect Port for UDP Client  
        void ConnectSocket_UDP_Client();
        
        //! Connect Port for UDP Server
        void ConnectSocket_UDP_Server(int Port);

        
        //! Close Port TCP
        void CloseSocket_TCP();
        
        //! Close Port UDP Client
        void CloseSocket_UDP_Client();
        
        //! Close Port UDP send
        void CloseSocket_UDP_Server();

        
        //! Struct Check Sum calc
        uint8_t do_cs(uint8_t *buffer); 
    
        
        //! Read UDP Packet on Client Port
        int  Rec_Data_UDP_Client(char *buffer, int size);

        //! Read UDP Packet on Server Port
        int  Rec_Data_UDP_Server(char *buffer, int size);
        
        //! Check Packet of containing Struct 
        bool Rec_Struct(uint8_t *buffer);
        
        //! Read TCP Packet
        int  Rec_Data_TCP(char *buffer, int size);

        
        //! Send UDP Packet as Client
        void Send_Data_UDP_Client(Endpoint Server, char* Daten, int size);

        //! Send UDP Packet as Server
        void Send_Data_UDP_Server(Endpoint Client, char* Daten, int size);
                
        //! Send Struct as UDP Client
        void Send_Struct_UDP_Client(Endpoint Server, uint8_t* Daten);
        
        //! Send Struct as UDP Server
        void Send_Struct_UDP_Server(Endpoint Client, uint8_t* Daten);       
       
       
        //! Send TCP Packet
        void Send_Data_TCP(char* Host, char* Daten);
        
        
    private:
        bool InitSucceed;    
        
};

#endif