changes for PubSub Subscriber

arch/patmos/CMakeLists.txt

@@ -4,7 +4,7 @@ ua_add_architecture("patmos")
 
 if("${UA_ARCHITECTURE}" STREQUAL "patmos")
 
-option(UA_PATMOS_WCET "Enable Patmos WCET" OFF)
+option(UA_PATMOS_WCET "Enable Patmos WCET" ON)
 
 ua_architecture_add_definitions(-Wno-error)
 

arch/patmos/ua_architecture.h

@@ -80,12 +80,17 @@
 #define SAME_AS(x)		(const char *)&errno_message[x]
 
 int udp_send_mac(unsigned int tx_addr, unsigned int rx_addr, unsigned char destination_mac[], unsigned char destination_ip[], unsigned short source_port, unsigned short destination_port, unsigned char data[], unsigned short data_length, long long timeout);
+unsigned eth_mac_receive_nb(unsigned int rx_addr);
 
+unsigned char udp_get_data(unsigned int pkt_addr, unsigned char data[], unsigned int data_length);
+unsigned short int udp_get_data_length(unsigned int pkt_addr);
+unsigned short int udp_get_destination_port(unsigned int pkt_addr);
 
-#define UA_free free
-#define UA_malloc malloc
-#define UA_calloc calloc
-#define UA_realloc realloc
+#define UA_free free_patmos
+#define UA_malloc malloc_patmos
+#define UA_calloc calloc_patmos
+#define UA_realloc realloc_patmos
+#define UA_memset memset_patmos
 
 #define UA_snprintf snprintf
 

arch/patmos/ua_architecture_functions.c

@@ -86,6 +86,9 @@ ssize_t send(int sockfd, const void *buf, size_t len, int flags)
 }
 
 #define BROADCAST_MAC (unsigned char[6]) {0xFF,0xFF,0xFF,0xFF,0xFF,0xFF}
+#define OPCUA_PUBSUB_PORT 4840
+#define SRCPORT 1234
+
 ssize_t sendto(int sockfd, const void *buf, size_t len, int flags,
                const struct sockaddr *dest_addr, socklen_t addrlen)
 {
@@ -95,11 +98,8 @@ ssize_t sendto(int sockfd, const void *buf, size_t len, int flags,
     unsigned int tx_addr = 0x800;
     static unsigned char target_ip[4] = {224, 0, 0, 22};
 
-    #define PORT 4840
-    #define SRCPORT 1234
-
     //printf("send(%i bytes)\n", (int)len);
-    udp_send_mac(tx_addr, rx_addr, BROADCAST_MAC, target_ip, SRCPORT, PORT, (unsigned char *)buf, len, 10);
+    udp_send_mac(tx_addr, rx_addr, BROADCAST_MAC, target_ip, SRCPORT, OPCUA_PUBSUB_PORT, (unsigned char *)buf, len, 10);
     //arp_table_print();
 
     return len;
@@ -114,8 +114,47 @@ ssize_t recv(int sockfd, void *buf, size_t len, int flags)
 ssize_t recvfrom(int sockfd, void *buf, size_t len, int flags,
                  struct sockaddr *src_addr, socklen_t *addrlen)
 {
-    printf("recvfrom(%i bytes)\n", (int)len);
-    return len;
+    size_t msg_length = -1;
+    //enum eth_protocol packet_type;
+
+    unsigned int rx_addr = 0x000;
+    unsigned int tx_addr = 0x800;
+
+    {
+        unsigned ret = eth_mac_receive_nb(rx_addr);
+        if(ret == 1)
+        {
+            unsigned char packet_type = mac_packet_type(rx_addr);
+
+            //printf("packet_type %i %i\n", packet_type, ret);
+            switch (packet_type) {
+                //case 6: //ARP
+                    //arp_process_received(rx_addr, tx_addr);
+                    //return -1;
+                case 3: //UDP
+                        //printf("DST_PORT %i\n", udp_get_destination_port(rx_addr));
+                    if( udp_get_destination_port(rx_addr)  == OPCUA_PUBSUB_PORT)
+                    {
+                        msg_length = udp_get_data_length(rx_addr);
+                        //printf("Message Length %i\n", msg_length);
+                        if(len >= msg_length)
+                        {
+                            udp_get_data(rx_addr, buf, msg_length);
+                        }
+                        else {
+                            return -1; 
+                        }
+                    }
+                    else
+                        return -1; 
+                    break;
+                default:
+                    return -1;
+            }
+        }
+    }
+
+    return msg_length;
 }
 
 int getaddrinfo(const char *node, const char *service,
@@ -167,4 +206,130 @@ __uint16_t ntohs(__uint16_t v) {
   return htons(v);
 }
 
+#define MEMORY_DEBUG
+
+#define MEMORY_BLOCKS 32
+#define MEMORY_BLOCK_SIZE 512
+unsigned char memory[MEMORY_BLOCKS][MEMORY_BLOCK_SIZE];
+bool memory_free[MEMORY_BLOCKS]= {0};
+
+#ifdef MEMORY_DEBUG
+# define MEMORY_DEBUG_PRINT(x) printf x
+#else
+# define MEMORY_DEBUG_PRINT(x)
+#endif
+
+void print_memory_usage()
+{
+    for(int i=0;i<MEMORY_BLOCKS;i++)
+    {
+        MEMORY_DEBUG_PRINT(("%i", memory_free[i] ));
+    }
+    MEMORY_DEBUG_PRINT(("\n"));
+}
+
+void *malloc_patmos(size_t size)
+{
+    int i;
+    MEMORY_DEBUG_PRINT(("malloc(%i)\n", size));
+
+    if(size > MEMORY_BLOCK_SIZE)
+    {
+        MEMORY_DEBUG_PRINT(("malloc() memory limit exceeded!\n"));
+        return NULL;
+    }
+
+    _Pragma("loopbound min 1 max 32") // MEMORY_BLOCKS
+    for(i=0;i<MEMORY_BLOCKS;i++)
+    {
+        if(memory_free[i]==0) 
+        {
+            MEMORY_DEBUG_PRINT(("malloc() block number %i! %p\n", i, &memory[i][0]));
+            memory_free[i] = 1;
+
+            print_memory_usage();
+
+            return (void *)&memory[i][0];
+        }
+    }
+    MEMORY_DEBUG_PRINT(("malloc() no free memory block!\n"));
+    return NULL;
+}
+
+void *calloc_patmos(size_t nitems, size_t size)
+{
+    int i;
+    MEMORY_DEBUG_PRINT(("calloc(%i, %i)\n", nitems, size));
+
+    if(size*nitems > MEMORY_BLOCK_SIZE)
+    {
+        MEMORY_DEBUG_PRINT(("calloc() no free memory block!\n"));
+        return NULL;
+    }
+
+    _Pragma("loopbound min 1 max 32") // MEMORY_BLOCKS
+    for(i=0;i<MEMORY_BLOCKS;i++)
+    {
+        if(memory_free[i]==0) 
+        {
+            MEMORY_DEBUG_PRINT(("calloc() block number %i! %p\n", i, &memory[i][0]));
+            memory_free[i] = 1;
+
+            print_memory_usage();
+
+            return (void *)&memory[i][0];
+        }
+    }
+    MEMORY_DEBUG_PRINT(("calloc() no free memory block!\n"));
+    return NULL;
+}
+
+void *realloc_patmos(void *ptr, size_t size)
+{
+    MEMORY_DEBUG_PRINT(("realloc(%p, %i)\n", ptr, size));
+
+    if(size > MEMORY_BLOCK_SIZE)
+    {
+        MEMORY_DEBUG_PRINT(("realloc() memory limit exceeded!\n"));
+        return NULL;
+    }
+}
+
+void free_patmos(void *p)
+{
+    int i;
+    MEMORY_DEBUG_PRINT(("free(%p)\n", p));
+
+    if(p == NULL) return;
+
+    _Pragma("loopbound min 1 max 32") // MEMORY_BLOCKS
+    for(i=0;i<MEMORY_BLOCKS;i++)
+    {
+        if( (void*)&memory[i][0] == p) 
+        {
+            MEMORY_DEBUG_PRINT(("free() block number %i!\n", i));
+            memory_free[i] = 0;
+
+            print_memory_usage();
+
+            return;
+        }
+    }
+    MEMORY_DEBUG_PRINT(("free() no matching block found!\n"));
+}
+
+void *memset_patmos(void *str, int c, size_t n)
+{
+    MEMORY_DEBUG_PRINT(("memset(%p, %i, %i)\n", str, c, n));
+
+    unsigned char *str_buffer = str;
+
+    _Pragma("loopbound min 1 max 512") // MEMORY_BLOCK_SIZE
+    for(int i=0;i<n;i++)
+    {
+        str_buffer[i] = c;
+    }
+    return str;
+}
+
 #endif /* UA_ARCHITECTURE_PATMOS */

arch/patmos/ua_clock.c

@@ -14,15 +14,15 @@
 #define UA_DATETIME_UNIX_EPOCH (11644473600LL * UA_DATETIME_SEC)
 
 UA_DateTime UA_DateTime_now(void) {
-    printf("UA_DateTime_now");
+    //printf("UA_DateTime_now");
     return UA_DATETIME_UNIX_EPOCH;// + get_cpu_usecs()*60/UA_DATETIME_USEC; //us is 60Hz
 }
 UA_DateTime UA_DateTime_nowMonotonic(void) {
-    printf("UA_DateTime_nowMonotonic");
+    //printf("UA_DateTime_nowMonotonic");
     return 0;
 }
 UA_Int64 UA_DateTime_localTimeUtcOffset(void) {
-    printf("UA_DateTime_localTimeUtcOffset");
+    //printf("UA_DateTime_localTimeUtcOffset");
     return 0;
 }
 

plugins/ua_pubsub_udp.c

@@ -374,6 +374,7 @@ UA_PubSubChannelUDPMC_receive(UA_PubSubChannel *channel, UA_ByteString *message,
     }
     UA_PubSubChannelDataUDPMC *channelConfigUDPMC = (UA_PubSubChannelDataUDPMC *) channel->handle;
 
+#ifndef UA_ARCHITECTURE_PATMOS
     if(timeout > 0) {
         fd_set fdset;
         FD_ZERO(&fdset);
@@ -391,8 +392,9 @@ UA_PubSubChannelUDPMC_receive(UA_PubSubChannel *channel, UA_ByteString *message,
             return UA_STATUSCODE_BADINTERNALERROR;
         }
     }
+#endif
 
-    if(channelConfigUDPMC->ai_family == PF_INET){
+    //if(channelConfigUDPMC->ai_family == PF_INET){
         ssize_t messageLength;
         messageLength = UA_recvfrom(channel->sockfd, message->data, message->length, 0, NULL, NULL);
         if(messageLength > 0){
@@ -404,7 +406,7 @@ UA_PubSubChannelUDPMC_receive(UA_PubSubChannel *channel, UA_ByteString *message,
     } else {
         //TODO implement recieve for IPv6
 #endif
-    }
+    //}
     return UA_STATUSCODE_GOOD;
 }
 

src/pubsub/ua_pubsub_networkmessage.c

@@ -367,7 +367,7 @@ UA_NetworkMessage_encodeBinary(const UA_NetworkMessage* src, UA_Byte **bufPos,
 static UA_StatusCode
 UA_NetworkMessage_decodeBinaryInternal(const UA_ByteString *src, size_t *offset,
                                        UA_NetworkMessage* dst) {
-    memset(dst, 0, sizeof(UA_NetworkMessage));
+    UA_memset(dst, 0, sizeof(UA_NetworkMessage));
     UA_Byte v = 0;
     UA_StatusCode rv = UA_Byte_decodeBinary(src, offset, &v);
     if(rv != UA_STATUSCODE_GOOD)
@@ -536,6 +536,7 @@ UA_NetworkMessage_decodeBinaryInternal(const UA_ByteString *src, size_t *offset,
             return rv;
     }
 
+#ifndef UA_PATMOS_WCET  // disable PromotedFields
     // PromotedFields 
     if(dst->promotedFieldsEnabled) {
         // Size
@@ -571,7 +572,9 @@ UA_NetworkMessage_decodeBinaryInternal(const UA_ByteString *src, size_t *offset,
             } while ((*offset) < offsetEnd);
         }
     }
+#endif // UA_PATMOS_WCET
 
+#ifndef UA_PATMOS_WCET  // disable Security
     // SecurityHeader
     if(dst->securityEnabled) {
         // SecurityFlags
@@ -623,6 +626,7 @@ UA_NetworkMessage_decodeBinaryInternal(const UA_ByteString *src, size_t *offset,
                 return rv;
         }
     }
+#endif // UA_PATMOS_WCET
 
     // Payload
     if(dst->networkMessageType != UA_NETWORKMESSAGE_DATASET)
@@ -652,6 +656,7 @@ UA_NetworkMessage_decodeBinaryInternal(const UA_ByteString *src, size_t *offset,
     if(rv != UA_STATUSCODE_GOOD)
         return rv;
 
+#ifndef UA_PATMOS_WCET  // disable Security
     if(dst->securityEnabled) {
         // SecurityFooter
         if(dst->securityHeader.securityFooterEnabled && (dst->securityHeader.securityFooterSize > 0)) {
@@ -673,6 +678,7 @@ UA_NetworkMessage_decodeBinaryInternal(const UA_ByteString *src, size_t *offset,
                 return rv;
         }
     }
+#endif // UA_PATMOS_WCET
 
     return UA_STATUSCODE_GOOD;
 }
@@ -891,7 +897,7 @@ UA_NetworkMessage_deleteMembers(UA_NetworkMessage* p) {
        UA_String_deleteMembers(&p->publisherId.publisherIdString);
     }
 
-    memset(p, 0, sizeof(UA_NetworkMessage));
+    UA_memset(p, 0, sizeof(UA_NetworkMessage));
 }
 
 void UA_NetworkMessage_delete(UA_NetworkMessage* p) {
@@ -1025,7 +1031,7 @@ UA_DataSetMessageHeader_encodeBinary(const UA_DataSetMessageHeader* src, UA_Byte
 UA_StatusCode
 UA_DataSetMessageHeader_decodeBinary(const UA_ByteString *src, size_t *offset,
                                      UA_DataSetMessageHeader* dst) {
-    memset(dst, 0, sizeof(UA_DataSetMessageHeader));
+    UA_memset(dst, 0, sizeof(UA_DataSetMessageHeader));
     UA_Byte v = 0;
     UA_StatusCode rv = UA_Byte_decodeBinary(src, offset, &v);
     if(rv != UA_STATUSCODE_GOOD)
@@ -1216,7 +1222,7 @@ UA_DataSetMessage_encodeBinary(const UA_DataSetMessage* src, UA_Byte **bufPos,
 
 UA_StatusCode
 UA_DataSetMessage_decodeBinary(const UA_ByteString *src, size_t *offset, UA_DataSetMessage* dst) {
-    memset(dst, 0, sizeof(UA_DataSetMessage));
+    UA_memset(dst, 0, sizeof(UA_DataSetMessage));
     UA_StatusCode rv = UA_DataSetMessageHeader_decodeBinary(src, offset, &dst->header);
     if(rv != UA_STATUSCODE_GOOD)
         return rv;

src/ua_types.c

@@ -139,7 +139,15 @@ String_copy(UA_String const *src, UA_String *dst, const UA_DataType *_) {
 
 static void
 String_clear(UA_String *s, const UA_DataType *_) {
+ #ifndef UA_PATMOS_WCET
     UA_Array_delete(s->data, s->length, &UA_TYPES[UA_TYPES_BYTE]);
+#else
+    void *p = s->data;
+    size_t size = s->length;
+    
+    UA_free((void*)((uintptr_t)p & ~(uintptr_t)UA_EMPTY_ARRAY_SENTINEL));
+#endif // UA_PATMOS_WCET
+
 }
 
 /* QualifiedName */
@@ -1132,7 +1140,11 @@ UA_clearSignature clearJumpTable[UA_DATATYPEKINDS] = {
 
 void
 UA_clear(void *p, const UA_DataType *type) {
+#ifndef UA_PATMOS_WCET
     clearJumpTable[type->typeKind](p, type);
+#else
+    if(type->typeKind == UA_DATATYPEKIND_BYTESTRING) String_clear(p, UA_DATATYPEKIND_BYTESTRING);
+#endif
     memset(p, 0, type->memSize); /* init */
 }
 
@@ -1198,6 +1210,9 @@ void
 UA_Array_delete(void *p, size_t size, const UA_DataType *type) {
     if(!type->pointerFree) {
         uintptr_t ptr = (uintptr_t)p;
+#ifdef UA_PATMOS_WCET
+    _Pragma("loopbound min 1 max 10")
+#endif // UA_PATMOS_WCET
         for(size_t i = 0; i < size; ++i) {
             UA_clear((void*)ptr, type);
             ptr += type->memSize;

src/ua_types_encoding_binary.c

@@ -102,11 +102,37 @@ encodeWithExchangeBuffer(const void *ptr, const UA_DataType *type, Ctx *ctx) {
 #ifdef UA_PATMOS_WCET
     //printf("type->typeKind %i\n", type->typeKind);
     status ret = UA_STATUSCODE_GOOD;
-    if(type->typeKind == 2) ret = encodeBinaryJumpTable[2](ptr, type, ctx); // Byte_encodeBinary
-    if(type->typeKind == 4) ret = encodeBinaryJumpTable[4](ptr, type, ctx); // UInt16_encodeBinary
-    if(type->typeKind == 6) ret = encodeBinaryJumpTable[6](ptr, type, ctx); // UInt32_encodeBinary
-    if(type->typeKind == 12) ret = encodeBinaryJumpTable[12](ptr, type, ctx); // UInt64_encodeBinary
-    if(type->typeKind == 23) ret = encodeBinaryJumpTable[23](ptr, type, ctx); // Variant_encodeBinary
+    if(type->typeKind == UA_DATATYPEKIND_BOOLEAN) ret = encodeBinaryJumpTable[UA_DATATYPEKIND_BOOLEAN](ptr, type, ctx);
+    if(type->typeKind == UA_DATATYPEKIND_SBYTE) ret = encodeBinaryJumpTable[UA_DATATYPEKIND_SBYTE](ptr, type, ctx);
+    if(type->typeKind == UA_DATATYPEKIND_BYTE) ret = encodeBinaryJumpTable[UA_DATATYPEKIND_BYTE](ptr, type, ctx);
+    if(type->typeKind == UA_DATATYPEKIND_INT16) ret = encodeBinaryJumpTable[UA_DATATYPEKIND_INT16](ptr, type, ctx);
+    if(type->typeKind == UA_DATATYPEKIND_UINT16) ret = encodeBinaryJumpTable[UA_DATATYPEKIND_UINT16](ptr, type, ctx);
+    if(type->typeKind == UA_DATATYPEKIND_INT32) ret = encodeBinaryJumpTable[UA_DATATYPEKIND_INT32](ptr, type, ctx);
+    if(type->typeKind == UA_DATATYPEKIND_UINT32) ret = encodeBinaryJumpTable[UA_DATATYPEKIND_UINT32](ptr, type, ctx);
+    if(type->typeKind == UA_DATATYPEKIND_INT64) ret = encodeBinaryJumpTable[UA_DATATYPEKIND_INT64](ptr, type, ctx);
+    if(type->typeKind == UA_DATATYPEKIND_UINT64) ret = encodeBinaryJumpTable[UA_DATATYPEKIND_UINT64](ptr, type, ctx);
+    //if(type->typeKind == UA_DATATYPEKIND_FLOAT) ret = encodeBinaryJumpTable[UA_DATATYPEKIND_FLOAT](ptr, type, ctx);
+    //if(type->typeKind == UA_DATATYPEKIND_DOUBLE) ret = encodeBinaryJumpTable[UA_DATATYPEKIND_DOUBLE](ptr, type, ctx);
+    //if(type->typeKind == UA_DATATYPEKIND_STRING) ret = encodeBinaryJumpTable[UA_DATATYPEKIND_STRING](ptr, type, ctx);
+    if(type->typeKind == UA_DATATYPEKIND_DATETIME) ret = encodeBinaryJumpTable[UA_DATATYPEKIND_DATETIME](ptr, type, ctx);
+    if(type->typeKind == UA_DATATYPEKIND_GUID) ret = encodeBinaryJumpTable[UA_DATATYPEKIND_GUID](ptr, type, ctx);
+    //if(type->typeKind == UA_DATATYPEKIND_BYTESTRING) ret = encodeBinaryJumpTable[UA_DATATYPEKIND_BYTESTRING](ptr, type, ctx);
+    //if(type->typeKind == UA_DATATYPEKIND_XMLELEMENT) ret = encodeBinaryJumpTable[UA_DATATYPEKIND_XMLELEMENT](ptr, type, ctx);
+    //if(type->typeKind == UA_DATATYPEKIND_NODEID) ret = encodeBinaryJumpTable[UA_DATATYPEKIND_NODEID](ptr, type, ctx);
+    //if(type->typeKind == UA_DATATYPEKIND_EXPANDEDNODEID) ret = encodeBinaryJumpTable[UA_DATATYPEKIND_EXPANDEDNODEID](ptr, type, ctx);
+    if(type->typeKind == UA_DATATYPEKIND_STATUSCODE) ret = encodeBinaryJumpTable[UA_DATATYPEKIND_STATUSCODE](ptr, type, ctx);
+    //if(type->typeKind == UA_DATATYPEKIND_QUALIFIEDNAME) ret = encodeBinaryJumpTable[UA_DATATYPEKIND_QUALIFIEDNAME](ptr, type, ctx);
+    //if(type->typeKind == UA_DATATYPEKIND_LOCALIZEDTEXT) ret = encodeBinaryJumpTable[UA_DATATYPEKIND_LOCALIZEDTEXT](ptr, type, ctx);
+    //if(type->typeKind == UA_DATATYPEKIND_EXTENSIONOBJECT) ret = encodeBinaryJumpTable[UA_DATATYPEKIND_EXTENSIONOBJECT](ptr, type, ctx);
+    //if(type->typeKind == UA_DATATYPEKIND_DATAVALUE) ret = encodeBinaryJumpTable[UA_DATATYPEKIND_DATAVALUE](ptr, type, ctx);
+    //if(type->typeKind == UA_DATATYPEKIND_VARIANT) ret = encodeBinaryJumpTable[UA_DATATYPEKIND_VARIANT](ptr, type, ctx);
+    //if(type->typeKind == UA_DATATYPEKIND_DIAGNOSTICINFO) ret = encodeBinaryJumpTable[UA_DATATYPEKIND_DIAGNOSTICINFO](ptr, type, ctx);
+    //if(type->typeKind == UA_DATATYPEKIND_DECIMAL) ret = encodeBinaryJumpTable[UA_DATATYPEKIND_DECIMAL](ptr, type, ctx);
+    if(type->typeKind == UA_DATATYPEKIND_ENUM) ret = encodeBinaryJumpTable[UA_DATATYPEKIND_ENUM](ptr, type, ctx);
+    //if(type->typeKind == UA_DATATYPEKIND_STRUCTURE) ret = encodeBinaryJumpTable[UA_DATATYPEKIND_STRUCTURE](ptr, type, ctx);
+    if(type->typeKind == UA_DATATYPEKIND_OPTSTRUCT) ret = encodeBinaryJumpTable[UA_DATATYPEKIND_OPTSTRUCT](ptr, type, ctx);
+    //if(type->typeKind == UA_DATATYPEKIND_UNION) ret = encodeBinaryJumpTable[UA_DATATYPEKIND_UNION](ptr, type, ctx);
+    //if(type->typeKind == UA_DATATYPEKIND_BITFIELDCLUSTER) ret = encodeBinaryJumpTable[UA_DATATYPEKIND_BITFIELDCLUSTER](ptr, type, ctx);
 
 #else
     status ret = encodeBinaryJumpTable[type->typeKind](ptr, type, ctx);
@@ -320,7 +346,13 @@ pack754(long double f, unsigned bits, unsigned expbits) {
     if(f < 0) { sign = 1; fnorm = -f; }
     else { sign = 0; fnorm = f; }
     int shift = 0;
+#ifdef UA_PATMOS_WCET
+    _Pragma("loopbound min 1 max 2048") //ToDo check loop bound, if
+#endif // UA_PATMOS_WCET
     while(fnorm >= 2.0) { fnorm /= 2.0; ++shift; }
+#ifdef UA_PATMOS_WCET
+    _Pragma("loopbound min 1 max 2048")
+#endif // UA_PATMOS_WCET
     while(fnorm < 1.0) { fnorm *= 2.0; --shift; }
     fnorm = fnorm - 1.0;
     long long significand = (long long)(fnorm * ((float)(1LL<<significandbits) + 0.5f));
@@ -419,6 +451,9 @@ Array_encodeBinaryOverlayable(uintptr_t ptr, size_t length,
     size_t finished = 0;
 
     /* Loop as long as more elements remain than fit into the chunk */
+    #if 1==0
+        _Pragma("loopbound min 1 max 1") //send all in one message
+    #endif // UA_PATMOS_WCET
     while(ctx->end < ctx->pos + (elementMemSize * (length-finished))) {
         size_t possible = ((uintptr_t)ctx->end - (uintptr_t)ctx->pos) / (sizeof(u8) * elementMemSize);
         size_t possibleMem = possible * elementMemSize;
@@ -426,7 +461,11 @@ Array_encodeBinaryOverlayable(uintptr_t ptr, size_t length,
         ctx->pos += possibleMem;
         ptr += possibleMem;
         finished += possible;
+        #ifdef UA_PATMOS_WCET
+        status ret = UA_STATUSCODE_BADREQUESTTOOLARGE;
+        #else
         status ret = exchangeBuffer(ctx);
+        #endif // UA_PATMOS_WCET
         ctx->oldpos = NULL; /* Set the sentinel so that no upper stack frame
                              * with a saved pos attempts to exchange from an
                              * invalid position in the old buffer. */
@@ -444,8 +483,16 @@ static status
 Array_encodeBinaryComplex(uintptr_t ptr, size_t length,
                           const UA_DataType *type, Ctx *ctx) {
     /* Encode every element */
+    #if 1==0
+        _Pragma("loopbound min 1 max 100")
+    #endif // UA_PATMOS_WCET
     for(size_t i = 0; i < length; ++i) {
+        //#ifdef UA_PATMOS_WCET
+        //status ret = UA_STATUSCODE_BADREQUESTTOOLARGE;
+        //if(type->typeKind == UA_DATATYPEKIND_BYTE) ret = encodeBinaryJumpTable[UA_DATATYPEKIND_BYTE](ptr, type, ctx);
+        //#else
         status ret = encodeWithExchangeBuffer((const void*)ptr, type, ctx);
+        //#endif // UA_PATMOS_WCET
         ptr += type->memSize;
 
         if(ret != UA_STATUSCODE_GOOD)
@@ -468,7 +515,11 @@ Array_encodeBinary(const void *src, size_t length,
         signed_length = 0;
 
     /* Encode the array length */
+#if 1==0
+    status ret = encodeBinaryJumpTable[UA_TYPES_INT32]((const void*)&signed_length, type, ctx);
+#else
     status ret = ENCODE_WITHEXCHANGE(&signed_length, UA_TYPES_INT32);
+#endif // UA_PATMOS_WCET
 
     /* Quit early? */
     if(ret != UA_STATUSCODE_GOOD || length == 0)
@@ -1114,6 +1165,61 @@ Variant_decodeBinaryUnwrapExtensionObject(UA_Variant *dst, Ctx *ctx) {
 
 /* The resulting variant always has the storagetype UA_VARIANT_DATA. */
 DECODE_BINARY(Variant) {
+#ifdef UA_PATMOS_WCET
+    /* Decode the encoding byte */
+    u8 encodingByte;
+    status ret = DECODE_DIRECT(&encodingByte, Byte);
+    if(ret != UA_STATUSCODE_GOOD)
+        return ret;
+
+    /* Return early for an empty variant (was already _inited) */
+    if(encodingByte == 0)
+        return UA_STATUSCODE_GOOD;
+
+    /* Does the variant contain an array? */
+    const UA_Boolean isArray = (encodingByte & (u8)UA_VARIANT_ENCODINGMASKTYPE_ARRAY) > 0;
+
+    /* Get the datatype of the content. The type must be a builtin data type.
+     * All not-builtin types are wrapped in an ExtensionObject. The "type kind"
+     * for types up to DiagnsticInfo equals to the index in the encoding
+     * byte. */
+    size_t typeKind = (size_t)((encodingByte & (u8)UA_VARIANT_ENCODINGMASKTYPE_TYPEID_MASK) - 1);
+    if(typeKind > UA_DATATYPEKIND_DIAGNOSTICINFO)
+        return UA_STATUSCODE_BADDECODINGERROR;
+
+    /* A variant cannot contain a variant. But it can contain an array of
+     * variants */
+    if(typeKind == UA_DATATYPEKIND_VARIANT && !isArray)
+        return UA_STATUSCODE_BADDECODINGERROR;
+
+    /* Check the recursion limit */
+    /* No recursion
+    if(ctx->depth > UA_ENCODING_MAX_RECURSION)
+        return UA_STATUSCODE_BADENCODINGERROR;
+    ctx->depth++;*/
+
+    /* Decode the content */
+    dst->type = &UA_TYPES[typeKind];
+    if(isArray) {
+        //ret = Array_decodeBinary(&dst->data, &dst->arrayLength, dst->type, ctx);
+    } else if(typeKind != UA_DATATYPEKIND_EXTENSIONOBJECT) {
+        dst->data = UA_new(dst->type);
+        if(!dst->data)
+            return UA_STATUSCODE_BADOUTOFMEMORY;
+        ret = UA_STATUSCODE_GOOD;
+        if(typeKind == UA_DATATYPEKIND_UINT32) ret = decodeBinaryJumpTable[UA_DATATYPEKIND_UINT32](dst->data, dst->type, ctx);
+    } else {
+        //ret = Variant_decodeBinaryUnwrapExtensionObject(dst, ctx);
+    }
+
+    /* Decode array dimensions
+    if(isArray && (encodingByte & (u8)UA_VARIANT_ENCODINGMASKTYPE_DIMENSIONS) > 0)
+        ret |= Array_decodeBinary((void**)&dst->arrayDimensions, &dst->arrayDimensionsSize,
+                                  &UA_TYPES[UA_TYPES_INT32], ctx);
+     */
+    //ctx->depth--;
+    return ret;
+#else
     /* Decode the encoding byte */
     u8 encodingByte;
     status ret = DECODE_DIRECT(&encodingByte, Byte);
@@ -1165,6 +1271,7 @@ DECODE_BINARY(Variant) {
 
     ctx->depth--;
     return ret;
+#endif
 }
 
 /* DataValue */
@@ -1541,7 +1648,16 @@ UA_decodeBinary(const UA_ByteString *src, size_t *offset, void *dst,
 
     /* Decode */
     memset(dst, 0, type->memSize); /* Initialize the value */
+#ifdef UA_PATMOS_WCET
+    status ret = UA_STATUSCODE_GOOD;
+    if(type->typeKind == UA_DATATYPEKIND_BYTE) ret = decodeBinaryJumpTable[UA_DATATYPEKIND_BYTE](dst, type, &ctx);
+    if(type->typeKind == UA_DATATYPEKIND_UINT16) ret = decodeBinaryJumpTable[UA_DATATYPEKIND_UINT16](dst, type, &ctx);
+    if(type->typeKind == UA_DATATYPEKIND_UINT32) ret = decodeBinaryJumpTable[UA_DATATYPEKIND_UINT32](dst, type, &ctx);
+    if(type->typeKind == UA_DATATYPEKIND_DATETIME) ret = decodeBinaryJumpTable[UA_DATATYPEKIND_DATETIME](dst, type, &ctx);
+    if(type->typeKind == UA_DATATYPEKIND_VARIANT) ret = decodeBinaryJumpTable[UA_DATATYPEKIND_VARIANT](dst, type, &ctx);
+#else
     status ret = decodeBinaryJumpTable[type->typeKind](dst, type, &ctx);
+#endif
 
     if(ret == UA_STATUSCODE_GOOD) {
         /* Set the new offset */